0xweb
Version:
Contract package manager and other web3 tools
1,357 lines (1,300 loc) • 2.14 MB
JavaScript
// source ./RootModuleWrapped.js
(function(){
var _dequanto_src_ChainAccountService = {};
var _dequanto_src_abi__abiCoder = {};
var _dequanto_src_abi__rlp = {};
var _dequanto_src_abi_abi_coder = {};
var _dequanto_src_abi_abi_coder_packed = {};
var _dequanto_src_abi_coders_abstract_coder = {};
var _dequanto_src_abi_coders_address = {};
var _dequanto_src_abi_coders_anonymous = {};
var _dequanto_src_abi_coders_array = {};
var _dequanto_src_abi_coders_boolean = {};
var _dequanto_src_abi_coders_bytes = {};
var _dequanto_src_abi_coders_fixed_bytes = {};
var _dequanto_src_abi_coders_null = {};
var _dequanto_src_abi_coders_number = {};
var _dequanto_src_abi_coders_string = {};
var _dequanto_src_abi_coders_tuple = {};
var _dequanto_src_abi_fragments = {};
var _dequanto_src_blocks_BlockDateResolver = {};
var _dequanto_src_chains_PlatformFactory = {};
var _dequanto_src_chains_arbitrum_ArbTokenProvider = {};
var _dequanto_src_class_PackedRanges = {};
var _dequanto_src_class_PromiseEvent = {};
var _dequanto_src_class_SubjectKind = {};
var _dequanto_src_class_SubjectStream = {};
var _dequanto_src_class_Subscription = {};
var _dequanto_src_clients_BscWeb3Client = {};
var _dequanto_src_clients_ClientEventsStream = {};
var _dequanto_src_clients_ClientPool = {};
var _dequanto_src_clients_ClientPoolStats = {};
var _dequanto_src_clients_EthWeb3Client = {};
var _dequanto_src_clients_EvmWeb3Client = {};
var _dequanto_src_clients_WalletClient = {};
var _dequanto_src_clients_Web3BatchRequests = {};
var _dequanto_src_clients_Web3Client = {};
var _dequanto_src_clients_Web3ClientFactory = {};
var _dequanto_src_clients_debug_ClientDebugMethods = {};
var _dequanto_src_clients_handlers_RateLimitGuard = {};
var _dequanto_src_clients_model_ClientStatus = {};
var _dequanto_src_clients_model_PromiEventWrap = {};
var _dequanto_src_clients_utils_ClientEndpoints = {};
var _dequanto_src_clients_utils_ClientErrorUtil = {};
var _dequanto_src_clients_utils__web3Abi = {};
var _dequanto_src_config_Config = {};
var _dequanto_src_config_ConfigDefaults = {};
var _dequanto_src_config_ConfigProvider = {};
var _dequanto_src_contracts_ContractAbiProvider = {};
var _dequanto_src_contracts_ContractBase = {};
var _dequanto_src_contracts_ContractClassFactory = {};
var _dequanto_src_contracts_ContractCreationResolver = {};
var _dequanto_src_contracts_ContractReader = {};
var _dequanto_src_contracts_ContractStorageReaderBase = {};
var _dequanto_src_contracts_ContractStream = {};
var _dequanto_src_contracts_ContractWriter = {};
var _dequanto_src_contracts_deploy_ContractDeployer = {};
var _dequanto_src_contracts_deploy_ContractDeployment = {};
var _dequanto_src_contracts_deploy_Deployments = {};
var _dequanto_src_contracts_deploy_proxy_ProxyDeployment = {};
var _dequanto_src_contracts_deploy_proxy__proxyDeploy = {};
var _dequanto_src_contracts_deploy_storage_DeploymentsStorage = {};
var _dequanto_src_contracts_utils_AbiDeserializer = {};
var _dequanto_src_contracts_utils_ContractBaseUtils = {};
var _dequanto_src_contracts_utils_InputDataUtils = {};
var _dequanto_src_contracts_wrappers_FnRequestWrapper = {};
var _dequanto_src_contracts_wrappers_FnSignedWrapper = {};
var _dequanto_src_env_BigIntSerializer = {};
var _dequanto_src_erc4337_Erc4337Factory = {};
var _dequanto_src_erc4337_Erc4337Service = {};
var _dequanto_src_erc4337_Erc4337TxWriter = {};
var _dequanto_src_erc4337_models_Erc4337Abi = {};
var _dequanto_src_erc4337_models_UserOperation = {};
var _dequanto_src_erc4337_utils__erc4337 = {};
var _dequanto_src_evm_EvmBytecode = {};
var _dequanto_src_evm_OpcodesInfo = {};
var _dequanto_src_evm_OpcodesWalker = {};
var _dequanto_src_evm_Stack = {};
var _dequanto_src_evm_opcodes_add = {};
var _dequanto_src_evm_opcodes_addmod = {};
var _dequanto_src_evm_opcodes_address = {};
var _dequanto_src_evm_opcodes_and = {};
var _dequanto_src_evm_opcodes_balance = {};
var _dequanto_src_evm_opcodes_blockhash = {};
var _dequanto_src_evm_opcodes_byte = {};
var _dequanto_src_evm_opcodes_call = {};
var _dequanto_src_evm_opcodes_callcode = {};
var _dequanto_src_evm_opcodes_calldatacopy = {};
var _dequanto_src_evm_opcodes_calldataload = {};
var _dequanto_src_evm_opcodes_calldatasize = {};
var _dequanto_src_evm_opcodes_caller = {};
var _dequanto_src_evm_opcodes_callvalue = {};
var _dequanto_src_evm_opcodes_codecopy = {};
var _dequanto_src_evm_opcodes_codesize = {};
var _dequanto_src_evm_opcodes_coinbase = {};
var _dequanto_src_evm_opcodes_create = {};
var _dequanto_src_evm_opcodes_create2 = {};
var _dequanto_src_evm_opcodes_delegatecall = {};
var _dequanto_src_evm_opcodes_difficulty = {};
var _dequanto_src_evm_opcodes_div = {};
var _dequanto_src_evm_opcodes_dup = {};
var _dequanto_src_evm_opcodes_eq = {};
var _dequanto_src_evm_opcodes_exp = {};
var _dequanto_src_evm_opcodes_extcodecopy = {};
var _dequanto_src_evm_opcodes_extcodehash = {};
var _dequanto_src_evm_opcodes_extcodesize = {};
var _dequanto_src_evm_opcodes_gas = {};
var _dequanto_src_evm_opcodes_gaslimit = {};
var _dequanto_src_evm_opcodes_gasprice = {};
var _dequanto_src_evm_opcodes_gt = {};
var _dequanto_src_evm_opcodes_invalid = {};
var _dequanto_src_evm_opcodes_iszero = {};
var _dequanto_src_evm_opcodes_jump = {};
var _dequanto_src_evm_opcodes_jumpdest = {};
var _dequanto_src_evm_opcodes_jumpi = {};
var _dequanto_src_evm_opcodes_log = {};
var _dequanto_src_evm_opcodes_lt = {};
var _dequanto_src_evm_opcodes_mload = {};
var _dequanto_src_evm_opcodes_mod = {};
var _dequanto_src_evm_opcodes_msize = {};
var _dequanto_src_evm_opcodes_mstore = {};
var _dequanto_src_evm_opcodes_mul = {};
var _dequanto_src_evm_opcodes_mulmod = {};
var _dequanto_src_evm_opcodes_not = {};
var _dequanto_src_evm_opcodes_number = {};
var _dequanto_src_evm_opcodes_or = {};
var _dequanto_src_evm_opcodes_origin = {};
var _dequanto_src_evm_opcodes_pc = {};
var _dequanto_src_evm_opcodes_pop = {};
var _dequanto_src_evm_opcodes_push = {};
var _dequanto_src_evm_opcodes_return = {};
var _dequanto_src_evm_opcodes_returndatacopy = {};
var _dequanto_src_evm_opcodes_returndatasize = {};
var _dequanto_src_evm_opcodes_revert = {};
var _dequanto_src_evm_opcodes_sar = {};
var _dequanto_src_evm_opcodes_selfdestruct = {};
var _dequanto_src_evm_opcodes_sha3 = {};
var _dequanto_src_evm_opcodes_shl = {};
var _dequanto_src_evm_opcodes_shr = {};
var _dequanto_src_evm_opcodes_signextend = {};
var _dequanto_src_evm_opcodes_sload = {};
var _dequanto_src_evm_opcodes_sstore = {};
var _dequanto_src_evm_opcodes_staticcall = {};
var _dequanto_src_evm_opcodes_stop = {};
var _dequanto_src_evm_opcodes_sub = {};
var _dequanto_src_evm_opcodes_swap = {};
var _dequanto_src_evm_opcodes_timestamp = {};
var _dequanto_src_evm_opcodes_xor = {};
var _dequanto_src_evm_utils__bytecode = {};
var _dequanto_src_evm_utils_hex = {};
var _dequanto_src_evm_utils_opcodes = {};
var _dequanto_src_evm_utils_stringify = {};
var _dequanto_src_explorer_BlockchainExplorer = {};
var _dequanto_src_explorer_BlockchainExplorerFactory = {};
var _dequanto_src_explorer_ContractVerifier = {};
var _dequanto_src_explorer_Etherscan = {};
var _dequanto_src_explorer_verifiers_FsHtmlVerifier = {};
var _dequanto_src_gen_Generator = {};
var _dequanto_src_gen_GeneratorFromAbi = {};
var _dequanto_src_gen_GeneratorStorageReader = {};
var _dequanto_src_gen_utils_Str = {};
var _dequanto_src_gen_utils__gen = {};
var _dequanto_src_hardhat_HardhatProvider = {};
var _dequanto_src_hardhat_HardhatWeb3Client = {};
var _dequanto_src_indexer_BlocksTxIndexer = {};
var _dequanto_src_indexer_handlers_BlocksWalker = {};
var _dequanto_src_json_JsonArrayStore = {};
var _dequanto_src_json_JsonObjectStore = {};
var _dequanto_src_json_JsonStoreFs = {};
var _dequanto_src_loggers_LoggerService = {};
var _dequanto_src_ns_NameService = {};
var _dequanto_src_ns_providers_ANsProvider = {};
var _dequanto_src_ns_providers_EnsProvider = {};
var _dequanto_src_ns_providers_SpaceIdProvider = {};
var _dequanto_src_ns_providers_UDProvider = {};
var _dequanto_src_ns_utils__ns = {};
var _dequanto_src_prebuilt_openzeppelin_ERC20 = {};
var _dequanto_src_prebuilt_safe_GnosisSafe = {};
var _dequanto_src_prebuilt_safe_Safe = {};
var _dequanto_src_prebuilt_safe_SafeProxyFactory = {};
var _dequanto_src_prebuilt_weth_WETH_WETH = {};
var _dequanto_src_rpc_Rpc = {};
var _dequanto_src_rpc_RpcBase = {};
var _dequanto_src_rpc_RpcContract = {};
var _dequanto_src_rpc_RpcError = {};
var _dequanto_src_rpc_RpcFunction = {};
var _dequanto_src_rpc_RpcSubscription = {};
var _dequanto_src_rpc__rpc = {};
var _dequanto_src_rpc_transports_DeferredTransport = {};
var _dequanto_src_rpc_transports_HttpTransport = {};
var _dequanto_src_rpc_transports_ITransport = {};
var _dequanto_src_rpc_transports_MessageBasedTransport = {};
var _dequanto_src_rpc_transports_RpcTransport = {};
var _dequanto_src_rpc_transports_WsTransport = {};
var _dequanto_src_rpc_transports_WsTransportIsomorphic = {};
var _dequanto_src_rpc_transports_compatibility_EIP1193Transport = {};
var _dequanto_src_rpc_transports_compatibility_Web3Transport = {};
var _dequanto_src_safe_GnosisSafeFactory = {};
var _dequanto_src_safe_GnosisSafeHandler = {};
var _dequanto_src_safe_transport_FileServiceTransport = {};
var _dequanto_src_safe_transport_SafeServiceTransport = {};
var _dequanto_src_solidity_SlotsDump = {};
var _dequanto_src_solidity_SlotsParser = {};
var _dequanto_src_solidity_SlotsParser_Ast = {};
var _dequanto_src_solidity_SlotsParser_MappingSettersResolver = {};
var _dequanto_src_solidity_SlotsParser_SourceFile = {};
var _dequanto_src_solidity_SlotsStorage = {};
var _dequanto_src_solidity_SolidityParser = {};
var _dequanto_src_solidity_SourceCodeProvider = {};
var _dequanto_src_solidity_storage_Accessor = {};
var _dequanto_src_solidity_storage_MappingKeysLoader = {};
var _dequanto_src_solidity_storage_SlotDynamicArray = {};
var _dequanto_src_solidity_storage_SlotFixedArray = {};
var _dequanto_src_solidity_storage_SlotsStorageHandler = {};
var _dequanto_src_solidity_storage_SlotsStorageTransport = {};
var _dequanto_src_solidity_storage_handlers_SlotBytesHandler = {};
var _dequanto_src_solidity_storage_handlers_SlotDynamicArrayHandler = {};
var _dequanto_src_solidity_storage_handlers_SlotFixedArrayHandler = {};
var _dequanto_src_solidity_storage_handlers_SlotMappingHandler = {};
var _dequanto_src_solidity_storage_handlers_SlotStringHandler = {};
var _dequanto_src_solidity_storage_handlers_SlotStructHandler = {};
var _dequanto_src_solidity_storage_handlers_SlotValueConstantHandler = {};
var _dequanto_src_solidity_storage_handlers_SlotValueHandler = {};
var _dequanto_src_solidity_storage_handlers_SlotValueImmutableHandler = {};
var _dequanto_src_solidity_utils__str = {};
var _dequanto_src_solidity_utils__types = {};
var _dequanto_src_tokens_TokenDataProvider = {};
var _dequanto_src_tokens_TokenOracles_SpotPriceAggregator_SpotPriceAggregator = {};
var _dequanto_src_tokens_TokenOracles_chainlink_ChainlinkFeedProvider = {};
var _dequanto_src_tokens_TokenOracles_chainlink_ChainlinkOracle = {};
var _dequanto_src_tokens_TokenPriceService = {};
var _dequanto_src_tokens_TokenProviders_ATokenProvider = {};
var _dequanto_src_tokens_TokenProviders_TPChain = {};
var _dequanto_src_tokens_TokenProviders_TPCoingecko = {};
var _dequanto_src_tokens_TokenProviders_TPCoinmarketcap = {};
var _dequanto_src_tokens_TokenProviders_TPConfig = {};
var _dequanto_src_tokens_TokenProviders_TPExplorer = {};
var _dequanto_src_tokens_TokenProviders_TPOneInch = {};
var _dequanto_src_tokens_TokenProviders_TPSushiswap = {};
var _dequanto_src_tokens_TokenProviders_TPUniswap = {};
var _dequanto_src_tokens_TokenService = {};
var _dequanto_src_tokens_TokenTransferService = {};
var _dequanto_src_tokens_TokensService = {};
var _dequanto_src_tokens_TokensServiceFactory = {};
var _dequanto_src_tokens_utils_TokenUtils = {};
var _dequanto_src_txs_TxDataBuilder = {};
var _dequanto_src_txs_TxLogger = {};
var _dequanto_src_txs_TxNonceManager = {};
var _dequanto_src_txs_TxWriter = {};
var _dequanto_src_txs_agents_Erc4337Agent = {};
var _dequanto_src_txs_agents_SafeAgent = {};
var _dequanto_src_txs_agents_TxWriterAccountAgents = {};
var _dequanto_src_txs_receipt_TxLogParser = {};
var _dequanto_src_txs_receipt_TxLogsTransfer = {};
var _dequanto_src_txs_receipt_TxTopicInMemoryProvider = {};
var _dequanto_src_txs_receipt_TxTopicProvider = {};
var _dequanto_src_txs_sig_transports_SigFileTransport = {};
var _dequanto_src_utils__abiParser = {};
var _dequanto_src_utils__abiType = {};
var _dequanto_src_utils__abiUtils = {};
var _dequanto_src_utils__account = {};
var _dequanto_src_utils__address = {};
var _dequanto_src_utils__array = {};
var _dequanto_src_utils__base = {};
var _dequanto_src_utils__bigfloat = {};
var _dequanto_src_utils__bigint = {};
var _dequanto_src_utils__block = {};
var _dequanto_src_utils__buffer = {};
var _dequanto_src_utils__cache = {};
var _dequanto_src_utils__class = {};
var _dequanto_src_utils__cli = {};
var _dequanto_src_utils__color = {};
var _dequanto_src_utils__config = {};
var _dequanto_src_utils__const = {};
var _dequanto_src_utils__contract = {};
var _dequanto_src_utils__crypto = {};
var _dequanto_src_utils__date = {};
var _dequanto_src_utils__dependency = {};
var _dequanto_src_utils__error = {};
var _dequanto_src_utils__gas = {};
var _dequanto_src_utils__hex = {};
var _dequanto_src_utils__http = {};
var _dequanto_src_utils__is = {};
var _dequanto_src_utils__logger = {};
var _dequanto_src_utils__machine = {};
var _dequanto_src_utils__number = {};
var _dequanto_src_utils__path = {};
var _dequanto_src_utils__perf = {};
var _dequanto_src_utils__platform = {};
var _dequanto_src_utils__promise = {};
var _dequanto_src_utils__ref = {};
var _dequanto_src_utils__require = {};
var _dequanto_src_utils__secret = {};
var _dequanto_src_utils__semver = {};
var _dequanto_src_utils__sig = {};
var _dequanto_src_utils__signSerializer = {};
var _dequanto_src_utils__txData = {};
var _dequanto_src_wallets_EIP6963ProviderFactory = {};
var _node_modules__noble_curves__shortw_utils = {};
var _node_modules__noble_curves_abstract_curve = {};
var _node_modules__noble_curves_abstract_hash_to_curve = {};
var _node_modules__noble_curves_abstract_modular = {};
var _node_modules__noble_curves_abstract_utils = {};
var _node_modules__noble_curves_abstract_weierstrass = {};
var _node_modules__noble_curves_secp256k1 = {};
var _node_modules__noble_hashes__assert = {};
var _node_modules__noble_hashes__sha2 = {};
var _node_modules__noble_hashes__u64 = {};
var _node_modules__noble_hashes_crypto = {};
var _node_modules__noble_hashes_hmac = {};
var _node_modules__noble_hashes_pbkdf2 = {};
var _node_modules__noble_hashes_ripemd160 = {};
var _node_modules__noble_hashes_sha256 = {};
var _node_modules__noble_hashes_sha3 = {};
var _node_modules__noble_hashes_sha512 = {};
var _node_modules__noble_hashes_utils = {};
var _node_modules__scure_base_lib_index = {};
var _node_modules__scure_bip32_lib_index = {};
var _node_modules__scure_bip39_index = {};
var _src_app_App = {};
var _src_commands_CommandsHandler = {};
var _src_commands_list_CAccount = {};
var _src_commands_list_CAccounts = {};
var _src_commands_list_CBlock = {};
var _src_commands_list_CConfig = {};
var _src_commands_list_CContract = {};
var _src_commands_list_CGas = {};
var _src_commands_list_CHardhat = {};
var _src_commands_list_CHelp = {};
var _src_commands_list_CInfo = {};
var _src_commands_list_CInit = {};
var _src_commands_list_CInstall = {};
var _src_commands_list_CNs = {};
var _src_commands_list_CReset = {};
var _src_commands_list_CRestore = {};
var _src_commands_list_CRpc = {};
var _src_commands_list_CSafe = {};
var _src_commands_list_CServer = {};
var _src_commands_list_CSolidity = {};
var _src_commands_list_CToken = {};
var _src_commands_list_CTokens = {};
var _src_commands_list_CTools = {};
var _src_commands_list_CTransfer = {};
var _src_commands_list_CTx = {};
var _src_commands_list_CVersion = {};
var _src_commands_utils__command = {};
var _src_factories_ContractFactory = {};
var _src_services_AccountsService = {};
var _src_services_BaseService = {};
var _src_services_BlockService = {};
var _src_services_ContractDumpService = {};
var _src_services_ContractService = {};
var _src_services_HardhatService = {};
var _src_services_InternalTokenService = {};
var _src_services_PackageService = {};
var _src_services_RpcService = {};
var _src_services_ServerService = {};
var _src_services_TxService = {};
var _src_utils_Parameters = {};
var _src_utils__abiInput = {};
var _src_utils__abiValues = {};
var _src_utils__cli = {};
var _src_utils__console = {};
var _src_utils__os = {};
var _src_utils__path = {};
var _src_utils__validate = {};
// source ./ModuleSimplified.js
var _dequanto_src_utils__cli;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _dequanto_src_utils__cli != null ? _dequanto_src_utils__cli : {};
var module = { exports: exports };
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.$cli = void 0;
var $cli;
(function ($cli) {
function getParamValue(flag, parameters) {
let k1 = cases.camelToHyphenCase(flag);
let k2 = cases.hyphenToCamelCase(flag);
if (parameters != null) {
if (k1 in parameters) {
return parameters[k1];
}
if (k2 in parameters) {
return parameters[k2];
}
}
if (typeof process !== 'undefined' && process.argv != null) {
let args = process.argv;
for (let i = 0; i < args.length - 1; i++) {
let key = args[i].replace(/^\-+/, '');
if (key === k1 || key === k2) {
return args[i + 1];
}
}
}
return null;
}
$cli.getParamValue = getParamValue;
let cases;
(function (cases) {
function hyphenToCamelCase(str) {
if (str.includes('-') === false) {
return str;
}
return str.replace(/\-([a-z])/g, (g) => g[1].toUpperCase());
}
cases.hyphenToCamelCase = hyphenToCamelCase;
function camelToHyphenCase(str) {
if (/[A-Z]/.test(str) === false) {
return str;
}
return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
}
cases.camelToHyphenCase = camelToHyphenCase;
})(cases || (cases = {}));
})($cli = exports.$cli || (exports.$cli = {}));
;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_dequanto_src_utils__cli === module.exports) {
// do nothing if
} else if (__isObj(_dequanto_src_utils__cli) && __isObj(module.exports)) {
Object.assign(_dequanto_src_utils__cli, module.exports);
} else {
_dequanto_src_utils__cli = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _dequanto_src_utils__is;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _dequanto_src_utils__is != null ? _dequanto_src_utils__is : {};
var module = { exports: exports };
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.$is = void 0;
const $Array = Array;
var $is;
(function ($is) {
function Number(val) {
return typeof val === 'number' && isNaN(val) === false;
}
$is.Number = Number;
function notNull(val) {
return val != null;
}
$is.notNull = notNull;
function notEmpty(val) {
return val != null && val.length > 0;
}
$is.notEmpty = notEmpty;
function empty(val) {
if (val == null) {
return true;
}
if (typeof val === 'number' && val === 0) {
return true;
}
if (typeof val === 'string' || $Array.isArray(val)) {
return val.length === 0;
}
return false;
}
$is.empty = empty;
function BigInt(val) {
return typeof val === 'bigint';
}
$is.BigInt = BigInt;
function Address(val, message) {
if (typeof val !== 'string') {
return false;
}
// Make addresses like `0x0` also valid (assumed zeros)
return /^0x[a-fA-F0-9]{1,40}$/g.test(val);
}
$is.Address = Address;
function Promise(val) {
return typeof val === 'object' && val !== null && 'then' in val;
}
$is.Promise = Promise;
function TxHash(val) {
if (Hex(val) === false) {
return false;
}
// 0x115f9d0e3c5d7538eb27466cf42ac68527703a14e93c0d1243131164af2d1c6c
if (val.length !== 2 + 64) {
return false;
}
return true;
}
$is.TxHash = TxHash;
function Hex(str) {
if (typeof str !== 'string') {
return false;
}
return /^0x[\da-f]+$/i.test(str);
}
$is.Hex = Hex;
function HexBytes32(str) {
return Hex(str) && /0x.{64}/.test(str);
}
$is.HexBytes32 = HexBytes32;
function Array(val) {
return $Array.isArray(val);
}
$is.Array = Array;
function ArrayOfStrings(val) {
return $Array.isArray(val) && val.length > 0 && val.every(x => typeof x === 'string');
}
$is.ArrayOfStrings = ArrayOfStrings;
$is.BROWSER = typeof location !== 'undefined' && typeof location.reload === 'function';
$is.NODE = !$is.BROWSER;
})($is = exports.$is || (exports.$is = {}));
;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_dequanto_src_utils__is === module.exports) {
// do nothing if
} else if (__isObj(_dequanto_src_utils__is) && __isObj(module.exports)) {
Object.assign(_dequanto_src_utils__is, module.exports);
} else {
_dequanto_src_utils__is = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _dequanto_src_utils__dependency;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _dequanto_src_utils__dependency != null ? _dequanto_src_utils__dependency : {};
var module = { exports: exports };
"use strict";
/** ESM and CJS Loader */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.$dependency = void 0;
const _is_1 = _dequanto_src_utils__is;
var $dependency;
(function ($dependency) {
async function load(name) {
var _a;
//#if (CJS)
const r = require;
return Promise.resolve(require(name));
//#endif
//#if (ESM)
// @ts-ignore: Conditional import
const exp = await (_a = name, Promise.resolve().then(() => __importStar(require(_a))));
return exp;
//#endif
}
$dependency.load = load;
function dirname() {
if (_is_1.$is.BROWSER) {
return location.origin;
}
if (typeof __dirname !== 'undefined') {
return __dirname;
}
//#if (CJS)
throw new Error('__dirname is not defined in CommonJS environment');
//#endif
/**#if (ESM)
return import.meta.dirname;
*/
}
$dependency.dirname = dirname;
})($dependency = exports.$dependency || (exports.$dependency = {}));
;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_dequanto_src_utils__dependency === module.exports) {
// do nothing if
} else if (__isObj(_dequanto_src_utils__dependency) && __isObj(module.exports)) {
Object.assign(_dequanto_src_utils__dependency, module.exports);
} else {
_dequanto_src_utils__dependency = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _dequanto_src_utils__machine;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _dequanto_src_utils__machine != null ? _dequanto_src_utils__machine : {};
var module = { exports: exports };
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.$machine = void 0;
const _dependency_1 = _dequanto_src_utils__dependency;
var $machine;
(function ($machine) {
function id(original = false) {
return new Promise(async (resolve, reject) => {
const { exec } = await _dependency_1.$dependency.load('child_process');
return exec(getCommand(), {}, async (err, stdout, stderr) => {
if (err) {
return reject(new Error(`Error while obtaining machine id: ${err.stack}`));
}
let id = extractId(stdout.toString());
let result = original ? id : await hash(id);
return resolve(result);
});
});
}
$machine.id = id;
async function hash(guid) {
const { createHash } = await _dependency_1.$dependency.load('crypto');
return createHash('sha256').update(guid).digest('hex');
}
function getCommand() {
let { platform } = process;
let win32RegBinPath = {
native: '%windir%\\System32',
mixed: '%windir%\\sysnative\\cmd.exe /c %windir%\\System32'
};
let guid = {
darwin: 'ioreg -rd1 -c IOPlatformExpertDevice',
win32: `${win32RegBinPath[isWindowsProcessMixedOrNativeArchitecture()]}\\REG.exe ` +
'QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography ' +
'/v MachineGuid',
linux: '( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname ) | head -n 1 || :',
freebsd: 'kenv -q smbios.system.uuid || sysctl -n kern.hostuuid'
};
function isWindowsProcessMixedOrNativeArchitecture() {
// detect if the node binary is the same arch as the Windows OS.
// or if this is 32 bit node on 64 bit windows.
if (process.platform !== 'win32') {
return '';
}
if (process.arch === 'ia32' && process.env.hasOwnProperty('PROCESSOR_ARCHITEW6432')) {
return 'mixed';
}
return 'native';
}
return guid[platform];
}
function extractId(result) {
switch (process.platform) {
case 'darwin':
return result
.split('IOPlatformUUID')[1]
.split('\n')[0].replace(/\=|\s+|\"/ig, '')
.toLowerCase();
case 'win32':
return result
.toString()
.split('REG_SZ')[1]
.replace(/\r+|\n+|\s+/ig, '')
.toLowerCase();
case 'linux':
return result
.toString()
.replace(/\r+|\n+|\s+/ig, '')
.toLowerCase();
case 'freebsd':
return result
.toString()
.replace(/\r+|\n+|\s+/ig, '')
.toLowerCase();
default:
throw new Error(`Unsupported platform: ${process.platform}`);
}
}
})($machine = exports.$machine || (exports.$machine = {}));
;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_dequanto_src_utils__machine === module.exports) {
// do nothing if
} else if (__isObj(_dequanto_src_utils__machine) && __isObj(module.exports)) {
Object.assign(_dequanto_src_utils__machine, module.exports);
} else {
_dequanto_src_utils__machine = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _dequanto_src_utils__secret;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _dequanto_src_utils__secret != null ? _dequanto_src_utils__secret : {};
var module = { exports: exports };
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.$secret = void 0;
const _machine_1 = _dequanto_src_utils__machine;
var $secret;
(function ($secret) {
async function getPin(parameters) {
let pin = parameters?.pin ?? getPinFromCli() ?? getPinFromEnv();
if (pin == null || pin.length === 0) {
return null;
}
let machineKey = parameters?.machineKey ?? getMachineKeyFromCli() ?? getMachineKeyFromEnv() ?? await _machine_1.$machine.id();
return `${machineKey}:${pin}`;
}
$secret.getPin = getPin;
function getPinFromCli() {
let args = process.argv;
for (let i = 0; i < args.length - 1; i++) {
let key = args[i].replace(/^\-+/, '');
if (key === 'p' || key === 'pin') {
return args[i + 1];
}
}
return null;
}
function getPinFromEnv() {
return process.env.PIN;
}
function getMachineKeyFromCli() {
let args = process.argv;
for (let i = 0; i < args.length - 1; i++) {
let key = args[i].replace(/^\-+/, '');
if (key === 'machineKey' || key === 'machine-key') {
return args[i + 1];
}
}
return null;
}
function getMachineKeyFromEnv() {
return process.env.MACHINE_KEY;
}
})($secret = exports.$secret || (exports.$secret = {}));
;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_dequanto_src_utils__secret === module.exports) {
// do nothing if
} else if (__isObj(_dequanto_src_utils__secret) && __isObj(module.exports)) {
Object.assign(_dequanto_src_utils__secret, module.exports);
} else {
_dequanto_src_utils__secret = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _dequanto_src_utils__buffer;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _dequanto_src_utils__buffer != null ? _dequanto_src_utils__buffer : {};
var module = { exports: exports };
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.$buffer = void 0;
const atma_utils_1 = require("atma-utils");
class BufferBase {
ensure(mix) {
if (mix == null) {
return new Uint8Array(0);
}
if (typeof mix === 'string') {
let str = mix.startsWith('0x') ? mix.substring(2) : mix;
if (str.length % 2 !== 0) {
str = '0' + str;
}
return this.fromHex(str);
}
if (mix instanceof Uint8Array) {
return mix;
}
if (typeof mix === 'boolean') {
return new Uint8Array(mix ? [1] : [0]);
}
if (typeof mix === 'number') {
if (Math.floor(mix) !== mix) {
throw new Error('Floats are not supported for buffer array');
}
mix = BigInt(mix);
}
if (typeof mix === 'bigint') {
return exports.$buffer.fromBigInt(mix);
}
console.error(mix);
throw new Error(`Unexpected buffer type: ${mix} (${typeof mix})`);
}
toBigInt(buffer) {
let result = 0n;
let length = buffer.length;
for (let i = 0; i < length; i++) {
result = (result << 8n) | BigInt(buffer[i]);
}
return result;
}
fromBigInt(value) {
if (typeof value === 'number' || typeof value === 'string') {
value = BigInt(value);
}
if (value < 0n) {
throw new Error(`Cannot convert negative ${value} to Uint8Array`);
}
if (value === 0n) {
return new Uint8Array([0]);
}
// Determine the number of bytes needed to represent the BigInt
let byteCount = 0;
let tempValue = value;
while (tempValue > 0n) {
byteCount++;
tempValue >>= 8n; // Right-shift by 8 bits to check the next byte
}
const uint8Array = new Uint8Array(byteCount);
// Fill the Uint8Array with the bytes from the BigInt
for (let i = byteCount - 1; i >= 0; i--) {
uint8Array[i] = Number(value & 0xffn); // Extract the least significant byte
value >>= 8n; // Right-shift by 8 bits to get the next byte
}
return uint8Array;
}
}
class NodeBufferUtils extends BufferBase {
fromString(str, encoding) {
return Buffer.from(str, encoding ?? 'utf8');
}
toString(buffer, encoding = 'utf8') {
return Buffer.from(buffer).toString(encoding);
}
fromHex(hex) {
return Buffer.from(utils.normalizeHex(hex), 'hex');
}
toHex(buffer) {
if (buffer instanceof Buffer) {
return (`0x` + buffer.toString('hex'));
}
return (`0x` + buffer.reduce((hex, x) => {
return hex + x.toString(16).padStart(2, '0');
}, ''));
}
concat(buffers) {
return Buffer.concat(buffers);
}
}
const HEX_CHARS = "0123456789abcdef";
const HEX_DIGITS = {
0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15
};
class WebBufferUtils extends BufferBase {
fromString(string, encoding) {
if (encoding != null && /utf\-?8/.test(encoding) === false) {
throw new Error(`Only UTF8 Encoding supported`);
}
return new TextEncoder().encode(string);
}
toString(buffer, encoding) {
if (encoding != null && /utf\-?8/.test(encoding) === false) {
throw new Error(`Only UTF8 Encoding supported`);
}
return new TextDecoder().decode(buffer);
}
fromHex(hex) {
hex = utils.normalizeHex(hex);
let bytes = new Uint8Array(Math.floor(hex.length / 2));
let i = 0;
for (; i < bytes.length; i++) {
const a = HEX_DIGITS[hex[i * 2]];
const b = HEX_DIGITS[hex[i * 2 + 1]];
if (a == null || b == null) {
break;
}
bytes[i] = (a << 4) | b;
}
return i === bytes.length
? bytes
: bytes.slice(0, i);
}
toHex(buffer) {
let hex = '';
for (let i = 0; i < buffer.length; i++) {
let b = buffer[i];
hex += HEX_CHARS[b >> 4] + HEX_CHARS[b & 15];
}
return ('0x' + hex);
}
concat(buffers) {
let size = buffers.reduce((a, x) => a + x.length, 0);
let buffer = new Uint8Array(size);
let offset = 0;
for (let i = 0; i < buffers.length; i++) {
let buf = buffers[i];
buffer.set(buf, offset);
offset += buf.length;
}
return buffer;
}
}
var utils;
(function (utils) {
function normalizeHex(hex) {
if (hex.startsWith('0x')) {
hex = hex.substring(2);
}
if (hex.length % 2 !== 0) {
throw new Error(`Not valid hex buffer. Char count not even: ${hex}`);
}
if (hex.length > 0 && /^[\da-f]+$/i.test(hex) === false) {
throw new Error(`Not valid hex buffer. Invalid char in ${hex}`);
}
return hex;
}
utils.normalizeHex = normalizeHex;
})(utils || (utils = {}));
exports.$buffer = atma_utils_1.is_NODE
? new NodeBufferUtils()
: new WebBufferUtils();
;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_dequanto_src_utils__buffer === module.exports) {
// do nothing if
} else if (__isObj(_dequanto_src_utils__buffer) && __isObj(module.exports)) {
Object.assign(_dequanto_src_utils__buffer, module.exports);
} else {
_dequanto_src_utils__buffer = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _dequanto_src_utils__hex;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _dequanto_src_utils__hex != null ? _dequanto_src_utils__hex : {};
var module = { exports: exports };
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.$hex = void 0;
const _buffer_1 = _dequanto_src_utils__buffer;
const _require_1 = _dequanto_src_utils__require;
var $hex;
(function ($hex) {
$hex.ZERO = '0x';
/**
* Adds '00' bytes to the hex string.
* @param hex
* @param byteSize Min bytes count in the hex string
*/
function padBytes(hex, byteSize, opts) {
let length = byteSize * 2;
hex = ensure(hex);
if (hex.length === length + 2) {
return hex;
}
hex = hex.substring(2)[opts?.padEnd ? 'padEnd' : 'padStart'](length, '0');
return `0x${hex}`;
}
$hex.padBytes = padBytes;
/**
* Trims '00' bytes from start or end, e.g. 0x68656c6c6f000000 => 0x68656c6c6f
*/
function trimBytes(hex) {
if (hex.startsWith('0x00') === false && hex.endsWith('00') === false) {
return hex;
}
return hex.replace(/^0x(0{2})+/, '').replace(/(0{2})+$/, '');
}
$hex.trimBytes = trimBytes;
function trimLeadingZerosFromNumber(hex) {
hex = hex.replace(/^0x0*/, '');
return hex === '' ? '0x0' : `0x${hex}`;
}
$hex.trimLeadingZerosFromNumber = trimLeadingZerosFromNumber;
function getBytes(hex, offset, length) {
let start = hex.startsWith('0x') ? 2 : 0;
let offsetChars = offset * 2;
let lengthChars = length * 2;
return (`0x` + hex.substring(start + offsetChars, start + offsetChars + lengthChars));
}
$hex.getBytes = getBytes;
function getBytesLength(hex) {
let pfx = hex.startsWith('0x') ? 2 : 0;
let chars = hex.length - pfx;
_require_1.$require.True(chars % 2 === 0, `Expect buffer to have even length, got ${chars}`);
return chars / 2;
}
$hex.getBytesLength = getBytesLength;
function getNumber(hex, byteIndex, bytesCount = 1) {
let start = hex.startsWith('0x') ? 2 : 0;
let i = start + byteIndex * 2;
return parseInt(hex.substring(i, i + 2 * bytesCount), 16);
}
$hex.getNumber = getNumber;
function raw(hex) {
return hex.startsWith('0x')
? hex.substring(2)
: hex;
}
$hex.raw = raw;
function concat(arr) {
return ('0x' + arr.map(ensure).map(raw).join(''));
}
$hex.concat = concat;
function split(hex, bytes = 32) {
let str = raw(hex);
let args = [];
while (str.length > 0) {
args.push('0x' + str.substring(0, bytes * 2));
str = str.substring(bytes * 2);
}
return args;
}
$hex.split = split;
function toHex(value) {
switch (typeof value) {
case 'string': {
if (value.startsWith('0x')) {
return value;
}
return _buffer_1.$buffer.toHex(_buffer_1.$buffer.fromString(value));
}
case 'number':
case 'bigint':
let hex = value.toString(16);
return ('0x' + hex);
case 'boolean':
return value ? '0x1' : '0x0';
}
throw new Error(`Invalid value to convert to hex: ${value}`);
}
$hex.toHex = toHex;
function toHexBuffer(value) {
value = toHex(value);
if (value.length % 2 === 1) {
value = '0x0' + value.substring(2);
}
return value;
}
$hex.toHexBuffer = toHexBuffer;
function convert(hex, abiType) {
if (abiType === 'bool') {
return Boolean(Number(hex));
}
let bigintMatch = /int(?<size>\d+)?$/.exec(abiType);
if (bigintMatch) {
let size = Number(bigintMatch.groups.size ?? 256);
if (size < 16) {
return Number(hex);
}
return BigInt(hex);
}
return hex;
}
$hex.convert = convert;
/**
* Adds `0x` to the start if not present
*/
function ensure(mix) {
if (mix == null) {
return '0x';
}
if (mix instanceof Uint8Array) {
mix = _buffer_1.$buffer.toHex(mix);
}
if (typeof mix === 'number' || typeof mix === 'bigint') {
return `0x${mix.toString(16)}`;
}
if (typeof mix === 'boolean') {
return mix ? '0x1' : '0x0';
}
if (mix.startsWith('0x')) {
return mix;
}
return `0x${mix}`;
}
$hex.ensure = ensure;
function isEmpty(hex) {
return hex == null || hex.length === 0 || hex === '0x';
}
$hex.isEmpty = isEmpty;
})($hex = exports.$hex || (exports.$hex = {}));
;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_dequanto_src_utils__hex === module.exports) {
// do nothing if
} else if (__isObj(_dequanto_src_utils__hex) && __isObj(module.exports)) {
Object.assign(_dequanto_src_utils__hex, module.exports);
} else {
_dequanto_src_utils__hex = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _node_modules__noble_hashes__assert;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _node_modules__noble_hashes__assert != null ? _node_modules__noble_hashes__assert : {};
var module = { exports: exports };
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0;
function number(n) {
if (!Number.isSafeInteger(n) || n < 0)
throw new Error(`Wrong positive integer: ${n}`);
}
exports.number = number;
function bool(b) {
if (typeof b !== 'boolean')
throw new Error(`Expected boolean, not ${b}`);
}
exports.bool = bool;
function bytes(b, ...lengths) {
if (!(b instanceof Uint8Array))
throw new Error('Expected Uint8Array');
if (lengths.length > 0 && !lengths.includes(b.length))
throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
}
exports.bytes = bytes;
function hash(hash) {
if (typeof hash !== 'function' || typeof hash.create !== 'function')
throw new Error('Hash should be wrapped by utils.wrapConstructor');
number(hash.outputLen);
number(hash.blockLen);
}
exports.hash = hash;
function exists(instance, checkFinished = true) {
if (instance.destroyed)
throw new Error('Hash instance has been destroyed');
if (checkFinished && instance.finished)
throw new Error('Hash#digest() has already been called');
}
exports.exists = exists;
function output(out, instance) {
bytes(out);
const min = instance.outputLen;
if (out.length < min) {
throw new Error(`digestInto() expects output buffer of length at least ${min}`);
}
}
exports.output = output;
const assert = { number, bool, bytes, hash, exists, output };
exports.default = assert;
//# sourceMappingURL=_assert.js.map;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_node_modules__noble_hashes__assert === module.exports) {
// do nothing if
} else if (__isObj(_node_modules__noble_hashes__assert) && __isObj(module.exports)) {
Object.assign(_node_modules__noble_hashes__assert, module.exports);
} else {
_node_modules__noble_hashes__assert = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _node_modules__noble_hashes__u64;
(function () {
// ensure AMD is not active for the model, so that any UMD exports as commonjs
var define = null;
var exports = _node_modules__noble_hashes__u64 != null ? _node_modules__noble_hashes__u64 : {};
var module = { exports: exports };
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.add5L = exports.add5H = exports.add4H = exports.add4L = exports.add3H = exports.add3L = exports.add = exports.rotlBL = exports.rotlBH = exports.rotlSL = exports.rotlSH = exports.rotr32L = exports.rotr32H = exports.rotrBL = exports.rotrBH = exports.rotrSL = exports.rotrSH = exports.shrSL = exports.shrSH = exports.toBig = exports.split = exports.fromBig = void 0;
const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
const _32n = /* @__PURE__ */ BigInt(32);
// We are not using BigUint64Array, because they are extremely slow as per 2022
function fromBig(n, le = false) {
if (le)
return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
}
exports.fromBig = fromBig;
function split(lst, le = false) {
let Ah = new Uint32Array(lst.length);
let Al = new Uint32Array(lst.length);
for (let i = 0; i < lst.length; i++) {
const { h, l } = fromBig(lst[i], le);
[Ah[i], Al[i]] = [h, l];
}
return [Ah, Al];
}
exports.split = split;
const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
exports.toBig = toBig;
// for Shift in [0, 32)
const shrSH = (h, _l, s) => h >>> s;
exports.shrSH = shrSH;
const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
exports.shrSL = shrSL;
// Right rotate for Shift in [1, 32)
const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
exports.rotrSH = rotrSH;
const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
exports.rotrSL = rotrSL;
// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
exports.rotrBH = rotrBH;
const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
exports.rotrBL = rotrBL;
// Right rotate for shift===32 (just swaps l&h)
const rotr32H = (_h, l) => l;
exports.rotr32H = rotr32H;
const rotr32L = (h, _l) => h;
exports.rotr32L = rotr32L;
// Left rotate for Shift in [1, 32)
const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
exports.rotlSH = rotlSH;
const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
exports.rotlSL = rotlSL;
// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
exports.rotlBH = rotlBH;
const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
exports.rotlBL = rotlBL;
// JS uses 32-bit signed integers for bitwise operations which means we cannot
// simple take carry out of low bit sum by shift, we need to use division.
function add(Ah, Al, Bh, Bl) {
const l = (Al >>> 0) + (Bl >>> 0);
return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
}
exports.add = add;
// Addition with more than 2 elements
const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
exports.add3L = add3L;
const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
exports.add3H = add3H;
const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
exports.add4L = add4L;
const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
exports.add4H = add4H;
const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
exports.add5L = add5L;
const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
exports.add5H = add5H;
// prettier-ignore
const u64 = {
fromBig, split, toBig,
shrSH, shrSL,
rotrSH, rotrSL, rotrBH, rotrBL,
rotr32H, rotr32L,
rotlSH, rotlSL, rotlBH, rotlBL,
add, add3L, add3H, add4L, add4H, add5H, add5L,
};
exports.default = u64;
//# sourceMappingURL=_u64.js.map;
function __isObj(x) {
return x != null && typeof x === 'object' && x.constructor === Object;
}
if (_node_modules__noble_hashes__u64 === module.exports) {
// do nothing if
} else if (__isObj(_node_modules__noble_hashes__u64) && __isObj(module.exports)) {
Object.assign(_node_modules__noble_hashes__u64, module.exports);
} else {
_node_modules__noble_hashes__u64 = module.exports;
}
;
}());
// end:source ./ModuleSimplified.js
// source ./ModuleSimplified.js
var _node_modules__noble_hashes_crypto;
(function () {
// ensure AMD is