From 2fc5c1667da9a51551641e55ec8e5dece65b12cd Mon Sep 17 00:00:00 2001 From: JudeTulel Date: Fri, 11 Oct 2024 08:17:01 +0300 Subject: [PATCH] waah --- .../node_modules/.vite/deps/@dfinity_agent.js | 5145 +++++++ .../.vite/deps/@dfinity_agent.js.map | 7 + .../node_modules/.vite/deps/_metadata.json | 39 +- .../.vite/deps/canisterStatus-7DMGTDW5.js | 14 + .../.vite/deps/canisterStatus-7DMGTDW5.js.map | 7 + .../{chunk-JHBQJ233.js => chunk-2DCM46BG.js} | 37 +- ...-JHBQJ233.js.map => chunk-2DCM46BG.js.map} | 2 +- .../node_modules/.vite/deps/chunk-5WWUZCGV.js | 36 + .../.vite/deps/chunk-5WWUZCGV.js.map | 7 + .../{chunk-CI5QM2G2.js => chunk-F3VLP26G.js} | 8 +- ...-CI5QM2G2.js.map => chunk-F3VLP26G.js.map} | 2 +- .../node_modules/.vite/deps/chunk-WEDUZXV4.js | 12782 ++++++++++++++++ .../.vite/deps/chunk-WEDUZXV4.js.map | 7 + .../node_modules/.vite/deps/lucide-react.js | 8 +- .../.vite/deps/lucide-react.js.map | 2 +- .../.vite/deps/react-dom_client.js | 5 +- .../.vite/deps/react-dom_client.js.map | 2 +- .../.vite/deps/react-router-dom.js | 8 +- .../.vite/deps/react-router-dom.js.map | 2 +- .../node_modules/.vite/deps/react.js | 3 +- .../.vite/deps/react_jsx-dev-runtime.js | 6 +- .../.vite/deps/react_jsx-dev-runtime.js.map | 2 +- .../.vite/deps/react_jsx-runtime.js | 6 +- .../.vite/deps/react_jsx-runtime.js.map | 2 +- .../node_modules/.vite/deps/recharts.js | 10 +- .../node_modules/.vite/deps/recharts.js.map | 2 +- .../src/components/DeviceDataModal.jsx | 47 + ...{Modal.jsx => DeviceRegistrationModal.jsx} | 2 +- .../src/components/MainContent.jsx | 2 +- .../src/styles/Maincontent.css | 178 +- src/BlockThings_frontend/src/styles/Modal.css | 51 +- 31 files changed, 18295 insertions(+), 136 deletions(-) create mode 100644 src/BlockThings_frontend/node_modules/.vite/deps/@dfinity_agent.js create mode 100644 src/BlockThings_frontend/node_modules/.vite/deps/@dfinity_agent.js.map create mode 100644 src/BlockThings_frontend/node_modules/.vite/deps/canisterStatus-7DMGTDW5.js create mode 100644 src/BlockThings_frontend/node_modules/.vite/deps/canisterStatus-7DMGTDW5.js.map rename src/BlockThings_frontend/node_modules/.vite/deps/{chunk-JHBQJ233.js => chunk-2DCM46BG.js} (98%) rename src/BlockThings_frontend/node_modules/.vite/deps/{chunk-JHBQJ233.js.map => chunk-2DCM46BG.js.map} (72%) create mode 100644 src/BlockThings_frontend/node_modules/.vite/deps/chunk-5WWUZCGV.js create mode 100644 src/BlockThings_frontend/node_modules/.vite/deps/chunk-5WWUZCGV.js.map rename src/BlockThings_frontend/node_modules/.vite/deps/{chunk-CI5QM2G2.js => chunk-F3VLP26G.js} (99%) rename src/BlockThings_frontend/node_modules/.vite/deps/{chunk-CI5QM2G2.js.map => chunk-F3VLP26G.js.map} (74%) create mode 100644 src/BlockThings_frontend/node_modules/.vite/deps/chunk-WEDUZXV4.js create mode 100644 src/BlockThings_frontend/node_modules/.vite/deps/chunk-WEDUZXV4.js.map create mode 100644 src/BlockThings_frontend/src/components/DeviceDataModal.jsx rename src/BlockThings_frontend/src/components/{Modal.jsx => DeviceRegistrationModal.jsx} (93%) diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/@dfinity_agent.js b/src/BlockThings_frontend/node_modules/.vite/deps/@dfinity_agent.js new file mode 100644 index 0000000..d32910a --- /dev/null +++ b/src/BlockThings_frontend/node_modules/.vite/deps/@dfinity_agent.js @@ -0,0 +1,5145 @@ +import { + AgentError, + Certificate, + CertificateVerificationError, + Field, + FpSqrtEven, + HashMD, + LookupStatus, + NodeType, + Principal, + aInRange, + abool, + blsVerify, + bufEquals, + bufFromBufLike, + bytesToHex, + bytesToNumberLE, + canisterStatus_exports, + cbor_exports, + check_canister_ranges, + compare, + concat, + concatBytes, + concatBytes2, + createHasher, + decode, + decodeTime, + encode, + ensureBytes, + equalBytes, + find_label, + flatten_forks, + fromHex, + hash, + hashOfMap, + hashTreeToString, + hashValue, + idl_exports, + isNegativeLE, + lebEncode, + lookupResultToBuffer, + lookup_path, + memoized, + mod, + numberToBytesLE, + pippenger, + pow, + pow2, + randomBytes, + reconstruct, + request, + requestIdOf, + require_base64_js, + require_ieee754, + require_src, + toHex, + uint8ToBuf, + utf8ToBytes, + validateBasic, + validateObject, + verify, + wNAF, + wrapConstructor +} from "./chunk-WEDUZXV4.js"; +import { + __commonJS, + __export, + __toESM +} from "./chunk-5WWUZCGV.js"; + +// ../../node_modules/buffer/index.js +var require_buffer = __commonJS({ + "../../node_modules/buffer/index.js"(exports) { + "use strict"; + var base64 = require_base64_js(); + var ieee754 = require_ieee754(); + var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null; + exports.Buffer = Buffer2; + exports.SlowBuffer = SlowBuffer; + exports.INSPECT_MAX_BYTES = 50; + var K_MAX_LENGTH = 2147483647; + exports.kMaxLength = K_MAX_LENGTH; + Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport(); + if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") { + console.error( + "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support." + ); + } + function typedArraySupport() { + try { + const arr = new Uint8Array(1); + const proto = { foo: function() { + return 42; + } }; + Object.setPrototypeOf(proto, Uint8Array.prototype); + Object.setPrototypeOf(arr, proto); + return arr.foo() === 42; + } catch (e) { + return false; + } + } + Object.defineProperty(Buffer2.prototype, "parent", { + enumerable: true, + get: function() { + if (!Buffer2.isBuffer(this)) + return void 0; + return this.buffer; + } + }); + Object.defineProperty(Buffer2.prototype, "offset", { + enumerable: true, + get: function() { + if (!Buffer2.isBuffer(this)) + return void 0; + return this.byteOffset; + } + }); + function createBuffer(length) { + if (length > K_MAX_LENGTH) { + throw new RangeError('The value "' + length + '" is invalid for option "size"'); + } + const buf = new Uint8Array(length); + Object.setPrototypeOf(buf, Buffer2.prototype); + return buf; + } + function Buffer2(arg, encodingOrOffset, length) { + if (typeof arg === "number") { + if (typeof encodingOrOffset === "string") { + throw new TypeError( + 'The "string" argument must be of type string. Received type number' + ); + } + return allocUnsafe(arg); + } + return from(arg, encodingOrOffset, length); + } + Buffer2.poolSize = 8192; + function from(value2, encodingOrOffset, length) { + if (typeof value2 === "string") { + return fromString(value2, encodingOrOffset); + } + if (ArrayBuffer.isView(value2)) { + return fromArrayView(value2); + } + if (value2 == null) { + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value2 + ); + } + if (isInstance(value2, ArrayBuffer) || value2 && isInstance(value2.buffer, ArrayBuffer)) { + return fromArrayBuffer(value2, encodingOrOffset, length); + } + if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value2, SharedArrayBuffer) || value2 && isInstance(value2.buffer, SharedArrayBuffer))) { + return fromArrayBuffer(value2, encodingOrOffset, length); + } + if (typeof value2 === "number") { + throw new TypeError( + 'The "value" argument must not be of type number. Received type number' + ); + } + const valueOf = value2.valueOf && value2.valueOf(); + if (valueOf != null && valueOf !== value2) { + return Buffer2.from(valueOf, encodingOrOffset, length); + } + const b = fromObject(value2); + if (b) + return b; + if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value2[Symbol.toPrimitive] === "function") { + return Buffer2.from(value2[Symbol.toPrimitive]("string"), encodingOrOffset, length); + } + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value2 + ); + } + Buffer2.from = function(value2, encodingOrOffset, length) { + return from(value2, encodingOrOffset, length); + }; + Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype); + Object.setPrototypeOf(Buffer2, Uint8Array); + function assertSize(size) { + if (typeof size !== "number") { + throw new TypeError('"size" argument must be of type number'); + } else if (size < 0) { + throw new RangeError('The value "' + size + '" is invalid for option "size"'); + } + } + function alloc(size, fill, encoding) { + assertSize(size); + if (size <= 0) { + return createBuffer(size); + } + if (fill !== void 0) { + return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill); + } + return createBuffer(size); + } + Buffer2.alloc = function(size, fill, encoding) { + return alloc(size, fill, encoding); + }; + function allocUnsafe(size) { + assertSize(size); + return createBuffer(size < 0 ? 0 : checked(size) | 0); + } + Buffer2.allocUnsafe = function(size) { + return allocUnsafe(size); + }; + Buffer2.allocUnsafeSlow = function(size) { + return allocUnsafe(size); + }; + function fromString(string, encoding) { + if (typeof encoding !== "string" || encoding === "") { + encoding = "utf8"; + } + if (!Buffer2.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + const length = byteLength(string, encoding) | 0; + let buf = createBuffer(length); + const actual = buf.write(string, encoding); + if (actual !== length) { + buf = buf.slice(0, actual); + } + return buf; + } + function fromArrayLike(array) { + const length = array.length < 0 ? 0 : checked(array.length) | 0; + const buf = createBuffer(length); + for (let i = 0; i < length; i += 1) { + buf[i] = array[i] & 255; + } + return buf; + } + function fromArrayView(arrayView) { + if (isInstance(arrayView, Uint8Array)) { + const copy = new Uint8Array(arrayView); + return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength); + } + return fromArrayLike(arrayView); + } + function fromArrayBuffer(array, byteOffset, length) { + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('"offset" is outside of buffer bounds'); + } + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('"length" is outside of buffer bounds'); + } + let buf; + if (byteOffset === void 0 && length === void 0) { + buf = new Uint8Array(array); + } else if (length === void 0) { + buf = new Uint8Array(array, byteOffset); + } else { + buf = new Uint8Array(array, byteOffset, length); + } + Object.setPrototypeOf(buf, Buffer2.prototype); + return buf; + } + function fromObject(obj) { + if (Buffer2.isBuffer(obj)) { + const len = checked(obj.length) | 0; + const buf = createBuffer(len); + if (buf.length === 0) { + return buf; + } + obj.copy(buf, 0, 0, len); + return buf; + } + if (obj.length !== void 0) { + if (typeof obj.length !== "number" || numberIsNaN(obj.length)) { + return createBuffer(0); + } + return fromArrayLike(obj); + } + if (obj.type === "Buffer" && Array.isArray(obj.data)) { + return fromArrayLike(obj.data); + } + } + function checked(length) { + if (length >= K_MAX_LENGTH) { + throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes"); + } + return length | 0; + } + function SlowBuffer(length) { + if (+length != length) { + length = 0; + } + return Buffer2.alloc(+length); + } + Buffer2.isBuffer = function isBuffer(b) { + return b != null && b._isBuffer === true && b !== Buffer2.prototype; + }; + Buffer2.compare = function compare2(a, b) { + if (isInstance(a, Uint8Array)) + a = Buffer2.from(a, a.offset, a.byteLength); + if (isInstance(b, Uint8Array)) + b = Buffer2.from(b, b.offset, b.byteLength); + if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) { + throw new TypeError( + 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' + ); + } + if (a === b) + return 0; + let x = a.length; + let y = b.length; + for (let i = 0, len = Math.min(x, y); i < len; ++i) { + if (a[i] !== b[i]) { + x = a[i]; + y = b[i]; + break; + } + } + if (x < y) + return -1; + if (y < x) + return 1; + return 0; + }; + Buffer2.isEncoding = function isEncoding(encoding) { + switch (String(encoding).toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "latin1": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return true; + default: + return false; + } + }; + Buffer2.concat = function concat2(list, length) { + if (!Array.isArray(list)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } + if (list.length === 0) { + return Buffer2.alloc(0); + } + let i; + if (length === void 0) { + length = 0; + for (i = 0; i < list.length; ++i) { + length += list[i].length; + } + } + const buffer = Buffer2.allocUnsafe(length); + let pos = 0; + for (i = 0; i < list.length; ++i) { + let buf = list[i]; + if (isInstance(buf, Uint8Array)) { + if (pos + buf.length > buffer.length) { + if (!Buffer2.isBuffer(buf)) + buf = Buffer2.from(buf); + buf.copy(buffer, pos); + } else { + Uint8Array.prototype.set.call( + buffer, + buf, + pos + ); + } + } else if (!Buffer2.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } else { + buf.copy(buffer, pos); + } + pos += buf.length; + } + return buffer; + }; + function byteLength(string, encoding) { + if (Buffer2.isBuffer(string)) { + return string.length; + } + if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) { + return string.byteLength; + } + if (typeof string !== "string") { + throw new TypeError( + 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string + ); + } + const len = string.length; + const mustMatch = arguments.length > 2 && arguments[2] === true; + if (!mustMatch && len === 0) + return 0; + let loweredCase = false; + for (; ; ) { + switch (encoding) { + case "ascii": + case "latin1": + case "binary": + return len; + case "utf8": + case "utf-8": + return utf8ToBytes2(string).length; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return len * 2; + case "hex": + return len >>> 1; + case "base64": + return base64ToBytes(string).length; + default: + if (loweredCase) { + return mustMatch ? -1 : utf8ToBytes2(string).length; + } + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + } + Buffer2.byteLength = byteLength; + function slowToString(encoding, start, end) { + let loweredCase = false; + if (start === void 0 || start < 0) { + start = 0; + } + if (start > this.length) { + return ""; + } + if (end === void 0 || end > this.length) { + end = this.length; + } + if (end <= 0) { + return ""; + } + end >>>= 0; + start >>>= 0; + if (end <= start) { + return ""; + } + if (!encoding) + encoding = "utf8"; + while (true) { + switch (encoding) { + case "hex": + return hexSlice(this, start, end); + case "utf8": + case "utf-8": + return utf8Slice(this, start, end); + case "ascii": + return asciiSlice(this, start, end); + case "latin1": + case "binary": + return latin1Slice(this, start, end); + case "base64": + return base64Slice(this, start, end); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return utf16leSlice(this, start, end); + default: + if (loweredCase) + throw new TypeError("Unknown encoding: " + encoding); + encoding = (encoding + "").toLowerCase(); + loweredCase = true; + } + } + } + Buffer2.prototype._isBuffer = true; + function swap(b, n, m) { + const i = b[n]; + b[n] = b[m]; + b[m] = i; + } + Buffer2.prototype.swap16 = function swap16() { + const len = this.length; + if (len % 2 !== 0) { + throw new RangeError("Buffer size must be a multiple of 16-bits"); + } + for (let i = 0; i < len; i += 2) { + swap(this, i, i + 1); + } + return this; + }; + Buffer2.prototype.swap32 = function swap32() { + const len = this.length; + if (len % 4 !== 0) { + throw new RangeError("Buffer size must be a multiple of 32-bits"); + } + for (let i = 0; i < len; i += 4) { + swap(this, i, i + 3); + swap(this, i + 1, i + 2); + } + return this; + }; + Buffer2.prototype.swap64 = function swap64() { + const len = this.length; + if (len % 8 !== 0) { + throw new RangeError("Buffer size must be a multiple of 64-bits"); + } + for (let i = 0; i < len; i += 8) { + swap(this, i, i + 7); + swap(this, i + 1, i + 6); + swap(this, i + 2, i + 5); + swap(this, i + 3, i + 4); + } + return this; + }; + Buffer2.prototype.toString = function toString() { + const length = this.length; + if (length === 0) + return ""; + if (arguments.length === 0) + return utf8Slice(this, 0, length); + return slowToString.apply(this, arguments); + }; + Buffer2.prototype.toLocaleString = Buffer2.prototype.toString; + Buffer2.prototype.equals = function equals(b) { + if (!Buffer2.isBuffer(b)) + throw new TypeError("Argument must be a Buffer"); + if (this === b) + return true; + return Buffer2.compare(this, b) === 0; + }; + Buffer2.prototype.inspect = function inspect() { + let str = ""; + const max = exports.INSPECT_MAX_BYTES; + str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim(); + if (this.length > max) + str += " ... "; + return ""; + }; + if (customInspectSymbol) { + Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect; + } + Buffer2.prototype.compare = function compare2(target, start, end, thisStart, thisEnd) { + if (isInstance(target, Uint8Array)) { + target = Buffer2.from(target, target.offset, target.byteLength); + } + if (!Buffer2.isBuffer(target)) { + throw new TypeError( + 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target + ); + } + if (start === void 0) { + start = 0; + } + if (end === void 0) { + end = target ? target.length : 0; + } + if (thisStart === void 0) { + thisStart = 0; + } + if (thisEnd === void 0) { + thisEnd = this.length; + } + if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) { + throw new RangeError("out of range index"); + } + if (thisStart >= thisEnd && start >= end) { + return 0; + } + if (thisStart >= thisEnd) { + return -1; + } + if (start >= end) { + return 1; + } + start >>>= 0; + end >>>= 0; + thisStart >>>= 0; + thisEnd >>>= 0; + if (this === target) + return 0; + let x = thisEnd - thisStart; + let y = end - start; + const len = Math.min(x, y); + const thisCopy = this.slice(thisStart, thisEnd); + const targetCopy = target.slice(start, end); + for (let i = 0; i < len; ++i) { + if (thisCopy[i] !== targetCopy[i]) { + x = thisCopy[i]; + y = targetCopy[i]; + break; + } + } + if (x < y) + return -1; + if (y < x) + return 1; + return 0; + }; + function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) { + if (buffer.length === 0) + return -1; + if (typeof byteOffset === "string") { + encoding = byteOffset; + byteOffset = 0; + } else if (byteOffset > 2147483647) { + byteOffset = 2147483647; + } else if (byteOffset < -2147483648) { + byteOffset = -2147483648; + } + byteOffset = +byteOffset; + if (numberIsNaN(byteOffset)) { + byteOffset = dir ? 0 : buffer.length - 1; + } + if (byteOffset < 0) + byteOffset = buffer.length + byteOffset; + if (byteOffset >= buffer.length) { + if (dir) + return -1; + else + byteOffset = buffer.length - 1; + } else if (byteOffset < 0) { + if (dir) + byteOffset = 0; + else + return -1; + } + if (typeof val === "string") { + val = Buffer2.from(val, encoding); + } + if (Buffer2.isBuffer(val)) { + if (val.length === 0) { + return -1; + } + return arrayIndexOf(buffer, val, byteOffset, encoding, dir); + } else if (typeof val === "number") { + val = val & 255; + if (typeof Uint8Array.prototype.indexOf === "function") { + if (dir) { + return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset); + } else { + return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset); + } + } + return arrayIndexOf(buffer, [val], byteOffset, encoding, dir); + } + throw new TypeError("val must be string, number or Buffer"); + } + function arrayIndexOf(arr, val, byteOffset, encoding, dir) { + let indexSize = 1; + let arrLength = arr.length; + let valLength = val.length; + if (encoding !== void 0) { + encoding = String(encoding).toLowerCase(); + if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") { + if (arr.length < 2 || val.length < 2) { + return -1; + } + indexSize = 2; + arrLength /= 2; + valLength /= 2; + byteOffset /= 2; + } + } + function read(buf, i2) { + if (indexSize === 1) { + return buf[i2]; + } else { + return buf.readUInt16BE(i2 * indexSize); + } + } + let i; + if (dir) { + let foundIndex = -1; + for (i = byteOffset; i < arrLength; i++) { + if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) { + if (foundIndex === -1) + foundIndex = i; + if (i - foundIndex + 1 === valLength) + return foundIndex * indexSize; + } else { + if (foundIndex !== -1) + i -= i - foundIndex; + foundIndex = -1; + } + } + } else { + if (byteOffset + valLength > arrLength) + byteOffset = arrLength - valLength; + for (i = byteOffset; i >= 0; i--) { + let found = true; + for (let j = 0; j < valLength; j++) { + if (read(arr, i + j) !== read(val, j)) { + found = false; + break; + } + } + if (found) + return i; + } + } + return -1; + } + Buffer2.prototype.includes = function includes(val, byteOffset, encoding) { + return this.indexOf(val, byteOffset, encoding) !== -1; + }; + Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, true); + }; + Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) { + return bidirectionalIndexOf(this, val, byteOffset, encoding, false); + }; + function hexWrite(buf, string, offset, length) { + offset = Number(offset) || 0; + const remaining = buf.length - offset; + if (!length) { + length = remaining; + } else { + length = Number(length); + if (length > remaining) { + length = remaining; + } + } + const strLen = string.length; + if (length > strLen / 2) { + length = strLen / 2; + } + let i; + for (i = 0; i < length; ++i) { + const parsed = parseInt(string.substr(i * 2, 2), 16); + if (numberIsNaN(parsed)) + return i; + buf[offset + i] = parsed; + } + return i; + } + function utf8Write(buf, string, offset, length) { + return blitBuffer(utf8ToBytes2(string, buf.length - offset), buf, offset, length); + } + function asciiWrite(buf, string, offset, length) { + return blitBuffer(asciiToBytes(string), buf, offset, length); + } + function base64Write(buf, string, offset, length) { + return blitBuffer(base64ToBytes(string), buf, offset, length); + } + function ucs2Write(buf, string, offset, length) { + return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length); + } + Buffer2.prototype.write = function write(string, offset, length, encoding) { + if (offset === void 0) { + encoding = "utf8"; + length = this.length; + offset = 0; + } else if (length === void 0 && typeof offset === "string") { + encoding = offset; + length = this.length; + offset = 0; + } else if (isFinite(offset)) { + offset = offset >>> 0; + if (isFinite(length)) { + length = length >>> 0; + if (encoding === void 0) + encoding = "utf8"; + } else { + encoding = length; + length = void 0; + } + } else { + throw new Error( + "Buffer.write(string, encoding, offset[, length]) is no longer supported" + ); + } + const remaining = this.length - offset; + if (length === void 0 || length > remaining) + length = remaining; + if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) { + throw new RangeError("Attempt to write outside buffer bounds"); + } + if (!encoding) + encoding = "utf8"; + let loweredCase = false; + for (; ; ) { + switch (encoding) { + case "hex": + return hexWrite(this, string, offset, length); + case "utf8": + case "utf-8": + return utf8Write(this, string, offset, length); + case "ascii": + case "latin1": + case "binary": + return asciiWrite(this, string, offset, length); + case "base64": + return base64Write(this, string, offset, length); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return ucs2Write(this, string, offset, length); + default: + if (loweredCase) + throw new TypeError("Unknown encoding: " + encoding); + encoding = ("" + encoding).toLowerCase(); + loweredCase = true; + } + } + }; + Buffer2.prototype.toJSON = function toJSON() { + return { + type: "Buffer", + data: Array.prototype.slice.call(this._arr || this, 0) + }; + }; + function base64Slice(buf, start, end) { + if (start === 0 && end === buf.length) { + return base64.fromByteArray(buf); + } else { + return base64.fromByteArray(buf.slice(start, end)); + } + } + function utf8Slice(buf, start, end) { + end = Math.min(buf.length, end); + const res = []; + let i = start; + while (i < end) { + const firstByte = buf[i]; + let codePoint = null; + let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1; + if (i + bytesPerSequence <= end) { + let secondByte, thirdByte, fourthByte, tempCodePoint; + switch (bytesPerSequence) { + case 1: + if (firstByte < 128) { + codePoint = firstByte; + } + break; + case 2: + secondByte = buf[i + 1]; + if ((secondByte & 192) === 128) { + tempCodePoint = (firstByte & 31) << 6 | secondByte & 63; + if (tempCodePoint > 127) { + codePoint = tempCodePoint; + } + } + break; + case 3: + secondByte = buf[i + 1]; + thirdByte = buf[i + 2]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63; + if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) { + codePoint = tempCodePoint; + } + } + break; + case 4: + secondByte = buf[i + 1]; + thirdByte = buf[i + 2]; + fourthByte = buf[i + 3]; + if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) { + tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63; + if (tempCodePoint > 65535 && tempCodePoint < 1114112) { + codePoint = tempCodePoint; + } + } + } + } + if (codePoint === null) { + codePoint = 65533; + bytesPerSequence = 1; + } else if (codePoint > 65535) { + codePoint -= 65536; + res.push(codePoint >>> 10 & 1023 | 55296); + codePoint = 56320 | codePoint & 1023; + } + res.push(codePoint); + i += bytesPerSequence; + } + return decodeCodePointsArray(res); + } + var MAX_ARGUMENTS_LENGTH = 4096; + function decodeCodePointsArray(codePoints) { + const len = codePoints.length; + if (len <= MAX_ARGUMENTS_LENGTH) { + return String.fromCharCode.apply(String, codePoints); + } + let res = ""; + let i = 0; + while (i < len) { + res += String.fromCharCode.apply( + String, + codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH) + ); + } + return res; + } + function asciiSlice(buf, start, end) { + let ret = ""; + end = Math.min(buf.length, end); + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 127); + } + return ret; + } + function latin1Slice(buf, start, end) { + let ret = ""; + end = Math.min(buf.length, end); + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]); + } + return ret; + } + function hexSlice(buf, start, end) { + const len = buf.length; + if (!start || start < 0) + start = 0; + if (!end || end < 0 || end > len) + end = len; + let out = ""; + for (let i = start; i < end; ++i) { + out += hexSliceLookupTable[buf[i]]; + } + return out; + } + function utf16leSlice(buf, start, end) { + const bytes = buf.slice(start, end); + let res = ""; + for (let i = 0; i < bytes.length - 1; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); + } + return res; + } + Buffer2.prototype.slice = function slice(start, end) { + const len = this.length; + start = ~~start; + end = end === void 0 ? len : ~~end; + if (start < 0) { + start += len; + if (start < 0) + start = 0; + } else if (start > len) { + start = len; + } + if (end < 0) { + end += len; + if (end < 0) + end = 0; + } else if (end > len) { + end = len; + } + if (end < start) + end = start; + const newBuf = this.subarray(start, end); + Object.setPrototypeOf(newBuf, Buffer2.prototype); + return newBuf; + }; + function checkOffset(offset, ext, length) { + if (offset % 1 !== 0 || offset < 0) + throw new RangeError("offset is not uint"); + if (offset + ext > length) + throw new RangeError("Trying to access beyond buffer length"); + } + Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) + checkOffset(offset, byteLength2, this.length); + let val = this[offset]; + let mul = 1; + let i = 0; + while (++i < byteLength2 && (mul *= 256)) { + val += this[offset + i] * mul; + } + return val; + }; + Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + checkOffset(offset, byteLength2, this.length); + } + let val = this[offset + --byteLength2]; + let mul = 1; + while (byteLength2 > 0 && (mul *= 256)) { + val += this[offset + --byteLength2] * mul; + } + return val; + }; + Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 1, this.length); + return this[offset]; + }; + Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 2, this.length); + return this[offset] | this[offset + 1] << 8; + }; + Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 2, this.length); + return this[offset] << 8 | this[offset + 1]; + }; + Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216; + }; + Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]); + }; + Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24; + const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24; + return BigInt(lo) + (BigInt(hi) << BigInt(32)); + }); + Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last; + return (BigInt(hi) << BigInt(32)) + BigInt(lo); + }); + Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) + checkOffset(offset, byteLength2, this.length); + let val = this[offset]; + let mul = 1; + let i = 0; + while (++i < byteLength2 && (mul *= 256)) { + val += this[offset + i] * mul; + } + mul *= 128; + if (val >= mul) + val -= Math.pow(2, 8 * byteLength2); + return val; + }; + Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) { + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) + checkOffset(offset, byteLength2, this.length); + let i = byteLength2; + let mul = 1; + let val = this[offset + --i]; + while (i > 0 && (mul *= 256)) { + val += this[offset + --i] * mul; + } + mul *= 128; + if (val >= mul) + val -= Math.pow(2, 8 * byteLength2); + return val; + }; + Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 1, this.length); + if (!(this[offset] & 128)) + return this[offset]; + return (255 - this[offset] + 1) * -1; + }; + Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 2, this.length); + const val = this[offset] | this[offset + 1] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 2, this.length); + const val = this[offset + 1] | this[offset] << 8; + return val & 32768 ? val | 4294901760 : val; + }; + Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24; + }; + Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]; + }; + Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24); + return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24); + }); + Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, "offset"); + const first = this[offset]; + const last = this[offset + 7]; + if (first === void 0 || last === void 0) { + boundsError(offset, this.length - 8); + } + const val = (first << 24) + // Overflow + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last); + }); + Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return ieee754.read(this, offset, true, 23, 4); + }; + Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 4, this.length); + return ieee754.read(this, offset, false, 23, 4); + }; + Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 8, this.length); + return ieee754.read(this, offset, true, 52, 8); + }; + Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) + checkOffset(offset, 8, this.length); + return ieee754.read(this, offset, false, 52, 8); + }; + function checkInt(buf, value2, offset, ext, max, min) { + if (!Buffer2.isBuffer(buf)) + throw new TypeError('"buffer" argument must be a Buffer instance'); + if (value2 > max || value2 < min) + throw new RangeError('"value" argument is out of bounds'); + if (offset + ext > buf.length) + throw new RangeError("Index out of range"); + } + Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value2, offset, byteLength2, noAssert) { + value2 = +value2; + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength2) - 1; + checkInt(this, value2, offset, byteLength2, maxBytes, 0); + } + let mul = 1; + let i = 0; + this[offset] = value2 & 255; + while (++i < byteLength2 && (mul *= 256)) { + this[offset + i] = value2 / mul & 255; + } + return offset + byteLength2; + }; + Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value2, offset, byteLength2, noAssert) { + value2 = +value2; + offset = offset >>> 0; + byteLength2 = byteLength2 >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength2) - 1; + checkInt(this, value2, offset, byteLength2, maxBytes, 0); + } + let i = byteLength2 - 1; + let mul = 1; + this[offset + i] = value2 & 255; + while (--i >= 0 && (mul *= 256)) { + this[offset + i] = value2 / mul & 255; + } + return offset + byteLength2; + }; + Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 1, 255, 0); + this[offset] = value2 & 255; + return offset + 1; + }; + Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 2, 65535, 0); + this[offset] = value2 & 255; + this[offset + 1] = value2 >>> 8; + return offset + 2; + }; + Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 2, 65535, 0); + this[offset] = value2 >>> 8; + this[offset + 1] = value2 & 255; + return offset + 2; + }; + Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 4, 4294967295, 0); + this[offset + 3] = value2 >>> 24; + this[offset + 2] = value2 >>> 16; + this[offset + 1] = value2 >>> 8; + this[offset] = value2 & 255; + return offset + 4; + }; + Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 4, 4294967295, 0); + this[offset] = value2 >>> 24; + this[offset + 1] = value2 >>> 16; + this[offset + 2] = value2 >>> 8; + this[offset + 3] = value2 & 255; + return offset + 4; + }; + function wrtBigUInt64LE(buf, value2, offset, min, max) { + checkIntBI(value2, min, max, buf, offset, 7); + let lo = Number(value2 & BigInt(4294967295)); + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + let hi = Number(value2 >> BigInt(32) & BigInt(4294967295)); + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + return offset; + } + function wrtBigUInt64BE(buf, value2, offset, min, max) { + checkIntBI(value2, min, max, buf, offset, 7); + let lo = Number(value2 & BigInt(4294967295)); + buf[offset + 7] = lo; + lo = lo >> 8; + buf[offset + 6] = lo; + lo = lo >> 8; + buf[offset + 5] = lo; + lo = lo >> 8; + buf[offset + 4] = lo; + let hi = Number(value2 >> BigInt(32) & BigInt(4294967295)); + buf[offset + 3] = hi; + hi = hi >> 8; + buf[offset + 2] = hi; + hi = hi >> 8; + buf[offset + 1] = hi; + hi = hi >> 8; + buf[offset] = hi; + return offset + 8; + } + Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value2, offset = 0) { + return wrtBigUInt64LE(this, value2, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value2, offset = 0) { + return wrtBigUInt64BE(this, value2, offset, BigInt(0), BigInt("0xffffffffffffffff")); + }); + Buffer2.prototype.writeIntLE = function writeIntLE(value2, offset, byteLength2, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength2 - 1); + checkInt(this, value2, offset, byteLength2, limit - 1, -limit); + } + let i = 0; + let mul = 1; + let sub = 0; + this[offset] = value2 & 255; + while (++i < byteLength2 && (mul *= 256)) { + if (value2 < 0 && sub === 0 && this[offset + i - 1] !== 0) { + sub = 1; + } + this[offset + i] = (value2 / mul >> 0) - sub & 255; + } + return offset + byteLength2; + }; + Buffer2.prototype.writeIntBE = function writeIntBE(value2, offset, byteLength2, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength2 - 1); + checkInt(this, value2, offset, byteLength2, limit - 1, -limit); + } + let i = byteLength2 - 1; + let mul = 1; + let sub = 0; + this[offset + i] = value2 & 255; + while (--i >= 0 && (mul *= 256)) { + if (value2 < 0 && sub === 0 && this[offset + i + 1] !== 0) { + sub = 1; + } + this[offset + i] = (value2 / mul >> 0) - sub & 255; + } + return offset + byteLength2; + }; + Buffer2.prototype.writeInt8 = function writeInt8(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 1, 127, -128); + if (value2 < 0) + value2 = 255 + value2 + 1; + this[offset] = value2 & 255; + return offset + 1; + }; + Buffer2.prototype.writeInt16LE = function writeInt16LE(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 2, 32767, -32768); + this[offset] = value2 & 255; + this[offset + 1] = value2 >>> 8; + return offset + 2; + }; + Buffer2.prototype.writeInt16BE = function writeInt16BE(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 2, 32767, -32768); + this[offset] = value2 >>> 8; + this[offset + 1] = value2 & 255; + return offset + 2; + }; + Buffer2.prototype.writeInt32LE = function writeInt32LE(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 4, 2147483647, -2147483648); + this[offset] = value2 & 255; + this[offset + 1] = value2 >>> 8; + this[offset + 2] = value2 >>> 16; + this[offset + 3] = value2 >>> 24; + return offset + 4; + }; + Buffer2.prototype.writeInt32BE = function writeInt32BE(value2, offset, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) + checkInt(this, value2, offset, 4, 2147483647, -2147483648); + if (value2 < 0) + value2 = 4294967295 + value2 + 1; + this[offset] = value2 >>> 24; + this[offset + 1] = value2 >>> 16; + this[offset + 2] = value2 >>> 8; + this[offset + 3] = value2 & 255; + return offset + 4; + }; + Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value2, offset = 0) { + return wrtBigUInt64LE(this, value2, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value2, offset = 0) { + return wrtBigUInt64BE(this, value2, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff")); + }); + function checkIEEE754(buf, value2, offset, ext, max, min) { + if (offset + ext > buf.length) + throw new RangeError("Index out of range"); + if (offset < 0) + throw new RangeError("Index out of range"); + } + function writeFloat(buf, value2, offset, littleEndian, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value2, offset, 4, 34028234663852886e22, -34028234663852886e22); + } + ieee754.write(buf, value2, offset, littleEndian, 23, 4); + return offset + 4; + } + Buffer2.prototype.writeFloatLE = function writeFloatLE(value2, offset, noAssert) { + return writeFloat(this, value2, offset, true, noAssert); + }; + Buffer2.prototype.writeFloatBE = function writeFloatBE(value2, offset, noAssert) { + return writeFloat(this, value2, offset, false, noAssert); + }; + function writeDouble(buf, value2, offset, littleEndian, noAssert) { + value2 = +value2; + offset = offset >>> 0; + if (!noAssert) { + checkIEEE754(buf, value2, offset, 8, 17976931348623157e292, -17976931348623157e292); + } + ieee754.write(buf, value2, offset, littleEndian, 52, 8); + return offset + 8; + } + Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value2, offset, noAssert) { + return writeDouble(this, value2, offset, true, noAssert); + }; + Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value2, offset, noAssert) { + return writeDouble(this, value2, offset, false, noAssert); + }; + Buffer2.prototype.copy = function copy(target, targetStart, start, end) { + if (!Buffer2.isBuffer(target)) + throw new TypeError("argument should be a Buffer"); + if (!start) + start = 0; + if (!end && end !== 0) + end = this.length; + if (targetStart >= target.length) + targetStart = target.length; + if (!targetStart) + targetStart = 0; + if (end > 0 && end < start) + end = start; + if (end === start) + return 0; + if (target.length === 0 || this.length === 0) + return 0; + if (targetStart < 0) { + throw new RangeError("targetStart out of bounds"); + } + if (start < 0 || start >= this.length) + throw new RangeError("Index out of range"); + if (end < 0) + throw new RangeError("sourceEnd out of bounds"); + if (end > this.length) + end = this.length; + if (target.length - targetStart < end - start) { + end = target.length - targetStart + start; + } + const len = end - start; + if (this === target && typeof Uint8Array.prototype.copyWithin === "function") { + this.copyWithin(targetStart, start, end); + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, end), + targetStart + ); + } + return len; + }; + Buffer2.prototype.fill = function fill(val, start, end, encoding) { + if (typeof val === "string") { + if (typeof start === "string") { + encoding = start; + start = 0; + end = this.length; + } else if (typeof end === "string") { + encoding = end; + end = this.length; + } + if (encoding !== void 0 && typeof encoding !== "string") { + throw new TypeError("encoding must be a string"); + } + if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) { + throw new TypeError("Unknown encoding: " + encoding); + } + if (val.length === 1) { + const code = val.charCodeAt(0); + if (encoding === "utf8" && code < 128 || encoding === "latin1") { + val = code; + } + } + } else if (typeof val === "number") { + val = val & 255; + } else if (typeof val === "boolean") { + val = Number(val); + } + if (start < 0 || this.length < start || this.length < end) { + throw new RangeError("Out of range index"); + } + if (end <= start) { + return this; + } + start = start >>> 0; + end = end === void 0 ? this.length : end >>> 0; + if (!val) + val = 0; + let i; + if (typeof val === "number") { + for (i = start; i < end; ++i) { + this[i] = val; + } + } else { + const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding); + const len = bytes.length; + if (len === 0) { + throw new TypeError('The value "' + val + '" is invalid for argument "value"'); + } + for (i = 0; i < end - start; ++i) { + this[i + start] = bytes[i % len]; + } + } + return this; + }; + var errors = {}; + function E(sym, getMessage, Base) { + errors[sym] = class NodeError extends Base { + constructor() { + super(); + Object.defineProperty(this, "message", { + value: getMessage.apply(this, arguments), + writable: true, + configurable: true + }); + this.name = `${this.name} [${sym}]`; + this.stack; + delete this.name; + } + get code() { + return sym; + } + set code(value2) { + Object.defineProperty(this, "code", { + configurable: true, + enumerable: true, + value: value2, + writable: true + }); + } + toString() { + return `${this.name} [${sym}]: ${this.message}`; + } + }; + } + E( + "ERR_BUFFER_OUT_OF_BOUNDS", + function(name) { + if (name) { + return `${name} is outside of buffer bounds`; + } + return "Attempt to access memory outside buffer bounds"; + }, + RangeError + ); + E( + "ERR_INVALID_ARG_TYPE", + function(name, actual) { + return `The "${name}" argument must be of type number. Received type ${typeof actual}`; + }, + TypeError + ); + E( + "ERR_OUT_OF_RANGE", + function(str, range, input) { + let msg = `The value of "${str}" is out of range.`; + let received = input; + if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) { + received = addNumericalSeparator(String(input)); + } else if (typeof input === "bigint") { + received = String(input); + if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) { + received = addNumericalSeparator(received); + } + received += "n"; + } + msg += ` It must be ${range}. Received ${received}`; + return msg; + }, + RangeError + ); + function addNumericalSeparator(val) { + let res = ""; + let i = val.length; + const start = val[0] === "-" ? 1 : 0; + for (; i >= start + 4; i -= 3) { + res = `_${val.slice(i - 3, i)}${res}`; + } + return `${val.slice(0, i)}${res}`; + } + function checkBounds(buf, offset, byteLength2) { + validateNumber(offset, "offset"); + if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) { + boundsError(offset, buf.length - (byteLength2 + 1)); + } + } + function checkIntBI(value2, min, max, buf, offset, byteLength2) { + if (value2 > max || value2 < min) { + const n = typeof min === "bigint" ? "n" : ""; + let range; + if (byteLength2 > 3) { + if (min === 0 || min === BigInt(0)) { + range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`; + } else { + range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`; + } + } else { + range = `>= ${min}${n} and <= ${max}${n}`; + } + throw new errors.ERR_OUT_OF_RANGE("value", range, value2); + } + checkBounds(buf, offset, byteLength2); + } + function validateNumber(value2, name) { + if (typeof value2 !== "number") { + throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value2); + } + } + function boundsError(value2, length, type) { + if (Math.floor(value2) !== value2) { + validateNumber(value2, type); + throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value2); + } + if (length < 0) { + throw new errors.ERR_BUFFER_OUT_OF_BOUNDS(); + } + throw new errors.ERR_OUT_OF_RANGE( + type || "offset", + `>= ${type ? 1 : 0} and <= ${length}`, + value2 + ); + } + var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g; + function base64clean(str) { + str = str.split("=")[0]; + str = str.trim().replace(INVALID_BASE64_RE, ""); + if (str.length < 2) + return ""; + while (str.length % 4 !== 0) { + str = str + "="; + } + return str; + } + function utf8ToBytes2(string, units) { + units = units || Infinity; + let codePoint; + const length = string.length; + let leadSurrogate = null; + const bytes = []; + for (let i = 0; i < length; ++i) { + codePoint = string.charCodeAt(i); + if (codePoint > 55295 && codePoint < 57344) { + if (!leadSurrogate) { + if (codePoint > 56319) { + if ((units -= 3) > -1) + bytes.push(239, 191, 189); + continue; + } else if (i + 1 === length) { + if ((units -= 3) > -1) + bytes.push(239, 191, 189); + continue; + } + leadSurrogate = codePoint; + continue; + } + if (codePoint < 56320) { + if ((units -= 3) > -1) + bytes.push(239, 191, 189); + leadSurrogate = codePoint; + continue; + } + codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536; + } else if (leadSurrogate) { + if ((units -= 3) > -1) + bytes.push(239, 191, 189); + } + leadSurrogate = null; + if (codePoint < 128) { + if ((units -= 1) < 0) + break; + bytes.push(codePoint); + } else if (codePoint < 2048) { + if ((units -= 2) < 0) + break; + bytes.push( + codePoint >> 6 | 192, + codePoint & 63 | 128 + ); + } else if (codePoint < 65536) { + if ((units -= 3) < 0) + break; + bytes.push( + codePoint >> 12 | 224, + codePoint >> 6 & 63 | 128, + codePoint & 63 | 128 + ); + } else if (codePoint < 1114112) { + if ((units -= 4) < 0) + break; + bytes.push( + codePoint >> 18 | 240, + codePoint >> 12 & 63 | 128, + codePoint >> 6 & 63 | 128, + codePoint & 63 | 128 + ); + } else { + throw new Error("Invalid code point"); + } + } + return bytes; + } + function asciiToBytes(str) { + const byteArray = []; + for (let i = 0; i < str.length; ++i) { + byteArray.push(str.charCodeAt(i) & 255); + } + return byteArray; + } + function utf16leToBytes(str, units) { + let c, hi, lo; + const byteArray = []; + for (let i = 0; i < str.length; ++i) { + if ((units -= 2) < 0) + break; + c = str.charCodeAt(i); + hi = c >> 8; + lo = c % 256; + byteArray.push(lo); + byteArray.push(hi); + } + return byteArray; + } + function base64ToBytes(str) { + return base64.toByteArray(base64clean(str)); + } + function blitBuffer(src, dst, offset, length) { + let i; + for (i = 0; i < length; ++i) { + if (i + offset >= dst.length || i >= src.length) + break; + dst[i + offset] = src[i]; + } + return i; + } + function isInstance(obj, type) { + return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name; + } + function numberIsNaN(obj) { + return obj !== obj; + } + var hexSliceLookupTable = function() { + const alphabet = "0123456789abcdef"; + const table = new Array(256); + for (let i = 0; i < 16; ++i) { + const i16 = i * 16; + for (let j = 0; j < 16; ++j) { + table[i16 + j] = alphabet[i] + alphabet[j]; + } + } + return table; + }(); + function defineBigIntMethod(fn) { + return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn; + } + function BufferBigIntNotDefined() { + throw new Error("BigInt not supported"); + } + } +}); + +// ../../node_modules/@dfinity/agent/lib/esm/actor.js +var import_buffer6 = __toESM(require_buffer()); + +// ../../node_modules/@dfinity/agent/lib/esm/agent/api.js +var ReplicaRejectCode; +(function(ReplicaRejectCode2) { + ReplicaRejectCode2[ReplicaRejectCode2["SysFatal"] = 1] = "SysFatal"; + ReplicaRejectCode2[ReplicaRejectCode2["SysTransient"] = 2] = "SysTransient"; + ReplicaRejectCode2[ReplicaRejectCode2["DestinationInvalid"] = 3] = "DestinationInvalid"; + ReplicaRejectCode2[ReplicaRejectCode2["CanisterReject"] = 4] = "CanisterReject"; + ReplicaRejectCode2[ReplicaRejectCode2["CanisterError"] = 5] = "CanisterError"; +})(ReplicaRejectCode || (ReplicaRejectCode = {})); + +// ../../node_modules/@dfinity/agent/lib/esm/auth.js +var __rest = function(s, e) { + var t = {}; + for (var p in s) + if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +}; +var domainSeparator = new TextEncoder().encode("\nic-request"); +var SignIdentity = class { + /** + * Get the principal represented by this identity. Normally should be a + * `Principal.selfAuthenticating()`. + */ + getPrincipal() { + if (!this._principal) { + this._principal = Principal.selfAuthenticating(new Uint8Array(this.getPublicKey().toDer())); + } + return this._principal; + } + /** + * Transform a request into a signed version of the request. This is done last + * after the transforms on the body of a request. The returned object can be + * anything, but must be serializable to CBOR. + * @param request - internet computer request to transform + */ + async transformRequest(request2) { + const { body } = request2, fields = __rest(request2, ["body"]); + const requestId = await requestIdOf(body); + return Object.assign(Object.assign({}, fields), { body: { + content: body, + sender_pubkey: this.getPublicKey().toDer(), + sender_sig: await this.sign(concat(domainSeparator, requestId)) + } }); + } +}; +var AnonymousIdentity = class { + getPrincipal() { + return Principal.anonymous(); + } + async transformRequest(request2) { + return Object.assign(Object.assign({}, request2), { body: { content: request2.body } }); + } +}; +function createIdentityDescriptor(identity) { + const identityIndicator = "getPublicKey" in identity ? { type: "PublicKeyIdentity", publicKey: toHex(identity.getPublicKey().toDer()) } : { type: "AnonymousIdentity" }; + return identityIndicator; +} + +// ../../node_modules/@dfinity/agent/lib/esm/agent/http/transforms.js +var cbor = __toESM(require_src()); + +// ../../node_modules/@dfinity/agent/lib/esm/utils/random.js +var randomNumber = () => { + if (typeof window !== "undefined" && !!window.crypto && !!window.crypto.getRandomValues) { + const array = new Uint32Array(1); + window.crypto.getRandomValues(array); + return array[0]; + } + if (typeof crypto !== "undefined" && crypto.getRandomValues) { + const array = new Uint32Array(1); + crypto.getRandomValues(array); + return array[0]; + } + if (typeof crypto !== "undefined" && crypto.randomInt) { + return crypto.randomInt(0, 4294967295); + } + return Math.floor(Math.random() * 4294967295); +}; + +// ../../node_modules/@dfinity/agent/lib/esm/agent/http/types.js +var SubmitRequestType; +(function(SubmitRequestType2) { + SubmitRequestType2["Call"] = "call"; +})(SubmitRequestType || (SubmitRequestType = {})); +function makeNonce() { + const buffer = new ArrayBuffer(16); + const view = new DataView(buffer); + const rand1 = randomNumber(); + const rand2 = randomNumber(); + const rand3 = randomNumber(); + const rand4 = randomNumber(); + view.setUint32(0, rand1); + view.setUint32(4, rand2); + view.setUint32(8, rand3); + view.setUint32(12, rand4); + return buffer; +} + +// ../../node_modules/@dfinity/agent/lib/esm/agent/http/transforms.js +var NANOSECONDS_PER_MILLISECONDS = BigInt(1e6); +var REPLICA_PERMITTED_DRIFT_MILLISECONDS = 60 * 1e3; +var Expiry = class { + constructor(deltaInMSec) { + const raw_value = BigInt(Math.floor(Date.now() + deltaInMSec - REPLICA_PERMITTED_DRIFT_MILLISECONDS)) * NANOSECONDS_PER_MILLISECONDS; + const ingress_as_seconds = raw_value / BigInt(1e9); + const ingress_as_minutes = ingress_as_seconds / BigInt(60); + const rounded_down_nanos = ingress_as_minutes * BigInt(60) * BigInt(1e9); + this._value = rounded_down_nanos; + } + toCBOR() { + return cbor.value.u64(this._value.toString(16), 16); + } + toHash() { + return lebEncode(this._value); + } +}; +function makeNonceTransform(nonceFn = makeNonce) { + return async (request2) => { + const headers = request2.request.headers; + request2.request.headers = headers; + if (request2.endpoint === "call") { + request2.body.nonce = nonceFn(); + } + }; +} +function makeExpiryTransform(delayInMilliseconds) { + return async (request2) => { + request2.body.ingress_expiry = new Expiry(delayInMilliseconds); + }; +} +function httpHeadersTransform(headers) { + const headerFields = []; + headers.forEach((value2, key) => { + headerFields.push([key, value2]); + }); + return headerFields; +} + +// ../../node_modules/@dfinity/agent/lib/esm/agent/http/errors.js +var AgentHTTPResponseError = class extends AgentError { + constructor(message, response) { + super(message); + this.response = response; + this.name = this.constructor.name; + Object.setPrototypeOf(this, new.target.prototype); + } +}; + +// ../../node_modules/@noble/hashes/esm/_u64.js +var U32_MASK64 = BigInt(2 ** 32 - 1); +var _32n = BigInt(32); +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 }; +} +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]; +} +var toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0); +var shrSH = (h, _l, s) => h >>> s; +var shrSL = (h, l, s) => h << 32 - s | l >>> s; +var rotrSH = (h, l, s) => h >>> s | l << 32 - s; +var rotrSL = (h, l, s) => h << 32 - s | l >>> s; +var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32; +var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s; +var rotr32H = (_h, l) => l; +var rotr32L = (h, _l) => h; +var rotlSH = (h, l, s) => h << s | l >>> 32 - s; +var rotlSL = (h, l, s) => l << s | h >>> 32 - s; +var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s; +var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s; +function add(Ah, Al, Bh, Bl) { + const l = (Al >>> 0) + (Bl >>> 0); + return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 }; +} +var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0); +var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0; +var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0); +var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0; +var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0); +var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0; +var u64 = { + fromBig, + split, + toBig, + shrSH, + shrSL, + rotrSH, + rotrSL, + rotrBH, + rotrBL, + rotr32H, + rotr32L, + rotlSH, + rotlSL, + rotlBH, + rotlBL, + add, + add3L, + add3H, + add4L, + add4H, + add5H, + add5L +}; +var u64_default = u64; + +// ../../node_modules/@noble/hashes/esm/sha512.js +var [SHA512_Kh, SHA512_Kl] = (() => u64_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((n) => BigInt(n))))(); +var SHA512_W_H = new Uint32Array(80); +var SHA512_W_L = new Uint32Array(80); +var SHA512 = class extends HashMD { + constructor() { + super(128, 64, 16, false); + this.Ah = 1779033703 | 0; + this.Al = 4089235720 | 0; + this.Bh = 3144134277 | 0; + this.Bl = 2227873595 | 0; + this.Ch = 1013904242 | 0; + this.Cl = 4271175723 | 0; + this.Dh = 2773480762 | 0; + this.Dl = 1595750129 | 0; + this.Eh = 1359893119 | 0; + this.El = 2917565137 | 0; + this.Fh = 2600822924 | 0; + this.Fl = 725511199 | 0; + this.Gh = 528734635 | 0; + this.Gl = 4215389547 | 0; + this.Hh = 1541459225 | 0; + this.Hl = 327033209 | 0; + } + // prettier-ignore + get() { + const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this; + return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl]; + } + // prettier-ignore + set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) { + this.Ah = Ah | 0; + this.Al = Al | 0; + this.Bh = Bh | 0; + this.Bl = Bl | 0; + this.Ch = Ch | 0; + this.Cl = Cl | 0; + this.Dh = Dh | 0; + this.Dl = Dl | 0; + this.Eh = Eh | 0; + this.El = El | 0; + this.Fh = Fh | 0; + this.Fl = Fl | 0; + this.Gh = Gh | 0; + this.Gl = Gl | 0; + this.Hh = Hh | 0; + this.Hl = Hl | 0; + } + process(view, offset) { + for (let i = 0; i < 16; i++, offset += 4) { + SHA512_W_H[i] = view.getUint32(offset); + SHA512_W_L[i] = view.getUint32(offset += 4); + } + for (let i = 16; i < 80; i++) { + const W15h = SHA512_W_H[i - 15] | 0; + const W15l = SHA512_W_L[i - 15] | 0; + const s0h = u64_default.rotrSH(W15h, W15l, 1) ^ u64_default.rotrSH(W15h, W15l, 8) ^ u64_default.shrSH(W15h, W15l, 7); + const s0l = u64_default.rotrSL(W15h, W15l, 1) ^ u64_default.rotrSL(W15h, W15l, 8) ^ u64_default.shrSL(W15h, W15l, 7); + const W2h = SHA512_W_H[i - 2] | 0; + const W2l = SHA512_W_L[i - 2] | 0; + const s1h = u64_default.rotrSH(W2h, W2l, 19) ^ u64_default.rotrBH(W2h, W2l, 61) ^ u64_default.shrSH(W2h, W2l, 6); + const s1l = u64_default.rotrSL(W2h, W2l, 19) ^ u64_default.rotrBL(W2h, W2l, 61) ^ u64_default.shrSL(W2h, W2l, 6); + const SUMl = u64_default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]); + const SUMh = u64_default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]); + SHA512_W_H[i] = SUMh | 0; + SHA512_W_L[i] = SUMl | 0; + } + let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this; + for (let i = 0; i < 80; i++) { + const sigma1h = u64_default.rotrSH(Eh, El, 14) ^ u64_default.rotrSH(Eh, El, 18) ^ u64_default.rotrBH(Eh, El, 41); + const sigma1l = u64_default.rotrSL(Eh, El, 14) ^ u64_default.rotrSL(Eh, El, 18) ^ u64_default.rotrBL(Eh, El, 41); + const CHIh = Eh & Fh ^ ~Eh & Gh; + const CHIl = El & Fl ^ ~El & Gl; + const T1ll = u64_default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]); + const T1h = u64_default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]); + const T1l = T1ll | 0; + const sigma0h = u64_default.rotrSH(Ah, Al, 28) ^ u64_default.rotrBH(Ah, Al, 34) ^ u64_default.rotrBH(Ah, Al, 39); + const sigma0l = u64_default.rotrSL(Ah, Al, 28) ^ u64_default.rotrBL(Ah, Al, 34) ^ u64_default.rotrBL(Ah, Al, 39); + const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch; + const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl; + Hh = Gh | 0; + Hl = Gl | 0; + Gh = Fh | 0; + Gl = Fl | 0; + Fh = Eh | 0; + Fl = El | 0; + ({ h: Eh, l: El } = u64_default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0)); + Dh = Ch | 0; + Dl = Cl | 0; + Ch = Bh | 0; + Cl = Bl | 0; + Bh = Ah | 0; + Bl = Al | 0; + const All = u64_default.add3L(T1l, sigma0l, MAJl); + Ah = u64_default.add3H(All, T1h, sigma0h, MAJh); + Al = All | 0; + } + ({ h: Ah, l: Al } = u64_default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0)); + ({ h: Bh, l: Bl } = u64_default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0)); + ({ h: Ch, l: Cl } = u64_default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0)); + ({ h: Dh, l: Dl } = u64_default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0)); + ({ h: Eh, l: El } = u64_default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0)); + ({ h: Fh, l: Fl } = u64_default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0)); + ({ h: Gh, l: Gl } = u64_default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0)); + ({ h: Hh, l: Hl } = u64_default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0)); + this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl); + } + roundClean() { + SHA512_W_H.fill(0); + SHA512_W_L.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); + } +}; +var SHA512_224 = class extends SHA512 { + constructor() { + super(); + this.Ah = 2352822216 | 0; + this.Al = 424955298 | 0; + this.Bh = 1944164710 | 0; + this.Bl = 2312950998 | 0; + this.Ch = 502970286 | 0; + this.Cl = 855612546 | 0; + this.Dh = 1738396948 | 0; + this.Dl = 1479516111 | 0; + this.Eh = 258812777 | 0; + this.El = 2077511080 | 0; + this.Fh = 2011393907 | 0; + this.Fl = 79989058 | 0; + this.Gh = 1067287976 | 0; + this.Gl = 1780299464 | 0; + this.Hh = 286451373 | 0; + this.Hl = 2446758561 | 0; + this.outputLen = 28; + } +}; +var SHA512_256 = class extends SHA512 { + constructor() { + super(); + this.Ah = 573645204 | 0; + this.Al = 4230739756 | 0; + this.Bh = 2673172387 | 0; + this.Bl = 3360449730 | 0; + this.Ch = 596883563 | 0; + this.Cl = 1867755857 | 0; + this.Dh = 2520282905 | 0; + this.Dl = 1497426621 | 0; + this.Eh = 2519219938 | 0; + this.El = 2827943907 | 0; + this.Fh = 3193839141 | 0; + this.Fl = 1401305490 | 0; + this.Gh = 721525244 | 0; + this.Gl = 746961066 | 0; + this.Hh = 246885852 | 0; + this.Hl = 2177182882 | 0; + this.outputLen = 32; + } +}; +var SHA384 = class extends SHA512 { + constructor() { + super(); + this.Ah = 3418070365 | 0; + this.Al = 3238371032 | 0; + this.Bh = 1654270250 | 0; + this.Bl = 914150663 | 0; + this.Ch = 2438529370 | 0; + this.Cl = 812702999 | 0; + this.Dh = 355462360 | 0; + this.Dl = 4144912697 | 0; + this.Eh = 1731405415 | 0; + this.El = 4290775857 | 0; + this.Fh = 2394180231 | 0; + this.Fl = 1750603025 | 0; + this.Gh = 3675008525 | 0; + this.Gl = 1694076839 | 0; + this.Hh = 1203062813 | 0; + this.Hl = 3204075428 | 0; + this.outputLen = 48; + } +}; +var sha512 = wrapConstructor(() => new SHA512()); +var sha512_224 = wrapConstructor(() => new SHA512_224()); +var sha512_256 = wrapConstructor(() => new SHA512_256()); +var sha384 = wrapConstructor(() => new SHA384()); + +// ../../node_modules/@noble/curves/esm/abstract/edwards.js +var _0n = BigInt(0); +var _1n = BigInt(1); +var _2n = BigInt(2); +var _8n = BigInt(8); +var VERIFY_DEFAULT = { zip215: true }; +function validateOpts(curve) { + const opts = validateBasic(curve); + validateObject(curve, { + hash: "function", + a: "bigint", + d: "bigint", + randomBytes: "function" + }, { + adjustScalarBytes: "function", + domain: "function", + uvRatio: "function", + mapToCurve: "function" + }); + return Object.freeze({ ...opts }); +} +function twistedEdwards(curveDef) { + const CURVE = validateOpts(curveDef); + const { Fp: Fp2, n: CURVE_ORDER, prehash, hash: cHash, randomBytes: randomBytes2, nByteLength, h: cofactor } = CURVE; + const MASK = _2n << BigInt(nByteLength * 8) - _1n; + const modP = Fp2.create; + const Fn = Field(CURVE.n, CURVE.nBitLength); + const uvRatio2 = CURVE.uvRatio || ((u, v) => { + try { + return { isValid: true, value: Fp2.sqrt(u * Fp2.inv(v)) }; + } catch (e) { + return { isValid: false, value: _0n }; + } + }); + const adjustScalarBytes2 = CURVE.adjustScalarBytes || ((bytes) => bytes); + const domain = CURVE.domain || ((data, ctx, phflag) => { + abool("phflag", phflag); + if (ctx.length || phflag) + throw new Error("Contexts/pre-hash are not supported"); + return data; + }); + function aCoordinate(title, n) { + aInRange("coordinate " + title, n, _0n, MASK); + } + function assertPoint(other) { + if (!(other instanceof Point)) + throw new Error("ExtendedPoint expected"); + } + const toAffineMemo = memoized((p, iz) => { + const { ex: x, ey: y, ez: z } = p; + const is0 = p.is0(); + if (iz == null) + iz = is0 ? _8n : Fp2.inv(z); + const ax = modP(x * iz); + const ay = modP(y * iz); + const zz = modP(z * iz); + if (is0) + return { x: _0n, y: _1n }; + if (zz !== _1n) + throw new Error("invZ was invalid"); + return { x: ax, y: ay }; + }); + const assertValidMemo = memoized((p) => { + const { a, d } = CURVE; + if (p.is0()) + throw new Error("bad point: ZERO"); + const { ex: X, ey: Y, ez: Z, et: T } = p; + const X2 = modP(X * X); + const Y2 = modP(Y * Y); + const Z2 = modP(Z * Z); + const Z4 = modP(Z2 * Z2); + const aX2 = modP(X2 * a); + const left = modP(Z2 * modP(aX2 + Y2)); + const right = modP(Z4 + modP(d * modP(X2 * Y2))); + if (left !== right) + throw new Error("bad point: equation left != right (1)"); + const XY = modP(X * Y); + const ZT = modP(Z * T); + if (XY !== ZT) + throw new Error("bad point: equation left != right (2)"); + return true; + }); + class Point { + constructor(ex, ey, ez, et) { + this.ex = ex; + this.ey = ey; + this.ez = ez; + this.et = et; + aCoordinate("x", ex); + aCoordinate("y", ey); + aCoordinate("z", ez); + aCoordinate("t", et); + Object.freeze(this); + } + get x() { + return this.toAffine().x; + } + get y() { + return this.toAffine().y; + } + static fromAffine(p) { + if (p instanceof Point) + throw new Error("extended point not allowed"); + const { x, y } = p || {}; + aCoordinate("x", x); + aCoordinate("y", y); + return new Point(x, y, _1n, modP(x * y)); + } + static normalizeZ(points) { + const toInv = Fp2.invertBatch(points.map((p) => p.ez)); + return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine); + } + // Multiscalar Multiplication + static msm(points, scalars) { + return pippenger(Point, Fn, points, scalars); + } + // "Private method", don't use it directly + _setWindowSize(windowSize) { + wnaf.setWindowSize(this, windowSize); + } + // Not required for fromHex(), which always creates valid points. + // Could be useful for fromAffine(). + assertValidity() { + assertValidMemo(this); + } + // Compare one point to another. + equals(other) { + assertPoint(other); + const { ex: X1, ey: Y1, ez: Z1 } = this; + const { ex: X2, ey: Y2, ez: Z2 } = other; + const X1Z2 = modP(X1 * Z2); + const X2Z1 = modP(X2 * Z1); + const Y1Z2 = modP(Y1 * Z2); + const Y2Z1 = modP(Y2 * Z1); + return X1Z2 === X2Z1 && Y1Z2 === Y2Z1; + } + is0() { + return this.equals(Point.ZERO); + } + negate() { + return new Point(modP(-this.ex), this.ey, this.ez, modP(-this.et)); + } + // Fast algo for doubling Extended Point. + // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd + // Cost: 4M + 4S + 1*a + 6add + 1*2. + double() { + const { a } = CURVE; + const { ex: X1, ey: Y1, ez: Z1 } = this; + const A = modP(X1 * X1); + const B = modP(Y1 * Y1); + const C = modP(_2n * modP(Z1 * Z1)); + const D = modP(a * A); + const x1y1 = X1 + Y1; + const E = modP(modP(x1y1 * x1y1) - A - B); + const G2 = D + B; + const F = G2 - C; + const H = D - B; + const X3 = modP(E * F); + const Y3 = modP(G2 * H); + const T3 = modP(E * H); + const Z3 = modP(F * G2); + return new Point(X3, Y3, Z3, T3); + } + // Fast algo for adding 2 Extended Points. + // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd + // Cost: 9M + 1*a + 1*d + 7add. + add(other) { + assertPoint(other); + const { a, d } = CURVE; + const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this; + const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other; + if (a === BigInt(-1)) { + const A2 = modP((Y1 - X1) * (Y2 + X2)); + const B2 = modP((Y1 + X1) * (Y2 - X2)); + const F2 = modP(B2 - A2); + if (F2 === _0n) + return this.double(); + const C2 = modP(Z1 * _2n * T2); + const D2 = modP(T1 * _2n * Z2); + const E2 = D2 + C2; + const G3 = B2 + A2; + const H2 = D2 - C2; + const X32 = modP(E2 * F2); + const Y32 = modP(G3 * H2); + const T32 = modP(E2 * H2); + const Z32 = modP(F2 * G3); + return new Point(X32, Y32, Z32, T32); + } + const A = modP(X1 * X2); + const B = modP(Y1 * Y2); + const C = modP(T1 * d * T2); + const D = modP(Z1 * Z2); + const E = modP((X1 + Y1) * (X2 + Y2) - A - B); + const F = D - C; + const G2 = D + C; + const H = modP(B - a * A); + const X3 = modP(E * F); + const Y3 = modP(G2 * H); + const T3 = modP(E * H); + const Z3 = modP(F * G2); + return new Point(X3, Y3, Z3, T3); + } + subtract(other) { + return this.add(other.negate()); + } + wNAF(n) { + return wnaf.wNAFCached(this, n, Point.normalizeZ); + } + // Constant-time multiplication. + multiply(scalar) { + const n = scalar; + aInRange("scalar", n, _1n, CURVE_ORDER); + const { p, f } = this.wNAF(n); + return Point.normalizeZ([p, f])[0]; + } + // Non-constant-time multiplication. Uses double-and-add algorithm. + // It's faster, but should only be used when you don't care about + // an exposed private key e.g. sig verification. + // Does NOT allow scalars higher than CURVE.n. + multiplyUnsafe(scalar) { + const n = scalar; + aInRange("scalar", n, _0n, CURVE_ORDER); + if (n === _0n) + return I; + if (this.equals(I) || n === _1n) + return this; + if (this.equals(G)) + return this.wNAF(n).p; + return wnaf.unsafeLadder(this, n); + } + // Checks if point is of small order. + // If you add something to small order point, you will have "dirty" + // point with torsion component. + // Multiplies point by cofactor and checks if the result is 0. + isSmallOrder() { + return this.multiplyUnsafe(cofactor).is0(); + } + // Multiplies point by curve order and checks if the result is 0. + // Returns `false` is the point is dirty. + isTorsionFree() { + return wnaf.unsafeLadder(this, CURVE_ORDER).is0(); + } + // Converts Extended point to default (x, y) coordinates. + // Can accept precomputed Z^-1 - for example, from invertBatch. + toAffine(iz) { + return toAffineMemo(this, iz); + } + clearCofactor() { + const { h: cofactor2 } = CURVE; + if (cofactor2 === _1n) + return this; + return this.multiplyUnsafe(cofactor2); + } + // Converts hash string or Uint8Array to Point. + // Uses algo from RFC8032 5.1.3. + static fromHex(hex, zip215 = false) { + const { d, a } = CURVE; + const len = Fp2.BYTES; + hex = ensureBytes("pointHex", hex, len); + abool("zip215", zip215); + const normed = hex.slice(); + const lastByte = hex[len - 1]; + normed[len - 1] = lastByte & ~128; + const y = bytesToNumberLE(normed); + const max = zip215 ? MASK : Fp2.ORDER; + aInRange("pointHex.y", y, _0n, max); + const y2 = modP(y * y); + const u = modP(y2 - _1n); + const v = modP(d * y2 - a); + let { isValid, value: x } = uvRatio2(u, v); + if (!isValid) + throw new Error("Point.fromHex: invalid y coordinate"); + const isXOdd = (x & _1n) === _1n; + const isLastByteOdd = (lastByte & 128) !== 0; + if (!zip215 && x === _0n && isLastByteOdd) + throw new Error("Point.fromHex: x=0 and x_0=1"); + if (isLastByteOdd !== isXOdd) + x = modP(-x); + return Point.fromAffine({ x, y }); + } + static fromPrivateKey(privKey) { + return getExtendedPublicKey(privKey).point; + } + toRawBytes() { + const { x, y } = this.toAffine(); + const bytes = numberToBytesLE(y, Fp2.BYTES); + bytes[bytes.length - 1] |= x & _1n ? 128 : 0; + return bytes; + } + toHex() { + return bytesToHex(this.toRawBytes()); + } + } + Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n, modP(CURVE.Gx * CURVE.Gy)); + Point.ZERO = new Point(_0n, _1n, _1n, _0n); + const { BASE: G, ZERO: I } = Point; + const wnaf = wNAF(Point, nByteLength * 8); + function modN(a) { + return mod(a, CURVE_ORDER); + } + function modN_LE(hash2) { + return modN(bytesToNumberLE(hash2)); + } + function getExtendedPublicKey(key) { + const len = nByteLength; + key = ensureBytes("private key", key, len); + const hashed = ensureBytes("hashed private key", cHash(key), 2 * len); + const head = adjustScalarBytes2(hashed.slice(0, len)); + const prefix = hashed.slice(len, 2 * len); + const scalar = modN_LE(head); + const point = G.multiply(scalar); + const pointBytes = point.toRawBytes(); + return { head, prefix, scalar, point, pointBytes }; + } + function getPublicKey(privKey) { + return getExtendedPublicKey(privKey).pointBytes; + } + function hashDomainToScalar(context = new Uint8Array(), ...msgs) { + const msg = concatBytes2(...msgs); + return modN_LE(cHash(domain(msg, ensureBytes("context", context), !!prehash))); + } + function sign(msg, privKey, options = {}) { + msg = ensureBytes("message", msg); + if (prehash) + msg = prehash(msg); + const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey); + const r = hashDomainToScalar(options.context, prefix, msg); + const R = G.multiply(r).toRawBytes(); + const k = hashDomainToScalar(options.context, R, pointBytes, msg); + const s = modN(r + k * scalar); + aInRange("signature.s", s, _0n, CURVE_ORDER); + const res = concatBytes2(R, numberToBytesLE(s, Fp2.BYTES)); + return ensureBytes("result", res, nByteLength * 2); + } + const verifyOpts = VERIFY_DEFAULT; + function verify2(sig, msg, publicKey, options = verifyOpts) { + const { context, zip215 } = options; + const len = Fp2.BYTES; + sig = ensureBytes("signature", sig, 2 * len); + msg = ensureBytes("message", msg); + if (zip215 !== void 0) + abool("zip215", zip215); + if (prehash) + msg = prehash(msg); + const s = bytesToNumberLE(sig.slice(len, 2 * len)); + let A, R, SB; + try { + A = Point.fromHex(publicKey, zip215); + R = Point.fromHex(sig.slice(0, len), zip215); + SB = G.multiplyUnsafe(s); + } catch (error) { + return false; + } + if (!zip215 && A.isSmallOrder()) + return false; + const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg); + const RkA = R.add(A.multiplyUnsafe(k)); + return RkA.subtract(SB).clearCofactor().equals(Point.ZERO); + } + G._setWindowSize(8); + const utils = { + getExtendedPublicKey, + // ed25519 private keys are uniform 32b. No need to check for modulo bias, like in secp256k1. + randomPrivateKey: () => randomBytes2(Fp2.BYTES), + /** + * We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT + * values. This slows down first getPublicKey() by milliseconds (see Speed section), + * but allows to speed-up subsequent getPublicKey() calls up to 20x. + * @param windowSize 2, 4, 8, 16 + */ + precompute(windowSize = 8, point = Point.BASE) { + point._setWindowSize(windowSize); + point.multiply(BigInt(3)); + return point; + } + }; + return { + CURVE, + getPublicKey, + sign, + verify: verify2, + ExtendedPoint: Point, + utils + }; +} + +// ../../node_modules/@noble/curves/esm/abstract/montgomery.js +var _0n2 = BigInt(0); +var _1n2 = BigInt(1); +function validateOpts2(curve) { + validateObject(curve, { + a: "bigint" + }, { + montgomeryBits: "isSafeInteger", + nByteLength: "isSafeInteger", + adjustScalarBytes: "function", + domain: "function", + powPminus2: "function", + Gu: "bigint" + }); + return Object.freeze({ ...curve }); +} +function montgomery(curveDef) { + const CURVE = validateOpts2(curveDef); + const { P } = CURVE; + const modP = (n) => mod(n, P); + const montgomeryBits = CURVE.montgomeryBits; + const montgomeryBytes = Math.ceil(montgomeryBits / 8); + const fieldLen = CURVE.nByteLength; + const adjustScalarBytes2 = CURVE.adjustScalarBytes || ((bytes) => bytes); + const powPminus2 = CURVE.powPminus2 || ((x) => pow(x, P - BigInt(2), P)); + function cswap(swap, x_2, x_3) { + const dummy = modP(swap * (x_2 - x_3)); + x_2 = modP(x_2 - dummy); + x_3 = modP(x_3 + dummy); + return [x_2, x_3]; + } + const a24 = (CURVE.a - BigInt(2)) / BigInt(4); + function montgomeryLadder(u, scalar) { + aInRange("u", u, _0n2, P); + aInRange("scalar", scalar, _0n2, P); + const k = scalar; + const x_1 = u; + let x_2 = _1n2; + let z_2 = _0n2; + let x_3 = u; + let z_3 = _1n2; + let swap = _0n2; + let sw; + for (let t = BigInt(montgomeryBits - 1); t >= _0n2; t--) { + const k_t = k >> t & _1n2; + swap ^= k_t; + sw = cswap(swap, x_2, x_3); + x_2 = sw[0]; + x_3 = sw[1]; + sw = cswap(swap, z_2, z_3); + z_2 = sw[0]; + z_3 = sw[1]; + swap = k_t; + const A = x_2 + z_2; + const AA = modP(A * A); + const B = x_2 - z_2; + const BB = modP(B * B); + const E = AA - BB; + const C = x_3 + z_3; + const D = x_3 - z_3; + const DA = modP(D * A); + const CB = modP(C * B); + const dacb = DA + CB; + const da_cb = DA - CB; + x_3 = modP(dacb * dacb); + z_3 = modP(x_1 * modP(da_cb * da_cb)); + x_2 = modP(AA * BB); + z_2 = modP(E * (AA + modP(a24 * E))); + } + sw = cswap(swap, x_2, x_3); + x_2 = sw[0]; + x_3 = sw[1]; + sw = cswap(swap, z_2, z_3); + z_2 = sw[0]; + z_3 = sw[1]; + const z2 = powPminus2(z_2); + return modP(x_2 * z2); + } + function encodeUCoordinate(u) { + return numberToBytesLE(modP(u), montgomeryBytes); + } + function decodeUCoordinate(uEnc) { + const u = ensureBytes("u coordinate", uEnc, montgomeryBytes); + if (fieldLen === 32) + u[31] &= 127; + return bytesToNumberLE(u); + } + function decodeScalar(n) { + const bytes = ensureBytes("scalar", n); + const len = bytes.length; + if (len !== montgomeryBytes && len !== fieldLen) + throw new Error(`Expected ${montgomeryBytes} or ${fieldLen} bytes, got ${len}`); + return bytesToNumberLE(adjustScalarBytes2(bytes)); + } + function scalarMult(scalar, u) { + const pointU = decodeUCoordinate(u); + const _scalar = decodeScalar(scalar); + const pu = montgomeryLadder(pointU, _scalar); + if (pu === _0n2) + throw new Error("Invalid private or public key received"); + return encodeUCoordinate(pu); + } + const GuBytes = encodeUCoordinate(CURVE.Gu); + function scalarMultBase(scalar) { + return scalarMult(scalar, GuBytes); + } + return { + scalarMult, + scalarMultBase, + getSharedSecret: (privateKey, publicKey) => scalarMult(privateKey, publicKey), + getPublicKey: (privateKey) => scalarMultBase(privateKey), + utils: { randomPrivateKey: () => CURVE.randomBytes(CURVE.nByteLength) }, + GuBytes + }; +} + +// ../../node_modules/@noble/curves/esm/ed25519.js +var ED25519_P = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819949"); +var ED25519_SQRT_M1 = BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752"); +var _0n3 = BigInt(0); +var _1n3 = BigInt(1); +var _2n2 = BigInt(2); +var _3n = BigInt(3); +var _5n = BigInt(5); +var _8n2 = BigInt(8); +function ed25519_pow_2_252_3(x) { + const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80); + const P = ED25519_P; + const x2 = x * x % P; + const b2 = x2 * x % P; + const b4 = pow2(b2, _2n2, P) * b2 % P; + const b5 = pow2(b4, _1n3, P) * x % P; + const b10 = pow2(b5, _5n, P) * b5 % P; + const b20 = pow2(b10, _10n, P) * b10 % P; + const b40 = pow2(b20, _20n, P) * b20 % P; + const b80 = pow2(b40, _40n, P) * b40 % P; + const b160 = pow2(b80, _80n, P) * b80 % P; + const b240 = pow2(b160, _80n, P) * b80 % P; + const b250 = pow2(b240, _10n, P) * b10 % P; + const pow_p_5_8 = pow2(b250, _2n2, P) * x % P; + return { pow_p_5_8, b2 }; +} +function adjustScalarBytes(bytes) { + bytes[0] &= 248; + bytes[31] &= 127; + bytes[31] |= 64; + return bytes; +} +function uvRatio(u, v) { + const P = ED25519_P; + const v3 = mod(v * v * v, P); + const v7 = mod(v3 * v3 * v, P); + const pow3 = ed25519_pow_2_252_3(u * v7).pow_p_5_8; + let x = mod(u * v3 * pow3, P); + const vx2 = mod(v * x * x, P); + const root1 = x; + const root2 = mod(x * ED25519_SQRT_M1, P); + const useRoot1 = vx2 === u; + const useRoot2 = vx2 === mod(-u, P); + const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P); + if (useRoot1) + x = root1; + if (useRoot2 || noRoot) + x = root2; + if (isNegativeLE(x, P)) + x = mod(-x, P); + return { isValid: useRoot1 || useRoot2, value: x }; +} +var Fp = (() => Field(ED25519_P, void 0, true))(); +var ed25519Defaults = (() => ({ + // Param: a + a: BigInt(-1), + // Fp.create(-1) is proper; our way still works and is faster + // d is equal to -121665/121666 over finite field. + // Negative number is P - number, and division is invert(number, P) + d: BigInt("37095705934669439343138083508754565189542113879843219016388785533085940283555"), + // Finite field 𝔽p over which we'll do calculations; 2n**255n - 19n + Fp, + // Subgroup order: how many points curve has + // 2n**252n + 27742317777372353535851937790883648493n; + n: BigInt("7237005577332262213973186563042994240857116359379907606001950938285454250989"), + // Cofactor + h: _8n2, + // Base point (x, y) aka generator point + Gx: BigInt("15112221349535400772501151409588531511454012693041857206046113283949847762202"), + Gy: BigInt("46316835694926478169428394003475163141307993866256225615783033603165251855960"), + hash: sha512, + randomBytes, + adjustScalarBytes, + // dom2 + // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3. + // Constant-time, u/√v + uvRatio +}))(); +var ed25519 = (() => twistedEdwards(ed25519Defaults))(); +function ed25519_domain(data, ctx, phflag) { + if (ctx.length > 255) + throw new Error("Context is too big"); + return concatBytes(utf8ToBytes("SigEd25519 no Ed25519 collisions"), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data); +} +var ed25519ctx = (() => twistedEdwards({ + ...ed25519Defaults, + domain: ed25519_domain +}))(); +var ed25519ph = (() => twistedEdwards(Object.assign({}, ed25519Defaults, { + domain: ed25519_domain, + prehash: sha512 +})))(); +var x25519 = (() => montgomery({ + P: ED25519_P, + a: BigInt(486662), + montgomeryBits: 255, + // n is 253 bits + nByteLength: 32, + Gu: BigInt(9), + powPminus2: (x) => { + const P = ED25519_P; + const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x); + return mod(pow2(pow_p_5_8, _3n, P) * b2, P); + }, + adjustScalarBytes, + randomBytes +}))(); +var ELL2_C1 = (() => (Fp.ORDER + _3n) / _8n2)(); +var ELL2_C2 = (() => Fp.pow(_2n2, ELL2_C1))(); +var ELL2_C3 = (() => Fp.sqrt(Fp.neg(Fp.ONE)))(); +function map_to_curve_elligator2_curve25519(u) { + const ELL2_C4 = (Fp.ORDER - _5n) / _8n2; + const ELL2_J = BigInt(486662); + let tv1 = Fp.sqr(u); + tv1 = Fp.mul(tv1, _2n2); + let xd = Fp.add(tv1, Fp.ONE); + let x1n = Fp.neg(ELL2_J); + let tv2 = Fp.sqr(xd); + let gxd = Fp.mul(tv2, xd); + let gx1 = Fp.mul(tv1, ELL2_J); + gx1 = Fp.mul(gx1, x1n); + gx1 = Fp.add(gx1, tv2); + gx1 = Fp.mul(gx1, x1n); + let tv3 = Fp.sqr(gxd); + tv2 = Fp.sqr(tv3); + tv3 = Fp.mul(tv3, gxd); + tv3 = Fp.mul(tv3, gx1); + tv2 = Fp.mul(tv2, tv3); + let y11 = Fp.pow(tv2, ELL2_C4); + y11 = Fp.mul(y11, tv3); + let y12 = Fp.mul(y11, ELL2_C3); + tv2 = Fp.sqr(y11); + tv2 = Fp.mul(tv2, gxd); + let e1 = Fp.eql(tv2, gx1); + let y1 = Fp.cmov(y12, y11, e1); + let x2n = Fp.mul(x1n, tv1); + let y21 = Fp.mul(y11, u); + y21 = Fp.mul(y21, ELL2_C2); + let y22 = Fp.mul(y21, ELL2_C3); + let gx2 = Fp.mul(gx1, tv1); + tv2 = Fp.sqr(y21); + tv2 = Fp.mul(tv2, gxd); + let e2 = Fp.eql(tv2, gx2); + let y2 = Fp.cmov(y22, y21, e2); + tv2 = Fp.sqr(y1); + tv2 = Fp.mul(tv2, gxd); + let e3 = Fp.eql(tv2, gx1); + let xn = Fp.cmov(x2n, x1n, e3); + let y = Fp.cmov(y2, y1, e3); + let e4 = Fp.isOdd(y); + y = Fp.cmov(y, Fp.neg(y), e3 !== e4); + return { xMn: xn, xMd: xd, yMn: y, yMd: _1n3 }; +} +var ELL2_C1_EDWARDS = (() => FpSqrtEven(Fp, Fp.neg(BigInt(486664))))(); +function map_to_curve_elligator2_edwards25519(u) { + const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u); + let xn = Fp.mul(xMn, yMd); + xn = Fp.mul(xn, ELL2_C1_EDWARDS); + let xd = Fp.mul(xMd, yMn); + let yn = Fp.sub(xMn, xMd); + let yd = Fp.add(xMn, xMd); + let tv1 = Fp.mul(xd, yd); + let e = Fp.eql(tv1, Fp.ZERO); + xn = Fp.cmov(xn, Fp.ZERO, e); + xd = Fp.cmov(xd, Fp.ONE, e); + yn = Fp.cmov(yn, Fp.ONE, e); + yd = Fp.cmov(yd, Fp.ONE, e); + const inv = Fp.invertBatch([xd, yd]); + return { x: Fp.mul(xn, inv[0]), y: Fp.mul(yn, inv[1]) }; +} +var htf = (() => createHasher(ed25519.ExtendedPoint, (scalars) => map_to_curve_elligator2_edwards25519(scalars[0]), { + DST: "edwards25519_XMD:SHA-512_ELL2_RO_", + encodeDST: "edwards25519_XMD:SHA-512_ELL2_NU_", + p: Fp.ORDER, + m: 1, + k: 128, + expand: "xmd", + hash: sha512 +}))(); +var hashToCurve = (() => htf.hashToCurve)(); +var encodeToCurve = (() => htf.encodeToCurve)(); +function assertRstPoint(other) { + if (!(other instanceof RistPoint)) + throw new Error("RistrettoPoint expected"); +} +var SQRT_M1 = ED25519_SQRT_M1; +var SQRT_AD_MINUS_ONE = BigInt("25063068953384623474111414158702152701244531502492656460079210482610430750235"); +var INVSQRT_A_MINUS_D = BigInt("54469307008909316920995813868745141605393597292927456921205312896311721017578"); +var ONE_MINUS_D_SQ = BigInt("1159843021668779879193775521855586647937357759715417654439879720876111806838"); +var D_MINUS_ONE_SQ = BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952"); +var invertSqrt = (number) => uvRatio(_1n3, number); +var MAX_255B = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); +var bytes255ToNumberLE = (bytes) => ed25519.CURVE.Fp.create(bytesToNumberLE(bytes) & MAX_255B); +function calcElligatorRistrettoMap(r0) { + const { d } = ed25519.CURVE; + const P = ed25519.CURVE.Fp.ORDER; + const mod2 = ed25519.CURVE.Fp.create; + const r = mod2(SQRT_M1 * r0 * r0); + const Ns = mod2((r + _1n3) * ONE_MINUS_D_SQ); + let c = BigInt(-1); + const D = mod2((c - d * r) * mod2(r + d)); + let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D); + let s_ = mod2(s * r0); + if (!isNegativeLE(s_, P)) + s_ = mod2(-s_); + if (!Ns_D_is_sq) + s = s_; + if (!Ns_D_is_sq) + c = r; + const Nt = mod2(c * (r - _1n3) * D_MINUS_ONE_SQ - D); + const s2 = s * s; + const W0 = mod2((s + s) * D); + const W1 = mod2(Nt * SQRT_AD_MINUS_ONE); + const W2 = mod2(_1n3 - s2); + const W3 = mod2(_1n3 + s2); + return new ed25519.ExtendedPoint(mod2(W0 * W3), mod2(W2 * W1), mod2(W1 * W3), mod2(W0 * W2)); +} +var RistPoint = class _RistPoint { + // Private property to discourage combining ExtendedPoint + RistrettoPoint + // Always use Ristretto encoding/decoding instead. + constructor(ep) { + this.ep = ep; + } + static fromAffine(ap) { + return new _RistPoint(ed25519.ExtendedPoint.fromAffine(ap)); + } + /** + * Takes uniform output of 64-byte hash function like sha512 and converts it to `RistrettoPoint`. + * The hash-to-group operation applies Elligator twice and adds the results. + * **Note:** this is one-way map, there is no conversion from point to hash. + * https://ristretto.group/formulas/elligator.html + * @param hex 64-byte output of a hash function + */ + static hashToCurve(hex) { + hex = ensureBytes("ristrettoHash", hex, 64); + const r1 = bytes255ToNumberLE(hex.slice(0, 32)); + const R1 = calcElligatorRistrettoMap(r1); + const r2 = bytes255ToNumberLE(hex.slice(32, 64)); + const R2 = calcElligatorRistrettoMap(r2); + return new _RistPoint(R1.add(R2)); + } + /** + * Converts ristretto-encoded string to ristretto point. + * https://ristretto.group/formulas/decoding.html + * @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding + */ + static fromHex(hex) { + hex = ensureBytes("ristrettoHex", hex, 32); + const { a, d } = ed25519.CURVE; + const P = ed25519.CURVE.Fp.ORDER; + const mod2 = ed25519.CURVE.Fp.create; + const emsg = "RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint"; + const s = bytes255ToNumberLE(hex); + if (!equalBytes(numberToBytesLE(s, 32), hex) || isNegativeLE(s, P)) + throw new Error(emsg); + const s2 = mod2(s * s); + const u1 = mod2(_1n3 + a * s2); + const u2 = mod2(_1n3 - a * s2); + const u1_2 = mod2(u1 * u1); + const u2_2 = mod2(u2 * u2); + const v = mod2(a * d * u1_2 - u2_2); + const { isValid, value: I } = invertSqrt(mod2(v * u2_2)); + const Dx = mod2(I * u2); + const Dy = mod2(I * Dx * v); + let x = mod2((s + s) * Dx); + if (isNegativeLE(x, P)) + x = mod2(-x); + const y = mod2(u1 * Dy); + const t = mod2(x * y); + if (!isValid || isNegativeLE(t, P) || y === _0n3) + throw new Error(emsg); + return new _RistPoint(new ed25519.ExtendedPoint(x, y, _1n3, t)); + } + /** + * Encodes ristretto point to Uint8Array. + * https://ristretto.group/formulas/encoding.html + */ + toRawBytes() { + let { ex: x, ey: y, ez: z, et: t } = this.ep; + const P = ed25519.CURVE.Fp.ORDER; + const mod2 = ed25519.CURVE.Fp.create; + const u1 = mod2(mod2(z + y) * mod2(z - y)); + const u2 = mod2(x * y); + const u2sq = mod2(u2 * u2); + const { value: invsqrt } = invertSqrt(mod2(u1 * u2sq)); + const D1 = mod2(invsqrt * u1); + const D2 = mod2(invsqrt * u2); + const zInv = mod2(D1 * D2 * t); + let D; + if (isNegativeLE(t * zInv, P)) { + let _x = mod2(y * SQRT_M1); + let _y = mod2(x * SQRT_M1); + x = _x; + y = _y; + D = mod2(D1 * INVSQRT_A_MINUS_D); + } else { + D = D2; + } + if (isNegativeLE(x * zInv, P)) + y = mod2(-y); + let s = mod2((z - y) * D); + if (isNegativeLE(s, P)) + s = mod2(-s); + return numberToBytesLE(s, 32); + } + toHex() { + return bytesToHex(this.toRawBytes()); + } + toString() { + return this.toHex(); + } + // Compare one point to another. + equals(other) { + assertRstPoint(other); + const { ex: X1, ey: Y1 } = this.ep; + const { ex: X2, ey: Y2 } = other.ep; + const mod2 = ed25519.CURVE.Fp.create; + const one = mod2(X1 * Y2) === mod2(Y1 * X2); + const two = mod2(Y1 * Y2) === mod2(X1 * X2); + return one || two; + } + add(other) { + assertRstPoint(other); + return new _RistPoint(this.ep.add(other.ep)); + } + subtract(other) { + assertRstPoint(other); + return new _RistPoint(this.ep.subtract(other.ep)); + } + multiply(scalar) { + return new _RistPoint(this.ep.multiply(scalar)); + } + multiplyUnsafe(scalar) { + return new _RistPoint(this.ep.multiplyUnsafe(scalar)); + } + double() { + return new _RistPoint(this.ep.double()); + } + negate() { + return new _RistPoint(this.ep.negate()); + } +}; +var RistrettoPoint = (() => { + if (!RistPoint.BASE) + RistPoint.BASE = new RistPoint(ed25519.ExtendedPoint.BASE); + if (!RistPoint.ZERO) + RistPoint.ZERO = new RistPoint(ed25519.ExtendedPoint.ZERO); + return RistPoint; +})(); + +// ../../node_modules/@dfinity/agent/lib/esm/utils/expirableMap.js +var __classPrivateFieldSet = function(receiver, state, value2, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value2) : f ? f.value = value2 : state.set(receiver, value2), value2; +}; +var __classPrivateFieldGet = function(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _ExpirableMap_inner; +var _ExpirableMap_expirationTime; +var _a; +var _b; +var ExpirableMap = class { + /** + * Create a new ExpirableMap. + * @param {ExpirableMapOptions} options - options for the map. + * @param {Iterable<[any, any]>} options.source - an optional source of entries to initialize the map with. + * @param {number} options.expirationTime - the time in milliseconds after which entries will expire. + */ + constructor(options = {}) { + _ExpirableMap_inner.set(this, void 0); + _ExpirableMap_expirationTime.set(this, void 0); + this[_a] = this.entries.bind(this); + this[_b] = "ExpirableMap"; + const { source = [], expirationTime = 10 * 60 * 1e3 } = options; + const currentTime = Date.now(); + __classPrivateFieldSet(this, _ExpirableMap_inner, new Map([...source].map(([key, value2]) => [key, { value: value2, timestamp: currentTime }])), "f"); + __classPrivateFieldSet(this, _ExpirableMap_expirationTime, expirationTime, "f"); + } + /** + * Prune removes all expired entries. + */ + prune() { + const currentTime = Date.now(); + for (const [key, entry] of __classPrivateFieldGet(this, _ExpirableMap_inner, "f").entries()) { + if (currentTime - entry.timestamp > __classPrivateFieldGet(this, _ExpirableMap_expirationTime, "f")) { + __classPrivateFieldGet(this, _ExpirableMap_inner, "f").delete(key); + } + } + return this; + } + // Implementing the Map interface + /** + * Set the value for the given key. Prunes expired entries. + * @param key for the entry + * @param value of the entry + * @returns this + */ + set(key, value2) { + this.prune(); + const entry = { + value: value2, + timestamp: Date.now() + }; + __classPrivateFieldGet(this, _ExpirableMap_inner, "f").set(key, entry); + return this; + } + /** + * Get the value associated with the key, if it exists and has not expired. + * @param key K + * @returns the value associated with the key, or undefined if the key is not present or has expired. + */ + get(key) { + const entry = __classPrivateFieldGet(this, _ExpirableMap_inner, "f").get(key); + if (entry === void 0) { + return void 0; + } + if (Date.now() - entry.timestamp > __classPrivateFieldGet(this, _ExpirableMap_expirationTime, "f")) { + __classPrivateFieldGet(this, _ExpirableMap_inner, "f").delete(key); + return void 0; + } + return entry.value; + } + /** + * Clear all entries. + */ + clear() { + __classPrivateFieldGet(this, _ExpirableMap_inner, "f").clear(); + } + /** + * Entries returns the entries of the map, without the expiration time. + * @returns an iterator over the entries of the map. + */ + entries() { + const iterator = __classPrivateFieldGet(this, _ExpirableMap_inner, "f").entries(); + const generator = function* () { + for (const [key, value2] of iterator) { + yield [key, value2.value]; + } + }; + return generator(); + } + /** + * Values returns the values of the map, without the expiration time. + * @returns an iterator over the values of the map. + */ + values() { + const iterator = __classPrivateFieldGet(this, _ExpirableMap_inner, "f").values(); + const generator = function* () { + for (const value2 of iterator) { + yield value2.value; + } + }; + return generator(); + } + /** + * Keys returns the keys of the map + * @returns an iterator over the keys of the map. + */ + keys() { + return __classPrivateFieldGet(this, _ExpirableMap_inner, "f").keys(); + } + /** + * forEach calls the callbackfn on each entry of the map. + * @param callbackfn to call on each entry + * @param thisArg to use as this when calling the callbackfn + */ + forEach(callbackfn, thisArg) { + for (const [key, value2] of __classPrivateFieldGet(this, _ExpirableMap_inner, "f").entries()) { + callbackfn.call(thisArg, value2.value, key, this); + } + } + /** + * has returns true if the key exists and has not expired. + * @param key K + * @returns true if the key exists and has not expired. + */ + has(key) { + return __classPrivateFieldGet(this, _ExpirableMap_inner, "f").has(key); + } + /** + * delete the entry for the given key. + * @param key K + * @returns true if the key existed and has been deleted. + */ + delete(key) { + return __classPrivateFieldGet(this, _ExpirableMap_inner, "f").delete(key); + } + /** + * get size of the map. + * @returns the size of the map. + */ + get size() { + return __classPrivateFieldGet(this, _ExpirableMap_inner, "f").size; + } +}; +_ExpirableMap_inner = /* @__PURE__ */ new WeakMap(), _ExpirableMap_expirationTime = /* @__PURE__ */ new WeakMap(), _a = Symbol.iterator, _b = Symbol.toStringTag; + +// ../../node_modules/@dfinity/agent/lib/esm/der.js +var encodeLenBytes = (len) => { + if (len <= 127) { + return 1; + } else if (len <= 255) { + return 2; + } else if (len <= 65535) { + return 3; + } else if (len <= 16777215) { + return 4; + } else { + throw new Error("Length too long (> 4 bytes)"); + } +}; +var encodeLen = (buf, offset, len) => { + if (len <= 127) { + buf[offset] = len; + return 1; + } else if (len <= 255) { + buf[offset] = 129; + buf[offset + 1] = len; + return 2; + } else if (len <= 65535) { + buf[offset] = 130; + buf[offset + 1] = len >> 8; + buf[offset + 2] = len; + return 3; + } else if (len <= 16777215) { + buf[offset] = 131; + buf[offset + 1] = len >> 16; + buf[offset + 2] = len >> 8; + buf[offset + 3] = len; + return 4; + } else { + throw new Error("Length too long (> 4 bytes)"); + } +}; +var decodeLenBytes = (buf, offset) => { + if (buf[offset] < 128) + return 1; + if (buf[offset] === 128) + throw new Error("Invalid length 0"); + if (buf[offset] === 129) + return 2; + if (buf[offset] === 130) + return 3; + if (buf[offset] === 131) + return 4; + throw new Error("Length too long (> 4 bytes)"); +}; +var decodeLen = (buf, offset) => { + const lenBytes = decodeLenBytes(buf, offset); + if (lenBytes === 1) + return buf[offset]; + else if (lenBytes === 2) + return buf[offset + 1]; + else if (lenBytes === 3) + return (buf[offset + 1] << 8) + buf[offset + 2]; + else if (lenBytes === 4) + return (buf[offset + 1] << 16) + (buf[offset + 2] << 8) + buf[offset + 3]; + throw new Error("Length too long (> 4 bytes)"); +}; +var DER_COSE_OID = Uint8Array.from([ + ...[48, 12], + ...[6, 10], + ...[43, 6, 1, 4, 1, 131, 184, 67, 1, 1] + // DER encoded COSE +]); +var ED25519_OID = Uint8Array.from([ + ...[48, 5], + ...[6, 3], + ...[43, 101, 112] + // id-Ed25519 OID +]); +var SECP256K1_OID = Uint8Array.from([ + ...[48, 16], + ...[6, 7], + ...[42, 134, 72, 206, 61, 2, 1], + ...[6, 5], + ...[43, 129, 4, 0, 10] + // OID secp256k1 +]); +function wrapDER(payload, oid) { + const bitStringHeaderLength = 2 + encodeLenBytes(payload.byteLength + 1); + const len = oid.byteLength + bitStringHeaderLength + payload.byteLength; + let offset = 0; + const buf = new Uint8Array(1 + encodeLenBytes(len) + len); + buf[offset++] = 48; + offset += encodeLen(buf, offset, len); + buf.set(oid, offset); + offset += oid.byteLength; + buf[offset++] = 3; + offset += encodeLen(buf, offset, payload.byteLength + 1); + buf[offset++] = 0; + buf.set(new Uint8Array(payload), offset); + return buf; +} +var unwrapDER = (derEncoded, oid) => { + let offset = 0; + const expect = (n, msg) => { + if (buf[offset++] !== n) { + throw new Error("Expected: " + msg); + } + }; + const buf = new Uint8Array(derEncoded); + expect(48, "sequence"); + offset += decodeLenBytes(buf, offset); + if (!bufEquals(buf.slice(offset, offset + oid.byteLength), oid)) { + throw new Error("Not the expected OID."); + } + offset += oid.byteLength; + expect(3, "bit string"); + const payloadLen = decodeLen(buf, offset) - 1; + offset += decodeLenBytes(buf, offset); + expect(0, "0 padding"); + const result = buf.slice(offset); + if (payloadLen !== result.length) { + throw new Error(`DER payload mismatch: Expected length ${payloadLen} actual length ${result.length}`); + } + return result; +}; + +// ../../node_modules/@dfinity/agent/lib/esm/public_key.js +var __classPrivateFieldSet2 = function(receiver, state, value2, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value2) : f ? f.value = value2 : state.set(receiver, value2), value2; +}; +var __classPrivateFieldGet2 = function(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _Ed25519PublicKey_rawKey; +var _Ed25519PublicKey_derKey; +var Ed25519PublicKey = class _Ed25519PublicKey { + // `fromRaw` and `fromDer` should be used for instantiation, not this constructor. + constructor(key) { + _Ed25519PublicKey_rawKey.set(this, void 0); + _Ed25519PublicKey_derKey.set(this, void 0); + if (key.byteLength !== _Ed25519PublicKey.RAW_KEY_LENGTH) { + throw new Error("An Ed25519 public key must be exactly 32bytes long"); + } + __classPrivateFieldSet2(this, _Ed25519PublicKey_rawKey, key, "f"); + __classPrivateFieldSet2(this, _Ed25519PublicKey_derKey, _Ed25519PublicKey.derEncode(key), "f"); + } + static from(key) { + return this.fromDer(key.toDer()); + } + static fromRaw(rawKey) { + return new _Ed25519PublicKey(rawKey); + } + static fromDer(derKey) { + return new _Ed25519PublicKey(this.derDecode(derKey)); + } + static derEncode(publicKey) { + return wrapDER(publicKey, ED25519_OID).buffer; + } + static derDecode(key) { + const unwrapped = unwrapDER(key, ED25519_OID); + if (unwrapped.length !== this.RAW_KEY_LENGTH) { + throw new Error("An Ed25519 public key must be exactly 32bytes long"); + } + return unwrapped; + } + get rawKey() { + return __classPrivateFieldGet2(this, _Ed25519PublicKey_rawKey, "f"); + } + get derKey() { + return __classPrivateFieldGet2(this, _Ed25519PublicKey_derKey, "f"); + } + toDer() { + return this.derKey; + } + toRaw() { + return this.rawKey; + } +}; +_Ed25519PublicKey_rawKey = /* @__PURE__ */ new WeakMap(), _Ed25519PublicKey_derKey = /* @__PURE__ */ new WeakMap(); +Ed25519PublicKey.RAW_KEY_LENGTH = 32; + +// ../../node_modules/@dfinity/agent/lib/esm/observable.js +var Observable = class { + constructor() { + this.observers = []; + } + subscribe(func) { + this.observers.push(func); + } + unsubscribe(func) { + this.observers = this.observers.filter((observer) => observer !== func); + } + notify(data, ...rest) { + this.observers.forEach((observer) => observer(data, ...rest)); + } +}; +var ObservableLog = class extends Observable { + constructor() { + super(); + } + print(message, ...rest) { + this.notify({ message, level: "info" }, ...rest); + } + warn(message, ...rest) { + this.notify({ message, level: "warn" }, ...rest); + } + error(message, error, ...rest) { + this.notify({ message, level: "error", error }, ...rest); + } +}; + +// ../../node_modules/@dfinity/agent/lib/esm/polling/backoff.js +var __classPrivateFieldSet3 = function(receiver, state, value2, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value2) : f ? f.value = value2 : state.set(receiver, value2), value2; +}; +var __classPrivateFieldGet3 = function(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _ExponentialBackoff_currentInterval; +var _ExponentialBackoff_randomizationFactor; +var _ExponentialBackoff_multiplier; +var _ExponentialBackoff_maxInterval; +var _ExponentialBackoff_startTime; +var _ExponentialBackoff_maxElapsedTime; +var _ExponentialBackoff_maxIterations; +var _ExponentialBackoff_date; +var _ExponentialBackoff_count; +var RANDOMIZATION_FACTOR = 0.5; +var MULTIPLIER = 1.5; +var INITIAL_INTERVAL_MSEC = 500; +var MAX_INTERVAL_MSEC = 6e4; +var MAX_ELAPSED_TIME_MSEC = 9e5; +var MAX_ITERATIONS = 10; +var ExponentialBackoff = class _ExponentialBackoff { + constructor(options = _ExponentialBackoff.default) { + _ExponentialBackoff_currentInterval.set(this, void 0); + _ExponentialBackoff_randomizationFactor.set(this, void 0); + _ExponentialBackoff_multiplier.set(this, void 0); + _ExponentialBackoff_maxInterval.set(this, void 0); + _ExponentialBackoff_startTime.set(this, void 0); + _ExponentialBackoff_maxElapsedTime.set(this, void 0); + _ExponentialBackoff_maxIterations.set(this, void 0); + _ExponentialBackoff_date.set(this, void 0); + _ExponentialBackoff_count.set(this, 0); + const { initialInterval = INITIAL_INTERVAL_MSEC, randomizationFactor = RANDOMIZATION_FACTOR, multiplier = MULTIPLIER, maxInterval = MAX_INTERVAL_MSEC, maxElapsedTime = MAX_ELAPSED_TIME_MSEC, maxIterations = MAX_ITERATIONS, date = Date } = options; + __classPrivateFieldSet3(this, _ExponentialBackoff_currentInterval, initialInterval, "f"); + __classPrivateFieldSet3(this, _ExponentialBackoff_randomizationFactor, randomizationFactor, "f"); + __classPrivateFieldSet3(this, _ExponentialBackoff_multiplier, multiplier, "f"); + __classPrivateFieldSet3(this, _ExponentialBackoff_maxInterval, maxInterval, "f"); + __classPrivateFieldSet3(this, _ExponentialBackoff_date, date, "f"); + __classPrivateFieldSet3(this, _ExponentialBackoff_startTime, date.now(), "f"); + __classPrivateFieldSet3(this, _ExponentialBackoff_maxElapsedTime, maxElapsedTime, "f"); + __classPrivateFieldSet3(this, _ExponentialBackoff_maxIterations, maxIterations, "f"); + } + get ellapsedTimeInMsec() { + return __classPrivateFieldGet3(this, _ExponentialBackoff_date, "f").now() - __classPrivateFieldGet3(this, _ExponentialBackoff_startTime, "f"); + } + get currentInterval() { + return __classPrivateFieldGet3(this, _ExponentialBackoff_currentInterval, "f"); + } + get count() { + return __classPrivateFieldGet3(this, _ExponentialBackoff_count, "f"); + } + get randomValueFromInterval() { + const delta = __classPrivateFieldGet3(this, _ExponentialBackoff_randomizationFactor, "f") * __classPrivateFieldGet3(this, _ExponentialBackoff_currentInterval, "f"); + const min = __classPrivateFieldGet3(this, _ExponentialBackoff_currentInterval, "f") - delta; + const max = __classPrivateFieldGet3(this, _ExponentialBackoff_currentInterval, "f") + delta; + return Math.random() * (max - min) + min; + } + incrementCurrentInterval() { + var _a2; + __classPrivateFieldSet3(this, _ExponentialBackoff_currentInterval, Math.min(__classPrivateFieldGet3(this, _ExponentialBackoff_currentInterval, "f") * __classPrivateFieldGet3(this, _ExponentialBackoff_multiplier, "f"), __classPrivateFieldGet3(this, _ExponentialBackoff_maxInterval, "f")), "f"); + __classPrivateFieldSet3(this, _ExponentialBackoff_count, (_a2 = __classPrivateFieldGet3(this, _ExponentialBackoff_count, "f"), _a2++, _a2), "f"); + return __classPrivateFieldGet3(this, _ExponentialBackoff_currentInterval, "f"); + } + next() { + if (this.ellapsedTimeInMsec >= __classPrivateFieldGet3(this, _ExponentialBackoff_maxElapsedTime, "f") || __classPrivateFieldGet3(this, _ExponentialBackoff_count, "f") >= __classPrivateFieldGet3(this, _ExponentialBackoff_maxIterations, "f")) { + return null; + } else { + this.incrementCurrentInterval(); + return this.randomValueFromInterval; + } + } +}; +_ExponentialBackoff_currentInterval = /* @__PURE__ */ new WeakMap(), _ExponentialBackoff_randomizationFactor = /* @__PURE__ */ new WeakMap(), _ExponentialBackoff_multiplier = /* @__PURE__ */ new WeakMap(), _ExponentialBackoff_maxInterval = /* @__PURE__ */ new WeakMap(), _ExponentialBackoff_startTime = /* @__PURE__ */ new WeakMap(), _ExponentialBackoff_maxElapsedTime = /* @__PURE__ */ new WeakMap(), _ExponentialBackoff_maxIterations = /* @__PURE__ */ new WeakMap(), _ExponentialBackoff_date = /* @__PURE__ */ new WeakMap(), _ExponentialBackoff_count = /* @__PURE__ */ new WeakMap(); +ExponentialBackoff.default = { + initialInterval: INITIAL_INTERVAL_MSEC, + randomizationFactor: RANDOMIZATION_FACTOR, + multiplier: MULTIPLIER, + maxInterval: MAX_INTERVAL_MSEC, + // 1 minute + maxElapsedTime: MAX_ELAPSED_TIME_MSEC, + maxIterations: MAX_ITERATIONS, + date: Date +}; + +// ../../node_modules/@dfinity/agent/lib/esm/agent/http/index.js +var __classPrivateFieldSet4 = function(receiver, state, value2, kind, f) { + if (kind === "m") + throw new TypeError("Private method is not writable"); + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a setter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot write private member to an object whose class did not declare it"); + return kind === "a" ? f.call(receiver, value2) : f ? f.value = value2 : state.set(receiver, value2), value2; +}; +var __classPrivateFieldGet4 = function(receiver, state, kind, f) { + if (kind === "a" && !f) + throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) + throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +}; +var _HttpAgent_instances; +var _HttpAgent_retryTimes; +var _HttpAgent_backoffStrategy; +var _HttpAgent_waterMark; +var _HttpAgent_queryPipeline; +var _HttpAgent_updatePipeline; +var _HttpAgent_subnetKeys; +var _HttpAgent_verifyQuerySignatures; +var _HttpAgent_requestAndRetryQuery; +var _HttpAgent_requestAndRetry; +var _HttpAgent_verifyQueryResponse; +var RequestStatusResponseStatus; +(function(RequestStatusResponseStatus2) { + RequestStatusResponseStatus2["Received"] = "received"; + RequestStatusResponseStatus2["Processing"] = "processing"; + RequestStatusResponseStatus2["Replied"] = "replied"; + RequestStatusResponseStatus2["Rejected"] = "rejected"; + RequestStatusResponseStatus2["Unknown"] = "unknown"; + RequestStatusResponseStatus2["Done"] = "done"; +})(RequestStatusResponseStatus || (RequestStatusResponseStatus = {})); +var DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS = 5 * 60 * 1e3; +var IC_ROOT_KEY = "308182301d060d2b0601040182dc7c0503010201060c2b0601040182dc7c05030201036100814c0e6ec71fab583b08bd81373c255c3c371b2e84863c98a4f1e08b74235d14fb5d9c0cd546d9685f913a0c0b2cc5341583bf4b4392e467db96d65b9bb4cb717112f8472e0d5a4d14505ffd7484b01291091c5f87b98883463f98091a0baaae"; +var MANAGEMENT_CANISTER_ID = "aaaaa-aa"; +var IC0_DOMAIN = "ic0.app"; +var IC0_SUB_DOMAIN = ".ic0.app"; +var ICP0_DOMAIN = "icp0.io"; +var ICP0_SUB_DOMAIN = ".icp0.io"; +var ICP_API_DOMAIN = "icp-api.io"; +var ICP_API_SUB_DOMAIN = ".icp-api.io"; +var HttpDefaultFetchError = class extends AgentError { + constructor(message) { + super(message); + this.message = message; + } +}; +var IdentityInvalidError = class extends AgentError { + constructor(message) { + super(message); + this.message = message; + } +}; +function getDefaultFetch() { + let defaultFetch; + if (typeof window !== "undefined") { + if (window.fetch) { + defaultFetch = window.fetch.bind(window); + } else { + throw new HttpDefaultFetchError("Fetch implementation was not available. You appear to be in a browser context, but window.fetch was not present."); + } + } else if (typeof globalThis !== "undefined") { + if (globalThis.fetch) { + defaultFetch = globalThis.fetch.bind(globalThis); + } else { + throw new HttpDefaultFetchError("Fetch implementation was not available. You appear to be in a Node.js context, but global.fetch was not available."); + } + } else if (typeof self !== "undefined") { + if (self.fetch) { + defaultFetch = self.fetch.bind(self); + } + } + if (defaultFetch) { + return defaultFetch; + } + throw new HttpDefaultFetchError("Fetch implementation was not available. Please provide fetch to the HttpAgent constructor, or ensure it is available in the window or global context."); +} +var HttpAgent = class _HttpAgent { + constructor(options = {}) { + var _a2; + _HttpAgent_instances.add(this); + this.rootKey = fromHex(IC_ROOT_KEY); + this._timeDiffMsecs = 0; + this._rootKeyFetched = false; + _HttpAgent_retryTimes.set(this, void 0); + _HttpAgent_backoffStrategy.set(this, void 0); + this._isAgent = true; + _HttpAgent_waterMark.set(this, 0); + this.log = new ObservableLog(); + _HttpAgent_queryPipeline.set(this, []); + _HttpAgent_updatePipeline.set(this, []); + _HttpAgent_subnetKeys.set(this, new ExpirableMap({ + expirationTime: 5 * 60 * 1e3 + // 5 minutes + })); + _HttpAgent_verifyQuerySignatures.set(this, true); + _HttpAgent_verifyQueryResponse.set(this, (queryResponse, subnetStatus) => { + if (__classPrivateFieldGet4(this, _HttpAgent_verifyQuerySignatures, "f") === false) { + return queryResponse; + } + if (!subnetStatus) { + throw new CertificateVerificationError("Invalid signature from replica signed query: no matching node key found."); + } + const { status, signatures = [], requestId } = queryResponse; + const domainSeparator2 = new TextEncoder().encode("\vic-response"); + for (const sig of signatures) { + const { timestamp, identity } = sig; + const nodeId = Principal.fromUint8Array(identity).toText(); + let hash2; + if (status === "replied") { + const { reply } = queryResponse; + hash2 = hashOfMap({ + status, + reply, + timestamp: BigInt(timestamp), + request_id: requestId + }); + } else if (status === "rejected") { + const { reject_code, reject_message, error_code } = queryResponse; + hash2 = hashOfMap({ + status, + reject_code, + reject_message, + error_code, + timestamp: BigInt(timestamp), + request_id: requestId + }); + } else { + throw new Error(`Unknown status: ${status}`); + } + const separatorWithHash = concat(domainSeparator2, new Uint8Array(hash2)); + const pubKey = subnetStatus === null || subnetStatus === void 0 ? void 0 : subnetStatus.nodeKeys.get(nodeId); + if (!pubKey) { + throw new CertificateVerificationError("Invalid signature from replica signed query: no matching node key found."); + } + const rawKey = Ed25519PublicKey.fromDer(pubKey).rawKey; + const valid = ed25519.verify(sig.signature, new Uint8Array(separatorWithHash), new Uint8Array(rawKey)); + if (valid) + return queryResponse; + throw new CertificateVerificationError(`Invalid signature from replica ${nodeId} signed query.`); + } + return queryResponse; + }); + if (options.source) { + if (!(options.source instanceof _HttpAgent)) { + throw new Error("An Agent's source can only be another HttpAgent"); + } + this._identity = options.source._identity; + this._fetch = options.source._fetch; + this._host = options.source._host; + this._credentials = options.source._credentials; + } else { + this._fetch = options.fetch || getDefaultFetch() || fetch.bind(globalThis); + this._fetchOptions = options.fetchOptions; + this._callOptions = options.callOptions; + } + if (options.host !== void 0) { + if (!options.host.match(/^[a-z]+:/) && typeof window !== "undefined") { + this._host = new URL(window.location.protocol + "//" + options.host); + } else { + this._host = new URL(options.host); + } + } else if (options.source !== void 0) { + this._host = options.source._host; + } else { + const location = typeof window !== "undefined" ? window.location : void 0; + if (!location) { + this._host = new URL("https://icp-api.io"); + this.log.warn("Could not infer host from window.location, defaulting to mainnet gateway of https://icp-api.io. Please provide a host to the HttpAgent constructor to avoid this warning."); + } + const knownHosts = ["ic0.app", "icp0.io", "127.0.0.1", "localhost"]; + const remoteHosts = [".github.dev", ".gitpod.io"]; + const hostname = location === null || location === void 0 ? void 0 : location.hostname; + let knownHost; + if (hostname && typeof hostname === "string") { + if (remoteHosts.some((host) => hostname.endsWith(host))) { + knownHost = hostname; + } else { + knownHost = knownHosts.find((host) => hostname.endsWith(host)); + } + } + if (location && knownHost) { + this._host = new URL(`${location.protocol}//${knownHost}${location.port ? ":" + location.port : ""}`); + } else { + this._host = new URL("https://icp-api.io"); + this.log.warn("Could not infer host from window.location, defaulting to mainnet gateway of https://icp-api.io. Please provide a host to the HttpAgent constructor to avoid this warning."); + } + } + if (options.verifyQuerySignatures !== void 0) { + __classPrivateFieldSet4(this, _HttpAgent_verifyQuerySignatures, options.verifyQuerySignatures, "f"); + } + __classPrivateFieldSet4(this, _HttpAgent_retryTimes, (_a2 = options.retryTimes) !== null && _a2 !== void 0 ? _a2 : 3, "f"); + const defaultBackoffFactory = () => new ExponentialBackoff({ + maxIterations: __classPrivateFieldGet4(this, _HttpAgent_retryTimes, "f") + }); + __classPrivateFieldSet4(this, _HttpAgent_backoffStrategy, options.backoffStrategy || defaultBackoffFactory, "f"); + if (this._host.hostname.endsWith(IC0_SUB_DOMAIN)) { + this._host.hostname = IC0_DOMAIN; + } else if (this._host.hostname.endsWith(ICP0_SUB_DOMAIN)) { + this._host.hostname = ICP0_DOMAIN; + } else if (this._host.hostname.endsWith(ICP_API_SUB_DOMAIN)) { + this._host.hostname = ICP_API_DOMAIN; + } + if (options.credentials) { + const { name, password } = options.credentials; + this._credentials = `${name}${password ? ":" + password : ""}`; + } + this._identity = Promise.resolve(options.identity || new AnonymousIdentity()); + this.addTransform("update", makeNonceTransform(makeNonce)); + if (options.useQueryNonces) { + this.addTransform("query", makeNonceTransform(makeNonce)); + } + if (options.logToConsole) { + this.log.subscribe((log) => { + if (log.level === "error") { + console.error(log.message); + } else if (log.level === "warn") { + console.warn(log.message); + } else { + console.log(log.message); + } + }); + } + } + get waterMark() { + return __classPrivateFieldGet4(this, _HttpAgent_waterMark, "f"); + } + isLocal() { + const hostname = this._host.hostname; + return hostname === "127.0.0.1" || hostname.endsWith("127.0.0.1"); + } + addTransform(type, fn, priority = fn.priority || 0) { + if (type === "update") { + const i = __classPrivateFieldGet4(this, _HttpAgent_updatePipeline, "f").findIndex((x) => (x.priority || 0) < priority); + __classPrivateFieldGet4(this, _HttpAgent_updatePipeline, "f").splice(i >= 0 ? i : __classPrivateFieldGet4(this, _HttpAgent_updatePipeline, "f").length, 0, Object.assign(fn, { priority })); + } else if (type === "query") { + const i = __classPrivateFieldGet4(this, _HttpAgent_queryPipeline, "f").findIndex((x) => (x.priority || 0) < priority); + __classPrivateFieldGet4(this, _HttpAgent_queryPipeline, "f").splice(i >= 0 ? i : __classPrivateFieldGet4(this, _HttpAgent_queryPipeline, "f").length, 0, Object.assign(fn, { priority })); + } + } + async getPrincipal() { + if (!this._identity) { + throw new IdentityInvalidError("This identity has expired due this application's security policy. Please refresh your authentication."); + } + return (await this._identity).getPrincipal(); + } + async call(canisterId, options, identity) { + const id = await (identity !== void 0 ? await identity : await this._identity); + if (!id) { + throw new IdentityInvalidError("This identity has expired due this application's security policy. Please refresh your authentication."); + } + const canister = Principal.from(canisterId); + const ecid = options.effectiveCanisterId ? Principal.from(options.effectiveCanisterId) : canister; + const sender = id.getPrincipal() || Principal.anonymous(); + let ingress_expiry = new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS); + if (Math.abs(this._timeDiffMsecs) > 1e3 * 30) { + ingress_expiry = new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS + this._timeDiffMsecs); + } + const submit = { + request_type: SubmitRequestType.Call, + canister_id: canister, + method_name: options.methodName, + arg: options.arg, + sender, + ingress_expiry + }; + let transformedRequest = await this._transform({ + request: { + body: null, + method: "POST", + headers: Object.assign({ "Content-Type": "application/cbor" }, this._credentials ? { Authorization: "Basic " + btoa(this._credentials) } : {}) + }, + endpoint: "call", + body: submit + }); + transformedRequest = await id.transformRequest(transformedRequest); + const body = encode(transformedRequest.body); + this.log.print(`fetching "/api/v2/canister/${ecid.toText()}/call" with request:`, transformedRequest); + const backoff2 = __classPrivateFieldGet4(this, _HttpAgent_backoffStrategy, "f").call(this); + const request2 = __classPrivateFieldGet4(this, _HttpAgent_instances, "m", _HttpAgent_requestAndRetry).call(this, { + request: () => this._fetch("" + new URL(`/api/v2/canister/${ecid.toText()}/call`, this._host), Object.assign(Object.assign(Object.assign({}, this._callOptions), transformedRequest.request), { body })), + backoff: backoff2, + tries: 0 + }); + const [response, requestId] = await Promise.all([request2, requestIdOf(submit)]); + const responseBuffer = await response.arrayBuffer(); + const responseBody = response.status === 200 && responseBuffer.byteLength > 0 ? decode(responseBuffer) : null; + return { + requestId, + response: { + ok: response.ok, + status: response.status, + statusText: response.statusText, + body: responseBody, + headers: httpHeadersTransform(response.headers) + } + }; + } + async query(canisterId, fields, identity) { + const backoff2 = __classPrivateFieldGet4(this, _HttpAgent_backoffStrategy, "f").call(this); + const ecid = fields.effectiveCanisterId ? Principal.from(fields.effectiveCanisterId) : Principal.from(canisterId); + this.log.print(`ecid ${ecid.toString()}`); + this.log.print(`canisterId ${canisterId.toString()}`); + const makeQuery = async () => { + const id = await (identity !== void 0 ? await identity : await this._identity); + if (!id) { + throw new IdentityInvalidError("This identity has expired due this application's security policy. Please refresh your authentication."); + } + const canister = Principal.from(canisterId); + const sender = (id === null || id === void 0 ? void 0 : id.getPrincipal()) || Principal.anonymous(); + const request2 = { + request_type: "query", + canister_id: canister, + method_name: fields.methodName, + arg: fields.arg, + sender, + ingress_expiry: new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS) + }; + const requestId = await requestIdOf(request2); + let transformedRequest = await this._transform({ + request: { + method: "POST", + headers: Object.assign({ "Content-Type": "application/cbor" }, this._credentials ? { Authorization: "Basic " + btoa(this._credentials) } : {}) + }, + endpoint: "read", + body: request2 + }); + transformedRequest = await (id === null || id === void 0 ? void 0 : id.transformRequest(transformedRequest)); + const body = encode(transformedRequest.body); + const args = { + canister: canister.toText(), + ecid, + transformedRequest, + body, + requestId, + backoff: backoff2, + tries: 0 + }; + return await __classPrivateFieldGet4(this, _HttpAgent_instances, "m", _HttpAgent_requestAndRetryQuery).call(this, args); + }; + const getSubnetStatus = async () => { + if (!__classPrivateFieldGet4(this, _HttpAgent_verifyQuerySignatures, "f")) { + return void 0; + } + const subnetStatus2 = __classPrivateFieldGet4(this, _HttpAgent_subnetKeys, "f").get(ecid.toString()); + if (subnetStatus2) { + return subnetStatus2; + } + await this.fetchSubnetKeys(ecid.toString()); + return __classPrivateFieldGet4(this, _HttpAgent_subnetKeys, "f").get(ecid.toString()); + }; + const [query, subnetStatus] = await Promise.all([makeQuery(), getSubnetStatus()]); + this.log.print("Query response:", query); + if (!__classPrivateFieldGet4(this, _HttpAgent_verifyQuerySignatures, "f")) { + return query; + } + try { + return __classPrivateFieldGet4(this, _HttpAgent_verifyQueryResponse, "f").call(this, query, subnetStatus); + } catch (_) { + this.log.warn("Query response verification failed. Retrying with fresh subnet keys."); + __classPrivateFieldGet4(this, _HttpAgent_subnetKeys, "f").delete(canisterId.toString()); + await this.fetchSubnetKeys(ecid.toString()); + const updatedSubnetStatus = __classPrivateFieldGet4(this, _HttpAgent_subnetKeys, "f").get(canisterId.toString()); + if (!updatedSubnetStatus) { + throw new CertificateVerificationError("Invalid signature from replica signed query: no matching node key found."); + } + return __classPrivateFieldGet4(this, _HttpAgent_verifyQueryResponse, "f").call(this, query, updatedSubnetStatus); + } + } + async createReadStateRequest(fields, identity) { + const id = await (identity !== void 0 ? await identity : await this._identity); + if (!id) { + throw new IdentityInvalidError("This identity has expired due this application's security policy. Please refresh your authentication."); + } + const sender = (id === null || id === void 0 ? void 0 : id.getPrincipal()) || Principal.anonymous(); + const transformedRequest = await this._transform({ + request: { + method: "POST", + headers: Object.assign({ "Content-Type": "application/cbor" }, this._credentials ? { Authorization: "Basic " + btoa(this._credentials) } : {}) + }, + endpoint: "read_state", + body: { + request_type: "read_state", + paths: fields.paths, + sender, + ingress_expiry: new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS) + } + }); + return id === null || id === void 0 ? void 0 : id.transformRequest(transformedRequest); + } + async readState(canisterId, fields, identity, request2) { + const canister = typeof canisterId === "string" ? Principal.fromText(canisterId) : canisterId; + const transformedRequest = request2 !== null && request2 !== void 0 ? request2 : await this.createReadStateRequest(fields, identity); + const body = encode(transformedRequest.body); + this.log.print(`fetching "/api/v2/canister/${canister}/read_state" with request:`, transformedRequest); + const backoff2 = __classPrivateFieldGet4(this, _HttpAgent_backoffStrategy, "f").call(this); + const response = await __classPrivateFieldGet4(this, _HttpAgent_instances, "m", _HttpAgent_requestAndRetry).call(this, { + request: () => this._fetch("" + new URL(`/api/v2/canister/${canister.toString()}/read_state`, this._host), Object.assign(Object.assign(Object.assign({}, this._fetchOptions), transformedRequest.request), { body })), + backoff: backoff2, + tries: 0 + }); + if (!response.ok) { + throw new Error(`Server returned an error: + Code: ${response.status} (${response.statusText}) + Body: ${await response.text()} +`); + } + const decodedResponse = decode(await response.arrayBuffer()); + this.log.print("Read state response:", decodedResponse); + const parsedTime = await this.parseTimeFromResponse(decodedResponse); + if (parsedTime > 0) { + this.log.print("Read state response time:", parsedTime); + __classPrivateFieldSet4(this, _HttpAgent_waterMark, parsedTime, "f"); + } + return decodedResponse; + } + async parseTimeFromResponse(response) { + let tree; + if (response.certificate) { + const decoded = decode(response.certificate); + if (decoded && "tree" in decoded) { + tree = decoded.tree; + } else { + throw new Error("Could not decode time from response"); + } + const timeLookup = lookup_path(["time"], tree); + if (timeLookup.status !== LookupStatus.Found) { + throw new Error("Time was not found in the response or was not in its expected format."); + } + if (!(timeLookup.value instanceof ArrayBuffer) && !ArrayBuffer.isView(timeLookup)) { + throw new Error("Time was not found in the response or was not in its expected format."); + } + const date = decodeTime(bufFromBufLike(timeLookup.value)); + this.log.print("Time from response:", date); + this.log.print("Time from response in milliseconds:", Number(date)); + return Number(date); + } else { + this.log.warn("No certificate found in response"); + } + return 0; + } + /** + * Allows agent to sync its time with the network. Can be called during intialization or mid-lifecycle if the device's clock has drifted away from the network time. This is necessary to set the Expiry for a request + * @param {Principal} canisterId - Pass a canister ID if you need to sync the time with a particular replica. Uses the management canister by default + */ + async syncTime(canisterId) { + const CanisterStatus = await import("./canisterStatus-7DMGTDW5.js"); + const callTime = Date.now(); + try { + if (!canisterId) { + this.log.print("Syncing time with the IC. No canisterId provided, so falling back to ryjl3-tyaaa-aaaaa-aaaba-cai"); + } + const status = await CanisterStatus.request({ + // Fall back with canisterId of the ICP Ledger + canisterId: canisterId !== null && canisterId !== void 0 ? canisterId : Principal.from("ryjl3-tyaaa-aaaaa-aaaba-cai"), + agent: this, + paths: ["time"] + }); + const replicaTime = status.get("time"); + if (replicaTime) { + this._timeDiffMsecs = Number(replicaTime) - Number(callTime); + } + } catch (error) { + this.log.error("Caught exception while attempting to sync time", error); + } + } + async status() { + const headers = this._credentials ? { + Authorization: "Basic " + btoa(this._credentials) + } : {}; + this.log.print(`fetching "/api/v2/status"`); + const backoff2 = __classPrivateFieldGet4(this, _HttpAgent_backoffStrategy, "f").call(this); + const response = await __classPrivateFieldGet4(this, _HttpAgent_instances, "m", _HttpAgent_requestAndRetry).call(this, { + backoff: backoff2, + request: () => this._fetch("" + new URL(`/api/v2/status`, this._host), Object.assign({ headers }, this._fetchOptions)), + tries: 0 + }); + return decode(await response.arrayBuffer()); + } + async fetchRootKey() { + if (!this._rootKeyFetched) { + this.rootKey = (await this.status()).root_key; + this._rootKeyFetched = true; + } + return this.rootKey; + } + invalidateIdentity() { + this._identity = null; + } + replaceIdentity(identity) { + this._identity = Promise.resolve(identity); + } + async fetchSubnetKeys(canisterId) { + const effectiveCanisterId = Principal.from(canisterId); + const response = await request({ + canisterId: effectiveCanisterId, + paths: ["subnet"], + agent: this + }); + const subnetResponse = response.get("subnet"); + if (subnetResponse && typeof subnetResponse === "object" && "nodeKeys" in subnetResponse) { + __classPrivateFieldGet4(this, _HttpAgent_subnetKeys, "f").set(effectiveCanisterId.toText(), subnetResponse); + return subnetResponse; + } + return void 0; + } + _transform(request2) { + let p = Promise.resolve(request2); + if (request2.endpoint === "call") { + for (const fn of __classPrivateFieldGet4(this, _HttpAgent_updatePipeline, "f")) { + p = p.then((r) => fn(r).then((r2) => r2 || r)); + } + } else { + for (const fn of __classPrivateFieldGet4(this, _HttpAgent_queryPipeline, "f")) { + p = p.then((r) => fn(r).then((r2) => r2 || r)); + } + } + return p; + } +}; +_HttpAgent_retryTimes = /* @__PURE__ */ new WeakMap(), _HttpAgent_backoffStrategy = /* @__PURE__ */ new WeakMap(), _HttpAgent_waterMark = /* @__PURE__ */ new WeakMap(), _HttpAgent_queryPipeline = /* @__PURE__ */ new WeakMap(), _HttpAgent_updatePipeline = /* @__PURE__ */ new WeakMap(), _HttpAgent_subnetKeys = /* @__PURE__ */ new WeakMap(), _HttpAgent_verifyQuerySignatures = /* @__PURE__ */ new WeakMap(), _HttpAgent_verifyQueryResponse = /* @__PURE__ */ new WeakMap(), _HttpAgent_instances = /* @__PURE__ */ new WeakSet(), _HttpAgent_requestAndRetryQuery = async function _HttpAgent_requestAndRetryQuery2(args) { + var _a2, _b2; + const { ecid, transformedRequest, body, requestId, backoff: backoff2, tries } = args; + const delay = tries === 0 ? 0 : backoff2.next(); + this.log.print(`fetching "/api/v2/canister/${ecid.toString()}/query" with tries:`, { + tries, + backoff: backoff2, + delay + }); + if (delay === null) { + throw new AgentError(`Timestamp failed to pass the watermark after retrying the configured ${__classPrivateFieldGet4(this, _HttpAgent_retryTimes, "f")} times. We cannot guarantee the integrity of the response since it could be a replay attack.`); + } + if (delay > 0) { + await new Promise((resolve) => setTimeout(resolve, delay)); + } + let response; + try { + this.log.print(`fetching "/api/v2/canister/${ecid.toString()}/query" with request:`, transformedRequest); + const fetchResponse = await this._fetch("" + new URL(`/api/v2/canister/${ecid.toString()}/query`, this._host), Object.assign(Object.assign(Object.assign({}, this._fetchOptions), transformedRequest.request), { body })); + if (fetchResponse.status === 200) { + const queryResponse = decode(await fetchResponse.arrayBuffer()); + response = Object.assign(Object.assign({}, queryResponse), { httpDetails: { + ok: fetchResponse.ok, + status: fetchResponse.status, + statusText: fetchResponse.statusText, + headers: httpHeadersTransform(fetchResponse.headers) + }, requestId }); + } else { + throw new AgentHTTPResponseError(`Gateway returned an error: + Code: ${fetchResponse.status} (${fetchResponse.statusText}) + Body: ${await fetchResponse.text()} +`, { + ok: fetchResponse.ok, + status: fetchResponse.status, + statusText: fetchResponse.statusText, + headers: httpHeadersTransform(fetchResponse.headers) + }); + } + } catch (error) { + if (tries < __classPrivateFieldGet4(this, _HttpAgent_retryTimes, "f")) { + this.log.warn(`Caught exception while attempting to make query: + ${error} + Retrying query.`); + return await __classPrivateFieldGet4(this, _HttpAgent_instances, "m", _HttpAgent_requestAndRetryQuery2).call(this, Object.assign(Object.assign({}, args), { tries: tries + 1 })); + } + throw error; + } + const timestamp = (_b2 = (_a2 = response.signatures) === null || _a2 === void 0 ? void 0 : _a2[0]) === null || _b2 === void 0 ? void 0 : _b2.timestamp; + if (!__classPrivateFieldGet4(this, _HttpAgent_verifyQuerySignatures, "f")) { + return response; + } + if (!timestamp) { + throw new Error("Timestamp not found in query response. This suggests a malformed or malicious response."); + } + const timeStampInMs = Number(BigInt(timestamp) / BigInt(1e6)); + this.log.print("watermark and timestamp", { + waterMark: this.waterMark, + timestamp: timeStampInMs + }); + if (Number(this.waterMark) > timeStampInMs) { + const error = new AgentError("Timestamp is below the watermark. Retrying query."); + this.log.error("Timestamp is below", error, { + timestamp, + waterMark: this.waterMark + }); + if (tries < __classPrivateFieldGet4(this, _HttpAgent_retryTimes, "f")) { + return await __classPrivateFieldGet4(this, _HttpAgent_instances, "m", _HttpAgent_requestAndRetryQuery2).call(this, Object.assign(Object.assign({}, args), { tries: tries + 1 })); + } + { + throw new AgentError(`Timestamp failed to pass the watermark after retrying the configured ${__classPrivateFieldGet4(this, _HttpAgent_retryTimes, "f")} times. We cannot guarantee the integrity of the response since it could be a replay attack.`); + } + } + return response; +}, _HttpAgent_requestAndRetry = async function _HttpAgent_requestAndRetry2(args) { + const { request: request2, backoff: backoff2, tries } = args; + const delay = tries === 0 ? 0 : backoff2.next(); + if (delay === null) { + throw new AgentError(`Timestamp failed to pass the watermark after retrying the configured ${__classPrivateFieldGet4(this, _HttpAgent_retryTimes, "f")} times. We cannot guarantee the integrity of the response since it could be a replay attack.`); + } + if (delay > 0) { + await new Promise((resolve) => setTimeout(resolve, delay)); + } + let response; + try { + response = await request2(); + } catch (error) { + if (__classPrivateFieldGet4(this, _HttpAgent_retryTimes, "f") > tries) { + this.log.warn(`Caught exception while attempting to make request: + ${error} + Retrying request.`); + return await __classPrivateFieldGet4(this, _HttpAgent_instances, "m", _HttpAgent_requestAndRetry2).call(this, { request: request2, backoff: backoff2, tries: tries + 1 }); + } + throw error; + } + if (response.ok) { + return response; + } + const responseText = await response.clone().text(); + const errorMessage = `Server returned an error: + Code: ${response.status} (${response.statusText}) + Body: ${responseText} +`; + if (tries < __classPrivateFieldGet4(this, _HttpAgent_retryTimes, "f")) { + return await __classPrivateFieldGet4(this, _HttpAgent_instances, "m", _HttpAgent_requestAndRetry2).call(this, { request: request2, backoff: backoff2, tries: tries + 1 }); + } + throw new AgentHTTPResponseError(errorMessage, { + ok: response.ok, + status: response.status, + statusText: response.statusText, + headers: httpHeadersTransform(response.headers) + }); +}; + +// ../../node_modules/@dfinity/agent/lib/esm/agent/proxy.js +var ProxyMessageKind; +(function(ProxyMessageKind2) { + ProxyMessageKind2["Error"] = "err"; + ProxyMessageKind2["GetPrincipal"] = "gp"; + ProxyMessageKind2["GetPrincipalResponse"] = "gpr"; + ProxyMessageKind2["Query"] = "q"; + ProxyMessageKind2["QueryResponse"] = "qr"; + ProxyMessageKind2["Call"] = "c"; + ProxyMessageKind2["CallResponse"] = "cr"; + ProxyMessageKind2["ReadState"] = "rs"; + ProxyMessageKind2["ReadStateResponse"] = "rsr"; + ProxyMessageKind2["Status"] = "s"; + ProxyMessageKind2["StatusResponse"] = "sr"; +})(ProxyMessageKind || (ProxyMessageKind = {})); +var ProxyStubAgent = class { + constructor(_frontend, _agent) { + this._frontend = _frontend; + this._agent = _agent; + } + onmessage(msg) { + switch (msg.type) { + case ProxyMessageKind.GetPrincipal: + this._agent.getPrincipal().then((response) => { + this._frontend({ + id: msg.id, + type: ProxyMessageKind.GetPrincipalResponse, + response: response.toText() + }); + }); + break; + case ProxyMessageKind.Query: + this._agent.query(...msg.args).then((response) => { + this._frontend({ + id: msg.id, + type: ProxyMessageKind.QueryResponse, + response + }); + }); + break; + case ProxyMessageKind.Call: + this._agent.call(...msg.args).then((response) => { + this._frontend({ + id: msg.id, + type: ProxyMessageKind.CallResponse, + response + }); + }); + break; + case ProxyMessageKind.ReadState: + this._agent.readState(...msg.args).then((response) => { + this._frontend({ + id: msg.id, + type: ProxyMessageKind.ReadStateResponse, + response + }); + }); + break; + case ProxyMessageKind.Status: + this._agent.status().then((response) => { + this._frontend({ + id: msg.id, + type: ProxyMessageKind.StatusResponse, + response + }); + }); + break; + default: + throw new Error(`Invalid message received: ${JSON.stringify(msg)}`); + } + } +}; +var ProxyAgent = class { + constructor(_backend) { + this._backend = _backend; + this._nextId = 0; + this._pendingCalls = /* @__PURE__ */ new Map(); + this.rootKey = null; + } + onmessage(msg) { + const id = msg.id; + const maybePromise = this._pendingCalls.get(id); + if (!maybePromise) { + throw new Error("A proxy get the same message twice..."); + } + this._pendingCalls.delete(id); + const [resolve, reject] = maybePromise; + switch (msg.type) { + case ProxyMessageKind.Error: + return reject(msg.error); + case ProxyMessageKind.GetPrincipalResponse: + case ProxyMessageKind.CallResponse: + case ProxyMessageKind.QueryResponse: + case ProxyMessageKind.ReadStateResponse: + case ProxyMessageKind.StatusResponse: + return resolve(msg.response); + default: + throw new Error(`Invalid message being sent to ProxyAgent: ${JSON.stringify(msg)}`); + } + } + async getPrincipal() { + return this._sendAndWait({ + id: this._nextId++, + type: ProxyMessageKind.GetPrincipal + }).then((principal) => { + if (typeof principal !== "string") { + throw new Error("Invalid principal received."); + } + return Principal.fromText(principal); + }); + } + readState(canisterId, fields) { + return this._sendAndWait({ + id: this._nextId++, + type: ProxyMessageKind.ReadState, + args: [canisterId.toString(), fields] + }); + } + call(canisterId, fields) { + return this._sendAndWait({ + id: this._nextId++, + type: ProxyMessageKind.Call, + args: [canisterId.toString(), fields] + }); + } + status() { + return this._sendAndWait({ + id: this._nextId++, + type: ProxyMessageKind.Status + }); + } + query(canisterId, fields) { + return this._sendAndWait({ + id: this._nextId++, + type: ProxyMessageKind.Query, + args: [canisterId.toString(), fields] + }); + } + async _sendAndWait(msg) { + return new Promise((resolve, reject) => { + this._pendingCalls.set(msg.id, [resolve, reject]); + this._backend(msg); + }); + } + async fetchRootKey() { + const rootKey = (await this.status()).root_key; + this.rootKey = rootKey; + return rootKey; + } +}; + +// ../../node_modules/@dfinity/agent/lib/esm/agent/index.js +function getDefaultAgent() { + const agent = typeof window === "undefined" ? typeof globalThis === "undefined" ? typeof self === "undefined" ? void 0 : self.ic.agent : globalThis.ic.agent : window.ic.agent; + if (!agent) { + throw new Error("No Agent could be found."); + } + return agent; +} + +// ../../node_modules/@dfinity/agent/lib/esm/polling/index.js +var polling_exports = {}; +__export(polling_exports, { + defaultStrategy: () => defaultStrategy, + pollForResponse: () => pollForResponse, + strategy: () => strategy_exports +}); + +// ../../node_modules/@dfinity/agent/lib/esm/polling/strategy.js +var strategy_exports = {}; +__export(strategy_exports, { + backoff: () => backoff, + chain: () => chain, + conditionalDelay: () => conditionalDelay, + defaultStrategy: () => defaultStrategy, + maxAttempts: () => maxAttempts, + once: () => once, + throttle: () => throttle, + timeout: () => timeout +}); +var FIVE_MINUTES_IN_MSEC = 5 * 60 * 1e3; +function defaultStrategy() { + return chain(conditionalDelay(once(), 1e3), backoff(1e3, 1.2), timeout(FIVE_MINUTES_IN_MSEC)); +} +function once() { + let first = true; + return async () => { + if (first) { + first = false; + return true; + } + return false; + }; +} +function conditionalDelay(condition, timeInMsec) { + return async (canisterId, requestId, status) => { + if (await condition(canisterId, requestId, status)) { + return new Promise((resolve) => setTimeout(resolve, timeInMsec)); + } + }; +} +function maxAttempts(count) { + let attempts = count; + return async (canisterId, requestId, status) => { + if (--attempts <= 0) { + throw new Error(`Failed to retrieve a reply for request after ${count} attempts: + Request ID: ${toHex(requestId)} + Request status: ${status} +`); + } + }; +} +function throttle(throttleInMsec) { + return () => new Promise((resolve) => setTimeout(resolve, throttleInMsec)); +} +function timeout(timeInMsec) { + const end = Date.now() + timeInMsec; + return async (canisterId, requestId, status) => { + if (Date.now() > end) { + throw new Error(`Request timed out after ${timeInMsec} msec: + Request ID: ${toHex(requestId)} + Request status: ${status} +`); + } + }; +} +function backoff(startingThrottleInMsec, backoffFactor) { + let currentThrottling = startingThrottleInMsec; + return () => new Promise((resolve) => setTimeout(() => { + currentThrottling *= backoffFactor; + resolve(); + }, currentThrottling)); +} +function chain(...strategies) { + return async (canisterId, requestId, status) => { + for (const a of strategies) { + await a(canisterId, requestId, status); + } + }; +} + +// ../../node_modules/@dfinity/agent/lib/esm/polling/index.js +async function pollForResponse(agent, canisterId, requestId, strategy, request2, blsVerify2) { + var _a2; + const path = [new TextEncoder().encode("request_status"), requestId]; + const currentRequest = request2 !== null && request2 !== void 0 ? request2 : await ((_a2 = agent.createReadStateRequest) === null || _a2 === void 0 ? void 0 : _a2.call(agent, { paths: [path] })); + const state = await agent.readState(canisterId, { paths: [path] }, void 0, currentRequest); + if (agent.rootKey == null) + throw new Error("Agent root key not initialized before polling"); + const cert = await Certificate.create({ + certificate: state.certificate, + rootKey: agent.rootKey, + canisterId, + blsVerify: blsVerify2 + }); + const maybeBuf = lookupResultToBuffer(cert.lookup([...path, new TextEncoder().encode("status")])); + let status; + if (typeof maybeBuf === "undefined") { + status = RequestStatusResponseStatus.Unknown; + } else { + status = new TextDecoder().decode(maybeBuf); + } + switch (status) { + case RequestStatusResponseStatus.Replied: { + return lookupResultToBuffer(cert.lookup([...path, "reply"])); + } + case RequestStatusResponseStatus.Received: + case RequestStatusResponseStatus.Unknown: + case RequestStatusResponseStatus.Processing: + await strategy(canisterId, requestId, status); + return pollForResponse(agent, canisterId, requestId, strategy, currentRequest); + case RequestStatusResponseStatus.Rejected: { + const rejectCode = new Uint8Array(lookupResultToBuffer(cert.lookup([...path, "reject_code"])))[0]; + const rejectMessage = new TextDecoder().decode(lookupResultToBuffer(cert.lookup([...path, "reject_message"]))); + throw new Error(`Call was rejected: + Request ID: ${toHex(requestId)} + Reject code: ${rejectCode} + Reject text: ${rejectMessage} +`); + } + case RequestStatusResponseStatus.Done: + throw new Error(`Call was marked as done but we never saw the reply: + Request ID: ${toHex(requestId)} +`); + } + throw new Error("unreachable"); +} + +// ../../node_modules/@dfinity/agent/lib/esm/canisters/management_idl.js +var management_idl_default = ({ IDL }) => { + const bitcoin_network = IDL.Variant({ + mainnet: IDL.Null, + testnet: IDL.Null + }); + const bitcoin_address = IDL.Text; + const bitcoin_get_balance_args = IDL.Record({ + network: bitcoin_network, + address: bitcoin_address, + min_confirmations: IDL.Opt(IDL.Nat32) + }); + const satoshi = IDL.Nat64; + const bitcoin_get_balance_result = satoshi; + const bitcoin_get_current_fee_percentiles_args = IDL.Record({ + network: bitcoin_network + }); + const millisatoshi_per_byte = IDL.Nat64; + const bitcoin_get_current_fee_percentiles_result = IDL.Vec(millisatoshi_per_byte); + const bitcoin_get_utxos_args = IDL.Record({ + network: bitcoin_network, + filter: IDL.Opt(IDL.Variant({ + page: IDL.Vec(IDL.Nat8), + min_confirmations: IDL.Nat32 + })), + address: bitcoin_address + }); + const block_hash = IDL.Vec(IDL.Nat8); + const outpoint = IDL.Record({ + txid: IDL.Vec(IDL.Nat8), + vout: IDL.Nat32 + }); + const utxo = IDL.Record({ + height: IDL.Nat32, + value: satoshi, + outpoint + }); + const bitcoin_get_utxos_result = IDL.Record({ + next_page: IDL.Opt(IDL.Vec(IDL.Nat8)), + tip_height: IDL.Nat32, + tip_block_hash: block_hash, + utxos: IDL.Vec(utxo) + }); + const bitcoin_send_transaction_args = IDL.Record({ + transaction: IDL.Vec(IDL.Nat8), + network: bitcoin_network + }); + const canister_id = IDL.Principal; + const canister_info_args = IDL.Record({ + canister_id, + num_requested_changes: IDL.Opt(IDL.Nat64) + }); + const change_origin = IDL.Variant({ + from_user: IDL.Record({ user_id: IDL.Principal }), + from_canister: IDL.Record({ + canister_version: IDL.Opt(IDL.Nat64), + canister_id: IDL.Principal + }) + }); + const change_details = IDL.Variant({ + creation: IDL.Record({ controllers: IDL.Vec(IDL.Principal) }), + code_deployment: IDL.Record({ + mode: IDL.Variant({ + reinstall: IDL.Null, + upgrade: IDL.Null, + install: IDL.Null + }), + module_hash: IDL.Vec(IDL.Nat8) + }), + controllers_change: IDL.Record({ + controllers: IDL.Vec(IDL.Principal) + }), + code_uninstall: IDL.Null + }); + const change = IDL.Record({ + timestamp_nanos: IDL.Nat64, + canister_version: IDL.Nat64, + origin: change_origin, + details: change_details + }); + const canister_info_result = IDL.Record({ + controllers: IDL.Vec(IDL.Principal), + module_hash: IDL.Opt(IDL.Vec(IDL.Nat8)), + recent_changes: IDL.Vec(change), + total_num_changes: IDL.Nat64 + }); + const canister_status_args = IDL.Record({ canister_id }); + const log_visibility = IDL.Variant({ + controllers: IDL.Null, + public: IDL.Null + }); + const definite_canister_settings = IDL.Record({ + freezing_threshold: IDL.Nat, + controllers: IDL.Vec(IDL.Principal), + reserved_cycles_limit: IDL.Nat, + log_visibility, + wasm_memory_limit: IDL.Nat, + memory_allocation: IDL.Nat, + compute_allocation: IDL.Nat + }); + const canister_status_result = IDL.Record({ + status: IDL.Variant({ + stopped: IDL.Null, + stopping: IDL.Null, + running: IDL.Null + }), + memory_size: IDL.Nat, + cycles: IDL.Nat, + settings: definite_canister_settings, + query_stats: IDL.Record({ + response_payload_bytes_total: IDL.Nat, + num_instructions_total: IDL.Nat, + num_calls_total: IDL.Nat, + request_payload_bytes_total: IDL.Nat + }), + idle_cycles_burned_per_day: IDL.Nat, + module_hash: IDL.Opt(IDL.Vec(IDL.Nat8)), + reserved_cycles: IDL.Nat + }); + const clear_chunk_store_args = IDL.Record({ canister_id }); + const canister_settings = IDL.Record({ + freezing_threshold: IDL.Opt(IDL.Nat), + controllers: IDL.Opt(IDL.Vec(IDL.Principal)), + reserved_cycles_limit: IDL.Opt(IDL.Nat), + log_visibility: IDL.Opt(log_visibility), + wasm_memory_limit: IDL.Opt(IDL.Nat), + memory_allocation: IDL.Opt(IDL.Nat), + compute_allocation: IDL.Opt(IDL.Nat) + }); + const create_canister_args = IDL.Record({ + settings: IDL.Opt(canister_settings), + sender_canister_version: IDL.Opt(IDL.Nat64) + }); + const create_canister_result = IDL.Record({ canister_id }); + const delete_canister_args = IDL.Record({ canister_id }); + const deposit_cycles_args = IDL.Record({ canister_id }); + const ecdsa_curve = IDL.Variant({ secp256k1: IDL.Null }); + const ecdsa_public_key_args = IDL.Record({ + key_id: IDL.Record({ name: IDL.Text, curve: ecdsa_curve }), + canister_id: IDL.Opt(canister_id), + derivation_path: IDL.Vec(IDL.Vec(IDL.Nat8)) + }); + const ecdsa_public_key_result = IDL.Record({ + public_key: IDL.Vec(IDL.Nat8), + chain_code: IDL.Vec(IDL.Nat8) + }); + const fetch_canister_logs_args = IDL.Record({ canister_id }); + const canister_log_record = IDL.Record({ + idx: IDL.Nat64, + timestamp_nanos: IDL.Nat64, + content: IDL.Vec(IDL.Nat8) + }); + const fetch_canister_logs_result = IDL.Record({ + canister_log_records: IDL.Vec(canister_log_record) + }); + const http_header = IDL.Record({ value: IDL.Text, name: IDL.Text }); + const http_request_result = IDL.Record({ + status: IDL.Nat, + body: IDL.Vec(IDL.Nat8), + headers: IDL.Vec(http_header) + }); + const http_request_args = IDL.Record({ + url: IDL.Text, + method: IDL.Variant({ + get: IDL.Null, + head: IDL.Null, + post: IDL.Null + }), + max_response_bytes: IDL.Opt(IDL.Nat64), + body: IDL.Opt(IDL.Vec(IDL.Nat8)), + transform: IDL.Opt(IDL.Record({ + function: IDL.Func([ + IDL.Record({ + context: IDL.Vec(IDL.Nat8), + response: http_request_result + }) + ], [http_request_result], ["query"]), + context: IDL.Vec(IDL.Nat8) + })), + headers: IDL.Vec(http_header) + }); + const canister_install_mode = IDL.Variant({ + reinstall: IDL.Null, + upgrade: IDL.Opt(IDL.Record({ + wasm_memory_persistence: IDL.Opt(IDL.Variant({ keep: IDL.Null, replace: IDL.Null })), + skip_pre_upgrade: IDL.Opt(IDL.Bool) + })), + install: IDL.Null + }); + const chunk_hash = IDL.Record({ hash: IDL.Vec(IDL.Nat8) }); + const install_chunked_code_args = IDL.Record({ + arg: IDL.Vec(IDL.Nat8), + wasm_module_hash: IDL.Vec(IDL.Nat8), + mode: canister_install_mode, + chunk_hashes_list: IDL.Vec(chunk_hash), + target_canister: canister_id, + store_canister: IDL.Opt(canister_id), + sender_canister_version: IDL.Opt(IDL.Nat64) + }); + const wasm_module = IDL.Vec(IDL.Nat8); + const install_code_args = IDL.Record({ + arg: IDL.Vec(IDL.Nat8), + wasm_module, + mode: canister_install_mode, + canister_id, + sender_canister_version: IDL.Opt(IDL.Nat64) + }); + const node_metrics_history_args = IDL.Record({ + start_at_timestamp_nanos: IDL.Nat64, + subnet_id: IDL.Principal + }); + const node_metrics = IDL.Record({ + num_block_failures_total: IDL.Nat64, + node_id: IDL.Principal, + num_blocks_proposed_total: IDL.Nat64 + }); + const node_metrics_history_result = IDL.Vec(IDL.Record({ + timestamp_nanos: IDL.Nat64, + node_metrics: IDL.Vec(node_metrics) + })); + const provisional_create_canister_with_cycles_args = IDL.Record({ + settings: IDL.Opt(canister_settings), + specified_id: IDL.Opt(canister_id), + amount: IDL.Opt(IDL.Nat), + sender_canister_version: IDL.Opt(IDL.Nat64) + }); + const provisional_create_canister_with_cycles_result = IDL.Record({ + canister_id + }); + const provisional_top_up_canister_args = IDL.Record({ + canister_id, + amount: IDL.Nat + }); + const raw_rand_result = IDL.Vec(IDL.Nat8); + const sign_with_ecdsa_args = IDL.Record({ + key_id: IDL.Record({ name: IDL.Text, curve: ecdsa_curve }), + derivation_path: IDL.Vec(IDL.Vec(IDL.Nat8)), + message_hash: IDL.Vec(IDL.Nat8) + }); + const sign_with_ecdsa_result = IDL.Record({ + signature: IDL.Vec(IDL.Nat8) + }); + const start_canister_args = IDL.Record({ canister_id }); + const stop_canister_args = IDL.Record({ canister_id }); + const stored_chunks_args = IDL.Record({ canister_id }); + const stored_chunks_result = IDL.Vec(chunk_hash); + const uninstall_code_args = IDL.Record({ + canister_id, + sender_canister_version: IDL.Opt(IDL.Nat64) + }); + const update_settings_args = IDL.Record({ + canister_id: IDL.Principal, + settings: canister_settings, + sender_canister_version: IDL.Opt(IDL.Nat64) + }); + const upload_chunk_args = IDL.Record({ + chunk: IDL.Vec(IDL.Nat8), + canister_id: IDL.Principal + }); + const upload_chunk_result = chunk_hash; + return IDL.Service({ + bitcoin_get_balance: IDL.Func([bitcoin_get_balance_args], [bitcoin_get_balance_result], []), + bitcoin_get_current_fee_percentiles: IDL.Func([bitcoin_get_current_fee_percentiles_args], [bitcoin_get_current_fee_percentiles_result], []), + bitcoin_get_utxos: IDL.Func([bitcoin_get_utxos_args], [bitcoin_get_utxos_result], []), + bitcoin_send_transaction: IDL.Func([bitcoin_send_transaction_args], [], []), + canister_info: IDL.Func([canister_info_args], [canister_info_result], []), + canister_status: IDL.Func([canister_status_args], [canister_status_result], []), + clear_chunk_store: IDL.Func([clear_chunk_store_args], [], []), + create_canister: IDL.Func([create_canister_args], [create_canister_result], []), + delete_canister: IDL.Func([delete_canister_args], [], []), + deposit_cycles: IDL.Func([deposit_cycles_args], [], []), + ecdsa_public_key: IDL.Func([ecdsa_public_key_args], [ecdsa_public_key_result], []), + fetch_canister_logs: IDL.Func([fetch_canister_logs_args], [fetch_canister_logs_result], ["query"]), + http_request: IDL.Func([http_request_args], [http_request_result], []), + install_chunked_code: IDL.Func([install_chunked_code_args], [], []), + install_code: IDL.Func([install_code_args], [], []), + node_metrics_history: IDL.Func([node_metrics_history_args], [node_metrics_history_result], []), + provisional_create_canister_with_cycles: IDL.Func([provisional_create_canister_with_cycles_args], [provisional_create_canister_with_cycles_result], []), + provisional_top_up_canister: IDL.Func([provisional_top_up_canister_args], [], []), + raw_rand: IDL.Func([], [raw_rand_result], []), + sign_with_ecdsa: IDL.Func([sign_with_ecdsa_args], [sign_with_ecdsa_result], []), + start_canister: IDL.Func([start_canister_args], [], []), + stop_canister: IDL.Func([stop_canister_args], [], []), + stored_chunks: IDL.Func([stored_chunks_args], [stored_chunks_result], []), + uninstall_code: IDL.Func([uninstall_code_args], [], []), + update_settings: IDL.Func([update_settings_args], [], []), + upload_chunk: IDL.Func([upload_chunk_args], [upload_chunk_result], []) + }); +}; + +// ../../node_modules/@dfinity/agent/lib/esm/actor.js +var ActorCallError = class extends AgentError { + constructor(canisterId, methodName, type, props) { + super([ + `Call failed:`, + ` Canister: ${canisterId.toText()}`, + ` Method: ${methodName} (${type})`, + ...Object.getOwnPropertyNames(props).map((n) => ` "${n}": ${JSON.stringify(props[n])}`) + ].join("\n")); + this.canisterId = canisterId; + this.methodName = methodName; + this.type = type; + this.props = props; + } +}; +var QueryCallRejectedError = class extends ActorCallError { + constructor(canisterId, methodName, result) { + var _a2; + super(canisterId, methodName, "query", { + Status: result.status, + Code: (_a2 = ReplicaRejectCode[result.reject_code]) !== null && _a2 !== void 0 ? _a2 : `Unknown Code "${result.reject_code}"`, + Message: result.reject_message + }); + this.result = result; + } +}; +var UpdateCallRejectedError = class extends ActorCallError { + constructor(canisterId, methodName, requestId, response) { + super(canisterId, methodName, "update", Object.assign({ "Request ID": toHex(requestId) }, response.body ? Object.assign(Object.assign({}, response.body.error_code ? { + "Error code": response.body.error_code + } : {}), { "Reject code": String(response.body.reject_code), "Reject message": response.body.reject_message }) : { + "HTTP status code": response.status.toString(), + "HTTP status text": response.statusText + })); + this.requestId = requestId; + this.response = response; + } +}; +var metadataSymbol = Symbol.for("ic-agent-metadata"); +var Actor = class _Actor { + constructor(metadata) { + this[metadataSymbol] = Object.freeze(metadata); + } + /** + * Get the Agent class this Actor would call, or undefined if the Actor would use + * the default agent (global.ic.agent). + * @param actor The actor to get the agent of. + */ + static agentOf(actor) { + return actor[metadataSymbol].config.agent; + } + /** + * Get the interface of an actor, in the form of an instance of a Service. + * @param actor The actor to get the interface of. + */ + static interfaceOf(actor) { + return actor[metadataSymbol].service; + } + static canisterIdOf(actor) { + return Principal.from(actor[metadataSymbol].config.canisterId); + } + static async install(fields, config) { + const mode = fields.mode === void 0 ? { install: null } : fields.mode; + const arg = fields.arg ? [...new Uint8Array(fields.arg)] : []; + const wasmModule = [...new Uint8Array(fields.module)]; + const canisterId = typeof config.canisterId === "string" ? Principal.fromText(config.canisterId) : config.canisterId; + await getManagementCanister(config).install_code({ + mode, + arg, + wasm_module: wasmModule, + canister_id: canisterId, + sender_canister_version: [] + }); + } + static async createCanister(config, settings) { + function settingsToCanisterSettings(settings2) { + return [ + { + controllers: settings2.controllers ? [settings2.controllers] : [], + compute_allocation: settings2.compute_allocation ? [settings2.compute_allocation] : [], + freezing_threshold: settings2.freezing_threshold ? [settings2.freezing_threshold] : [], + memory_allocation: settings2.memory_allocation ? [settings2.memory_allocation] : [], + reserved_cycles_limit: [], + log_visibility: [], + wasm_memory_limit: [] + } + ]; + } + const { canister_id: canisterId } = await getManagementCanister(config || {}).provisional_create_canister_with_cycles({ + amount: [], + settings: settingsToCanisterSettings(settings || {}), + specified_id: [], + sender_canister_version: [] + }); + return canisterId; + } + static async createAndInstallCanister(interfaceFactory, fields, config) { + const canisterId = await this.createCanister(config); + await this.install(Object.assign({}, fields), Object.assign(Object.assign({}, config), { canisterId })); + return this.createActor(interfaceFactory, Object.assign(Object.assign({}, config), { canisterId })); + } + static createActorClass(interfaceFactory, options) { + const service = interfaceFactory({ IDL: idl_exports }); + class CanisterActor extends _Actor { + constructor(config) { + if (!config.canisterId) + throw new AgentError(`Canister ID is required, but received ${typeof config.canisterId} instead. If you are using automatically generated declarations, this may be because your application is not setting the canister ID in process.env correctly.`); + const canisterId = typeof config.canisterId === "string" ? Principal.fromText(config.canisterId) : config.canisterId; + super({ + config: Object.assign(Object.assign(Object.assign({}, DEFAULT_ACTOR_CONFIG), config), { canisterId }), + service + }); + for (const [methodName, func] of service._fields) { + if (options === null || options === void 0 ? void 0 : options.httpDetails) { + func.annotations.push(ACTOR_METHOD_WITH_HTTP_DETAILS); + } + this[methodName] = _createActorMethod(this, methodName, func, config.blsVerify); + } + } + } + return CanisterActor; + } + static createActor(interfaceFactory, configuration) { + if (!configuration.canisterId) { + throw new AgentError(`Canister ID is required, but received ${typeof configuration.canisterId} instead. If you are using automatically generated declarations, this may be because your application is not setting the canister ID in process.env correctly.`); + } + return new (this.createActorClass(interfaceFactory))(configuration); + } + static createActorWithHttpDetails(interfaceFactory, configuration) { + return new (this.createActorClass(interfaceFactory, { httpDetails: true }))(configuration); + } +}; +function decodeReturnValue(types, msg) { + const returnValues = idl_exports.decode(types, import_buffer6.Buffer.from(msg)); + switch (returnValues.length) { + case 0: + return void 0; + case 1: + return returnValues[0]; + default: + return returnValues; + } +} +var DEFAULT_ACTOR_CONFIG = { + pollingStrategyFactory: strategy_exports.defaultStrategy +}; +var ACTOR_METHOD_WITH_HTTP_DETAILS = "http-details"; +function _createActorMethod(actor, methodName, func, blsVerify2) { + let caller; + if (func.annotations.includes("query") || func.annotations.includes("composite_query")) { + caller = async (options, ...args) => { + var _a2, _b2; + options = Object.assign(Object.assign({}, options), (_b2 = (_a2 = actor[metadataSymbol].config).queryTransform) === null || _b2 === void 0 ? void 0 : _b2.call(_a2, methodName, args, Object.assign(Object.assign({}, actor[metadataSymbol].config), options))); + const agent = options.agent || actor[metadataSymbol].config.agent || getDefaultAgent(); + const cid = Principal.from(options.canisterId || actor[metadataSymbol].config.canisterId); + const arg = idl_exports.encode(func.argTypes, args); + const result = await agent.query(cid, { + methodName, + arg, + effectiveCanisterId: options.effectiveCanisterId + }); + switch (result.status) { + case "rejected": + throw new QueryCallRejectedError(cid, methodName, result); + case "replied": + return func.annotations.includes(ACTOR_METHOD_WITH_HTTP_DETAILS) ? { + httpDetails: result.httpDetails, + result: decodeReturnValue(func.retTypes, result.reply.arg) + } : decodeReturnValue(func.retTypes, result.reply.arg); + } + }; + } else { + caller = async (options, ...args) => { + var _a2, _b2; + options = Object.assign(Object.assign({}, options), (_b2 = (_a2 = actor[metadataSymbol].config).callTransform) === null || _b2 === void 0 ? void 0 : _b2.call(_a2, methodName, args, Object.assign(Object.assign({}, actor[metadataSymbol].config), options))); + const agent = options.agent || actor[metadataSymbol].config.agent || getDefaultAgent(); + const { canisterId, effectiveCanisterId, pollingStrategyFactory } = Object.assign(Object.assign(Object.assign({}, DEFAULT_ACTOR_CONFIG), actor[metadataSymbol].config), options); + const cid = Principal.from(canisterId); + const ecid = effectiveCanisterId !== void 0 ? Principal.from(effectiveCanisterId) : cid; + const arg = idl_exports.encode(func.argTypes, args); + const { requestId, response } = await agent.call(cid, { + methodName, + arg, + effectiveCanisterId: ecid + }); + if (!response.ok || response.body) { + throw new UpdateCallRejectedError(cid, methodName, requestId, response); + } + const pollStrategy = pollingStrategyFactory(); + const responseBytes = await pollForResponse(agent, ecid, requestId, pollStrategy, blsVerify2); + const shouldIncludeHttpDetails = func.annotations.includes(ACTOR_METHOD_WITH_HTTP_DETAILS); + if (responseBytes !== void 0) { + return shouldIncludeHttpDetails ? { + httpDetails: response, + result: decodeReturnValue(func.retTypes, responseBytes) + } : decodeReturnValue(func.retTypes, responseBytes); + } else if (func.retTypes.length === 0) { + return shouldIncludeHttpDetails ? { + httpDetails: response, + result: void 0 + } : void 0; + } else { + throw new Error(`Call was returned undefined, but type [${func.retTypes.join(",")}].`); + } + }; + } + const handler = (...args) => caller({}, ...args); + handler.withOptions = (options) => (...args) => caller(options, ...args); + return handler; +} +function getManagementCanister(config) { + function transform(_methodName, args) { + if (config.effectiveCanisterId) { + return { effectiveCanisterId: Principal.from(config.effectiveCanisterId) }; + } + const first = args[0]; + let effectiveCanisterId = Principal.fromHex(""); + if (first && typeof first === "object" && first.canister_id) { + effectiveCanisterId = Principal.from(first.canister_id); + } + return { effectiveCanisterId }; + } + return Actor.createActor(management_idl_default, Object.assign(Object.assign(Object.assign({}, config), { canisterId: Principal.fromHex("") }), { + callTransform: transform, + queryTransform: transform + })); +} + +// ../../node_modules/@dfinity/agent/lib/esm/canisters/asset_idl.js +var asset_idl_default = ({ IDL }) => { + return IDL.Service({ + retrieve: IDL.Func([IDL.Text], [IDL.Vec(IDL.Nat8)], ["query"]), + store: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8)], [], []) + }); +}; + +// ../../node_modules/@dfinity/agent/lib/esm/canisters/asset.js +function createAssetCanisterActor(config) { + return Actor.createActor(asset_idl_default, config); +} + +// ../../node_modules/@dfinity/agent/lib/esm/fetch_candid.js +async function fetchCandid(canisterId, agent) { + if (!agent) { + agent = new HttpAgent(); + if (agent.isLocal()) { + agent.fetchRootKey(); + } + } + const status = await request({ + agent, + canisterId: Principal.fromText(canisterId), + paths: ["candid"] + }); + const candid = status.get("candid"); + if (candid) { + return candid; + } + const tmpHackInterface = ({ IDL }) => IDL.Service({ + __get_candid_interface_tmp_hack: IDL.Func([], [IDL.Text], ["query"]) + }); + const actor = Actor.createActor(tmpHackInterface, { agent, canisterId }); + return await actor.__get_candid_interface_tmp_hack(); +} +export { + ACTOR_METHOD_WITH_HTTP_DETAILS, + Actor, + ActorCallError, + AgentHTTPResponseError, + AnonymousIdentity, + canisterStatus_exports as CanisterStatus, + cbor_exports as Cbor, + Certificate, + CertificateVerificationError, + DER_COSE_OID, + ED25519_OID, + Ed25519PublicKey, + Expiry, + HttpAgent, + IC_ROOT_KEY, + IdentityInvalidError, + LookupStatus, + MANAGEMENT_CANISTER_ID, + NodeType, + ProxyAgent, + ProxyMessageKind, + ProxyStubAgent, + QueryCallRejectedError, + ReplicaRejectCode, + RequestStatusResponseStatus, + SECP256K1_OID, + SignIdentity, + SubmitRequestType, + UpdateCallRejectedError, + blsVerify, + bufEquals, + bufFromBufLike, + check_canister_ranges, + compare, + concat, + createAssetCanisterActor, + createIdentityDescriptor, + decodeLen, + decodeLenBytes, + encodeLen, + encodeLenBytes, + fetchCandid, + find_label, + flatten_forks, + fromHex, + getDefaultAgent, + getManagementCanister, + hash, + hashOfMap, + hashTreeToString, + hashValue, + httpHeadersTransform, + lookupResultToBuffer, + lookup_path, + makeExpiryTransform, + makeNonce, + makeNonceTransform, + polling_exports as polling, + randomNumber, + reconstruct, + requestIdOf, + toHex, + uint8ToBuf, + unwrapDER, + verify, + wrapDER +}; +/*! Bundled license information: + +buffer/index.js: + (*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + *) + +@noble/curves/esm/abstract/edwards.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/curves/esm/abstract/montgomery.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) + +@noble/curves/esm/ed25519.js: + (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *) +*/ +//# sourceMappingURL=@dfinity_agent.js.map diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/@dfinity_agent.js.map b/src/BlockThings_frontend/node_modules/.vite/deps/@dfinity_agent.js.map new file mode 100644 index 0000000..018d66f --- /dev/null +++ b/src/BlockThings_frontend/node_modules/.vite/deps/@dfinity_agent.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../../../node_modules/buffer/index.js", "../../../../../node_modules/@dfinity/agent/src/actor.ts", "../../../../../node_modules/@dfinity/agent/src/agent/api.ts", "../../../../../node_modules/@dfinity/agent/src/auth.ts", "../../../../../node_modules/@dfinity/agent/src/agent/http/transforms.ts", "../../../../../node_modules/@dfinity/agent/src/utils/random.ts", "../../../../../node_modules/@dfinity/agent/src/agent/http/types.ts", "../../../../../node_modules/@dfinity/agent/src/agent/http/errors.ts", "../../../../../node_modules/@noble/hashes/src/_u64.ts", "../../../../../node_modules/@noble/hashes/src/sha512.ts", "../../../../../node_modules/@noble/curves/src/abstract/edwards.ts", "../../../../../node_modules/@noble/curves/src/abstract/montgomery.ts", "../../../../../node_modules/@noble/curves/src/ed25519.ts", "../../../../../node_modules/@dfinity/agent/src/utils/expirableMap.ts", "../../../../../node_modules/@dfinity/agent/src/der.ts", "../../../../../node_modules/@dfinity/agent/src/public_key.ts", "../../../../../node_modules/@dfinity/agent/src/observable.ts", "../../../../../node_modules/@dfinity/agent/src/polling/backoff.ts", "../../../../../node_modules/@dfinity/agent/src/agent/http/index.ts", "../../../../../node_modules/@dfinity/agent/src/agent/proxy.ts", "../../../../../node_modules/@dfinity/agent/src/agent/index.ts", "../../../../../node_modules/@dfinity/agent/src/polling/index.ts", "../../../../../node_modules/@dfinity/agent/src/polling/strategy.ts", "../../../../../node_modules/@dfinity/agent/src/canisters/management_idl.ts", "../../../../../node_modules/@dfinity/agent/src/canisters/asset_idl.ts", "../../../../../node_modules/@dfinity/agent/src/canisters/asset.ts", "../../../../../node_modules/@dfinity/agent/src/fetch_candid.ts"], + "sourcesContent": ["/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh \n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Print warning and recommend using `buffer` v4.x which has an Object\n * implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n typeof console.error === 'function') {\n console.error(\n 'This browser lacks typed array (Uint8Array) support which is required by ' +\n '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n )\n}\n\nfunction typedArraySupport () {\n // Can typed array instances can be augmented?\n try {\n const arr = new Uint8Array(1)\n const proto = { foo: function () { return 42 } }\n Object.setPrototypeOf(proto, Uint8Array.prototype)\n Object.setPrototypeOf(arr, proto)\n return arr.foo() === 42\n } catch (e) {\n return false\n }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n enumerable: true,\n get: function () {\n if (!Buffer.isBuffer(this)) return undefined\n return this.buffer\n }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n enumerable: true,\n get: function () {\n if (!Buffer.isBuffer(this)) return undefined\n return this.byteOffset\n }\n})\n\nfunction createBuffer (length) {\n if (length > K_MAX_LENGTH) {\n throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n }\n // Return an augmented `Uint8Array` instance\n const buf = new Uint8Array(length)\n Object.setPrototypeOf(buf, Buffer.prototype)\n return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new TypeError(\n 'The \"string\" argument must be of type string. Received type number'\n )\n }\n return allocUnsafe(arg)\n }\n return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n if (typeof value === 'string') {\n return fromString(value, encodingOrOffset)\n }\n\n if (ArrayBuffer.isView(value)) {\n return fromArrayView(value)\n }\n\n if (value == null) {\n throw new TypeError(\n 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n 'or Array-like Object. Received type ' + (typeof value)\n )\n }\n\n if (isInstance(value, ArrayBuffer) ||\n (value && isInstance(value.buffer, ArrayBuffer))) {\n return fromArrayBuffer(value, encodingOrOffset, length)\n }\n\n if (typeof SharedArrayBuffer !== 'undefined' &&\n (isInstance(value, SharedArrayBuffer) ||\n (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n return fromArrayBuffer(value, encodingOrOffset, length)\n }\n\n if (typeof value === 'number') {\n throw new TypeError(\n 'The \"value\" argument must not be of type number. Received type number'\n )\n }\n\n const valueOf = value.valueOf && value.valueOf()\n if (valueOf != null && valueOf !== value) {\n return Buffer.from(valueOf, encodingOrOffset, length)\n }\n\n const b = fromObject(value)\n if (b) return b\n\n if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n typeof value[Symbol.toPrimitive] === 'function') {\n return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n }\n\n throw new TypeError(\n 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n 'or Array-like Object. Received type ' + (typeof value)\n )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be of type number')\n } else if (size < 0) {\n throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n }\n}\n\nfunction alloc (size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpreted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(size).fill(fill, encoding)\n : createBuffer(size).fill(fill)\n }\n return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n assertSize(size)\n return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n\n const length = byteLength(string, encoding) | 0\n let buf = createBuffer(length)\n\n const actual = buf.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n buf = buf.slice(0, actual)\n }\n\n return buf\n}\n\nfunction fromArrayLike (array) {\n const length = array.length < 0 ? 0 : checked(array.length) | 0\n const buf = createBuffer(length)\n for (let i = 0; i < length; i += 1) {\n buf[i] = array[i] & 255\n }\n return buf\n}\n\nfunction fromArrayView (arrayView) {\n if (isInstance(arrayView, Uint8Array)) {\n const copy = new Uint8Array(arrayView)\n return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n }\n return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\"offset\" is outside of buffer bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\"length\" is outside of buffer bounds')\n }\n\n let buf\n if (byteOffset === undefined && length === undefined) {\n buf = new Uint8Array(array)\n } else if (length === undefined) {\n buf = new Uint8Array(array, byteOffset)\n } else {\n buf = new Uint8Array(array, byteOffset, length)\n }\n\n // Return an augmented `Uint8Array` instance\n Object.setPrototypeOf(buf, Buffer.prototype)\n\n return buf\n}\n\nfunction fromObject (obj) {\n if (Buffer.isBuffer(obj)) {\n const len = checked(obj.length) | 0\n const buf = createBuffer(len)\n\n if (buf.length === 0) {\n return buf\n }\n\n obj.copy(buf, 0, 0, len)\n return buf\n }\n\n if (obj.length !== undefined) {\n if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n return createBuffer(0)\n }\n return fromArrayLike(obj)\n }\n\n if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n return fromArrayLike(obj.data)\n }\n}\n\nfunction checked (length) {\n // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= K_MAX_LENGTH) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return b != null && b._isBuffer === true &&\n b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError(\n 'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n )\n }\n\n if (a === b) return 0\n\n let x = a.length\n let y = b.length\n\n for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!Array.isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n let i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n const buffer = Buffer.allocUnsafe(length)\n let pos = 0\n for (i = 0; i < list.length; ++i) {\n let buf = list[i]\n if (isInstance(buf, Uint8Array)) {\n if (pos + buf.length > buffer.length) {\n if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n buf.copy(buffer, pos)\n } else {\n Uint8Array.prototype.set.call(\n buffer,\n buf,\n pos\n )\n }\n } else if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n } else {\n buf.copy(buffer, pos)\n }\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n throw new TypeError(\n 'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n 'Received type ' + typeof string\n )\n }\n\n const len = string.length\n const mustMatch = (arguments.length > 2 && arguments[2] === true)\n if (!mustMatch && len === 0) return 0\n\n // Use a for loop to avoid recursion\n let loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) {\n return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n }\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n let loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n const i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n const len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (let i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n const len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (let i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n const len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (let i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n const length = this.length\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n let str = ''\n const max = exports.INSPECT_MAX_BYTES\n str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n if (this.length > max) str += ' ... '\n return ''\n}\nif (customInspectSymbol) {\n Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (isInstance(target, Uint8Array)) {\n target = Buffer.from(target, target.offset, target.byteLength)\n }\n if (!Buffer.isBuffer(target)) {\n throw new TypeError(\n 'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n 'Received type ' + (typeof target)\n )\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n let x = thisEnd - thisStart\n let y = end - start\n const len = Math.min(x, y)\n\n const thisCopy = this.slice(thisStart, thisEnd)\n const targetCopy = target.slice(start, end)\n\n for (let i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (numberIsNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n let indexSize = 1\n let arrLength = arr.length\n let valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n let i\n if (dir) {\n let foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n let found = true\n for (let j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n const remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n const strLen = string.length\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n let i\n for (i = 0; i < length; ++i) {\n const parsed = parseInt(string.substr(i * 2, 2), 16)\n if (numberIsNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset >>> 0\n if (isFinite(length)) {\n length = length >>> 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n const remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n let loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n case 'latin1':\n case 'binary':\n return asciiWrite(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n const res = []\n\n let i = start\n while (i < end) {\n const firstByte = buf[i]\n let codePoint = null\n let bytesPerSequence = (firstByte > 0xEF)\n ? 4\n : (firstByte > 0xDF)\n ? 3\n : (firstByte > 0xBF)\n ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n let secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n const len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n let res = ''\n let i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n let ret = ''\n end = Math.min(buf.length, end)\n\n for (let i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n let ret = ''\n end = Math.min(buf.length, end)\n\n for (let i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n const len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n let out = ''\n for (let i = start; i < end; ++i) {\n out += hexSliceLookupTable[buf[i]]\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n const bytes = buf.slice(start, end)\n let res = ''\n // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n for (let i = 0; i < bytes.length - 1; i += 2) {\n res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n const len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n const newBuf = this.subarray(start, end)\n // Return an augmented `Uint8Array` instance\n Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUintLE =\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n let val = this[offset]\n let mul = 1\n let i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUintBE =\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n let val = this[offset + --byteLength]\n let mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUint32BE =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n offset = offset >>> 0\n validateNumber(offset, 'offset')\n const first = this[offset]\n const last = this[offset + 7]\n if (first === undefined || last === undefined) {\n boundsError(offset, this.length - 8)\n }\n\n const lo = first +\n this[++offset] * 2 ** 8 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 24\n\n const hi = this[++offset] +\n this[++offset] * 2 ** 8 +\n this[++offset] * 2 ** 16 +\n last * 2 ** 24\n\n return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n offset = offset >>> 0\n validateNumber(offset, 'offset')\n const first = this[offset]\n const last = this[offset + 7]\n if (first === undefined || last === undefined) {\n boundsError(offset, this.length - 8)\n }\n\n const hi = first * 2 ** 24 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 8 +\n this[++offset]\n\n const lo = this[++offset] * 2 ** 24 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 8 +\n last\n\n return (BigInt(hi) << BigInt(32)) + BigInt(lo)\n})\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n let val = this[offset]\n let mul = 1\n let i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n let i = byteLength\n let mul = 1\n let val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n const val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n const val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n offset = offset >>> 0\n validateNumber(offset, 'offset')\n const first = this[offset]\n const last = this[offset + 7]\n if (first === undefined || last === undefined) {\n boundsError(offset, this.length - 8)\n }\n\n const val = this[offset + 4] +\n this[offset + 5] * 2 ** 8 +\n this[offset + 6] * 2 ** 16 +\n (last << 24) // Overflow\n\n return (BigInt(val) << BigInt(32)) +\n BigInt(first +\n this[++offset] * 2 ** 8 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n offset = offset >>> 0\n validateNumber(offset, 'offset')\n const first = this[offset]\n const last = this[offset + 7]\n if (first === undefined || last === undefined) {\n boundsError(offset, this.length - 8)\n }\n\n const val = (first << 24) + // Overflow\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 8 +\n this[++offset]\n\n return (BigInt(val) << BigInt(32)) +\n BigInt(this[++offset] * 2 ** 24 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 8 +\n last)\n})\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUintLE =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n const maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n let mul = 1\n let i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUintBE =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n const maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n let i = byteLength - 1\n let mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUint8 =\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n return offset + 4\n}\n\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n checkIntBI(value, min, max, buf, offset, 7)\n\n let lo = Number(value & BigInt(0xffffffff))\n buf[offset++] = lo\n lo = lo >> 8\n buf[offset++] = lo\n lo = lo >> 8\n buf[offset++] = lo\n lo = lo >> 8\n buf[offset++] = lo\n let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n buf[offset++] = hi\n hi = hi >> 8\n buf[offset++] = hi\n hi = hi >> 8\n buf[offset++] = hi\n hi = hi >> 8\n buf[offset++] = hi\n return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n checkIntBI(value, min, max, buf, offset, 7)\n\n let lo = Number(value & BigInt(0xffffffff))\n buf[offset + 7] = lo\n lo = lo >> 8\n buf[offset + 6] = lo\n lo = lo >> 8\n buf[offset + 5] = lo\n lo = lo >> 8\n buf[offset + 4] = lo\n let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n buf[offset + 3] = hi\n hi = hi >> 8\n buf[offset + 2] = hi\n hi = hi >> 8\n buf[offset + 1] = hi\n hi = hi >> 8\n buf[offset] = hi\n return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n const limit = Math.pow(2, (8 * byteLength) - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n let i = 0\n let mul = 1\n let sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n const limit = Math.pow(2, (8 * byteLength) - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n let i = byteLength - 1\n let mul = 1\n let sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n return offset + 4\n}\n\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n const len = end - start\n\n if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n // Use built-in when available, missing from IE11\n this.copyWithin(targetStart, start, end)\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, end),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n if (val.length === 1) {\n const code = val.charCodeAt(0)\n if ((encoding === 'utf8' && code < 128) ||\n encoding === 'latin1') {\n // Fast path: If `val` fits into a single byte, use that numeric value.\n val = code\n }\n }\n } else if (typeof val === 'number') {\n val = val & 255\n } else if (typeof val === 'boolean') {\n val = Number(val)\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n let i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n const bytes = Buffer.isBuffer(val)\n ? val\n : Buffer.from(val, encoding)\n const len = bytes.length\n if (len === 0) {\n throw new TypeError('The value \"' + val +\n '\" is invalid for argument \"value\"')\n }\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n errors[sym] = class NodeError extends Base {\n constructor () {\n super()\n\n Object.defineProperty(this, 'message', {\n value: getMessage.apply(this, arguments),\n writable: true,\n configurable: true\n })\n\n // Add the error code to the name to include it in the stack trace.\n this.name = `${this.name} [${sym}]`\n // Access the stack to generate the error message including the error code\n // from the name.\n this.stack // eslint-disable-line no-unused-expressions\n // Reset the name to the actual name.\n delete this.name\n }\n\n get code () {\n return sym\n }\n\n set code (value) {\n Object.defineProperty(this, 'code', {\n configurable: true,\n enumerable: true,\n value,\n writable: true\n })\n }\n\n toString () {\n return `${this.name} [${sym}]: ${this.message}`\n }\n }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n function (name) {\n if (name) {\n return `${name} is outside of buffer bounds`\n }\n\n return 'Attempt to access memory outside buffer bounds'\n }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n function (name, actual) {\n return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n }, TypeError)\nE('ERR_OUT_OF_RANGE',\n function (str, range, input) {\n let msg = `The value of \"${str}\" is out of range.`\n let received = input\n if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n received = addNumericalSeparator(String(input))\n } else if (typeof input === 'bigint') {\n received = String(input)\n if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n received = addNumericalSeparator(received)\n }\n received += 'n'\n }\n msg += ` It must be ${range}. Received ${received}`\n return msg\n }, RangeError)\n\nfunction addNumericalSeparator (val) {\n let res = ''\n let i = val.length\n const start = val[0] === '-' ? 1 : 0\n for (; i >= start + 4; i -= 3) {\n res = `_${val.slice(i - 3, i)}${res}`\n }\n return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n validateNumber(offset, 'offset')\n if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n boundsError(offset, buf.length - (byteLength + 1))\n }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n if (value > max || value < min) {\n const n = typeof min === 'bigint' ? 'n' : ''\n let range\n if (byteLength > 3) {\n if (min === 0 || min === BigInt(0)) {\n range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n } else {\n range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n `${(byteLength + 1) * 8 - 1}${n}`\n }\n } else {\n range = `>= ${min}${n} and <= ${max}${n}`\n }\n throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n }\n checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n if (typeof value !== 'number') {\n throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n }\n}\n\nfunction boundsError (value, length, type) {\n if (Math.floor(value) !== value) {\n validateNumber(value, type)\n throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n }\n\n if (length < 0) {\n throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n }\n\n throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n `>= ${type ? 1 : 0} and <= ${length}`,\n value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node takes equal signs as end of the Base64 encoding\n str = str.split('=')[0]\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = str.trim().replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n let codePoint\n const length = string.length\n let leadSurrogate = null\n const bytes = []\n\n for (let i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n const byteArray = []\n for (let i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n let c, hi, lo\n const byteArray = []\n for (let i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n let i\n for (i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n return obj instanceof type ||\n (obj != null && obj.constructor != null && obj.constructor.name != null &&\n obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n // For IE11 support\n return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n const alphabet = '0123456789abcdef'\n const table = new Array(256)\n for (let i = 0; i < 16; ++i) {\n const i16 = i * 16\n for (let j = 0; j < 16; ++j) {\n table[i16 + j] = alphabet[i] + alphabet[j]\n }\n }\n return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n throw new Error('BigInt not supported')\n}\n", "import { Buffer } from 'buffer/';\nimport {\n Agent,\n getDefaultAgent,\n HttpDetailsResponse,\n QueryResponseRejected,\n QueryResponseStatus,\n ReplicaRejectCode,\n SubmitResponse,\n} from './agent';\nimport { AgentError } from './errors';\nimport { IDL } from '@dfinity/candid';\nimport { pollForResponse, PollStrategyFactory, strategy } from './polling';\nimport { Principal } from '@dfinity/principal';\nimport { RequestId } from './request_id';\nimport { toHex } from './utils/buffer';\nimport { CreateCertificateOptions } from './certificate';\nimport managementCanisterIdl from './canisters/management_idl';\nimport _SERVICE, { canister_install_mode, canister_settings } from './canisters/management_service';\n\nexport class ActorCallError extends AgentError {\n constructor(\n public readonly canisterId: Principal,\n public readonly methodName: string,\n public readonly type: 'query' | 'update',\n public readonly props: Record,\n ) {\n super(\n [\n `Call failed:`,\n ` Canister: ${canisterId.toText()}`,\n ` Method: ${methodName} (${type})`,\n ...Object.getOwnPropertyNames(props).map(n => ` \"${n}\": ${JSON.stringify(props[n])}`),\n ].join('\\n'),\n );\n }\n}\n\nexport class QueryCallRejectedError extends ActorCallError {\n constructor(\n canisterId: Principal,\n methodName: string,\n public readonly result: QueryResponseRejected,\n ) {\n super(canisterId, methodName, 'query', {\n Status: result.status,\n Code: ReplicaRejectCode[result.reject_code] ?? `Unknown Code \"${result.reject_code}\"`,\n Message: result.reject_message,\n });\n }\n}\n\nexport class UpdateCallRejectedError extends ActorCallError {\n constructor(\n canisterId: Principal,\n methodName: string,\n public readonly requestId: RequestId,\n public readonly response: SubmitResponse['response'],\n ) {\n super(canisterId, methodName, 'update', {\n 'Request ID': toHex(requestId),\n ...(response.body\n ? {\n ...(response.body.error_code\n ? {\n 'Error code': response.body.error_code,\n }\n : {}),\n 'Reject code': String(response.body.reject_code),\n 'Reject message': response.body.reject_message,\n }\n : {\n 'HTTP status code': response.status.toString(),\n 'HTTP status text': response.statusText,\n }),\n });\n }\n}\n\n/**\n * Configuration to make calls to the Replica.\n */\nexport interface CallConfig {\n /**\n * An agent to use in this call, otherwise the actor or call will try to discover the\n * agent to use.\n */\n agent?: Agent;\n\n /**\n * A polling strategy factory that dictates how much and often we should poll the\n * read_state endpoint to get the result of an update call.\n */\n pollingStrategyFactory?: PollStrategyFactory;\n\n /**\n * The canister ID of this Actor.\n */\n canisterId?: string | Principal;\n\n /**\n * The effective canister ID. This should almost always be ignored.\n */\n effectiveCanisterId?: Principal;\n}\n\n/**\n * Configuration that can be passed to customize the Actor behaviour.\n */\nexport interface ActorConfig extends CallConfig {\n /**\n * The Canister ID of this Actor. This is required for an Actor.\n */\n canisterId: string | Principal;\n\n /**\n * An override function for update calls' CallConfig. This will be called on every calls.\n */\n callTransform?(\n methodName: string,\n args: unknown[],\n callConfig: CallConfig,\n ): Partial | void;\n\n /**\n * An override function for query calls' CallConfig. This will be called on every query.\n */\n queryTransform?(\n methodName: string,\n args: unknown[],\n callConfig: CallConfig,\n ): Partial | void;\n\n /**\n * Polyfill for BLS Certificate verification in case wasm is not supported\n */\n blsVerify?: CreateCertificateOptions['blsVerify'];\n}\n\n// TODO: move this to proper typing when Candid support TypeScript.\n/**\n * A subclass of an actor. Actor class itself is meant to be a based class.\n */\nexport type ActorSubclass> = Actor & T;\n\n/**\n * An actor method type, defined for each methods of the actor service.\n */\nexport interface ActorMethod {\n (...args: Args): Promise;\n withOptions(options: CallConfig): (...args: Args) => Promise;\n}\n\n/**\n * An actor method type, defined for each methods of the actor service.\n */\nexport interface ActorMethodWithHttpDetails\n extends ActorMethod {\n (...args: Args): Promise<{ httpDetails: HttpDetailsResponse; result: Ret }>;\n}\n\nexport type FunctionWithArgsAndReturn = (\n ...args: Args\n) => Ret;\n\n// Update all entries of T with the extra information from ActorMethodWithInfo\nexport type ActorMethodMappedWithHttpDetails = {\n [K in keyof T]: T[K] extends FunctionWithArgsAndReturn\n ? ActorMethodWithHttpDetails\n : never;\n};\n\n/**\n * The mode used when installing a canister.\n */\nexport type CanisterInstallMode =\n | {\n reinstall: null;\n }\n | {\n upgrade:\n | []\n | [\n {\n skip_pre_upgrade: [] | [boolean];\n },\n ];\n }\n | {\n install: null;\n };\n\n/**\n * Internal metadata for actors. It's an enhanced version of ActorConfig with\n * some fields marked as required (as they are defaulted) and canisterId as\n * a Principal type.\n */\ninterface ActorMetadata {\n service: IDL.ServiceClass;\n agent?: Agent;\n config: ActorConfig;\n}\n\nconst metadataSymbol = Symbol.for('ic-agent-metadata');\n\nexport interface CreateActorClassOpts {\n httpDetails?: boolean;\n}\n\ninterface CreateCanisterSettings {\n freezing_threshold?: bigint;\n controllers?: Array;\n memory_allocation?: bigint;\n compute_allocation?: bigint;\n}\n\n/**\n * An actor base class. An actor is an object containing only functions that will\n * return a promise. These functions are derived from the IDL definition.\n */\nexport class Actor {\n /**\n * Get the Agent class this Actor would call, or undefined if the Actor would use\n * the default agent (global.ic.agent).\n * @param actor The actor to get the agent of.\n */\n public static agentOf(actor: Actor): Agent | undefined {\n return actor[metadataSymbol].config.agent;\n }\n\n /**\n * Get the interface of an actor, in the form of an instance of a Service.\n * @param actor The actor to get the interface of.\n */\n public static interfaceOf(actor: Actor): IDL.ServiceClass {\n return actor[metadataSymbol].service;\n }\n\n public static canisterIdOf(actor: Actor): Principal {\n return Principal.from(actor[metadataSymbol].config.canisterId);\n }\n\n public static async install(\n fields: {\n module: ArrayBuffer;\n mode?: canister_install_mode;\n arg?: ArrayBuffer;\n },\n config: ActorConfig,\n ): Promise {\n const mode = fields.mode === undefined ? { install: null } : fields.mode;\n // Need to transform the arg into a number array.\n const arg = fields.arg ? [...new Uint8Array(fields.arg)] : [];\n // Same for module.\n const wasmModule = [...new Uint8Array(fields.module)];\n const canisterId =\n typeof config.canisterId === 'string'\n ? Principal.fromText(config.canisterId)\n : config.canisterId;\n\n await getManagementCanister(config).install_code({\n mode,\n arg,\n wasm_module: wasmModule,\n canister_id: canisterId,\n sender_canister_version: [],\n });\n }\n\n public static async createCanister(\n config?: CallConfig,\n settings?: CreateCanisterSettings,\n ): Promise {\n function settingsToCanisterSettings(settings: CreateCanisterSettings): [canister_settings] {\n return [\n {\n controllers: settings.controllers ? [settings.controllers] : [],\n compute_allocation: settings.compute_allocation ? [settings.compute_allocation] : [],\n freezing_threshold: settings.freezing_threshold ? [settings.freezing_threshold] : [],\n memory_allocation: settings.memory_allocation ? [settings.memory_allocation] : [],\n reserved_cycles_limit: [],\n log_visibility: [],\n wasm_memory_limit: [],\n },\n ];\n }\n\n const { canister_id: canisterId } = await getManagementCanister(\n config || {},\n ).provisional_create_canister_with_cycles({\n amount: [],\n settings: settingsToCanisterSettings(settings || {}),\n specified_id: [],\n sender_canister_version: [],\n });\n\n return canisterId;\n }\n\n public static async createAndInstallCanister(\n interfaceFactory: IDL.InterfaceFactory,\n fields: {\n module: ArrayBuffer;\n arg?: ArrayBuffer;\n },\n config?: CallConfig,\n ): Promise {\n const canisterId = await this.createCanister(config);\n await this.install(\n {\n ...fields,\n },\n { ...config, canisterId },\n );\n\n return this.createActor(interfaceFactory, { ...config, canisterId });\n }\n\n public static createActorClass(\n interfaceFactory: IDL.InterfaceFactory,\n options?: CreateActorClassOpts,\n ): ActorConstructor {\n const service = interfaceFactory({ IDL });\n\n class CanisterActor extends Actor {\n [x: string]: ActorMethod;\n\n constructor(config: ActorConfig) {\n if (!config.canisterId)\n throw new AgentError(\n `Canister ID is required, but received ${typeof config.canisterId} instead. If you are using automatically generated declarations, this may be because your application is not setting the canister ID in process.env correctly.`,\n );\n const canisterId =\n typeof config.canisterId === 'string'\n ? Principal.fromText(config.canisterId)\n : config.canisterId;\n\n super({\n config: {\n ...DEFAULT_ACTOR_CONFIG,\n ...config,\n canisterId,\n },\n service,\n });\n\n for (const [methodName, func] of service._fields) {\n if (options?.httpDetails) {\n func.annotations.push(ACTOR_METHOD_WITH_HTTP_DETAILS);\n }\n\n this[methodName] = _createActorMethod(this, methodName, func, config.blsVerify);\n }\n }\n }\n\n return CanisterActor;\n }\n\n public static createActor>(\n interfaceFactory: IDL.InterfaceFactory,\n configuration: ActorConfig,\n ): ActorSubclass {\n if (!configuration.canisterId) {\n throw new AgentError(\n `Canister ID is required, but received ${typeof configuration.canisterId} instead. If you are using automatically generated declarations, this may be because your application is not setting the canister ID in process.env correctly.`,\n );\n }\n return new (this.createActorClass(interfaceFactory))(\n configuration,\n ) as unknown as ActorSubclass;\n }\n\n public static createActorWithHttpDetails>(\n interfaceFactory: IDL.InterfaceFactory,\n configuration: ActorConfig,\n ): ActorSubclass> {\n return new (this.createActorClass(interfaceFactory, { httpDetails: true }))(\n configuration,\n ) as unknown as ActorSubclass>;\n }\n\n private [metadataSymbol]: ActorMetadata;\n\n protected constructor(metadata: ActorMetadata) {\n this[metadataSymbol] = Object.freeze(metadata);\n }\n}\n\n// IDL functions can have multiple return values, so decoding always\n// produces an array. Ensure that functions with single or zero return\n// values behave as expected.\nfunction decodeReturnValue(types: IDL.Type[], msg: ArrayBuffer) {\n const returnValues = IDL.decode(types, Buffer.from(msg));\n switch (returnValues.length) {\n case 0:\n return undefined;\n case 1:\n return returnValues[0];\n default:\n return returnValues;\n }\n}\n\nconst DEFAULT_ACTOR_CONFIG = {\n pollingStrategyFactory: strategy.defaultStrategy,\n};\n\nexport type ActorConstructor = new (config: ActorConfig) => ActorSubclass;\n\nexport const ACTOR_METHOD_WITH_HTTP_DETAILS = 'http-details';\n\nfunction _createActorMethod(\n actor: Actor,\n methodName: string,\n func: IDL.FuncClass,\n blsVerify?: CreateCertificateOptions['blsVerify'],\n): ActorMethod {\n let caller: (options: CallConfig, ...args: unknown[]) => Promise;\n if (func.annotations.includes('query') || func.annotations.includes('composite_query')) {\n caller = async (options, ...args) => {\n // First, if there's a config transformation, call it.\n options = {\n ...options,\n ...actor[metadataSymbol].config.queryTransform?.(methodName, args, {\n ...actor[metadataSymbol].config,\n ...options,\n }),\n };\n\n const agent = options.agent || actor[metadataSymbol].config.agent || getDefaultAgent();\n const cid = Principal.from(options.canisterId || actor[metadataSymbol].config.canisterId);\n const arg = IDL.encode(func.argTypes, args);\n\n const result = await agent.query(cid, {\n methodName,\n arg,\n effectiveCanisterId: options.effectiveCanisterId,\n });\n\n switch (result.status) {\n case QueryResponseStatus.Rejected:\n throw new QueryCallRejectedError(cid, methodName, result);\n\n case QueryResponseStatus.Replied:\n return func.annotations.includes(ACTOR_METHOD_WITH_HTTP_DETAILS)\n ? {\n httpDetails: result.httpDetails,\n result: decodeReturnValue(func.retTypes, result.reply.arg),\n }\n : decodeReturnValue(func.retTypes, result.reply.arg);\n }\n };\n } else {\n caller = async (options, ...args) => {\n // First, if there's a config transformation, call it.\n options = {\n ...options,\n ...actor[metadataSymbol].config.callTransform?.(methodName, args, {\n ...actor[metadataSymbol].config,\n ...options,\n }),\n };\n\n const agent = options.agent || actor[metadataSymbol].config.agent || getDefaultAgent();\n const { canisterId, effectiveCanisterId, pollingStrategyFactory } = {\n ...DEFAULT_ACTOR_CONFIG,\n ...actor[metadataSymbol].config,\n ...options,\n };\n const cid = Principal.from(canisterId);\n const ecid = effectiveCanisterId !== undefined ? Principal.from(effectiveCanisterId) : cid;\n const arg = IDL.encode(func.argTypes, args);\n const { requestId, response } = await agent.call(cid, {\n methodName,\n arg,\n effectiveCanisterId: ecid,\n });\n\n if (!response.ok || response.body /* IC-1462 */) {\n throw new UpdateCallRejectedError(cid, methodName, requestId, response);\n }\n\n const pollStrategy = pollingStrategyFactory();\n const responseBytes = await pollForResponse(agent, ecid, requestId, pollStrategy, blsVerify);\n const shouldIncludeHttpDetails = func.annotations.includes(ACTOR_METHOD_WITH_HTTP_DETAILS);\n\n if (responseBytes !== undefined) {\n return shouldIncludeHttpDetails\n ? {\n httpDetails: response,\n result: decodeReturnValue(func.retTypes, responseBytes),\n }\n : decodeReturnValue(func.retTypes, responseBytes);\n } else if (func.retTypes.length === 0) {\n return shouldIncludeHttpDetails\n ? {\n httpDetails: response,\n result: undefined,\n }\n : undefined;\n } else {\n throw new Error(`Call was returned undefined, but type [${func.retTypes.join(',')}].`);\n }\n };\n }\n\n const handler = (...args: unknown[]) => caller({}, ...args);\n handler.withOptions =\n (options: CallConfig) =>\n (...args: unknown[]) =>\n caller(options, ...args);\n return handler as ActorMethod;\n}\n\nexport type ManagementCanisterRecord = _SERVICE;\n\n/**\n * Create a management canister actor\n * @param config - a CallConfig\n */\nexport function getManagementCanister(config: CallConfig): ActorSubclass {\n function transform(\n _methodName: string,\n args: Record & { canister_id: string }[],\n ) {\n if (config.effectiveCanisterId) {\n return { effectiveCanisterId: Principal.from(config.effectiveCanisterId) };\n }\n const first = args[0];\n let effectiveCanisterId = Principal.fromHex('');\n if (first && typeof first === 'object' && first.canister_id) {\n effectiveCanisterId = Principal.from(first.canister_id as unknown);\n }\n return { effectiveCanisterId };\n }\n\n return Actor.createActor(managementCanisterIdl, {\n ...config,\n canisterId: Principal.fromHex(''),\n ...{\n callTransform: transform,\n queryTransform: transform,\n },\n });\n}\n", "import { Principal } from '@dfinity/principal';\nimport { RequestId } from '../request_id';\nimport { JsonObject } from '@dfinity/candid';\nimport { Identity } from '../auth';\nimport { HttpHeaderField } from './http/types';\n\n/**\n * Codes used by the replica for rejecting a message.\n * See {@link https://sdk.dfinity.org/docs/interface-spec/#reject-codes | the interface spec}.\n */\nexport enum ReplicaRejectCode {\n SysFatal = 1,\n SysTransient = 2,\n DestinationInvalid = 3,\n CanisterReject = 4,\n CanisterError = 5,\n}\n\n/**\n * Options when doing a {@link Agent.readState} call.\n */\nexport interface ReadStateOptions {\n /**\n * A list of paths to read the state of.\n */\n paths: ArrayBuffer[][];\n}\n\n/**\n *\n */\nexport type QueryResponse = QueryResponseReplied | QueryResponseRejected;\n\nexport const enum QueryResponseStatus {\n Replied = 'replied',\n Rejected = 'rejected',\n}\n\nexport interface HttpDetailsResponse {\n ok: boolean;\n status: number;\n statusText: string;\n headers: HttpHeaderField[];\n}\n\nexport type ApiQueryResponse = QueryResponse & {\n httpDetails: HttpDetailsResponse;\n requestId: RequestId;\n};\n\nexport interface QueryResponseBase {\n status: QueryResponseStatus;\n}\n\nexport type NodeSignature = {\n // the batch time\n timestamp: bigint;\n // the signature\n signature: Uint8Array;\n // the ID of the node that created the signature\n identity: Uint8Array;\n};\n\nexport interface QueryResponseReplied extends QueryResponseBase {\n status: QueryResponseStatus.Replied;\n reply: { arg: ArrayBuffer };\n signatures?: NodeSignature[];\n}\n\nexport interface QueryResponseRejected extends QueryResponseBase {\n status: QueryResponseStatus.Rejected;\n reject_code: ReplicaRejectCode;\n reject_message: string;\n error_code: string;\n signatures?: NodeSignature[];\n}\n\n/**\n * Options when doing a {@link Agent.query} call.\n */\nexport interface QueryFields {\n /**\n * The method name to call.\n */\n methodName: string;\n\n /**\n * A binary encoded argument. This is already encoded and will be sent as is.\n */\n arg: ArrayBuffer;\n\n /**\n * Overrides canister id for path to fetch. This is used for management canister calls.\n */\n effectiveCanisterId?: Principal;\n}\n\n/**\n * Options when doing a {@link Agent.call} call.\n */\nexport interface CallOptions {\n /**\n * The method name to call.\n */\n methodName: string;\n\n /**\n * A binary encoded argument. This is already encoded and will be sent as is.\n */\n arg: ArrayBuffer;\n\n /**\n * An effective canister ID, used for routing. This should only be mentioned if\n * it's different from the canister ID.\n */\n effectiveCanisterId: Principal | string;\n}\n\nexport interface ReadStateResponse {\n certificate: ArrayBuffer;\n}\n\nexport interface SubmitResponse {\n requestId: RequestId;\n response: {\n ok: boolean;\n status: number;\n statusText: string;\n body: {\n error_code?: string;\n reject_code: number;\n reject_message: string;\n } | null;\n headers: HttpHeaderField[];\n };\n}\n\n/**\n * An Agent able to make calls and queries to a Replica.\n */\nexport interface Agent {\n readonly rootKey: ArrayBuffer | null;\n /**\n * Returns the principal ID associated with this agent (by default). It only shows\n * the principal of the default identity in the agent, which is the principal used\n * when calls don't specify it.\n */\n getPrincipal(): Promise;\n\n /**\n * Create the request for the read state call.\n * `readState` uses this internally.\n * Useful to avoid signing the same request multiple times.\n */\n createReadStateRequest?(\n options: ReadStateOptions,\n identity?: Identity,\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n ): Promise;\n\n /**\n * Send a read state query to the replica. This includes a list of paths to return,\n * and will return a Certificate. This will only reject on communication errors,\n * but the certificate might contain less information than requested.\n * @param effectiveCanisterId A Canister ID related to this call.\n * @param options The options for this call.\n * @param identity Identity for the call. If not specified, uses the instance identity.\n * @param request The request to send in case it has already been created.\n */\n readState(\n effectiveCanisterId: Principal | string,\n options: ReadStateOptions,\n identity?: Identity,\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n request?: any,\n ): Promise;\n\n call(canisterId: Principal | string, fields: CallOptions): Promise;\n\n /**\n * Query the status endpoint of the replica. This normally has a few fields that\n * corresponds to the version of the replica, its root public key, and any other\n * information made public.\n * @returns A JsonObject that is essentially a record of fields from the status\n * endpoint.\n */\n status(): Promise;\n\n /**\n * Send a query call to a canister. See\n * {@link https://sdk.dfinity.org/docs/interface-spec/#http-query | the interface spec}.\n * @param canisterId The Principal of the Canister to send the query to. Sending a query to\n * the management canister is not supported (as it has no meaning from an agent).\n * @param options Options to use to create and send the query.\n * @param identity Sender principal to use when sending the query.\n * @returns The response from the replica. The Promise will only reject when the communication\n * failed. If the query itself failed but no protocol errors happened, the response will\n * be of type QueryResponseRejected.\n */\n query(\n canisterId: Principal | string,\n options: QueryFields,\n identity?: Identity | Promise,\n ): Promise;\n\n /**\n * By default, the agent is configured to talk to the main Internet Computer,\n * and verifies responses using a hard-coded public key.\n *\n * This function will instruct the agent to ask the endpoint for its public\n * key, and use that instead. This is required when talking to a local test\n * instance, for example.\n *\n * Only use this when you are _not_ talking to the main Internet Computer,\n * otherwise you are prone to man-in-the-middle attacks! Do not call this\n * function by default.\n */\n fetchRootKey(): Promise;\n /**\n * If an application needs to invalidate an identity under certain conditions, an `Agent` may expose an `invalidateIdentity` method.\n * Invoking this method will set the inner identity used by the `Agent` to `null`.\n *\n * A use case for this would be - after a certain period of inactivity, a secure application chooses to invalidate the identity of any `HttpAgent` instances. An invalid identity can be replaced by `Agent.replaceIdentity`\n */\n invalidateIdentity?(): void;\n /**\n * If an application needs to replace an identity under certain conditions, an `Agent` may expose a `replaceIdentity` method.\n * Invoking this method will set the inner identity used by the `Agent` to a newly provided identity.\n *\n * A use case for this would be - after authenticating using `@dfinity/auth-client`, you can replace the `AnonymousIdentity` of your `Actor` with a `DelegationIdentity`.\n *\n * ```Actor.agentOf(defaultActor).replaceIdentity(await authClient.getIdentity());```\n */\n replaceIdentity?(identity: Identity): void;\n}\n", "import { Principal } from '@dfinity/principal';\nimport { HttpAgentRequest } from './agent/http/types';\nimport { requestIdOf } from './request_id';\nimport { concat, toHex } from './utils/buffer';\n\nconst domainSeparator = new TextEncoder().encode('\\x0Aic-request');\n\n/**\n * A Key Pair, containing a secret and public key.\n */\nexport interface KeyPair {\n secretKey: ArrayBuffer;\n publicKey: PublicKey;\n}\n\n/**\n * A public key that is DER encoded. This is a branded ArrayBuffer.\n */\nexport type DerEncodedPublicKey = ArrayBuffer & { __derEncodedPublicKey__?: void };\n\n/**\n * A signature array buffer.\n */\nexport type Signature = ArrayBuffer & { __signature__: void };\n\n/**\n * A Public Key implementation.\n */\nexport interface PublicKey {\n toDer(): DerEncodedPublicKey;\n // rawKey, toRaw, and derKey are optional for backwards compatibility.\n toRaw?(): ArrayBuffer;\n rawKey?: ArrayBuffer;\n derKey?: DerEncodedPublicKey;\n}\n\n/**\n * A General Identity object. This does not have to be a private key (for example,\n * the Anonymous identity), but it must be able to transform request.\n */\nexport interface Identity {\n /**\n * Get the principal represented by this identity. Normally should be a\n * `Principal.selfAuthenticating()`.\n */\n getPrincipal(): Principal;\n\n /**\n * Transform a request into a signed version of the request. This is done last\n * after the transforms on the body of a request. The returned object can be\n * anything, but must be serializable to CBOR.\n */\n transformRequest(request: HttpAgentRequest): Promise;\n}\n\n/**\n * An Identity that can sign blobs.\n */\nexport abstract class SignIdentity implements Identity {\n protected _principal: Principal | undefined;\n\n /**\n * Returns the public key that would match this identity's signature.\n */\n public abstract getPublicKey(): PublicKey;\n\n /**\n * Signs a blob of data, with this identity's private key.\n */\n public abstract sign(blob: ArrayBuffer): Promise;\n\n /**\n * Get the principal represented by this identity. Normally should be a\n * `Principal.selfAuthenticating()`.\n */\n public getPrincipal(): Principal {\n if (!this._principal) {\n this._principal = Principal.selfAuthenticating(new Uint8Array(this.getPublicKey().toDer()));\n }\n return this._principal;\n }\n\n /**\n * Transform a request into a signed version of the request. This is done last\n * after the transforms on the body of a request. The returned object can be\n * anything, but must be serializable to CBOR.\n * @param request - internet computer request to transform\n */\n public async transformRequest(request: HttpAgentRequest): Promise {\n const { body, ...fields } = request;\n const requestId = await requestIdOf(body);\n return {\n ...fields,\n body: {\n content: body,\n sender_pubkey: this.getPublicKey().toDer(),\n sender_sig: await this.sign(concat(domainSeparator, requestId)),\n },\n };\n }\n}\n\nexport class AnonymousIdentity implements Identity {\n public getPrincipal(): Principal {\n return Principal.anonymous();\n }\n\n public async transformRequest(request: HttpAgentRequest): Promise {\n return {\n ...request,\n body: { content: request.body },\n };\n }\n}\n\n/*\n * We need to communicate with other agents on the page about identities,\n * but those messages may need to go across boundaries where it's not possible to\n * serialize/deserialize object prototypes easily.\n * So these are lightweight, serializable objects that contain enough information to recreate\n * SignIdentities, but don't commit to having all methods of SignIdentity.\n *\n * Use Case:\n * * DOM Events that let differently-versioned components communicate to one another about\n * Identities, even if they're using slightly different versions of agent packages to\n * create/interpret them.\n */\nexport interface AnonymousIdentityDescriptor {\n type: 'AnonymousIdentity';\n}\nexport interface PublicKeyIdentityDescriptor {\n type: 'PublicKeyIdentity';\n publicKey: string;\n}\nexport type IdentityDescriptor = AnonymousIdentityDescriptor | PublicKeyIdentityDescriptor;\n\n/**\n * Create an IdentityDescriptor from a @dfinity/identity Identity\n * @param identity - identity describe in returned descriptor\n */\nexport function createIdentityDescriptor(\n identity: SignIdentity | AnonymousIdentity,\n): IdentityDescriptor {\n const identityIndicator: IdentityDescriptor =\n 'getPublicKey' in identity\n ? { type: 'PublicKeyIdentity', publicKey: toHex(identity.getPublicKey().toDer()) }\n : { type: 'AnonymousIdentity' };\n return identityIndicator;\n}\n", "import { lebEncode } from '@dfinity/candid';\nimport * as cbor from 'simple-cbor';\nimport {\n Endpoint,\n HttpAgentRequest,\n HttpAgentRequestTransformFn,\n HttpHeaderField,\n makeNonce,\n Nonce,\n} from './types';\n\nconst NANOSECONDS_PER_MILLISECONDS = BigInt(1_000_000);\n\nconst REPLICA_PERMITTED_DRIFT_MILLISECONDS = 60 * 1000;\n\nexport class Expiry {\n private readonly _value: bigint;\n\n constructor(deltaInMSec: number) {\n // Use bigint because it can overflow the maximum number allowed in a double float.\n const raw_value =\n BigInt(Math.floor(Date.now() + deltaInMSec - REPLICA_PERMITTED_DRIFT_MILLISECONDS)) *\n NANOSECONDS_PER_MILLISECONDS;\n\n // round down to the nearest second\n const ingress_as_seconds = raw_value / BigInt(1_000_000_000);\n\n // round down to nearest minute\n const ingress_as_minutes = ingress_as_seconds / BigInt(60);\n\n const rounded_down_nanos = ingress_as_minutes * BigInt(60) * BigInt(1_000_000_000);\n\n this._value = rounded_down_nanos;\n }\n\n public toCBOR(): cbor.CborValue {\n // TODO: change this to take the minimum amount of space (it always takes 8 bytes now).\n return cbor.value.u64(this._value.toString(16), 16);\n }\n\n public toHash(): ArrayBuffer {\n return lebEncode(this._value);\n }\n}\n\n/**\n * Create a Nonce transform, which takes a function that returns a Buffer, and adds it\n * as the nonce to every call requests.\n * @param nonceFn A function that returns a buffer. By default uses a semi-random method.\n */\nexport function makeNonceTransform(nonceFn: () => Nonce = makeNonce): HttpAgentRequestTransformFn {\n return async (request: HttpAgentRequest) => {\n // Nonce needs to be inserted into the header for all requests, to enable logs to be correlated with requests.\n const headers = request.request.headers;\n // TODO: uncomment this when the http proxy supports it.\n // headers.set('X-IC-Request-ID', toHex(new Uint8Array(nonce)));\n request.request.headers = headers;\n\n // Nonce only needs to be inserted into the body for async calls, to prevent replay attacks.\n if (request.endpoint === Endpoint.Call) {\n request.body.nonce = nonceFn();\n }\n };\n}\n\n/**\n * Create a transform that adds a delay (by default 5 minutes) to the expiry.\n *\n * @param delayInMilliseconds The delay to add to the call time, in milliseconds.\n */\nexport function makeExpiryTransform(delayInMilliseconds: number): HttpAgentRequestTransformFn {\n return async (request: HttpAgentRequest) => {\n request.body.ingress_expiry = new Expiry(delayInMilliseconds);\n };\n}\n\n/**\n * Maps the default fetch headers field to the serializable HttpHeaderField.\n *\n * @param headers Fetch definition of the headers type\n * @returns array of header fields\n */\nexport function httpHeadersTransform(headers: Headers): HttpHeaderField[] {\n const headerFields: HttpHeaderField[] = [];\n headers.forEach((value, key) => {\n headerFields.push([key, value]);\n });\n return headerFields;\n}\n", "/**\n * Generates a random unsigned 32-bit integer between 0 and 0xffffffff\n * @returns {number} a random number\n */\nexport const randomNumber = (): number => {\n // determine whether browser crypto is available\n if (typeof window !== 'undefined' && !!window.crypto && !!window.crypto.getRandomValues) {\n const array = new Uint32Array(1);\n window.crypto.getRandomValues(array);\n return array[0];\n }\n // A second check for webcrypto, in case it is loaded under global instead of window\n if (typeof crypto !== 'undefined' && crypto.getRandomValues) {\n const array = new Uint32Array(1);\n crypto.getRandomValues(array);\n return array[0];\n }\n\n type nodeCrypto = {\n randomInt: (min: number, max: number) => number;\n };\n\n // determine whether node crypto is available\n if (typeof crypto !== 'undefined' && (crypto as unknown as nodeCrypto).randomInt) {\n return (crypto as unknown as nodeCrypto).randomInt(0, 0xffffffff);\n }\n\n // fall back to Math.random\n return Math.floor(Math.random() * 0xffffffff);\n};\n", "import type { Principal } from '@dfinity/principal';\nimport { Expiry } from './transforms';\nimport { randomNumber } from '../../utils/random';\n\n/**\n * @internal\n */\nexport const enum Endpoint {\n Query = 'read',\n ReadState = 'read_state',\n Call = 'call',\n}\n\n// An HttpAgent request, before it gets encoded and sent to the server.\n// We create an empty request that we will fill later.\nexport type HttpAgentRequest =\n | HttpAgentQueryRequest\n | HttpAgentSubmitRequest\n | HttpAgentReadStateRequest;\n\nexport interface HttpAgentBaseRequest {\n readonly endpoint: Endpoint;\n request: RequestInit;\n}\n\nexport type HttpHeaderField = [string, string];\n\nexport interface HttpAgentSubmitRequest extends HttpAgentBaseRequest {\n readonly endpoint: Endpoint.Call;\n body: CallRequest;\n}\n\nexport interface HttpAgentQueryRequest extends HttpAgentBaseRequest {\n readonly endpoint: Endpoint.Query;\n body: ReadRequest;\n}\n\nexport interface HttpAgentReadStateRequest extends HttpAgentBaseRequest {\n readonly endpoint: Endpoint.ReadState;\n body: ReadRequest;\n}\n\nexport interface Signed {\n content: T;\n sender_pubkey: ArrayBuffer;\n sender_sig: ArrayBuffer;\n}\n\nexport interface UnSigned {\n content: T;\n}\n\nexport type Envelope = Signed | UnSigned;\n\nexport interface HttpAgentRequestTransformFn {\n (args: HttpAgentRequest): Promise;\n priority?: number;\n}\n\n// The fields in a \"call\" submit request.\nexport interface CallRequest extends Record {\n request_type: SubmitRequestType.Call;\n canister_id: Principal;\n method_name: string;\n arg: ArrayBuffer;\n sender: Uint8Array | Principal;\n ingress_expiry: Expiry;\n}\n\n// The types of values allowed in the `request_type` field for submit requests.\nexport enum SubmitRequestType {\n Call = 'call',\n}\n\n// The types of values allowed in the `request_type` field for read requests.\nexport const enum ReadRequestType {\n Query = 'query',\n ReadState = 'read_state',\n}\n\n// The fields in a \"query\" read request.\nexport interface QueryRequest extends Record {\n request_type: ReadRequestType.Query;\n canister_id: Principal;\n method_name: string;\n arg: ArrayBuffer;\n sender: Uint8Array | Principal;\n ingress_expiry: Expiry;\n}\n\nexport interface ReadStateRequest extends Record {\n request_type: ReadRequestType.ReadState;\n paths: ArrayBuffer[][];\n ingress_expiry: Expiry;\n sender: Uint8Array | Principal;\n}\n\nexport type ReadRequest = QueryRequest | ReadStateRequest;\n\n// A Nonce that can be used for calls.\nexport type Nonce = Uint8Array & { __nonce__: void };\n\n/**\n * Create a random Nonce, based on random values\n */\nexport function makeNonce(): Nonce {\n // Encode 128 bits.\n const buffer = new ArrayBuffer(16);\n const view = new DataView(buffer);\n const rand1 = randomNumber();\n const rand2 = randomNumber();\n const rand3 = randomNumber();\n const rand4 = randomNumber();\n\n view.setUint32(0, rand1);\n view.setUint32(4, rand2);\n view.setUint32(8, rand3);\n view.setUint32(12, rand4);\n\n return buffer as Nonce;\n}\n", "import { AgentError } from '../../errors';\nimport { HttpDetailsResponse } from '../api';\n\nexport class AgentHTTPResponseError extends AgentError {\n constructor(message: string, public readonly response: HttpDetailsResponse) {\n super(message);\n this.name = this.constructor.name;\n Object.setPrototypeOf(this, new.target.prototype);\n }\n}\n", "const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\n\n// We are not using BigUint64Array, because they are extremely slow as per 2022\nfunction fromBig(n: bigint, le = false) {\n if (le) return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\n\nfunction split(lst: bigint[], le = false) {\n let Ah = new Uint32Array(lst.length);\n let Al = new Uint32Array(lst.length);\n for (let i = 0; i < lst.length; i++) {\n const { h, l } = fromBig(lst[i], le);\n [Ah[i], Al[i]] = [h, l];\n }\n return [Ah, Al];\n}\n\nconst toBig = (h: number, l: number) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h: number, _l: number, s: number) => h >>> s;\nconst shrSL = (h: number, l: number, s: number) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h: number, l: number, s: number) => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h: number, l: number, s: number) => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h: number, l: number, s: number) => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h: number, l: number, s: number) => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h: number, l: number) => l;\nconst rotr32L = (h: number, _l: number) => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h: number, l: number, s: number) => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h: number, l: number, s: number) => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h: number, l: number, s: number) => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h: number, l: number, s: number) => (h << (s - 32)) | (l >>> (64 - s));\n\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\nfunction add(Ah: number, Al: number, Bh: number, Bl: number) {\n const l = (Al >>> 0) + (Bl >>> 0);\n return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al: number, Bl: number, Cl: number) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low: number, Ah: number, Bh: number, Ch: number) =>\n (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al: number, Bl: number, Cl: number, Dl: number) =>\n (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low: number, Ah: number, Bh: number, Ch: number, Dh: number) =>\n (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al: number, Bl: number, Cl: number, Dl: number, El: number) =>\n (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number) =>\n (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n\n// prettier-ignore\nexport {\n fromBig, split, toBig,\n shrSH, shrSL,\n rotrSH, rotrSL, rotrBH, rotrBL,\n rotr32H, rotr32L,\n rotlSH, rotlSL, rotlBH, rotlBL,\n add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\n// prettier-ignore\nconst u64 = {\n fromBig, split, toBig,\n shrSH, shrSL,\n rotrSH, rotrSL, rotrBH, rotrBL,\n rotr32H, rotr32L,\n rotlSH, rotlSL, rotlBH, rotlBL,\n add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n", "import { HashMD } from './_md.js';\nimport u64 from './_u64.js';\nimport { wrapConstructor } from './utils.js';\n\n// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):\n// prettier-ignore\nconst [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64.split([\n '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\n\n// Temporary buffer, not used to store anything between runs\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends HashMD {\n // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.\n // Also looks cleaner and easier to verify with spec.\n // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n // h -- high 32 bits, l -- low 32 bits\n Ah = 0x6a09e667 | 0;\n Al = 0xf3bcc908 | 0;\n Bh = 0xbb67ae85 | 0;\n Bl = 0x84caa73b | 0;\n Ch = 0x3c6ef372 | 0;\n Cl = 0xfe94f82b | 0;\n Dh = 0xa54ff53a | 0;\n Dl = 0x5f1d36f1 | 0;\n Eh = 0x510e527f | 0;\n El = 0xade682d1 | 0;\n Fh = 0x9b05688c | 0;\n Fl = 0x2b3e6c1f | 0;\n Gh = 0x1f83d9ab | 0;\n Gl = 0xfb41bd6b | 0;\n Hh = 0x5be0cd19 | 0;\n Hl = 0x137e2179 | 0;\n\n constructor() {\n super(128, 64, 16, false);\n }\n // prettier-ignore\n protected get(): [\n number, number, number, number, number, number, number, number,\n number, number, number, number, number, number, number, number\n ] {\n const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n }\n // prettier-ignore\n protected set(\n Ah: number, Al: number, Bh: number, Bl: number, Ch: number, Cl: number, Dh: number, Dl: number,\n Eh: number, El: number, Fh: number, Fl: number, Gh: number, Gl: number, Hh: number, Hl: number\n ) {\n this.Ah = Ah | 0;\n this.Al = Al | 0;\n this.Bh = Bh | 0;\n this.Bl = Bl | 0;\n this.Ch = Ch | 0;\n this.Cl = Cl | 0;\n this.Dh = Dh | 0;\n this.Dl = Dl | 0;\n this.Eh = Eh | 0;\n this.El = El | 0;\n this.Fh = Fh | 0;\n this.Fl = Fl | 0;\n this.Gh = Gh | 0;\n this.Gl = Gl | 0;\n this.Hh = Hh | 0;\n this.Hl = Hl | 0;\n }\n protected process(view: DataView, offset: number) {\n // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n for (let i = 0; i < 16; i++, offset += 4) {\n SHA512_W_H[i] = view.getUint32(offset);\n SHA512_W_L[i] = view.getUint32((offset += 4));\n }\n for (let i = 16; i < 80; i++) {\n // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n const W15h = SHA512_W_H[i - 15] | 0;\n const W15l = SHA512_W_L[i - 15] | 0;\n const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n const W2h = SHA512_W_H[i - 2] | 0;\n const W2l = SHA512_W_L[i - 2] | 0;\n const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n SHA512_W_H[i] = SUMh | 0;\n SHA512_W_L[i] = SUMl | 0;\n }\n let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n // Compression function main loop, 80 rounds\n for (let i = 0; i < 80; i++) {\n // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n const CHIl = (El & Fl) ^ (~El & Gl);\n // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n // prettier-ignore\n const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n const T1l = T1ll | 0;\n // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n Hh = Gh | 0;\n Hl = Gl | 0;\n Gh = Fh | 0;\n Gl = Fl | 0;\n Fh = Eh | 0;\n Fl = El | 0;\n ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n Dh = Ch | 0;\n Dl = Cl | 0;\n Ch = Bh | 0;\n Cl = Bl | 0;\n Bh = Ah | 0;\n Bl = Al | 0;\n const All = u64.add3L(T1l, sigma0l, MAJl);\n Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n Al = All | 0;\n }\n // Add the compressed chunk to the current hash value\n ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n }\n protected roundClean() {\n SHA512_W_H.fill(0);\n SHA512_W_L.fill(0);\n }\n destroy() {\n this.buffer.fill(0);\n this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n }\n}\n\nexport class SHA512_224 extends SHA512 {\n // h -- high 32 bits, l -- low 32 bits\n Ah = 0x8c3d37c8 | 0;\n Al = 0x19544da2 | 0;\n Bh = 0x73e19966 | 0;\n Bl = 0x89dcd4d6 | 0;\n Ch = 0x1dfab7ae | 0;\n Cl = 0x32ff9c82 | 0;\n Dh = 0x679dd514 | 0;\n Dl = 0x582f9fcf | 0;\n Eh = 0x0f6d2b69 | 0;\n El = 0x7bd44da8 | 0;\n Fh = 0x77e36f73 | 0;\n Fl = 0x04c48942 | 0;\n Gh = 0x3f9d85a8 | 0;\n Gl = 0x6a1d36c8 | 0;\n Hh = 0x1112e6ad | 0;\n Hl = 0x91d692a1 | 0;\n\n constructor() {\n super();\n this.outputLen = 28;\n }\n}\n\nexport class SHA512_256 extends SHA512 {\n // h -- high 32 bits, l -- low 32 bits\n Ah = 0x22312194 | 0;\n Al = 0xfc2bf72c | 0;\n Bh = 0x9f555fa3 | 0;\n Bl = 0xc84c64c2 | 0;\n Ch = 0x2393b86b | 0;\n Cl = 0x6f53b151 | 0;\n Dh = 0x96387719 | 0;\n Dl = 0x5940eabd | 0;\n Eh = 0x96283ee2 | 0;\n El = 0xa88effe3 | 0;\n Fh = 0xbe5e1e25 | 0;\n Fl = 0x53863992 | 0;\n Gh = 0x2b0199fc | 0;\n Gl = 0x2c85b8aa | 0;\n Hh = 0x0eb72ddc | 0;\n Hl = 0x81c52ca2 | 0;\n\n constructor() {\n super();\n this.outputLen = 32;\n }\n}\n\nexport class SHA384 extends SHA512 {\n // h -- high 32 bits, l -- low 32 bits\n Ah = 0xcbbb9d5d | 0;\n Al = 0xc1059ed8 | 0;\n Bh = 0x629a292a | 0;\n Bl = 0x367cd507 | 0;\n Ch = 0x9159015a | 0;\n Cl = 0x3070dd17 | 0;\n Dh = 0x152fecd8 | 0;\n Dl = 0xf70e5939 | 0;\n Eh = 0x67332667 | 0;\n El = 0xffc00b31 | 0;\n Fh = 0x8eb44a87 | 0;\n Fl = 0x68581511 | 0;\n Gh = 0xdb0c2e0d | 0;\n Gl = 0x64f98fa7 | 0;\n Hh = 0x47b5481d | 0;\n Hl = 0xbefa4fa4 | 0;\n\n constructor() {\n super();\n this.outputLen = 48;\n }\n}\n\nexport const sha512 = /* @__PURE__ */ wrapConstructor(() => new SHA512());\nexport const sha512_224 = /* @__PURE__ */ wrapConstructor(() => new SHA512_224());\nexport const sha512_256 = /* @__PURE__ */ wrapConstructor(() => new SHA512_256());\nexport const sha384 = /* @__PURE__ */ wrapConstructor(() => new SHA384());\n", "/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Twisted Edwards curve. The formula is: ax² + y² = 1 + dx²y²\nimport {\n AffinePoint,\n BasicCurve,\n Group,\n GroupConstructor,\n validateBasic,\n wNAF,\n pippenger,\n} from './curve.js';\nimport { mod, Field } from './modular.js';\nimport * as ut from './utils.js';\nimport { ensureBytes, FHash, Hex, memoized, abool } from './utils.js';\n\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _8n = BigInt(8);\n\n// Edwards curves must declare params a & d.\nexport type CurveType = BasicCurve & {\n a: bigint; // curve param a\n d: bigint; // curve param d\n hash: FHash; // Hashing\n randomBytes: (bytesLength?: number) => Uint8Array; // CSPRNG\n adjustScalarBytes?: (bytes: Uint8Array) => Uint8Array; // clears bits to get valid field elemtn\n domain?: (data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array; // Used for hashing\n uvRatio?: (u: bigint, v: bigint) => { isValid: boolean; value: bigint }; // Ratio √(u/v)\n prehash?: FHash; // RFC 8032 pre-hashing of messages to sign() / verify()\n mapToCurve?: (scalar: bigint[]) => AffinePoint; // for hash-to-curve standard\n};\n\n// verification rule is either zip215 or rfc8032 / nist186-5. Consult fromHex:\nconst VERIFY_DEFAULT = { zip215: true };\n\nfunction validateOpts(curve: CurveType) {\n const opts = validateBasic(curve);\n ut.validateObject(\n curve,\n {\n hash: 'function',\n a: 'bigint',\n d: 'bigint',\n randomBytes: 'function',\n },\n {\n adjustScalarBytes: 'function',\n domain: 'function',\n uvRatio: 'function',\n mapToCurve: 'function',\n }\n );\n // Set defaults\n return Object.freeze({ ...opts } as const);\n}\n\n// Instance of Extended Point with coordinates in X, Y, Z, T\nexport interface ExtPointType extends Group {\n readonly ex: bigint;\n readonly ey: bigint;\n readonly ez: bigint;\n readonly et: bigint;\n get x(): bigint;\n get y(): bigint;\n assertValidity(): void;\n multiply(scalar: bigint): ExtPointType;\n multiplyUnsafe(scalar: bigint): ExtPointType;\n isSmallOrder(): boolean;\n isTorsionFree(): boolean;\n clearCofactor(): ExtPointType;\n toAffine(iz?: bigint): AffinePoint;\n toRawBytes(isCompressed?: boolean): Uint8Array;\n toHex(isCompressed?: boolean): string;\n}\n// Static methods of Extended Point with coordinates in X, Y, Z, T\nexport interface ExtPointConstructor extends GroupConstructor {\n new (x: bigint, y: bigint, z: bigint, t: bigint): ExtPointType;\n fromAffine(p: AffinePoint): ExtPointType;\n fromHex(hex: Hex): ExtPointType;\n fromPrivateKey(privateKey: Hex): ExtPointType;\n msm(points: ExtPointType[], scalars: bigint[]): ExtPointType;\n}\n\n/**\n * Edwards Curve interface.\n * Main methods: `getPublicKey(priv)`, `sign(msg, priv)`, `verify(sig, msg, pub)`.\n */\nexport type CurveFn = {\n CURVE: ReturnType;\n getPublicKey: (privateKey: Hex) => Uint8Array;\n sign: (message: Hex, privateKey: Hex, options?: { context?: Hex }) => Uint8Array;\n verify: (\n sig: Hex,\n message: Hex,\n publicKey: Hex,\n options?: { context?: Hex; zip215: boolean }\n ) => boolean;\n ExtendedPoint: ExtPointConstructor;\n utils: {\n randomPrivateKey: () => Uint8Array;\n getExtendedPublicKey: (key: Hex) => {\n head: Uint8Array;\n prefix: Uint8Array;\n scalar: bigint;\n point: ExtPointType;\n pointBytes: Uint8Array;\n };\n };\n};\n\n/**\n * Creates Twisted Edwards curve with EdDSA signatures.\n * @example\n * import { Field } from '@noble/curves/abstract/modular';\n * // Before that, define BigInt-s: a, d, p, n, Gx, Gy, h\n * const curve = twistedEdwards({ a, d, Fp: Field(p), n, Gx, Gy, h })\n */\nexport function twistedEdwards(curveDef: CurveType): CurveFn {\n const CURVE = validateOpts(curveDef) as ReturnType;\n const {\n Fp,\n n: CURVE_ORDER,\n prehash: prehash,\n hash: cHash,\n randomBytes,\n nByteLength,\n h: cofactor,\n } = CURVE;\n const MASK = _2n << (BigInt(nByteLength * 8) - _1n);\n const modP = Fp.create; // Function overrides\n const Fn = Field(CURVE.n, CURVE.nBitLength);\n\n // sqrt(u/v)\n const uvRatio =\n CURVE.uvRatio ||\n ((u: bigint, v: bigint) => {\n try {\n return { isValid: true, value: Fp.sqrt(u * Fp.inv(v)) };\n } catch (e) {\n return { isValid: false, value: _0n };\n }\n });\n const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes: Uint8Array) => bytes); // NOOP\n const domain =\n CURVE.domain ||\n ((data: Uint8Array, ctx: Uint8Array, phflag: boolean) => {\n abool('phflag', phflag);\n if (ctx.length || phflag) throw new Error('Contexts/pre-hash are not supported');\n return data;\n }); // NOOP\n // 0 <= n < MASK\n // Coordinates larger than Fp.ORDER are allowed for zip215\n function aCoordinate(title: string, n: bigint) {\n ut.aInRange('coordinate ' + title, n, _0n, MASK);\n }\n\n function assertPoint(other: unknown) {\n if (!(other instanceof Point)) throw new Error('ExtendedPoint expected');\n }\n // Converts Extended point to default (x, y) coordinates.\n // Can accept precomputed Z^-1 - for example, from invertBatch.\n const toAffineMemo = memoized((p: Point, iz?: bigint): AffinePoint => {\n const { ex: x, ey: y, ez: z } = p;\n const is0 = p.is0();\n if (iz == null) iz = is0 ? _8n : (Fp.inv(z) as bigint); // 8 was chosen arbitrarily\n const ax = modP(x * iz);\n const ay = modP(y * iz);\n const zz = modP(z * iz);\n if (is0) return { x: _0n, y: _1n };\n if (zz !== _1n) throw new Error('invZ was invalid');\n return { x: ax, y: ay };\n });\n const assertValidMemo = memoized((p: Point) => {\n const { a, d } = CURVE;\n if (p.is0()) throw new Error('bad point: ZERO'); // TODO: optimize, with vars below?\n // Equation in affine coordinates: ax² + y² = 1 + dx²y²\n // Equation in projective coordinates (X/Z, Y/Z, Z): (aX² + Y²)Z² = Z⁴ + dX²Y²\n const { ex: X, ey: Y, ez: Z, et: T } = p;\n const X2 = modP(X * X); // X²\n const Y2 = modP(Y * Y); // Y²\n const Z2 = modP(Z * Z); // Z²\n const Z4 = modP(Z2 * Z2); // Z⁴\n const aX2 = modP(X2 * a); // aX²\n const left = modP(Z2 * modP(aX2 + Y2)); // (aX² + Y²)Z²\n const right = modP(Z4 + modP(d * modP(X2 * Y2))); // Z⁴ + dX²Y²\n if (left !== right) throw new Error('bad point: equation left != right (1)');\n // In Extended coordinates we also have T, which is x*y=T/Z: check X*Y == Z*T\n const XY = modP(X * Y);\n const ZT = modP(Z * T);\n if (XY !== ZT) throw new Error('bad point: equation left != right (2)');\n return true;\n });\n\n // Extended Point works in extended coordinates: (x, y, z, t) ∋ (x=x/z, y=y/z, t=xy).\n // https://en.wikipedia.org/wiki/Twisted_Edwards_curve#Extended_coordinates\n class Point implements ExtPointType {\n static readonly BASE = new Point(CURVE.Gx, CURVE.Gy, _1n, modP(CURVE.Gx * CURVE.Gy));\n static readonly ZERO = new Point(_0n, _1n, _1n, _0n); // 0, 1, 1, 0\n\n constructor(\n readonly ex: bigint,\n readonly ey: bigint,\n readonly ez: bigint,\n readonly et: bigint\n ) {\n aCoordinate('x', ex);\n aCoordinate('y', ey);\n aCoordinate('z', ez);\n aCoordinate('t', et);\n Object.freeze(this);\n }\n\n get x(): bigint {\n return this.toAffine().x;\n }\n get y(): bigint {\n return this.toAffine().y;\n }\n\n static fromAffine(p: AffinePoint): Point {\n if (p instanceof Point) throw new Error('extended point not allowed');\n const { x, y } = p || {};\n aCoordinate('x', x);\n aCoordinate('y', y);\n return new Point(x, y, _1n, modP(x * y));\n }\n static normalizeZ(points: Point[]): Point[] {\n const toInv = Fp.invertBatch(points.map((p) => p.ez));\n return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n }\n // Multiscalar Multiplication\n static msm(points: Point[], scalars: bigint[]) {\n return pippenger(Point, Fn, points, scalars);\n }\n\n // \"Private method\", don't use it directly\n _setWindowSize(windowSize: number) {\n wnaf.setWindowSize(this, windowSize);\n }\n // Not required for fromHex(), which always creates valid points.\n // Could be useful for fromAffine().\n assertValidity(): void {\n assertValidMemo(this);\n }\n\n // Compare one point to another.\n equals(other: Point): boolean {\n assertPoint(other);\n const { ex: X1, ey: Y1, ez: Z1 } = this;\n const { ex: X2, ey: Y2, ez: Z2 } = other;\n const X1Z2 = modP(X1 * Z2);\n const X2Z1 = modP(X2 * Z1);\n const Y1Z2 = modP(Y1 * Z2);\n const Y2Z1 = modP(Y2 * Z1);\n return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;\n }\n\n is0(): boolean {\n return this.equals(Point.ZERO);\n }\n\n negate(): Point {\n // Flips point sign to a negative one (-x, y in affine coords)\n return new Point(modP(-this.ex), this.ey, this.ez, modP(-this.et));\n }\n\n // Fast algo for doubling Extended Point.\n // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd\n // Cost: 4M + 4S + 1*a + 6add + 1*2.\n double(): Point {\n const { a } = CURVE;\n const { ex: X1, ey: Y1, ez: Z1 } = this;\n const A = modP(X1 * X1); // A = X12\n const B = modP(Y1 * Y1); // B = Y12\n const C = modP(_2n * modP(Z1 * Z1)); // C = 2*Z12\n const D = modP(a * A); // D = a*A\n const x1y1 = X1 + Y1;\n const E = modP(modP(x1y1 * x1y1) - A - B); // E = (X1+Y1)2-A-B\n const G = D + B; // G = D+B\n const F = G - C; // F = G-C\n const H = D - B; // H = D-B\n const X3 = modP(E * F); // X3 = E*F\n const Y3 = modP(G * H); // Y3 = G*H\n const T3 = modP(E * H); // T3 = E*H\n const Z3 = modP(F * G); // Z3 = F*G\n return new Point(X3, Y3, Z3, T3);\n }\n\n // Fast algo for adding 2 Extended Points.\n // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd\n // Cost: 9M + 1*a + 1*d + 7add.\n add(other: Point) {\n assertPoint(other);\n const { a, d } = CURVE;\n const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;\n const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;\n // Faster algo for adding 2 Extended Points when curve's a=-1.\n // http://hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html#addition-add-2008-hwcd-4\n // Cost: 8M + 8add + 2*2.\n // Note: It does not check whether the `other` point is valid.\n if (a === BigInt(-1)) {\n const A = modP((Y1 - X1) * (Y2 + X2));\n const B = modP((Y1 + X1) * (Y2 - X2));\n const F = modP(B - A);\n if (F === _0n) return this.double(); // Same point. Tests say it doesn't affect timing\n const C = modP(Z1 * _2n * T2);\n const D = modP(T1 * _2n * Z2);\n const E = D + C;\n const G = B + A;\n const H = D - C;\n const X3 = modP(E * F);\n const Y3 = modP(G * H);\n const T3 = modP(E * H);\n const Z3 = modP(F * G);\n return new Point(X3, Y3, Z3, T3);\n }\n const A = modP(X1 * X2); // A = X1*X2\n const B = modP(Y1 * Y2); // B = Y1*Y2\n const C = modP(T1 * d * T2); // C = T1*d*T2\n const D = modP(Z1 * Z2); // D = Z1*Z2\n const E = modP((X1 + Y1) * (X2 + Y2) - A - B); // E = (X1+Y1)*(X2+Y2)-A-B\n const F = D - C; // F = D-C\n const G = D + C; // G = D+C\n const H = modP(B - a * A); // H = B-a*A\n const X3 = modP(E * F); // X3 = E*F\n const Y3 = modP(G * H); // Y3 = G*H\n const T3 = modP(E * H); // T3 = E*H\n const Z3 = modP(F * G); // Z3 = F*G\n\n return new Point(X3, Y3, Z3, T3);\n }\n\n subtract(other: Point): Point {\n return this.add(other.negate());\n }\n\n private wNAF(n: bigint): { p: Point; f: Point } {\n return wnaf.wNAFCached(this, n, Point.normalizeZ);\n }\n\n // Constant-time multiplication.\n multiply(scalar: bigint): Point {\n const n = scalar;\n ut.aInRange('scalar', n, _1n, CURVE_ORDER); // 1 <= scalar < L\n const { p, f } = this.wNAF(n);\n return Point.normalizeZ([p, f])[0];\n }\n\n // Non-constant-time multiplication. Uses double-and-add algorithm.\n // It's faster, but should only be used when you don't care about\n // an exposed private key e.g. sig verification.\n // Does NOT allow scalars higher than CURVE.n.\n multiplyUnsafe(scalar: bigint): Point {\n const n = scalar;\n ut.aInRange('scalar', n, _0n, CURVE_ORDER); // 0 <= scalar < L\n if (n === _0n) return I;\n if (this.equals(I) || n === _1n) return this;\n if (this.equals(G)) return this.wNAF(n).p;\n return wnaf.unsafeLadder(this, n);\n }\n\n // Checks if point is of small order.\n // If you add something to small order point, you will have \"dirty\"\n // point with torsion component.\n // Multiplies point by cofactor and checks if the result is 0.\n isSmallOrder(): boolean {\n return this.multiplyUnsafe(cofactor).is0();\n }\n\n // Multiplies point by curve order and checks if the result is 0.\n // Returns `false` is the point is dirty.\n isTorsionFree(): boolean {\n return wnaf.unsafeLadder(this, CURVE_ORDER).is0();\n }\n\n // Converts Extended point to default (x, y) coordinates.\n // Can accept precomputed Z^-1 - for example, from invertBatch.\n toAffine(iz?: bigint): AffinePoint {\n return toAffineMemo(this, iz);\n }\n\n clearCofactor(): Point {\n const { h: cofactor } = CURVE;\n if (cofactor === _1n) return this;\n return this.multiplyUnsafe(cofactor);\n }\n\n // Converts hash string or Uint8Array to Point.\n // Uses algo from RFC8032 5.1.3.\n static fromHex(hex: Hex, zip215 = false): Point {\n const { d, a } = CURVE;\n const len = Fp.BYTES;\n hex = ensureBytes('pointHex', hex, len); // copy hex to a new array\n abool('zip215', zip215);\n const normed = hex.slice(); // copy again, we'll manipulate it\n const lastByte = hex[len - 1]; // select last byte\n normed[len - 1] = lastByte & ~0x80; // clear last bit\n const y = ut.bytesToNumberLE(normed);\n\n // RFC8032 prohibits >= p, but ZIP215 doesn't\n // zip215=true: 0 <= y < MASK (2^256 for ed25519)\n // zip215=false: 0 <= y < P (2^255-19 for ed25519)\n const max = zip215 ? MASK : Fp.ORDER;\n ut.aInRange('pointHex.y', y, _0n, max);\n\n // Ed25519: x² = (y²-1)/(dy²+1) mod p. Ed448: x² = (y²-1)/(dy²-1) mod p. Generic case:\n // ax²+y²=1+dx²y² => y²-1=dx²y²-ax² => y²-1=x²(dy²-a) => x²=(y²-1)/(dy²-a)\n const y2 = modP(y * y); // denominator is always non-0 mod p.\n const u = modP(y2 - _1n); // u = y² - 1\n const v = modP(d * y2 - a); // v = d y² + 1.\n let { isValid, value: x } = uvRatio(u, v); // √(u/v)\n if (!isValid) throw new Error('Point.fromHex: invalid y coordinate');\n const isXOdd = (x & _1n) === _1n; // There are 2 square roots. Use x_0 bit to select proper\n const isLastByteOdd = (lastByte & 0x80) !== 0; // x_0, last bit\n if (!zip215 && x === _0n && isLastByteOdd)\n // if x=0 and x_0 = 1, fail\n throw new Error('Point.fromHex: x=0 and x_0=1');\n if (isLastByteOdd !== isXOdd) x = modP(-x); // if x_0 != x mod 2, set x = p-x\n return Point.fromAffine({ x, y });\n }\n static fromPrivateKey(privKey: Hex) {\n return getExtendedPublicKey(privKey).point;\n }\n toRawBytes(): Uint8Array {\n const { x, y } = this.toAffine();\n const bytes = ut.numberToBytesLE(y, Fp.BYTES); // each y has 2 x values (x, -y)\n bytes[bytes.length - 1] |= x & _1n ? 0x80 : 0; // when compressing, it's enough to store y\n return bytes; // and use the last byte to encode sign of x\n }\n toHex(): string {\n return ut.bytesToHex(this.toRawBytes()); // Same as toRawBytes, but returns string.\n }\n }\n const { BASE: G, ZERO: I } = Point;\n const wnaf = wNAF(Point, nByteLength * 8);\n\n function modN(a: bigint) {\n return mod(a, CURVE_ORDER);\n }\n // Little-endian SHA512 with modulo n\n function modN_LE(hash: Uint8Array): bigint {\n return modN(ut.bytesToNumberLE(hash));\n }\n\n /** Convenience method that creates public key and other stuff. RFC8032 5.1.5 */\n function getExtendedPublicKey(key: Hex) {\n const len = nByteLength;\n key = ensureBytes('private key', key, len);\n // Hash private key with curve's hash function to produce uniformingly random input\n // Check byte lengths: ensure(64, h(ensure(32, key)))\n const hashed = ensureBytes('hashed private key', cHash(key), 2 * len);\n const head = adjustScalarBytes(hashed.slice(0, len)); // clear first half bits, produce FE\n const prefix = hashed.slice(len, 2 * len); // second half is called key prefix (5.1.6)\n const scalar = modN_LE(head); // The actual private scalar\n const point = G.multiply(scalar); // Point on Edwards curve aka public key\n const pointBytes = point.toRawBytes(); // Uint8Array representation\n return { head, prefix, scalar, point, pointBytes };\n }\n\n // Calculates EdDSA pub key. RFC8032 5.1.5. Privkey is hashed. Use first half with 3 bits cleared\n function getPublicKey(privKey: Hex): Uint8Array {\n return getExtendedPublicKey(privKey).pointBytes;\n }\n\n // int('LE', SHA512(dom2(F, C) || msgs)) mod N\n function hashDomainToScalar(context: Hex = new Uint8Array(), ...msgs: Uint8Array[]) {\n const msg = ut.concatBytes(...msgs);\n return modN_LE(cHash(domain(msg, ensureBytes('context', context), !!prehash)));\n }\n\n /** Signs message with privateKey. RFC8032 5.1.6 */\n function sign(msg: Hex, privKey: Hex, options: { context?: Hex } = {}): Uint8Array {\n msg = ensureBytes('message', msg);\n if (prehash) msg = prehash(msg); // for ed25519ph etc.\n const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);\n const r = hashDomainToScalar(options.context, prefix, msg); // r = dom2(F, C) || prefix || PH(M)\n const R = G.multiply(r).toRawBytes(); // R = rG\n const k = hashDomainToScalar(options.context, R, pointBytes, msg); // R || A || PH(M)\n const s = modN(r + k * scalar); // S = (r + k * s) mod L\n ut.aInRange('signature.s', s, _0n, CURVE_ORDER); // 0 <= s < l\n const res = ut.concatBytes(R, ut.numberToBytesLE(s, Fp.BYTES));\n return ensureBytes('result', res, nByteLength * 2); // 64-byte signature\n }\n\n const verifyOpts: { context?: Hex; zip215?: boolean } = VERIFY_DEFAULT;\n function verify(sig: Hex, msg: Hex, publicKey: Hex, options = verifyOpts): boolean {\n const { context, zip215 } = options;\n const len = Fp.BYTES; // Verifies EdDSA signature against message and public key. RFC8032 5.1.7.\n sig = ensureBytes('signature', sig, 2 * len); // An extended group equation is checked.\n msg = ensureBytes('message', msg);\n if (zip215 !== undefined) abool('zip215', zip215);\n if (prehash) msg = prehash(msg); // for ed25519ph, etc\n\n const s = ut.bytesToNumberLE(sig.slice(len, 2 * len));\n // zip215: true is good for consensus-critical apps and allows points < 2^256\n // zip215: false follows RFC8032 / NIST186-5 and restricts points to CURVE.p\n let A, R, SB;\n try {\n A = Point.fromHex(publicKey, zip215);\n R = Point.fromHex(sig.slice(0, len), zip215);\n SB = G.multiplyUnsafe(s); // 0 <= s < l is done inside\n } catch (error) {\n return false;\n }\n if (!zip215 && A.isSmallOrder()) return false;\n\n const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg);\n const RkA = R.add(A.multiplyUnsafe(k));\n // [8][S]B = [8]R + [8][k]A'\n return RkA.subtract(SB).clearCofactor().equals(Point.ZERO);\n }\n\n G._setWindowSize(8); // Enable precomputes. Slows down first publicKey computation by 20ms.\n\n const utils = {\n getExtendedPublicKey,\n // ed25519 private keys are uniform 32b. No need to check for modulo bias, like in secp256k1.\n randomPrivateKey: (): Uint8Array => randomBytes(Fp.BYTES),\n\n /**\n * We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT\n * values. This slows down first getPublicKey() by milliseconds (see Speed section),\n * but allows to speed-up subsequent getPublicKey() calls up to 20x.\n * @param windowSize 2, 4, 8, 16\n */\n precompute(windowSize = 8, point = Point.BASE): typeof Point.BASE {\n point._setWindowSize(windowSize);\n point.multiply(BigInt(3));\n return point;\n },\n };\n\n return {\n CURVE,\n getPublicKey,\n sign,\n verify,\n ExtendedPoint: Point,\n utils,\n };\n}\n", "/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { mod, pow } from './modular.js';\nimport {\n aInRange,\n bytesToNumberLE,\n ensureBytes,\n numberToBytesLE,\n validateObject,\n} from './utils.js';\n\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\ntype Hex = string | Uint8Array;\n\nexport type CurveType = {\n P: bigint; // finite field prime\n nByteLength: number;\n adjustScalarBytes?: (bytes: Uint8Array) => Uint8Array;\n domain?: (data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array;\n a: bigint;\n montgomeryBits: number;\n powPminus2?: (x: bigint) => bigint;\n xyToU?: (x: bigint, y: bigint) => bigint;\n Gu: bigint;\n randomBytes?: (bytesLength?: number) => Uint8Array;\n};\nexport type CurveFn = {\n scalarMult: (scalar: Hex, u: Hex) => Uint8Array;\n scalarMultBase: (scalar: Hex) => Uint8Array;\n getSharedSecret: (privateKeyA: Hex, publicKeyB: Hex) => Uint8Array;\n getPublicKey: (privateKey: Hex) => Uint8Array;\n utils: { randomPrivateKey: () => Uint8Array };\n GuBytes: Uint8Array;\n};\n\nfunction validateOpts(curve: CurveType) {\n validateObject(\n curve,\n {\n a: 'bigint',\n },\n {\n montgomeryBits: 'isSafeInteger',\n nByteLength: 'isSafeInteger',\n adjustScalarBytes: 'function',\n domain: 'function',\n powPminus2: 'function',\n Gu: 'bigint',\n }\n );\n // Set defaults\n return Object.freeze({ ...curve } as const);\n}\n\n// NOTE: not really montgomery curve, just bunch of very specific methods for X25519/X448 (RFC 7748, https://www.rfc-editor.org/rfc/rfc7748)\n// Uses only one coordinate instead of two\nexport function montgomery(curveDef: CurveType): CurveFn {\n const CURVE = validateOpts(curveDef);\n const { P } = CURVE;\n const modP = (n: bigint) => mod(n, P);\n const montgomeryBits = CURVE.montgomeryBits;\n const montgomeryBytes = Math.ceil(montgomeryBits / 8);\n const fieldLen = CURVE.nByteLength;\n const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes: Uint8Array) => bytes);\n const powPminus2 = CURVE.powPminus2 || ((x: bigint) => pow(x, P - BigInt(2), P));\n\n // cswap from RFC7748. But it is not from RFC7748!\n /*\n cswap(swap, x_2, x_3):\n dummy = mask(swap) AND (x_2 XOR x_3)\n x_2 = x_2 XOR dummy\n x_3 = x_3 XOR dummy\n Return (x_2, x_3)\n Where mask(swap) is the all-1 or all-0 word of the same length as x_2\n and x_3, computed, e.g., as mask(swap) = 0 - swap.\n */\n function cswap(swap: bigint, x_2: bigint, x_3: bigint): [bigint, bigint] {\n const dummy = modP(swap * (x_2 - x_3));\n x_2 = modP(x_2 - dummy);\n x_3 = modP(x_3 + dummy);\n return [x_2, x_3];\n }\n\n // x25519 from 4\n // The constant a24 is (486662 - 2) / 4 = 121665 for curve25519/X25519\n const a24 = (CURVE.a - BigInt(2)) / BigInt(4);\n /**\n *\n * @param pointU u coordinate (x) on Montgomery Curve 25519\n * @param scalar by which the point would be multiplied\n * @returns new Point on Montgomery curve\n */\n function montgomeryLadder(u: bigint, scalar: bigint): bigint {\n aInRange('u', u, _0n, P);\n aInRange('scalar', scalar, _0n, P);\n // Section 5: Implementations MUST accept non-canonical values and process them as\n // if they had been reduced modulo the field prime.\n const k = scalar;\n const x_1 = u;\n let x_2 = _1n;\n let z_2 = _0n;\n let x_3 = u;\n let z_3 = _1n;\n let swap = _0n;\n let sw: [bigint, bigint];\n for (let t = BigInt(montgomeryBits - 1); t >= _0n; t--) {\n const k_t = (k >> t) & _1n;\n swap ^= k_t;\n sw = cswap(swap, x_2, x_3);\n x_2 = sw[0];\n x_3 = sw[1];\n sw = cswap(swap, z_2, z_3);\n z_2 = sw[0];\n z_3 = sw[1];\n swap = k_t;\n\n const A = x_2 + z_2;\n const AA = modP(A * A);\n const B = x_2 - z_2;\n const BB = modP(B * B);\n const E = AA - BB;\n const C = x_3 + z_3;\n const D = x_3 - z_3;\n const DA = modP(D * A);\n const CB = modP(C * B);\n const dacb = DA + CB;\n const da_cb = DA - CB;\n x_3 = modP(dacb * dacb);\n z_3 = modP(x_1 * modP(da_cb * da_cb));\n x_2 = modP(AA * BB);\n z_2 = modP(E * (AA + modP(a24 * E)));\n }\n // (x_2, x_3) = cswap(swap, x_2, x_3)\n sw = cswap(swap, x_2, x_3);\n x_2 = sw[0];\n x_3 = sw[1];\n // (z_2, z_3) = cswap(swap, z_2, z_3)\n sw = cswap(swap, z_2, z_3);\n z_2 = sw[0];\n z_3 = sw[1];\n // z_2^(p - 2)\n const z2 = powPminus2(z_2);\n // Return x_2 * (z_2^(p - 2))\n return modP(x_2 * z2);\n }\n\n function encodeUCoordinate(u: bigint): Uint8Array {\n return numberToBytesLE(modP(u), montgomeryBytes);\n }\n\n function decodeUCoordinate(uEnc: Hex): bigint {\n // Section 5: When receiving such an array, implementations of X25519\n // MUST mask the most significant bit in the final byte.\n const u = ensureBytes('u coordinate', uEnc, montgomeryBytes);\n if (fieldLen === 32) u[31] &= 127; // 0b0111_1111\n return bytesToNumberLE(u);\n }\n function decodeScalar(n: Hex): bigint {\n const bytes = ensureBytes('scalar', n);\n const len = bytes.length;\n if (len !== montgomeryBytes && len !== fieldLen)\n throw new Error(`Expected ${montgomeryBytes} or ${fieldLen} bytes, got ${len}`);\n return bytesToNumberLE(adjustScalarBytes(bytes));\n }\n function scalarMult(scalar: Hex, u: Hex): Uint8Array {\n const pointU = decodeUCoordinate(u);\n const _scalar = decodeScalar(scalar);\n const pu = montgomeryLadder(pointU, _scalar);\n // The result was not contributory\n // https://cr.yp.to/ecdh.html#validate\n if (pu === _0n) throw new Error('Invalid private or public key received');\n return encodeUCoordinate(pu);\n }\n // Computes public key from private. By doing scalar multiplication of base point.\n const GuBytes = encodeUCoordinate(CURVE.Gu);\n function scalarMultBase(scalar: Hex): Uint8Array {\n return scalarMult(scalar, GuBytes);\n }\n\n return {\n scalarMult,\n scalarMultBase,\n getSharedSecret: (privateKey: Hex, publicKey: Hex) => scalarMult(privateKey, publicKey),\n getPublicKey: (privateKey: Hex): Uint8Array => scalarMultBase(privateKey),\n utils: { randomPrivateKey: () => CURVE.randomBytes!(CURVE.nByteLength) },\n GuBytes: GuBytes,\n };\n}\n", "/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha512 } from '@noble/hashes/sha512';\nimport { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils';\nimport { AffinePoint, Group } from './abstract/curve.js';\nimport { CurveFn, ExtPointType, twistedEdwards } from './abstract/edwards.js';\nimport { createHasher, expand_message_xmd, htfBasicOpts } from './abstract/hash-to-curve.js';\nimport { Field, FpSqrtEven, isNegativeLE, mod, pow2 } from './abstract/modular.js';\nimport { montgomery } from './abstract/montgomery.js';\nimport {\n bytesToHex,\n bytesToNumberLE,\n ensureBytes,\n equalBytes,\n Hex,\n numberToBytesLE,\n} from './abstract/utils.js';\n\n/**\n * ed25519 Twisted Edwards curve with following addons:\n * - X25519 ECDH\n * - Ristretto cofactor elimination\n * - Elligator hash-to-group / point indistinguishability\n */\n\nconst ED25519_P = BigInt(\n '57896044618658097711785492504343953926634992332820282019728792003956564819949'\n);\n// √(-1) aka √(a) aka 2^((p-1)/4)\nconst ED25519_SQRT_M1 = /* @__PURE__ */ BigInt(\n '19681161376707505956807079304988542015446066515923890162744021073123829784752'\n);\n\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _5n = BigInt(5), _8n = BigInt(8);\n\nfunction ed25519_pow_2_252_3(x: bigint) {\n // prettier-ignore\n const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);\n const P = ED25519_P;\n const x2 = (x * x) % P;\n const b2 = (x2 * x) % P; // x^3, 11\n const b4 = (pow2(b2, _2n, P) * b2) % P; // x^15, 1111\n const b5 = (pow2(b4, _1n, P) * x) % P; // x^31\n const b10 = (pow2(b5, _5n, P) * b5) % P;\n const b20 = (pow2(b10, _10n, P) * b10) % P;\n const b40 = (pow2(b20, _20n, P) * b20) % P;\n const b80 = (pow2(b40, _40n, P) * b40) % P;\n const b160 = (pow2(b80, _80n, P) * b80) % P;\n const b240 = (pow2(b160, _80n, P) * b80) % P;\n const b250 = (pow2(b240, _10n, P) * b10) % P;\n const pow_p_5_8 = (pow2(b250, _2n, P) * x) % P;\n // ^ To pow to (p+3)/8, multiply it by x.\n return { pow_p_5_8, b2 };\n}\n\nfunction adjustScalarBytes(bytes: Uint8Array): Uint8Array {\n // Section 5: For X25519, in order to decode 32 random bytes as an integer scalar,\n // set the three least significant bits of the first byte\n bytes[0] &= 248; // 0b1111_1000\n // and the most significant bit of the last to zero,\n bytes[31] &= 127; // 0b0111_1111\n // set the second most significant bit of the last byte to 1\n bytes[31] |= 64; // 0b0100_0000\n return bytes;\n}\n\n// sqrt(u/v)\nfunction uvRatio(u: bigint, v: bigint): { isValid: boolean; value: bigint } {\n const P = ED25519_P;\n const v3 = mod(v * v * v, P); // v³\n const v7 = mod(v3 * v3 * v, P); // v⁷\n // (p+3)/8 and (p-5)/8\n const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;\n let x = mod(u * v3 * pow, P); // (uv³)(uv⁷)^(p-5)/8\n const vx2 = mod(v * x * x, P); // vx²\n const root1 = x; // First root candidate\n const root2 = mod(x * ED25519_SQRT_M1, P); // Second root candidate\n const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root\n const useRoot2 = vx2 === mod(-u, P); // If vx² = -u, set x <-- x * 2^((p-1)/4)\n const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P); // There is no valid root, vx² = -u√(-1)\n if (useRoot1) x = root1;\n if (useRoot2 || noRoot) x = root2; // We return root2 anyway, for const-time\n if (isNegativeLE(x, P)) x = mod(-x, P);\n return { isValid: useRoot1 || useRoot2, value: x };\n}\n\n// Just in case\nexport const ED25519_TORSION_SUBGROUP = [\n '0100000000000000000000000000000000000000000000000000000000000000',\n 'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a',\n '0000000000000000000000000000000000000000000000000000000000000080',\n '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05',\n 'ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f',\n '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85',\n '0000000000000000000000000000000000000000000000000000000000000000',\n 'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa',\n];\n\nconst Fp = /* @__PURE__ */ (() => Field(ED25519_P, undefined, true))();\n\nconst ed25519Defaults = /* @__PURE__ */ (() =>\n ({\n // Param: a\n a: BigInt(-1), // Fp.create(-1) is proper; our way still works and is faster\n // d is equal to -121665/121666 over finite field.\n // Negative number is P - number, and division is invert(number, P)\n d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),\n // Finite field 𝔽p over which we'll do calculations; 2n**255n - 19n\n Fp,\n // Subgroup order: how many points curve has\n // 2n**252n + 27742317777372353535851937790883648493n;\n n: BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989'),\n // Cofactor\n h: _8n,\n // Base point (x, y) aka generator point\n Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),\n Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),\n hash: sha512,\n randomBytes,\n adjustScalarBytes,\n // dom2\n // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.\n // Constant-time, u/√v\n uvRatio,\n }) as const)();\n\n/**\n * ed25519 curve with EdDSA signatures.\n */\nexport const ed25519: CurveFn = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();\n\nfunction ed25519_domain(data: Uint8Array, ctx: Uint8Array, phflag: boolean) {\n if (ctx.length > 255) throw new Error('Context is too big');\n return concatBytes(\n utf8ToBytes('SigEd25519 no Ed25519 collisions'),\n new Uint8Array([phflag ? 1 : 0, ctx.length]),\n ctx,\n data\n );\n}\n\nexport const ed25519ctx = /* @__PURE__ */ (() =>\n twistedEdwards({\n ...ed25519Defaults,\n domain: ed25519_domain,\n }))();\nexport const ed25519ph = /* @__PURE__ */ (() =>\n twistedEdwards(\n Object.assign({}, ed25519Defaults, {\n domain: ed25519_domain,\n prehash: sha512,\n })\n ))();\n\nexport const x25519 = /* @__PURE__ */ (() =>\n montgomery({\n P: ED25519_P,\n a: BigInt(486662),\n montgomeryBits: 255, // n is 253 bits\n nByteLength: 32,\n Gu: BigInt(9),\n powPminus2: (x: bigint): bigint => {\n const P = ED25519_P;\n // x^(p-2) aka x^(2^255-21)\n const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);\n return mod(pow2(pow_p_5_8, _3n, P) * b2, P);\n },\n adjustScalarBytes,\n randomBytes,\n }))();\n\n/**\n * Converts ed25519 public key to x25519 public key. Uses formula:\n * * `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`\n * * `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`\n * @example\n * const someonesPub = ed25519.getPublicKey(ed25519.utils.randomPrivateKey());\n * const aPriv = x25519.utils.randomPrivateKey();\n * x25519.getSharedSecret(aPriv, edwardsToMontgomeryPub(someonesPub))\n */\nexport function edwardsToMontgomeryPub(edwardsPub: Hex): Uint8Array {\n const { y } = ed25519.ExtendedPoint.fromHex(edwardsPub);\n const _1n = BigInt(1);\n return Fp.toBytes(Fp.create((_1n + y) * Fp.inv(_1n - y)));\n}\nexport const edwardsToMontgomery = edwardsToMontgomeryPub; // deprecated\n\n/**\n * Converts ed25519 secret key to x25519 secret key.\n * @example\n * const someonesPub = x25519.getPublicKey(x25519.utils.randomPrivateKey());\n * const aPriv = ed25519.utils.randomPrivateKey();\n * x25519.getSharedSecret(edwardsToMontgomeryPriv(aPriv), someonesPub)\n */\nexport function edwardsToMontgomeryPriv(edwardsPriv: Uint8Array): Uint8Array {\n const hashed = ed25519Defaults.hash(edwardsPriv.subarray(0, 32));\n return ed25519Defaults.adjustScalarBytes(hashed).subarray(0, 32);\n}\n\n// Hash To Curve Elligator2 Map (NOTE: different from ristretto255 elligator)\n// NOTE: very important part is usage of FpSqrtEven for ELL2_C1_EDWARDS, since\n// SageMath returns different root first and everything falls apart\n\nconst ELL2_C1 = /* @__PURE__ */ (() => (Fp.ORDER + _3n) / _8n)(); // 1. c1 = (q + 3) / 8 # Integer arithmetic\nconst ELL2_C2 = /* @__PURE__ */ (() => Fp.pow(_2n, ELL2_C1))(); // 2. c2 = 2^c1\nconst ELL2_C3 = /* @__PURE__ */ (() => Fp.sqrt(Fp.neg(Fp.ONE)))(); // 3. c3 = sqrt(-1)\n\n// prettier-ignore\nfunction map_to_curve_elligator2_curve25519(u: bigint) {\n const ELL2_C4 = (Fp.ORDER - _5n) / _8n; // 4. c4 = (q - 5) / 8 # Integer arithmetic\n const ELL2_J = BigInt(486662);\n\n let tv1 = Fp.sqr(u); // 1. tv1 = u^2\n tv1 = Fp.mul(tv1, _2n); // 2. tv1 = 2 * tv1\n let xd = Fp.add(tv1, Fp.ONE); // 3. xd = tv1 + 1 # Nonzero: -1 is square (mod p), tv1 is not\n let x1n = Fp.neg(ELL2_J); // 4. x1n = -J # x1 = x1n / xd = -J / (1 + 2 * u^2)\n let tv2 = Fp.sqr(xd); // 5. tv2 = xd^2\n let gxd = Fp.mul(tv2, xd); // 6. gxd = tv2 * xd # gxd = xd^3\n let gx1 = Fp.mul(tv1, ELL2_J);// 7. gx1 = J * tv1 # x1n + J * xd\n gx1 = Fp.mul(gx1, x1n); // 8. gx1 = gx1 * x1n # x1n^2 + J * x1n * xd\n gx1 = Fp.add(gx1, tv2); // 9. gx1 = gx1 + tv2 # x1n^2 + J * x1n * xd + xd^2\n gx1 = Fp.mul(gx1, x1n); // 10. gx1 = gx1 * x1n # x1n^3 + J * x1n^2 * xd + x1n * xd^2\n let tv3 = Fp.sqr(gxd); // 11. tv3 = gxd^2\n tv2 = Fp.sqr(tv3); // 12. tv2 = tv3^2 # gxd^4\n tv3 = Fp.mul(tv3, gxd); // 13. tv3 = tv3 * gxd # gxd^3\n tv3 = Fp.mul(tv3, gx1); // 14. tv3 = tv3 * gx1 # gx1 * gxd^3\n tv2 = Fp.mul(tv2, tv3); // 15. tv2 = tv2 * tv3 # gx1 * gxd^7\n let y11 = Fp.pow(tv2, ELL2_C4); // 16. y11 = tv2^c4 # (gx1 * gxd^7)^((p - 5) / 8)\n y11 = Fp.mul(y11, tv3); // 17. y11 = y11 * tv3 # gx1*gxd^3*(gx1*gxd^7)^((p-5)/8)\n let y12 = Fp.mul(y11, ELL2_C3); // 18. y12 = y11 * c3\n tv2 = Fp.sqr(y11); // 19. tv2 = y11^2\n tv2 = Fp.mul(tv2, gxd); // 20. tv2 = tv2 * gxd\n let e1 = Fp.eql(tv2, gx1); // 21. e1 = tv2 == gx1\n let y1 = Fp.cmov(y12, y11, e1); // 22. y1 = CMOV(y12, y11, e1) # If g(x1) is square, this is its sqrt\n let x2n = Fp.mul(x1n, tv1); // 23. x2n = x1n * tv1 # x2 = x2n / xd = 2 * u^2 * x1n / xd\n let y21 = Fp.mul(y11, u); // 24. y21 = y11 * u\n y21 = Fp.mul(y21, ELL2_C2); // 25. y21 = y21 * c2\n let y22 = Fp.mul(y21, ELL2_C3); // 26. y22 = y21 * c3\n let gx2 = Fp.mul(gx1, tv1); // 27. gx2 = gx1 * tv1 # g(x2) = gx2 / gxd = 2 * u^2 * g(x1)\n tv2 = Fp.sqr(y21); // 28. tv2 = y21^2\n tv2 = Fp.mul(tv2, gxd); // 29. tv2 = tv2 * gxd\n let e2 = Fp.eql(tv2, gx2); // 30. e2 = tv2 == gx2\n let y2 = Fp.cmov(y22, y21, e2); // 31. y2 = CMOV(y22, y21, e2) # If g(x2) is square, this is its sqrt\n tv2 = Fp.sqr(y1); // 32. tv2 = y1^2\n tv2 = Fp.mul(tv2, gxd); // 33. tv2 = tv2 * gxd\n let e3 = Fp.eql(tv2, gx1); // 34. e3 = tv2 == gx1\n let xn = Fp.cmov(x2n, x1n, e3); // 35. xn = CMOV(x2n, x1n, e3) # If e3, x = x1, else x = x2\n let y = Fp.cmov(y2, y1, e3); // 36. y = CMOV(y2, y1, e3) # If e3, y = y1, else y = y2\n let e4 = Fp.isOdd(y); // 37. e4 = sgn0(y) == 1 # Fix sign of y\n y = Fp.cmov(y, Fp.neg(y), e3 !== e4); // 38. y = CMOV(y, -y, e3 XOR e4)\n return { xMn: xn, xMd: xd, yMn: y, yMd: _1n }; // 39. return (xn, xd, y, 1)\n}\n\nconst ELL2_C1_EDWARDS = /* @__PURE__ */ (() => FpSqrtEven(Fp, Fp.neg(BigInt(486664))))(); // sgn0(c1) MUST equal 0\nfunction map_to_curve_elligator2_edwards25519(u: bigint) {\n const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u); // 1. (xMn, xMd, yMn, yMd) =\n // map_to_curve_elligator2_curve25519(u)\n let xn = Fp.mul(xMn, yMd); // 2. xn = xMn * yMd\n xn = Fp.mul(xn, ELL2_C1_EDWARDS); // 3. xn = xn * c1\n let xd = Fp.mul(xMd, yMn); // 4. xd = xMd * yMn # xn / xd = c1 * xM / yM\n let yn = Fp.sub(xMn, xMd); // 5. yn = xMn - xMd\n let yd = Fp.add(xMn, xMd); // 6. yd = xMn + xMd # (n / d - 1) / (n / d + 1) = (n - d) / (n + d)\n let tv1 = Fp.mul(xd, yd); // 7. tv1 = xd * yd\n let e = Fp.eql(tv1, Fp.ZERO); // 8. e = tv1 == 0\n xn = Fp.cmov(xn, Fp.ZERO, e); // 9. xn = CMOV(xn, 0, e)\n xd = Fp.cmov(xd, Fp.ONE, e); // 10. xd = CMOV(xd, 1, e)\n yn = Fp.cmov(yn, Fp.ONE, e); // 11. yn = CMOV(yn, 1, e)\n yd = Fp.cmov(yd, Fp.ONE, e); // 12. yd = CMOV(yd, 1, e)\n\n const inv = Fp.invertBatch([xd, yd]); // batch division\n return { x: Fp.mul(xn, inv[0]), y: Fp.mul(yn, inv[1]) }; // 13. return (xn, xd, yn, yd)\n}\n\nconst htf = /* @__PURE__ */ (() =>\n createHasher(\n ed25519.ExtendedPoint,\n (scalars: bigint[]) => map_to_curve_elligator2_edwards25519(scalars[0]),\n {\n DST: 'edwards25519_XMD:SHA-512_ELL2_RO_',\n encodeDST: 'edwards25519_XMD:SHA-512_ELL2_NU_',\n p: Fp.ORDER,\n m: 1,\n k: 128,\n expand: 'xmd',\n hash: sha512,\n }\n ))();\nexport const hashToCurve = /* @__PURE__ */ (() => htf.hashToCurve)();\nexport const encodeToCurve = /* @__PURE__ */ (() => htf.encodeToCurve)();\n\nfunction assertRstPoint(other: unknown) {\n if (!(other instanceof RistPoint)) throw new Error('RistrettoPoint expected');\n}\n\n// √(-1) aka √(a) aka 2^((p-1)/4)\nconst SQRT_M1 = ED25519_SQRT_M1;\n// √(ad - 1)\nconst SQRT_AD_MINUS_ONE = /* @__PURE__ */ BigInt(\n '25063068953384623474111414158702152701244531502492656460079210482610430750235'\n);\n// 1 / √(a-d)\nconst INVSQRT_A_MINUS_D = /* @__PURE__ */ BigInt(\n '54469307008909316920995813868745141605393597292927456921205312896311721017578'\n);\n// 1-d²\nconst ONE_MINUS_D_SQ = /* @__PURE__ */ BigInt(\n '1159843021668779879193775521855586647937357759715417654439879720876111806838'\n);\n// (d-1)²\nconst D_MINUS_ONE_SQ = /* @__PURE__ */ BigInt(\n '40440834346308536858101042469323190826248399146238708352240133220865137265952'\n);\n// Calculates 1/√(number)\nconst invertSqrt = (number: bigint) => uvRatio(_1n, number);\n\nconst MAX_255B = /* @__PURE__ */ BigInt(\n '0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'\n);\nconst bytes255ToNumberLE = (bytes: Uint8Array) =>\n ed25519.CURVE.Fp.create(bytesToNumberLE(bytes) & MAX_255B);\n\ntype ExtendedPoint = ExtPointType;\n\n// Computes Elligator map for Ristretto\n// https://ristretto.group/formulas/elligator.html\nfunction calcElligatorRistrettoMap(r0: bigint): ExtendedPoint {\n const { d } = ed25519.CURVE;\n const P = ed25519.CURVE.Fp.ORDER;\n const mod = ed25519.CURVE.Fp.create;\n const r = mod(SQRT_M1 * r0 * r0); // 1\n const Ns = mod((r + _1n) * ONE_MINUS_D_SQ); // 2\n let c = BigInt(-1); // 3\n const D = mod((c - d * r) * mod(r + d)); // 4\n let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D); // 5\n let s_ = mod(s * r0); // 6\n if (!isNegativeLE(s_, P)) s_ = mod(-s_);\n if (!Ns_D_is_sq) s = s_; // 7\n if (!Ns_D_is_sq) c = r; // 8\n const Nt = mod(c * (r - _1n) * D_MINUS_ONE_SQ - D); // 9\n const s2 = s * s;\n const W0 = mod((s + s) * D); // 10\n const W1 = mod(Nt * SQRT_AD_MINUS_ONE); // 11\n const W2 = mod(_1n - s2); // 12\n const W3 = mod(_1n + s2); // 13\n return new ed25519.ExtendedPoint(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));\n}\n\n/**\n * Each ed25519/ExtendedPoint has 8 different equivalent points. This can be\n * a source of bugs for protocols like ring signatures. Ristretto was created to solve this.\n * Ristretto point operates in X:Y:Z:T extended coordinates like ExtendedPoint,\n * but it should work in its own namespace: do not combine those two.\n * https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-ristretto255-decaf448\n */\nclass RistPoint implements Group {\n static BASE: RistPoint;\n static ZERO: RistPoint;\n // Private property to discourage combining ExtendedPoint + RistrettoPoint\n // Always use Ristretto encoding/decoding instead.\n constructor(private readonly ep: ExtendedPoint) {}\n\n static fromAffine(ap: AffinePoint) {\n return new RistPoint(ed25519.ExtendedPoint.fromAffine(ap));\n }\n\n /**\n * Takes uniform output of 64-byte hash function like sha512 and converts it to `RistrettoPoint`.\n * The hash-to-group operation applies Elligator twice and adds the results.\n * **Note:** this is one-way map, there is no conversion from point to hash.\n * https://ristretto.group/formulas/elligator.html\n * @param hex 64-byte output of a hash function\n */\n static hashToCurve(hex: Hex): RistPoint {\n hex = ensureBytes('ristrettoHash', hex, 64);\n const r1 = bytes255ToNumberLE(hex.slice(0, 32));\n const R1 = calcElligatorRistrettoMap(r1);\n const r2 = bytes255ToNumberLE(hex.slice(32, 64));\n const R2 = calcElligatorRistrettoMap(r2);\n return new RistPoint(R1.add(R2));\n }\n\n /**\n * Converts ristretto-encoded string to ristretto point.\n * https://ristretto.group/formulas/decoding.html\n * @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding\n */\n static fromHex(hex: Hex): RistPoint {\n hex = ensureBytes('ristrettoHex', hex, 32);\n const { a, d } = ed25519.CURVE;\n const P = ed25519.CURVE.Fp.ORDER;\n const mod = ed25519.CURVE.Fp.create;\n const emsg = 'RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint';\n const s = bytes255ToNumberLE(hex);\n // 1. Check that s_bytes is the canonical encoding of a field element, or else abort.\n // 3. Check that s is non-negative, or else abort\n if (!equalBytes(numberToBytesLE(s, 32), hex) || isNegativeLE(s, P)) throw new Error(emsg);\n const s2 = mod(s * s);\n const u1 = mod(_1n + a * s2); // 4 (a is -1)\n const u2 = mod(_1n - a * s2); // 5\n const u1_2 = mod(u1 * u1);\n const u2_2 = mod(u2 * u2);\n const v = mod(a * d * u1_2 - u2_2); // 6\n const { isValid, value: I } = invertSqrt(mod(v * u2_2)); // 7\n const Dx = mod(I * u2); // 8\n const Dy = mod(I * Dx * v); // 9\n let x = mod((s + s) * Dx); // 10\n if (isNegativeLE(x, P)) x = mod(-x); // 10\n const y = mod(u1 * Dy); // 11\n const t = mod(x * y); // 12\n if (!isValid || isNegativeLE(t, P) || y === _0n) throw new Error(emsg);\n return new RistPoint(new ed25519.ExtendedPoint(x, y, _1n, t));\n }\n\n /**\n * Encodes ristretto point to Uint8Array.\n * https://ristretto.group/formulas/encoding.html\n */\n toRawBytes(): Uint8Array {\n let { ex: x, ey: y, ez: z, et: t } = this.ep;\n const P = ed25519.CURVE.Fp.ORDER;\n const mod = ed25519.CURVE.Fp.create;\n const u1 = mod(mod(z + y) * mod(z - y)); // 1\n const u2 = mod(x * y); // 2\n // Square root always exists\n const u2sq = mod(u2 * u2);\n const { value: invsqrt } = invertSqrt(mod(u1 * u2sq)); // 3\n const D1 = mod(invsqrt * u1); // 4\n const D2 = mod(invsqrt * u2); // 5\n const zInv = mod(D1 * D2 * t); // 6\n let D: bigint; // 7\n if (isNegativeLE(t * zInv, P)) {\n let _x = mod(y * SQRT_M1);\n let _y = mod(x * SQRT_M1);\n x = _x;\n y = _y;\n D = mod(D1 * INVSQRT_A_MINUS_D);\n } else {\n D = D2; // 8\n }\n if (isNegativeLE(x * zInv, P)) y = mod(-y); // 9\n let s = mod((z - y) * D); // 10 (check footer's note, no sqrt(-a))\n if (isNegativeLE(s, P)) s = mod(-s);\n return numberToBytesLE(s, 32); // 11\n }\n\n toHex(): string {\n return bytesToHex(this.toRawBytes());\n }\n\n toString(): string {\n return this.toHex();\n }\n\n // Compare one point to another.\n equals(other: RistPoint): boolean {\n assertRstPoint(other);\n const { ex: X1, ey: Y1 } = this.ep;\n const { ex: X2, ey: Y2 } = other.ep;\n const mod = ed25519.CURVE.Fp.create;\n // (x1 * y2 == y1 * x2) | (y1 * y2 == x1 * x2)\n const one = mod(X1 * Y2) === mod(Y1 * X2);\n const two = mod(Y1 * Y2) === mod(X1 * X2);\n return one || two;\n }\n\n add(other: RistPoint): RistPoint {\n assertRstPoint(other);\n return new RistPoint(this.ep.add(other.ep));\n }\n\n subtract(other: RistPoint): RistPoint {\n assertRstPoint(other);\n return new RistPoint(this.ep.subtract(other.ep));\n }\n\n multiply(scalar: bigint): RistPoint {\n return new RistPoint(this.ep.multiply(scalar));\n }\n\n multiplyUnsafe(scalar: bigint): RistPoint {\n return new RistPoint(this.ep.multiplyUnsafe(scalar));\n }\n\n double(): RistPoint {\n return new RistPoint(this.ep.double());\n }\n\n negate(): RistPoint {\n return new RistPoint(this.ep.negate());\n }\n}\nexport const RistrettoPoint = /* @__PURE__ */ (() => {\n if (!RistPoint.BASE) RistPoint.BASE = new RistPoint(ed25519.ExtendedPoint.BASE);\n if (!RistPoint.ZERO) RistPoint.ZERO = new RistPoint(ed25519.ExtendedPoint.ZERO);\n return RistPoint;\n})();\n\n// Hashing to ristretto255. https://www.rfc-editor.org/rfc/rfc9380#appendix-B\nexport const hashToRistretto255 = (msg: Uint8Array, options: htfBasicOpts) => {\n const d = options.DST;\n const DST = typeof d === 'string' ? utf8ToBytes(d) : d;\n const uniform_bytes = expand_message_xmd(msg, DST, 64, sha512);\n const P = RistPoint.hashToCurve(uniform_bytes);\n return P;\n};\nexport const hash_to_ristretto255 = hashToRistretto255; // legacy\n", "export type ExpirableMapOptions = {\n source?: Iterable<[K, V]>;\n expirationTime?: number;\n};\n\n/**\n * A map that expires entries after a given time.\n * Defaults to 10 minutes.\n */\nexport class ExpirableMap implements Map {\n // Internals\n #inner: Map;\n #expirationTime: number;\n\n [Symbol.iterator]: () => IterableIterator<[K, V]> = this.entries.bind(this);\n [Symbol.toStringTag] = 'ExpirableMap';\n\n /**\n * Create a new ExpirableMap.\n * @param {ExpirableMapOptions} options - options for the map.\n * @param {Iterable<[any, any]>} options.source - an optional source of entries to initialize the map with.\n * @param {number} options.expirationTime - the time in milliseconds after which entries will expire.\n */\n constructor(options: ExpirableMapOptions = {}) {\n const { source = [], expirationTime = 10 * 60 * 1000 } = options;\n const currentTime = Date.now();\n this.#inner = new Map(\n [...source].map(([key, value]) => [key, { value, timestamp: currentTime }]),\n );\n this.#expirationTime = expirationTime;\n }\n\n /**\n * Prune removes all expired entries.\n */\n prune() {\n const currentTime = Date.now();\n for (const [key, entry] of this.#inner.entries()) {\n if (currentTime - entry.timestamp > this.#expirationTime) {\n this.#inner.delete(key);\n }\n }\n return this;\n }\n\n // Implementing the Map interface\n\n /**\n * Set the value for the given key. Prunes expired entries.\n * @param key for the entry\n * @param value of the entry\n * @returns this\n */\n set(key: K, value: V) {\n this.prune();\n const entry = {\n value,\n timestamp: Date.now(),\n };\n this.#inner.set(key, entry);\n\n return this;\n }\n\n /**\n * Get the value associated with the key, if it exists and has not expired.\n * @param key K\n * @returns the value associated with the key, or undefined if the key is not present or has expired.\n */\n get(key: K) {\n const entry = this.#inner.get(key);\n if (entry === undefined) {\n return undefined;\n }\n if (Date.now() - entry.timestamp > this.#expirationTime) {\n this.#inner.delete(key);\n return undefined;\n }\n return entry.value;\n }\n\n /**\n * Clear all entries.\n */\n clear() {\n this.#inner.clear();\n }\n\n /**\n * Entries returns the entries of the map, without the expiration time.\n * @returns an iterator over the entries of the map.\n */\n entries(): IterableIterator<[K, V]> {\n const iterator = this.#inner.entries();\n const generator = function* () {\n for (const [key, value] of iterator) {\n yield [key, value.value] as [K, V];\n }\n };\n return generator();\n }\n\n /**\n * Values returns the values of the map, without the expiration time.\n * @returns an iterator over the values of the map.\n */\n values(): IterableIterator {\n const iterator = this.#inner.values();\n const generator = function* () {\n for (const value of iterator) {\n yield value.value;\n }\n };\n return generator();\n }\n\n /**\n * Keys returns the keys of the map\n * @returns an iterator over the keys of the map.\n */\n keys(): IterableIterator {\n return this.#inner.keys();\n }\n\n /**\n * forEach calls the callbackfn on each entry of the map.\n * @param callbackfn to call on each entry\n * @param thisArg to use as this when calling the callbackfn\n */\n forEach(callbackfn: (value: V, key: K, map: Map) => void, thisArg?: ExpirableMap) {\n for (const [key, value] of this.#inner.entries()) {\n callbackfn.call(thisArg, value.value, key, this);\n }\n }\n\n /**\n * has returns true if the key exists and has not expired.\n * @param key K\n * @returns true if the key exists and has not expired.\n */\n has(key: K): boolean {\n return this.#inner.has(key);\n }\n\n /**\n * delete the entry for the given key.\n * @param key K\n * @returns true if the key existed and has been deleted.\n */\n delete(key: K) {\n return this.#inner.delete(key);\n }\n\n /**\n * get size of the map.\n * @returns the size of the map.\n */\n get size() {\n return this.#inner.size;\n }\n}\n", "import { bufEquals } from './utils/buffer';\n\nexport const encodeLenBytes = (len: number): number => {\n if (len <= 0x7f) {\n return 1;\n } else if (len <= 0xff) {\n return 2;\n } else if (len <= 0xffff) {\n return 3;\n } else if (len <= 0xffffff) {\n return 4;\n } else {\n throw new Error('Length too long (> 4 bytes)');\n }\n};\n\nexport const encodeLen = (buf: Uint8Array, offset: number, len: number): number => {\n if (len <= 0x7f) {\n buf[offset] = len;\n return 1;\n } else if (len <= 0xff) {\n buf[offset] = 0x81;\n buf[offset + 1] = len;\n return 2;\n } else if (len <= 0xffff) {\n buf[offset] = 0x82;\n buf[offset + 1] = len >> 8;\n buf[offset + 2] = len;\n return 3;\n } else if (len <= 0xffffff) {\n buf[offset] = 0x83;\n buf[offset + 1] = len >> 16;\n buf[offset + 2] = len >> 8;\n buf[offset + 3] = len;\n return 4;\n } else {\n throw new Error('Length too long (> 4 bytes)');\n }\n};\n\nexport const decodeLenBytes = (buf: Uint8Array, offset: number): number => {\n if (buf[offset] < 0x80) return 1;\n if (buf[offset] === 0x80) throw new Error('Invalid length 0');\n if (buf[offset] === 0x81) return 2;\n if (buf[offset] === 0x82) return 3;\n if (buf[offset] === 0x83) return 4;\n throw new Error('Length too long (> 4 bytes)');\n};\n\nexport const decodeLen = (buf: Uint8Array, offset: number): number => {\n const lenBytes = decodeLenBytes(buf, offset);\n if (lenBytes === 1) return buf[offset];\n else if (lenBytes === 2) return buf[offset + 1];\n else if (lenBytes === 3) return (buf[offset + 1] << 8) + buf[offset + 2];\n else if (lenBytes === 4)\n return (buf[offset + 1] << 16) + (buf[offset + 2] << 8) + buf[offset + 3];\n throw new Error('Length too long (> 4 bytes)');\n};\n\n/**\n * A DER encoded `SEQUENCE(OID)` for DER-encoded-COSE\n */\nexport const DER_COSE_OID = Uint8Array.from([\n ...[0x30, 0x0c], // SEQUENCE\n ...[0x06, 0x0a], // OID with 10 bytes\n ...[0x2b, 0x06, 0x01, 0x04, 0x01, 0x83, 0xb8, 0x43, 0x01, 0x01], // DER encoded COSE\n]);\n\n/**\n * A DER encoded `SEQUENCE(OID)` for the Ed25519 algorithm\n */\nexport const ED25519_OID = Uint8Array.from([\n ...[0x30, 0x05], // SEQUENCE\n ...[0x06, 0x03], // OID with 3 bytes\n ...[0x2b, 0x65, 0x70], // id-Ed25519 OID\n]);\n\n/**\n * A DER encoded `SEQUENCE(OID)` for secp256k1 with the ECDSA algorithm\n */\nexport const SECP256K1_OID = Uint8Array.from([\n ...[0x30, 0x10], // SEQUENCE\n ...[0x06, 0x07], // OID with 7 bytes\n ...[0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01], // OID ECDSA\n ...[0x06, 0x05], // OID with 5 bytes\n ...[0x2b, 0x81, 0x04, 0x00, 0x0a], // OID secp256k1\n]);\n\n/**\n * Wraps the given `payload` in a DER encoding tagged with the given encoded `oid` like so:\n * `SEQUENCE(oid, BITSTRING(payload))`\n *\n * @param payload The payload to encode as the bit string\n * @param oid The DER encoded (and SEQUENCE wrapped!) OID to tag the payload with\n */\nexport function wrapDER(payload: ArrayBuffer, oid: Uint8Array): Uint8Array {\n // The Bit String header needs to include the unused bit count byte in its length\n const bitStringHeaderLength = 2 + encodeLenBytes(payload.byteLength + 1);\n const len = oid.byteLength + bitStringHeaderLength + payload.byteLength;\n let offset = 0;\n const buf = new Uint8Array(1 + encodeLenBytes(len) + len);\n // Sequence\n buf[offset++] = 0x30;\n // Sequence Length\n offset += encodeLen(buf, offset, len);\n\n // OID\n buf.set(oid, offset);\n offset += oid.byteLength;\n\n // Bit String Header\n buf[offset++] = 0x03;\n offset += encodeLen(buf, offset, payload.byteLength + 1);\n // 0 padding\n buf[offset++] = 0x00;\n buf.set(new Uint8Array(payload), offset);\n\n return buf;\n}\n\n/**\n * Extracts a payload from the given `derEncoded` data, and checks that it was tagged with the given `oid`.\n *\n * `derEncoded = SEQUENCE(oid, BITSTRING(payload))`\n *\n * @param derEncoded The DER encoded and tagged data\n * @param oid The DER encoded (and SEQUENCE wrapped!) expected OID\n * @returns The unwrapped payload\n */\nexport const unwrapDER = (derEncoded: ArrayBuffer, oid: Uint8Array): Uint8Array => {\n let offset = 0;\n const expect = (n: number, msg: string) => {\n if (buf[offset++] !== n) {\n throw new Error('Expected: ' + msg);\n }\n };\n\n const buf = new Uint8Array(derEncoded);\n expect(0x30, 'sequence');\n offset += decodeLenBytes(buf, offset);\n\n if (!bufEquals(buf.slice(offset, offset + oid.byteLength), oid)) {\n throw new Error('Not the expected OID.');\n }\n offset += oid.byteLength;\n\n expect(0x03, 'bit string');\n const payloadLen = decodeLen(buf, offset) - 1; // Subtracting 1 to account for the 0 padding\n offset += decodeLenBytes(buf, offset);\n expect(0x00, '0 padding');\n const result = buf.slice(offset);\n if (payloadLen !== result.length) {\n throw new Error(\n `DER payload mismatch: Expected length ${payloadLen} actual length ${result.length}`,\n );\n }\n return result;\n};\n", "import { DerEncodedPublicKey, PublicKey } from './auth';\nimport { ED25519_OID, unwrapDER, wrapDER } from './der';\n\nexport class Ed25519PublicKey implements PublicKey {\n public static from(key: PublicKey): Ed25519PublicKey {\n return this.fromDer(key.toDer());\n }\n\n public static fromRaw(rawKey: ArrayBuffer): Ed25519PublicKey {\n return new Ed25519PublicKey(rawKey);\n }\n\n public static fromDer(derKey: DerEncodedPublicKey): Ed25519PublicKey {\n return new Ed25519PublicKey(this.derDecode(derKey));\n }\n\n // The length of Ed25519 public keys is always 32 bytes.\n private static RAW_KEY_LENGTH = 32;\n\n private static derEncode(publicKey: ArrayBuffer): DerEncodedPublicKey {\n return wrapDER(publicKey, ED25519_OID).buffer as DerEncodedPublicKey;\n }\n\n private static derDecode(key: DerEncodedPublicKey): ArrayBuffer {\n const unwrapped = unwrapDER(key, ED25519_OID);\n if (unwrapped.length !== this.RAW_KEY_LENGTH) {\n throw new Error('An Ed25519 public key must be exactly 32bytes long');\n }\n return unwrapped;\n }\n\n #rawKey: ArrayBuffer;\n\n public get rawKey(): ArrayBuffer {\n return this.#rawKey;\n }\n\n #derKey: DerEncodedPublicKey;\n\n public get derKey(): DerEncodedPublicKey {\n return this.#derKey;\n }\n\n // `fromRaw` and `fromDer` should be used for instantiation, not this constructor.\n private constructor(key: ArrayBuffer) {\n if (key.byteLength !== Ed25519PublicKey.RAW_KEY_LENGTH) {\n throw new Error('An Ed25519 public key must be exactly 32bytes long');\n }\n this.#rawKey = key;\n this.#derKey = Ed25519PublicKey.derEncode(key);\n }\n\n public toDer(): DerEncodedPublicKey {\n return this.derKey;\n }\n\n public toRaw(): ArrayBuffer {\n return this.rawKey;\n }\n}\n", "import { AgentError } from './errors';\n\nexport type ObserveFunction = (data: T, ...rest: unknown[]) => void;\n\nexport class Observable {\n observers: ObserveFunction[];\n\n constructor() {\n this.observers = [];\n }\n\n subscribe(func: ObserveFunction) {\n this.observers.push(func);\n }\n\n unsubscribe(func: ObserveFunction) {\n this.observers = this.observers.filter(observer => observer !== func);\n }\n\n notify(data: T, ...rest: unknown[]) {\n this.observers.forEach(observer => observer(data, ...rest));\n }\n}\n\nexport type AgentLog =\n | {\n message: string;\n level: 'warn' | 'info';\n }\n | {\n message: string;\n level: 'error';\n error: AgentError;\n };\n\nexport class ObservableLog extends Observable {\n constructor() {\n super();\n }\n print(message: string, ...rest: unknown[]) {\n this.notify({ message, level: 'info' }, ...rest);\n }\n warn(message: string, ...rest: unknown[]) {\n this.notify({ message, level: 'warn' }, ...rest);\n }\n error(message: string, error: AgentError, ...rest: unknown[]) {\n this.notify({ message, level: 'error', error }, ...rest);\n }\n}\n", "const RANDOMIZATION_FACTOR = 0.5;\nconst MULTIPLIER = 1.5;\nconst INITIAL_INTERVAL_MSEC = 500;\nconst MAX_INTERVAL_MSEC = 60_000;\nconst MAX_ELAPSED_TIME_MSEC = 900_000;\nconst MAX_ITERATIONS = 10;\n\nexport type BackoffStrategy = {\n next: () => number | null;\n currentInterval?: number;\n count?: number;\n ellapsedTimeInMsec?: number;\n};\n\nexport type BackoffStrategyArgs = {\n maxIterations?: number;\n maxElapsedTime?: number;\n};\n\nexport type BackoffStrategyFactory = (args?: BackoffStrategyArgs) => BackoffStrategy;\n\n// export type BackoffStrategyGenerator = Generator;\n\nexport type ExponentialBackoffOptions = {\n initialInterval?: number;\n randomizationFactor?: number;\n multiplier?: number;\n maxInterval?: number;\n maxElapsedTime?: number;\n maxIterations?: number;\n date?: DateConstructor;\n};\n\n/**\n * Exponential backoff strategy.\n */\nexport class ExponentialBackoff {\n #currentInterval: number;\n #randomizationFactor: number;\n #multiplier: number;\n #maxInterval: number;\n #startTime: number;\n #maxElapsedTime: number;\n #maxIterations: number;\n #date: DateConstructor;\n #count = 0;\n\n static default = {\n initialInterval: INITIAL_INTERVAL_MSEC,\n randomizationFactor: RANDOMIZATION_FACTOR,\n multiplier: MULTIPLIER,\n maxInterval: MAX_INTERVAL_MSEC,\n // 1 minute\n maxElapsedTime: MAX_ELAPSED_TIME_MSEC,\n maxIterations: MAX_ITERATIONS,\n date: Date,\n };\n\n constructor(options: ExponentialBackoffOptions = ExponentialBackoff.default) {\n const {\n initialInterval = INITIAL_INTERVAL_MSEC,\n randomizationFactor = RANDOMIZATION_FACTOR,\n multiplier = MULTIPLIER,\n maxInterval = MAX_INTERVAL_MSEC,\n maxElapsedTime = MAX_ELAPSED_TIME_MSEC,\n maxIterations = MAX_ITERATIONS,\n date = Date,\n } = options;\n this.#currentInterval = initialInterval;\n this.#randomizationFactor = randomizationFactor;\n this.#multiplier = multiplier;\n this.#maxInterval = maxInterval;\n this.#date = date;\n this.#startTime = date.now();\n this.#maxElapsedTime = maxElapsedTime;\n this.#maxIterations = maxIterations;\n }\n\n get ellapsedTimeInMsec() {\n return this.#date.now() - this.#startTime;\n }\n\n get currentInterval() {\n return this.#currentInterval;\n }\n\n get count() {\n return this.#count;\n }\n\n get randomValueFromInterval() {\n const delta = this.#randomizationFactor * this.#currentInterval;\n const min = this.#currentInterval - delta;\n const max = this.#currentInterval + delta;\n return Math.random() * (max - min) + min;\n }\n\n public incrementCurrentInterval() {\n this.#currentInterval = Math.min(this.#currentInterval * this.#multiplier, this.#maxInterval);\n this.#count++;\n\n return this.#currentInterval;\n }\n\n public next() {\n if (this.ellapsedTimeInMsec >= this.#maxElapsedTime || this.#count >= this.#maxIterations) {\n return null;\n } else {\n this.incrementCurrentInterval();\n return this.randomValueFromInterval;\n }\n }\n}\n/**\n * Utility function to create an exponential backoff iterator.\n * @param options - for the exponential backoff\n * @returns an iterator that yields the next delay in the exponential backoff\n * @yields the next delay in the exponential backoff\n */\nexport function* exponentialBackoff(\n options: ExponentialBackoffOptions = ExponentialBackoff.default,\n) {\n const backoff = new ExponentialBackoff(options);\n\n let next = backoff.next();\n while (next) {\n yield next;\n next = backoff.next();\n }\n}\n", "import { JsonObject } from '@dfinity/candid';\nimport { Principal } from '@dfinity/principal';\nimport { AgentError } from '../../errors';\nimport { AnonymousIdentity, Identity } from '../../auth';\nimport * as cbor from '../../cbor';\nimport { RequestId, hashOfMap, requestIdOf } from '../../request_id';\nimport { bufFromBufLike, concat, fromHex } from '../../utils/buffer';\nimport {\n Agent,\n ApiQueryResponse,\n QueryFields,\n QueryResponse,\n ReadStateOptions,\n ReadStateResponse,\n SubmitResponse,\n} from '../api';\nimport { Expiry, httpHeadersTransform, makeNonceTransform } from './transforms';\nimport {\n CallRequest,\n Endpoint,\n HttpAgentRequest,\n HttpAgentRequestTransformFn,\n HttpAgentSubmitRequest,\n makeNonce,\n Nonce,\n QueryRequest,\n ReadRequestType,\n SubmitRequestType,\n} from './types';\nimport { AgentHTTPResponseError } from './errors';\nimport { SubnetStatus, request } from '../../canisterStatus';\nimport {\n CertificateVerificationError,\n HashTree,\n LookupStatus,\n lookup_path,\n} from '../../certificate';\nimport { ed25519 } from '@noble/curves/ed25519';\nimport { ExpirableMap } from '../../utils/expirableMap';\nimport { Ed25519PublicKey } from '../../public_key';\nimport { decodeTime } from '../../utils/leb';\nimport { ObservableLog } from '../../observable';\nimport { BackoffStrategy, BackoffStrategyFactory, ExponentialBackoff } from '../../polling/backoff';\nexport * from './transforms';\nexport { Nonce, makeNonce } from './types';\n\nexport enum RequestStatusResponseStatus {\n Received = 'received',\n Processing = 'processing',\n Replied = 'replied',\n Rejected = 'rejected',\n Unknown = 'unknown',\n Done = 'done',\n}\n\n// Default delta for ingress expiry is 5 minutes.\nconst DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS = 5 * 60 * 1000;\n\n// Root public key for the IC, encoded as hex\nexport const IC_ROOT_KEY =\n '308182301d060d2b0601040182dc7c0503010201060c2b0601040182dc7c05030201036100814' +\n 'c0e6ec71fab583b08bd81373c255c3c371b2e84863c98a4f1e08b74235d14fb5d9c0cd546d968' +\n '5f913a0c0b2cc5341583bf4b4392e467db96d65b9bb4cb717112f8472e0d5a4d14505ffd7484' +\n 'b01291091c5f87b98883463f98091a0baaae';\n\nexport const MANAGEMENT_CANISTER_ID = 'aaaaa-aa';\n\n// IC0 domain info\nconst IC0_DOMAIN = 'ic0.app';\nconst IC0_SUB_DOMAIN = '.ic0.app';\n\nconst ICP0_DOMAIN = 'icp0.io';\nconst ICP0_SUB_DOMAIN = '.icp0.io';\n\nconst ICP_API_DOMAIN = 'icp-api.io';\nconst ICP_API_SUB_DOMAIN = '.icp-api.io';\n\nclass HttpDefaultFetchError extends AgentError {\n constructor(public readonly message: string) {\n super(message);\n }\n}\nexport class IdentityInvalidError extends AgentError {\n constructor(public readonly message: string) {\n super(message);\n }\n}\n\n// HttpAgent options that can be used at construction.\nexport interface HttpAgentOptions {\n // Another HttpAgent to inherit configuration (pipeline and fetch) of. This\n // is only used at construction.\n source?: HttpAgent;\n\n // A surrogate to the global fetch function. Useful for testing.\n fetch?: typeof fetch;\n\n // Additional options to pass along to fetch. Will not override fields that\n // the agent already needs to set\n // Should follow the RequestInit interface, but we intentially support non-standard fields\n fetchOptions?: Record;\n\n // Additional options to pass along to fetch for the call API.\n callOptions?: Record;\n\n // The host to use for the client. By default, uses the same host as\n // the current page.\n host?: string;\n\n // The principal used to send messages. This cannot be empty at the request\n // time (will throw).\n identity?: Identity | Promise;\n\n credentials?: {\n name: string;\n password?: string;\n };\n /**\n * Adds a unique {@link Nonce} with each query.\n * Enabling will prevent queries from being answered with a cached response.\n * @example\n * const agent = new HttpAgent({ useQueryNonces: true });\n * agent.addTransform(makeNonceTransform(makeNonce);\n * @default false\n */\n useQueryNonces?: boolean;\n /**\n * Number of times to retry requests before throwing an error\n * @default 3\n */\n retryTimes?: number;\n /**\n * The strategy to use for backoff when retrying requests\n */\n backoffStrategy?: BackoffStrategyFactory;\n /**\n * Whether the agent should verify signatures signed by node keys on query responses. Increases security, but adds overhead and must make a separate request to cache the node keys for the canister's subnet.\n * @default true\n */\n verifyQuerySignatures?: boolean;\n /**\n * Whether to log to the console. Defaults to false.\n */\n logToConsole?: boolean;\n}\n\nfunction getDefaultFetch(): typeof fetch {\n let defaultFetch;\n\n if (typeof window !== 'undefined') {\n // Browser context\n if (window.fetch) {\n defaultFetch = window.fetch.bind(window);\n } else {\n throw new HttpDefaultFetchError(\n 'Fetch implementation was not available. You appear to be in a browser context, but window.fetch was not present.',\n );\n }\n } else if (typeof global !== 'undefined') {\n // Node context\n if (global.fetch) {\n defaultFetch = global.fetch.bind(global);\n } else {\n throw new HttpDefaultFetchError(\n 'Fetch implementation was not available. You appear to be in a Node.js context, but global.fetch was not available.',\n );\n }\n } else if (typeof self !== 'undefined') {\n if (self.fetch) {\n defaultFetch = self.fetch.bind(self);\n }\n }\n\n if (defaultFetch) {\n return defaultFetch;\n }\n throw new HttpDefaultFetchError(\n 'Fetch implementation was not available. Please provide fetch to the HttpAgent constructor, or ensure it is available in the window or global context.',\n );\n}\n\n// A HTTP agent allows users to interact with a client of the internet computer\n// using the available methods. It exposes an API that closely follows the\n// public view of the internet computer, and is not intended to be exposed\n// directly to the majority of users due to its low-level interface.\n//\n// There is a pipeline to apply transformations to the request before sending\n// it to the client. This is to decouple signature, nonce generation and\n// other computations so that this class can stay as simple as possible while\n// allowing extensions.\nexport class HttpAgent implements Agent {\n public rootKey = fromHex(IC_ROOT_KEY);\n private _identity: Promise | null;\n private readonly _fetch: typeof fetch;\n private readonly _fetchOptions?: Record;\n private readonly _callOptions?: Record;\n private _timeDiffMsecs = 0;\n private readonly _host: URL;\n private readonly _credentials: string | undefined;\n private _rootKeyFetched = false;\n #retryTimes; // Retry requests N times before erroring by default\n #backoffStrategy: BackoffStrategyFactory;\n public readonly _isAgent = true;\n\n // The UTC time in milliseconds when the latest request was made\n #waterMark = 0;\n\n get waterMark(): number {\n return this.#waterMark;\n }\n\n public log: ObservableLog = new ObservableLog();\n\n #queryPipeline: HttpAgentRequestTransformFn[] = [];\n #updatePipeline: HttpAgentRequestTransformFn[] = [];\n\n #subnetKeys: ExpirableMap = new ExpirableMap({\n expirationTime: 5 * 60 * 1000, // 5 minutes\n });\n #verifyQuerySignatures = true;\n\n constructor(options: HttpAgentOptions = {}) {\n if (options.source) {\n if (!(options.source instanceof HttpAgent)) {\n throw new Error(\"An Agent's source can only be another HttpAgent\");\n }\n this._identity = options.source._identity;\n this._fetch = options.source._fetch;\n this._host = options.source._host;\n this._credentials = options.source._credentials;\n } else {\n this._fetch = options.fetch || getDefaultFetch() || fetch.bind(global);\n this._fetchOptions = options.fetchOptions;\n this._callOptions = options.callOptions;\n }\n if (options.host !== undefined) {\n if (!options.host.match(/^[a-z]+:/) && typeof window !== 'undefined') {\n this._host = new URL(window.location.protocol + '//' + options.host);\n } else {\n this._host = new URL(options.host);\n }\n } else if (options.source !== undefined) {\n // Safe to ignore here.\n this._host = options.source._host;\n } else {\n const location = typeof window !== 'undefined' ? window.location : undefined;\n if (!location) {\n this._host = new URL('https://icp-api.io');\n this.log.warn(\n 'Could not infer host from window.location, defaulting to mainnet gateway of https://icp-api.io. Please provide a host to the HttpAgent constructor to avoid this warning.',\n );\n }\n // Mainnet, local, and remote environments will have the api route available\n const knownHosts = ['ic0.app', 'icp0.io', '127.0.0.1', 'localhost'];\n const remoteHosts = ['.github.dev', '.gitpod.io'];\n const hostname = location?.hostname;\n let knownHost;\n if (hostname && typeof hostname === 'string') {\n if (remoteHosts.some(host => hostname.endsWith(host))) {\n knownHost = hostname;\n } else {\n knownHost = knownHosts.find(host => hostname.endsWith(host));\n }\n }\n\n if (location && knownHost) {\n // If the user is on a boundary-node provided host, we can use the same host for the agent\n this._host = new URL(\n `${location.protocol}//${knownHost}${location.port ? ':' + location.port : ''}`,\n );\n } else {\n this._host = new URL('https://icp-api.io');\n this.log.warn(\n 'Could not infer host from window.location, defaulting to mainnet gateway of https://icp-api.io. Please provide a host to the HttpAgent constructor to avoid this warning.',\n );\n }\n }\n if (options.verifyQuerySignatures !== undefined) {\n this.#verifyQuerySignatures = options.verifyQuerySignatures;\n }\n // Default is 3\n this.#retryTimes = options.retryTimes ?? 3;\n // Delay strategy for retries. Default is exponential backoff\n const defaultBackoffFactory = () =>\n new ExponentialBackoff({\n maxIterations: this.#retryTimes,\n });\n this.#backoffStrategy = options.backoffStrategy || defaultBackoffFactory;\n // Rewrite to avoid redirects\n if (this._host.hostname.endsWith(IC0_SUB_DOMAIN)) {\n this._host.hostname = IC0_DOMAIN;\n } else if (this._host.hostname.endsWith(ICP0_SUB_DOMAIN)) {\n this._host.hostname = ICP0_DOMAIN;\n } else if (this._host.hostname.endsWith(ICP_API_SUB_DOMAIN)) {\n this._host.hostname = ICP_API_DOMAIN;\n }\n\n if (options.credentials) {\n const { name, password } = options.credentials;\n this._credentials = `${name}${password ? ':' + password : ''}`;\n }\n this._identity = Promise.resolve(options.identity || new AnonymousIdentity());\n\n // Add a nonce transform to ensure calls are unique\n this.addTransform('update', makeNonceTransform(makeNonce));\n if (options.useQueryNonces) {\n this.addTransform('query', makeNonceTransform(makeNonce));\n }\n if (options.logToConsole) {\n this.log.subscribe(log => {\n if (log.level === 'error') {\n console.error(log.message);\n } else if (log.level === 'warn') {\n console.warn(log.message);\n } else {\n console.log(log.message);\n }\n });\n }\n }\n\n public isLocal(): boolean {\n const hostname = this._host.hostname;\n return hostname === '127.0.0.1' || hostname.endsWith('127.0.0.1');\n }\n\n public addTransform(\n type: 'update' | 'query',\n fn: HttpAgentRequestTransformFn,\n priority = fn.priority || 0,\n ): void {\n if (type === 'update') {\n // Keep the pipeline sorted at all time, by priority.\n const i = this.#updatePipeline.findIndex(x => (x.priority || 0) < priority);\n this.#updatePipeline.splice(\n i >= 0 ? i : this.#updatePipeline.length,\n 0,\n Object.assign(fn, { priority }),\n );\n } else if (type === 'query') {\n // Keep the pipeline sorted at all time, by priority.\n const i = this.#queryPipeline.findIndex(x => (x.priority || 0) < priority);\n this.#queryPipeline.splice(\n i >= 0 ? i : this.#queryPipeline.length,\n 0,\n Object.assign(fn, { priority }),\n );\n }\n }\n\n public async getPrincipal(): Promise {\n if (!this._identity) {\n throw new IdentityInvalidError(\n \"This identity has expired due this application's security policy. Please refresh your authentication.\",\n );\n }\n return (await this._identity).getPrincipal();\n }\n\n public async call(\n canisterId: Principal | string,\n options: {\n methodName: string;\n arg: ArrayBuffer;\n effectiveCanisterId?: Principal | string;\n },\n identity?: Identity | Promise,\n ): Promise {\n const id = await (identity !== undefined ? await identity : await this._identity);\n if (!id) {\n throw new IdentityInvalidError(\n \"This identity has expired due this application's security policy. Please refresh your authentication.\",\n );\n }\n const canister = Principal.from(canisterId);\n const ecid = options.effectiveCanisterId\n ? Principal.from(options.effectiveCanisterId)\n : canister;\n\n const sender: Principal = id.getPrincipal() || Principal.anonymous();\n\n let ingress_expiry = new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS);\n\n // If the value is off by more than 30 seconds, reconcile system time with the network\n if (Math.abs(this._timeDiffMsecs) > 1_000 * 30) {\n ingress_expiry = new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS + this._timeDiffMsecs);\n }\n\n const submit: CallRequest = {\n request_type: SubmitRequestType.Call,\n canister_id: canister,\n method_name: options.methodName,\n arg: options.arg,\n sender,\n ingress_expiry,\n };\n\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n let transformedRequest: any = (await this._transform({\n request: {\n body: null,\n method: 'POST',\n headers: {\n 'Content-Type': 'application/cbor',\n ...(this._credentials ? { Authorization: 'Basic ' + btoa(this._credentials) } : {}),\n },\n },\n endpoint: Endpoint.Call,\n body: submit,\n })) as HttpAgentSubmitRequest;\n\n // Apply transform for identity.\n transformedRequest = await id.transformRequest(transformedRequest);\n\n const body = cbor.encode(transformedRequest.body);\n\n this.log.print(\n `fetching \"/api/v2/canister/${ecid.toText()}/call\" with request:`,\n transformedRequest,\n );\n\n // Run both in parallel. The fetch is quite expensive, so we have plenty of time to\n // calculate the requestId locally.\n const backoff = this.#backoffStrategy();\n const request = this.#requestAndRetry({\n request: () =>\n this._fetch('' + new URL(`/api/v2/canister/${ecid.toText()}/call`, this._host), {\n ...this._callOptions,\n ...transformedRequest.request,\n body,\n }),\n backoff,\n tries: 0,\n });\n\n const [response, requestId] = await Promise.all([request, requestIdOf(submit)]);\n\n const responseBuffer = await response.arrayBuffer();\n const responseBody = (\n response.status === 200 && responseBuffer.byteLength > 0 ? cbor.decode(responseBuffer) : null\n ) as SubmitResponse['response']['body'];\n\n return {\n requestId,\n response: {\n ok: response.ok,\n status: response.status,\n statusText: response.statusText,\n body: responseBody,\n headers: httpHeadersTransform(response.headers),\n },\n };\n }\n\n async #requestAndRetryQuery(args: {\n ecid: Principal;\n transformedRequest: HttpAgentRequest;\n body: ArrayBuffer;\n requestId: RequestId;\n backoff: BackoffStrategy;\n tries: number;\n }): Promise {\n const { ecid, transformedRequest, body, requestId, backoff, tries } = args;\n\n const delay = tries === 0 ? 0 : backoff.next();\n this.log.print(`fetching \"/api/v2/canister/${ecid.toString()}/query\" with tries:`, {\n tries,\n backoff,\n delay,\n });\n\n // If delay is null, the backoff strategy is exhausted due to a maximum number of retries, duration, or other reason\n if (delay === null) {\n throw new AgentError(\n `Timestamp failed to pass the watermark after retrying the configured ${\n this.#retryTimes\n } times. We cannot guarantee the integrity of the response since it could be a replay attack.`,\n );\n }\n\n if (delay > 0) {\n await new Promise(resolve => setTimeout(resolve, delay));\n }\n let response: ApiQueryResponse;\n // Make the request and retry if it throws an error\n try {\n this.log.print(\n `fetching \"/api/v2/canister/${ecid.toString()}/query\" with request:`,\n transformedRequest,\n );\n const fetchResponse = await this._fetch(\n '' + new URL(`/api/v2/canister/${ecid.toString()}/query`, this._host),\n {\n ...this._fetchOptions,\n ...transformedRequest.request,\n body,\n },\n );\n if (fetchResponse.status === 200) {\n const queryResponse: QueryResponse = cbor.decode(await fetchResponse.arrayBuffer());\n response = {\n ...queryResponse,\n httpDetails: {\n ok: fetchResponse.ok,\n status: fetchResponse.status,\n statusText: fetchResponse.statusText,\n headers: httpHeadersTransform(fetchResponse.headers),\n },\n requestId,\n };\n } else {\n throw new AgentHTTPResponseError(\n `Gateway returned an error:\\n` +\n ` Code: ${fetchResponse.status} (${fetchResponse.statusText})\\n` +\n ` Body: ${await fetchResponse.text()}\\n`,\n {\n ok: fetchResponse.ok,\n status: fetchResponse.status,\n statusText: fetchResponse.statusText,\n headers: httpHeadersTransform(fetchResponse.headers),\n },\n );\n }\n } catch (error) {\n if (tries < this.#retryTimes) {\n this.log.warn(\n `Caught exception while attempting to make query:\\n` +\n ` ${error}\\n` +\n ` Retrying query.`,\n );\n return await this.#requestAndRetryQuery({ ...args, tries: tries + 1 });\n }\n throw error;\n }\n\n const timestamp = response.signatures?.[0]?.timestamp;\n\n // Skip watermark verification if the user has set verifyQuerySignatures to false\n if (!this.#verifyQuerySignatures) {\n return response;\n }\n\n if (!timestamp) {\n throw new Error(\n 'Timestamp not found in query response. This suggests a malformed or malicious response.',\n );\n }\n\n // Convert the timestamp to milliseconds\n const timeStampInMs = Number(BigInt(timestamp) / BigInt(1_000_000));\n\n this.log.print('watermark and timestamp', {\n waterMark: this.waterMark,\n timestamp: timeStampInMs,\n });\n\n // If the timestamp is less than the watermark, retry the request up to the retry limit\n if (Number(this.waterMark) > timeStampInMs) {\n const error = new AgentError('Timestamp is below the watermark. Retrying query.');\n this.log.error('Timestamp is below', error, {\n timestamp,\n waterMark: this.waterMark,\n });\n if (tries < this.#retryTimes) {\n return await this.#requestAndRetryQuery({ ...args, tries: tries + 1 });\n }\n {\n throw new AgentError(\n `Timestamp failed to pass the watermark after retrying the configured ${\n this.#retryTimes\n } times. We cannot guarantee the integrity of the response since it could be a replay attack.`,\n );\n }\n }\n\n return response;\n }\n\n async #requestAndRetry(args: {\n request: () => Promise;\n backoff: BackoffStrategy;\n tries: number;\n }): Promise {\n const { request, backoff, tries } = args;\n const delay = tries === 0 ? 0 : backoff.next();\n\n // If delay is null, the backoff strategy is exhausted due to a maximum number of retries, duration, or other reason\n if (delay === null) {\n throw new AgentError(\n `Timestamp failed to pass the watermark after retrying the configured ${\n this.#retryTimes\n } times. We cannot guarantee the integrity of the response since it could be a replay attack.`,\n );\n }\n\n if (delay > 0) {\n await new Promise(resolve => setTimeout(resolve, delay));\n }\n\n let response: Response;\n try {\n response = await request();\n } catch (error) {\n if (this.#retryTimes > tries) {\n this.log.warn(\n `Caught exception while attempting to make request:\\n` +\n ` ${error}\\n` +\n ` Retrying request.`,\n );\n // Delay the request by the configured backoff strategy\n return await this.#requestAndRetry({ request, backoff, tries: tries + 1 });\n }\n throw error;\n }\n if (response.ok) {\n return response;\n }\n\n const responseText = await response.clone().text();\n const errorMessage =\n `Server returned an error:\\n` +\n ` Code: ${response.status} (${response.statusText})\\n` +\n ` Body: ${responseText}\\n`;\n\n if (tries < this.#retryTimes) {\n return await this.#requestAndRetry({ request, backoff, tries: tries + 1 });\n }\n throw new AgentHTTPResponseError(errorMessage, {\n ok: response.ok,\n status: response.status,\n statusText: response.statusText,\n headers: httpHeadersTransform(response.headers),\n });\n }\n\n public async query(\n canisterId: Principal | string,\n fields: QueryFields,\n identity?: Identity | Promise,\n ): Promise {\n const backoff = this.#backoffStrategy();\n const ecid = fields.effectiveCanisterId\n ? Principal.from(fields.effectiveCanisterId)\n : Principal.from(canisterId);\n\n this.log.print(`ecid ${ecid.toString()}`);\n this.log.print(`canisterId ${canisterId.toString()}`);\n const makeQuery = async () => {\n const id = await (identity !== undefined ? await identity : await this._identity);\n if (!id) {\n throw new IdentityInvalidError(\n \"This identity has expired due this application's security policy. Please refresh your authentication.\",\n );\n }\n\n const canister = Principal.from(canisterId);\n const sender = id?.getPrincipal() || Principal.anonymous();\n\n const request: QueryRequest = {\n request_type: ReadRequestType.Query,\n canister_id: canister,\n method_name: fields.methodName,\n arg: fields.arg,\n sender,\n ingress_expiry: new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS),\n };\n\n const requestId = await requestIdOf(request);\n\n // TODO: remove this any. This can be a Signed or UnSigned request.\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n let transformedRequest: HttpAgentRequest = await this._transform({\n request: {\n method: 'POST',\n headers: {\n 'Content-Type': 'application/cbor',\n ...(this._credentials ? { Authorization: 'Basic ' + btoa(this._credentials) } : {}),\n },\n },\n endpoint: Endpoint.Query,\n body: request,\n });\n\n // Apply transform for identity.\n transformedRequest = (await id?.transformRequest(transformedRequest)) as HttpAgentRequest;\n\n const body = cbor.encode(transformedRequest.body);\n\n const args = {\n canister: canister.toText(),\n ecid,\n transformedRequest,\n body,\n requestId,\n backoff,\n tries: 0,\n };\n\n return await this.#requestAndRetryQuery(args);\n };\n\n const getSubnetStatus = async (): Promise => {\n if (!this.#verifyQuerySignatures) {\n return undefined;\n }\n const subnetStatus = this.#subnetKeys.get(ecid.toString());\n if (subnetStatus) {\n return subnetStatus;\n }\n await this.fetchSubnetKeys(ecid.toString());\n return this.#subnetKeys.get(ecid.toString());\n };\n // Attempt to make the query i=retryTimes times\n // Make query and fetch subnet keys in parallel\n const [query, subnetStatus] = await Promise.all([makeQuery(), getSubnetStatus()]);\n\n this.log.print('Query response:', query);\n // Skip verification if the user has disabled it\n if (!this.#verifyQuerySignatures) {\n return query;\n }\n\n try {\n return this.#verifyQueryResponse(query, subnetStatus);\n } catch (_) {\n // In case the node signatures have changed, refresh the subnet keys and try again\n this.log.warn('Query response verification failed. Retrying with fresh subnet keys.');\n this.#subnetKeys.delete(canisterId.toString());\n await this.fetchSubnetKeys(ecid.toString());\n\n const updatedSubnetStatus = this.#subnetKeys.get(canisterId.toString());\n if (!updatedSubnetStatus) {\n throw new CertificateVerificationError(\n 'Invalid signature from replica signed query: no matching node key found.',\n );\n }\n return this.#verifyQueryResponse(query, updatedSubnetStatus);\n }\n }\n\n /**\n * See https://internetcomputer.org/docs/current/references/ic-interface-spec/#http-query for details on validation\n * @param queryResponse - The response from the query\n * @param subnetStatus - The subnet status, including all node keys\n * @returns ApiQueryResponse\n */\n #verifyQueryResponse = (\n queryResponse: ApiQueryResponse,\n subnetStatus: SubnetStatus | void,\n ): ApiQueryResponse => {\n if (this.#verifyQuerySignatures === false) {\n // This should not be called if the user has disabled verification\n return queryResponse;\n }\n if (!subnetStatus) {\n throw new CertificateVerificationError(\n 'Invalid signature from replica signed query: no matching node key found.',\n );\n }\n const { status, signatures = [], requestId } = queryResponse;\n\n const domainSeparator = new TextEncoder().encode('\\x0Bic-response');\n for (const sig of signatures) {\n const { timestamp, identity } = sig;\n const nodeId = Principal.fromUint8Array(identity).toText();\n let hash: ArrayBuffer;\n\n // Hash is constructed differently depending on the status\n if (status === 'replied') {\n const { reply } = queryResponse;\n hash = hashOfMap({\n status: status,\n reply: reply,\n timestamp: BigInt(timestamp),\n request_id: requestId,\n });\n } else if (status === 'rejected') {\n const { reject_code, reject_message, error_code } = queryResponse;\n hash = hashOfMap({\n status: status,\n reject_code: reject_code,\n reject_message: reject_message,\n error_code: error_code,\n timestamp: BigInt(timestamp),\n request_id: requestId,\n });\n } else {\n throw new Error(`Unknown status: ${status}`);\n }\n\n const separatorWithHash = concat(domainSeparator, new Uint8Array(hash));\n\n // FIX: check for match without verifying N times\n const pubKey = subnetStatus?.nodeKeys.get(nodeId);\n if (!pubKey) {\n throw new CertificateVerificationError(\n 'Invalid signature from replica signed query: no matching node key found.',\n );\n }\n const rawKey = Ed25519PublicKey.fromDer(pubKey).rawKey;\n const valid = ed25519.verify(\n sig.signature,\n new Uint8Array(separatorWithHash),\n new Uint8Array(rawKey),\n );\n if (valid) return queryResponse;\n\n throw new CertificateVerificationError(\n `Invalid signature from replica ${nodeId} signed query.`,\n );\n }\n return queryResponse;\n };\n\n public async createReadStateRequest(\n fields: ReadStateOptions,\n identity?: Identity | Promise,\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n ): Promise {\n const id = await (identity !== undefined ? await identity : await this._identity);\n if (!id) {\n throw new IdentityInvalidError(\n \"This identity has expired due this application's security policy. Please refresh your authentication.\",\n );\n }\n const sender = id?.getPrincipal() || Principal.anonymous();\n\n // TODO: remove this any. This can be a Signed or UnSigned request.\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n const transformedRequest: any = await this._transform({\n request: {\n method: 'POST',\n headers: {\n 'Content-Type': 'application/cbor',\n ...(this._credentials ? { Authorization: 'Basic ' + btoa(this._credentials) } : {}),\n },\n },\n endpoint: Endpoint.ReadState,\n body: {\n request_type: ReadRequestType.ReadState,\n paths: fields.paths,\n sender,\n ingress_expiry: new Expiry(DEFAULT_INGRESS_EXPIRY_DELTA_IN_MSECS),\n },\n });\n\n // Apply transform for identity.\n return id?.transformRequest(transformedRequest);\n }\n\n public async readState(\n canisterId: Principal | string,\n fields: ReadStateOptions,\n identity?: Identity | Promise,\n // eslint-disable-next-line\n request?: any,\n ): Promise {\n const canister = typeof canisterId === 'string' ? Principal.fromText(canisterId) : canisterId;\n\n const transformedRequest = request ?? (await this.createReadStateRequest(fields, identity));\n const body = cbor.encode(transformedRequest.body);\n\n this.log.print(\n `fetching \"/api/v2/canister/${canister}/read_state\" with request:`,\n transformedRequest,\n );\n // TODO - https://dfinity.atlassian.net/browse/SDK-1092\n const backoff = this.#backoffStrategy();\n\n const response = await this.#requestAndRetry({\n request: () =>\n this._fetch(\n '' + new URL(`/api/v2/canister/${canister.toString()}/read_state`, this._host),\n {\n ...this._fetchOptions,\n ...transformedRequest.request,\n body,\n },\n ),\n backoff,\n tries: 0,\n });\n\n if (!response.ok) {\n throw new Error(\n `Server returned an error:\\n` +\n ` Code: ${response.status} (${response.statusText})\\n` +\n ` Body: ${await response.text()}\\n`,\n );\n }\n const decodedResponse: ReadStateResponse = cbor.decode(await response.arrayBuffer());\n\n this.log.print('Read state response:', decodedResponse);\n const parsedTime = await this.parseTimeFromResponse(decodedResponse);\n if (parsedTime > 0) {\n this.log.print('Read state response time:', parsedTime);\n this.#waterMark = parsedTime;\n }\n\n return decodedResponse;\n }\n\n public async parseTimeFromResponse(response: ReadStateResponse): Promise {\n let tree: HashTree;\n if (response.certificate) {\n const decoded: { tree: HashTree } | undefined = cbor.decode(response.certificate);\n if (decoded && 'tree' in decoded) {\n tree = decoded.tree;\n } else {\n throw new Error('Could not decode time from response');\n }\n const timeLookup = lookup_path(['time'], tree);\n if (timeLookup.status !== LookupStatus.Found) {\n throw new Error('Time was not found in the response or was not in its expected format.');\n }\n\n if (!(timeLookup.value instanceof ArrayBuffer) && !ArrayBuffer.isView(timeLookup)) {\n throw new Error('Time was not found in the response or was not in its expected format.');\n }\n const date = decodeTime(bufFromBufLike(timeLookup.value as ArrayBuffer));\n this.log.print('Time from response:', date);\n this.log.print('Time from response in milliseconds:', Number(date));\n return Number(date);\n } else {\n this.log.warn('No certificate found in response');\n }\n return 0;\n }\n\n /**\n * Allows agent to sync its time with the network. Can be called during intialization or mid-lifecycle if the device's clock has drifted away from the network time. This is necessary to set the Expiry for a request\n * @param {Principal} canisterId - Pass a canister ID if you need to sync the time with a particular replica. Uses the management canister by default\n */\n public async syncTime(canisterId?: Principal): Promise {\n const CanisterStatus = await import('../../canisterStatus');\n const callTime = Date.now();\n try {\n if (!canisterId) {\n this.log.print(\n 'Syncing time with the IC. No canisterId provided, so falling back to ryjl3-tyaaa-aaaaa-aaaba-cai',\n );\n }\n const status = await CanisterStatus.request({\n // Fall back with canisterId of the ICP Ledger\n canisterId: canisterId ?? Principal.from('ryjl3-tyaaa-aaaaa-aaaba-cai'),\n agent: this,\n paths: ['time'],\n });\n\n const replicaTime = status.get('time');\n if (replicaTime) {\n this._timeDiffMsecs = Number(replicaTime as bigint) - Number(callTime);\n }\n } catch (error) {\n this.log.error('Caught exception while attempting to sync time', error as AgentError);\n }\n }\n\n public async status(): Promise {\n const headers: Record = this._credentials\n ? {\n Authorization: 'Basic ' + btoa(this._credentials),\n }\n : {};\n\n this.log.print(`fetching \"/api/v2/status\"`);\n const backoff = this.#backoffStrategy();\n const response = await this.#requestAndRetry({\n backoff,\n request: () =>\n this._fetch('' + new URL(`/api/v2/status`, this._host), { headers, ...this._fetchOptions }),\n tries: 0,\n });\n return cbor.decode(await response.arrayBuffer());\n }\n\n public async fetchRootKey(): Promise {\n if (!this._rootKeyFetched) {\n // Hex-encoded version of the replica root key\n this.rootKey = ((await this.status()) as JsonObject & { root_key: ArrayBuffer }).root_key;\n this._rootKeyFetched = true;\n }\n return this.rootKey;\n }\n\n public invalidateIdentity(): void {\n this._identity = null;\n }\n\n public replaceIdentity(identity: Identity): void {\n this._identity = Promise.resolve(identity);\n }\n\n public async fetchSubnetKeys(canisterId: Principal | string) {\n const effectiveCanisterId: Principal = Principal.from(canisterId);\n const response = await request({\n canisterId: effectiveCanisterId,\n paths: ['subnet'],\n agent: this,\n });\n\n const subnetResponse = response.get('subnet');\n if (subnetResponse && typeof subnetResponse === 'object' && 'nodeKeys' in subnetResponse) {\n this.#subnetKeys.set(effectiveCanisterId.toText(), subnetResponse as SubnetStatus);\n return subnetResponse as SubnetStatus;\n }\n // If the subnet status is not returned, return undefined\n return undefined;\n }\n\n protected _transform(request: HttpAgentRequest): Promise {\n let p = Promise.resolve(request);\n if (request.endpoint === Endpoint.Call) {\n for (const fn of this.#updatePipeline) {\n p = p.then(r => fn(r).then(r2 => r2 || r));\n }\n } else {\n for (const fn of this.#queryPipeline) {\n p = p.then(r => fn(r).then(r2 => r2 || r));\n }\n }\n\n return p;\n }\n}\n", "import { JsonObject } from '@dfinity/candid';\nimport {\n Agent,\n ApiQueryResponse,\n CallOptions,\n QueryFields,\n QueryResponse,\n ReadStateOptions,\n ReadStateResponse,\n SubmitResponse,\n} from './api';\nimport { Principal } from '@dfinity/principal';\n\nexport enum ProxyMessageKind {\n Error = 'err',\n GetPrincipal = 'gp',\n GetPrincipalResponse = 'gpr',\n Query = 'q',\n QueryResponse = 'qr',\n Call = 'c',\n CallResponse = 'cr',\n ReadState = 'rs',\n ReadStateResponse = 'rsr',\n Status = 's',\n StatusResponse = 'sr',\n}\n\nexport interface ProxyMessageBase {\n id: number;\n type: ProxyMessageKind;\n}\n\nexport interface ProxyMessageError extends ProxyMessageBase {\n type: ProxyMessageKind.Error;\n error: any;\n}\n\nexport interface ProxyMessageGetPrincipal extends ProxyMessageBase {\n type: ProxyMessageKind.GetPrincipal;\n}\n\nexport interface ProxyMessageGetPrincipalResponse extends ProxyMessageBase {\n type: ProxyMessageKind.GetPrincipalResponse;\n response: string;\n}\n\nexport interface ProxyMessageQuery extends ProxyMessageBase {\n type: ProxyMessageKind.Query;\n args: [string, QueryFields];\n}\n\nexport interface ProxyMessageQueryResponse extends ProxyMessageBase {\n type: ProxyMessageKind.QueryResponse;\n response: QueryResponse;\n}\n\nexport interface ProxyMessageCall extends ProxyMessageBase {\n type: ProxyMessageKind.Call;\n args: [string, CallOptions];\n}\n\nexport interface ProxyMessageCallResponse extends ProxyMessageBase {\n type: ProxyMessageKind.CallResponse;\n response: SubmitResponse;\n}\n\nexport interface ProxyMessageReadState extends ProxyMessageBase {\n type: ProxyMessageKind.ReadState;\n args: [string, ReadStateOptions];\n}\n\nexport interface ProxyMessageReadStateResponse extends ProxyMessageBase {\n type: ProxyMessageKind.ReadStateResponse;\n response: ReadStateResponse;\n}\n\nexport interface ProxyMessageStatus extends ProxyMessageBase {\n type: ProxyMessageKind.Status;\n}\n\nexport interface ProxyMessageStatusResponse extends ProxyMessageBase {\n type: ProxyMessageKind.StatusResponse;\n response: JsonObject;\n}\n\nexport type ProxyMessage =\n | ProxyMessageError\n | ProxyMessageGetPrincipal\n | ProxyMessageGetPrincipalResponse\n | ProxyMessageQuery\n | ProxyMessageQueryResponse\n | ProxyMessageCall\n | ProxyMessageReadState\n | ProxyMessageReadStateResponse\n | ProxyMessageCallResponse\n | ProxyMessageStatus\n | ProxyMessageStatusResponse;\n\n// A Stub Agent that forwards calls to another Agent implementation.\nexport class ProxyStubAgent {\n constructor(private _frontend: (msg: ProxyMessage) => void, private _agent: Agent) {}\n\n public onmessage(msg: ProxyMessage): void {\n switch (msg.type) {\n case ProxyMessageKind.GetPrincipal:\n this._agent.getPrincipal().then(response => {\n this._frontend({\n id: msg.id,\n type: ProxyMessageKind.GetPrincipalResponse,\n response: response.toText(),\n });\n });\n break;\n case ProxyMessageKind.Query:\n this._agent.query(...msg.args).then(response => {\n this._frontend({\n id: msg.id,\n type: ProxyMessageKind.QueryResponse,\n response,\n });\n });\n break;\n case ProxyMessageKind.Call:\n this._agent.call(...msg.args).then(response => {\n this._frontend({\n id: msg.id,\n type: ProxyMessageKind.CallResponse,\n response,\n });\n });\n break;\n case ProxyMessageKind.ReadState:\n this._agent.readState(...msg.args).then(response => {\n this._frontend({\n id: msg.id,\n type: ProxyMessageKind.ReadStateResponse,\n response,\n });\n });\n break;\n case ProxyMessageKind.Status:\n this._agent.status().then(response => {\n this._frontend({\n id: msg.id,\n type: ProxyMessageKind.StatusResponse,\n response,\n });\n });\n break;\n\n default:\n throw new Error(`Invalid message received: ${JSON.stringify(msg)}`);\n }\n }\n}\n\n// An Agent that forwards calls to a backend. The calls are serialized\nexport class ProxyAgent implements Agent {\n private _nextId = 0;\n private _pendingCalls = new Map void, (reject: any) => void]>();\n public rootKey = null;\n\n constructor(private _backend: (msg: ProxyMessage) => void) {}\n\n public onmessage(msg: ProxyMessage): void {\n const id = msg.id;\n\n const maybePromise = this._pendingCalls.get(id);\n if (!maybePromise) {\n throw new Error('A proxy get the same message twice...');\n }\n\n this._pendingCalls.delete(id);\n const [resolve, reject] = maybePromise;\n\n switch (msg.type) {\n case ProxyMessageKind.Error:\n return reject(msg.error);\n case ProxyMessageKind.GetPrincipalResponse:\n case ProxyMessageKind.CallResponse:\n case ProxyMessageKind.QueryResponse:\n case ProxyMessageKind.ReadStateResponse:\n case ProxyMessageKind.StatusResponse:\n return resolve(msg.response);\n default:\n throw new Error(`Invalid message being sent to ProxyAgent: ${JSON.stringify(msg)}`);\n }\n }\n\n public async getPrincipal(): Promise {\n return this._sendAndWait({\n id: this._nextId++,\n type: ProxyMessageKind.GetPrincipal,\n }).then(principal => {\n if (typeof principal !== 'string') {\n throw new Error('Invalid principal received.');\n }\n return Principal.fromText(principal);\n });\n }\n\n public readState(\n canisterId: Principal | string,\n fields: ReadStateOptions,\n ): Promise {\n return this._sendAndWait({\n id: this._nextId++,\n type: ProxyMessageKind.ReadState,\n args: [canisterId.toString(), fields],\n }) as Promise;\n }\n\n public call(canisterId: Principal | string, fields: CallOptions): Promise {\n return this._sendAndWait({\n id: this._nextId++,\n type: ProxyMessageKind.Call,\n args: [canisterId.toString(), fields],\n }) as Promise;\n }\n\n public status(): Promise {\n return this._sendAndWait({\n id: this._nextId++,\n type: ProxyMessageKind.Status,\n }) as Promise;\n }\n\n public query(canisterId: Principal | string, fields: QueryFields): Promise {\n return this._sendAndWait({\n id: this._nextId++,\n type: ProxyMessageKind.Query,\n args: [canisterId.toString(), fields],\n }) as Promise;\n }\n\n private async _sendAndWait(msg: ProxyMessage): Promise {\n return new Promise((resolve, reject) => {\n this._pendingCalls.set(msg.id, [resolve, reject]);\n\n this._backend(msg);\n });\n }\n\n public async fetchRootKey(): Promise {\n // Hex-encoded version of the replica root key\n const rootKey = ((await this.status()) as any).root_key;\n this.rootKey = rootKey;\n return rootKey;\n }\n}\n", "import { GlobalInternetComputer } from '../index';\nimport { Agent } from './api';\n\nexport * from './api';\nexport * from './http';\nexport * from './http/errors';\nexport * from './proxy';\n\ndeclare const window: GlobalInternetComputer;\ndeclare const global: GlobalInternetComputer;\ndeclare const self: GlobalInternetComputer;\n\nexport function getDefaultAgent(): Agent {\n const agent =\n typeof window === 'undefined'\n ? typeof global === 'undefined'\n ? typeof self === 'undefined'\n ? undefined\n : self.ic.agent\n : global.ic.agent\n : window.ic.agent;\n\n if (!agent) {\n throw new Error('No Agent could be found.');\n }\n\n return agent;\n}\n", "import { Principal } from '@dfinity/principal';\nimport { Agent, RequestStatusResponseStatus } from '../agent';\nimport { Certificate, CreateCertificateOptions, lookupResultToBuffer } from '../certificate';\nimport { RequestId } from '../request_id';\nimport { toHex } from '../utils/buffer';\n\nexport * as strategy from './strategy';\nexport { defaultStrategy } from './strategy';\nexport type PollStrategy = (\n canisterId: Principal,\n requestId: RequestId,\n status: RequestStatusResponseStatus,\n) => Promise;\nexport type PollStrategyFactory = () => PollStrategy;\n\n/**\n * Polls the IC to check the status of the given request then\n * returns the response bytes once the request has been processed.\n * @param agent The agent to use to poll read_state.\n * @param canisterId The effective canister ID.\n * @param requestId The Request ID to poll status for.\n * @param strategy A polling strategy.\n * @param request Request for the readState call.\n * @param blsVerify - optional replacement function that verifies the BLS signature of a certificate.\n */\nexport async function pollForResponse(\n agent: Agent,\n canisterId: Principal,\n requestId: RequestId,\n strategy: PollStrategy,\n // eslint-disable-next-line\n request?: any,\n blsVerify?: CreateCertificateOptions['blsVerify'],\n): Promise {\n const path = [new TextEncoder().encode('request_status'), requestId];\n const currentRequest = request ?? (await agent.createReadStateRequest?.({ paths: [path] }));\n const state = await agent.readState(canisterId, { paths: [path] }, undefined, currentRequest);\n if (agent.rootKey == null) throw new Error('Agent root key not initialized before polling');\n const cert = await Certificate.create({\n certificate: state.certificate,\n rootKey: agent.rootKey,\n canisterId: canisterId,\n blsVerify,\n });\n const maybeBuf = lookupResultToBuffer(cert.lookup([...path, new TextEncoder().encode('status')]));\n let status;\n if (typeof maybeBuf === 'undefined') {\n // Missing requestId means we need to wait\n status = RequestStatusResponseStatus.Unknown;\n } else {\n status = new TextDecoder().decode(maybeBuf);\n }\n\n switch (status) {\n case RequestStatusResponseStatus.Replied: {\n return lookupResultToBuffer(cert.lookup([...path, 'reply']))!;\n }\n\n case RequestStatusResponseStatus.Received:\n case RequestStatusResponseStatus.Unknown:\n case RequestStatusResponseStatus.Processing:\n // Execute the polling strategy, then retry.\n await strategy(canisterId, requestId, status);\n return pollForResponse(agent, canisterId, requestId, strategy, currentRequest);\n\n case RequestStatusResponseStatus.Rejected: {\n const rejectCode = new Uint8Array(\n lookupResultToBuffer(cert.lookup([...path, 'reject_code']))!,\n )[0];\n const rejectMessage = new TextDecoder().decode(\n lookupResultToBuffer(cert.lookup([...path, 'reject_message']))!,\n );\n throw new Error(\n `Call was rejected:\\n` +\n ` Request ID: ${toHex(requestId)}\\n` +\n ` Reject code: ${rejectCode}\\n` +\n ` Reject text: ${rejectMessage}\\n`,\n );\n }\n\n case RequestStatusResponseStatus.Done:\n // This is _technically_ not an error, but we still didn't see the `Replied` status so\n // we don't know the result and cannot decode it.\n throw new Error(\n `Call was marked as done but we never saw the reply:\\n` +\n ` Request ID: ${toHex(requestId)}\\n`,\n );\n }\n throw new Error('unreachable');\n}\n", "import { Principal } from '@dfinity/principal';\nimport { RequestStatusResponseStatus } from '../agent';\nimport { toHex } from '../utils/buffer';\nimport { PollStrategy } from './index';\nimport { RequestId } from '../request_id';\n\nexport type Predicate = (\n canisterId: Principal,\n requestId: RequestId,\n status: RequestStatusResponseStatus,\n) => Promise;\n\nconst FIVE_MINUTES_IN_MSEC = 5 * 60 * 1000;\n\n/**\n * A best practices polling strategy: wait 2 seconds before the first poll, then 1 second\n * with an exponential backoff factor of 1.2. Timeout after 5 minutes.\n */\nexport function defaultStrategy(): PollStrategy {\n return chain(conditionalDelay(once(), 1000), backoff(1000, 1.2), timeout(FIVE_MINUTES_IN_MSEC));\n}\n\n/**\n * Predicate that returns true once.\n */\nexport function once(): Predicate {\n let first = true;\n return async () => {\n if (first) {\n first = false;\n return true;\n }\n return false;\n };\n}\n\n/**\n * Delay the polling once.\n * @param condition A predicate that indicates when to delay.\n * @param timeInMsec The amount of time to delay.\n */\nexport function conditionalDelay(condition: Predicate, timeInMsec: number): PollStrategy {\n return async (\n canisterId: Principal,\n requestId: RequestId,\n status: RequestStatusResponseStatus,\n ) => {\n if (await condition(canisterId, requestId, status)) {\n return new Promise(resolve => setTimeout(resolve, timeInMsec));\n }\n };\n}\n\n/**\n * Error out after a maximum number of polling has been done.\n * @param count The maximum attempts to poll.\n */\nexport function maxAttempts(count: number): PollStrategy {\n let attempts = count;\n return async (\n canisterId: Principal,\n requestId: RequestId,\n status: RequestStatusResponseStatus,\n ) => {\n if (--attempts <= 0) {\n throw new Error(\n `Failed to retrieve a reply for request after ${count} attempts:\\n` +\n ` Request ID: ${toHex(requestId)}\\n` +\n ` Request status: ${status}\\n`,\n );\n }\n };\n}\n\n/**\n * Throttle polling.\n * @param throttleInMsec Amount in millisecond to wait between each polling.\n */\nexport function throttle(throttleInMsec: number): PollStrategy {\n return () => new Promise(resolve => setTimeout(resolve, throttleInMsec));\n}\n\n/**\n * Reject a call after a certain amount of time.\n * @param timeInMsec Time in milliseconds before the polling should be rejected.\n */\nexport function timeout(timeInMsec: number): PollStrategy {\n const end = Date.now() + timeInMsec;\n return async (\n canisterId: Principal,\n requestId: RequestId,\n status: RequestStatusResponseStatus,\n ) => {\n if (Date.now() > end) {\n throw new Error(\n `Request timed out after ${timeInMsec} msec:\\n` +\n ` Request ID: ${toHex(requestId)}\\n` +\n ` Request status: ${status}\\n`,\n );\n }\n };\n}\n\n/**\n * A strategy that throttle, but using an exponential backoff strategy.\n * @param startingThrottleInMsec The throttle in milliseconds to start with.\n * @param backoffFactor The factor to multiple the throttle time between every poll. For\n * example if using 2, the throttle will double between every run.\n */\nexport function backoff(startingThrottleInMsec: number, backoffFactor: number): PollStrategy {\n let currentThrottling = startingThrottleInMsec;\n\n return () =>\n new Promise(resolve =>\n setTimeout(() => {\n currentThrottling *= backoffFactor;\n resolve();\n }, currentThrottling),\n );\n}\n\n/**\n * Chain multiple polling strategy. This _chains_ the strategies, so if you pass in,\n * say, two throttling strategy of 1 second, it will result in a throttle of 2 seconds.\n * @param strategies A strategy list to chain.\n */\nexport function chain(...strategies: PollStrategy[]): PollStrategy {\n return async (\n canisterId: Principal,\n requestId: RequestId,\n status: RequestStatusResponseStatus,\n ) => {\n for (const a of strategies) {\n await a(canisterId, requestId, status);\n }\n };\n}\n", "/*\n * This file is generated from the candid for asset management.\n * didc version: 0.4.0\n */\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\n\nexport default ({ IDL }) => {\n const bitcoin_network = IDL.Variant({\n mainnet: IDL.Null,\n testnet: IDL.Null,\n });\n const bitcoin_address = IDL.Text;\n const bitcoin_get_balance_args = IDL.Record({\n network: bitcoin_network,\n address: bitcoin_address,\n min_confirmations: IDL.Opt(IDL.Nat32),\n });\n const satoshi = IDL.Nat64;\n const bitcoin_get_balance_result = satoshi;\n const bitcoin_get_current_fee_percentiles_args = IDL.Record({\n network: bitcoin_network,\n });\n const millisatoshi_per_byte = IDL.Nat64;\n const bitcoin_get_current_fee_percentiles_result = IDL.Vec(millisatoshi_per_byte);\n const bitcoin_get_utxos_args = IDL.Record({\n network: bitcoin_network,\n filter: IDL.Opt(\n IDL.Variant({\n page: IDL.Vec(IDL.Nat8),\n min_confirmations: IDL.Nat32,\n }),\n ),\n address: bitcoin_address,\n });\n const block_hash = IDL.Vec(IDL.Nat8);\n const outpoint = IDL.Record({\n txid: IDL.Vec(IDL.Nat8),\n vout: IDL.Nat32,\n });\n const utxo = IDL.Record({\n height: IDL.Nat32,\n value: satoshi,\n outpoint: outpoint,\n });\n const bitcoin_get_utxos_result = IDL.Record({\n next_page: IDL.Opt(IDL.Vec(IDL.Nat8)),\n tip_height: IDL.Nat32,\n tip_block_hash: block_hash,\n utxos: IDL.Vec(utxo),\n });\n const bitcoin_send_transaction_args = IDL.Record({\n transaction: IDL.Vec(IDL.Nat8),\n network: bitcoin_network,\n });\n const canister_id = IDL.Principal;\n const canister_info_args = IDL.Record({\n canister_id: canister_id,\n num_requested_changes: IDL.Opt(IDL.Nat64),\n });\n const change_origin = IDL.Variant({\n from_user: IDL.Record({ user_id: IDL.Principal }),\n from_canister: IDL.Record({\n canister_version: IDL.Opt(IDL.Nat64),\n canister_id: IDL.Principal,\n }),\n });\n const change_details = IDL.Variant({\n creation: IDL.Record({ controllers: IDL.Vec(IDL.Principal) }),\n code_deployment: IDL.Record({\n mode: IDL.Variant({\n reinstall: IDL.Null,\n upgrade: IDL.Null,\n install: IDL.Null,\n }),\n module_hash: IDL.Vec(IDL.Nat8),\n }),\n controllers_change: IDL.Record({\n controllers: IDL.Vec(IDL.Principal),\n }),\n code_uninstall: IDL.Null,\n });\n const change = IDL.Record({\n timestamp_nanos: IDL.Nat64,\n canister_version: IDL.Nat64,\n origin: change_origin,\n details: change_details,\n });\n const canister_info_result = IDL.Record({\n controllers: IDL.Vec(IDL.Principal),\n module_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),\n recent_changes: IDL.Vec(change),\n total_num_changes: IDL.Nat64,\n });\n const canister_status_args = IDL.Record({ canister_id: canister_id });\n const log_visibility = IDL.Variant({\n controllers: IDL.Null,\n public: IDL.Null,\n });\n const definite_canister_settings = IDL.Record({\n freezing_threshold: IDL.Nat,\n controllers: IDL.Vec(IDL.Principal),\n reserved_cycles_limit: IDL.Nat,\n log_visibility: log_visibility,\n wasm_memory_limit: IDL.Nat,\n memory_allocation: IDL.Nat,\n compute_allocation: IDL.Nat,\n });\n const canister_status_result = IDL.Record({\n status: IDL.Variant({\n stopped: IDL.Null,\n stopping: IDL.Null,\n running: IDL.Null,\n }),\n memory_size: IDL.Nat,\n cycles: IDL.Nat,\n settings: definite_canister_settings,\n query_stats: IDL.Record({\n response_payload_bytes_total: IDL.Nat,\n num_instructions_total: IDL.Nat,\n num_calls_total: IDL.Nat,\n request_payload_bytes_total: IDL.Nat,\n }),\n idle_cycles_burned_per_day: IDL.Nat,\n module_hash: IDL.Opt(IDL.Vec(IDL.Nat8)),\n reserved_cycles: IDL.Nat,\n });\n const clear_chunk_store_args = IDL.Record({ canister_id: canister_id });\n const canister_settings = IDL.Record({\n freezing_threshold: IDL.Opt(IDL.Nat),\n controllers: IDL.Opt(IDL.Vec(IDL.Principal)),\n reserved_cycles_limit: IDL.Opt(IDL.Nat),\n log_visibility: IDL.Opt(log_visibility),\n wasm_memory_limit: IDL.Opt(IDL.Nat),\n memory_allocation: IDL.Opt(IDL.Nat),\n compute_allocation: IDL.Opt(IDL.Nat),\n });\n const create_canister_args = IDL.Record({\n settings: IDL.Opt(canister_settings),\n sender_canister_version: IDL.Opt(IDL.Nat64),\n });\n const create_canister_result = IDL.Record({ canister_id: canister_id });\n const delete_canister_args = IDL.Record({ canister_id: canister_id });\n const deposit_cycles_args = IDL.Record({ canister_id: canister_id });\n const ecdsa_curve = IDL.Variant({ secp256k1: IDL.Null });\n const ecdsa_public_key_args = IDL.Record({\n key_id: IDL.Record({ name: IDL.Text, curve: ecdsa_curve }),\n canister_id: IDL.Opt(canister_id),\n derivation_path: IDL.Vec(IDL.Vec(IDL.Nat8)),\n });\n const ecdsa_public_key_result = IDL.Record({\n public_key: IDL.Vec(IDL.Nat8),\n chain_code: IDL.Vec(IDL.Nat8),\n });\n const fetch_canister_logs_args = IDL.Record({ canister_id: canister_id });\n const canister_log_record = IDL.Record({\n idx: IDL.Nat64,\n timestamp_nanos: IDL.Nat64,\n content: IDL.Vec(IDL.Nat8),\n });\n const fetch_canister_logs_result = IDL.Record({\n canister_log_records: IDL.Vec(canister_log_record),\n });\n const http_header = IDL.Record({ value: IDL.Text, name: IDL.Text });\n const http_request_result = IDL.Record({\n status: IDL.Nat,\n body: IDL.Vec(IDL.Nat8),\n headers: IDL.Vec(http_header),\n });\n const http_request_args = IDL.Record({\n url: IDL.Text,\n method: IDL.Variant({\n get: IDL.Null,\n head: IDL.Null,\n post: IDL.Null,\n }),\n max_response_bytes: IDL.Opt(IDL.Nat64),\n body: IDL.Opt(IDL.Vec(IDL.Nat8)),\n transform: IDL.Opt(\n IDL.Record({\n function: IDL.Func(\n [\n IDL.Record({\n context: IDL.Vec(IDL.Nat8),\n response: http_request_result,\n }),\n ],\n [http_request_result],\n ['query'],\n ),\n context: IDL.Vec(IDL.Nat8),\n }),\n ),\n headers: IDL.Vec(http_header),\n });\n const canister_install_mode = IDL.Variant({\n reinstall: IDL.Null,\n upgrade: IDL.Opt(\n IDL.Record({\n wasm_memory_persistence: IDL.Opt(IDL.Variant({ keep: IDL.Null, replace: IDL.Null })),\n skip_pre_upgrade: IDL.Opt(IDL.Bool),\n }),\n ),\n install: IDL.Null,\n });\n const chunk_hash = IDL.Record({ hash: IDL.Vec(IDL.Nat8) });\n const install_chunked_code_args = IDL.Record({\n arg: IDL.Vec(IDL.Nat8),\n wasm_module_hash: IDL.Vec(IDL.Nat8),\n mode: canister_install_mode,\n chunk_hashes_list: IDL.Vec(chunk_hash),\n target_canister: canister_id,\n store_canister: IDL.Opt(canister_id),\n sender_canister_version: IDL.Opt(IDL.Nat64),\n });\n const wasm_module = IDL.Vec(IDL.Nat8);\n const install_code_args = IDL.Record({\n arg: IDL.Vec(IDL.Nat8),\n wasm_module: wasm_module,\n mode: canister_install_mode,\n canister_id: canister_id,\n sender_canister_version: IDL.Opt(IDL.Nat64),\n });\n const node_metrics_history_args = IDL.Record({\n start_at_timestamp_nanos: IDL.Nat64,\n subnet_id: IDL.Principal,\n });\n const node_metrics = IDL.Record({\n num_block_failures_total: IDL.Nat64,\n node_id: IDL.Principal,\n num_blocks_proposed_total: IDL.Nat64,\n });\n const node_metrics_history_result = IDL.Vec(\n IDL.Record({\n timestamp_nanos: IDL.Nat64,\n node_metrics: IDL.Vec(node_metrics),\n }),\n );\n const provisional_create_canister_with_cycles_args = IDL.Record({\n settings: IDL.Opt(canister_settings),\n specified_id: IDL.Opt(canister_id),\n amount: IDL.Opt(IDL.Nat),\n sender_canister_version: IDL.Opt(IDL.Nat64),\n });\n const provisional_create_canister_with_cycles_result = IDL.Record({\n canister_id: canister_id,\n });\n const provisional_top_up_canister_args = IDL.Record({\n canister_id: canister_id,\n amount: IDL.Nat,\n });\n const raw_rand_result = IDL.Vec(IDL.Nat8);\n const sign_with_ecdsa_args = IDL.Record({\n key_id: IDL.Record({ name: IDL.Text, curve: ecdsa_curve }),\n derivation_path: IDL.Vec(IDL.Vec(IDL.Nat8)),\n message_hash: IDL.Vec(IDL.Nat8),\n });\n const sign_with_ecdsa_result = IDL.Record({\n signature: IDL.Vec(IDL.Nat8),\n });\n const start_canister_args = IDL.Record({ canister_id: canister_id });\n const stop_canister_args = IDL.Record({ canister_id: canister_id });\n const stored_chunks_args = IDL.Record({ canister_id: canister_id });\n const stored_chunks_result = IDL.Vec(chunk_hash);\n const uninstall_code_args = IDL.Record({\n canister_id: canister_id,\n sender_canister_version: IDL.Opt(IDL.Nat64),\n });\n const update_settings_args = IDL.Record({\n canister_id: IDL.Principal,\n settings: canister_settings,\n sender_canister_version: IDL.Opt(IDL.Nat64),\n });\n const upload_chunk_args = IDL.Record({\n chunk: IDL.Vec(IDL.Nat8),\n canister_id: IDL.Principal,\n });\n const upload_chunk_result = chunk_hash;\n return IDL.Service({\n bitcoin_get_balance: IDL.Func([bitcoin_get_balance_args], [bitcoin_get_balance_result], []),\n bitcoin_get_current_fee_percentiles: IDL.Func(\n [bitcoin_get_current_fee_percentiles_args],\n [bitcoin_get_current_fee_percentiles_result],\n [],\n ),\n bitcoin_get_utxos: IDL.Func([bitcoin_get_utxos_args], [bitcoin_get_utxos_result], []),\n bitcoin_send_transaction: IDL.Func([bitcoin_send_transaction_args], [], []),\n canister_info: IDL.Func([canister_info_args], [canister_info_result], []),\n canister_status: IDL.Func([canister_status_args], [canister_status_result], []),\n clear_chunk_store: IDL.Func([clear_chunk_store_args], [], []),\n create_canister: IDL.Func([create_canister_args], [create_canister_result], []),\n delete_canister: IDL.Func([delete_canister_args], [], []),\n deposit_cycles: IDL.Func([deposit_cycles_args], [], []),\n ecdsa_public_key: IDL.Func([ecdsa_public_key_args], [ecdsa_public_key_result], []),\n fetch_canister_logs: IDL.Func(\n [fetch_canister_logs_args],\n [fetch_canister_logs_result],\n ['query'],\n ),\n http_request: IDL.Func([http_request_args], [http_request_result], []),\n install_chunked_code: IDL.Func([install_chunked_code_args], [], []),\n install_code: IDL.Func([install_code_args], [], []),\n node_metrics_history: IDL.Func([node_metrics_history_args], [node_metrics_history_result], []),\n provisional_create_canister_with_cycles: IDL.Func(\n [provisional_create_canister_with_cycles_args],\n [provisional_create_canister_with_cycles_result],\n [],\n ),\n provisional_top_up_canister: IDL.Func([provisional_top_up_canister_args], [], []),\n raw_rand: IDL.Func([], [raw_rand_result], []),\n sign_with_ecdsa: IDL.Func([sign_with_ecdsa_args], [sign_with_ecdsa_result], []),\n start_canister: IDL.Func([start_canister_args], [], []),\n stop_canister: IDL.Func([stop_canister_args], [], []),\n stored_chunks: IDL.Func([stored_chunks_args], [stored_chunks_result], []),\n uninstall_code: IDL.Func([uninstall_code_args], [], []),\n update_settings: IDL.Func([update_settings_args], [], []),\n upload_chunk: IDL.Func([upload_chunk_args], [upload_chunk_result], []),\n });\n};\n", "/**\n * This file is generated from the candid for asset management.\n */\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nexport default ({ IDL }) => {\n return IDL.Service({\n retrieve: IDL.Func([IDL.Text], [IDL.Vec(IDL.Nat8)], ['query']),\n store: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8)], [], []),\n });\n};\n", "import { Actor, ActorConfig, ActorSubclass, CallConfig } from '../actor';\nimport assetCanister from './asset_idl';\n\nexport interface AssetCanisterRecord {\n store(path: string, content: number[]): Promise;\n retrieve(path: string): Promise;\n}\n\n/**\n * Create a management canister actor.\n * @param config\n */\nexport function createAssetCanisterActor(config: ActorConfig) {\n return Actor.createActor(assetCanister, config);\n}\n", "import { Principal } from '@dfinity/principal';\nimport * as CanisterStatus from './canisterStatus/index';\nimport { IDL } from '@dfinity/candid';\nimport { HttpAgent } from './agent/http';\nimport { Actor, ActorSubclass } from './actor';\n\n/**\n * Retrieves the Candid interface for the specified canister.\n *\n * @param agent The agent to use for the request (usually an `HttpAgent`)\n * @param canisterId A string corresponding to the canister ID\n * @returns Candid source code\n */\nexport async function fetchCandid(canisterId: string, agent?: HttpAgent): Promise {\n if (!agent) {\n // Create an anonymous `HttpAgent` (adapted from Candid UI)\n agent = new HttpAgent();\n if (agent.isLocal()) {\n agent.fetchRootKey();\n }\n }\n\n // Attempt to use canister metadata\n const status = await CanisterStatus.request({\n agent,\n canisterId: Principal.fromText(canisterId),\n paths: ['candid'],\n });\n const candid = status.get('candid') as string | undefined;\n if (candid) {\n return candid;\n }\n\n // Use `__get_candid_interface_tmp_hack` for canisters without Candid metadata\n const tmpHackInterface: IDL.InterfaceFactory = ({ IDL }) =>\n IDL.Service({\n __get_candid_interface_tmp_hack: IDL.Func([], [IDL.Text], ['query']),\n });\n const actor: ActorSubclass = Actor.createActor(tmpHackInterface, { agent, canisterId });\n return (await actor.__get_candid_interface_tmp_hack()) as string;\n}\n"], + "mappings": "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", + "names": ["Buffer", "value", "compare", "concat", "utf8ToBytes", "i", "byteLength", "import_buffer", "ReplicaRejectCode", "request", "SubmitRequestType", "request", "value", "Fp", "randomBytes", "uvRatio", "adjustScalarBytes", "G", "A", "B", "F", "C", "D", "E", "H", "X3", "Y3", "T3", "Z3", "cofactor", "hash", "concatBytes", "verify", "_0n", "_1n", "validateOpts", "adjustScalarBytes", "_0n", "_1n", "_2n", "_8n", "pow", "_8n", "_8n", "_2n", "_1n", "mod", "_0n", "value", "__classPrivateFieldSet", "__classPrivateFieldGet", "__classPrivateFieldSet", "__classPrivateFieldGet", "_a", "RequestStatusResponseStatus", "__classPrivateFieldGet", "domainSeparator", "hash", "__classPrivateFieldSet", "_a", "backoff", "request", "subnetStatus", "_HttpAgent_requestAndRetryQuery", "_b", "_HttpAgent_requestAndRetry", "ProxyMessageKind", "request", "blsVerify", "_a", "_a", "settings", "blsVerify", "_b"] +} diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/_metadata.json b/src/BlockThings_frontend/node_modules/.vite/deps/_metadata.json index 5c9a445..227855b 100644 --- a/src/BlockThings_frontend/node_modules/.vite/deps/_metadata.json +++ b/src/BlockThings_frontend/node_modules/.vite/deps/_metadata.json @@ -1,56 +1,71 @@ { "hash": "789f12ff", - "browserHash": "e4de0b68", + "browserHash": "3dabecc6", "optimized": { "react": { "src": "../../../../../node_modules/react/index.js", "file": "react.js", - "fileHash": "3004c39f", + "fileHash": "f2e0861a", "needsInterop": true }, "react/jsx-dev-runtime": { "src": "../../../../../node_modules/react/jsx-dev-runtime.js", "file": "react_jsx-dev-runtime.js", - "fileHash": "2575d3e1", + "fileHash": "fa8b241d", "needsInterop": true }, "react/jsx-runtime": { "src": "../../../../../node_modules/react/jsx-runtime.js", "file": "react_jsx-runtime.js", - "fileHash": "74dbe448", + "fileHash": "335d6ea4", "needsInterop": true }, "react-dom/client": { "src": "../../../../../node_modules/react-dom/client.js", "file": "react-dom_client.js", - "fileHash": "2b65a97b", + "fileHash": "bb9fed50", "needsInterop": true }, "react-router-dom": { "src": "../../../../../node_modules/react-router-dom/dist/index.js", "file": "react-router-dom.js", - "fileHash": "8c0ad98b", + "fileHash": "8445b7b2", "needsInterop": false }, "recharts": { "src": "../../../../../node_modules/recharts/es6/index.js", "file": "recharts.js", - "fileHash": "a1c959e5", + "fileHash": "5e3fa7c7", "needsInterop": false }, "lucide-react": { "src": "../../../../../node_modules/lucide-react/dist/esm/lucide-react.js", "file": "lucide-react.js", - "fileHash": "01c7df86", + "fileHash": "9f4729c0", + "needsInterop": false + }, + "@dfinity/agent": { + "src": "../../../../../node_modules/@dfinity/agent/lib/esm/index.js", + "file": "@dfinity_agent.js", + "fileHash": "148cf2bf", "needsInterop": false } }, "chunks": { - "chunk-CI5QM2G2": { - "file": "chunk-CI5QM2G2.js" + "canisterStatus-7DMGTDW5": { + "file": "canisterStatus-7DMGTDW5.js" + }, + "chunk-WEDUZXV4": { + "file": "chunk-WEDUZXV4.js" + }, + "chunk-F3VLP26G": { + "file": "chunk-F3VLP26G.js" + }, + "chunk-2DCM46BG": { + "file": "chunk-2DCM46BG.js" }, - "chunk-JHBQJ233": { - "file": "chunk-JHBQJ233.js" + "chunk-5WWUZCGV": { + "file": "chunk-5WWUZCGV.js" } } } \ No newline at end of file diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/canisterStatus-7DMGTDW5.js b/src/BlockThings_frontend/node_modules/.vite/deps/canisterStatus-7DMGTDW5.js new file mode 100644 index 0000000..36f59ab --- /dev/null +++ b/src/BlockThings_frontend/node_modules/.vite/deps/canisterStatus-7DMGTDW5.js @@ -0,0 +1,14 @@ +import { + CustomPath, + encodePath, + fetchNodeKeys, + request +} from "./chunk-WEDUZXV4.js"; +import "./chunk-5WWUZCGV.js"; +export { + CustomPath, + encodePath, + fetchNodeKeys, + request +}; +//# sourceMappingURL=canisterStatus-7DMGTDW5.js.map diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/canisterStatus-7DMGTDW5.js.map b/src/BlockThings_frontend/node_modules/.vite/deps/canisterStatus-7DMGTDW5.js.map new file mode 100644 index 0000000..9865211 --- /dev/null +++ b/src/BlockThings_frontend/node_modules/.vite/deps/canisterStatus-7DMGTDW5.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": [], + "sourcesContent": [], + "mappings": "", + "names": [] +} diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-JHBQJ233.js b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-2DCM46BG.js similarity index 98% rename from src/BlockThings_frontend/node_modules/.vite/deps/chunk-JHBQJ233.js rename to src/BlockThings_frontend/node_modules/.vite/deps/chunk-2DCM46BG.js index 203e724..7abc7f0 100644 --- a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-JHBQJ233.js +++ b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-2DCM46BG.js @@ -1,32 +1,6 @@ -var __create = Object.create; -var __defProp = Object.defineProperty; -var __getOwnPropDesc = Object.getOwnPropertyDescriptor; -var __getOwnPropNames = Object.getOwnPropertyNames; -var __getProtoOf = Object.getPrototypeOf; -var __hasOwnProp = Object.prototype.hasOwnProperty; -var __commonJS = (cb, mod) => function __require() { - return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; -}; -var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); -}; -var __copyProps = (to, from, except, desc) => { - if (from && typeof from === "object" || typeof from === "function") { - for (let key of __getOwnPropNames(from)) - if (!__hasOwnProp.call(to, key) && key !== except) - __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); - } - return to; -}; -var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( - // If the importer is in node compatibility mode or this is not an ESM - // file that has been converted to a CommonJS file using a Babel- - // compatible transform (i.e. "__esModule" has not been set), then set - // "default" to the CommonJS "module.exports" for node compatibility. - isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, - mod -)); +import { + __commonJS +} from "./chunk-5WWUZCGV.js"; // ../../node_modules/react/cjs/react.development.js var require_react_development = __commonJS({ @@ -1914,9 +1888,6 @@ var require_react = __commonJS({ }); export { - __commonJS, - __export, - __toESM, require_react }; /*! Bundled license information: @@ -1932,4 +1903,4 @@ react/cjs/react.development.js: * LICENSE file in the root directory of this source tree. *) */ -//# sourceMappingURL=chunk-JHBQJ233.js.map +//# sourceMappingURL=chunk-2DCM46BG.js.map diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-JHBQJ233.js.map b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-2DCM46BG.js.map similarity index 72% rename from src/BlockThings_frontend/node_modules/.vite/deps/chunk-JHBQJ233.js.map rename to src/BlockThings_frontend/node_modules/.vite/deps/chunk-2DCM46BG.js.map index d488983..2410940 100644 --- a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-JHBQJ233.js.map +++ b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-2DCM46BG.js.map @@ -2,6 +2,6 @@ "version": 3, "sources": ["../../../../../node_modules/react/cjs/react.development.js", "../../../../../node_modules/react/index.js"], "sourcesContent": ["/**\n * @license React\n * react.development.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== \"production\") {\n (function() {\n\n 'use strict';\n\n/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===\n 'function'\n) {\n __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());\n}\n var ReactVersion = '18.3.1';\n\n// ATTENTION\n// When adding new symbols to this file,\n// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'\n// The Symbol used to tag the ReactElement-like types.\nvar REACT_ELEMENT_TYPE = Symbol.for('react.element');\nvar REACT_PORTAL_TYPE = Symbol.for('react.portal');\nvar REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');\nvar REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');\nvar REACT_PROFILER_TYPE = Symbol.for('react.profiler');\nvar REACT_PROVIDER_TYPE = Symbol.for('react.provider');\nvar REACT_CONTEXT_TYPE = Symbol.for('react.context');\nvar REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');\nvar REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');\nvar REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');\nvar REACT_MEMO_TYPE = Symbol.for('react.memo');\nvar REACT_LAZY_TYPE = Symbol.for('react.lazy');\nvar REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');\nvar MAYBE_ITERATOR_SYMBOL = Symbol.iterator;\nvar FAUX_ITERATOR_SYMBOL = '@@iterator';\nfunction getIteratorFn(maybeIterable) {\n if (maybeIterable === null || typeof maybeIterable !== 'object') {\n return null;\n }\n\n var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\n\n if (typeof maybeIterator === 'function') {\n return maybeIterator;\n }\n\n return null;\n}\n\n/**\n * Keeps track of the current dispatcher.\n */\nvar ReactCurrentDispatcher = {\n /**\n * @internal\n * @type {ReactComponent}\n */\n current: null\n};\n\n/**\n * Keeps track of the current batch's configuration such as how long an update\n * should suspend for if it needs to.\n */\nvar ReactCurrentBatchConfig = {\n transition: null\n};\n\nvar ReactCurrentActQueue = {\n current: null,\n // Used to reproduce behavior of `batchedUpdates` in legacy mode.\n isBatchingLegacy: false,\n didScheduleLegacyUpdate: false\n};\n\n/**\n * Keeps track of the current owner.\n *\n * The current owner is the component who should own any components that are\n * currently being constructed.\n */\nvar ReactCurrentOwner = {\n /**\n * @internal\n * @type {ReactComponent}\n */\n current: null\n};\n\nvar ReactDebugCurrentFrame = {};\nvar currentExtraStackFrame = null;\nfunction setExtraStackFrame(stack) {\n {\n currentExtraStackFrame = stack;\n }\n}\n\n{\n ReactDebugCurrentFrame.setExtraStackFrame = function (stack) {\n {\n currentExtraStackFrame = stack;\n }\n }; // Stack implementation injected by the current renderer.\n\n\n ReactDebugCurrentFrame.getCurrentStack = null;\n\n ReactDebugCurrentFrame.getStackAddendum = function () {\n var stack = ''; // Add an extra top frame while an element is being validated\n\n if (currentExtraStackFrame) {\n stack += currentExtraStackFrame;\n } // Delegate to the injected renderer-specific implementation\n\n\n var impl = ReactDebugCurrentFrame.getCurrentStack;\n\n if (impl) {\n stack += impl() || '';\n }\n\n return stack;\n };\n}\n\n// -----------------------------------------------------------------------------\n\nvar enableScopeAPI = false; // Experimental Create Event Handle API.\nvar enableCacheElement = false;\nvar enableTransitionTracing = false; // No known bugs, but needs performance testing\n\nvar enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber\n// stuff. Intended to enable React core members to more easily debug scheduling\n// issues in DEV builds.\n\nvar enableDebugTracing = false; // Track which Fiber(s) schedule render work.\n\nvar ReactSharedInternals = {\n ReactCurrentDispatcher: ReactCurrentDispatcher,\n ReactCurrentBatchConfig: ReactCurrentBatchConfig,\n ReactCurrentOwner: ReactCurrentOwner\n};\n\n{\n ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;\n ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;\n}\n\n// by calls to these methods by a Babel plugin.\n//\n// In PROD (or in packages without access to React internals),\n// they are left as they are instead.\n\nfunction warn(format) {\n {\n {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n printWarning('warn', format, args);\n }\n }\n}\nfunction error(format) {\n {\n {\n for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n args[_key2 - 1] = arguments[_key2];\n }\n\n printWarning('error', format, args);\n }\n }\n}\n\nfunction printWarning(level, format, args) {\n // When changing this logic, you might want to also\n // update consoleWithStackDev.www.js as well.\n {\n var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\n var stack = ReactDebugCurrentFrame.getStackAddendum();\n\n if (stack !== '') {\n format += '%s';\n args = args.concat([stack]);\n } // eslint-disable-next-line react-internal/safe-string-coercion\n\n\n var argsWithFormat = args.map(function (item) {\n return String(item);\n }); // Careful: RN currently depends on this prefix\n\n argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it\n // breaks IE9: https://github.com/facebook/react/issues/13610\n // eslint-disable-next-line react-internal/no-production-logging\n\n Function.prototype.apply.call(console[level], console, argsWithFormat);\n }\n}\n\nvar didWarnStateUpdateForUnmountedComponent = {};\n\nfunction warnNoop(publicInstance, callerName) {\n {\n var _constructor = publicInstance.constructor;\n var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';\n var warningKey = componentName + \".\" + callerName;\n\n if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\n return;\n }\n\n error(\"Can't call %s on a component that is not yet mounted. \" + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);\n\n didWarnStateUpdateForUnmountedComponent[warningKey] = true;\n }\n}\n/**\n * This is the abstract API for an update queue.\n */\n\n\nvar ReactNoopUpdateQueue = {\n /**\n * Checks whether or not this composite component is mounted.\n * @param {ReactClass} publicInstance The instance we want to test.\n * @return {boolean} True if mounted, false otherwise.\n * @protected\n * @final\n */\n isMounted: function (publicInstance) {\n return false;\n },\n\n /**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {?function} callback Called after component is updated.\n * @param {?string} callerName name of the calling function in the public API.\n * @internal\n */\n enqueueForceUpdate: function (publicInstance, callback, callerName) {\n warnNoop(publicInstance, 'forceUpdate');\n },\n\n /**\n * Replaces all of the state. Always use this or `setState` to mutate state.\n * You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} completeState Next state.\n * @param {?function} callback Called after component is updated.\n * @param {?string} callerName name of the calling function in the public API.\n * @internal\n */\n enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\n warnNoop(publicInstance, 'replaceState');\n },\n\n /**\n * Sets a subset of the state. This only exists because _pendingState is\n * internal. This provides a merging strategy that is not available to deep\n * properties which is confusing. TODO: Expose pendingState or don't use it\n * during the merge.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialState Next partial state to be merged with state.\n * @param {?function} callback Called after component is updated.\n * @param {?string} Name of the calling function in the public API.\n * @internal\n */\n enqueueSetState: function (publicInstance, partialState, callback, callerName) {\n warnNoop(publicInstance, 'setState');\n }\n};\n\nvar assign = Object.assign;\n\nvar emptyObject = {};\n\n{\n Object.freeze(emptyObject);\n}\n/**\n * Base class helpers for the updating state of a component.\n */\n\n\nfunction Component(props, context, updater) {\n this.props = props;\n this.context = context; // If a component has string refs, we will assign a different object later.\n\n this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the\n // renderer.\n\n this.updater = updater || ReactNoopUpdateQueue;\n}\n\nComponent.prototype.isReactComponent = {};\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together. You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n * produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\n\nComponent.prototype.setState = function (partialState, callback) {\n if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {\n throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.');\n }\n\n this.updater.enqueueSetState(this, partialState, callback, 'setState');\n};\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\n\n\nComponent.prototype.forceUpdate = function (callback) {\n this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\n};\n/**\n * Deprecated APIs. These APIs used to exist on classic React classes but since\n * we would like to deprecate them, we're not going to move them over to this\n * modern base class. Instead, we define a getter that warns if it's accessed.\n */\n\n\n{\n var deprecatedAPIs = {\n isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\n replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\n };\n\n var defineDeprecationWarning = function (methodName, info) {\n Object.defineProperty(Component.prototype, methodName, {\n get: function () {\n warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\n\n return undefined;\n }\n });\n };\n\n for (var fnName in deprecatedAPIs) {\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\n }\n }\n}\n\nfunction ComponentDummy() {}\n\nComponentDummy.prototype = Component.prototype;\n/**\n * Convenience component with default shallow equality check for sCU.\n */\n\nfunction PureComponent(props, context, updater) {\n this.props = props;\n this.context = context; // If a component has string refs, we will assign a different object later.\n\n this.refs = emptyObject;\n this.updater = updater || ReactNoopUpdateQueue;\n}\n\nvar pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\npureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.\n\nassign(pureComponentPrototype, Component.prototype);\npureComponentPrototype.isPureReactComponent = true;\n\n// an immutable object with a single mutable value\nfunction createRef() {\n var refObject = {\n current: null\n };\n\n {\n Object.seal(refObject);\n }\n\n return refObject;\n}\n\nvar isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare\n\nfunction isArray(a) {\n return isArrayImpl(a);\n}\n\n/*\n * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol\n * and Temporal.* types. See https://github.com/facebook/react/pull/22064.\n *\n * The functions in this module will throw an easier-to-understand,\n * easier-to-debug exception with a clear errors message message explaining the\n * problem. (Instead of a confusing exception thrown inside the implementation\n * of the `value` object).\n */\n// $FlowFixMe only called in DEV, so void return is not possible.\nfunction typeName(value) {\n {\n // toStringTag is needed for namespaced types like Temporal.Instant\n var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;\n var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';\n return type;\n }\n} // $FlowFixMe only called in DEV, so void return is not possible.\n\n\nfunction willCoercionThrow(value) {\n {\n try {\n testStringCoercion(value);\n return false;\n } catch (e) {\n return true;\n }\n }\n}\n\nfunction testStringCoercion(value) {\n // If you ended up here by following an exception call stack, here's what's\n // happened: you supplied an object or symbol value to React (as a prop, key,\n // DOM attribute, CSS property, string ref, etc.) and when React tried to\n // coerce it to a string using `'' + value`, an exception was thrown.\n //\n // The most common types that will cause this exception are `Symbol` instances\n // and Temporal objects like `Temporal.Instant`. But any object that has a\n // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this\n // exception. (Library authors do this to prevent users from using built-in\n // numeric operators like `+` or comparison operators like `>=` because custom\n // methods are needed to perform accurate arithmetic or comparison.)\n //\n // To fix the problem, coerce this object or symbol value to a string before\n // passing it to React. The most reliable way is usually `String(value)`.\n //\n // To find which value is throwing, check the browser or debugger console.\n // Before this exception was thrown, there should be `console.error` output\n // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the\n // problem and how that type was used: key, atrribute, input value prop, etc.\n // In most cases, this console output also shows the component and its\n // ancestor components where the exception happened.\n //\n // eslint-disable-next-line react-internal/safe-string-coercion\n return '' + value;\n}\nfunction checkKeyStringCoercion(value) {\n {\n if (willCoercionThrow(value)) {\n error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));\n\n return testStringCoercion(value); // throw (to help callers find troubleshooting comments)\n }\n }\n}\n\nfunction getWrappedName(outerType, innerType, wrapperName) {\n var displayName = outerType.displayName;\n\n if (displayName) {\n return displayName;\n }\n\n var functionName = innerType.displayName || innerType.name || '';\n return functionName !== '' ? wrapperName + \"(\" + functionName + \")\" : wrapperName;\n} // Keep in sync with react-reconciler/getComponentNameFromFiber\n\n\nfunction getContextName(type) {\n return type.displayName || 'Context';\n} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.\n\n\nfunction getComponentNameFromType(type) {\n if (type == null) {\n // Host root, text node or just invalid type.\n return null;\n }\n\n {\n if (typeof type.tag === 'number') {\n error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');\n }\n }\n\n if (typeof type === 'function') {\n return type.displayName || type.name || null;\n }\n\n if (typeof type === 'string') {\n return type;\n }\n\n switch (type) {\n case REACT_FRAGMENT_TYPE:\n return 'Fragment';\n\n case REACT_PORTAL_TYPE:\n return 'Portal';\n\n case REACT_PROFILER_TYPE:\n return 'Profiler';\n\n case REACT_STRICT_MODE_TYPE:\n return 'StrictMode';\n\n case REACT_SUSPENSE_TYPE:\n return 'Suspense';\n\n case REACT_SUSPENSE_LIST_TYPE:\n return 'SuspenseList';\n\n }\n\n if (typeof type === 'object') {\n switch (type.$$typeof) {\n case REACT_CONTEXT_TYPE:\n var context = type;\n return getContextName(context) + '.Consumer';\n\n case REACT_PROVIDER_TYPE:\n var provider = type;\n return getContextName(provider._context) + '.Provider';\n\n case REACT_FORWARD_REF_TYPE:\n return getWrappedName(type, type.render, 'ForwardRef');\n\n case REACT_MEMO_TYPE:\n var outerName = type.displayName || null;\n\n if (outerName !== null) {\n return outerName;\n }\n\n return getComponentNameFromType(type.type) || 'Memo';\n\n case REACT_LAZY_TYPE:\n {\n var lazyComponent = type;\n var payload = lazyComponent._payload;\n var init = lazyComponent._init;\n\n try {\n return getComponentNameFromType(init(payload));\n } catch (x) {\n return null;\n }\n }\n\n // eslint-disable-next-line no-fallthrough\n }\n }\n\n return null;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar RESERVED_PROPS = {\n key: true,\n ref: true,\n __self: true,\n __source: true\n};\nvar specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;\n\n{\n didWarnAboutStringRefs = {};\n}\n\nfunction hasValidRef(config) {\n {\n if (hasOwnProperty.call(config, 'ref')) {\n var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\n\n if (getter && getter.isReactWarning) {\n return false;\n }\n }\n }\n\n return config.ref !== undefined;\n}\n\nfunction hasValidKey(config) {\n {\n if (hasOwnProperty.call(config, 'key')) {\n var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\n\n if (getter && getter.isReactWarning) {\n return false;\n }\n }\n }\n\n return config.key !== undefined;\n}\n\nfunction defineKeyPropWarningGetter(props, displayName) {\n var warnAboutAccessingKey = function () {\n {\n if (!specialPropKeyWarningShown) {\n specialPropKeyWarningShown = true;\n\n error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);\n }\n }\n };\n\n warnAboutAccessingKey.isReactWarning = true;\n Object.defineProperty(props, 'key', {\n get: warnAboutAccessingKey,\n configurable: true\n });\n}\n\nfunction defineRefPropWarningGetter(props, displayName) {\n var warnAboutAccessingRef = function () {\n {\n if (!specialPropRefWarningShown) {\n specialPropRefWarningShown = true;\n\n error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);\n }\n }\n };\n\n warnAboutAccessingRef.isReactWarning = true;\n Object.defineProperty(props, 'ref', {\n get: warnAboutAccessingRef,\n configurable: true\n });\n}\n\nfunction warnIfStringRefCannotBeAutoConverted(config) {\n {\n if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {\n var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);\n\n if (!didWarnAboutStringRefs[componentName]) {\n error('Component \"%s\" contains the string ref \"%s\". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref);\n\n didWarnAboutStringRefs[componentName] = true;\n }\n }\n }\n}\n/**\n * Factory method to create a new React element. This no longer adheres to\n * the class pattern, so do not use new to call it. Also, instanceof check\n * will not work. Instead test $$typeof field against Symbol.for('react.element') to check\n * if something is a React Element.\n *\n * @param {*} type\n * @param {*} props\n * @param {*} key\n * @param {string|object} ref\n * @param {*} owner\n * @param {*} self A *temporary* helper to detect places where `this` is\n * different from the `owner` when React.createElement is called, so that we\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\n * functions, and as long as `this` and owner are the same, there will be no\n * change in behavior.\n * @param {*} source An annotation object (added by a transpiler or otherwise)\n * indicating filename, line number, and/or other information.\n * @internal\n */\n\n\nvar ReactElement = function (type, key, ref, self, source, owner, props) {\n var element = {\n // This tag allows us to uniquely identify this as a React Element\n $$typeof: REACT_ELEMENT_TYPE,\n // Built-in properties that belong on the element\n type: type,\n key: key,\n ref: ref,\n props: props,\n // Record the component responsible for creating this element.\n _owner: owner\n };\n\n {\n // The validation flag is currently mutative. We put it on\n // an external backing store so that we can freeze the whole object.\n // This can be replaced with a WeakMap once they are implemented in\n // commonly used development environments.\n element._store = {}; // To make comparing ReactElements easier for testing purposes, we make\n // the validation flag non-enumerable (where possible, which should\n // include every environment we run tests in), so the test framework\n // ignores it.\n\n Object.defineProperty(element._store, 'validated', {\n configurable: false,\n enumerable: false,\n writable: true,\n value: false\n }); // self and source are DEV only properties.\n\n Object.defineProperty(element, '_self', {\n configurable: false,\n enumerable: false,\n writable: false,\n value: self\n }); // Two elements created in two different places should be considered\n // equal for testing purposes and therefore we hide it from enumeration.\n\n Object.defineProperty(element, '_source', {\n configurable: false,\n enumerable: false,\n writable: false,\n value: source\n });\n\n if (Object.freeze) {\n Object.freeze(element.props);\n Object.freeze(element);\n }\n }\n\n return element;\n};\n/**\n * Create and return a new ReactElement of the given type.\n * See https://reactjs.org/docs/react-api.html#createelement\n */\n\nfunction createElement(type, config, children) {\n var propName; // Reserved names are extracted\n\n var props = {};\n var key = null;\n var ref = null;\n var self = null;\n var source = null;\n\n if (config != null) {\n if (hasValidRef(config)) {\n ref = config.ref;\n\n {\n warnIfStringRefCannotBeAutoConverted(config);\n }\n }\n\n if (hasValidKey(config)) {\n {\n checkKeyStringCoercion(config.key);\n }\n\n key = '' + config.key;\n }\n\n self = config.__self === undefined ? null : config.__self;\n source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object\n\n for (propName in config) {\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n props[propName] = config[propName];\n }\n }\n } // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n\n\n var childrenLength = arguments.length - 2;\n\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = Array(childrenLength);\n\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 2];\n }\n\n {\n if (Object.freeze) {\n Object.freeze(childArray);\n }\n }\n\n props.children = childArray;\n } // Resolve default props\n\n\n if (type && type.defaultProps) {\n var defaultProps = type.defaultProps;\n\n for (propName in defaultProps) {\n if (props[propName] === undefined) {\n props[propName] = defaultProps[propName];\n }\n }\n }\n\n {\n if (key || ref) {\n var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\n\n if (key) {\n defineKeyPropWarningGetter(props, displayName);\n }\n\n if (ref) {\n defineRefPropWarningGetter(props, displayName);\n }\n }\n }\n\n return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\n}\nfunction cloneAndReplaceKey(oldElement, newKey) {\n var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\n return newElement;\n}\n/**\n * Clone and return a new ReactElement using element as the starting point.\n * See https://reactjs.org/docs/react-api.html#cloneelement\n */\n\nfunction cloneElement(element, config, children) {\n if (element === null || element === undefined) {\n throw new Error(\"React.cloneElement(...): The argument must be a React element, but you passed \" + element + \".\");\n }\n\n var propName; // Original props are copied\n\n var props = assign({}, element.props); // Reserved names are extracted\n\n var key = element.key;\n var ref = element.ref; // Self is preserved since the owner is preserved.\n\n var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a\n // transpiler, and the original source is probably a better indicator of the\n // true owner.\n\n var source = element._source; // Owner will be preserved, unless ref is overridden\n\n var owner = element._owner;\n\n if (config != null) {\n if (hasValidRef(config)) {\n // Silently steal the ref from the parent.\n ref = config.ref;\n owner = ReactCurrentOwner.current;\n }\n\n if (hasValidKey(config)) {\n {\n checkKeyStringCoercion(config.key);\n }\n\n key = '' + config.key;\n } // Remaining properties override existing props\n\n\n var defaultProps;\n\n if (element.type && element.type.defaultProps) {\n defaultProps = element.type.defaultProps;\n }\n\n for (propName in config) {\n if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n if (config[propName] === undefined && defaultProps !== undefined) {\n // Resolve default props\n props[propName] = defaultProps[propName];\n } else {\n props[propName] = config[propName];\n }\n }\n }\n } // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n\n\n var childrenLength = arguments.length - 2;\n\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = Array(childrenLength);\n\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 2];\n }\n\n props.children = childArray;\n }\n\n return ReactElement(element.type, key, ref, self, source, owner, props);\n}\n/**\n * Verifies the object is a ReactElement.\n * See https://reactjs.org/docs/react-api.html#isvalidelement\n * @param {?object} object\n * @return {boolean} True if `object` is a ReactElement.\n * @final\n */\n\nfunction isValidElement(object) {\n return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\n}\n\nvar SEPARATOR = '.';\nvar SUBSEPARATOR = ':';\n/**\n * Escape and wrap key so it is safe to use as a reactid\n *\n * @param {string} key to be escaped.\n * @return {string} the escaped key.\n */\n\nfunction escape(key) {\n var escapeRegex = /[=:]/g;\n var escaperLookup = {\n '=': '=0',\n ':': '=2'\n };\n var escapedString = key.replace(escapeRegex, function (match) {\n return escaperLookup[match];\n });\n return '$' + escapedString;\n}\n/**\n * TODO: Test that a single child and an array with one item have the same key\n * pattern.\n */\n\n\nvar didWarnAboutMaps = false;\nvar userProvidedKeyEscapeRegex = /\\/+/g;\n\nfunction escapeUserProvidedKey(text) {\n return text.replace(userProvidedKeyEscapeRegex, '$&/');\n}\n/**\n * Generate a key string that identifies a element within a set.\n *\n * @param {*} element A element that could contain a manual key.\n * @param {number} index Index that is used if a manual key is not provided.\n * @return {string}\n */\n\n\nfunction getElementKey(element, index) {\n // Do some typechecking here since we call this blindly. We want to ensure\n // that we don't block potential future ES APIs.\n if (typeof element === 'object' && element !== null && element.key != null) {\n // Explicit key\n {\n checkKeyStringCoercion(element.key);\n }\n\n return escape('' + element.key);\n } // Implicit key determined by the index in the set\n\n\n return index.toString(36);\n}\n\nfunction mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {\n var type = typeof children;\n\n if (type === 'undefined' || type === 'boolean') {\n // All of the above are perceived as null.\n children = null;\n }\n\n var invokeCallback = false;\n\n if (children === null) {\n invokeCallback = true;\n } else {\n switch (type) {\n case 'string':\n case 'number':\n invokeCallback = true;\n break;\n\n case 'object':\n switch (children.$$typeof) {\n case REACT_ELEMENT_TYPE:\n case REACT_PORTAL_TYPE:\n invokeCallback = true;\n }\n\n }\n }\n\n if (invokeCallback) {\n var _child = children;\n var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array\n // so that it's consistent if the number of children grows:\n\n var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;\n\n if (isArray(mappedChild)) {\n var escapedChildKey = '';\n\n if (childKey != null) {\n escapedChildKey = escapeUserProvidedKey(childKey) + '/';\n }\n\n mapIntoArray(mappedChild, array, escapedChildKey, '', function (c) {\n return c;\n });\n } else if (mappedChild != null) {\n if (isValidElement(mappedChild)) {\n {\n // The `if` statement here prevents auto-disabling of the safe\n // coercion ESLint rule, so we must manually disable it below.\n // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key\n if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) {\n checkKeyStringCoercion(mappedChild.key);\n }\n }\n\n mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as\n // traverseAllChildren used to do for objects as children\n escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key\n mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number\n // eslint-disable-next-line react-internal/safe-string-coercion\n escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey);\n }\n\n array.push(mappedChild);\n }\n\n return 1;\n }\n\n var child;\n var nextName;\n var subtreeCount = 0; // Count of children found in the current subtree.\n\n var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\n\n if (isArray(children)) {\n for (var i = 0; i < children.length; i++) {\n child = children[i];\n nextName = nextNamePrefix + getElementKey(child, i);\n subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);\n }\n } else {\n var iteratorFn = getIteratorFn(children);\n\n if (typeof iteratorFn === 'function') {\n var iterableChildren = children;\n\n {\n // Warn about using Maps as children\n if (iteratorFn === iterableChildren.entries) {\n if (!didWarnAboutMaps) {\n warn('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.');\n }\n\n didWarnAboutMaps = true;\n }\n }\n\n var iterator = iteratorFn.call(iterableChildren);\n var step;\n var ii = 0;\n\n while (!(step = iterator.next()).done) {\n child = step.value;\n nextName = nextNamePrefix + getElementKey(child, ii++);\n subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);\n }\n } else if (type === 'object') {\n // eslint-disable-next-line react-internal/safe-string-coercion\n var childrenString = String(children);\n throw new Error(\"Objects are not valid as a React child (found: \" + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + \"). \" + 'If you meant to render a collection of children, use an array ' + 'instead.');\n }\n }\n\n return subtreeCount;\n}\n\n/**\n * Maps children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\n *\n * The provided mapFunction(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} func The map function.\n * @param {*} context Context for mapFunction.\n * @return {object} Object containing the ordered map of results.\n */\nfunction mapChildren(children, func, context) {\n if (children == null) {\n return children;\n }\n\n var result = [];\n var count = 0;\n mapIntoArray(children, result, '', '', function (child) {\n return func.call(context, child, count++);\n });\n return result;\n}\n/**\n * Count the number of children that are typically specified as\n * `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\n *\n * @param {?*} children Children tree container.\n * @return {number} The number of children.\n */\n\n\nfunction countChildren(children) {\n var n = 0;\n mapChildren(children, function () {\n n++; // Don't return anything\n });\n return n;\n}\n\n/**\n * Iterates through children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\n *\n * The provided forEachFunc(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} forEachFunc\n * @param {*} forEachContext Context for forEachContext.\n */\nfunction forEachChildren(children, forEachFunc, forEachContext) {\n mapChildren(children, function () {\n forEachFunc.apply(this, arguments); // Don't return anything.\n }, forEachContext);\n}\n/**\n * Flatten a children object (typically specified as `props.children`) and\n * return an array with appropriately re-keyed children.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\n */\n\n\nfunction toArray(children) {\n return mapChildren(children, function (child) {\n return child;\n }) || [];\n}\n/**\n * Returns the first child in a collection of children and verifies that there\n * is only one child in the collection.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\n *\n * The current implementation of this function assumes that a single child gets\n * passed without a wrapper, but the purpose of this helper function is to\n * abstract away the particular structure of children.\n *\n * @param {?object} children Child collection structure.\n * @return {ReactElement} The first and only `ReactElement` contained in the\n * structure.\n */\n\n\nfunction onlyChild(children) {\n if (!isValidElement(children)) {\n throw new Error('React.Children.only expected to receive a single React element child.');\n }\n\n return children;\n}\n\nfunction createContext(defaultValue) {\n // TODO: Second argument used to be an optional `calculateChangedBits`\n // function. Warn to reserve for future use?\n var context = {\n $$typeof: REACT_CONTEXT_TYPE,\n // As a workaround to support multiple concurrent renderers, we categorize\n // some renderers as primary and others as secondary. We only expect\n // there to be two concurrent renderers at most: React Native (primary) and\n // Fabric (secondary); React DOM (primary) and React ART (secondary).\n // Secondary renderers store their context values on separate fields.\n _currentValue: defaultValue,\n _currentValue2: defaultValue,\n // Used to track how many concurrent renderers this context currently\n // supports within in a single renderer. Such as parallel server rendering.\n _threadCount: 0,\n // These are circular\n Provider: null,\n Consumer: null,\n // Add these to use same hidden class in VM as ServerContext\n _defaultValue: null,\n _globalName: null\n };\n context.Provider = {\n $$typeof: REACT_PROVIDER_TYPE,\n _context: context\n };\n var hasWarnedAboutUsingNestedContextConsumers = false;\n var hasWarnedAboutUsingConsumerProvider = false;\n var hasWarnedAboutDisplayNameOnConsumer = false;\n\n {\n // A separate object, but proxies back to the original context object for\n // backwards compatibility. It has a different $$typeof, so we can properly\n // warn for the incorrect usage of Context as a Consumer.\n var Consumer = {\n $$typeof: REACT_CONTEXT_TYPE,\n _context: context\n }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here\n\n Object.defineProperties(Consumer, {\n Provider: {\n get: function () {\n if (!hasWarnedAboutUsingConsumerProvider) {\n hasWarnedAboutUsingConsumerProvider = true;\n\n error('Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\n }\n\n return context.Provider;\n },\n set: function (_Provider) {\n context.Provider = _Provider;\n }\n },\n _currentValue: {\n get: function () {\n return context._currentValue;\n },\n set: function (_currentValue) {\n context._currentValue = _currentValue;\n }\n },\n _currentValue2: {\n get: function () {\n return context._currentValue2;\n },\n set: function (_currentValue2) {\n context._currentValue2 = _currentValue2;\n }\n },\n _threadCount: {\n get: function () {\n return context._threadCount;\n },\n set: function (_threadCount) {\n context._threadCount = _threadCount;\n }\n },\n Consumer: {\n get: function () {\n if (!hasWarnedAboutUsingNestedContextConsumers) {\n hasWarnedAboutUsingNestedContextConsumers = true;\n\n error('Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');\n }\n\n return context.Consumer;\n }\n },\n displayName: {\n get: function () {\n return context.displayName;\n },\n set: function (displayName) {\n if (!hasWarnedAboutDisplayNameOnConsumer) {\n warn('Setting `displayName` on Context.Consumer has no effect. ' + \"You should set it directly on the context with Context.displayName = '%s'.\", displayName);\n\n hasWarnedAboutDisplayNameOnConsumer = true;\n }\n }\n }\n }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty\n\n context.Consumer = Consumer;\n }\n\n {\n context._currentRenderer = null;\n context._currentRenderer2 = null;\n }\n\n return context;\n}\n\nvar Uninitialized = -1;\nvar Pending = 0;\nvar Resolved = 1;\nvar Rejected = 2;\n\nfunction lazyInitializer(payload) {\n if (payload._status === Uninitialized) {\n var ctor = payload._result;\n var thenable = ctor(); // Transition to the next state.\n // This might throw either because it's missing or throws. If so, we treat it\n // as still uninitialized and try again next time. Which is the same as what\n // happens if the ctor or any wrappers processing the ctor throws. This might\n // end up fixing it if the resolution was a concurrency bug.\n\n thenable.then(function (moduleObject) {\n if (payload._status === Pending || payload._status === Uninitialized) {\n // Transition to the next state.\n var resolved = payload;\n resolved._status = Resolved;\n resolved._result = moduleObject;\n }\n }, function (error) {\n if (payload._status === Pending || payload._status === Uninitialized) {\n // Transition to the next state.\n var rejected = payload;\n rejected._status = Rejected;\n rejected._result = error;\n }\n });\n\n if (payload._status === Uninitialized) {\n // In case, we're still uninitialized, then we're waiting for the thenable\n // to resolve. Set it as pending in the meantime.\n var pending = payload;\n pending._status = Pending;\n pending._result = thenable;\n }\n }\n\n if (payload._status === Resolved) {\n var moduleObject = payload._result;\n\n {\n if (moduleObject === undefined) {\n error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\\n\\nYour code should look like: \\n ' + // Break up imports to avoid accidentally parsing them as dependencies.\n 'const MyComponent = lazy(() => imp' + \"ort('./MyComponent'))\\n\\n\" + 'Did you accidentally put curly braces around the import?', moduleObject);\n }\n }\n\n {\n if (!('default' in moduleObject)) {\n error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\\n\\nYour code should look like: \\n ' + // Break up imports to avoid accidentally parsing them as dependencies.\n 'const MyComponent = lazy(() => imp' + \"ort('./MyComponent'))\", moduleObject);\n }\n }\n\n return moduleObject.default;\n } else {\n throw payload._result;\n }\n}\n\nfunction lazy(ctor) {\n var payload = {\n // We use these fields to store the result.\n _status: Uninitialized,\n _result: ctor\n };\n var lazyType = {\n $$typeof: REACT_LAZY_TYPE,\n _payload: payload,\n _init: lazyInitializer\n };\n\n {\n // In production, this would just set it on the object.\n var defaultProps;\n var propTypes; // $FlowFixMe\n\n Object.defineProperties(lazyType, {\n defaultProps: {\n configurable: true,\n get: function () {\n return defaultProps;\n },\n set: function (newDefaultProps) {\n error('React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\n\n defaultProps = newDefaultProps; // Match production behavior more closely:\n // $FlowFixMe\n\n Object.defineProperty(lazyType, 'defaultProps', {\n enumerable: true\n });\n }\n },\n propTypes: {\n configurable: true,\n get: function () {\n return propTypes;\n },\n set: function (newPropTypes) {\n error('React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');\n\n propTypes = newPropTypes; // Match production behavior more closely:\n // $FlowFixMe\n\n Object.defineProperty(lazyType, 'propTypes', {\n enumerable: true\n });\n }\n }\n });\n }\n\n return lazyType;\n}\n\nfunction forwardRef(render) {\n {\n if (render != null && render.$$typeof === REACT_MEMO_TYPE) {\n error('forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');\n } else if (typeof render !== 'function') {\n error('forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);\n } else {\n if (render.length !== 0 && render.length !== 2) {\n error('forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.');\n }\n }\n\n if (render != null) {\n if (render.defaultProps != null || render.propTypes != null) {\n error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?');\n }\n }\n }\n\n var elementType = {\n $$typeof: REACT_FORWARD_REF_TYPE,\n render: render\n };\n\n {\n var ownName;\n Object.defineProperty(elementType, 'displayName', {\n enumerable: false,\n configurable: true,\n get: function () {\n return ownName;\n },\n set: function (name) {\n ownName = name; // The inner component shouldn't inherit this display name in most cases,\n // because the component may be used elsewhere.\n // But it's nice for anonymous functions to inherit the name,\n // so that our component-stack generation logic will display their frames.\n // An anonymous function generally suggests a pattern like:\n // React.forwardRef((props, ref) => {...});\n // This kind of inner function is not used elsewhere so the side effect is okay.\n\n if (!render.name && !render.displayName) {\n render.displayName = name;\n }\n }\n });\n }\n\n return elementType;\n}\n\nvar REACT_MODULE_REFERENCE;\n\n{\n REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');\n}\n\nfunction isValidElementType(type) {\n if (typeof type === 'string' || typeof type === 'function') {\n return true;\n } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).\n\n\n if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing ) {\n return true;\n }\n\n if (typeof type === 'object' && type !== null) {\n if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object\n // types supported by any Flight configuration anywhere since\n // we don't know which Flight build this will end up being used\n // with.\n type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {\n return true;\n }\n }\n\n return false;\n}\n\nfunction memo(type, compare) {\n {\n if (!isValidElementType(type)) {\n error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);\n }\n }\n\n var elementType = {\n $$typeof: REACT_MEMO_TYPE,\n type: type,\n compare: compare === undefined ? null : compare\n };\n\n {\n var ownName;\n Object.defineProperty(elementType, 'displayName', {\n enumerable: false,\n configurable: true,\n get: function () {\n return ownName;\n },\n set: function (name) {\n ownName = name; // The inner component shouldn't inherit this display name in most cases,\n // because the component may be used elsewhere.\n // But it's nice for anonymous functions to inherit the name,\n // so that our component-stack generation logic will display their frames.\n // An anonymous function generally suggests a pattern like:\n // React.memo((props) => {...});\n // This kind of inner function is not used elsewhere so the side effect is okay.\n\n if (!type.name && !type.displayName) {\n type.displayName = name;\n }\n }\n });\n }\n\n return elementType;\n}\n\nfunction resolveDispatcher() {\n var dispatcher = ReactCurrentDispatcher.current;\n\n {\n if (dispatcher === null) {\n error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\\n' + '2. You might be breaking the Rules of Hooks\\n' + '3. You might have more than one copy of React in the same app\\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');\n }\n } // Will result in a null access error if accessed outside render phase. We\n // intentionally don't throw our own error because this is in a hot path.\n // Also helps ensure this is inlined.\n\n\n return dispatcher;\n}\nfunction useContext(Context) {\n var dispatcher = resolveDispatcher();\n\n {\n // TODO: add a more generic warning for invalid values.\n if (Context._context !== undefined) {\n var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs\n // and nobody should be using this in existing code.\n\n if (realContext.Consumer === Context) {\n error('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');\n } else if (realContext.Provider === Context) {\n error('Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');\n }\n }\n }\n\n return dispatcher.useContext(Context);\n}\nfunction useState(initialState) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useState(initialState);\n}\nfunction useReducer(reducer, initialArg, init) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useReducer(reducer, initialArg, init);\n}\nfunction useRef(initialValue) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useRef(initialValue);\n}\nfunction useEffect(create, deps) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useEffect(create, deps);\n}\nfunction useInsertionEffect(create, deps) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useInsertionEffect(create, deps);\n}\nfunction useLayoutEffect(create, deps) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useLayoutEffect(create, deps);\n}\nfunction useCallback(callback, deps) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useCallback(callback, deps);\n}\nfunction useMemo(create, deps) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useMemo(create, deps);\n}\nfunction useImperativeHandle(ref, create, deps) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useImperativeHandle(ref, create, deps);\n}\nfunction useDebugValue(value, formatterFn) {\n {\n var dispatcher = resolveDispatcher();\n return dispatcher.useDebugValue(value, formatterFn);\n }\n}\nfunction useTransition() {\n var dispatcher = resolveDispatcher();\n return dispatcher.useTransition();\n}\nfunction useDeferredValue(value) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useDeferredValue(value);\n}\nfunction useId() {\n var dispatcher = resolveDispatcher();\n return dispatcher.useId();\n}\nfunction useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {\n var dispatcher = resolveDispatcher();\n return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);\n}\n\n// Helpers to patch console.logs to avoid logging during side-effect free\n// replaying on render function. This currently only patches the object\n// lazily which won't cover if the log function was extracted eagerly.\n// We could also eagerly patch the method.\nvar disabledDepth = 0;\nvar prevLog;\nvar prevInfo;\nvar prevWarn;\nvar prevError;\nvar prevGroup;\nvar prevGroupCollapsed;\nvar prevGroupEnd;\n\nfunction disabledLog() {}\n\ndisabledLog.__reactDisabledLog = true;\nfunction disableLogs() {\n {\n if (disabledDepth === 0) {\n /* eslint-disable react-internal/no-production-logging */\n prevLog = console.log;\n prevInfo = console.info;\n prevWarn = console.warn;\n prevError = console.error;\n prevGroup = console.group;\n prevGroupCollapsed = console.groupCollapsed;\n prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099\n\n var props = {\n configurable: true,\n enumerable: true,\n value: disabledLog,\n writable: true\n }; // $FlowFixMe Flow thinks console is immutable.\n\n Object.defineProperties(console, {\n info: props,\n log: props,\n warn: props,\n error: props,\n group: props,\n groupCollapsed: props,\n groupEnd: props\n });\n /* eslint-enable react-internal/no-production-logging */\n }\n\n disabledDepth++;\n }\n}\nfunction reenableLogs() {\n {\n disabledDepth--;\n\n if (disabledDepth === 0) {\n /* eslint-disable react-internal/no-production-logging */\n var props = {\n configurable: true,\n enumerable: true,\n writable: true\n }; // $FlowFixMe Flow thinks console is immutable.\n\n Object.defineProperties(console, {\n log: assign({}, props, {\n value: prevLog\n }),\n info: assign({}, props, {\n value: prevInfo\n }),\n warn: assign({}, props, {\n value: prevWarn\n }),\n error: assign({}, props, {\n value: prevError\n }),\n group: assign({}, props, {\n value: prevGroup\n }),\n groupCollapsed: assign({}, props, {\n value: prevGroupCollapsed\n }),\n groupEnd: assign({}, props, {\n value: prevGroupEnd\n })\n });\n /* eslint-enable react-internal/no-production-logging */\n }\n\n if (disabledDepth < 0) {\n error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');\n }\n }\n}\n\nvar ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;\nvar prefix;\nfunction describeBuiltInComponentFrame(name, source, ownerFn) {\n {\n if (prefix === undefined) {\n // Extract the VM specific prefix used by each line.\n try {\n throw Error();\n } catch (x) {\n var match = x.stack.trim().match(/\\n( *(at )?)/);\n prefix = match && match[1] || '';\n }\n } // We use the prefix to ensure our stacks line up with native stack frames.\n\n\n return '\\n' + prefix + name;\n }\n}\nvar reentry = false;\nvar componentFrameCache;\n\n{\n var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;\n componentFrameCache = new PossiblyWeakMap();\n}\n\nfunction describeNativeComponentFrame(fn, construct) {\n // If something asked for a stack inside a fake render, it should get ignored.\n if ( !fn || reentry) {\n return '';\n }\n\n {\n var frame = componentFrameCache.get(fn);\n\n if (frame !== undefined) {\n return frame;\n }\n }\n\n var control;\n reentry = true;\n var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.\n\n Error.prepareStackTrace = undefined;\n var previousDispatcher;\n\n {\n previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function\n // for warnings.\n\n ReactCurrentDispatcher$1.current = null;\n disableLogs();\n }\n\n try {\n // This should throw.\n if (construct) {\n // Something should be setting the props in the constructor.\n var Fake = function () {\n throw Error();\n }; // $FlowFixMe\n\n\n Object.defineProperty(Fake.prototype, 'props', {\n set: function () {\n // We use a throwing setter instead of frozen or non-writable props\n // because that won't throw in a non-strict mode function.\n throw Error();\n }\n });\n\n if (typeof Reflect === 'object' && Reflect.construct) {\n // We construct a different control for this case to include any extra\n // frames added by the construct call.\n try {\n Reflect.construct(Fake, []);\n } catch (x) {\n control = x;\n }\n\n Reflect.construct(fn, [], Fake);\n } else {\n try {\n Fake.call();\n } catch (x) {\n control = x;\n }\n\n fn.call(Fake.prototype);\n }\n } else {\n try {\n throw Error();\n } catch (x) {\n control = x;\n }\n\n fn();\n }\n } catch (sample) {\n // This is inlined manually because closure doesn't do it for us.\n if (sample && control && typeof sample.stack === 'string') {\n // This extracts the first frame from the sample that isn't also in the control.\n // Skipping one frame that we assume is the frame that calls the two.\n var sampleLines = sample.stack.split('\\n');\n var controlLines = control.stack.split('\\n');\n var s = sampleLines.length - 1;\n var c = controlLines.length - 1;\n\n while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {\n // We expect at least one stack frame to be shared.\n // Typically this will be the root most one. However, stack frames may be\n // cut off due to maximum stack limits. In this case, one maybe cut off\n // earlier than the other. We assume that the sample is longer or the same\n // and there for cut off earlier. So we should find the root most frame in\n // the sample somewhere in the control.\n c--;\n }\n\n for (; s >= 1 && c >= 0; s--, c--) {\n // Next we find the first one that isn't the same which should be the\n // frame that called our sample function and the control.\n if (sampleLines[s] !== controlLines[c]) {\n // In V8, the first line is describing the message but other VMs don't.\n // If we're about to return the first line, and the control is also on the same\n // line, that's a pretty good indicator that our sample threw at same line as\n // the control. I.e. before we entered the sample frame. So we ignore this result.\n // This can happen if you passed a class to function component, or non-function.\n if (s !== 1 || c !== 1) {\n do {\n s--;\n c--; // We may still have similar intermediate frames from the construct call.\n // The next one that isn't the same should be our match though.\n\n if (c < 0 || sampleLines[s] !== controlLines[c]) {\n // V8 adds a \"new\" prefix for native classes. Let's remove it to make it prettier.\n var _frame = '\\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled \"\"\n // but we have a user-provided \"displayName\"\n // splice it in to make the stack more readable.\n\n\n if (fn.displayName && _frame.includes('')) {\n _frame = _frame.replace('', fn.displayName);\n }\n\n {\n if (typeof fn === 'function') {\n componentFrameCache.set(fn, _frame);\n }\n } // Return the line we found.\n\n\n return _frame;\n }\n } while (s >= 1 && c >= 0);\n }\n\n break;\n }\n }\n }\n } finally {\n reentry = false;\n\n {\n ReactCurrentDispatcher$1.current = previousDispatcher;\n reenableLogs();\n }\n\n Error.prepareStackTrace = previousPrepareStackTrace;\n } // Fallback to just using the name if we couldn't make it throw.\n\n\n var name = fn ? fn.displayName || fn.name : '';\n var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';\n\n {\n if (typeof fn === 'function') {\n componentFrameCache.set(fn, syntheticFrame);\n }\n }\n\n return syntheticFrame;\n}\nfunction describeFunctionComponentFrame(fn, source, ownerFn) {\n {\n return describeNativeComponentFrame(fn, false);\n }\n}\n\nfunction shouldConstruct(Component) {\n var prototype = Component.prototype;\n return !!(prototype && prototype.isReactComponent);\n}\n\nfunction describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {\n\n if (type == null) {\n return '';\n }\n\n if (typeof type === 'function') {\n {\n return describeNativeComponentFrame(type, shouldConstruct(type));\n }\n }\n\n if (typeof type === 'string') {\n return describeBuiltInComponentFrame(type);\n }\n\n switch (type) {\n case REACT_SUSPENSE_TYPE:\n return describeBuiltInComponentFrame('Suspense');\n\n case REACT_SUSPENSE_LIST_TYPE:\n return describeBuiltInComponentFrame('SuspenseList');\n }\n\n if (typeof type === 'object') {\n switch (type.$$typeof) {\n case REACT_FORWARD_REF_TYPE:\n return describeFunctionComponentFrame(type.render);\n\n case REACT_MEMO_TYPE:\n // Memo may contain any component type so we recursively resolve it.\n return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);\n\n case REACT_LAZY_TYPE:\n {\n var lazyComponent = type;\n var payload = lazyComponent._payload;\n var init = lazyComponent._init;\n\n try {\n // Lazy may contain any component type so we recursively resolve it.\n return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);\n } catch (x) {}\n }\n }\n }\n\n return '';\n}\n\nvar loggedTypeFailures = {};\nvar ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;\n\nfunction setCurrentlyValidatingElement(element) {\n {\n if (element) {\n var owner = element._owner;\n var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);\n ReactDebugCurrentFrame$1.setExtraStackFrame(stack);\n } else {\n ReactDebugCurrentFrame$1.setExtraStackFrame(null);\n }\n }\n}\n\nfunction checkPropTypes(typeSpecs, values, location, componentName, element) {\n {\n // $FlowFixMe This is okay but Flow doesn't know it.\n var has = Function.call.bind(hasOwnProperty);\n\n for (var typeSpecName in typeSpecs) {\n if (has(typeSpecs, typeSpecName)) {\n var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to\n // fail the render phase where it didn't fail before. So we log it.\n // After these have been cleaned up, we'll let them throw.\n\n try {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n if (typeof typeSpecs[typeSpecName] !== 'function') {\n // eslint-disable-next-line react-internal/prod-error-codes\n var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');\n err.name = 'Invariant Violation';\n throw err;\n }\n\n error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');\n } catch (ex) {\n error$1 = ex;\n }\n\n if (error$1 && !(error$1 instanceof Error)) {\n setCurrentlyValidatingElement(element);\n\n error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);\n\n setCurrentlyValidatingElement(null);\n }\n\n if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n loggedTypeFailures[error$1.message] = true;\n setCurrentlyValidatingElement(element);\n\n error('Failed %s type: %s', location, error$1.message);\n\n setCurrentlyValidatingElement(null);\n }\n }\n }\n }\n}\n\nfunction setCurrentlyValidatingElement$1(element) {\n {\n if (element) {\n var owner = element._owner;\n var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);\n setExtraStackFrame(stack);\n } else {\n setExtraStackFrame(null);\n }\n }\n}\n\nvar propTypesMisspellWarningShown;\n\n{\n propTypesMisspellWarningShown = false;\n}\n\nfunction getDeclarationErrorAddendum() {\n if (ReactCurrentOwner.current) {\n var name = getComponentNameFromType(ReactCurrentOwner.current.type);\n\n if (name) {\n return '\\n\\nCheck the render method of `' + name + '`.';\n }\n }\n\n return '';\n}\n\nfunction getSourceInfoErrorAddendum(source) {\n if (source !== undefined) {\n var fileName = source.fileName.replace(/^.*[\\\\\\/]/, '');\n var lineNumber = source.lineNumber;\n return '\\n\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\n }\n\n return '';\n}\n\nfunction getSourceInfoErrorAddendumForProps(elementProps) {\n if (elementProps !== null && elementProps !== undefined) {\n return getSourceInfoErrorAddendum(elementProps.__source);\n }\n\n return '';\n}\n/**\n * Warn if there's no key explicitly set on dynamic arrays of children or\n * object keys are not valid. This allows us to keep track of children between\n * updates.\n */\n\n\nvar ownerHasKeyUseWarning = {};\n\nfunction getCurrentComponentErrorInfo(parentType) {\n var info = getDeclarationErrorAddendum();\n\n if (!info) {\n var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\n\n if (parentName) {\n info = \"\\n\\nCheck the top-level render call using <\" + parentName + \">.\";\n }\n }\n\n return info;\n}\n/**\n * Warn if the element doesn't have an explicit key assigned to it.\n * This element is in an array. The array could grow and shrink or be\n * reordered. All children that haven't already been validated are required to\n * have a \"key\" property assigned to it. Error statuses are cached so a warning\n * will only be shown once.\n *\n * @internal\n * @param {ReactElement} element Element that requires a key.\n * @param {*} parentType element's parent's type.\n */\n\n\nfunction validateExplicitKey(element, parentType) {\n if (!element._store || element._store.validated || element.key != null) {\n return;\n }\n\n element._store.validated = true;\n var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\n\n if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\n return;\n }\n\n ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a\n // property, it may be the creator of the child that's responsible for\n // assigning it a key.\n\n var childOwner = '';\n\n if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\n // Give the component that originally created this child.\n childOwner = \" It was passed a child from \" + getComponentNameFromType(element._owner.type) + \".\";\n }\n\n {\n setCurrentlyValidatingElement$1(element);\n\n error('Each child in a list should have a unique \"key\" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);\n\n setCurrentlyValidatingElement$1(null);\n }\n}\n/**\n * Ensure that every element either is passed in a static location, in an\n * array with an explicit keys property defined, or in an object literal\n * with valid key property.\n *\n * @internal\n * @param {ReactNode} node Statically passed child of any type.\n * @param {*} parentType node's parent's type.\n */\n\n\nfunction validateChildKeys(node, parentType) {\n if (typeof node !== 'object') {\n return;\n }\n\n if (isArray(node)) {\n for (var i = 0; i < node.length; i++) {\n var child = node[i];\n\n if (isValidElement(child)) {\n validateExplicitKey(child, parentType);\n }\n }\n } else if (isValidElement(node)) {\n // This element was passed in a valid location.\n if (node._store) {\n node._store.validated = true;\n }\n } else if (node) {\n var iteratorFn = getIteratorFn(node);\n\n if (typeof iteratorFn === 'function') {\n // Entry iterators used to provide implicit keys,\n // but now we print a separate warning for them later.\n if (iteratorFn !== node.entries) {\n var iterator = iteratorFn.call(node);\n var step;\n\n while (!(step = iterator.next()).done) {\n if (isValidElement(step.value)) {\n validateExplicitKey(step.value, parentType);\n }\n }\n }\n }\n }\n}\n/**\n * Given an element, validate that its props follow the propTypes definition,\n * provided by the type.\n *\n * @param {ReactElement} element\n */\n\n\nfunction validatePropTypes(element) {\n {\n var type = element.type;\n\n if (type === null || type === undefined || typeof type === 'string') {\n return;\n }\n\n var propTypes;\n\n if (typeof type === 'function') {\n propTypes = type.propTypes;\n } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.\n // Inner props are checked in the reconciler.\n type.$$typeof === REACT_MEMO_TYPE)) {\n propTypes = type.propTypes;\n } else {\n return;\n }\n\n if (propTypes) {\n // Intentionally inside to avoid triggering lazy initializers:\n var name = getComponentNameFromType(type);\n checkPropTypes(propTypes, element.props, 'prop', name, element);\n } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {\n propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:\n\n var _name = getComponentNameFromType(type);\n\n error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');\n }\n\n if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {\n error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');\n }\n }\n}\n/**\n * Given a fragment, validate that it can only be provided with fragment props\n * @param {ReactElement} fragment\n */\n\n\nfunction validateFragmentProps(fragment) {\n {\n var keys = Object.keys(fragment.props);\n\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n\n if (key !== 'children' && key !== 'key') {\n setCurrentlyValidatingElement$1(fragment);\n\n error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);\n\n setCurrentlyValidatingElement$1(null);\n break;\n }\n }\n\n if (fragment.ref !== null) {\n setCurrentlyValidatingElement$1(fragment);\n\n error('Invalid attribute `ref` supplied to `React.Fragment`.');\n\n setCurrentlyValidatingElement$1(null);\n }\n }\n}\nfunction createElementWithValidation(type, props, children) {\n var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to\n // succeed and there will likely be errors in render.\n\n if (!validType) {\n var info = '';\n\n if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\n info += ' You likely forgot to export your component from the file ' + \"it's defined in, or you might have mixed up default and named imports.\";\n }\n\n var sourceInfo = getSourceInfoErrorAddendumForProps(props);\n\n if (sourceInfo) {\n info += sourceInfo;\n } else {\n info += getDeclarationErrorAddendum();\n }\n\n var typeString;\n\n if (type === null) {\n typeString = 'null';\n } else if (isArray(type)) {\n typeString = 'array';\n } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {\n typeString = \"<\" + (getComponentNameFromType(type.type) || 'Unknown') + \" />\";\n info = ' Did you accidentally export a JSX literal instead of a component?';\n } else {\n typeString = typeof type;\n }\n\n {\n error('React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);\n }\n }\n\n var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.\n // TODO: Drop this when these are no longer allowed as the type argument.\n\n if (element == null) {\n return element;\n } // Skip key warning if the type isn't valid since our key validation logic\n // doesn't expect a non-string/function type and can throw confusing errors.\n // We don't want exception behavior to differ between dev and prod.\n // (Rendering will throw with a helpful message and as soon as the type is\n // fixed, the key warnings will appear.)\n\n\n if (validType) {\n for (var i = 2; i < arguments.length; i++) {\n validateChildKeys(arguments[i], type);\n }\n }\n\n if (type === REACT_FRAGMENT_TYPE) {\n validateFragmentProps(element);\n } else {\n validatePropTypes(element);\n }\n\n return element;\n}\nvar didWarnAboutDeprecatedCreateFactory = false;\nfunction createFactoryWithValidation(type) {\n var validatedFactory = createElementWithValidation.bind(null, type);\n validatedFactory.type = type;\n\n {\n if (!didWarnAboutDeprecatedCreateFactory) {\n didWarnAboutDeprecatedCreateFactory = true;\n\n warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.');\n } // Legacy hook: remove it\n\n\n Object.defineProperty(validatedFactory, 'type', {\n enumerable: false,\n get: function () {\n warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\n\n Object.defineProperty(this, 'type', {\n value: type\n });\n return type;\n }\n });\n }\n\n return validatedFactory;\n}\nfunction cloneElementWithValidation(element, props, children) {\n var newElement = cloneElement.apply(this, arguments);\n\n for (var i = 2; i < arguments.length; i++) {\n validateChildKeys(arguments[i], newElement.type);\n }\n\n validatePropTypes(newElement);\n return newElement;\n}\n\nfunction startTransition(scope, options) {\n var prevTransition = ReactCurrentBatchConfig.transition;\n ReactCurrentBatchConfig.transition = {};\n var currentTransition = ReactCurrentBatchConfig.transition;\n\n {\n ReactCurrentBatchConfig.transition._updatedFibers = new Set();\n }\n\n try {\n scope();\n } finally {\n ReactCurrentBatchConfig.transition = prevTransition;\n\n {\n if (prevTransition === null && currentTransition._updatedFibers) {\n var updatedFibersCount = currentTransition._updatedFibers.size;\n\n if (updatedFibersCount > 10) {\n warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.');\n }\n\n currentTransition._updatedFibers.clear();\n }\n }\n }\n}\n\nvar didWarnAboutMessageChannel = false;\nvar enqueueTaskImpl = null;\nfunction enqueueTask(task) {\n if (enqueueTaskImpl === null) {\n try {\n // read require off the module object to get around the bundlers.\n // we don't want them to detect a require and bundle a Node polyfill.\n var requireString = ('require' + Math.random()).slice(0, 7);\n var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's\n // version of setImmediate, bypassing fake timers if any.\n\n enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate;\n } catch (_err) {\n // we're in a browser\n // we can't use regular timers because they may still be faked\n // so we try MessageChannel+postMessage instead\n enqueueTaskImpl = function (callback) {\n {\n if (didWarnAboutMessageChannel === false) {\n didWarnAboutMessageChannel = true;\n\n if (typeof MessageChannel === 'undefined') {\n error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.');\n }\n }\n }\n\n var channel = new MessageChannel();\n channel.port1.onmessage = callback;\n channel.port2.postMessage(undefined);\n };\n }\n }\n\n return enqueueTaskImpl(task);\n}\n\nvar actScopeDepth = 0;\nvar didWarnNoAwaitAct = false;\nfunction act(callback) {\n {\n // `act` calls can be nested, so we track the depth. This represents the\n // number of `act` scopes on the stack.\n var prevActScopeDepth = actScopeDepth;\n actScopeDepth++;\n\n if (ReactCurrentActQueue.current === null) {\n // This is the outermost `act` scope. Initialize the queue. The reconciler\n // will detect the queue and use it instead of Scheduler.\n ReactCurrentActQueue.current = [];\n }\n\n var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;\n var result;\n\n try {\n // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only\n // set to `true` while the given callback is executed, not for updates\n // triggered during an async event, because this is how the legacy\n // implementation of `act` behaved.\n ReactCurrentActQueue.isBatchingLegacy = true;\n result = callback(); // Replicate behavior of original `act` implementation in legacy mode,\n // which flushed updates immediately after the scope function exits, even\n // if it's an async function.\n\n if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {\n var queue = ReactCurrentActQueue.current;\n\n if (queue !== null) {\n ReactCurrentActQueue.didScheduleLegacyUpdate = false;\n flushActQueue(queue);\n }\n }\n } catch (error) {\n popActScope(prevActScopeDepth);\n throw error;\n } finally {\n ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;\n }\n\n if (result !== null && typeof result === 'object' && typeof result.then === 'function') {\n var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait\n // for it to resolve before exiting the current scope.\n\n var wasAwaited = false;\n var thenable = {\n then: function (resolve, reject) {\n wasAwaited = true;\n thenableResult.then(function (returnValue) {\n popActScope(prevActScopeDepth);\n\n if (actScopeDepth === 0) {\n // We've exited the outermost act scope. Recursively flush the\n // queue until there's no remaining work.\n recursivelyFlushAsyncActWork(returnValue, resolve, reject);\n } else {\n resolve(returnValue);\n }\n }, function (error) {\n // The callback threw an error.\n popActScope(prevActScopeDepth);\n reject(error);\n });\n }\n };\n\n {\n if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') {\n // eslint-disable-next-line no-undef\n Promise.resolve().then(function () {}).then(function () {\n if (!wasAwaited) {\n didWarnNoAwaitAct = true;\n\n error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);');\n }\n });\n }\n }\n\n return thenable;\n } else {\n var returnValue = result; // The callback is not an async function. Exit the current scope\n // immediately, without awaiting.\n\n popActScope(prevActScopeDepth);\n\n if (actScopeDepth === 0) {\n // Exiting the outermost act scope. Flush the queue.\n var _queue = ReactCurrentActQueue.current;\n\n if (_queue !== null) {\n flushActQueue(_queue);\n ReactCurrentActQueue.current = null;\n } // Return a thenable. If the user awaits it, we'll flush again in\n // case additional work was scheduled by a microtask.\n\n\n var _thenable = {\n then: function (resolve, reject) {\n // Confirm we haven't re-entered another `act` scope, in case\n // the user does something weird like await the thenable\n // multiple times.\n if (ReactCurrentActQueue.current === null) {\n // Recursively flush the queue until there's no remaining work.\n ReactCurrentActQueue.current = [];\n recursivelyFlushAsyncActWork(returnValue, resolve, reject);\n } else {\n resolve(returnValue);\n }\n }\n };\n return _thenable;\n } else {\n // Since we're inside a nested `act` scope, the returned thenable\n // immediately resolves. The outer scope will flush the queue.\n var _thenable2 = {\n then: function (resolve, reject) {\n resolve(returnValue);\n }\n };\n return _thenable2;\n }\n }\n }\n}\n\nfunction popActScope(prevActScopeDepth) {\n {\n if (prevActScopeDepth !== actScopeDepth - 1) {\n error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');\n }\n\n actScopeDepth = prevActScopeDepth;\n }\n}\n\nfunction recursivelyFlushAsyncActWork(returnValue, resolve, reject) {\n {\n var queue = ReactCurrentActQueue.current;\n\n if (queue !== null) {\n try {\n flushActQueue(queue);\n enqueueTask(function () {\n if (queue.length === 0) {\n // No additional work was scheduled. Finish.\n ReactCurrentActQueue.current = null;\n resolve(returnValue);\n } else {\n // Keep flushing work until there's none left.\n recursivelyFlushAsyncActWork(returnValue, resolve, reject);\n }\n });\n } catch (error) {\n reject(error);\n }\n } else {\n resolve(returnValue);\n }\n }\n}\n\nvar isFlushing = false;\n\nfunction flushActQueue(queue) {\n {\n if (!isFlushing) {\n // Prevent re-entrance.\n isFlushing = true;\n var i = 0;\n\n try {\n for (; i < queue.length; i++) {\n var callback = queue[i];\n\n do {\n callback = callback(true);\n } while (callback !== null);\n }\n\n queue.length = 0;\n } catch (error) {\n // If something throws, leave the remaining callbacks on the queue.\n queue = queue.slice(i + 1);\n throw error;\n } finally {\n isFlushing = false;\n }\n }\n }\n}\n\nvar createElement$1 = createElementWithValidation ;\nvar cloneElement$1 = cloneElementWithValidation ;\nvar createFactory = createFactoryWithValidation ;\nvar Children = {\n map: mapChildren,\n forEach: forEachChildren,\n count: countChildren,\n toArray: toArray,\n only: onlyChild\n};\n\nexports.Children = Children;\nexports.Component = Component;\nexports.Fragment = REACT_FRAGMENT_TYPE;\nexports.Profiler = REACT_PROFILER_TYPE;\nexports.PureComponent = PureComponent;\nexports.StrictMode = REACT_STRICT_MODE_TYPE;\nexports.Suspense = REACT_SUSPENSE_TYPE;\nexports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;\nexports.act = act;\nexports.cloneElement = cloneElement$1;\nexports.createContext = createContext;\nexports.createElement = createElement$1;\nexports.createFactory = createFactory;\nexports.createRef = createRef;\nexports.forwardRef = forwardRef;\nexports.isValidElement = isValidElement;\nexports.lazy = lazy;\nexports.memo = memo;\nexports.startTransition = startTransition;\nexports.unstable_act = act;\nexports.useCallback = useCallback;\nexports.useContext = useContext;\nexports.useDebugValue = useDebugValue;\nexports.useDeferredValue = useDeferredValue;\nexports.useEffect = useEffect;\nexports.useId = useId;\nexports.useImperativeHandle = useImperativeHandle;\nexports.useInsertionEffect = useInsertionEffect;\nexports.useLayoutEffect = useLayoutEffect;\nexports.useMemo = useMemo;\nexports.useReducer = useReducer;\nexports.useRef = useRef;\nexports.useState = useState;\nexports.useSyncExternalStore = useSyncExternalStore;\nexports.useTransition = useTransition;\nexports.version = ReactVersion;\n /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===\n 'function'\n) {\n __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());\n}\n \n })();\n}\n", "'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./cjs/react.production.min.js');\n} else {\n module.exports = require('./cjs/react.development.js');\n}\n"], - "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAYA,QAAI,MAAuC;AACzC,OAAC,WAAW;AAEJ;AAGV,YACE,OAAO,mCAAmC,eAC1C,OAAO,+BAA+B,gCACpC,YACF;AACA,yCAA+B,4BAA4B,IAAI,MAAM,CAAC;AAAA,QACxE;AACU,YAAI,eAAe;AAM7B,YAAI,qBAAqB,OAAO,IAAI,eAAe;AACnD,YAAI,oBAAoB,OAAO,IAAI,cAAc;AACjD,YAAI,sBAAsB,OAAO,IAAI,gBAAgB;AACrD,YAAI,yBAAyB,OAAO,IAAI,mBAAmB;AAC3D,YAAI,sBAAsB,OAAO,IAAI,gBAAgB;AACrD,YAAI,sBAAsB,OAAO,IAAI,gBAAgB;AACrD,YAAI,qBAAqB,OAAO,IAAI,eAAe;AACnD,YAAI,yBAAyB,OAAO,IAAI,mBAAmB;AAC3D,YAAI,sBAAsB,OAAO,IAAI,gBAAgB;AACrD,YAAI,2BAA2B,OAAO,IAAI,qBAAqB;AAC/D,YAAI,kBAAkB,OAAO,IAAI,YAAY;AAC7C,YAAI,kBAAkB,OAAO,IAAI,YAAY;AAC7C,YAAI,uBAAuB,OAAO,IAAI,iBAAiB;AACvD,YAAI,wBAAwB,OAAO;AACnC,YAAI,uBAAuB;AAC3B,iBAAS,cAAc,eAAe;AACpC,cAAI,kBAAkB,QAAQ,OAAO,kBAAkB,UAAU;AAC/D,mBAAO;AAAA,UACT;AAEA,cAAI,gBAAgB,yBAAyB,cAAc,qBAAqB,KAAK,cAAc,oBAAoB;AAEvH,cAAI,OAAO,kBAAkB,YAAY;AACvC,mBAAO;AAAA,UACT;AAEA,iBAAO;AAAA,QACT;AAKA,YAAI,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA,UAK3B,SAAS;AAAA,QACX;AAMA,YAAI,0BAA0B;AAAA,UAC5B,YAAY;AAAA,QACd;AAEA,YAAI,uBAAuB;AAAA,UACzB,SAAS;AAAA;AAAA,UAET,kBAAkB;AAAA,UAClB,yBAAyB;AAAA,QAC3B;AAQA,YAAI,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA,UAKtB,SAAS;AAAA,QACX;AAEA,YAAI,yBAAyB,CAAC;AAC9B,YAAI,yBAAyB;AAC7B,iBAAS,mBAAmB,OAAO;AACjC;AACE,qCAAyB;AAAA,UAC3B;AAAA,QACF;AAEA;AACE,iCAAuB,qBAAqB,SAAU,OAAO;AAC3D;AACE,uCAAyB;AAAA,YAC3B;AAAA,UACF;AAGA,iCAAuB,kBAAkB;AAEzC,iCAAuB,mBAAmB,WAAY;AACpD,gBAAI,QAAQ;AAEZ,gBAAI,wBAAwB;AAC1B,uBAAS;AAAA,YACX;AAGA,gBAAI,OAAO,uBAAuB;AAElC,gBAAI,MAAM;AACR,uBAAS,KAAK,KAAK;AAAA,YACrB;AAEA,mBAAO;AAAA,UACT;AAAA,QACF;AAIA,YAAI,iBAAiB;AACrB,YAAI,qBAAqB;AACzB,YAAI,0BAA0B;AAE9B,YAAI,qBAAqB;AAIzB,YAAI,qBAAqB;AAEzB,YAAI,uBAAuB;AAAA,UACzB;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAEA;AACE,+BAAqB,yBAAyB;AAC9C,+BAAqB,uBAAuB;AAAA,QAC9C;AAOA,iBAAS,KAAK,QAAQ;AACpB;AACE;AACE,uBAAS,OAAO,UAAU,QAAQ,OAAO,IAAI,MAAM,OAAO,IAAI,OAAO,IAAI,CAAC,GAAG,OAAO,GAAG,OAAO,MAAM,QAAQ;AAC1G,qBAAK,OAAO,CAAC,IAAI,UAAU,IAAI;AAAA,cACjC;AAEA,2BAAa,QAAQ,QAAQ,IAAI;AAAA,YACnC;AAAA,UACF;AAAA,QACF;AACA,iBAAS,MAAM,QAAQ;AACrB;AACE;AACE,uBAAS,QAAQ,UAAU,QAAQ,OAAO,IAAI,MAAM,QAAQ,IAAI,QAAQ,IAAI,CAAC,GAAG,QAAQ,GAAG,QAAQ,OAAO,SAAS;AACjH,qBAAK,QAAQ,CAAC,IAAI,UAAU,KAAK;AAAA,cACnC;AAEA,2BAAa,SAAS,QAAQ,IAAI;AAAA,YACpC;AAAA,UACF;AAAA,QACF;AAEA,iBAAS,aAAa,OAAO,QAAQ,MAAM;AAGzC;AACE,gBAAIA,0BAAyB,qBAAqB;AAClD,gBAAI,QAAQA,wBAAuB,iBAAiB;AAEpD,gBAAI,UAAU,IAAI;AAChB,wBAAU;AACV,qBAAO,KAAK,OAAO,CAAC,KAAK,CAAC;AAAA,YAC5B;AAGA,gBAAI,iBAAiB,KAAK,IAAI,SAAU,MAAM;AAC5C,qBAAO,OAAO,IAAI;AAAA,YACpB,CAAC;AAED,2BAAe,QAAQ,cAAc,MAAM;AAI3C,qBAAS,UAAU,MAAM,KAAK,QAAQ,KAAK,GAAG,SAAS,cAAc;AAAA,UACvE;AAAA,QACF;AAEA,YAAI,0CAA0C,CAAC;AAE/C,iBAAS,SAAS,gBAAgB,YAAY;AAC5C;AACE,gBAAI,eAAe,eAAe;AAClC,gBAAI,gBAAgB,iBAAiB,aAAa,eAAe,aAAa,SAAS;AACvF,gBAAI,aAAa,gBAAgB,MAAM;AAEvC,gBAAI,wCAAwC,UAAU,GAAG;AACvD;AAAA,YACF;AAEA,kBAAM,yPAAwQ,YAAY,aAAa;AAEvS,oDAAwC,UAAU,IAAI;AAAA,UACxD;AAAA,QACF;AAMA,YAAI,uBAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAQzB,WAAW,SAAU,gBAAgB;AACnC,mBAAO;AAAA,UACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAiBA,oBAAoB,SAAU,gBAAgB,UAAU,YAAY;AAClE,qBAAS,gBAAgB,aAAa;AAAA,UACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAeA,qBAAqB,SAAU,gBAAgB,eAAe,UAAU,YAAY;AAClF,qBAAS,gBAAgB,cAAc;AAAA,UACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAcA,iBAAiB,SAAU,gBAAgB,cAAc,UAAU,YAAY;AAC7E,qBAAS,gBAAgB,UAAU;AAAA,UACrC;AAAA,QACF;AAEA,YAAI,SAAS,OAAO;AAEpB,YAAI,cAAc,CAAC;AAEnB;AACE,iBAAO,OAAO,WAAW;AAAA,QAC3B;AAMA,iBAAS,UAAU,OAAO,SAAS,SAAS;AAC1C,eAAK,QAAQ;AACb,eAAK,UAAU;AAEf,eAAK,OAAO;AAGZ,eAAK,UAAU,WAAW;AAAA,QAC5B;AAEA,kBAAU,UAAU,mBAAmB,CAAC;AA2BxC,kBAAU,UAAU,WAAW,SAAU,cAAc,UAAU;AAC/D,cAAI,OAAO,iBAAiB,YAAY,OAAO,iBAAiB,cAAc,gBAAgB,MAAM;AAClG,kBAAM,IAAI,MAAM,uHAA4H;AAAA,UAC9I;AAEA,eAAK,QAAQ,gBAAgB,MAAM,cAAc,UAAU,UAAU;AAAA,QACvE;AAiBA,kBAAU,UAAU,cAAc,SAAU,UAAU;AACpD,eAAK,QAAQ,mBAAmB,MAAM,UAAU,aAAa;AAAA,QAC/D;AAQA;AACE,cAAI,iBAAiB;AAAA,YACnB,WAAW,CAAC,aAAa,oHAAyH;AAAA,YAClJ,cAAc,CAAC,gBAAgB,iGAAsG;AAAA,UACvI;AAEA,cAAI,2BAA2B,SAAU,YAAY,MAAM;AACzD,mBAAO,eAAe,UAAU,WAAW,YAAY;AAAA,cACrD,KAAK,WAAY;AACf,qBAAK,+DAA+D,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC;AAEpF,uBAAO;AAAA,cACT;AAAA,YACF,CAAC;AAAA,UACH;AAEA,mBAAS,UAAU,gBAAgB;AACjC,gBAAI,eAAe,eAAe,MAAM,GAAG;AACzC,uCAAyB,QAAQ,eAAe,MAAM,CAAC;AAAA,YACzD;AAAA,UACF;AAAA,QACF;AAEA,iBAAS,iBAAiB;AAAA,QAAC;AAE3B,uBAAe,YAAY,UAAU;AAKrC,iBAAS,cAAc,OAAO,SAAS,SAAS;AAC9C,eAAK,QAAQ;AACb,eAAK,UAAU;AAEf,eAAK,OAAO;AACZ,eAAK,UAAU,WAAW;AAAA,QAC5B;AAEA,YAAI,yBAAyB,cAAc,YAAY,IAAI,eAAe;AAC1E,+BAAuB,cAAc;AAErC,eAAO,wBAAwB,UAAU,SAAS;AAClD,+BAAuB,uBAAuB;AAG9C,iBAAS,YAAY;AACnB,cAAI,YAAY;AAAA,YACd,SAAS;AAAA,UACX;AAEA;AACE,mBAAO,KAAK,SAAS;AAAA,UACvB;AAEA,iBAAO;AAAA,QACT;AAEA,YAAI,cAAc,MAAM;AAExB,iBAAS,QAAQ,GAAG;AAClB,iBAAO,YAAY,CAAC;AAAA,QACtB;AAYA,iBAAS,SAAS,OAAO;AACvB;AAEE,gBAAI,iBAAiB,OAAO,WAAW,cAAc,OAAO;AAC5D,gBAAI,OAAO,kBAAkB,MAAM,OAAO,WAAW,KAAK,MAAM,YAAY,QAAQ;AACpF,mBAAO;AAAA,UACT;AAAA,QACF;AAGA,iBAAS,kBAAkB,OAAO;AAChC;AACE,gBAAI;AACF,iCAAmB,KAAK;AACxB,qBAAO;AAAA,YACT,SAAS,GAAG;AACV,qBAAO;AAAA,YACT;AAAA,UACF;AAAA,QACF;AAEA,iBAAS,mBAAmB,OAAO;AAwBjC,iBAAO,KAAK;AAAA,QACd;AACA,iBAAS,uBAAuB,OAAO;AACrC;AACE,gBAAI,kBAAkB,KAAK,GAAG;AAC5B,oBAAM,mHAAwH,SAAS,KAAK,CAAC;AAE7I,qBAAO,mBAAmB,KAAK;AAAA,YACjC;AAAA,UACF;AAAA,QACF;AAEA,iBAAS,eAAe,WAAW,WAAW,aAAa;AACzD,cAAI,cAAc,UAAU;AAE5B,cAAI,aAAa;AACf,mBAAO;AAAA,UACT;AAEA,cAAI,eAAe,UAAU,eAAe,UAAU,QAAQ;AAC9D,iBAAO,iBAAiB,KAAK,cAAc,MAAM,eAAe,MAAM;AAAA,QACxE;AAGA,iBAAS,eAAe,MAAM;AAC5B,iBAAO,KAAK,eAAe;AAAA,QAC7B;AAGA,iBAAS,yBAAyB,MAAM;AACtC,cAAI,QAAQ,MAAM;AAEhB,mBAAO;AAAA,UACT;AAEA;AACE,gBAAI,OAAO,KAAK,QAAQ,UAAU;AAChC,oBAAM,mHAAwH;AAAA,YAChI;AAAA,UACF;AAEA,cAAI,OAAO,SAAS,YAAY;AAC9B,mBAAO,KAAK,eAAe,KAAK,QAAQ;AAAA,UAC1C;AAEA,cAAI,OAAO,SAAS,UAAU;AAC5B,mBAAO;AAAA,UACT;AAEA,kBAAQ,MAAM;AAAA,YACZ,KAAK;AACH,qBAAO;AAAA,YAET,KAAK;AACH,qBAAO;AAAA,YAET,KAAK;AACH,qBAAO;AAAA,YAET,KAAK;AACH,qBAAO;AAAA,YAET,KAAK;AACH,qBAAO;AAAA,YAET,KAAK;AACH,qBAAO;AAAA,UAEX;AAEA,cAAI,OAAO,SAAS,UAAU;AAC5B,oBAAQ,KAAK,UAAU;AAAA,cACrB,KAAK;AACH,oBAAI,UAAU;AACd,uBAAO,eAAe,OAAO,IAAI;AAAA,cAEnC,KAAK;AACH,oBAAI,WAAW;AACf,uBAAO,eAAe,SAAS,QAAQ,IAAI;AAAA,cAE7C,KAAK;AACH,uBAAO,eAAe,MAAM,KAAK,QAAQ,YAAY;AAAA,cAEvD,KAAK;AACH,oBAAI,YAAY,KAAK,eAAe;AAEpC,oBAAI,cAAc,MAAM;AACtB,yBAAO;AAAA,gBACT;AAEA,uBAAO,yBAAyB,KAAK,IAAI,KAAK;AAAA,cAEhD,KAAK,iBACH;AACE,oBAAI,gBAAgB;AACpB,oBAAI,UAAU,cAAc;AAC5B,oBAAI,OAAO,cAAc;AAEzB,oBAAI;AACF,yBAAO,yBAAyB,KAAK,OAAO,CAAC;AAAA,gBAC/C,SAAS,GAAG;AACV,yBAAO;AAAA,gBACT;AAAA,cACF;AAAA,YAGJ;AAAA,UACF;AAEA,iBAAO;AAAA,QACT;AAEA,YAAI,iBAAiB,OAAO,UAAU;AAEtC,YAAI,iBAAiB;AAAA,UACnB,KAAK;AAAA,UACL,KAAK;AAAA,UACL,QAAQ;AAAA,UACR,UAAU;AAAA,QACZ;AACA,YAAI,4BAA4B,4BAA4B;AAE5D;AACE,mCAAyB,CAAC;AAAA,QAC5B;AAEA,iBAAS,YAAY,QAAQ;AAC3B;AACE,gBAAI,eAAe,KAAK,QAAQ,KAAK,GAAG;AACtC,kBAAI,SAAS,OAAO,yBAAyB,QAAQ,KAAK,EAAE;AAE5D,kBAAI,UAAU,OAAO,gBAAgB;AACnC,uBAAO;AAAA,cACT;AAAA,YACF;AAAA,UACF;AAEA,iBAAO,OAAO,QAAQ;AAAA,QACxB;AAEA,iBAAS,YAAY,QAAQ;AAC3B;AACE,gBAAI,eAAe,KAAK,QAAQ,KAAK,GAAG;AACtC,kBAAI,SAAS,OAAO,yBAAyB,QAAQ,KAAK,EAAE;AAE5D,kBAAI,UAAU,OAAO,gBAAgB;AACnC,uBAAO;AAAA,cACT;AAAA,YACF;AAAA,UACF;AAEA,iBAAO,OAAO,QAAQ;AAAA,QACxB;AAEA,iBAAS,2BAA2B,OAAO,aAAa;AACtD,cAAI,wBAAwB,WAAY;AACtC;AACE,kBAAI,CAAC,4BAA4B;AAC/B,6CAA6B;AAE7B,sBAAM,6OAA4P,WAAW;AAAA,cAC/Q;AAAA,YACF;AAAA,UACF;AAEA,gCAAsB,iBAAiB;AACvC,iBAAO,eAAe,OAAO,OAAO;AAAA,YAClC,KAAK;AAAA,YACL,cAAc;AAAA,UAChB,CAAC;AAAA,QACH;AAEA,iBAAS,2BAA2B,OAAO,aAAa;AACtD,cAAI,wBAAwB,WAAY;AACtC;AACE,kBAAI,CAAC,4BAA4B;AAC/B,6CAA6B;AAE7B,sBAAM,6OAA4P,WAAW;AAAA,cAC/Q;AAAA,YACF;AAAA,UACF;AAEA,gCAAsB,iBAAiB;AACvC,iBAAO,eAAe,OAAO,OAAO;AAAA,YAClC,KAAK;AAAA,YACL,cAAc;AAAA,UAChB,CAAC;AAAA,QACH;AAEA,iBAAS,qCAAqC,QAAQ;AACpD;AACE,gBAAI,OAAO,OAAO,QAAQ,YAAY,kBAAkB,WAAW,OAAO,UAAU,kBAAkB,QAAQ,cAAc,OAAO,QAAQ;AACzI,kBAAI,gBAAgB,yBAAyB,kBAAkB,QAAQ,IAAI;AAE3E,kBAAI,CAAC,uBAAuB,aAAa,GAAG;AAC1C,sBAAM,6VAAsX,eAAe,OAAO,GAAG;AAErZ,uCAAuB,aAAa,IAAI;AAAA,cAC1C;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAuBA,YAAI,eAAe,SAAU,MAAM,KAAK,KAAK,MAAM,QAAQ,OAAO,OAAO;AACvE,cAAI,UAAU;AAAA;AAAA,YAEZ,UAAU;AAAA;AAAA,YAEV;AAAA,YACA;AAAA,YACA;AAAA,YACA;AAAA;AAAA,YAEA,QAAQ;AAAA,UACV;AAEA;AAKE,oBAAQ,SAAS,CAAC;AAKlB,mBAAO,eAAe,QAAQ,QAAQ,aAAa;AAAA,cACjD,cAAc;AAAA,cACd,YAAY;AAAA,cACZ,UAAU;AAAA,cACV,OAAO;AAAA,YACT,CAAC;AAED,mBAAO,eAAe,SAAS,SAAS;AAAA,cACtC,cAAc;AAAA,cACd,YAAY;AAAA,cACZ,UAAU;AAAA,cACV,OAAO;AAAA,YACT,CAAC;AAGD,mBAAO,eAAe,SAAS,WAAW;AAAA,cACxC,cAAc;AAAA,cACd,YAAY;AAAA,cACZ,UAAU;AAAA,cACV,OAAO;AAAA,YACT,CAAC;AAED,gBAAI,OAAO,QAAQ;AACjB,qBAAO,OAAO,QAAQ,KAAK;AAC3B,qBAAO,OAAO,OAAO;AAAA,YACvB;AAAA,UACF;AAEA,iBAAO;AAAA,QACT;AAMA,iBAAS,cAAc,MAAM,QAAQ,UAAU;AAC7C,cAAI;AAEJ,cAAI,QAAQ,CAAC;AACb,cAAI,MAAM;AACV,cAAI,MAAM;AACV,cAAI,OAAO;AACX,cAAI,SAAS;AAEb,cAAI,UAAU,MAAM;AAClB,gBAAI,YAAY,MAAM,GAAG;AACvB,oBAAM,OAAO;AAEb;AACE,qDAAqC,MAAM;AAAA,cAC7C;AAAA,YACF;AAEA,gBAAI,YAAY,MAAM,GAAG;AACvB;AACE,uCAAuB,OAAO,GAAG;AAAA,cACnC;AAEA,oBAAM,KAAK,OAAO;AAAA,YACpB;AAEA,mBAAO,OAAO,WAAW,SAAY,OAAO,OAAO;AACnD,qBAAS,OAAO,aAAa,SAAY,OAAO,OAAO;AAEvD,iBAAK,YAAY,QAAQ;AACvB,kBAAI,eAAe,KAAK,QAAQ,QAAQ,KAAK,CAAC,eAAe,eAAe,QAAQ,GAAG;AACrF,sBAAM,QAAQ,IAAI,OAAO,QAAQ;AAAA,cACnC;AAAA,YACF;AAAA,UACF;AAIA,cAAI,iBAAiB,UAAU,SAAS;AAExC,cAAI,mBAAmB,GAAG;AACxB,kBAAM,WAAW;AAAA,UACnB,WAAW,iBAAiB,GAAG;AAC7B,gBAAI,aAAa,MAAM,cAAc;AAErC,qBAAS,IAAI,GAAG,IAAI,gBAAgB,KAAK;AACvC,yBAAW,CAAC,IAAI,UAAU,IAAI,CAAC;AAAA,YACjC;AAEA;AACE,kBAAI,OAAO,QAAQ;AACjB,uBAAO,OAAO,UAAU;AAAA,cAC1B;AAAA,YACF;AAEA,kBAAM,WAAW;AAAA,UACnB;AAGA,cAAI,QAAQ,KAAK,cAAc;AAC7B,gBAAI,eAAe,KAAK;AAExB,iBAAK,YAAY,cAAc;AAC7B,kBAAI,MAAM,QAAQ,MAAM,QAAW;AACjC,sBAAM,QAAQ,IAAI,aAAa,QAAQ;AAAA,cACzC;AAAA,YACF;AAAA,UACF;AAEA;AACE,gBAAI,OAAO,KAAK;AACd,kBAAI,cAAc,OAAO,SAAS,aAAa,KAAK,eAAe,KAAK,QAAQ,YAAY;AAE5F,kBAAI,KAAK;AACP,2CAA2B,OAAO,WAAW;AAAA,cAC/C;AAEA,kBAAI,KAAK;AACP,2CAA2B,OAAO,WAAW;AAAA,cAC/C;AAAA,YACF;AAAA,UACF;AAEA,iBAAO,aAAa,MAAM,KAAK,KAAK,MAAM,QAAQ,kBAAkB,SAAS,KAAK;AAAA,QACpF;AACA,iBAAS,mBAAmB,YAAY,QAAQ;AAC9C,cAAI,aAAa,aAAa,WAAW,MAAM,QAAQ,WAAW,KAAK,WAAW,OAAO,WAAW,SAAS,WAAW,QAAQ,WAAW,KAAK;AAChJ,iBAAO;AAAA,QACT;AAMA,iBAAS,aAAa,SAAS,QAAQ,UAAU;AAC/C,cAAI,YAAY,QAAQ,YAAY,QAAW;AAC7C,kBAAM,IAAI,MAAM,mFAAmF,UAAU,GAAG;AAAA,UAClH;AAEA,cAAI;AAEJ,cAAI,QAAQ,OAAO,CAAC,GAAG,QAAQ,KAAK;AAEpC,cAAI,MAAM,QAAQ;AAClB,cAAI,MAAM,QAAQ;AAElB,cAAI,OAAO,QAAQ;AAInB,cAAI,SAAS,QAAQ;AAErB,cAAI,QAAQ,QAAQ;AAEpB,cAAI,UAAU,MAAM;AAClB,gBAAI,YAAY,MAAM,GAAG;AAEvB,oBAAM,OAAO;AACb,sBAAQ,kBAAkB;AAAA,YAC5B;AAEA,gBAAI,YAAY,MAAM,GAAG;AACvB;AACE,uCAAuB,OAAO,GAAG;AAAA,cACnC;AAEA,oBAAM,KAAK,OAAO;AAAA,YACpB;AAGA,gBAAI;AAEJ,gBAAI,QAAQ,QAAQ,QAAQ,KAAK,cAAc;AAC7C,6BAAe,QAAQ,KAAK;AAAA,YAC9B;AAEA,iBAAK,YAAY,QAAQ;AACvB,kBAAI,eAAe,KAAK,QAAQ,QAAQ,KAAK,CAAC,eAAe,eAAe,QAAQ,GAAG;AACrF,oBAAI,OAAO,QAAQ,MAAM,UAAa,iBAAiB,QAAW;AAEhE,wBAAM,QAAQ,IAAI,aAAa,QAAQ;AAAA,gBACzC,OAAO;AACL,wBAAM,QAAQ,IAAI,OAAO,QAAQ;AAAA,gBACnC;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAIA,cAAI,iBAAiB,UAAU,SAAS;AAExC,cAAI,mBAAmB,GAAG;AACxB,kBAAM,WAAW;AAAA,UACnB,WAAW,iBAAiB,GAAG;AAC7B,gBAAI,aAAa,MAAM,cAAc;AAErC,qBAAS,IAAI,GAAG,IAAI,gBAAgB,KAAK;AACvC,yBAAW,CAAC,IAAI,UAAU,IAAI,CAAC;AAAA,YACjC;AAEA,kBAAM,WAAW;AAAA,UACnB;AAEA,iBAAO,aAAa,QAAQ,MAAM,KAAK,KAAK,MAAM,QAAQ,OAAO,KAAK;AAAA,QACxE;AASA,iBAAS,eAAe,QAAQ;AAC9B,iBAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,OAAO,aAAa;AAAA,QAC9E;AAEA,YAAI,YAAY;AAChB,YAAI,eAAe;AAQnB,iBAAS,OAAO,KAAK;AACnB,cAAI,cAAc;AAClB,cAAI,gBAAgB;AAAA,YAClB,KAAK;AAAA,YACL,KAAK;AAAA,UACP;AACA,cAAI,gBAAgB,IAAI,QAAQ,aAAa,SAAU,OAAO;AAC5D,mBAAO,cAAc,KAAK;AAAA,UAC5B,CAAC;AACD,iBAAO,MAAM;AAAA,QACf;AAOA,YAAI,mBAAmB;AACvB,YAAI,6BAA6B;AAEjC,iBAAS,sBAAsB,MAAM;AACnC,iBAAO,KAAK,QAAQ,4BAA4B,KAAK;AAAA,QACvD;AAUA,iBAAS,cAAc,SAAS,OAAO;AAGrC,cAAI,OAAO,YAAY,YAAY,YAAY,QAAQ,QAAQ,OAAO,MAAM;AAE1E;AACE,qCAAuB,QAAQ,GAAG;AAAA,YACpC;AAEA,mBAAO,OAAO,KAAK,QAAQ,GAAG;AAAA,UAChC;AAGA,iBAAO,MAAM,SAAS,EAAE;AAAA,QAC1B;AAEA,iBAAS,aAAa,UAAU,OAAO,eAAe,WAAW,UAAU;AACzE,cAAI,OAAO,OAAO;AAElB,cAAI,SAAS,eAAe,SAAS,WAAW;AAE9C,uBAAW;AAAA,UACb;AAEA,cAAI,iBAAiB;AAErB,cAAI,aAAa,MAAM;AACrB,6BAAiB;AAAA,UACnB,OAAO;AACL,oBAAQ,MAAM;AAAA,cACZ,KAAK;AAAA,cACL,KAAK;AACH,iCAAiB;AACjB;AAAA,cAEF,KAAK;AACH,wBAAQ,SAAS,UAAU;AAAA,kBACzB,KAAK;AAAA,kBACL,KAAK;AACH,qCAAiB;AAAA,gBACrB;AAAA,YAEJ;AAAA,UACF;AAEA,cAAI,gBAAgB;AAClB,gBAAI,SAAS;AACb,gBAAI,cAAc,SAAS,MAAM;AAGjC,gBAAI,WAAW,cAAc,KAAK,YAAY,cAAc,QAAQ,CAAC,IAAI;AAEzE,gBAAI,QAAQ,WAAW,GAAG;AACxB,kBAAI,kBAAkB;AAEtB,kBAAI,YAAY,MAAM;AACpB,kCAAkB,sBAAsB,QAAQ,IAAI;AAAA,cACtD;AAEA,2BAAa,aAAa,OAAO,iBAAiB,IAAI,SAAU,GAAG;AACjE,uBAAO;AAAA,cACT,CAAC;AAAA,YACH,WAAW,eAAe,MAAM;AAC9B,kBAAI,eAAe,WAAW,GAAG;AAC/B;AAIE,sBAAI,YAAY,QAAQ,CAAC,UAAU,OAAO,QAAQ,YAAY,MAAM;AAClE,2CAAuB,YAAY,GAAG;AAAA,kBACxC;AAAA,gBACF;AAEA,8BAAc;AAAA,kBAAmB;AAAA;AAAA;AAAA,kBAEjC;AAAA,mBACA,YAAY,QAAQ,CAAC,UAAU,OAAO,QAAQ,YAAY;AAAA;AAAA;AAAA,oBAE1D,sBAAsB,KAAK,YAAY,GAAG,IAAI;AAAA,sBAAM,MAAM;AAAA,gBAAQ;AAAA,cACpE;AAEA,oBAAM,KAAK,WAAW;AAAA,YACxB;AAEA,mBAAO;AAAA,UACT;AAEA,cAAI;AACJ,cAAI;AACJ,cAAI,eAAe;AAEnB,cAAI,iBAAiB,cAAc,KAAK,YAAY,YAAY;AAEhE,cAAI,QAAQ,QAAQ,GAAG;AACrB,qBAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACxC,sBAAQ,SAAS,CAAC;AAClB,yBAAW,iBAAiB,cAAc,OAAO,CAAC;AAClD,8BAAgB,aAAa,OAAO,OAAO,eAAe,UAAU,QAAQ;AAAA,YAC9E;AAAA,UACF,OAAO;AACL,gBAAI,aAAa,cAAc,QAAQ;AAEvC,gBAAI,OAAO,eAAe,YAAY;AACpC,kBAAI,mBAAmB;AAEvB;AAEE,oBAAI,eAAe,iBAAiB,SAAS;AAC3C,sBAAI,CAAC,kBAAkB;AACrB,yBAAK,uFAA4F;AAAA,kBACnG;AAEA,qCAAmB;AAAA,gBACrB;AAAA,cACF;AAEA,kBAAI,WAAW,WAAW,KAAK,gBAAgB;AAC/C,kBAAI;AACJ,kBAAI,KAAK;AAET,qBAAO,EAAE,OAAO,SAAS,KAAK,GAAG,MAAM;AACrC,wBAAQ,KAAK;AACb,2BAAW,iBAAiB,cAAc,OAAO,IAAI;AACrD,gCAAgB,aAAa,OAAO,OAAO,eAAe,UAAU,QAAQ;AAAA,cAC9E;AAAA,YACF,WAAW,SAAS,UAAU;AAE5B,kBAAI,iBAAiB,OAAO,QAAQ;AACpC,oBAAM,IAAI,MAAM,qDAAqD,mBAAmB,oBAAoB,uBAAuB,OAAO,KAAK,QAAQ,EAAE,KAAK,IAAI,IAAI,MAAM,kBAAkB,2EAAqF;AAAA,YACrR;AAAA,UACF;AAEA,iBAAO;AAAA,QACT;AAeA,iBAAS,YAAY,UAAU,MAAM,SAAS;AAC5C,cAAI,YAAY,MAAM;AACpB,mBAAO;AAAA,UACT;AAEA,cAAI,SAAS,CAAC;AACd,cAAI,QAAQ;AACZ,uBAAa,UAAU,QAAQ,IAAI,IAAI,SAAU,OAAO;AACtD,mBAAO,KAAK,KAAK,SAAS,OAAO,OAAO;AAAA,UAC1C,CAAC;AACD,iBAAO;AAAA,QACT;AAYA,iBAAS,cAAc,UAAU;AAC/B,cAAI,IAAI;AACR,sBAAY,UAAU,WAAY;AAChC;AAAA,UACF,CAAC;AACD,iBAAO;AAAA,QACT;AAcA,iBAAS,gBAAgB,UAAU,aAAa,gBAAgB;AAC9D,sBAAY,UAAU,WAAY;AAChC,wBAAY,MAAM,MAAM,SAAS;AAAA,UACnC,GAAG,cAAc;AAAA,QACnB;AASA,iBAAS,QAAQ,UAAU;AACzB,iBAAO,YAAY,UAAU,SAAU,OAAO;AAC5C,mBAAO;AAAA,UACT,CAAC,KAAK,CAAC;AAAA,QACT;AAiBA,iBAAS,UAAU,UAAU;AAC3B,cAAI,CAAC,eAAe,QAAQ,GAAG;AAC7B,kBAAM,IAAI,MAAM,uEAAuE;AAAA,UACzF;AAEA,iBAAO;AAAA,QACT;AAEA,iBAAS,cAAc,cAAc;AAGnC,cAAI,UAAU;AAAA,YACZ,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAMV,eAAe;AAAA,YACf,gBAAgB;AAAA;AAAA;AAAA,YAGhB,cAAc;AAAA;AAAA,YAEd,UAAU;AAAA,YACV,UAAU;AAAA;AAAA,YAEV,eAAe;AAAA,YACf,aAAa;AAAA,UACf;AACA,kBAAQ,WAAW;AAAA,YACjB,UAAU;AAAA,YACV,UAAU;AAAA,UACZ;AACA,cAAI,4CAA4C;AAChD,cAAI,sCAAsC;AAC1C,cAAI,sCAAsC;AAE1C;AAIE,gBAAI,WAAW;AAAA,cACb,UAAU;AAAA,cACV,UAAU;AAAA,YACZ;AAEA,mBAAO,iBAAiB,UAAU;AAAA,cAChC,UAAU;AAAA,gBACR,KAAK,WAAY;AACf,sBAAI,CAAC,qCAAqC;AACxC,0DAAsC;AAEtC,0BAAM,0JAA+J;AAAA,kBACvK;AAEA,yBAAO,QAAQ;AAAA,gBACjB;AAAA,gBACA,KAAK,SAAU,WAAW;AACxB,0BAAQ,WAAW;AAAA,gBACrB;AAAA,cACF;AAAA,cACA,eAAe;AAAA,gBACb,KAAK,WAAY;AACf,yBAAO,QAAQ;AAAA,gBACjB;AAAA,gBACA,KAAK,SAAU,eAAe;AAC5B,0BAAQ,gBAAgB;AAAA,gBAC1B;AAAA,cACF;AAAA,cACA,gBAAgB;AAAA,gBACd,KAAK,WAAY;AACf,yBAAO,QAAQ;AAAA,gBACjB;AAAA,gBACA,KAAK,SAAU,gBAAgB;AAC7B,0BAAQ,iBAAiB;AAAA,gBAC3B;AAAA,cACF;AAAA,cACA,cAAc;AAAA,gBACZ,KAAK,WAAY;AACf,yBAAO,QAAQ;AAAA,gBACjB;AAAA,gBACA,KAAK,SAAU,cAAc;AAC3B,0BAAQ,eAAe;AAAA,gBACzB;AAAA,cACF;AAAA,cACA,UAAU;AAAA,gBACR,KAAK,WAAY;AACf,sBAAI,CAAC,2CAA2C;AAC9C,gEAA4C;AAE5C,0BAAM,0JAA+J;AAAA,kBACvK;AAEA,yBAAO,QAAQ;AAAA,gBACjB;AAAA,cACF;AAAA,cACA,aAAa;AAAA,gBACX,KAAK,WAAY;AACf,yBAAO,QAAQ;AAAA,gBACjB;AAAA,gBACA,KAAK,SAAU,aAAa;AAC1B,sBAAI,CAAC,qCAAqC;AACxC,yBAAK,uIAA4I,WAAW;AAE5J,0DAAsC;AAAA,kBACxC;AAAA,gBACF;AAAA,cACF;AAAA,YACF,CAAC;AAED,oBAAQ,WAAW;AAAA,UACrB;AAEA;AACE,oBAAQ,mBAAmB;AAC3B,oBAAQ,oBAAoB;AAAA,UAC9B;AAEA,iBAAO;AAAA,QACT;AAEA,YAAI,gBAAgB;AACpB,YAAI,UAAU;AACd,YAAI,WAAW;AACf,YAAI,WAAW;AAEf,iBAAS,gBAAgB,SAAS;AAChC,cAAI,QAAQ,YAAY,eAAe;AACrC,gBAAI,OAAO,QAAQ;AACnB,gBAAI,WAAW,KAAK;AAMpB,qBAAS,KAAK,SAAUC,eAAc;AACpC,kBAAI,QAAQ,YAAY,WAAW,QAAQ,YAAY,eAAe;AAEpE,oBAAI,WAAW;AACf,yBAAS,UAAU;AACnB,yBAAS,UAAUA;AAAA,cACrB;AAAA,YACF,GAAG,SAAUC,QAAO;AAClB,kBAAI,QAAQ,YAAY,WAAW,QAAQ,YAAY,eAAe;AAEpE,oBAAI,WAAW;AACf,yBAAS,UAAU;AACnB,yBAAS,UAAUA;AAAA,cACrB;AAAA,YACF,CAAC;AAED,gBAAI,QAAQ,YAAY,eAAe;AAGrC,kBAAI,UAAU;AACd,sBAAQ,UAAU;AAClB,sBAAQ,UAAU;AAAA,YACpB;AAAA,UACF;AAEA,cAAI,QAAQ,YAAY,UAAU;AAChC,gBAAI,eAAe,QAAQ;AAE3B;AACE,kBAAI,iBAAiB,QAAW;AAC9B,sBAAM,qOAC2H,YAAY;AAAA,cAC/I;AAAA,YACF;AAEA;AACE,kBAAI,EAAE,aAAa,eAAe;AAChC,sBAAM,yKAC0D,YAAY;AAAA,cAC9E;AAAA,YACF;AAEA,mBAAO,aAAa;AAAA,UACtB,OAAO;AACL,kBAAM,QAAQ;AAAA,UAChB;AAAA,QACF;AAEA,iBAAS,KAAK,MAAM;AAClB,cAAI,UAAU;AAAA;AAAA,YAEZ,SAAS;AAAA,YACT,SAAS;AAAA,UACX;AACA,cAAI,WAAW;AAAA,YACb,UAAU;AAAA,YACV,UAAU;AAAA,YACV,OAAO;AAAA,UACT;AAEA;AAEE,gBAAI;AACJ,gBAAI;AAEJ,mBAAO,iBAAiB,UAAU;AAAA,cAChC,cAAc;AAAA,gBACZ,cAAc;AAAA,gBACd,KAAK,WAAY;AACf,yBAAO;AAAA,gBACT;AAAA,gBACA,KAAK,SAAU,iBAAiB;AAC9B,wBAAM,yLAAmM;AAEzM,iCAAe;AAGf,yBAAO,eAAe,UAAU,gBAAgB;AAAA,oBAC9C,YAAY;AAAA,kBACd,CAAC;AAAA,gBACH;AAAA,cACF;AAAA,cACA,WAAW;AAAA,gBACT,cAAc;AAAA,gBACd,KAAK,WAAY;AACf,yBAAO;AAAA,gBACT;AAAA,gBACA,KAAK,SAAU,cAAc;AAC3B,wBAAM,sLAAgM;AAEtM,8BAAY;AAGZ,yBAAO,eAAe,UAAU,aAAa;AAAA,oBAC3C,YAAY;AAAA,kBACd,CAAC;AAAA,gBACH;AAAA,cACF;AAAA,YACF,CAAC;AAAA,UACH;AAEA,iBAAO;AAAA,QACT;AAEA,iBAAS,WAAW,QAAQ;AAC1B;AACE,gBAAI,UAAU,QAAQ,OAAO,aAAa,iBAAiB;AACzD,oBAAM,qIAA+I;AAAA,YACvJ,WAAW,OAAO,WAAW,YAAY;AACvC,oBAAM,2DAA2D,WAAW,OAAO,SAAS,OAAO,MAAM;AAAA,YAC3G,OAAO;AACL,kBAAI,OAAO,WAAW,KAAK,OAAO,WAAW,GAAG;AAC9C,sBAAM,gFAAgF,OAAO,WAAW,IAAI,6CAA6C,6CAA6C;AAAA,cACxM;AAAA,YACF;AAEA,gBAAI,UAAU,MAAM;AAClB,kBAAI,OAAO,gBAAgB,QAAQ,OAAO,aAAa,MAAM;AAC3D,sBAAM,oHAAyH;AAAA,cACjI;AAAA,YACF;AAAA,UACF;AAEA,cAAI,cAAc;AAAA,YAChB,UAAU;AAAA,YACV;AAAA,UACF;AAEA;AACE,gBAAI;AACJ,mBAAO,eAAe,aAAa,eAAe;AAAA,cAChD,YAAY;AAAA,cACZ,cAAc;AAAA,cACd,KAAK,WAAY;AACf,uBAAO;AAAA,cACT;AAAA,cACA,KAAK,SAAU,MAAM;AACnB,0BAAU;AAQV,oBAAI,CAAC,OAAO,QAAQ,CAAC,OAAO,aAAa;AACvC,yBAAO,cAAc;AAAA,gBACvB;AAAA,cACF;AAAA,YACF,CAAC;AAAA,UACH;AAEA,iBAAO;AAAA,QACT;AAEA,YAAI;AAEJ;AACE,mCAAyB,OAAO,IAAI,wBAAwB;AAAA,QAC9D;AAEA,iBAAS,mBAAmB,MAAM;AAChC,cAAI,OAAO,SAAS,YAAY,OAAO,SAAS,YAAY;AAC1D,mBAAO;AAAA,UACT;AAGA,cAAI,SAAS,uBAAuB,SAAS,uBAAuB,sBAAuB,SAAS,0BAA0B,SAAS,uBAAuB,SAAS,4BAA4B,sBAAuB,SAAS,wBAAwB,kBAAmB,sBAAuB,yBAA0B;AAC7T,mBAAO;AAAA,UACT;AAEA,cAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAC7C,gBAAI,KAAK,aAAa,mBAAmB,KAAK,aAAa,mBAAmB,KAAK,aAAa,uBAAuB,KAAK,aAAa,sBAAsB,KAAK,aAAa;AAAA;AAAA;AAAA;AAAA,YAIjL,KAAK,aAAa,0BAA0B,KAAK,gBAAgB,QAAW;AAC1E,qBAAO;AAAA,YACT;AAAA,UACF;AAEA,iBAAO;AAAA,QACT;AAEA,iBAAS,KAAK,MAAM,SAAS;AAC3B;AACE,gBAAI,CAAC,mBAAmB,IAAI,GAAG;AAC7B,oBAAM,sEAA2E,SAAS,OAAO,SAAS,OAAO,IAAI;AAAA,YACvH;AAAA,UACF;AAEA,cAAI,cAAc;AAAA,YAChB,UAAU;AAAA,YACV;AAAA,YACA,SAAS,YAAY,SAAY,OAAO;AAAA,UAC1C;AAEA;AACE,gBAAI;AACJ,mBAAO,eAAe,aAAa,eAAe;AAAA,cAChD,YAAY;AAAA,cACZ,cAAc;AAAA,cACd,KAAK,WAAY;AACf,uBAAO;AAAA,cACT;AAAA,cACA,KAAK,SAAU,MAAM;AACnB,0BAAU;AAQV,oBAAI,CAAC,KAAK,QAAQ,CAAC,KAAK,aAAa;AACnC,uBAAK,cAAc;AAAA,gBACrB;AAAA,cACF;AAAA,YACF,CAAC;AAAA,UACH;AAEA,iBAAO;AAAA,QACT;AAEA,iBAAS,oBAAoB;AAC3B,cAAI,aAAa,uBAAuB;AAExC;AACE,gBAAI,eAAe,MAAM;AACvB,oBAAM,ibAA0c;AAAA,YACld;AAAA,UACF;AAKA,iBAAO;AAAA,QACT;AACA,iBAAS,WAAW,SAAS;AAC3B,cAAI,aAAa,kBAAkB;AAEnC;AAEE,gBAAI,QAAQ,aAAa,QAAW;AAClC,kBAAI,cAAc,QAAQ;AAG1B,kBAAI,YAAY,aAAa,SAAS;AACpC,sBAAM,yKAA8K;AAAA,cACtL,WAAW,YAAY,aAAa,SAAS;AAC3C,sBAAM,0GAA+G;AAAA,cACvH;AAAA,YACF;AAAA,UACF;AAEA,iBAAO,WAAW,WAAW,OAAO;AAAA,QACtC;AACA,iBAAS,SAAS,cAAc;AAC9B,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,SAAS,YAAY;AAAA,QACzC;AACA,iBAAS,WAAW,SAAS,YAAY,MAAM;AAC7C,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,WAAW,SAAS,YAAY,IAAI;AAAA,QACxD;AACA,iBAAS,OAAO,cAAc;AAC5B,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,OAAO,YAAY;AAAA,QACvC;AACA,iBAAS,UAAU,QAAQ,MAAM;AAC/B,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,UAAU,QAAQ,IAAI;AAAA,QAC1C;AACA,iBAAS,mBAAmB,QAAQ,MAAM;AACxC,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,mBAAmB,QAAQ,IAAI;AAAA,QACnD;AACA,iBAAS,gBAAgB,QAAQ,MAAM;AACrC,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,gBAAgB,QAAQ,IAAI;AAAA,QAChD;AACA,iBAAS,YAAY,UAAU,MAAM;AACnC,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,YAAY,UAAU,IAAI;AAAA,QAC9C;AACA,iBAAS,QAAQ,QAAQ,MAAM;AAC7B,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,QAAQ,QAAQ,IAAI;AAAA,QACxC;AACA,iBAAS,oBAAoB,KAAK,QAAQ,MAAM;AAC9C,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,oBAAoB,KAAK,QAAQ,IAAI;AAAA,QACzD;AACA,iBAAS,cAAc,OAAO,aAAa;AACzC;AACE,gBAAI,aAAa,kBAAkB;AACnC,mBAAO,WAAW,cAAc,OAAO,WAAW;AAAA,UACpD;AAAA,QACF;AACA,iBAAS,gBAAgB;AACvB,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,cAAc;AAAA,QAClC;AACA,iBAAS,iBAAiB,OAAO;AAC/B,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,iBAAiB,KAAK;AAAA,QAC1C;AACA,iBAAS,QAAQ;AACf,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,MAAM;AAAA,QAC1B;AACA,iBAAS,qBAAqB,WAAW,aAAa,mBAAmB;AACvE,cAAI,aAAa,kBAAkB;AACnC,iBAAO,WAAW,qBAAqB,WAAW,aAAa,iBAAiB;AAAA,QAClF;AAMA,YAAI,gBAAgB;AACpB,YAAI;AACJ,YAAI;AACJ,YAAI;AACJ,YAAI;AACJ,YAAI;AACJ,YAAI;AACJ,YAAI;AAEJ,iBAAS,cAAc;AAAA,QAAC;AAExB,oBAAY,qBAAqB;AACjC,iBAAS,cAAc;AACrB;AACE,gBAAI,kBAAkB,GAAG;AAEvB,wBAAU,QAAQ;AAClB,yBAAW,QAAQ;AACnB,yBAAW,QAAQ;AACnB,0BAAY,QAAQ;AACpB,0BAAY,QAAQ;AACpB,mCAAqB,QAAQ;AAC7B,6BAAe,QAAQ;AAEvB,kBAAI,QAAQ;AAAA,gBACV,cAAc;AAAA,gBACd,YAAY;AAAA,gBACZ,OAAO;AAAA,gBACP,UAAU;AAAA,cACZ;AAEA,qBAAO,iBAAiB,SAAS;AAAA,gBAC/B,MAAM;AAAA,gBACN,KAAK;AAAA,gBACL,MAAM;AAAA,gBACN,OAAO;AAAA,gBACP,OAAO;AAAA,gBACP,gBAAgB;AAAA,gBAChB,UAAU;AAAA,cACZ,CAAC;AAAA,YAEH;AAEA;AAAA,UACF;AAAA,QACF;AACA,iBAAS,eAAe;AACtB;AACE;AAEA,gBAAI,kBAAkB,GAAG;AAEvB,kBAAI,QAAQ;AAAA,gBACV,cAAc;AAAA,gBACd,YAAY;AAAA,gBACZ,UAAU;AAAA,cACZ;AAEA,qBAAO,iBAAiB,SAAS;AAAA,gBAC/B,KAAK,OAAO,CAAC,GAAG,OAAO;AAAA,kBACrB,OAAO;AAAA,gBACT,CAAC;AAAA,gBACD,MAAM,OAAO,CAAC,GAAG,OAAO;AAAA,kBACtB,OAAO;AAAA,gBACT,CAAC;AAAA,gBACD,MAAM,OAAO,CAAC,GAAG,OAAO;AAAA,kBACtB,OAAO;AAAA,gBACT,CAAC;AAAA,gBACD,OAAO,OAAO,CAAC,GAAG,OAAO;AAAA,kBACvB,OAAO;AAAA,gBACT,CAAC;AAAA,gBACD,OAAO,OAAO,CAAC,GAAG,OAAO;AAAA,kBACvB,OAAO;AAAA,gBACT,CAAC;AAAA,gBACD,gBAAgB,OAAO,CAAC,GAAG,OAAO;AAAA,kBAChC,OAAO;AAAA,gBACT,CAAC;AAAA,gBACD,UAAU,OAAO,CAAC,GAAG,OAAO;AAAA,kBAC1B,OAAO;AAAA,gBACT,CAAC;AAAA,cACH,CAAC;AAAA,YAEH;AAEA,gBAAI,gBAAgB,GAAG;AACrB,oBAAM,8EAAmF;AAAA,YAC3F;AAAA,UACF;AAAA,QACF;AAEA,YAAI,2BAA2B,qBAAqB;AACpD,YAAI;AACJ,iBAAS,8BAA8B,MAAM,QAAQ,SAAS;AAC5D;AACE,gBAAI,WAAW,QAAW;AAExB,kBAAI;AACF,sBAAM,MAAM;AAAA,cACd,SAAS,GAAG;AACV,oBAAI,QAAQ,EAAE,MAAM,KAAK,EAAE,MAAM,cAAc;AAC/C,yBAAS,SAAS,MAAM,CAAC,KAAK;AAAA,cAChC;AAAA,YACF;AAGA,mBAAO,OAAO,SAAS;AAAA,UACzB;AAAA,QACF;AACA,YAAI,UAAU;AACd,YAAI;AAEJ;AACE,cAAI,kBAAkB,OAAO,YAAY,aAAa,UAAU;AAChE,gCAAsB,IAAI,gBAAgB;AAAA,QAC5C;AAEA,iBAAS,6BAA6B,IAAI,WAAW;AAEnD,cAAK,CAAC,MAAM,SAAS;AACnB,mBAAO;AAAA,UACT;AAEA;AACE,gBAAI,QAAQ,oBAAoB,IAAI,EAAE;AAEtC,gBAAI,UAAU,QAAW;AACvB,qBAAO;AAAA,YACT;AAAA,UACF;AAEA,cAAI;AACJ,oBAAU;AACV,cAAI,4BAA4B,MAAM;AAEtC,gBAAM,oBAAoB;AAC1B,cAAI;AAEJ;AACE,iCAAqB,yBAAyB;AAG9C,qCAAyB,UAAU;AACnC,wBAAY;AAAA,UACd;AAEA,cAAI;AAEF,gBAAI,WAAW;AAEb,kBAAI,OAAO,WAAY;AACrB,sBAAM,MAAM;AAAA,cACd;AAGA,qBAAO,eAAe,KAAK,WAAW,SAAS;AAAA,gBAC7C,KAAK,WAAY;AAGf,wBAAM,MAAM;AAAA,gBACd;AAAA,cACF,CAAC;AAED,kBAAI,OAAO,YAAY,YAAY,QAAQ,WAAW;AAGpD,oBAAI;AACF,0BAAQ,UAAU,MAAM,CAAC,CAAC;AAAA,gBAC5B,SAAS,GAAG;AACV,4BAAU;AAAA,gBACZ;AAEA,wBAAQ,UAAU,IAAI,CAAC,GAAG,IAAI;AAAA,cAChC,OAAO;AACL,oBAAI;AACF,uBAAK,KAAK;AAAA,gBACZ,SAAS,GAAG;AACV,4BAAU;AAAA,gBACZ;AAEA,mBAAG,KAAK,KAAK,SAAS;AAAA,cACxB;AAAA,YACF,OAAO;AACL,kBAAI;AACF,sBAAM,MAAM;AAAA,cACd,SAAS,GAAG;AACV,0BAAU;AAAA,cACZ;AAEA,iBAAG;AAAA,YACL;AAAA,UACF,SAAS,QAAQ;AAEf,gBAAI,UAAU,WAAW,OAAO,OAAO,UAAU,UAAU;AAGzD,kBAAI,cAAc,OAAO,MAAM,MAAM,IAAI;AACzC,kBAAI,eAAe,QAAQ,MAAM,MAAM,IAAI;AAC3C,kBAAI,IAAI,YAAY,SAAS;AAC7B,kBAAI,IAAI,aAAa,SAAS;AAE9B,qBAAO,KAAK,KAAK,KAAK,KAAK,YAAY,CAAC,MAAM,aAAa,CAAC,GAAG;AAO7D;AAAA,cACF;AAEA,qBAAO,KAAK,KAAK,KAAK,GAAG,KAAK,KAAK;AAGjC,oBAAI,YAAY,CAAC,MAAM,aAAa,CAAC,GAAG;AAMtC,sBAAI,MAAM,KAAK,MAAM,GAAG;AACtB,uBAAG;AACD;AACA;AAGA,0BAAI,IAAI,KAAK,YAAY,CAAC,MAAM,aAAa,CAAC,GAAG;AAE/C,4BAAI,SAAS,OAAO,YAAY,CAAC,EAAE,QAAQ,YAAY,MAAM;AAK7D,4BAAI,GAAG,eAAe,OAAO,SAAS,aAAa,GAAG;AACpD,mCAAS,OAAO,QAAQ,eAAe,GAAG,WAAW;AAAA,wBACvD;AAEA;AACE,8BAAI,OAAO,OAAO,YAAY;AAC5B,gDAAoB,IAAI,IAAI,MAAM;AAAA,0BACpC;AAAA,wBACF;AAGA,+BAAO;AAAA,sBACT;AAAA,oBACF,SAAS,KAAK,KAAK,KAAK;AAAA,kBAC1B;AAEA;AAAA,gBACF;AAAA,cACF;AAAA,YACF;AAAA,UACF,UAAE;AACA,sBAAU;AAEV;AACE,uCAAyB,UAAU;AACnC,2BAAa;AAAA,YACf;AAEA,kBAAM,oBAAoB;AAAA,UAC5B;AAGA,cAAI,OAAO,KAAK,GAAG,eAAe,GAAG,OAAO;AAC5C,cAAI,iBAAiB,OAAO,8BAA8B,IAAI,IAAI;AAElE;AACE,gBAAI,OAAO,OAAO,YAAY;AAC5B,kCAAoB,IAAI,IAAI,cAAc;AAAA,YAC5C;AAAA,UACF;AAEA,iBAAO;AAAA,QACT;AACA,iBAAS,+BAA+B,IAAI,QAAQ,SAAS;AAC3D;AACE,mBAAO,6BAA6B,IAAI,KAAK;AAAA,UAC/C;AAAA,QACF;AAEA,iBAAS,gBAAgBC,YAAW;AAClC,cAAI,YAAYA,WAAU;AAC1B,iBAAO,CAAC,EAAE,aAAa,UAAU;AAAA,QACnC;AAEA,iBAAS,qCAAqC,MAAM,QAAQ,SAAS;AAEnE,cAAI,QAAQ,MAAM;AAChB,mBAAO;AAAA,UACT;AAEA,cAAI,OAAO,SAAS,YAAY;AAC9B;AACE,qBAAO,6BAA6B,MAAM,gBAAgB,IAAI,CAAC;AAAA,YACjE;AAAA,UACF;AAEA,cAAI,OAAO,SAAS,UAAU;AAC5B,mBAAO,8BAA8B,IAAI;AAAA,UAC3C;AAEA,kBAAQ,MAAM;AAAA,YACZ,KAAK;AACH,qBAAO,8BAA8B,UAAU;AAAA,YAEjD,KAAK;AACH,qBAAO,8BAA8B,cAAc;AAAA,UACvD;AAEA,cAAI,OAAO,SAAS,UAAU;AAC5B,oBAAQ,KAAK,UAAU;AAAA,cACrB,KAAK;AACH,uBAAO,+BAA+B,KAAK,MAAM;AAAA,cAEnD,KAAK;AAEH,uBAAO,qCAAqC,KAAK,MAAM,QAAQ,OAAO;AAAA,cAExE,KAAK,iBACH;AACE,oBAAI,gBAAgB;AACpB,oBAAI,UAAU,cAAc;AAC5B,oBAAI,OAAO,cAAc;AAEzB,oBAAI;AAEF,yBAAO,qCAAqC,KAAK,OAAO,GAAG,QAAQ,OAAO;AAAA,gBAC5E,SAAS,GAAG;AAAA,gBAAC;AAAA,cACf;AAAA,YACJ;AAAA,UACF;AAEA,iBAAO;AAAA,QACT;AAEA,YAAI,qBAAqB,CAAC;AAC1B,YAAI,2BAA2B,qBAAqB;AAEpD,iBAAS,8BAA8B,SAAS;AAC9C;AACE,gBAAI,SAAS;AACX,kBAAI,QAAQ,QAAQ;AACpB,kBAAI,QAAQ,qCAAqC,QAAQ,MAAM,QAAQ,SAAS,QAAQ,MAAM,OAAO,IAAI;AACzG,uCAAyB,mBAAmB,KAAK;AAAA,YACnD,OAAO;AACL,uCAAyB,mBAAmB,IAAI;AAAA,YAClD;AAAA,UACF;AAAA,QACF;AAEA,iBAAS,eAAe,WAAW,QAAQ,UAAU,eAAe,SAAS;AAC3E;AAEE,gBAAI,MAAM,SAAS,KAAK,KAAK,cAAc;AAE3C,qBAAS,gBAAgB,WAAW;AAClC,kBAAI,IAAI,WAAW,YAAY,GAAG;AAChC,oBAAI,UAAU;AAId,oBAAI;AAGF,sBAAI,OAAO,UAAU,YAAY,MAAM,YAAY;AAEjD,wBAAI,MAAM,OAAO,iBAAiB,iBAAiB,OAAO,WAAW,YAAY,eAAe,+FAAoG,OAAO,UAAU,YAAY,IAAI,iGAAsG;AAC3U,wBAAI,OAAO;AACX,0BAAM;AAAA,kBACR;AAEA,4BAAU,UAAU,YAAY,EAAE,QAAQ,cAAc,eAAe,UAAU,MAAM,8CAA8C;AAAA,gBACvI,SAAS,IAAI;AACX,4BAAU;AAAA,gBACZ;AAEA,oBAAI,WAAW,EAAE,mBAAmB,QAAQ;AAC1C,gDAA8B,OAAO;AAErC,wBAAM,4RAAqT,iBAAiB,eAAe,UAAU,cAAc,OAAO,OAAO;AAEjY,gDAA8B,IAAI;AAAA,gBACpC;AAEA,oBAAI,mBAAmB,SAAS,EAAE,QAAQ,WAAW,qBAAqB;AAGxE,qCAAmB,QAAQ,OAAO,IAAI;AACtC,gDAA8B,OAAO;AAErC,wBAAM,sBAAsB,UAAU,QAAQ,OAAO;AAErD,gDAA8B,IAAI;AAAA,gBACpC;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAEA,iBAAS,gCAAgC,SAAS;AAChD;AACE,gBAAI,SAAS;AACX,kBAAI,QAAQ,QAAQ;AACpB,kBAAI,QAAQ,qCAAqC,QAAQ,MAAM,QAAQ,SAAS,QAAQ,MAAM,OAAO,IAAI;AACzG,iCAAmB,KAAK;AAAA,YAC1B,OAAO;AACL,iCAAmB,IAAI;AAAA,YACzB;AAAA,UACF;AAAA,QACF;AAEA,YAAI;AAEJ;AACE,0CAAgC;AAAA,QAClC;AAEA,iBAAS,8BAA8B;AACrC,cAAI,kBAAkB,SAAS;AAC7B,gBAAI,OAAO,yBAAyB,kBAAkB,QAAQ,IAAI;AAElE,gBAAI,MAAM;AACR,qBAAO,qCAAqC,OAAO;AAAA,YACrD;AAAA,UACF;AAEA,iBAAO;AAAA,QACT;AAEA,iBAAS,2BAA2B,QAAQ;AAC1C,cAAI,WAAW,QAAW;AACxB,gBAAI,WAAW,OAAO,SAAS,QAAQ,aAAa,EAAE;AACtD,gBAAI,aAAa,OAAO;AACxB,mBAAO,4BAA4B,WAAW,MAAM,aAAa;AAAA,UACnE;AAEA,iBAAO;AAAA,QACT;AAEA,iBAAS,mCAAmC,cAAc;AACxD,cAAI,iBAAiB,QAAQ,iBAAiB,QAAW;AACvD,mBAAO,2BAA2B,aAAa,QAAQ;AAAA,UACzD;AAEA,iBAAO;AAAA,QACT;AAQA,YAAI,wBAAwB,CAAC;AAE7B,iBAAS,6BAA6B,YAAY;AAChD,cAAI,OAAO,4BAA4B;AAEvC,cAAI,CAAC,MAAM;AACT,gBAAI,aAAa,OAAO,eAAe,WAAW,aAAa,WAAW,eAAe,WAAW;AAEpG,gBAAI,YAAY;AACd,qBAAO,gDAAgD,aAAa;AAAA,YACtE;AAAA,UACF;AAEA,iBAAO;AAAA,QACT;AAcA,iBAAS,oBAAoB,SAAS,YAAY;AAChD,cAAI,CAAC,QAAQ,UAAU,QAAQ,OAAO,aAAa,QAAQ,OAAO,MAAM;AACtE;AAAA,UACF;AAEA,kBAAQ,OAAO,YAAY;AAC3B,cAAI,4BAA4B,6BAA6B,UAAU;AAEvE,cAAI,sBAAsB,yBAAyB,GAAG;AACpD;AAAA,UACF;AAEA,gCAAsB,yBAAyB,IAAI;AAInD,cAAI,aAAa;AAEjB,cAAI,WAAW,QAAQ,UAAU,QAAQ,WAAW,kBAAkB,SAAS;AAE7E,yBAAa,iCAAiC,yBAAyB,QAAQ,OAAO,IAAI,IAAI;AAAA,UAChG;AAEA;AACE,4CAAgC,OAAO;AAEvC,kBAAM,6HAAkI,2BAA2B,UAAU;AAE7K,4CAAgC,IAAI;AAAA,UACtC;AAAA,QACF;AAYA,iBAAS,kBAAkB,MAAM,YAAY;AAC3C,cAAI,OAAO,SAAS,UAAU;AAC5B;AAAA,UACF;AAEA,cAAI,QAAQ,IAAI,GAAG;AACjB,qBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,kBAAI,QAAQ,KAAK,CAAC;AAElB,kBAAI,eAAe,KAAK,GAAG;AACzB,oCAAoB,OAAO,UAAU;AAAA,cACvC;AAAA,YACF;AAAA,UACF,WAAW,eAAe,IAAI,GAAG;AAE/B,gBAAI,KAAK,QAAQ;AACf,mBAAK,OAAO,YAAY;AAAA,YAC1B;AAAA,UACF,WAAW,MAAM;AACf,gBAAI,aAAa,cAAc,IAAI;AAEnC,gBAAI,OAAO,eAAe,YAAY;AAGpC,kBAAI,eAAe,KAAK,SAAS;AAC/B,oBAAI,WAAW,WAAW,KAAK,IAAI;AACnC,oBAAI;AAEJ,uBAAO,EAAE,OAAO,SAAS,KAAK,GAAG,MAAM;AACrC,sBAAI,eAAe,KAAK,KAAK,GAAG;AAC9B,wCAAoB,KAAK,OAAO,UAAU;AAAA,kBAC5C;AAAA,gBACF;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAAA,QACF;AASA,iBAAS,kBAAkB,SAAS;AAClC;AACE,gBAAI,OAAO,QAAQ;AAEnB,gBAAI,SAAS,QAAQ,SAAS,UAAa,OAAO,SAAS,UAAU;AACnE;AAAA,YACF;AAEA,gBAAI;AAEJ,gBAAI,OAAO,SAAS,YAAY;AAC9B,0BAAY,KAAK;AAAA,YACnB,WAAW,OAAO,SAAS,aAAa,KAAK,aAAa;AAAA;AAAA,YAE1D,KAAK,aAAa,kBAAkB;AAClC,0BAAY,KAAK;AAAA,YACnB,OAAO;AACL;AAAA,YACF;AAEA,gBAAI,WAAW;AAEb,kBAAI,OAAO,yBAAyB,IAAI;AACxC,6BAAe,WAAW,QAAQ,OAAO,QAAQ,MAAM,OAAO;AAAA,YAChE,WAAW,KAAK,cAAc,UAAa,CAAC,+BAA+B;AACzE,8CAAgC;AAEhC,kBAAI,QAAQ,yBAAyB,IAAI;AAEzC,oBAAM,uGAAuG,SAAS,SAAS;AAAA,YACjI;AAEA,gBAAI,OAAO,KAAK,oBAAoB,cAAc,CAAC,KAAK,gBAAgB,sBAAsB;AAC5F,oBAAM,4HAAiI;AAAA,YACzI;AAAA,UACF;AAAA,QACF;AAOA,iBAAS,sBAAsB,UAAU;AACvC;AACE,gBAAI,OAAO,OAAO,KAAK,SAAS,KAAK;AAErC,qBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,kBAAI,MAAM,KAAK,CAAC;AAEhB,kBAAI,QAAQ,cAAc,QAAQ,OAAO;AACvC,gDAAgC,QAAQ;AAExC,sBAAM,4GAAiH,GAAG;AAE1H,gDAAgC,IAAI;AACpC;AAAA,cACF;AAAA,YACF;AAEA,gBAAI,SAAS,QAAQ,MAAM;AACzB,8CAAgC,QAAQ;AAExC,oBAAM,uDAAuD;AAE7D,8CAAgC,IAAI;AAAA,YACtC;AAAA,UACF;AAAA,QACF;AACA,iBAAS,4BAA4B,MAAM,OAAO,UAAU;AAC1D,cAAI,YAAY,mBAAmB,IAAI;AAGvC,cAAI,CAAC,WAAW;AACd,gBAAI,OAAO;AAEX,gBAAI,SAAS,UAAa,OAAO,SAAS,YAAY,SAAS,QAAQ,OAAO,KAAK,IAAI,EAAE,WAAW,GAAG;AACrG,sBAAQ;AAAA,YACV;AAEA,gBAAI,aAAa,mCAAmC,KAAK;AAEzD,gBAAI,YAAY;AACd,sBAAQ;AAAA,YACV,OAAO;AACL,sBAAQ,4BAA4B;AAAA,YACtC;AAEA,gBAAI;AAEJ,gBAAI,SAAS,MAAM;AACjB,2BAAa;AAAA,YACf,WAAW,QAAQ,IAAI,GAAG;AACxB,2BAAa;AAAA,YACf,WAAW,SAAS,UAAa,KAAK,aAAa,oBAAoB;AACrE,2BAAa,OAAO,yBAAyB,KAAK,IAAI,KAAK,aAAa;AACxE,qBAAO;AAAA,YACT,OAAO;AACL,2BAAa,OAAO;AAAA,YACtB;AAEA;AACE,oBAAM,qJAA+J,YAAY,IAAI;AAAA,YACvL;AAAA,UACF;AAEA,cAAI,UAAU,cAAc,MAAM,MAAM,SAAS;AAGjD,cAAI,WAAW,MAAM;AACnB,mBAAO;AAAA,UACT;AAOA,cAAI,WAAW;AACb,qBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACzC,gCAAkB,UAAU,CAAC,GAAG,IAAI;AAAA,YACtC;AAAA,UACF;AAEA,cAAI,SAAS,qBAAqB;AAChC,kCAAsB,OAAO;AAAA,UAC/B,OAAO;AACL,8BAAkB,OAAO;AAAA,UAC3B;AAEA,iBAAO;AAAA,QACT;AACA,YAAI,sCAAsC;AAC1C,iBAAS,4BAA4B,MAAM;AACzC,cAAI,mBAAmB,4BAA4B,KAAK,MAAM,IAAI;AAClE,2BAAiB,OAAO;AAExB;AACE,gBAAI,CAAC,qCAAqC;AACxC,oDAAsC;AAEtC,mBAAK,sJAAgK;AAAA,YACvK;AAGA,mBAAO,eAAe,kBAAkB,QAAQ;AAAA,cAC9C,YAAY;AAAA,cACZ,KAAK,WAAY;AACf,qBAAK,2FAAgG;AAErG,uBAAO,eAAe,MAAM,QAAQ;AAAA,kBAClC,OAAO;AAAA,gBACT,CAAC;AACD,uBAAO;AAAA,cACT;AAAA,YACF,CAAC;AAAA,UACH;AAEA,iBAAO;AAAA,QACT;AACA,iBAAS,2BAA2B,SAAS,OAAO,UAAU;AAC5D,cAAI,aAAa,aAAa,MAAM,MAAM,SAAS;AAEnD,mBAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACzC,8BAAkB,UAAU,CAAC,GAAG,WAAW,IAAI;AAAA,UACjD;AAEA,4BAAkB,UAAU;AAC5B,iBAAO;AAAA,QACT;AAEA,iBAAS,gBAAgB,OAAO,SAAS;AACvC,cAAI,iBAAiB,wBAAwB;AAC7C,kCAAwB,aAAa,CAAC;AACtC,cAAI,oBAAoB,wBAAwB;AAEhD;AACE,oCAAwB,WAAW,iBAAiB,oBAAI,IAAI;AAAA,UAC9D;AAEA,cAAI;AACF,kBAAM;AAAA,UACR,UAAE;AACA,oCAAwB,aAAa;AAErC;AACE,kBAAI,mBAAmB,QAAQ,kBAAkB,gBAAgB;AAC/D,oBAAI,qBAAqB,kBAAkB,eAAe;AAE1D,oBAAI,qBAAqB,IAAI;AAC3B,uBAAK,qMAA+M;AAAA,gBACtN;AAEA,kCAAkB,eAAe,MAAM;AAAA,cACzC;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAEA,YAAI,6BAA6B;AACjC,YAAI,kBAAkB;AACtB,iBAAS,YAAY,MAAM;AACzB,cAAI,oBAAoB,MAAM;AAC5B,gBAAI;AAGF,kBAAI,iBAAiB,YAAY,KAAK,OAAO,GAAG,MAAM,GAAG,CAAC;AAC1D,kBAAI,cAAc,UAAU,OAAO,aAAa;AAGhD,gCAAkB,YAAY,KAAK,QAAQ,QAAQ,EAAE;AAAA,YACvD,SAAS,MAAM;AAIb,gCAAkB,SAAU,UAAU;AACpC;AACE,sBAAI,+BAA+B,OAAO;AACxC,iDAA6B;AAE7B,wBAAI,OAAO,mBAAmB,aAAa;AACzC,4BAAM,0NAAyO;AAAA,oBACjP;AAAA,kBACF;AAAA,gBACF;AAEA,oBAAI,UAAU,IAAI,eAAe;AACjC,wBAAQ,MAAM,YAAY;AAC1B,wBAAQ,MAAM,YAAY,MAAS;AAAA,cACrC;AAAA,YACF;AAAA,UACF;AAEA,iBAAO,gBAAgB,IAAI;AAAA,QAC7B;AAEA,YAAI,gBAAgB;AACpB,YAAI,oBAAoB;AACxB,iBAAS,IAAI,UAAU;AACrB;AAGE,gBAAI,oBAAoB;AACxB;AAEA,gBAAI,qBAAqB,YAAY,MAAM;AAGzC,mCAAqB,UAAU,CAAC;AAAA,YAClC;AAEA,gBAAI,uBAAuB,qBAAqB;AAChD,gBAAI;AAEJ,gBAAI;AAKF,mCAAqB,mBAAmB;AACxC,uBAAS,SAAS;AAIlB,kBAAI,CAAC,wBAAwB,qBAAqB,yBAAyB;AACzE,oBAAI,QAAQ,qBAAqB;AAEjC,oBAAI,UAAU,MAAM;AAClB,uCAAqB,0BAA0B;AAC/C,gCAAc,KAAK;AAAA,gBACrB;AAAA,cACF;AAAA,YACF,SAASD,QAAO;AACd,0BAAY,iBAAiB;AAC7B,oBAAMA;AAAA,YACR,UAAE;AACA,mCAAqB,mBAAmB;AAAA,YAC1C;AAEA,gBAAI,WAAW,QAAQ,OAAO,WAAW,YAAY,OAAO,OAAO,SAAS,YAAY;AACtF,kBAAI,iBAAiB;AAGrB,kBAAI,aAAa;AACjB,kBAAI,WAAW;AAAA,gBACb,MAAM,SAAU,SAAS,QAAQ;AAC/B,+BAAa;AACb,iCAAe,KAAK,SAAUE,cAAa;AACzC,gCAAY,iBAAiB;AAE7B,wBAAI,kBAAkB,GAAG;AAGvB,mDAA6BA,cAAa,SAAS,MAAM;AAAA,oBAC3D,OAAO;AACL,8BAAQA,YAAW;AAAA,oBACrB;AAAA,kBACF,GAAG,SAAUF,QAAO;AAElB,gCAAY,iBAAiB;AAC7B,2BAAOA,MAAK;AAAA,kBACd,CAAC;AAAA,gBACH;AAAA,cACF;AAEA;AACE,oBAAI,CAAC,qBAAqB,OAAO,YAAY,aAAa;AAExD,0BAAQ,QAAQ,EAAE,KAAK,WAAY;AAAA,kBAAC,CAAC,EAAE,KAAK,WAAY;AACtD,wBAAI,CAAC,YAAY;AACf,0CAAoB;AAEpB,4BAAM,mMAAuN;AAAA,oBAC/N;AAAA,kBACF,CAAC;AAAA,gBACH;AAAA,cACF;AAEA,qBAAO;AAAA,YACT,OAAO;AACL,kBAAI,cAAc;AAGlB,0BAAY,iBAAiB;AAE7B,kBAAI,kBAAkB,GAAG;AAEvB,oBAAI,SAAS,qBAAqB;AAElC,oBAAI,WAAW,MAAM;AACnB,gCAAc,MAAM;AACpB,uCAAqB,UAAU;AAAA,gBACjC;AAIA,oBAAI,YAAY;AAAA,kBACd,MAAM,SAAU,SAAS,QAAQ;AAI/B,wBAAI,qBAAqB,YAAY,MAAM;AAEzC,2CAAqB,UAAU,CAAC;AAChC,mDAA6B,aAAa,SAAS,MAAM;AAAA,oBAC3D,OAAO;AACL,8BAAQ,WAAW;AAAA,oBACrB;AAAA,kBACF;AAAA,gBACF;AACA,uBAAO;AAAA,cACT,OAAO;AAGL,oBAAI,aAAa;AAAA,kBACf,MAAM,SAAU,SAAS,QAAQ;AAC/B,4BAAQ,WAAW;AAAA,kBACrB;AAAA,gBACF;AACA,uBAAO;AAAA,cACT;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAEA,iBAAS,YAAY,mBAAmB;AACtC;AACE,gBAAI,sBAAsB,gBAAgB,GAAG;AAC3C,oBAAM,kIAAuI;AAAA,YAC/I;AAEA,4BAAgB;AAAA,UAClB;AAAA,QACF;AAEA,iBAAS,6BAA6B,aAAa,SAAS,QAAQ;AAClE;AACE,gBAAI,QAAQ,qBAAqB;AAEjC,gBAAI,UAAU,MAAM;AAClB,kBAAI;AACF,8BAAc,KAAK;AACnB,4BAAY,WAAY;AACtB,sBAAI,MAAM,WAAW,GAAG;AAEtB,yCAAqB,UAAU;AAC/B,4BAAQ,WAAW;AAAA,kBACrB,OAAO;AAEL,iDAA6B,aAAa,SAAS,MAAM;AAAA,kBAC3D;AAAA,gBACF,CAAC;AAAA,cACH,SAASA,QAAO;AACd,uBAAOA,MAAK;AAAA,cACd;AAAA,YACF,OAAO;AACL,sBAAQ,WAAW;AAAA,YACrB;AAAA,UACF;AAAA,QACF;AAEA,YAAI,aAAa;AAEjB,iBAAS,cAAc,OAAO;AAC5B;AACE,gBAAI,CAAC,YAAY;AAEf,2BAAa;AACb,kBAAI,IAAI;AAER,kBAAI;AACF,uBAAO,IAAI,MAAM,QAAQ,KAAK;AAC5B,sBAAI,WAAW,MAAM,CAAC;AAEtB,qBAAG;AACD,+BAAW,SAAS,IAAI;AAAA,kBAC1B,SAAS,aAAa;AAAA,gBACxB;AAEA,sBAAM,SAAS;AAAA,cACjB,SAASA,QAAO;AAEd,wBAAQ,MAAM,MAAM,IAAI,CAAC;AACzB,sBAAMA;AAAA,cACR,UAAE;AACA,6BAAa;AAAA,cACf;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAEA,YAAI,kBAAmB;AACvB,YAAI,iBAAkB;AACtB,YAAI,gBAAiB;AACrB,YAAI,WAAW;AAAA,UACb,KAAK;AAAA,UACL,SAAS;AAAA,UACT,OAAO;AAAA,UACP;AAAA,UACA,MAAM;AAAA,QACR;AAEA,gBAAQ,WAAW;AACnB,gBAAQ,YAAY;AACpB,gBAAQ,WAAW;AACnB,gBAAQ,WAAW;AACnB,gBAAQ,gBAAgB;AACxB,gBAAQ,aAAa;AACrB,gBAAQ,WAAW;AACnB,gBAAQ,qDAAqD;AAC7D,gBAAQ,MAAM;AACd,gBAAQ,eAAe;AACvB,gBAAQ,gBAAgB;AACxB,gBAAQ,gBAAgB;AACxB,gBAAQ,gBAAgB;AACxB,gBAAQ,YAAY;AACpB,gBAAQ,aAAa;AACrB,gBAAQ,iBAAiB;AACzB,gBAAQ,OAAO;AACf,gBAAQ,OAAO;AACf,gBAAQ,kBAAkB;AAC1B,gBAAQ,eAAe;AACvB,gBAAQ,cAAc;AACtB,gBAAQ,aAAa;AACrB,gBAAQ,gBAAgB;AACxB,gBAAQ,mBAAmB;AAC3B,gBAAQ,YAAY;AACpB,gBAAQ,QAAQ;AAChB,gBAAQ,sBAAsB;AAC9B,gBAAQ,qBAAqB;AAC7B,gBAAQ,kBAAkB;AAC1B,gBAAQ,UAAU;AAClB,gBAAQ,aAAa;AACrB,gBAAQ,SAAS;AACjB,gBAAQ,WAAW;AACnB,gBAAQ,uBAAuB;AAC/B,gBAAQ,gBAAgB;AACxB,gBAAQ,UAAU;AAElB,YACE,OAAO,mCAAmC,eAC1C,OAAO,+BAA+B,+BACpC,YACF;AACA,yCAA+B,2BAA2B,IAAI,MAAM,CAAC;AAAA,QACvE;AAAA,MAEE,GAAG;AAAA,IACL;AAAA;AAAA;;;ACnrFA;AAAA;AAEA,QAAI,OAAuC;AACzC,aAAO,UAAU;AAAA,IACnB,OAAO;AACL,aAAO,UAAU;AAAA,IACnB;AAAA;AAAA;", + "mappings": "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", "names": ["ReactDebugCurrentFrame", "moduleObject", "error", "Component", "returnValue"] } diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-5WWUZCGV.js b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-5WWUZCGV.js new file mode 100644 index 0000000..924dc37 --- /dev/null +++ b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-5WWUZCGV.js @@ -0,0 +1,36 @@ +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod +)); + +export { + __commonJS, + __export, + __toESM +}; +//# sourceMappingURL=chunk-5WWUZCGV.js.map diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-5WWUZCGV.js.map b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-5WWUZCGV.js.map new file mode 100644 index 0000000..9865211 --- /dev/null +++ b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-5WWUZCGV.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": [], + "sourcesContent": [], + "mappings": "", + "names": [] +} diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-CI5QM2G2.js b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-F3VLP26G.js similarity index 99% rename from src/BlockThings_frontend/node_modules/.vite/deps/chunk-CI5QM2G2.js rename to src/BlockThings_frontend/node_modules/.vite/deps/chunk-F3VLP26G.js index 184e5c4..48bcc3c 100644 --- a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-CI5QM2G2.js +++ b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-F3VLP26G.js @@ -1,7 +1,9 @@ import { - __commonJS, require_react -} from "./chunk-JHBQJ233.js"; +} from "./chunk-2DCM46BG.js"; +import { + __commonJS +} from "./chunk-5WWUZCGV.js"; // ../../node_modules/scheduler/cjs/scheduler.development.js var require_scheduler_development = __commonJS({ @@ -21653,4 +21655,4 @@ react-dom/cjs/react-dom.development.js: * @license Modernizr 3.0.0pre (Custom Build) | MIT *) */ -//# sourceMappingURL=chunk-CI5QM2G2.js.map +//# sourceMappingURL=chunk-F3VLP26G.js.map diff --git a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-CI5QM2G2.js.map b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-F3VLP26G.js.map similarity index 74% rename from src/BlockThings_frontend/node_modules/.vite/deps/chunk-CI5QM2G2.js.map rename to src/BlockThings_frontend/node_modules/.vite/deps/chunk-F3VLP26G.js.map index 2e56d2a..1d1a660 100644 --- a/src/BlockThings_frontend/node_modules/.vite/deps/chunk-CI5QM2G2.js.map +++ b/src/BlockThings_frontend/node_modules/.vite/deps/chunk-F3VLP26G.js.map @@ -2,6 +2,6 @@ "version": 3, "sources": ["../../../../../node_modules/scheduler/cjs/scheduler.development.js", "../../../../../node_modules/scheduler/index.js", "../../../../../node_modules/react-dom/cjs/react-dom.development.js", "../../../../../node_modules/react-dom/index.js"], "sourcesContent": ["/**\n * @license React\n * scheduler.development.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== \"production\") {\n (function() {\n\n 'use strict';\n\n/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===\n 'function'\n) {\n __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());\n}\n var enableSchedulerDebugging = false;\nvar enableProfiling = false;\nvar frameYieldMs = 5;\n\nfunction push(heap, node) {\n var index = heap.length;\n heap.push(node);\n siftUp(heap, node, index);\n}\nfunction peek(heap) {\n return heap.length === 0 ? null : heap[0];\n}\nfunction pop(heap) {\n if (heap.length === 0) {\n return null;\n }\n\n var first = heap[0];\n var last = heap.pop();\n\n if (last !== first) {\n heap[0] = last;\n siftDown(heap, last, 0);\n }\n\n return first;\n}\n\nfunction siftUp(heap, node, i) {\n var index = i;\n\n while (index > 0) {\n var parentIndex = index - 1 >>> 1;\n var parent = heap[parentIndex];\n\n if (compare(parent, node) > 0) {\n // The parent is larger. Swap positions.\n heap[parentIndex] = node;\n heap[index] = parent;\n index = parentIndex;\n } else {\n // The parent is smaller. Exit.\n return;\n }\n }\n}\n\nfunction siftDown(heap, node, i) {\n var index = i;\n var length = heap.length;\n var halfLength = length >>> 1;\n\n while (index < halfLength) {\n var leftIndex = (index + 1) * 2 - 1;\n var left = heap[leftIndex];\n var rightIndex = leftIndex + 1;\n var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.\n\n if (compare(left, node) < 0) {\n if (rightIndex < length && compare(right, left) < 0) {\n heap[index] = right;\n heap[rightIndex] = node;\n index = rightIndex;\n } else {\n heap[index] = left;\n heap[leftIndex] = node;\n index = leftIndex;\n }\n } else if (rightIndex < length && compare(right, node) < 0) {\n heap[index] = right;\n heap[rightIndex] = node;\n index = rightIndex;\n } else {\n // Neither child is smaller. Exit.\n return;\n }\n }\n}\n\nfunction compare(a, b) {\n // Compare sort index first, then task id.\n var diff = a.sortIndex - b.sortIndex;\n return diff !== 0 ? diff : a.id - b.id;\n}\n\n// TODO: Use symbols?\nvar ImmediatePriority = 1;\nvar UserBlockingPriority = 2;\nvar NormalPriority = 3;\nvar LowPriority = 4;\nvar IdlePriority = 5;\n\nfunction markTaskErrored(task, ms) {\n}\n\n/* eslint-disable no-var */\n\nvar hasPerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';\n\nif (hasPerformanceNow) {\n var localPerformance = performance;\n\n exports.unstable_now = function () {\n return localPerformance.now();\n };\n} else {\n var localDate = Date;\n var initialTime = localDate.now();\n\n exports.unstable_now = function () {\n return localDate.now() - initialTime;\n };\n} // Max 31 bit integer. The max integer size in V8 for 32-bit systems.\n// Math.pow(2, 30) - 1\n// 0b111111111111111111111111111111\n\n\nvar maxSigned31BitInt = 1073741823; // Times out immediately\n\nvar IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out\n\nvar USER_BLOCKING_PRIORITY_TIMEOUT = 250;\nvar NORMAL_PRIORITY_TIMEOUT = 5000;\nvar LOW_PRIORITY_TIMEOUT = 10000; // Never times out\n\nvar IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // Tasks are stored on a min heap\n\nvar taskQueue = [];\nvar timerQueue = []; // Incrementing id counter. Used to maintain insertion order.\n\nvar taskIdCounter = 1; // Pausing the scheduler is useful for debugging.\nvar currentTask = null;\nvar currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.\n\nvar isPerformingWork = false;\nvar isHostCallbackScheduled = false;\nvar isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.\n\nvar localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;\nvar localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;\nvar localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom\n\nvar isInputPending = typeof navigator !== 'undefined' && navigator.scheduling !== undefined && navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;\n\nfunction advanceTimers(currentTime) {\n // Check for tasks that are no longer delayed and add them to the queue.\n var timer = peek(timerQueue);\n\n while (timer !== null) {\n if (timer.callback === null) {\n // Timer was cancelled.\n pop(timerQueue);\n } else if (timer.startTime <= currentTime) {\n // Timer fired. Transfer to the task queue.\n pop(timerQueue);\n timer.sortIndex = timer.expirationTime;\n push(taskQueue, timer);\n } else {\n // Remaining timers are pending.\n return;\n }\n\n timer = peek(timerQueue);\n }\n}\n\nfunction handleTimeout(currentTime) {\n isHostTimeoutScheduled = false;\n advanceTimers(currentTime);\n\n if (!isHostCallbackScheduled) {\n if (peek(taskQueue) !== null) {\n isHostCallbackScheduled = true;\n requestHostCallback(flushWork);\n } else {\n var firstTimer = peek(timerQueue);\n\n if (firstTimer !== null) {\n requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);\n }\n }\n }\n}\n\nfunction flushWork(hasTimeRemaining, initialTime) {\n\n\n isHostCallbackScheduled = false;\n\n if (isHostTimeoutScheduled) {\n // We scheduled a timeout but it's no longer needed. Cancel it.\n isHostTimeoutScheduled = false;\n cancelHostTimeout();\n }\n\n isPerformingWork = true;\n var previousPriorityLevel = currentPriorityLevel;\n\n try {\n if (enableProfiling) {\n try {\n return workLoop(hasTimeRemaining, initialTime);\n } catch (error) {\n if (currentTask !== null) {\n var currentTime = exports.unstable_now();\n markTaskErrored(currentTask, currentTime);\n currentTask.isQueued = false;\n }\n\n throw error;\n }\n } else {\n // No catch in prod code path.\n return workLoop(hasTimeRemaining, initialTime);\n }\n } finally {\n currentTask = null;\n currentPriorityLevel = previousPriorityLevel;\n isPerformingWork = false;\n }\n}\n\nfunction workLoop(hasTimeRemaining, initialTime) {\n var currentTime = initialTime;\n advanceTimers(currentTime);\n currentTask = peek(taskQueue);\n\n while (currentTask !== null && !(enableSchedulerDebugging )) {\n if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {\n // This currentTask hasn't expired, and we've reached the deadline.\n break;\n }\n\n var callback = currentTask.callback;\n\n if (typeof callback === 'function') {\n currentTask.callback = null;\n currentPriorityLevel = currentTask.priorityLevel;\n var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;\n\n var continuationCallback = callback(didUserCallbackTimeout);\n currentTime = exports.unstable_now();\n\n if (typeof continuationCallback === 'function') {\n currentTask.callback = continuationCallback;\n } else {\n\n if (currentTask === peek(taskQueue)) {\n pop(taskQueue);\n }\n }\n\n advanceTimers(currentTime);\n } else {\n pop(taskQueue);\n }\n\n currentTask = peek(taskQueue);\n } // Return whether there's additional work\n\n\n if (currentTask !== null) {\n return true;\n } else {\n var firstTimer = peek(timerQueue);\n\n if (firstTimer !== null) {\n requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);\n }\n\n return false;\n }\n}\n\nfunction unstable_runWithPriority(priorityLevel, eventHandler) {\n switch (priorityLevel) {\n case ImmediatePriority:\n case UserBlockingPriority:\n case NormalPriority:\n case LowPriority:\n case IdlePriority:\n break;\n\n default:\n priorityLevel = NormalPriority;\n }\n\n var previousPriorityLevel = currentPriorityLevel;\n currentPriorityLevel = priorityLevel;\n\n try {\n return eventHandler();\n } finally {\n currentPriorityLevel = previousPriorityLevel;\n }\n}\n\nfunction unstable_next(eventHandler) {\n var priorityLevel;\n\n switch (currentPriorityLevel) {\n case ImmediatePriority:\n case UserBlockingPriority:\n case NormalPriority:\n // Shift down to normal priority\n priorityLevel = NormalPriority;\n break;\n\n default:\n // Anything lower than normal priority should remain at the current level.\n priorityLevel = currentPriorityLevel;\n break;\n }\n\n var previousPriorityLevel = currentPriorityLevel;\n currentPriorityLevel = priorityLevel;\n\n try {\n return eventHandler();\n } finally {\n currentPriorityLevel = previousPriorityLevel;\n }\n}\n\nfunction unstable_wrapCallback(callback) {\n var parentPriorityLevel = currentPriorityLevel;\n return function () {\n // This is a fork of runWithPriority, inlined for performance.\n var previousPriorityLevel = currentPriorityLevel;\n currentPriorityLevel = parentPriorityLevel;\n\n try {\n return callback.apply(this, arguments);\n } finally {\n currentPriorityLevel = previousPriorityLevel;\n }\n };\n}\n\nfunction unstable_scheduleCallback(priorityLevel, callback, options) {\n var currentTime = exports.unstable_now();\n var startTime;\n\n if (typeof options === 'object' && options !== null) {\n var delay = options.delay;\n\n if (typeof delay === 'number' && delay > 0) {\n startTime = currentTime + delay;\n } else {\n startTime = currentTime;\n }\n } else {\n startTime = currentTime;\n }\n\n var timeout;\n\n switch (priorityLevel) {\n case ImmediatePriority:\n timeout = IMMEDIATE_PRIORITY_TIMEOUT;\n break;\n\n case UserBlockingPriority:\n timeout = USER_BLOCKING_PRIORITY_TIMEOUT;\n break;\n\n case IdlePriority:\n timeout = IDLE_PRIORITY_TIMEOUT;\n break;\n\n case LowPriority:\n timeout = LOW_PRIORITY_TIMEOUT;\n break;\n\n case NormalPriority:\n default:\n timeout = NORMAL_PRIORITY_TIMEOUT;\n break;\n }\n\n var expirationTime = startTime + timeout;\n var newTask = {\n id: taskIdCounter++,\n callback: callback,\n priorityLevel: priorityLevel,\n startTime: startTime,\n expirationTime: expirationTime,\n sortIndex: -1\n };\n\n if (startTime > currentTime) {\n // This is a delayed task.\n newTask.sortIndex = startTime;\n push(timerQueue, newTask);\n\n if (peek(taskQueue) === null && newTask === peek(timerQueue)) {\n // All tasks are delayed, and this is the task with the earliest delay.\n if (isHostTimeoutScheduled) {\n // Cancel an existing timeout.\n cancelHostTimeout();\n } else {\n isHostTimeoutScheduled = true;\n } // Schedule a timeout.\n\n\n requestHostTimeout(handleTimeout, startTime - currentTime);\n }\n } else {\n newTask.sortIndex = expirationTime;\n push(taskQueue, newTask);\n // wait until the next time we yield.\n\n\n if (!isHostCallbackScheduled && !isPerformingWork) {\n isHostCallbackScheduled = true;\n requestHostCallback(flushWork);\n }\n }\n\n return newTask;\n}\n\nfunction unstable_pauseExecution() {\n}\n\nfunction unstable_continueExecution() {\n\n if (!isHostCallbackScheduled && !isPerformingWork) {\n isHostCallbackScheduled = true;\n requestHostCallback(flushWork);\n }\n}\n\nfunction unstable_getFirstCallbackNode() {\n return peek(taskQueue);\n}\n\nfunction unstable_cancelCallback(task) {\n // remove from the queue because you can't remove arbitrary nodes from an\n // array based heap, only the first one.)\n\n\n task.callback = null;\n}\n\nfunction unstable_getCurrentPriorityLevel() {\n return currentPriorityLevel;\n}\n\nvar isMessageLoopRunning = false;\nvar scheduledHostCallback = null;\nvar taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main\n// thread, like user events. By default, it yields multiple times per frame.\n// It does not attempt to align with frame boundaries, since most tasks don't\n// need to be frame aligned; for those that do, use requestAnimationFrame.\n\nvar frameInterval = frameYieldMs;\nvar startTime = -1;\n\nfunction shouldYieldToHost() {\n var timeElapsed = exports.unstable_now() - startTime;\n\n if (timeElapsed < frameInterval) {\n // The main thread has only been blocked for a really short amount of time;\n // smaller than a single frame. Don't yield yet.\n return false;\n } // The main thread has been blocked for a non-negligible amount of time. We\n\n\n return true;\n}\n\nfunction requestPaint() {\n\n}\n\nfunction forceFrameRate(fps) {\n if (fps < 0 || fps > 125) {\n // Using console['error'] to evade Babel and ESLint\n console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported');\n return;\n }\n\n if (fps > 0) {\n frameInterval = Math.floor(1000 / fps);\n } else {\n // reset the framerate\n frameInterval = frameYieldMs;\n }\n}\n\nvar performWorkUntilDeadline = function () {\n if (scheduledHostCallback !== null) {\n var currentTime = exports.unstable_now(); // Keep track of the start time so we can measure how long the main thread\n // has been blocked.\n\n startTime = currentTime;\n var hasTimeRemaining = true; // If a scheduler task throws, exit the current browser task so the\n // error can be observed.\n //\n // Intentionally not using a try-catch, since that makes some debugging\n // techniques harder. Instead, if `scheduledHostCallback` errors, then\n // `hasMoreWork` will remain true, and we'll continue the work loop.\n\n var hasMoreWork = true;\n\n try {\n hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);\n } finally {\n if (hasMoreWork) {\n // If there's more work, schedule the next message event at the end\n // of the preceding one.\n schedulePerformWorkUntilDeadline();\n } else {\n isMessageLoopRunning = false;\n scheduledHostCallback = null;\n }\n }\n } else {\n isMessageLoopRunning = false;\n } // Yielding to the browser will give it a chance to paint, so we can\n};\n\nvar schedulePerformWorkUntilDeadline;\n\nif (typeof localSetImmediate === 'function') {\n // Node.js and old IE.\n // There's a few reasons for why we prefer setImmediate.\n //\n // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.\n // (Even though this is a DOM fork of the Scheduler, you could get here\n // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)\n // https://github.com/facebook/react/issues/20756\n //\n // But also, it runs earlier which is the semantic we want.\n // If other browsers ever implement it, it's better to use it.\n // Although both of these would be inferior to native scheduling.\n schedulePerformWorkUntilDeadline = function () {\n localSetImmediate(performWorkUntilDeadline);\n };\n} else if (typeof MessageChannel !== 'undefined') {\n // DOM and Worker environments.\n // We prefer MessageChannel because of the 4ms setTimeout clamping.\n var channel = new MessageChannel();\n var port = channel.port2;\n channel.port1.onmessage = performWorkUntilDeadline;\n\n schedulePerformWorkUntilDeadline = function () {\n port.postMessage(null);\n };\n} else {\n // We should only fallback here in non-browser environments.\n schedulePerformWorkUntilDeadline = function () {\n localSetTimeout(performWorkUntilDeadline, 0);\n };\n}\n\nfunction requestHostCallback(callback) {\n scheduledHostCallback = callback;\n\n if (!isMessageLoopRunning) {\n isMessageLoopRunning = true;\n schedulePerformWorkUntilDeadline();\n }\n}\n\nfunction requestHostTimeout(callback, ms) {\n taskTimeoutID = localSetTimeout(function () {\n callback(exports.unstable_now());\n }, ms);\n}\n\nfunction cancelHostTimeout() {\n localClearTimeout(taskTimeoutID);\n taskTimeoutID = -1;\n}\n\nvar unstable_requestPaint = requestPaint;\nvar unstable_Profiling = null;\n\nexports.unstable_IdlePriority = IdlePriority;\nexports.unstable_ImmediatePriority = ImmediatePriority;\nexports.unstable_LowPriority = LowPriority;\nexports.unstable_NormalPriority = NormalPriority;\nexports.unstable_Profiling = unstable_Profiling;\nexports.unstable_UserBlockingPriority = UserBlockingPriority;\nexports.unstable_cancelCallback = unstable_cancelCallback;\nexports.unstable_continueExecution = unstable_continueExecution;\nexports.unstable_forceFrameRate = forceFrameRate;\nexports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;\nexports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;\nexports.unstable_next = unstable_next;\nexports.unstable_pauseExecution = unstable_pauseExecution;\nexports.unstable_requestPaint = unstable_requestPaint;\nexports.unstable_runWithPriority = unstable_runWithPriority;\nexports.unstable_scheduleCallback = unstable_scheduleCallback;\nexports.unstable_shouldYield = shouldYieldToHost;\nexports.unstable_wrapCallback = unstable_wrapCallback;\n /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===\n 'function'\n) {\n __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());\n}\n \n })();\n}\n", "'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n module.exports = require('./cjs/scheduler.development.js');\n}\n", "/**\n * @license React\n * react-dom.development.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== \"production\") {\n (function() {\n\n 'use strict';\n\n/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\nif (\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===\n 'function'\n) {\n __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());\n}\n var React = require('react');\nvar Scheduler = require('scheduler');\n\nvar ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n\nvar suppressWarning = false;\nfunction setSuppressWarning(newSuppressWarning) {\n {\n suppressWarning = newSuppressWarning;\n }\n} // In DEV, calls to console.warn and console.error get replaced\n// by calls to these methods by a Babel plugin.\n//\n// In PROD (or in packages without access to React internals),\n// they are left as they are instead.\n\nfunction warn(format) {\n {\n if (!suppressWarning) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n printWarning('warn', format, args);\n }\n }\n}\nfunction error(format) {\n {\n if (!suppressWarning) {\n for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n args[_key2 - 1] = arguments[_key2];\n }\n\n printWarning('error', format, args);\n }\n }\n}\n\nfunction printWarning(level, format, args) {\n // When changing this logic, you might want to also\n // update consoleWithStackDev.www.js as well.\n {\n var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\n var stack = ReactDebugCurrentFrame.getStackAddendum();\n\n if (stack !== '') {\n format += '%s';\n args = args.concat([stack]);\n } // eslint-disable-next-line react-internal/safe-string-coercion\n\n\n var argsWithFormat = args.map(function (item) {\n return String(item);\n }); // Careful: RN currently depends on this prefix\n\n argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it\n // breaks IE9: https://github.com/facebook/react/issues/13610\n // eslint-disable-next-line react-internal/no-production-logging\n\n Function.prototype.apply.call(console[level], console, argsWithFormat);\n }\n}\n\nvar FunctionComponent = 0;\nvar ClassComponent = 1;\nvar IndeterminateComponent = 2; // Before we know whether it is function or class\n\nvar HostRoot = 3; // Root of a host tree. Could be nested inside another node.\n\nvar HostPortal = 4; // A subtree. Could be an entry point to a different renderer.\n\nvar HostComponent = 5;\nvar HostText = 6;\nvar Fragment = 7;\nvar Mode = 8;\nvar ContextConsumer = 9;\nvar ContextProvider = 10;\nvar ForwardRef = 11;\nvar Profiler = 12;\nvar SuspenseComponent = 13;\nvar MemoComponent = 14;\nvar SimpleMemoComponent = 15;\nvar LazyComponent = 16;\nvar IncompleteClassComponent = 17;\nvar DehydratedFragment = 18;\nvar SuspenseListComponent = 19;\nvar ScopeComponent = 21;\nvar OffscreenComponent = 22;\nvar LegacyHiddenComponent = 23;\nvar CacheComponent = 24;\nvar TracingMarkerComponent = 25;\n\n// -----------------------------------------------------------------------------\n\nvar enableClientRenderFallbackOnTextMismatch = true; // TODO: Need to review this code one more time before landing\n// the react-reconciler package.\n\nvar enableNewReconciler = false; // Support legacy Primer support on internal FB www\n\nvar enableLazyContextPropagation = false; // FB-only usage. The new API has different semantics.\n\nvar enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber\n\nvar enableSuspenseAvoidThisFallback = false; // Enables unstable_avoidThisFallback feature in Fizz\n// React DOM Chopping Block\n//\n// Similar to main Chopping Block but only flags related to React DOM. These are\n// grouped because we will likely batch all of them into a single major release.\n// -----------------------------------------------------------------------------\n// Disable support for comment nodes as React DOM containers. Already disabled\n// in open source, but www codebase still relies on it. Need to remove.\n\nvar disableCommentsAsDOMContainers = true; // Disable javascript: URL strings in href for XSS protection.\n// and client rendering, mostly to allow JSX attributes to apply to the custom\n// element's object properties instead of only HTML attributes.\n// https://github.com/facebook/react/issues/11347\n\nvar enableCustomElementPropertySupport = false; // Disables children for