-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 __esm = (fn, res) => function __init () {
- return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res
-}
-var __commonJS = (cb, mod) => function __require () {
- return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports
-}
+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 __esm = (fn, res) => function __init() {
+ return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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 })
-}
+ __defProp(target, name, { get: all[name], enumerable: true });
+};
var __copyProps = (to, from2, except, desc) => {
if (from2 && typeof from2 === "object" || typeof from2 === "function") {
for (let key of __getOwnPropNames(from2))
if (!__hasOwnProp.call(to, key) && key !== except)
- __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable })
+ __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
}
- return to
-}
+ 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-
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
-))
+));
// dist/lib/blake2b.js
-var Blake2b, blake2b_default
+var Blake2b, blake2b_default;
var init_blake2b = __esm({
- "dist/lib/blake2b.js" () {
- "use strict"
+ "dist/lib/blake2b.js"() {
+ "use strict";
Blake2b = class _Blake2b {
static BYTES_MIN = 1;
static BYTES_MAX = 64;
* Sets v[a,a+1] += v[b,b+1]
* v should be a Uint32Array
*/
- static ADD64AA (v, a, b) {
- var o0 = v[a] + v[b]
- var o1 = v[a + 1] + v[b + 1]
+ static ADD64AA(v, a, b) {
+ var o0 = v[a] + v[b];
+ var o1 = v[a + 1] + v[b + 1];
if (o0 >= 4294967296) {
- o1++
+ o1++;
}
- v[a] = o0
- v[a + 1] = o1
+ v[a] = o0;
+ v[a + 1] = o1;
}
/**
* 64-bit unsigned addition
* Sets v[a,a+1] += b
* b0 is the low 32 bits of b, b1 represents the high 32 bits
*/
- static ADD64AC (v, a, b0, b1) {
- var o0 = v[a] + b0
+ static ADD64AC(v, a, b0, b1) {
+ var o0 = v[a] + b0;
if (b0 < 0) {
- o0 += 4294967296
+ o0 += 4294967296;
}
- var o1 = v[a + 1] + b1
+ var o1 = v[a + 1] + b1;
if (o0 >= 4294967296) {
- o1++
+ o1++;
}
- v[a] = o0
- v[a + 1] = o1
+ v[a] = o0;
+ v[a + 1] = o1;
}
// Little-endian byte access
- static B2B_GET32 (arr, i) {
- return arr[i] ^ arr[i + 1] << 8 ^ arr[i + 2] << 16 ^ arr[i + 3] << 24
+ static B2B_GET32(arr, i) {
+ return arr[i] ^ arr[i + 1] << 8 ^ arr[i + 2] << 16 ^ arr[i + 3] << 24;
}
/**
* G Mixing function
* The ROTRs are inlined for speed
*/
- static B2B_G (a, b, c, d, ix, iy) {
- var x0 = _Blake2b.m[ix]
- var x1 = _Blake2b.m[ix + 1]
- var y0 = _Blake2b.m[iy]
- var y1 = _Blake2b.m[iy + 1]
- _Blake2b.ADD64AA(_Blake2b.v, a, b)
- _Blake2b.ADD64AC(_Blake2b.v, a, x0, x1)
- var xor0 = _Blake2b.v[d] ^ _Blake2b.v[a]
- var xor1 = _Blake2b.v[d + 1] ^ _Blake2b.v[a + 1]
- _Blake2b.v[d] = xor1
- _Blake2b.v[d + 1] = xor0
- _Blake2b.ADD64AA(_Blake2b.v, c, d)
- xor0 = _Blake2b.v[b] ^ _Blake2b.v[c]
- xor1 = _Blake2b.v[b + 1] ^ _Blake2b.v[c + 1]
- _Blake2b.v[b] = xor0 >>> 24 ^ xor1 << 8
- _Blake2b.v[b + 1] = xor1 >>> 24 ^ xor0 << 8
- _Blake2b.ADD64AA(_Blake2b.v, a, b)
- _Blake2b.ADD64AC(_Blake2b.v, a, y0, y1)
- xor0 = _Blake2b.v[d] ^ _Blake2b.v[a]
- xor1 = _Blake2b.v[d + 1] ^ _Blake2b.v[a + 1]
- _Blake2b.v[d] = xor0 >>> 16 ^ xor1 << 16
- _Blake2b.v[d + 1] = xor1 >>> 16 ^ xor0 << 16
- _Blake2b.ADD64AA(_Blake2b.v, c, d)
- xor0 = _Blake2b.v[b] ^ _Blake2b.v[c]
- xor1 = _Blake2b.v[b + 1] ^ _Blake2b.v[c + 1]
- _Blake2b.v[b] = xor1 >>> 31 ^ xor0 << 1
- _Blake2b.v[b + 1] = xor0 >>> 31 ^ xor1 << 1
+ static B2B_G(a, b, c, d, ix, iy) {
+ var x0 = _Blake2b.m[ix];
+ var x1 = _Blake2b.m[ix + 1];
+ var y0 = _Blake2b.m[iy];
+ var y1 = _Blake2b.m[iy + 1];
+ _Blake2b.ADD64AA(_Blake2b.v, a, b);
+ _Blake2b.ADD64AC(_Blake2b.v, a, x0, x1);
+ var xor0 = _Blake2b.v[d] ^ _Blake2b.v[a];
+ var xor1 = _Blake2b.v[d + 1] ^ _Blake2b.v[a + 1];
+ _Blake2b.v[d] = xor1;
+ _Blake2b.v[d + 1] = xor0;
+ _Blake2b.ADD64AA(_Blake2b.v, c, d);
+ xor0 = _Blake2b.v[b] ^ _Blake2b.v[c];
+ xor1 = _Blake2b.v[b + 1] ^ _Blake2b.v[c + 1];
+ _Blake2b.v[b] = xor0 >>> 24 ^ xor1 << 8;
+ _Blake2b.v[b + 1] = xor1 >>> 24 ^ xor0 << 8;
+ _Blake2b.ADD64AA(_Blake2b.v, a, b);
+ _Blake2b.ADD64AC(_Blake2b.v, a, y0, y1);
+ xor0 = _Blake2b.v[d] ^ _Blake2b.v[a];
+ xor1 = _Blake2b.v[d + 1] ^ _Blake2b.v[a + 1];
+ _Blake2b.v[d] = xor0 >>> 16 ^ xor1 << 16;
+ _Blake2b.v[d + 1] = xor1 >>> 16 ^ xor0 << 16;
+ _Blake2b.ADD64AA(_Blake2b.v, c, d);
+ xor0 = _Blake2b.v[b] ^ _Blake2b.v[c];
+ xor1 = _Blake2b.v[b + 1] ^ _Blake2b.v[c + 1];
+ _Blake2b.v[b] = xor1 >>> 31 ^ xor0 << 1;
+ _Blake2b.v[b + 1] = xor0 >>> 31 ^ xor1 << 1;
}
/**
* Compression function. 'last' flag indicates last block.
* Note we're representing 16 uint64s as 32 uint32s
*/
- static blake2bCompress (ctx, last2) {
- let i = 0
+ static blake2bCompress(ctx, last2) {
+ let i = 0;
for (i = 0; i < 16; i++) {
- _Blake2b.v[i] = ctx.h[i]
- _Blake2b.v[i + 16] = _Blake2b.BLAKE2B_IV32[i]
+ _Blake2b.v[i] = ctx.h[i];
+ _Blake2b.v[i + 16] = _Blake2b.BLAKE2B_IV32[i];
}
- _Blake2b.v[24] = _Blake2b.v[24] ^ ctx.t
- _Blake2b.v[25] = _Blake2b.v[25] ^ ctx.t / 4294967296
+ _Blake2b.v[24] = _Blake2b.v[24] ^ ctx.t;
+ _Blake2b.v[25] = _Blake2b.v[25] ^ ctx.t / 4294967296;
if (last2) {
- _Blake2b.v[28] = ~_Blake2b.v[28]
- _Blake2b.v[29] = ~_Blake2b.v[29]
+ _Blake2b.v[28] = ~_Blake2b.v[28];
+ _Blake2b.v[29] = ~_Blake2b.v[29];
}
for (i = 0; i < 32; i++) {
- _Blake2b.m[i] = _Blake2b.B2B_GET32(ctx.b, 4 * i)
+ _Blake2b.m[i] = _Blake2b.B2B_GET32(ctx.b, 4 * i);
}
for (i = 0; i < 12; i++) {
- _Blake2b.B2B_G(0, 8, 16, 24, _Blake2b.SIGMA82[i * 16 + 0], _Blake2b.SIGMA82[i * 16 + 1])
- _Blake2b.B2B_G(2, 10, 18, 26, _Blake2b.SIGMA82[i * 16 + 2], _Blake2b.SIGMA82[i * 16 + 3])
- _Blake2b.B2B_G(4, 12, 20, 28, _Blake2b.SIGMA82[i * 16 + 4], _Blake2b.SIGMA82[i * 16 + 5])
- _Blake2b.B2B_G(6, 14, 22, 30, _Blake2b.SIGMA82[i * 16 + 6], _Blake2b.SIGMA82[i * 16 + 7])
- _Blake2b.B2B_G(0, 10, 20, 30, _Blake2b.SIGMA82[i * 16 + 8], _Blake2b.SIGMA82[i * 16 + 9])
- _Blake2b.B2B_G(2, 12, 22, 24, _Blake2b.SIGMA82[i * 16 + 10], _Blake2b.SIGMA82[i * 16 + 11])
- _Blake2b.B2B_G(4, 14, 16, 26, _Blake2b.SIGMA82[i * 16 + 12], _Blake2b.SIGMA82[i * 16 + 13])
- _Blake2b.B2B_G(6, 8, 18, 28, _Blake2b.SIGMA82[i * 16 + 14], _Blake2b.SIGMA82[i * 16 + 15])
+ _Blake2b.B2B_G(0, 8, 16, 24, _Blake2b.SIGMA82[i * 16 + 0], _Blake2b.SIGMA82[i * 16 + 1]);
+ _Blake2b.B2B_G(2, 10, 18, 26, _Blake2b.SIGMA82[i * 16 + 2], _Blake2b.SIGMA82[i * 16 + 3]);
+ _Blake2b.B2B_G(4, 12, 20, 28, _Blake2b.SIGMA82[i * 16 + 4], _Blake2b.SIGMA82[i * 16 + 5]);
+ _Blake2b.B2B_G(6, 14, 22, 30, _Blake2b.SIGMA82[i * 16 + 6], _Blake2b.SIGMA82[i * 16 + 7]);
+ _Blake2b.B2B_G(0, 10, 20, 30, _Blake2b.SIGMA82[i * 16 + 8], _Blake2b.SIGMA82[i * 16 + 9]);
+ _Blake2b.B2B_G(2, 12, 22, 24, _Blake2b.SIGMA82[i * 16 + 10], _Blake2b.SIGMA82[i * 16 + 11]);
+ _Blake2b.B2B_G(4, 14, 16, 26, _Blake2b.SIGMA82[i * 16 + 12], _Blake2b.SIGMA82[i * 16 + 13]);
+ _Blake2b.B2B_G(6, 8, 18, 28, _Blake2b.SIGMA82[i * 16 + 14], _Blake2b.SIGMA82[i * 16 + 15]);
}
for (i = 0; i < 16; i++) {
- ctx.h[i] = ctx.h[i] ^ _Blake2b.v[i] ^ _Blake2b.v[i + 16]
+ ctx.h[i] = ctx.h[i] ^ _Blake2b.v[i] ^ _Blake2b.v[i + 16];
}
}
/**
* Updates a BLAKE2b streaming hash
* Requires hash context and Uint8Array (byte array)
*/
- static blake2bUpdate (ctx, input) {
+ static blake2bUpdate(ctx, input) {
for (var i = 0; i < input.length; i++) {
if (ctx.c === 128) {
- ctx.t += ctx.c
- _Blake2b.blake2bCompress(ctx, false)
- ctx.c = 0
+ ctx.t += ctx.c;
+ _Blake2b.blake2bCompress(ctx, false);
+ ctx.c = 0;
}
- ctx.b[ctx.c++] = input[i]
+ ctx.b[ctx.c++] = input[i];
}
}
/**
* Completes a BLAKE2b streaming hash
* Returns a Uint8Array containing the message digest
*/
- static blake2bFinal (ctx, out) {
- ctx.t += ctx.c
+ static blake2bFinal(ctx, out) {
+ ctx.t += ctx.c;
while (ctx.c < 128) {
- ctx.b[ctx.c++] = 0
+ ctx.b[ctx.c++] = 0;
}
- _Blake2b.blake2bCompress(ctx, true)
+ _Blake2b.blake2bCompress(ctx, true);
for (var i = 0; i < ctx.outlen; i++) {
- out[i] = ctx.h[i >> 2] >> 8 * (i & 3)
+ out[i] = ctx.h[i >> 2] >> 8 * (i & 3);
}
- return out
+ return out;
}
- static hexSlice (buf) {
- let str = ""
+ static hexSlice(buf) {
+ let str = "";
for (let i = 0; i < buf.length; i++)
- str += _Blake2b.toHex(buf[i])
- return str
+ str += _Blake2b.toHex(buf[i]);
+ return str;
}
- static toHex (n) {
+ static toHex(n) {
if (typeof n !== "number")
- throw new TypeError(`expected number to convert to hex; received ${typeof n}`)
+ throw new TypeError(`expected number to convert to hex; received ${typeof n}`);
if (n < 0 || n > 255)
- throw new RangeError(`expected byte value 0-255; received ${n}`)
- return n.toString(16).padStart(2, "0")
- }
- b
- h
- t
- c
- outlen
+ throw new RangeError(`expected byte value 0-255; received ${n}`);
+ return n.toString(16).padStart(2, "0");
+ }
+ b;
+ h;
+ t;
+ c;
+ outlen;
/**
* Creates a BLAKE2b hashing context
* Requires an output length between 1 and 64 bytes
constructor(outlen, key, salt, personal, noAssert) {
if (noAssert !== true) {
if (outlen < _Blake2b.BYTES_MIN)
- throw new RangeError(`expected outlen >= ${_Blake2b.BYTES_MIN}; actual ${outlen}`)
+ throw new RangeError(`expected outlen >= ${_Blake2b.BYTES_MIN}; actual ${outlen}`);
if (outlen > _Blake2b.BYTES_MAX)
- throw new RangeError(`expectd outlen <= ${_Blake2b.BYTES_MAX}; actual ${outlen}`)
+ throw new RangeError(`expectd outlen <= ${_Blake2b.BYTES_MAX}; actual ${outlen}`);
if (key != null) {
if (!(key instanceof Uint8Array))
- throw new TypeError(`key must be Uint8Array or Buffer`)
+ throw new TypeError(`key must be Uint8Array or Buffer`);
if (key.length < _Blake2b.KEYBYTES_MIN)
- throw new RangeError(`expected key >= ${_Blake2b.KEYBYTES_MIN}; actual ${key.length}`)
+ throw new RangeError(`expected key >= ${_Blake2b.KEYBYTES_MIN}; actual ${key.length}`);
if (key.length > _Blake2b.KEYBYTES_MAX)
- throw new RangeError(`expected key <= ${_Blake2b.KEYBYTES_MAX}; actual ${key.length}`)
+ throw new RangeError(`expected key <= ${_Blake2b.KEYBYTES_MAX}; actual ${key.length}`);
}
if (salt != null) {
if (!(salt instanceof Uint8Array))
- throw new TypeError(`salt must be Uint8Array or Buffer`)
+ throw new TypeError(`salt must be Uint8Array or Buffer`);
if (salt.length !== _Blake2b.SALTBYTES)
- throw new RangeError(`expected salt ${_Blake2b.SALTBYTES} bytes; actual ${salt.length} bytes`)
+ throw new RangeError(`expected salt ${_Blake2b.SALTBYTES} bytes; actual ${salt.length} bytes`);
}
if (personal != null) {
if (!(personal instanceof Uint8Array))
- throw new TypeError(`personal must be Uint8Array or Buffer`)
+ throw new TypeError(`personal must be Uint8Array or Buffer`);
if (personal.length !== _Blake2b.PERSONALBYTES)
- throw new RangeError(`expected personal ${_Blake2b.PERSONALBYTES} bytes; actual ${personal.length} bytes`)
+ throw new RangeError(`expected personal ${_Blake2b.PERSONALBYTES} bytes; actual ${personal.length} bytes`);
}
}
- this.b = new Uint8Array(128)
- this.h = new Uint32Array(16)
- this.t = 0
- this.c = 0
- this.outlen = outlen
- _Blake2b.parameter_block.fill(0)
- _Blake2b.parameter_block[0] = outlen
+ this.b = new Uint8Array(128);
+ this.h = new Uint32Array(16);
+ this.t = 0;
+ this.c = 0;
+ this.outlen = outlen;
+ _Blake2b.parameter_block.fill(0);
+ _Blake2b.parameter_block[0] = outlen;
if (key)
- _Blake2b.parameter_block[1] = key.length
- _Blake2b.parameter_block[2] = 1
- _Blake2b.parameter_block[3] = 1
+ _Blake2b.parameter_block[1] = key.length;
+ _Blake2b.parameter_block[2] = 1;
+ _Blake2b.parameter_block[3] = 1;
if (salt)
- _Blake2b.parameter_block.set(salt, 32)
+ _Blake2b.parameter_block.set(salt, 32);
if (personal)
- _Blake2b.parameter_block.set(personal, 48)
+ _Blake2b.parameter_block.set(personal, 48);
for (var i = 0; i < 16; i++) {
- this.h[i] = _Blake2b.BLAKE2B_IV32[i] ^ _Blake2b.B2B_GET32(_Blake2b.parameter_block, i * 4)
+ this.h[i] = _Blake2b.BLAKE2B_IV32[i] ^ _Blake2b.B2B_GET32(_Blake2b.parameter_block, i * 4);
}
if (key) {
- _Blake2b.blake2bUpdate(this, key)
- this.c = 128
+ _Blake2b.blake2bUpdate(this, key);
+ this.c = 128;
}
}
- update (input) {
+ update(input) {
if (!(input instanceof Uint8Array))
- throw new TypeError(`input must be Uint8Array or Buffer`)
- _Blake2b.blake2bUpdate(this, input)
- return this
+ throw new TypeError(`input must be Uint8Array or Buffer`);
+ _Blake2b.blake2bUpdate(this, input);
+ return this;
}
- digest (out) {
- const buf = !out || out === "binary" || out === "hex" ? new Uint8Array(this.outlen) : out
+ digest(out) {
+ const buf = !out || out === "binary" || out === "hex" ? new Uint8Array(this.outlen) : out;
if (!(buf instanceof Uint8Array))
- throw new TypeError(`out must be "binary", "hex", Uint8Array, or Buffer`)
+ throw new TypeError(`out must be "binary", "hex", Uint8Array, or Buffer`);
if (buf.length < this.outlen)
- throw new RangeError(`out must have at least outlen bytes of space`)
- _Blake2b.blake2bFinal(this, buf)
+ throw new RangeError(`out must have at least outlen bytes of space`);
+ _Blake2b.blake2bFinal(this, buf);
if (out === "hex")
- return _Blake2b.hexSlice(buf)
- return buf
+ return _Blake2b.hexSlice(buf);
+ return buf;
}
- }
- blake2b_default = Blake2b.toString()
+ };
+ blake2b_default = Blake2b.toString();
}
-})
+});
// dist/lib/constants.js
-var ACCOUNT_KEY_LENGTH, ADDRESS_GAP, ALPHABET, BIP39_ITERATIONS, BIP44_PURPOSE, BIP44_COIN_NANO, BURN_ADDRESS, HARDENED_OFFSET, PREAMBLE, PREFIX, PREFIX_LEGACY, SEED_LENGTH_BIP44, SEED_LENGTH_BLAKE2B, THRESHOLD_RECEIVE, THRESHOLD_SEND, LEDGER_STATUS_CODES, UNITS
+var ACCOUNT_KEY_LENGTH, ADDRESS_GAP, ALPHABET, BIP39_ITERATIONS, BIP44_PURPOSE, BIP44_COIN_NANO, BURN_ADDRESS, HARDENED_OFFSET, PREAMBLE, PREFIX, PREFIX_LEGACY, SEED_LENGTH_BIP44, SEED_LENGTH_BLAKE2B, THRESHOLD_RECEIVE, THRESHOLD_SEND, LEDGER_STATUS_CODES, UNITS;
var init_constants = __esm({
- "dist/lib/constants.js" () {
- "use strict"
- ACCOUNT_KEY_LENGTH = 64
- ADDRESS_GAP = 20
- ALPHABET = "13456789abcdefghijkmnopqrstuwxyz"
- BIP39_ITERATIONS = 2048
- BIP44_PURPOSE = 44
- BIP44_COIN_NANO = 165
- BURN_ADDRESS = "nano_1111111111111111111111111111111111111111111111111111hifc8npp"
- HARDENED_OFFSET = 2147483648
- PREAMBLE = "0000000000000000000000000000000000000000000000000000000000000006"
- PREFIX = "nano_"
- PREFIX_LEGACY = "xrb_"
- SEED_LENGTH_BIP44 = 128
- SEED_LENGTH_BLAKE2B = 64
- THRESHOLD_RECEIVE = 4294966784
- THRESHOLD_SEND = 4294967288
+ "dist/lib/constants.js"() {
+ "use strict";
+ ACCOUNT_KEY_LENGTH = 64;
+ ADDRESS_GAP = 20;
+ ALPHABET = "13456789abcdefghijkmnopqrstuwxyz";
+ BIP39_ITERATIONS = 2048;
+ BIP44_PURPOSE = 44;
+ BIP44_COIN_NANO = 165;
+ BURN_ADDRESS = "nano_1111111111111111111111111111111111111111111111111111hifc8npp";
+ HARDENED_OFFSET = 2147483648;
+ PREAMBLE = "0000000000000000000000000000000000000000000000000000000000000006";
+ PREFIX = "nano_";
+ PREFIX_LEGACY = "xrb_";
+ SEED_LENGTH_BIP44 = 128;
+ SEED_LENGTH_BLAKE2B = 64;
+ THRESHOLD_RECEIVE = 4294966784;
+ THRESHOLD_SEND = 4294967288;
LEDGER_STATUS_CODES = Object.freeze({
26368: "INCORRECT_LENGTH",
26378: "NO_APPLICATION_SPECIFIED",
27392: "INCORRECT_PARAMETER",
28161: "TRANSPORT_STATUS_ERROR",
36864: "OK"
- })
+ });
UNITS = Object.freeze({
RAW: 0,
RAI: 24,
NANO: 30,
KNANO: 33,
MNANO: 36
- })
+ });
}
-})
+});
// dist/lib/convert.js
-var base32, bin, buffer, bytes, dec, hex, utf8
+var base32, bin, buffer, bytes, dec, hex, utf8;
var init_convert = __esm({
- "dist/lib/convert.js" () {
- "use strict"
- init_constants()
+ "dist/lib/convert.js"() {
+ "use strict";
+ init_constants();
base32 = {
/**
* Converts a base32 string to a Uint8Array of bytes.
* @param {string} base32 - String to convert
* @returns {Uint8Array} Byte array representation of the input string
*/
- toBytes (base322) {
- const leftover = base322.length * 5 % 8
- const offset = leftover === 0 ? 0 : 8 - leftover
- let bits = 0
- let value = 0
- let index = 0
- let output = new Uint8Array(Math.ceil(base322.length * 5 / 8))
+ toBytes(base322) {
+ const leftover = base322.length * 5 % 8;
+ const offset = leftover === 0 ? 0 : 8 - leftover;
+ let bits = 0;
+ let value = 0;
+ let index = 0;
+ let output = new Uint8Array(Math.ceil(base322.length * 5 / 8));
for (let i = 0; i < base322.length; i++) {
- value = value << 5 | ALPHABET.indexOf(base322[i])
- bits += 5
+ value = value << 5 | ALPHABET.indexOf(base322[i]);
+ bits += 5;
if (bits >= 8) {
- output[index++] = value >>> bits + offset - 8 & 255
- bits -= 8
+ output[index++] = value >>> bits + offset - 8 & 255;
+ bits -= 8;
}
}
if (bits > 0) {
- output[index++] = value << bits + offset - 8 & 255
+ output[index++] = value << bits + offset - 8 & 255;
}
if (leftover !== 0) {
- output = output.slice(1)
+ output = output.slice(1);
}
- return output
+ return output;
},
/**
* Converts a base32 string to a hexadecimal string.
* @param {string} base32 - String to convert
* @returns {string} Hexadecimal representation of the input base32
*/
- toHex (base322) {
- return bytes.toHex(this.toBytes(base322))
+ toHex(base322) {
+ return bytes.toHex(this.toBytes(base322));
}
- }
+ };
bin = {
/**
* Convert a binary string to a Uint8Array of bytes.
* @param {string} bin - String to convert
* @returns {Uint8Array} Byte array representation of the input string
*/
- toBytes (bin2) {
- const bytes2 = []
+ toBytes(bin2) {
+ const bytes2 = [];
while (bin2.length > 0) {
- const bits = bin2.substring(0, 8)
- bytes2.push(parseInt(bits, 2))
- bin2 = bin2.substring(8)
+ const bits = bin2.substring(0, 8);
+ bytes2.push(parseInt(bits, 2));
+ bin2 = bin2.substring(8);
}
- return new Uint8Array(bytes2)
+ return new Uint8Array(bytes2);
},
/**
* Convert a binary string to a hexadecimal string.
* @param {string} bin - String to convert
* @returns {string} Hexadecimal string representation of the input binary
*/
- toHex (bin2) {
- return parseInt(bin2, 2).toString(16)
+ toHex(bin2) {
+ return parseInt(bin2, 2).toString(16);
}
- }
+ };
buffer = {
/**
* Converts an ArrayBuffer to a base32 string.
* @param {ArrayBuffer} buffer - Buffer to convert
* @returns {string} Base32 string representation of the input buffer
*/
- toBase32 (buffer2) {
- return bytes.toBase32(new Uint8Array(buffer2))
+ toBase32(buffer2) {
+ return bytes.toBase32(new Uint8Array(buffer2));
},
/**
* Converts an ArrayBuffer to a binary string.
* @param {ArrayBuffer} buffer - Buffer to convert
* @returns {string} Binary string representation of the input buffer
*/
- toBin (buffer2) {
- return bytes.toBin(new Uint8Array(buffer2))
+ toBin(buffer2) {
+ return bytes.toBin(new Uint8Array(buffer2));
},
/**
* Sums an ArrayBuffer to a decimal integer. If the result is larger than
* @param {ArrayBuffer} buffer - Buffer to convert
* @returns {bigint|number} Decimal sum of the literal buffer values
*/
- toDec (buffer2) {
- return bytes.toDec(new Uint8Array(buffer2))
+ toDec(buffer2) {
+ return bytes.toDec(new Uint8Array(buffer2));
},
/**
* Converts an ArrayBuffer to a hexadecimal string.
* @param {ArrayBuffer} buffer - Buffer to convert
* @returns {string} Hexadecimal string representation of the input buffer
*/
- toHex (buffer2) {
- return bytes.toHex(new Uint8Array(buffer2))
+ toHex(buffer2) {
+ return bytes.toHex(new Uint8Array(buffer2));
},
/**
* Converts an ArrayBuffer to a UTF-8 text string.
* @param {ArrayBuffer} buffer - Buffer to convert
* @returns {string} UTF-8 encoded text string
*/
- toUtf8 (buffer2) {
- return bytes.toUtf8(new Uint8Array(buffer2))
+ toUtf8(buffer2) {
+ return bytes.toUtf8(new Uint8Array(buffer2));
}
- }
+ };
bytes = {
/**
* Converts a Uint8Aarray of bytes to a base32 string.
* @param {Uint8Array} bytes - Byte array to convert
* @returns {string} Base32 string representation of the input bytes
*/
- toBase32 (bytes2) {
- const leftover = bytes2.length * 8 % 5
- const offset = leftover === 0 ? 0 : 5 - leftover
- let value = 0
- let output = ""
- let bits = 0
+ toBase32(bytes2) {
+ const leftover = bytes2.length * 8 % 5;
+ const offset = leftover === 0 ? 0 : 5 - leftover;
+ let value = 0;
+ let output = "";
+ let bits = 0;
for (let i = 0; i < bytes2.length; i++) {
- value = value << 8 | bytes2[i]
- bits += 8
+ value = value << 8 | bytes2[i];
+ bits += 8;
while (bits >= 5) {
- output += ALPHABET[value >>> bits + offset - 5 & 31]
- bits -= 5
+ output += ALPHABET[value >>> bits + offset - 5 & 31];
+ bits -= 5;
}
}
if (bits > 0) {
- output += ALPHABET[value << 5 - (bits + offset) & 31]
+ output += ALPHABET[value << 5 - (bits + offset) & 31];
}
- return output
+ return output;
},
/**
* Convert a Uint8Array of bytes to a binary string.
* @param {Uint8Array} bytes - Byte array to convert
* @returns {string} Binary string representation of the input value
*/
- toBin (bytes2) {
- return [...bytes2].map((b) => b.toString(2).padStart(8, "0")).join("")
+ toBin(bytes2) {
+ return [...bytes2].map((b) => b.toString(2).padStart(8, "0")).join("");
},
/**
* Sums an array of bytes to a decimal integer. If the result is larger than
* @param {Uint8Array} bytes - Byte array to convert
* @returns {bigint|number} Decimal sum of the literal byte values
*/
- toDec (bytes2) {
- const integers = []
- bytes2.reverse().forEach((b) => integers.push(BigInt(b)))
- let decimal = 0n
+ toDec(bytes2) {
+ const integers = [];
+ bytes2.reverse().forEach((b) => integers.push(BigInt(b)));
+ let decimal = 0n;
for (let i = 0; i < integers.length; i++) {
- decimal += integers[i] << BigInt(i * 8)
+ decimal += integers[i] << BigInt(i * 8);
}
if (decimal > 9007199254740991n) {
- return decimal
+ return decimal;
} else {
- return Number(decimal)
+ return Number(decimal);
}
},
/**
* @param {Uint8Array} bytes - Byte array to convert
* @returns {string} Hexadecimal string representation of the input bytes
*/
- toHex (bytes2) {
- const byteArray = [...bytes2].map((byte) => byte.toString(16).padStart(2, "0"))
- return byteArray.join("").toUpperCase()
+ toHex(bytes2) {
+ const byteArray = [...bytes2].map((byte) => byte.toString(16).padStart(2, "0"));
+ return byteArray.join("").toUpperCase();
},
/**
* Converts a Uint8Array of bytes to a UTF-8 text string.
* @param {Uint8Array} bytes - Byte array to convert
* @returns {string} UTF-8 encoded text string
*/
- toUtf8 (bytes2) {
- return new TextDecoder().decode(bytes2)
+ toUtf8(bytes2) {
+ return new TextDecoder().decode(bytes2);
}
- }
+ };
dec = {
/**
* Convert a decimal integer to a binary string.
* @param {number} [padding=0] - Minimum length of the resulting string which will be padded as necessary with starting zeroes
* @returns {string} Binary string representation of the input decimal
*/
- toBin (decimal, padding = 0) {
+ toBin(decimal, padding = 0) {
if (typeof padding !== "number") {
- throw new TypeError("Invalid padding")
+ throw new TypeError("Invalid padding");
}
try {
- return BigInt(decimal).toString(2).padStart(padding, "0")
+ return BigInt(decimal).toString(2).padStart(padding, "0");
} catch (err) {
- throw new RangeError("Invalid decimal integer")
+ throw new RangeError("Invalid decimal integer");
}
},
/**
* @param {number} [padding=0] - Minimum length of the resulting array which will be padded as necessary with starting 0x00 bytes
* @returns {Uint8Array} Byte array representation of the input decimal
*/
- toBytes (decimal, padding = 0) {
+ toBytes(decimal, padding = 0) {
if (typeof padding !== "number") {
- throw new TypeError("Invalid padding")
+ throw new TypeError("Invalid padding");
}
- let integer = BigInt(decimal)
- const bytes2 = []
+ let integer = BigInt(decimal);
+ const bytes2 = [];
while (integer > 0) {
- const lsb = BigInt.asUintN(8, integer)
- bytes2.push(Number(lsb))
- integer >>= 8n
+ const lsb = BigInt.asUintN(8, integer);
+ bytes2.push(Number(lsb));
+ integer >>= 8n;
}
- const result = new Uint8Array(Math.max(padding, bytes2.length))
- result.set(bytes2)
- return result.reverse()
+ const result = new Uint8Array(Math.max(padding, bytes2.length));
+ result.set(bytes2);
+ return result.reverse();
},
/**
* Convert a decimal integer to a hexadecimal string.
* @param {number} [padding=0] - Minimum length of the resulting string which will be padded as necessary with starting zeroes
* @returns {string} Hexadecimal string representation of the input decimal
*/
- toHex (decimal, padding = 0) {
+ toHex(decimal, padding = 0) {
if (typeof padding !== "number") {
- throw new TypeError("Invalid padding")
+ throw new TypeError("Invalid padding");
}
try {
- return BigInt(decimal).toString(16).padStart(padding, "0").toUpperCase()
+ return BigInt(decimal).toString(16).padStart(padding, "0").toUpperCase();
} catch (err) {
- throw new RangeError("Invalid decimal integer")
+ throw new RangeError("Invalid decimal integer");
}
}
- }
+ };
hex = {
/**
* Convert a hexadecimal string to a binary string.
* @param {string} hex - Hexadecimal number string to convert
* @returns {string} Binary string representation of the input value
*/
- toBin (hex2) {
- return [...hex2].map((c) => dec.toBin(parseInt(c, 16), 4)).join("")
+ toBin(hex2) {
+ return [...hex2].map((c) => dec.toBin(parseInt(c, 16), 4)).join("");
},
/**
* Convert a hexadecimal string to a Uint8Array of bytes.
* @param {number} [padding=0] - Minimum length of the resulting array which will be padded as necessary with starting 0x00 bytes
* @returns {Uint8Array} Byte array representation of the input value
*/
- toBytes (hex2, padding = 0) {
+ toBytes(hex2, padding = 0) {
if (typeof padding !== "number") {
- throw new TypeError("Invalid padding when converting hex to bytes")
+ throw new TypeError("Invalid padding when converting hex to bytes");
}
- const hexArray = hex2.match(/.{1,2}/g)
+ const hexArray = hex2.match(/.{1,2}/g);
if (!/^[0-9a-f]+$/i.test(hex2) || hexArray == null) {
- console.warn("Invalid hex string when converting to bytes")
- return new Uint8Array()
+ console.warn("Invalid hex string when converting to bytes");
+ return new Uint8Array();
} else {
- const bytes2 = Uint8Array.from(hexArray.map((byte) => parseInt(byte, 16)))
- const result = new Uint8Array(Math.max(padding, bytes2.length))
- result.set(bytes2.reverse())
- return result.reverse()
+ const bytes2 = Uint8Array.from(hexArray.map((byte) => parseInt(byte, 16)));
+ const result = new Uint8Array(Math.max(padding, bytes2.length));
+ result.set(bytes2.reverse());
+ return result.reverse();
}
}
- }
+ };
utf8 = {
/**
* Convert a UTF-8 text string to a Uint8Array of bytes.
* @param {string} utf8 - String to convert
* @returns {Uint8Array} Byte array representation of the input string
*/
- toBytes (utf82) {
- return new TextEncoder().encode(utf82)
+ toBytes(utf82) {
+ return new TextEncoder().encode(utf82);
},
/**
* Convert a string to a hexadecimal representation
* @param {string} utf8 - String to convert
* @returns {string} Hexadecimal representation of the input string
*/
- toHex (utf82) {
- return bytes.toHex(this.toBytes(utf82))
+ toHex(utf82) {
+ return bytes.toHex(this.toBytes(utf82));
}
- }
+ };
}
-})
+});
// dist/lib/rpc.js
-var Rpc
+var Rpc;
var init_rpc = __esm({
- "dist/lib/rpc.js" () {
- "use strict"
+ "dist/lib/rpc.js"() {
+ "use strict";
Rpc = class {
- #u
- #n
+ #u;
+ #n;
constructor(url, apiKeyName) {
- this.#u = new URL(url)
- this.#u.protocol = "https:"
- this.#n = apiKeyName
+ this.#u = new URL(url);
+ this.#u.protocol = "https:";
+ this.#n = apiKeyName;
}
/**
*
* @param {object} [data] - JSON to send to the node as defined by the action
* @returns {Promise<any>} JSON-formatted RPC results from the node
*/
- async call (action, data) {
- var process3 = process3 || null
- this.#validate(action)
- const headers = {}
- headers["Content-Type"] = "application/json"
+ async call(action, data) {
+ var process3 = process3 || null;
+ this.#validate(action);
+ const headers = {};
+ headers["Content-Type"] = "application/json";
if (this.#n && process3?.env?.LIBNEMO_RPC_API_KEY) {
- headers[this.#n] = process3.env.LIBNEMO_RPC_API_KEY
+ headers[this.#n] = process3.env.LIBNEMO_RPC_API_KEY;
}
- data ??= {}
- data.action = action.toLowerCase()
- const body = JSON.stringify(data).replaceAll("/", "\\u002f").replaceAll("<", "\\u003c").replaceAll(">", "\\u003d").replaceAll("\\", "\\u005c")
+ data ??= {};
+ data.action = action.toLowerCase();
+ const body = JSON.stringify(data).replaceAll("/", "\\u002f").replaceAll("<", "\\u003c").replaceAll(">", "\\u003d").replaceAll("\\", "\\u005c");
const req = new Request(this.#u, {
method: "POST",
headers,
body
- })
+ });
try {
- const res = await fetch(req)
- return await res.json()
+ const res = await fetch(req);
+ return await res.json();
} catch (err) {
- console.error(err)
- return JSON.stringify(err)
+ console.error(err);
+ return JSON.stringify(err);
}
}
- #validate (action) {
+ #validate(action) {
if (!action) {
- throw new ReferenceError("Action is required for RPCs")
+ throw new ReferenceError("Action is required for RPCs");
}
if (typeof action !== "string") {
- throw new TypeError("RPC action must be a string")
+ throw new TypeError("RPC action must be a string");
}
if (!/^[A-Za-z]+(_[A-Za-z]+)*$/.test(action)) {
- throw new TypeError("RPC action contains invalid characters")
+ throw new TypeError("RPC action contains invalid characters");
}
}
- }
+ };
}
-})
+});
// dist/lib/entropy.js
-var crypto2, MIN, MAX, MOD, Entropy
+var crypto2, MIN, MAX, MOD, Entropy;
var init_entropy = __esm({
- "dist/lib/entropy.js" () {
- "use strict"
+ "dist/lib/entropy.js"() {
+ "use strict";
init_convert();
- ({ crypto: crypto2 } = globalThis)
- MIN = 16
- MAX = 32
- MOD = 4
+ ({ crypto: crypto2 } = globalThis);
+ MIN = 16;
+ MAX = 32;
+ MOD = 4;
Entropy = class _Entropy {
static #isInternal = false;
- #bytes
- get bits () {
- return bytes.toBin(this.#bytes)
+ #bytes;
+ get bits() {
+ return bytes.toBin(this.#bytes);
}
- get buffer () {
- return this.#bytes.buffer
+ get buffer() {
+ return this.#bytes.buffer;
}
- get bytes () {
- return this.#bytes
+ get bytes() {
+ return this.#bytes;
}
- get hex () {
- return bytes.toHex(this.#bytes)
+ get hex() {
+ return bytes.toHex(this.#bytes);
}
constructor(bytes2) {
if (!_Entropy.#isInternal) {
- throw new Error(`Entropy cannot be instantiated directly. Use 'await Entropy.create()' instead.`)
+ throw new Error(`Entropy cannot be instantiated directly. Use 'await Entropy.create()' instead.`);
}
- _Entropy.#isInternal = false
- this.#bytes = bytes2
+ _Entropy.#isInternal = false;
+ this.#bytes = bytes2;
}
- static async create (size) {
+ static async create(size) {
return new Promise((resolve) => {
if (size != null) {
if (typeof size !== "number") {
- throw new TypeError(`Entropy cannot use ${typeof size} as a size`)
+ throw new TypeError(`Entropy cannot use ${typeof size} as a size`);
}
if (size < MIN || size > MAX) {
- throw new RangeError(`Entropy must be ${MIN}-${MAX} bytes`)
+ throw new RangeError(`Entropy must be ${MIN}-${MAX} bytes`);
}
if (size % MOD !== 0) {
- throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
+ throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`);
}
}
- _Entropy.#isInternal = true
- resolve(new this(crypto2.getRandomValues(new Uint8Array(size ?? MAX))))
- })
+ _Entropy.#isInternal = true;
+ resolve(new this(crypto2.getRandomValues(new Uint8Array(size ?? MAX))));
+ });
}
- static async import (input) {
+ static async import(input) {
return new Promise((resolve, reject) => {
if (typeof input === "string") {
if (input.length < MIN * 2 || input.length > MAX * 2) {
- throw new RangeError(`Entropy must be ${MIN * 2}-${MAX * 2} characters`)
+ throw new RangeError(`Entropy must be ${MIN * 2}-${MAX * 2} characters`);
}
if (input.length % MOD * 2 !== 0) {
- throw new RangeError(`Entropy must be a multiple of ${MOD * 2} characters`)
+ throw new RangeError(`Entropy must be a multiple of ${MOD * 2} characters`);
}
if (!/^[0-9a-fA-F]+$/i.test(input)) {
- throw new RangeError("Entropy contains invalid hexadecimal characters")
+ throw new RangeError("Entropy contains invalid hexadecimal characters");
}
- _Entropy.#isInternal = true
- resolve(new this(hex.toBytes(input)))
+ _Entropy.#isInternal = true;
+ resolve(new this(hex.toBytes(input)));
}
if (input instanceof ArrayBuffer) {
if (input.byteLength < MIN || input.byteLength > MAX) {
- throw new Error(`Entropy must be ${MIN}-${MAX} bytes`)
+ throw new Error(`Entropy must be ${MIN}-${MAX} bytes`);
}
if (input.byteLength % MOD !== 0) {
- throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
+ throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`);
}
- _Entropy.#isInternal = true
- resolve(new this(new Uint8Array(input)))
+ _Entropy.#isInternal = true;
+ resolve(new this(new Uint8Array(input)));
}
if (input instanceof Uint8Array) {
if (input.length < MIN || input.length > MAX) {
- throw new Error(`Entropy must be ${MIN}-${MAX} bytes`)
+ throw new Error(`Entropy must be ${MIN}-${MAX} bytes`);
}
if (input.length % MOD !== 0) {
- throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`)
+ throw new RangeError(`Entropy must be a multiple of ${MOD} bytes`);
}
- _Entropy.#isInternal = true
- resolve(new this(input))
+ _Entropy.#isInternal = true;
+ resolve(new this(input));
}
- reject(new TypeError(`Entropy cannot import ${typeof input}`))
- })
+ reject(new TypeError(`Entropy cannot import ${typeof input}`));
+ });
}
/**
* Randomizes the bytes, rendering the original values generally inaccessible.
*/
- destroy () {
+ destroy() {
try {
- crypto2.getRandomValues(this.#bytes)
- return true
+ crypto2.getRandomValues(this.#bytes);
+ return true;
} catch (err) {
- return false
+ return false;
}
}
- }
+ };
}
-})
+});
// dist/lib/safe.js
-var subtle, ERR_MSG, Safe
+var subtle, ERR_MSG, Safe;
var init_safe = __esm({
- "dist/lib/safe.js" () {
- "use strict"
- init_convert()
+ "dist/lib/safe.js"() {
+ "use strict";
+ init_convert();
init_entropy();
- ({ subtle } = globalThis.crypto)
- ERR_MSG = "Failed to store item in Safe"
+ ({ subtle } = globalThis.crypto);
+ ERR_MSG = "Failed to store item in Safe";
Safe = class {
- #storage
+ #storage;
constructor() {
- this.#storage = globalThis.sessionStorage
+ this.#storage = globalThis.sessionStorage;
}
- async put (name, passkey, data) {
+ async put(name, passkey, data) {
if (this.#storage.getItem(name)) {
- throw new Error(ERR_MSG)
+ throw new Error(ERR_MSG);
}
- return this.overwrite(name, passkey, data)
+ return this.overwrite(name, passkey, data);
}
- async overwrite (name, passkey, data) {
+ async overwrite(name, passkey, data) {
if (this.#isNotValid(name, passkey, data)) {
- throw new Error(ERR_MSG)
+ throw new Error(ERR_MSG);
}
- const iv = await Entropy.create()
+ const iv = await Entropy.create();
if (typeof passkey === "string") {
try {
- passkey = await subtle.importKey("raw", utf8.toBytes(passkey), "PBKDF2", false, ["deriveBits", "deriveKey"])
- passkey = await subtle.deriveKey({ name: "PBKDF2", hash: "SHA-512", salt: iv.bytes, iterations: 21e4 }, passkey, { name: "AES-GCM", length: 256 }, false, ["encrypt"])
+ passkey = await subtle.importKey("raw", utf8.toBytes(passkey), "PBKDF2", false, ["deriveBits", "deriveKey"]);
+ passkey = await subtle.deriveKey({ name: "PBKDF2", hash: "SHA-512", salt: iv.bytes, iterations: 21e4 }, passkey, { name: "AES-GCM", length: 256 }, false, ["encrypt"]);
} catch (err) {
- throw new Error(ERR_MSG)
+ throw new Error(ERR_MSG);
}
}
try {
if (typeof data === "bigint") {
- data = data.toString()
+ data = data.toString();
}
- data = JSON.stringify(data)
- const encoded = utf8.toBytes(data)
- const encrypted = await subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, passkey, encoded)
+ data = JSON.stringify(data);
+ const encoded = utf8.toBytes(data);
+ const encrypted = await subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, passkey, encoded);
const record = {
encrypted: buffer.toHex(encrypted),
iv: iv.hex
- }
+ };
await new Promise((resolve, reject) => {
try {
- this.#storage.setItem(name, JSON.stringify(record))
- resolve()
+ this.#storage.setItem(name, JSON.stringify(record));
+ resolve();
} catch (err) {
- reject(err)
+ reject(err);
}
- })
- passkey = ""
+ });
+ passkey = "";
} catch (err) {
- throw new Error(ERR_MSG)
+ throw new Error(ERR_MSG);
}
- return this.#storage.getItem(name) != null
+ return this.#storage.getItem(name) != null;
}
- async get (name, passkey) {
+ async get(name, passkey) {
if (this.#isNotValid(name, passkey)) {
- return null
+ return null;
}
const item = await new Promise((resolve) => {
- resolve(this.#storage.getItem(name))
- })
+ resolve(this.#storage.getItem(name));
+ });
if (item == null) {
- return null
+ return null;
}
- const record = JSON.parse(item)
- const encrypted = hex.toBytes(record.encrypted)
- const iv = await Entropy.import(record.iv)
+ const record = JSON.parse(item);
+ const encrypted = hex.toBytes(record.encrypted);
+ const iv = await Entropy.import(record.iv);
try {
if (typeof passkey === "string") {
- passkey = await subtle.importKey("raw", utf8.toBytes(passkey), "PBKDF2", false, ["deriveBits", "deriveKey"])
- passkey = await subtle.deriveKey({ name: "PBKDF2", hash: "SHA-512", salt: iv.bytes, iterations: 21e4 }, passkey, { name: "AES-GCM", length: 256 }, false, ["decrypt"])
+ passkey = await subtle.importKey("raw", utf8.toBytes(passkey), "PBKDF2", false, ["deriveBits", "deriveKey"]);
+ passkey = await subtle.deriveKey({ name: "PBKDF2", hash: "SHA-512", salt: iv.bytes, iterations: 21e4 }, passkey, { name: "AES-GCM", length: 256 }, false, ["decrypt"]);
}
} catch (err) {
- return null
+ return null;
}
try {
- const decrypted = await subtle.decrypt({ name: "AES-GCM", iv: iv.buffer }, passkey, encrypted)
- const decoded = buffer.toUtf8(decrypted)
- const data = JSON.parse(decoded)
- passkey = ""
- this.#storage.removeItem(name)
- return data
+ const decrypted = await subtle.decrypt({ name: "AES-GCM", iv: iv.buffer }, passkey, encrypted);
+ const decoded = buffer.toUtf8(decrypted);
+ const data = JSON.parse(decoded);
+ passkey = "";
+ this.#storage.removeItem(name);
+ return data;
} catch (err) {
- return null
+ return null;
}
}
- #isNotValid (name, passkey, data) {
+ #isNotValid(name, passkey, data) {
if (typeof name !== "string" || name === "") {
- return true
+ return true;
}
if (typeof passkey !== "string" || passkey === "") {
if (!(passkey instanceof CryptoKey)) {
- return true
+ return true;
}
}
if (typeof data === "object") {
try {
- JSON.stringify(data)
+ JSON.stringify(data);
} catch (err) {
- return true
+ return true;
}
}
- return false
+ return false;
}
- }
+ };
}
-})
+});
// dist/lib/pool.js
-var Pool, WorkerInterface
+var Pool, WorkerInterface;
var init_pool = __esm({
- "dist/lib/pool.js" () {
- "use strict"
+ "dist/lib/pool.js"() {
+ "use strict";
Pool = class _Pool {
static #cores = Math.max(1, navigator.hardwareConcurrency - 1);
#queue = [];
#threads = [];
- #url
- get threadsBusy () {
- let n = 0
+ #url;
+ get threadsBusy() {
+ let n = 0;
for (const thread of this.#threads) {
- n += +(thread.job != null)
+ n += +(thread.job != null);
}
- return n
+ return n;
}
- get threadsIdle () {
- let n = 0
+ get threadsIdle() {
+ let n = 0;
for (const thread of this.#threads) {
- n += +(thread.job == null)
+ n += +(thread.job == null);
}
- return n
+ return n;
}
- async assign (data) {
+ async assign(data) {
if (!(data instanceof ArrayBuffer || Array.isArray(data)))
- data = [data]
+ data = [data];
return new Promise((resolve, reject) => {
const job = {
id: performance.now(),
data,
resolve,
reject
- }
+ };
if (this.#queue.length > 0) {
- this.#queue.push(job)
+ this.#queue.push(job);
} else {
for (const thread of this.#threads)
- this.#assign(thread, job)
+ this.#assign(thread, job);
}
- })
+ });
}
/**
*
* @param {number} [count=1] - Integer between 1 and CPU thread count shared among all Pools
*/
constructor(worker, count = 1) {
- count = Math.min(_Pool.#cores, Math.max(1, Math.floor(Math.abs(count))))
- this.#url = URL.createObjectURL(new Blob([worker], { type: "text/javascript" }))
+ count = Math.min(_Pool.#cores, Math.max(1, Math.floor(Math.abs(count))));
+ this.#url = URL.createObjectURL(new Blob([worker], { type: "text/javascript" }));
for (let i = 0; i < count; i++) {
const thread = {
worker: new Worker(this.#url, { type: "module" }),
job: null
- }
+ };
thread.worker.addEventListener("message", (message) => {
- let result = JSON.parse(new TextDecoder().decode(message.data) || "[]")
+ let result = JSON.parse(new TextDecoder().decode(message.data) || "[]");
if (!Array.isArray(result))
- result = [result]
- this.#report(thread, result)
- })
- this.#threads.push(thread)
- _Pool.#cores = Math.max(1, _Pool.#cores - this.#threads.length)
+ result = [result];
+ this.#report(thread, result);
+ });
+ this.#threads.push(thread);
+ _Pool.#cores = Math.max(1, _Pool.#cores - this.#threads.length);
}
}
- #assign (thread, job) {
+ #assign(thread, job) {
if (job.data instanceof ArrayBuffer) {
if (job.data.byteLength > 0) {
- thread.job = job
- thread.worker.postMessage({ buffer: job.data }, [job.data])
+ thread.job = job;
+ thread.worker.postMessage({ buffer: job.data }, [job.data]);
}
} else {
- const chunk = 1 + job.data.length / this.threadsIdle
- const next = job.data.slice(0, chunk)
- job.data = job.data.slice(chunk)
+ const chunk = 1 + job.data.length / this.threadsIdle;
+ const next = job.data.slice(0, chunk);
+ job.data = job.data.slice(chunk);
if (job.data.length === 0)
- this.#queue.shift()
+ this.#queue.shift();
if (next?.length > 0) {
- const buffer2 = new TextEncoder().encode(JSON.stringify(next)).buffer
- thread.job = job
- thread.worker.postMessage({ buffer: buffer2 }, [buffer2])
+ const buffer2 = new TextEncoder().encode(JSON.stringify(next)).buffer;
+ thread.job = job;
+ thread.worker.postMessage({ buffer: buffer2 }, [buffer2]);
}
}
}
- #isJobDone (jobId) {
+ #isJobDone(jobId) {
for (const thread of this.#threads) {
if (thread.job?.id === jobId)
- return false
+ return false;
}
- return true
+ return true;
}
- #report (thread, results) {
+ #report(thread, results) {
if (thread.job == null) {
- throw new Error("Thread returned results but had nowhere to report it.")
+ throw new Error("Thread returned results but had nowhere to report it.");
}
- const job = thread.job
+ const job = thread.job;
if (this.#queue.length > 0) {
- this.#assign(thread, this.#queue[0])
+ this.#assign(thread, this.#queue[0]);
} else {
- thread.job = null
+ thread.job = null;
}
if (results.length > 0) {
- job.results.push(...results)
+ job.results.push(...results);
}
if (this.#isJobDone(job.id)) {
- job.resolve(job.results)
+ job.resolve(job.results);
}
}
- }
+ };
WorkerInterface = class {
/**
* Processes data through a worker.
* @param {any[]} data - Array of data to process
* @returns Promise for that data after being processed
*/
- static async work (data) {
+ static async work(data) {
return new Promise(async (resolve, reject) => {
for (let d of data) {
try {
- d = await d
+ d = await d;
} catch (err) {
- reject(err)
+ reject(err);
}
}
- resolve(data)
- })
+ resolve(data);
+ });
}
/**
* Encodes worker results as an ArrayBuffer so it can be transferred back to
*
* @param {any[]} results - Array of processed data
*/
- static report (results) {
- const buffer2 = new TextEncoder().encode(JSON.stringify(results)).buffer
- postMessage(buffer2, [buffer2])
+ static report(results) {
+ const buffer2 = new TextEncoder().encode(JSON.stringify(results)).buffer;
+ postMessage(buffer2, [buffer2]);
}
/**
* Listens for messages from the main thread.
* }
* ```
*/
- static listen () {
+ static listen() {
addEventListener("message", (message) => {
- const { name, buffer: buffer2 } = message.data
+ const { name, buffer: buffer2 } = message.data;
if (name === "STOP") {
- close()
- const buffer3 = new ArrayBuffer(0)
- postMessage(buffer3, [buffer3])
+ close();
+ const buffer3 = new ArrayBuffer(0);
+ postMessage(buffer3, [buffer3]);
} else {
- const data = JSON.parse(new TextDecoder().decode(buffer2))
- this.work(data).then(this.report)
+ const data = JSON.parse(new TextDecoder().decode(buffer2));
+ this.work(data).then(this.report);
}
- })
+ });
}
- }
+ };
}
-})
+});
// dist/lib/workers/nano-nacl.js
-var NanoNaCl, nano_nacl_default
+var NanoNaCl, nano_nacl_default;
var init_nano_nacl = __esm({
- "dist/lib/workers/nano-nacl.js" () {
- "use strict"
- init_blake2b()
- init_pool()
+ "dist/lib/workers/nano-nacl.js"() {
+ "use strict";
+ init_blake2b();
+ init_pool();
NanoNaCl = class _NanoNaCl extends WorkerInterface {
static {
- _NanoNaCl.listen()
+ _NanoNaCl.listen();
}
- static async work (data) {
+ static async work(data) {
return new Promise(async (resolve, reject) => {
for (let d of data) {
try {
- d.publicKey = await this.convert(d.privateKey)
+ d.publicKey = await this.convert(d.privateKey);
} catch (err) {
- reject(err)
+ reject(err);
}
}
- resolve(data)
- })
+ resolve(data);
+ });
}
- static gf = function (init) {
- const r = new Float64Array(16)
+ static gf = function(init) {
+ const r = new Float64Array(16);
if (init)
for (let i = 0; i < init.length; i++)
- r[i] = init[i]
- return r
+ r[i] = init[i];
+ return r;
};
static gf0 = this.gf();
static gf1 = this.gf([1]);
static X = this.gf([54554, 36645, 11616, 51542, 42930, 38181, 51040, 26924, 56412, 64982, 57905, 49316, 21502, 52590, 14035, 8553]);
static Y = this.gf([26200, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214]);
static I = this.gf([41136, 18958, 6951, 50414, 58488, 44335, 6150, 12099, 55207, 15867, 153, 11085, 57099, 20417, 9344, 11139]);
- static vn (x, xi, y, yi, n) {
- let d = 0
+ static vn(x, xi, y, yi, n) {
+ let d = 0;
for (let i = 0; i < n; i++)
- d |= x[xi + i] ^ y[yi + i]
- return (1 & d - 1 >>> 8) - 1
+ d |= x[xi + i] ^ y[yi + i];
+ return (1 & d - 1 >>> 8) - 1;
}
- static crypto_verify_32 (x, xi, y, yi) {
- return this.vn(x, xi, y, yi, 32)
+ static crypto_verify_32(x, xi, y, yi) {
+ return this.vn(x, xi, y, yi, 32);
}
- static set25519 (r, a) {
+ static set25519(r, a) {
for (let i = 0; i < 16; i++)
- r[i] = a[i] | 0
+ r[i] = a[i] | 0;
}
- static car25519 (o) {
- let v, c = 1
+ static car25519(o) {
+ let v, c = 1;
for (let i = 0; i < 16; i++) {
- v = o[i] + c + 65535
- c = Math.floor(v / 65536)
- o[i] = v - c * 65536
+ v = o[i] + c + 65535;
+ c = Math.floor(v / 65536);
+ o[i] = v - c * 65536;
}
- o[0] += c - 1 + 37 * (c - 1)
+ o[0] += c - 1 + 37 * (c - 1);
}
- static sel25519 (p, q, b) {
- let t
- const c = ~(b - 1)
+ static sel25519(p, q, b) {
+ let t;
+ const c = ~(b - 1);
for (let i = 0; i < 16; i++) {
- t = c & (p[i] ^ q[i])
- p[i] ^= t
- q[i] ^= t
+ t = c & (p[i] ^ q[i]);
+ p[i] ^= t;
+ q[i] ^= t;
}
}
- static pack25519 (o, n) {
- let b
- const m = this.gf()
- const t = this.gf()
+ static pack25519(o, n) {
+ let b;
+ const m = this.gf();
+ const t = this.gf();
for (let i = 0; i < 16; i++)
- t[i] = n[i]
- this.car25519(t)
- this.car25519(t)
- this.car25519(t)
+ t[i] = n[i];
+ this.car25519(t);
+ this.car25519(t);
+ this.car25519(t);
for (let j = 0; j < 2; j++) {
- m[0] = t[0] - 65517
+ m[0] = t[0] - 65517;
for (let i = 1; i < 15; i++) {
- m[i] = t[i] - 65535 - (m[i - 1] >> 16 & 1)
- m[i - 1] &= 65535
+ m[i] = t[i] - 65535 - (m[i - 1] >> 16 & 1);
+ m[i - 1] &= 65535;
}
- m[15] = t[15] - 32767 - (m[14] >> 16 & 1)
- b = m[15] >> 16 & 1
- m[14] &= 65535
- this.sel25519(t, m, 1 - b)
+ m[15] = t[15] - 32767 - (m[14] >> 16 & 1);
+ b = m[15] >> 16 & 1;
+ m[14] &= 65535;
+ this.sel25519(t, m, 1 - b);
}
for (let i = 0; i < 16; i++) {
- o[2 * i] = t[i] & 255
- o[2 * i + 1] = t[i] >> 8
+ o[2 * i] = t[i] & 255;
+ o[2 * i + 1] = t[i] >> 8;
}
}
- static neq25519 (a, b) {
- const c = new Uint8Array(32)
- const d = new Uint8Array(32)
- this.pack25519(c, a)
- this.pack25519(d, b)
- return this.crypto_verify_32(c, 0, d, 0)
+ static neq25519(a, b) {
+ const c = new Uint8Array(32);
+ const d = new Uint8Array(32);
+ this.pack25519(c, a);
+ this.pack25519(d, b);
+ return this.crypto_verify_32(c, 0, d, 0);
}
- static par25519 (a) {
- var d = new Uint8Array(32)
- this.pack25519(d, a)
- return d[0] & 1
+ static par25519(a) {
+ var d = new Uint8Array(32);
+ this.pack25519(d, a);
+ return d[0] & 1;
}
- static unpack25519 (o, n) {
+ static unpack25519(o, n) {
for (let i = 0; i < 16; i++)
- o[i] = n[2 * i] + (n[2 * i + 1] << 8)
- o[15] &= 32767
+ o[i] = n[2 * i] + (n[2 * i + 1] << 8);
+ o[15] &= 32767;
}
- static A (o, a, b) {
+ static A(o, a, b) {
for (let i = 0; i < 16; i++)
- o[i] = a[i] + b[i]
+ o[i] = a[i] + b[i];
}
- static Z (o, a, b) {
+ static Z(o, a, b) {
for (let i = 0; i < 16; i++)
- o[i] = a[i] - b[i]
- }
- static M (o, a, b) {
- let v, c, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7], b8 = b[8], b9 = b[9], b10 = b[10], b11 = b[11], b12 = b[12], b13 = b[13], b14 = b[14], b15 = b[15]
- v = a[0]
- t0 += v * b0
- t1 += v * b1
- t2 += v * b2
- t3 += v * b3
- t4 += v * b4
- t5 += v * b5
- t6 += v * b6
- t7 += v * b7
- t8 += v * b8
- t9 += v * b9
- t10 += v * b10
- t11 += v * b11
- t12 += v * b12
- t13 += v * b13
- t14 += v * b14
- t15 += v * b15
- v = a[1]
- t1 += v * b0
- t2 += v * b1
- t3 += v * b2
- t4 += v * b3
- t5 += v * b4
- t6 += v * b5
- t7 += v * b6
- t8 += v * b7
- t9 += v * b8
- t10 += v * b9
- t11 += v * b10
- t12 += v * b11
- t13 += v * b12
- t14 += v * b13
- t15 += v * b14
- t16 += v * b15
- v = a[2]
- t2 += v * b0
- t3 += v * b1
- t4 += v * b2
- t5 += v * b3
- t6 += v * b4
- t7 += v * b5
- t8 += v * b6
- t9 += v * b7
- t10 += v * b8
- t11 += v * b9
- t12 += v * b10
- t13 += v * b11
- t14 += v * b12
- t15 += v * b13
- t16 += v * b14
- t17 += v * b15
- v = a[3]
- t3 += v * b0
- t4 += v * b1
- t5 += v * b2
- t6 += v * b3
- t7 += v * b4
- t8 += v * b5
- t9 += v * b6
- t10 += v * b7
- t11 += v * b8
- t12 += v * b9
- t13 += v * b10
- t14 += v * b11
- t15 += v * b12
- t16 += v * b13
- t17 += v * b14
- t18 += v * b15
- v = a[4]
- t4 += v * b0
- t5 += v * b1
- t6 += v * b2
- t7 += v * b3
- t8 += v * b4
- t9 += v * b5
- t10 += v * b6
- t11 += v * b7
- t12 += v * b8
- t13 += v * b9
- t14 += v * b10
- t15 += v * b11
- t16 += v * b12
- t17 += v * b13
- t18 += v * b14
- t19 += v * b15
- v = a[5]
- t5 += v * b0
- t6 += v * b1
- t7 += v * b2
- t8 += v * b3
- t9 += v * b4
- t10 += v * b5
- t11 += v * b6
- t12 += v * b7
- t13 += v * b8
- t14 += v * b9
- t15 += v * b10
- t16 += v * b11
- t17 += v * b12
- t18 += v * b13
- t19 += v * b14
- t20 += v * b15
- v = a[6]
- t6 += v * b0
- t7 += v * b1
- t8 += v * b2
- t9 += v * b3
- t10 += v * b4
- t11 += v * b5
- t12 += v * b6
- t13 += v * b7
- t14 += v * b8
- t15 += v * b9
- t16 += v * b10
- t17 += v * b11
- t18 += v * b12
- t19 += v * b13
- t20 += v * b14
- t21 += v * b15
- v = a[7]
- t7 += v * b0
- t8 += v * b1
- t9 += v * b2
- t10 += v * b3
- t11 += v * b4
- t12 += v * b5
- t13 += v * b6
- t14 += v * b7
- t15 += v * b8
- t16 += v * b9
- t17 += v * b10
- t18 += v * b11
- t19 += v * b12
- t20 += v * b13
- t21 += v * b14
- t22 += v * b15
- v = a[8]
- t8 += v * b0
- t9 += v * b1
- t10 += v * b2
- t11 += v * b3
- t12 += v * b4
- t13 += v * b5
- t14 += v * b6
- t15 += v * b7
- t16 += v * b8
- t17 += v * b9
- t18 += v * b10
- t19 += v * b11
- t20 += v * b12
- t21 += v * b13
- t22 += v * b14
- t23 += v * b15
- v = a[9]
- t9 += v * b0
- t10 += v * b1
- t11 += v * b2
- t12 += v * b3
- t13 += v * b4
- t14 += v * b5
- t15 += v * b6
- t16 += v * b7
- t17 += v * b8
- t18 += v * b9
- t19 += v * b10
- t20 += v * b11
- t21 += v * b12
- t22 += v * b13
- t23 += v * b14
- t24 += v * b15
- v = a[10]
- t10 += v * b0
- t11 += v * b1
- t12 += v * b2
- t13 += v * b3
- t14 += v * b4
- t15 += v * b5
- t16 += v * b6
- t17 += v * b7
- t18 += v * b8
- t19 += v * b9
- t20 += v * b10
- t21 += v * b11
- t22 += v * b12
- t23 += v * b13
- t24 += v * b14
- t25 += v * b15
- v = a[11]
- t11 += v * b0
- t12 += v * b1
- t13 += v * b2
- t14 += v * b3
- t15 += v * b4
- t16 += v * b5
- t17 += v * b6
- t18 += v * b7
- t19 += v * b8
- t20 += v * b9
- t21 += v * b10
- t22 += v * b11
- t23 += v * b12
- t24 += v * b13
- t25 += v * b14
- t26 += v * b15
- v = a[12]
- t12 += v * b0
- t13 += v * b1
- t14 += v * b2
- t15 += v * b3
- t16 += v * b4
- t17 += v * b5
- t18 += v * b6
- t19 += v * b7
- t20 += v * b8
- t21 += v * b9
- t22 += v * b10
- t23 += v * b11
- t24 += v * b12
- t25 += v * b13
- t26 += v * b14
- t27 += v * b15
- v = a[13]
- t13 += v * b0
- t14 += v * b1
- t15 += v * b2
- t16 += v * b3
- t17 += v * b4
- t18 += v * b5
- t19 += v * b6
- t20 += v * b7
- t21 += v * b8
- t22 += v * b9
- t23 += v * b10
- t24 += v * b11
- t25 += v * b12
- t26 += v * b13
- t27 += v * b14
- t28 += v * b15
- v = a[14]
- t14 += v * b0
- t15 += v * b1
- t16 += v * b2
- t17 += v * b3
- t18 += v * b4
- t19 += v * b5
- t20 += v * b6
- t21 += v * b7
- t22 += v * b8
- t23 += v * b9
- t24 += v * b10
- t25 += v * b11
- t26 += v * b12
- t27 += v * b13
- t28 += v * b14
- t29 += v * b15
- v = a[15]
- t15 += v * b0
- t16 += v * b1
- t17 += v * b2
- t18 += v * b3
- t19 += v * b4
- t20 += v * b5
- t21 += v * b6
- t22 += v * b7
- t23 += v * b8
- t24 += v * b9
- t25 += v * b10
- t26 += v * b11
- t27 += v * b12
- t28 += v * b13
- t29 += v * b14
- t30 += v * b15
- t0 += 38 * t16
- t1 += 38 * t17
- t2 += 38 * t18
- t3 += 38 * t19
- t4 += 38 * t20
- t5 += 38 * t21
- t6 += 38 * t22
- t7 += 38 * t23
- t8 += 38 * t24
- t9 += 38 * t25
- t10 += 38 * t26
- t11 += 38 * t27
- t12 += 38 * t28
- t13 += 38 * t29
- t14 += 38 * t30
- c = 1
- v = t0 + c + 65535
- c = Math.floor(v / 65536)
- t0 = v - c * 65536
- v = t1 + c + 65535
- c = Math.floor(v / 65536)
- t1 = v - c * 65536
- v = t2 + c + 65535
- c = Math.floor(v / 65536)
- t2 = v - c * 65536
- v = t3 + c + 65535
- c = Math.floor(v / 65536)
- t3 = v - c * 65536
- v = t4 + c + 65535
- c = Math.floor(v / 65536)
- t4 = v - c * 65536
- v = t5 + c + 65535
- c = Math.floor(v / 65536)
- t5 = v - c * 65536
- v = t6 + c + 65535
- c = Math.floor(v / 65536)
- t6 = v - c * 65536
- v = t7 + c + 65535
- c = Math.floor(v / 65536)
- t7 = v - c * 65536
- v = t8 + c + 65535
- c = Math.floor(v / 65536)
- t8 = v - c * 65536
- v = t9 + c + 65535
- c = Math.floor(v / 65536)
- t9 = v - c * 65536
- v = t10 + c + 65535
- c = Math.floor(v / 65536)
- t10 = v - c * 65536
- v = t11 + c + 65535
- c = Math.floor(v / 65536)
- t11 = v - c * 65536
- v = t12 + c + 65535
- c = Math.floor(v / 65536)
- t12 = v - c * 65536
- v = t13 + c + 65535
- c = Math.floor(v / 65536)
- t13 = v - c * 65536
- v = t14 + c + 65535
- c = Math.floor(v / 65536)
- t14 = v - c * 65536
- v = t15 + c + 65535
- c = Math.floor(v / 65536)
- t15 = v - c * 65536
- t0 += c - 1 + 37 * (c - 1)
- c = 1
- v = t0 + c + 65535
- c = Math.floor(v / 65536)
- t0 = v - c * 65536
- v = t1 + c + 65535
- c = Math.floor(v / 65536)
- t1 = v - c * 65536
- v = t2 + c + 65535
- c = Math.floor(v / 65536)
- t2 = v - c * 65536
- v = t3 + c + 65535
- c = Math.floor(v / 65536)
- t3 = v - c * 65536
- v = t4 + c + 65535
- c = Math.floor(v / 65536)
- t4 = v - c * 65536
- v = t5 + c + 65535
- c = Math.floor(v / 65536)
- t5 = v - c * 65536
- v = t6 + c + 65535
- c = Math.floor(v / 65536)
- t6 = v - c * 65536
- v = t7 + c + 65535
- c = Math.floor(v / 65536)
- t7 = v - c * 65536
- v = t8 + c + 65535
- c = Math.floor(v / 65536)
- t8 = v - c * 65536
- v = t9 + c + 65535
- c = Math.floor(v / 65536)
- t9 = v - c * 65536
- v = t10 + c + 65535
- c = Math.floor(v / 65536)
- t10 = v - c * 65536
- v = t11 + c + 65535
- c = Math.floor(v / 65536)
- t11 = v - c * 65536
- v = t12 + c + 65535
- c = Math.floor(v / 65536)
- t12 = v - c * 65536
- v = t13 + c + 65535
- c = Math.floor(v / 65536)
- t13 = v - c * 65536
- v = t14 + c + 65535
- c = Math.floor(v / 65536)
- t14 = v - c * 65536
- v = t15 + c + 65535
- c = Math.floor(v / 65536)
- t15 = v - c * 65536
- t0 += c - 1 + 37 * (c - 1)
- o[0] = t0
- o[1] = t1
- o[2] = t2
- o[3] = t3
- o[4] = t4
- o[5] = t5
- o[6] = t6
- o[7] = t7
- o[8] = t8
- o[9] = t9
- o[10] = t10
- o[11] = t11
- o[12] = t12
- o[13] = t13
- o[14] = t14
- o[15] = t15
- }
- static S (o, a) {
- this.M(o, a, a)
- }
- static inv25519 (o, i) {
- const c = this.gf()
+ o[i] = a[i] - b[i];
+ }
+ static M(o, a, b) {
+ let v, c, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7], b8 = b[8], b9 = b[9], b10 = b[10], b11 = b[11], b12 = b[12], b13 = b[13], b14 = b[14], b15 = b[15];
+ v = a[0];
+ t0 += v * b0;
+ t1 += v * b1;
+ t2 += v * b2;
+ t3 += v * b3;
+ t4 += v * b4;
+ t5 += v * b5;
+ t6 += v * b6;
+ t7 += v * b7;
+ t8 += v * b8;
+ t9 += v * b9;
+ t10 += v * b10;
+ t11 += v * b11;
+ t12 += v * b12;
+ t13 += v * b13;
+ t14 += v * b14;
+ t15 += v * b15;
+ v = a[1];
+ t1 += v * b0;
+ t2 += v * b1;
+ t3 += v * b2;
+ t4 += v * b3;
+ t5 += v * b4;
+ t6 += v * b5;
+ t7 += v * b6;
+ t8 += v * b7;
+ t9 += v * b8;
+ t10 += v * b9;
+ t11 += v * b10;
+ t12 += v * b11;
+ t13 += v * b12;
+ t14 += v * b13;
+ t15 += v * b14;
+ t16 += v * b15;
+ v = a[2];
+ t2 += v * b0;
+ t3 += v * b1;
+ t4 += v * b2;
+ t5 += v * b3;
+ t6 += v * b4;
+ t7 += v * b5;
+ t8 += v * b6;
+ t9 += v * b7;
+ t10 += v * b8;
+ t11 += v * b9;
+ t12 += v * b10;
+ t13 += v * b11;
+ t14 += v * b12;
+ t15 += v * b13;
+ t16 += v * b14;
+ t17 += v * b15;
+ v = a[3];
+ t3 += v * b0;
+ t4 += v * b1;
+ t5 += v * b2;
+ t6 += v * b3;
+ t7 += v * b4;
+ t8 += v * b5;
+ t9 += v * b6;
+ t10 += v * b7;
+ t11 += v * b8;
+ t12 += v * b9;
+ t13 += v * b10;
+ t14 += v * b11;
+ t15 += v * b12;
+ t16 += v * b13;
+ t17 += v * b14;
+ t18 += v * b15;
+ v = a[4];
+ t4 += v * b0;
+ t5 += v * b1;
+ t6 += v * b2;
+ t7 += v * b3;
+ t8 += v * b4;
+ t9 += v * b5;
+ t10 += v * b6;
+ t11 += v * b7;
+ t12 += v * b8;
+ t13 += v * b9;
+ t14 += v * b10;
+ t15 += v * b11;
+ t16 += v * b12;
+ t17 += v * b13;
+ t18 += v * b14;
+ t19 += v * b15;
+ v = a[5];
+ t5 += v * b0;
+ t6 += v * b1;
+ t7 += v * b2;
+ t8 += v * b3;
+ t9 += v * b4;
+ t10 += v * b5;
+ t11 += v * b6;
+ t12 += v * b7;
+ t13 += v * b8;
+ t14 += v * b9;
+ t15 += v * b10;
+ t16 += v * b11;
+ t17 += v * b12;
+ t18 += v * b13;
+ t19 += v * b14;
+ t20 += v * b15;
+ v = a[6];
+ t6 += v * b0;
+ t7 += v * b1;
+ t8 += v * b2;
+ t9 += v * b3;
+ t10 += v * b4;
+ t11 += v * b5;
+ t12 += v * b6;
+ t13 += v * b7;
+ t14 += v * b8;
+ t15 += v * b9;
+ t16 += v * b10;
+ t17 += v * b11;
+ t18 += v * b12;
+ t19 += v * b13;
+ t20 += v * b14;
+ t21 += v * b15;
+ v = a[7];
+ t7 += v * b0;
+ t8 += v * b1;
+ t9 += v * b2;
+ t10 += v * b3;
+ t11 += v * b4;
+ t12 += v * b5;
+ t13 += v * b6;
+ t14 += v * b7;
+ t15 += v * b8;
+ t16 += v * b9;
+ t17 += v * b10;
+ t18 += v * b11;
+ t19 += v * b12;
+ t20 += v * b13;
+ t21 += v * b14;
+ t22 += v * b15;
+ v = a[8];
+ t8 += v * b0;
+ t9 += v * b1;
+ t10 += v * b2;
+ t11 += v * b3;
+ t12 += v * b4;
+ t13 += v * b5;
+ t14 += v * b6;
+ t15 += v * b7;
+ t16 += v * b8;
+ t17 += v * b9;
+ t18 += v * b10;
+ t19 += v * b11;
+ t20 += v * b12;
+ t21 += v * b13;
+ t22 += v * b14;
+ t23 += v * b15;
+ v = a[9];
+ t9 += v * b0;
+ t10 += v * b1;
+ t11 += v * b2;
+ t12 += v * b3;
+ t13 += v * b4;
+ t14 += v * b5;
+ t15 += v * b6;
+ t16 += v * b7;
+ t17 += v * b8;
+ t18 += v * b9;
+ t19 += v * b10;
+ t20 += v * b11;
+ t21 += v * b12;
+ t22 += v * b13;
+ t23 += v * b14;
+ t24 += v * b15;
+ v = a[10];
+ t10 += v * b0;
+ t11 += v * b1;
+ t12 += v * b2;
+ t13 += v * b3;
+ t14 += v * b4;
+ t15 += v * b5;
+ t16 += v * b6;
+ t17 += v * b7;
+ t18 += v * b8;
+ t19 += v * b9;
+ t20 += v * b10;
+ t21 += v * b11;
+ t22 += v * b12;
+ t23 += v * b13;
+ t24 += v * b14;
+ t25 += v * b15;
+ v = a[11];
+ t11 += v * b0;
+ t12 += v * b1;
+ t13 += v * b2;
+ t14 += v * b3;
+ t15 += v * b4;
+ t16 += v * b5;
+ t17 += v * b6;
+ t18 += v * b7;
+ t19 += v * b8;
+ t20 += v * b9;
+ t21 += v * b10;
+ t22 += v * b11;
+ t23 += v * b12;
+ t24 += v * b13;
+ t25 += v * b14;
+ t26 += v * b15;
+ v = a[12];
+ t12 += v * b0;
+ t13 += v * b1;
+ t14 += v * b2;
+ t15 += v * b3;
+ t16 += v * b4;
+ t17 += v * b5;
+ t18 += v * b6;
+ t19 += v * b7;
+ t20 += v * b8;
+ t21 += v * b9;
+ t22 += v * b10;
+ t23 += v * b11;
+ t24 += v * b12;
+ t25 += v * b13;
+ t26 += v * b14;
+ t27 += v * b15;
+ v = a[13];
+ t13 += v * b0;
+ t14 += v * b1;
+ t15 += v * b2;
+ t16 += v * b3;
+ t17 += v * b4;
+ t18 += v * b5;
+ t19 += v * b6;
+ t20 += v * b7;
+ t21 += v * b8;
+ t22 += v * b9;
+ t23 += v * b10;
+ t24 += v * b11;
+ t25 += v * b12;
+ t26 += v * b13;
+ t27 += v * b14;
+ t28 += v * b15;
+ v = a[14];
+ t14 += v * b0;
+ t15 += v * b1;
+ t16 += v * b2;
+ t17 += v * b3;
+ t18 += v * b4;
+ t19 += v * b5;
+ t20 += v * b6;
+ t21 += v * b7;
+ t22 += v * b8;
+ t23 += v * b9;
+ t24 += v * b10;
+ t25 += v * b11;
+ t26 += v * b12;
+ t27 += v * b13;
+ t28 += v * b14;
+ t29 += v * b15;
+ v = a[15];
+ t15 += v * b0;
+ t16 += v * b1;
+ t17 += v * b2;
+ t18 += v * b3;
+ t19 += v * b4;
+ t20 += v * b5;
+ t21 += v * b6;
+ t22 += v * b7;
+ t23 += v * b8;
+ t24 += v * b9;
+ t25 += v * b10;
+ t26 += v * b11;
+ t27 += v * b12;
+ t28 += v * b13;
+ t29 += v * b14;
+ t30 += v * b15;
+ t0 += 38 * t16;
+ t1 += 38 * t17;
+ t2 += 38 * t18;
+ t3 += 38 * t19;
+ t4 += 38 * t20;
+ t5 += 38 * t21;
+ t6 += 38 * t22;
+ t7 += 38 * t23;
+ t8 += 38 * t24;
+ t9 += 38 * t25;
+ t10 += 38 * t26;
+ t11 += 38 * t27;
+ t12 += 38 * t28;
+ t13 += 38 * t29;
+ t14 += 38 * t30;
+ c = 1;
+ v = t0 + c + 65535;
+ c = Math.floor(v / 65536);
+ t0 = v - c * 65536;
+ v = t1 + c + 65535;
+ c = Math.floor(v / 65536);
+ t1 = v - c * 65536;
+ v = t2 + c + 65535;
+ c = Math.floor(v / 65536);
+ t2 = v - c * 65536;
+ v = t3 + c + 65535;
+ c = Math.floor(v / 65536);
+ t3 = v - c * 65536;
+ v = t4 + c + 65535;
+ c = Math.floor(v / 65536);
+ t4 = v - c * 65536;
+ v = t5 + c + 65535;
+ c = Math.floor(v / 65536);
+ t5 = v - c * 65536;
+ v = t6 + c + 65535;
+ c = Math.floor(v / 65536);
+ t6 = v - c * 65536;
+ v = t7 + c + 65535;
+ c = Math.floor(v / 65536);
+ t7 = v - c * 65536;
+ v = t8 + c + 65535;
+ c = Math.floor(v / 65536);
+ t8 = v - c * 65536;
+ v = t9 + c + 65535;
+ c = Math.floor(v / 65536);
+ t9 = v - c * 65536;
+ v = t10 + c + 65535;
+ c = Math.floor(v / 65536);
+ t10 = v - c * 65536;
+ v = t11 + c + 65535;
+ c = Math.floor(v / 65536);
+ t11 = v - c * 65536;
+ v = t12 + c + 65535;
+ c = Math.floor(v / 65536);
+ t12 = v - c * 65536;
+ v = t13 + c + 65535;
+ c = Math.floor(v / 65536);
+ t13 = v - c * 65536;
+ v = t14 + c + 65535;
+ c = Math.floor(v / 65536);
+ t14 = v - c * 65536;
+ v = t15 + c + 65535;
+ c = Math.floor(v / 65536);
+ t15 = v - c * 65536;
+ t0 += c - 1 + 37 * (c - 1);
+ c = 1;
+ v = t0 + c + 65535;
+ c = Math.floor(v / 65536);
+ t0 = v - c * 65536;
+ v = t1 + c + 65535;
+ c = Math.floor(v / 65536);
+ t1 = v - c * 65536;
+ v = t2 + c + 65535;
+ c = Math.floor(v / 65536);
+ t2 = v - c * 65536;
+ v = t3 + c + 65535;
+ c = Math.floor(v / 65536);
+ t3 = v - c * 65536;
+ v = t4 + c + 65535;
+ c = Math.floor(v / 65536);
+ t4 = v - c * 65536;
+ v = t5 + c + 65535;
+ c = Math.floor(v / 65536);
+ t5 = v - c * 65536;
+ v = t6 + c + 65535;
+ c = Math.floor(v / 65536);
+ t6 = v - c * 65536;
+ v = t7 + c + 65535;
+ c = Math.floor(v / 65536);
+ t7 = v - c * 65536;
+ v = t8 + c + 65535;
+ c = Math.floor(v / 65536);
+ t8 = v - c * 65536;
+ v = t9 + c + 65535;
+ c = Math.floor(v / 65536);
+ t9 = v - c * 65536;
+ v = t10 + c + 65535;
+ c = Math.floor(v / 65536);
+ t10 = v - c * 65536;
+ v = t11 + c + 65535;
+ c = Math.floor(v / 65536);
+ t11 = v - c * 65536;
+ v = t12 + c + 65535;
+ c = Math.floor(v / 65536);
+ t12 = v - c * 65536;
+ v = t13 + c + 65535;
+ c = Math.floor(v / 65536);
+ t13 = v - c * 65536;
+ v = t14 + c + 65535;
+ c = Math.floor(v / 65536);
+ t14 = v - c * 65536;
+ v = t15 + c + 65535;
+ c = Math.floor(v / 65536);
+ t15 = v - c * 65536;
+ t0 += c - 1 + 37 * (c - 1);
+ o[0] = t0;
+ o[1] = t1;
+ o[2] = t2;
+ o[3] = t3;
+ o[4] = t4;
+ o[5] = t5;
+ o[6] = t6;
+ o[7] = t7;
+ o[8] = t8;
+ o[9] = t9;
+ o[10] = t10;
+ o[11] = t11;
+ o[12] = t12;
+ o[13] = t13;
+ o[14] = t14;
+ o[15] = t15;
+ }
+ static S(o, a) {
+ this.M(o, a, a);
+ }
+ static inv25519(o, i) {
+ const c = this.gf();
for (let a = 0; a < 16; a++)
- c[a] = i[a]
+ c[a] = i[a];
for (let a = 253; a >= 0; a--) {
- this.S(c, c)
+ this.S(c, c);
if (a !== 2 && a !== 4)
- this.M(c, c, i)
+ this.M(c, c, i);
}
for (let a = 0; a < 16; a++)
- o[a] = c[a]
+ o[a] = c[a];
}
- static pow2523 (o, i) {
- const c = this.gf()
+ static pow2523(o, i) {
+ const c = this.gf();
for (let a = 0; a < 16; a++)
- c[a] = i[a]
+ c[a] = i[a];
for (let a = 250; a >= 0; a--) {
- this.S(c, c)
+ this.S(c, c);
if (a !== 1)
- this.M(c, c, i)
+ this.M(c, c, i);
}
for (let a = 0; a < 16; a++)
- o[a] = c[a]
+ o[a] = c[a];
}
// Note: difference from TweetNaCl - BLAKE2b used to hash instead of SHA-512.
- static crypto_hash (out, m, n) {
- const input = new Uint8Array(n)
+ static crypto_hash(out, m, n) {
+ const input = new Uint8Array(n);
for (let i = 0; i < n; ++i)
- input[i] = m[i]
- const hash2 = new Blake2b(64).update(m).digest()
+ input[i] = m[i];
+ const hash2 = new Blake2b(64).update(m).digest();
for (let i = 0; i < 64; ++i)
- out[i] = hash2[i]
- return 0
- }
- static add (p, q) {
- const a = this.gf()
- const b = this.gf()
- const c = this.gf()
- const d = this.gf()
- const e = this.gf()
- const f = this.gf()
- const g = this.gf()
- const h = this.gf()
- const t = this.gf()
- this.Z(a, p[1], p[0])
- this.Z(t, q[1], q[0])
- this.M(a, a, t)
- this.A(b, p[0], p[1])
- this.A(t, q[0], q[1])
- this.M(b, b, t)
- this.M(c, p[3], q[3])
- this.M(c, c, this.D2)
- this.M(d, p[2], q[2])
- this.A(d, d, d)
- this.Z(e, b, a)
- this.Z(f, d, c)
- this.A(g, d, c)
- this.A(h, b, a)
- this.M(p[0], e, f)
- this.M(p[1], h, g)
- this.M(p[2], g, f)
- this.M(p[3], e, h)
- }
- static cswap (p, q, b) {
+ out[i] = hash2[i];
+ return 0;
+ }
+ static add(p, q) {
+ const a = this.gf();
+ const b = this.gf();
+ const c = this.gf();
+ const d = this.gf();
+ const e = this.gf();
+ const f = this.gf();
+ const g = this.gf();
+ const h = this.gf();
+ const t = this.gf();
+ this.Z(a, p[1], p[0]);
+ this.Z(t, q[1], q[0]);
+ this.M(a, a, t);
+ this.A(b, p[0], p[1]);
+ this.A(t, q[0], q[1]);
+ this.M(b, b, t);
+ this.M(c, p[3], q[3]);
+ this.M(c, c, this.D2);
+ this.M(d, p[2], q[2]);
+ this.A(d, d, d);
+ this.Z(e, b, a);
+ this.Z(f, d, c);
+ this.A(g, d, c);
+ this.A(h, b, a);
+ this.M(p[0], e, f);
+ this.M(p[1], h, g);
+ this.M(p[2], g, f);
+ this.M(p[3], e, h);
+ }
+ static cswap(p, q, b) {
for (let i = 0; i < 4; i++) {
- this.sel25519(p[i], q[i], b)
- }
- }
- static pack (r, p) {
- const tx = this.gf()
- const ty = this.gf()
- const zi = this.gf()
- this.inv25519(zi, p[2])
- this.M(tx, p[0], zi)
- this.M(ty, p[1], zi)
- this.pack25519(r, ty)
- r[31] ^= this.par25519(tx) << 7
- }
- static scalarmult (p, q, s) {
- this.set25519(p[0], this.gf0)
- this.set25519(p[1], this.gf1)
- this.set25519(p[2], this.gf1)
- this.set25519(p[3], this.gf0)
+ this.sel25519(p[i], q[i], b);
+ }
+ }
+ static pack(r, p) {
+ const tx = this.gf();
+ const ty = this.gf();
+ const zi = this.gf();
+ this.inv25519(zi, p[2]);
+ this.M(tx, p[0], zi);
+ this.M(ty, p[1], zi);
+ this.pack25519(r, ty);
+ r[31] ^= this.par25519(tx) << 7;
+ }
+ static scalarmult(p, q, s) {
+ this.set25519(p[0], this.gf0);
+ this.set25519(p[1], this.gf1);
+ this.set25519(p[2], this.gf1);
+ this.set25519(p[3], this.gf0);
for (let i = 255; i >= 0; --i) {
- const b = s[i / 8 | 0] >> (i & 7) & 1
- this.cswap(p, q, b)
- this.add(q, p)
- this.add(p, p)
- this.cswap(p, q, b)
+ const b = s[i / 8 | 0] >> (i & 7) & 1;
+ this.cswap(p, q, b);
+ this.add(q, p);
+ this.add(p, p);
+ this.cswap(p, q, b);
}
}
- static scalarbase (p, s) {
- const q = [this.gf(), this.gf(), this.gf(), this.gf()]
- this.set25519(q[0], this.X)
- this.set25519(q[1], this.Y)
- this.set25519(q[2], this.gf1)
- this.M(q[3], this.X, this.Y)
- this.scalarmult(p, q, s)
+ static scalarbase(p, s) {
+ const q = [this.gf(), this.gf(), this.gf(), this.gf()];
+ this.set25519(q[0], this.X);
+ this.set25519(q[1], this.Y);
+ this.set25519(q[2], this.gf1);
+ this.M(q[3], this.X, this.Y);
+ this.scalarmult(p, q, s);
}
static L = new Float64Array([
237,
0,
16
]);
- static modL (r, x) {
- let carry, i, j, k
+ static modL(r, x) {
+ let carry, i, j, k;
for (i = 63; i >= 32; --i) {
- carry = 0
+ carry = 0;
for (j = i - 32, k = i - 12; j < k; ++j) {
- x[j] += carry - 16 * x[i] * this.L[j - (i - 32)]
- carry = Math.floor((x[j] + 128) / 256)
- x[j] -= carry * 256
+ x[j] += carry - 16 * x[i] * this.L[j - (i - 32)];
+ carry = Math.floor((x[j] + 128) / 256);
+ x[j] -= carry * 256;
}
- x[j] += carry
- x[i] = 0
+ x[j] += carry;
+ x[i] = 0;
}
- carry = 0
+ carry = 0;
for (j = 0; j < 32; j++) {
- x[j] += carry - (x[31] >> 4) * this.L[j]
- carry = x[j] >> 8
- x[j] &= 255
+ x[j] += carry - (x[31] >> 4) * this.L[j];
+ carry = x[j] >> 8;
+ x[j] &= 255;
}
for (j = 0; j < 32; j++)
- x[j] -= carry * this.L[j]
+ x[j] -= carry * this.L[j];
for (i = 0; i < 32; i++) {
- x[i + 1] += x[i] >> 8
- r[i] = x[i] & 255
+ x[i + 1] += x[i] >> 8;
+ r[i] = x[i] & 255;
}
}
- static reduce (r) {
- let x = new Float64Array(64)
+ static reduce(r) {
+ let x = new Float64Array(64);
for (let i = 0; i < 64; i++)
- x[i] = r[i]
+ x[i] = r[i];
for (let i = 0; i < 64; i++)
- r[i] = 0
- this.modL(r, x)
+ r[i] = 0;
+ this.modL(r, x);
}
// Note: difference from C - smlen returned, not passed as argument.
- static crypto_sign (sm, m, n, sk, pk) {
- const d = new Uint8Array(64)
- const h = new Uint8Array(64)
- const r = new Uint8Array(64)
- const x = new Float64Array(64)
- const p = [this.gf(), this.gf(), this.gf(), this.gf()]
- this.crypto_hash(d, sk, 32)
- d[0] &= 248
- d[31] &= 127
- d[31] |= 64
- const smlen = n + 64
+ static crypto_sign(sm, m, n, sk, pk) {
+ const d = new Uint8Array(64);
+ const h = new Uint8Array(64);
+ const r = new Uint8Array(64);
+ const x = new Float64Array(64);
+ const p = [this.gf(), this.gf(), this.gf(), this.gf()];
+ this.crypto_hash(d, sk, 32);
+ d[0] &= 248;
+ d[31] &= 127;
+ d[31] |= 64;
+ const smlen = n + 64;
for (let i = 0; i < n; i++)
- sm[64 + i] = m[i]
+ sm[64 + i] = m[i];
for (let i = 0; i < 32; i++)
- sm[32 + i] = d[32 + i]
- this.crypto_hash(r, sm.subarray(32), n + 32)
- this.reduce(r)
- this.scalarbase(p, r)
- this.pack(sm, p)
+ sm[32 + i] = d[32 + i];
+ this.crypto_hash(r, sm.subarray(32), n + 32);
+ this.reduce(r);
+ this.scalarbase(p, r);
+ this.pack(sm, p);
for (let i = 0; i < 32; i++)
- sm[i + 32] = pk[i]
- this.crypto_hash(h, sm, n + 64)
- this.reduce(h)
+ sm[i + 32] = pk[i];
+ this.crypto_hash(h, sm, n + 64);
+ this.reduce(h);
for (let i = 0; i < 64; i++)
- x[i] = 0
+ x[i] = 0;
for (let i = 0; i < 32; i++)
- x[i] = r[i]
+ x[i] = r[i];
for (let i = 0; i < 32; i++) {
for (let j = 0; j < 32; j++) {
- x[i + j] += h[i] * d[j]
- }
- }
- this.modL(sm.subarray(32), x)
- return smlen
- }
- static unpackneg (r, p) {
- const t = this.gf()
- const chk = this.gf()
- const num = this.gf()
- const den = this.gf()
- const den2 = this.gf()
- const den4 = this.gf()
- const den6 = this.gf()
- this.set25519(r[2], this.gf1)
- this.unpack25519(r[1], p)
- this.S(num, r[1])
- this.M(den, num, this.D)
- this.Z(num, num, r[2])
- this.A(den, r[2], den)
- this.S(den2, den)
- this.S(den4, den2)
- this.M(den6, den4, den2)
- this.M(t, den6, num)
- this.M(t, t, den)
- this.pow2523(t, t)
- this.M(t, t, num)
- this.M(t, t, den)
- this.M(t, t, den)
- this.M(r[0], t, den)
- this.S(chk, r[0])
- this.M(chk, chk, den)
+ x[i + j] += h[i] * d[j];
+ }
+ }
+ this.modL(sm.subarray(32), x);
+ return smlen;
+ }
+ static unpackneg(r, p) {
+ const t = this.gf();
+ const chk = this.gf();
+ const num = this.gf();
+ const den = this.gf();
+ const den2 = this.gf();
+ const den4 = this.gf();
+ const den6 = this.gf();
+ this.set25519(r[2], this.gf1);
+ this.unpack25519(r[1], p);
+ this.S(num, r[1]);
+ this.M(den, num, this.D);
+ this.Z(num, num, r[2]);
+ this.A(den, r[2], den);
+ this.S(den2, den);
+ this.S(den4, den2);
+ this.M(den6, den4, den2);
+ this.M(t, den6, num);
+ this.M(t, t, den);
+ this.pow2523(t, t);
+ this.M(t, t, num);
+ this.M(t, t, den);
+ this.M(t, t, den);
+ this.M(r[0], t, den);
+ this.S(chk, r[0]);
+ this.M(chk, chk, den);
if (this.neq25519(chk, num))
- this.M(r[0], r[0], this.I)
- this.S(chk, r[0])
- this.M(chk, chk, den)
+ this.M(r[0], r[0], this.I);
+ this.S(chk, r[0]);
+ this.M(chk, chk, den);
if (this.neq25519(chk, num))
- return -1
+ return -1;
if (this.par25519(r[0]) === p[31] >> 7)
- this.Z(r[0], this.gf0, r[0])
- this.M(r[3], r[0], r[1])
- return 0
- }
- static crypto_sign_open (m, sm, n, pk) {
- const t = new Uint8Array(32)
- const h = new Uint8Array(64)
- const p = [this.gf(), this.gf(), this.gf(), this.gf()]
- const q = [this.gf(), this.gf(), this.gf(), this.gf()]
+ this.Z(r[0], this.gf0, r[0]);
+ this.M(r[3], r[0], r[1]);
+ return 0;
+ }
+ static crypto_sign_open(m, sm, n, pk) {
+ const t = new Uint8Array(32);
+ const h = new Uint8Array(64);
+ const p = [this.gf(), this.gf(), this.gf(), this.gf()];
+ const q = [this.gf(), this.gf(), this.gf(), this.gf()];
if (n < 64)
- return -1
+ return -1;
if (this.unpackneg(q, pk))
- return -1
+ return -1;
for (let i = 0; i < n; i++)
- m[i] = sm[i]
+ m[i] = sm[i];
for (let i = 0; i < 32; i++)
- m[i + 32] = pk[i]
- this.crypto_hash(h, m, n)
- this.reduce(h)
- this.scalarmult(p, q, h)
- this.scalarbase(q, sm.subarray(32))
- this.add(p, q)
- this.pack(t, p)
- n -= 64
+ m[i + 32] = pk[i];
+ this.crypto_hash(h, m, n);
+ this.reduce(h);
+ this.scalarmult(p, q, h);
+ this.scalarbase(q, sm.subarray(32));
+ this.add(p, q);
+ this.pack(t, p);
+ n -= 64;
if (this.crypto_verify_32(sm, 0, t, 0)) {
for (let i = 0; i < n; i++)
- m[i] = 0
- return -1
+ m[i] = 0;
+ return -1;
}
for (let i = 0; i < n; i++)
- m[i] = sm[i + 64]
- return n
+ m[i] = sm[i + 64];
+ return n;
}
static crypto_sign_BYTES = 64;
static crypto_sign_PUBLICKEYBYTES = 32;
static crypto_sign_SECRETKEYBYTES = 32;
static crypto_sign_SEEDBYTES = 32;
/* High-level API */
- static checkArrayTypes (...args) {
+ static checkArrayTypes(...args) {
for (let i = 0; i < args.length; i++) {
if (!(args[i] instanceof Uint8Array))
- throw new TypeError(`expected Uint8Array; received ${args[i].constructor?.name ?? typeof args[i]}`)
+ throw new TypeError(`expected Uint8Array; received ${args[i].constructor?.name ?? typeof args[i]}`);
}
}
- static parseHex (hex2) {
+ static parseHex(hex2) {
if (hex2.length % 2 === 1)
- hex2 = `0${hex2}`
- const arr = hex2.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16))
- return Uint8Array.from(arr ?? [])
+ hex2 = `0${hex2}`;
+ const arr = hex2.match(/.{1,2}/g)?.map((byte) => parseInt(byte, 16));
+ return Uint8Array.from(arr ?? []);
}
- static hexify (buf) {
- let str = ""
+ static hexify(buf) {
+ let str = "";
for (let i = 0; i < buf.length; i++) {
if (typeof buf[i] !== "number")
- throw new TypeError(`expected number to convert to hex; received ${typeof buf[i]}`)
+ throw new TypeError(`expected number to convert to hex; received ${typeof buf[i]}`);
if (buf[i] < 0 || buf[i] > 255)
- throw new RangeError(`expected byte value 0-255; received ${buf[i]}`)
- str += buf[i].toString(16).padStart(2, "0")
+ throw new RangeError(`expected byte value 0-255; received ${buf[i]}`);
+ str += buf[i].toString(16).padStart(2, "0");
}
- return str
+ return str;
}
- static sign (msg, secretKey) {
- this.checkArrayTypes(msg, secretKey)
+ static sign(msg, secretKey) {
+ this.checkArrayTypes(msg, secretKey);
if (secretKey.length !== this.crypto_sign_SECRETKEYBYTES)
- throw new Error("bad secret key size")
- var signedMsg = new Uint8Array(this.crypto_sign_BYTES + msg.length)
- const publicKey = this.parseHex(this.convert(secretKey))
- this.crypto_sign(signedMsg, msg, msg.length, secretKey, publicKey)
- return signedMsg
- }
- static open (signedMsg, publicKey) {
- this.checkArrayTypes(signedMsg, publicKey)
+ throw new Error("bad secret key size");
+ var signedMsg = new Uint8Array(this.crypto_sign_BYTES + msg.length);
+ const publicKey = this.parseHex(this.convert(secretKey));
+ this.crypto_sign(signedMsg, msg, msg.length, secretKey, publicKey);
+ return signedMsg;
+ }
+ static open(signedMsg, publicKey) {
+ this.checkArrayTypes(signedMsg, publicKey);
if (publicKey.length !== this.crypto_sign_PUBLICKEYBYTES)
- throw new Error("bad public key size")
- const tmp = new Uint8Array(signedMsg.length)
- var mlen = this.crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey)
+ throw new Error("bad public key size");
+ const tmp = new Uint8Array(signedMsg.length);
+ var mlen = this.crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);
if (mlen < 0)
- return new Uint8Array(0)
- var m = new Uint8Array(mlen)
+ return new Uint8Array(0);
+ var m = new Uint8Array(mlen);
for (var i = 0; i < m.length; i++)
- m[i] = tmp[i]
- return m
+ m[i] = tmp[i];
+ return m;
}
- static detached (msg, secretKey) {
- var signedMsg = this.sign(msg, secretKey)
- var sig = new Uint8Array(this.crypto_sign_BYTES)
+ static detached(msg, secretKey) {
+ var signedMsg = this.sign(msg, secretKey);
+ var sig = new Uint8Array(this.crypto_sign_BYTES);
for (var i = 0; i < sig.length; i++)
- sig[i] = signedMsg[i]
- return this.hexify(sig).toUpperCase()
+ sig[i] = signedMsg[i];
+ return this.hexify(sig).toUpperCase();
}
- static verify (msg, sig, publicKey) {
- this.checkArrayTypes(msg, sig, publicKey)
+ static verify(msg, sig, publicKey) {
+ this.checkArrayTypes(msg, sig, publicKey);
if (sig.length !== this.crypto_sign_BYTES)
- throw new Error("bad signature size")
+ throw new Error("bad signature size");
if (publicKey.length !== this.crypto_sign_PUBLICKEYBYTES)
- throw new Error("bad public key size")
- const sm = new Uint8Array(this.crypto_sign_BYTES + msg.length)
- const m = new Uint8Array(this.crypto_sign_BYTES + msg.length)
+ throw new Error("bad public key size");
+ const sm = new Uint8Array(this.crypto_sign_BYTES + msg.length);
+ const m = new Uint8Array(this.crypto_sign_BYTES + msg.length);
for (let i = 0; i < this.crypto_sign_BYTES; i++)
- sm[i] = sig[i]
+ sm[i] = sig[i];
for (let i = 0; i < msg.length; i++)
- sm[i + this.crypto_sign_BYTES] = msg[i]
- return this.crypto_sign_open(m, sm, sm.length, publicKey) >= 0
+ sm[i + this.crypto_sign_BYTES] = msg[i];
+ return this.crypto_sign_open(m, sm, sm.length, publicKey) >= 0;
}
- static convert (seed) {
+ static convert(seed) {
if (typeof seed === "string")
- seed = this.parseHex(seed)
- this.checkArrayTypes(seed)
+ seed = this.parseHex(seed);
+ this.checkArrayTypes(seed);
if (seed.length !== this.crypto_sign_SEEDBYTES)
- throw new Error("bad seed size")
- const pk = new Uint8Array(this.crypto_sign_PUBLICKEYBYTES)
- const p = [this.gf(), this.gf(), this.gf(), this.gf()]
- const hash2 = new Blake2b(64).update(seed).digest()
- hash2[0] &= 248
- hash2[31] &= 127
- hash2[31] |= 64
- this.scalarbase(p, hash2)
- this.pack(pk, p)
- return this.hexify(pk).toUpperCase()
- }
- }
+ throw new Error("bad seed size");
+ const pk = new Uint8Array(this.crypto_sign_PUBLICKEYBYTES);
+ const p = [this.gf(), this.gf(), this.gf(), this.gf()];
+ const hash2 = new Blake2b(64).update(seed).digest();
+ hash2[0] &= 248;
+ hash2[31] &= 127;
+ hash2[31] |= 64;
+ this.scalarbase(p, hash2);
+ this.pack(pk, p);
+ return this.hexify(pk).toUpperCase();
+ }
+ };
nano_nacl_default = `
const Blake2b = ${Blake2b}
const WorkerInterface = ${WorkerInterface}
const NanoNaCl = ${NanoNaCl}
-`
+`;
}
-})
+});
// dist/lib/account.js
-var Account
+var Account;
var init_account = __esm({
- "dist/lib/account.js" () {
- "use strict"
- init_blake2b()
- init_constants()
- init_convert()
- init_rpc()
- init_safe()
- init_nano_nacl()
+ "dist/lib/account.js"() {
+ "use strict";
+ init_blake2b();
+ init_constants();
+ init_convert();
+ init_rpc();
+ init_safe();
+ init_nano_nacl();
Account = class _Account {
static #isInternal = false;
- #a
- #pub
- #prv
- #i
- #f
- #b
- #r
- #rep
- #w
- #s
- get address () {
- return `${PREFIX}${this.#a}`
+ #a;
+ #pub;
+ #prv;
+ #i;
+ #f;
+ #b;
+ #r;
+ #rep;
+ #w;
+ #s;
+ get address() {
+ return `${PREFIX}${this.#a}`;
}
- get publicKey () {
- return this.#pub
+ get publicKey() {
+ return this.#pub;
}
- get privateKey () {
- return this.#prv
+ get privateKey() {
+ return this.#prv;
}
- get index () {
- return this.#i
+ get index() {
+ return this.#i;
}
- get frontier () {
- return this.#f
+ get frontier() {
+ return this.#f;
}
- get balance () {
- return this.#b
+ get balance() {
+ return this.#b;
}
- get receivable () {
- return this.#r
+ get receivable() {
+ return this.#r;
}
- get representative () {
- return this.#rep
+ get representative() {
+ return this.#rep;
}
- get weight () {
- return this.#w
+ get weight() {
+ return this.#w;
}
- set frontier (v) {
- this.#f = v
+ set frontier(v) {
+ this.#f = v;
}
- set balance (v) {
- this.#b = v ? BigInt(v) : void 0
+ set balance(v) {
+ this.#b = v ? BigInt(v) : void 0;
}
- set receivable (v) {
- this.#r = v ? BigInt(v) : void 0
+ set receivable(v) {
+ this.#r = v ? BigInt(v) : void 0;
}
- set representative (v) {
+ set representative(v) {
if (v?.constructor === _Account) {
- this.#rep = v
+ this.#rep = v;
} else if (typeof v === "string") {
- this.#rep = _Account.fromAddress(v)
+ this.#rep = _Account.fromAddress(v);
} else {
- throw new TypeError(`Invalid argument for account representative: ${v}`)
+ throw new TypeError(`Invalid argument for account representative: ${v}`);
}
}
- set weight (v) {
- this.#w = v ? BigInt(v) : void 0
+ set weight(v) {
+ this.#w = v ? BigInt(v) : void 0;
}
constructor(address, publicKey, privateKey, index) {
if (!_Account.#isInternal) {
- throw new Error(`Account cannot be instantiated directly. Use factory methods instead.`)
+ throw new Error(`Account cannot be instantiated directly. Use factory methods instead.`);
}
if (index !== void 0 && typeof index !== "number") {
- throw new TypeError(`Invalid index ${index} when creating Account ${address}`)
+ throw new TypeError(`Invalid index ${index} when creating Account ${address}`);
}
- this.#a = address.replace(PREFIX, "").replace(PREFIX_LEGACY, "")
- this.#pub = publicKey
- this.#prv = privateKey ?? null
- this.#i = index
- this.#s = new Safe()
- _Account.#isInternal = false
+ this.#a = address.replace(PREFIX, "").replace(PREFIX_LEGACY, "");
+ this.#pub = publicKey;
+ this.#prv = privateKey ?? null;
+ this.#i = index;
+ this.#s = new Safe();
+ _Account.#isInternal = false;
}
/**
* Instantiates an Account object from its Nano address.
* @param {number} [index] - Account number used when deriving the address
* @returns {Account} The instantiated Account object
*/
- static fromAddress (address, index) {
- _Account.#isInternal = true
- _Account.validate(address)
- const publicKey = _Account.#addressToKey(address)
- const account = new this(address, publicKey, void 0, index)
- return account
+ static fromAddress(address, index) {
+ _Account.#isInternal = true;
+ _Account.validate(address);
+ const publicKey = _Account.#addressToKey(address);
+ const account = new this(address, publicKey, void 0, index);
+ return account;
}
/**
* Instantiates an Account object from its public key.
* @param {number} [index] - Account number used when deriving the key
* @returns {Account} The instantiated Account object
*/
- static fromPublicKey (publicKey, index) {
- _Account.#isInternal = true
- _Account.#validateKey(publicKey)
- const address = _Account.#keyToAddress(publicKey)
- const account = new this(address, publicKey, void 0, index)
- return account
+ static fromPublicKey(publicKey, index) {
+ _Account.#isInternal = true;
+ _Account.#validateKey(publicKey);
+ const address = _Account.#keyToAddress(publicKey);
+ const account = new this(address, publicKey, void 0, index);
+ return account;
}
/**
* Instantiates an Account object from its private key. The
* @param {number} [index] - Account number used when deriving the key
* @returns {Account} A new Account object
*/
- static fromPrivateKey (privateKey, index) {
- _Account.#isInternal = true
- _Account.#validateKey(privateKey)
- const publicKey = NanoNaCl.convert(privateKey)
- const account = _Account.fromPublicKey(publicKey, index)
- account.#prv = privateKey.toUpperCase()
- return account
+ static fromPrivateKey(privateKey, index) {
+ _Account.#isInternal = true;
+ _Account.#validateKey(privateKey);
+ const publicKey = NanoNaCl.convert(privateKey);
+ const account = _Account.fromPublicKey(publicKey, index);
+ account.#prv = privateKey.toUpperCase();
+ return account;
}
/**
* Instantiates an Account object from its public and private
* @param {number} [index] - Account number used when deriving the key
* @returns {Account} The instantiated Account object
*/
- static fromKeypair (privateKey, publicKey, index) {
- _Account.#isInternal = true
- _Account.#validateKey(privateKey)
- const account = _Account.fromPublicKey(publicKey, index)
- account.#prv = privateKey.toUpperCase()
- return account
- }
- async lock (passkey) {
+ static fromKeypair(privateKey, publicKey, index) {
+ _Account.#isInternal = true;
+ _Account.#validateKey(privateKey);
+ const account = _Account.fromPublicKey(publicKey, index);
+ account.#prv = privateKey.toUpperCase();
+ return account;
+ }
+ async lock(passkey) {
try {
if (this.#prv != null) {
- await this.#s.put(this.#pub, passkey, this.#prv)
+ await this.#s.put(this.#pub, passkey, this.#prv);
}
} catch (err) {
- console.error(`Failed to lock account ${this.address}`, err)
- return false
+ console.error(`Failed to lock account ${this.address}`, err);
+ return false;
}
- this.#prv = null
- return true
+ this.#prv = null;
+ return true;
}
- async unlock (passkey) {
+ async unlock(passkey) {
try {
- this.#prv = await this.#s.get(this.#pub, passkey)
+ this.#prv = await this.#s.get(this.#pub, passkey);
} catch (err) {
- console.error(`Failed to unlock account ${this.address}`, err)
- return false
+ console.error(`Failed to unlock account ${this.address}`, err);
+ return false;
}
- return true
+ return true;
}
/**
* Validates a Nano address with 'nano' and 'xrb' prefixes
* @param {string} address - Nano address to validate
* @throws Error if address is undefined, not a string, or an invalid format
*/
- static validate (address) {
+ static validate(address) {
if (address === void 0) {
- throw new ReferenceError("Address is undefined.")
+ throw new ReferenceError("Address is undefined.");
}
if (typeof address !== "string") {
- throw new TypeError("Address must be a string.")
+ throw new TypeError("Address must be a string.");
}
- const pattern = new RegExp(`^(${PREFIX}|${PREFIX_LEGACY})[13]{1}[${ALPHABET}]{59}$`)
+ const pattern = new RegExp(`^(${PREFIX}|${PREFIX_LEGACY})[13]{1}[${ALPHABET}]{59}$`);
if (!pattern.test(address)) {
- throw new RangeError("Invalid address format")
- }
- const expectedChecksum = address.slice(-8)
- const keyBase32 = address.slice(address.indexOf("_") + 1, -8)
- const keyBuf = base32.toBytes(keyBase32)
- const actualChecksumBuf = new Blake2b(5).update(keyBuf).digest()
- actualChecksumBuf.reverse()
- const actualChecksum = bytes.toBase32(actualChecksumBuf)
+ throw new RangeError("Invalid address format");
+ }
+ const expectedChecksum = address.slice(-8);
+ const keyBase32 = address.slice(address.indexOf("_") + 1, -8);
+ const keyBuf = base32.toBytes(keyBase32);
+ const actualChecksumBuf = new Blake2b(5).update(keyBuf).digest();
+ actualChecksumBuf.reverse();
+ const actualChecksum = bytes.toBase32(actualChecksumBuf);
if (expectedChecksum !== actualChecksum) {
- throw new Error("Incorrect address checksum")
+ throw new Error("Incorrect address checksum");
}
}
/**
*
* @param {Rpc|string|URL} rpc - RPC node information required to call `account_info`
*/
- async refresh (rpc) {
+ async refresh(rpc) {
if (typeof rpc === "string" || rpc.constructor === URL) {
- rpc = new Rpc(rpc)
+ rpc = new Rpc(rpc);
}
if (rpc.constructor !== Rpc) {
- throw new TypeError("RPC must be a valid node")
+ throw new TypeError("RPC must be a valid node");
}
const data = {
"account": this.address,
"receivable": "true",
"representative": "true",
"weight": "true"
- }
- const { balance, frontier, receivable, representative, weight } = await rpc.call("account_info", data)
+ };
+ const { balance, frontier, receivable, representative, weight } = await rpc.call("account_info", data);
if (frontier == null) {
- throw new Error("Account not found")
- }
- this.#b = BigInt(balance)
- this.#f = frontier
- this.#r = BigInt(receivable)
- this.#rep = _Account.fromAddress(representative)
- this.#w = BigInt(weight)
- }
- static #addressToKey (v) {
- const publicKeyBytes = base32.toBytes(v.slice(-60, -8))
- const checksumBytes = base32.toBytes(v.slice(-8))
- const rechecksumBytes = new Blake2b(5).update(publicKeyBytes).digest().reverse()
+ throw new Error("Account not found");
+ }
+ this.#b = BigInt(balance);
+ this.#f = frontier;
+ this.#r = BigInt(receivable);
+ this.#rep = _Account.fromAddress(representative);
+ this.#w = BigInt(weight);
+ }
+ static #addressToKey(v) {
+ const publicKeyBytes = base32.toBytes(v.slice(-60, -8));
+ const checksumBytes = base32.toBytes(v.slice(-8));
+ const rechecksumBytes = new Blake2b(5).update(publicKeyBytes).digest().reverse();
if (bytes.toHex(checksumBytes) !== bytes.toHex(rechecksumBytes)) {
- throw new Error("Checksum mismatch in address")
+ throw new Error("Checksum mismatch in address");
}
- return bytes.toHex(publicKeyBytes)
+ return bytes.toHex(publicKeyBytes);
}
- static #keyToAddress (publicKey) {
- const publicKeyBytes = hex.toBytes(publicKey)
- const checksumBytes = new Blake2b(5).update(publicKeyBytes).digest().reverse()
- const encodedPublicKey = bytes.toBase32(publicKeyBytes)
- const encodedChecksum = bytes.toBase32(checksumBytes)
- return `${PREFIX}${encodedPublicKey}${encodedChecksum}`
+ static #keyToAddress(publicKey) {
+ const publicKeyBytes = hex.toBytes(publicKey);
+ const checksumBytes = new Blake2b(5).update(publicKeyBytes).digest().reverse();
+ const encodedPublicKey = bytes.toBase32(publicKeyBytes);
+ const encodedChecksum = bytes.toBase32(checksumBytes);
+ return `${PREFIX}${encodedPublicKey}${encodedChecksum}`;
}
- static #validateKey (key) {
+ static #validateKey(key) {
if (key === void 0) {
- throw new TypeError(`Key is undefined`)
+ throw new TypeError(`Key is undefined`);
}
if (typeof key !== "string") {
- throw new TypeError(`Key must be a string`)
+ throw new TypeError(`Key must be a string`);
}
if (key.length !== ACCOUNT_KEY_LENGTH) {
- throw new TypeError(`Key must be ${ACCOUNT_KEY_LENGTH} characters`)
+ throw new TypeError(`Key must be ${ACCOUNT_KEY_LENGTH} characters`);
}
if (!/^[0-9a-fA-F]+$/i.test(key)) {
- throw new RangeError("Key is not a valid hexadecimal value")
+ throw new RangeError("Key is not a valid hexadecimal value");
}
}
- }
+ };
}
-})
+});
// dist/lib/workers/bip44-ckd.js
-var Bip44Ckd, bip44_ckd_default
+var Bip44Ckd, bip44_ckd_default;
var init_bip44_ckd = __esm({
- "dist/lib/workers/bip44-ckd.js" () {
- "use strict"
- init_pool()
+ "dist/lib/workers/bip44-ckd.js"() {
+ "use strict";
+ init_pool();
Bip44Ckd = class _Bip44Ckd extends WorkerInterface {
static BIP44_COIN_NANO = 165;
static BIP44_PURPOSE = 44;
static HARDENED_OFFSET = 2147483648;
static SLIP10_ED25519 = "ed25519 seed";
static {
- _Bip44Ckd.listen()
+ _Bip44Ckd.listen();
}
- static async work (data) {
+ static async work(data) {
for (const d of data) {
if (d.coin != null && d.coin !== this.BIP44_PURPOSE) {
- d.privateKey = await this.ckd(d.seed, d.coin, d.index)
+ d.privateKey = await this.ckd(d.seed, d.coin, d.index);
} else {
- d.privateKey = await this.nanoCKD(d.seed, d.index)
+ d.privateKey = await this.nanoCKD(d.seed, d.index);
}
}
- return data
+ return data;
}
/**
* Derives a private child key following the BIP-32 and BIP-44 derivation path
* @param {number} index - Account number between 0 and 2^31-1
* @returns {Promise<string>} Private child key for the account
*/
- static async nanoCKD (seed, index) {
+ static async nanoCKD(seed, index) {
if (!Number.isSafeInteger(index) || index < 0 || index > 2147483647) {
- throw new RangeError(`Invalid child key index 0x${index.toString(16)}`)
+ throw new RangeError(`Invalid child key index 0x${index.toString(16)}`);
}
- return await this.ckd(seed, this.BIP44_COIN_NANO, index)
+ return await this.ckd(seed, this.BIP44_COIN_NANO, index);
}
/**
* Derives a private child key for a coin by following the specified BIP-32 and
* @param {number} index - Account number between 0 and 2^31-1
* @returns {Promise<string>} Private child key for the account
*/
- static async ckd (seed, coin, index) {
+ static async ckd(seed, coin, index) {
if (seed.length < 32 || seed.length > 128) {
- throw new RangeError(`Invalid seed length`)
+ throw new RangeError(`Invalid seed length`);
}
if (!Number.isSafeInteger(index) || index < 0 || index > 2147483647) {
- throw new RangeError(`Invalid child key index 0x${index.toString(16)}`)
- }
- const masterKey = await this.slip10(this.SLIP10_ED25519, seed)
- const purposeKey = await this.CKDpriv(masterKey, this.BIP44_PURPOSE + this.HARDENED_OFFSET)
- const coinKey = await this.CKDpriv(purposeKey, coin + this.HARDENED_OFFSET)
- const accountKey = await this.CKDpriv(coinKey, index + this.HARDENED_OFFSET)
- const privateKey = new Uint8Array(accountKey.privateKey.buffer)
- let hex2 = ""
+ throw new RangeError(`Invalid child key index 0x${index.toString(16)}`);
+ }
+ const masterKey = await this.slip10(this.SLIP10_ED25519, seed);
+ const purposeKey = await this.CKDpriv(masterKey, this.BIP44_PURPOSE + this.HARDENED_OFFSET);
+ const coinKey = await this.CKDpriv(purposeKey, coin + this.HARDENED_OFFSET);
+ const accountKey = await this.CKDpriv(coinKey, index + this.HARDENED_OFFSET);
+ const privateKey = new Uint8Array(accountKey.privateKey.buffer);
+ let hex2 = "";
for (let i = 0; i < privateKey.length; i++) {
- hex2 += privateKey[i].toString(16).padStart(2, "0")
- }
- return hex2
- }
- static async slip10 (curve, S) {
- const key = new TextEncoder().encode(curve)
- const data = new Uint8Array(64)
- data.set(S.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)))
- const I = await this.hmac(key, data)
- const IL = new DataView(I.buffer.slice(0, I.length / 2))
- const IR = new DataView(I.buffer.slice(I.length / 2))
- return { privateKey: IL, chainCode: IR }
- }
- static async CKDpriv ({ privateKey, chainCode }, index) {
- const key = new Uint8Array(chainCode.buffer)
- const data = new Uint8Array(37)
- data.set([0])
- data.set(this.ser256(privateKey), 1)
- data.set(this.ser32(index), 33)
- const I = await this.hmac(key, data)
- const IL = new DataView(I.buffer.slice(0, I.length / 2))
- const IR = new DataView(I.buffer.slice(I.length / 2))
- return { privateKey: IL, chainCode: IR }
- }
- static ser32 (integer) {
+ hex2 += privateKey[i].toString(16).padStart(2, "0");
+ }
+ return hex2;
+ }
+ static async slip10(curve, S) {
+ const key = new TextEncoder().encode(curve);
+ const data = new Uint8Array(64);
+ data.set(S.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+ const I = await this.hmac(key, data);
+ const IL = new DataView(I.buffer.slice(0, I.length / 2));
+ const IR = new DataView(I.buffer.slice(I.length / 2));
+ return { privateKey: IL, chainCode: IR };
+ }
+ static async CKDpriv({ privateKey, chainCode }, index) {
+ const key = new Uint8Array(chainCode.buffer);
+ const data = new Uint8Array(37);
+ data.set([0]);
+ data.set(this.ser256(privateKey), 1);
+ data.set(this.ser32(index), 33);
+ const I = await this.hmac(key, data);
+ const IL = new DataView(I.buffer.slice(0, I.length / 2));
+ const IR = new DataView(I.buffer.slice(I.length / 2));
+ return { privateKey: IL, chainCode: IR };
+ }
+ static ser32(integer) {
if (typeof integer !== "number") {
- throw new TypeError(`Expected a number, received ${typeof integer}`)
+ throw new TypeError(`Expected a number, received ${typeof integer}`);
}
if (integer > 4294967295) {
- throw new RangeError(`Expected 32-bit integer, received ${integer.toString(2).length}-bit value: ${integer}`)
+ throw new RangeError(`Expected 32-bit integer, received ${integer.toString(2).length}-bit value: ${integer}`);
}
- const view = new DataView(new ArrayBuffer(4))
- view.setUint32(0, integer, false)
- return new Uint8Array(view.buffer)
+ const view = new DataView(new ArrayBuffer(4));
+ view.setUint32(0, integer, false);
+ return new Uint8Array(view.buffer);
}
- static ser256 (integer) {
+ static ser256(integer) {
if (integer.constructor !== DataView) {
- throw new TypeError(`Expected DataView, received ${typeof integer}`)
+ throw new TypeError(`Expected DataView, received ${typeof integer}`);
}
if (integer.byteLength > 32) {
- throw new RangeError(`Expected 32-byte integer, received ${integer.byteLength}-byte value: ${integer}`)
+ throw new RangeError(`Expected 32-byte integer, received ${integer.byteLength}-byte value: ${integer}`);
}
- return new Uint8Array(integer.buffer)
+ return new Uint8Array(integer.buffer);
}
- static async hmac (key, data) {
- const { subtle: subtle3 } = globalThis.crypto
- const pk = await subtle3.importKey("raw", key, { name: "HMAC", hash: "SHA-512" }, false, ["sign"])
- const signature = await subtle3.sign("HMAC", pk, data)
- return new Uint8Array(signature)
+ static async hmac(key, data) {
+ const { subtle: subtle3 } = globalThis.crypto;
+ const pk = await subtle3.importKey("raw", key, { name: "HMAC", hash: "SHA-512" }, false, ["sign"]);
+ const signature = await subtle3.sign("HMAC", pk, data);
+ return new Uint8Array(signature);
}
- }
+ };
bip44_ckd_default = `
const WorkerInterface = ${WorkerInterface}
const Bip44Ckd = ${Bip44Ckd}
-`
+`;
}
-})
+});
// dist/lib/workers/powgl.js
-var Pow, powgl_default
+var PowGl, powgl_default;
var init_powgl = __esm({
- "dist/lib/workers/powgl.js" () {
- "use strict"
- init_pool()
- Pow = class _Pow extends WorkerInterface {
+ "dist/lib/workers/powgl.js"() {
+ "use strict";
+ init_pool();
+ PowGl = class _PowGl extends WorkerInterface {
static {
- _Pow.listen()
+ _PowGl.listen();
}
/**
* Calculates proof-of-work as described by the Nano cryptocurrency protocol.
* @param {any[]} data - Array of hashes and minimum thresholds
* @returns Promise for proof-of-work attached to original array objects
*/
- static async work (data) {
+ static async work(data) {
return new Promise(async (resolve, reject) => {
for (const d of data) {
try {
- d.work = await this.find(d.hash, d.threshold)
+ d.work = await this.search(d.hash, d.threshold);
} catch (err) {
- reject(err)
+ reject(err);
}
}
- resolve(data)
- })
- }
- /**
- * Finds a nonce that satisfies the Nano proof-of-work requirements.
- *
- * @param {string} hashHex - Hexadecimal hash of previous block, or public key for new accounts
- * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
- */
- static async find (hash2, threshold = 4294967288) {
- return new Promise((resolve) => {
- this.#calculate(hash2, resolve, threshold)
- })
+ resolve(data);
+ });
}
// Vertex Shader
static #vsSource = `#version 300 es
28u,20u,8u,16u,18u,30u,26u,12u,2u,24u,0u,4u,22u,14u,10u,6u
);
-// 64-bit unsigned addition within the compression buffer
-// Sets v[a,a+1] += b
-// b0 is the low 32 bits of b, b1 represents the high 32 bits
-void add_uint64 (uint a, uint b0, uint b1) {
- uint o0 = v[a] + b0;
- uint o1 = v[a+1u] + b1;
- if (v[a] > 0xFFFFFFFFu - b0) { // did low 32 bits overflow?
- o1++;
+// G mixing function
+void G (uint ix, uint iy, uint a, uint b, uint c, uint d) {
+ uint o0;
+ uint o1;
+ uint xor0;
+ uint xor1;
+
+ // a = a + b;
+ o0 = v[a] + v[b];
+ o1 = v[a+1u] + v[b+1u];
+ if (v[a] > 0xFFFFFFFFu - v[b]) {
+ o1 = o1 + 1u;
}
v[a] = o0;
v[a+1u] = o1;
-}
-// G Mixing function
-void B2B_G (uint a, uint b, uint c, uint d, uint ix, uint iy) {
- add_uint64(a, v[b], v[b+1u]);
- add_uint64(a, m[ix], m[ix+1u]);
+ // a = a + m[sigma[r][2*i+0]];
+ o0 = v[a] + m[ix];
+ o1 = v[a+1u] + m[ix+1u];
+ if (v[a] > 0xFFFFFFFFu - m[ix]) {
+ o1 = o1 + 1u;
+ }
+ v[a] = o0;
+ v[a+1u] = o1;
- // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
- uint xor0 = v[d] ^ v[a];
- uint xor1 = v[d+1u] ^ v[a+1u];
+ // d = rotr64(d ^ a, 32);
+ xor0 = v[d] ^ v[a];
+ xor1 = v[d+1u] ^ v[a+1u];
v[d] = xor1;
v[d+1u] = xor0;
- add_uint64(c, v[d], v[d+1u]);
+ // c = c + d;
+ o0 = v[c] + v[d];
+ o1 = v[c+1u] + v[d+1u];
+ if (v[c] > 0xFFFFFFFFu - v[d]) {
+ o1 = o1 + 1u;
+ }
+ v[c] = o0;
+ v[c+1u] = o1;
- // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
+ // b = rotr64(b ^ c, 24);
xor0 = v[b] ^ v[c];
xor1 = v[b+1u] ^ v[c+1u];
v[b] = (xor0 >> 24u) ^ (xor1 << 8u);
v[b+1u] = (xor1 >> 24u) ^ (xor0 << 8u);
- add_uint64(a, v[b], v[b+1u]);
- add_uint64(a, m[iy], m[iy+1u]);
+ // a = a + b;
+ o0 = v[a] + v[b];
+ o1 = v[a+1u] + v[b+1u];
+ if (v[a] > 0xFFFFFFFFu - v[b]) {
+ o1 = o1 + 1u;
+ }
+ v[a] = o0;
+ v[a+1u] = o1;
- // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
+ // a = a + m[sigma[r][2*i+1]];
+ o0 = v[a] + m[iy];
+ o1 = v[a+1u] + m[iy+1u];
+ if (v[a] > 0xFFFFFFFFu - m[iy]) {
+ o1 = o1 + 1u;
+ }
+ v[a] = o0;
+ v[a+1u] = o1;
+
+ // d = rotr64(d ^ a, 16)
xor0 = v[d] ^ v[a];
xor1 = v[d+1u] ^ v[a+1u];
v[d] = (xor0 >> 16u) ^ (xor1 << 16u);
v[d+1u] = (xor1 >> 16u) ^ (xor0 << 16u);
- add_uint64(c, v[d], v[d+1u]);
+ // c = c + d;
+ o0 = v[c] + v[d];
+ o1 = v[c+1u] + v[d+1u];
+ if (v[c] > 0xFFFFFFFFu - v[d]) {
+ o1 = o1 + 1u;
+ }
+ v[c] = o0;
+ v[c+1u] = o1;
- // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
+ // b = rotr64(b ^ c, 63)
xor0 = v[b] ^ v[c];
xor1 = v[b+1u] ^ v[c+1u];
v[b] = (xor1 >> 31u) ^ (xor0 << 1u);
// twelve rounds of mixing
for(uint i = 0u; i < 12u; i = i + 1u) {
- B2B_G(0u, 8u, 16u, 24u, SIGMA82[i * 16u + 0u], SIGMA82[i * 16u + 1u]);
- B2B_G(2u, 10u, 18u, 26u, SIGMA82[i * 16u + 2u], SIGMA82[i * 16u + 3u]);
- B2B_G(4u, 12u, 20u, 28u, SIGMA82[i * 16u + 4u], SIGMA82[i * 16u + 5u]);
- B2B_G(6u, 14u, 22u, 30u, SIGMA82[i * 16u + 6u], SIGMA82[i * 16u + 7u]);
- B2B_G(0u, 10u, 20u, 30u, SIGMA82[i * 16u + 8u], SIGMA82[i * 16u + 9u]);
- B2B_G(2u, 12u, 22u, 24u, SIGMA82[i * 16u + 10u], SIGMA82[i * 16u + 11u]);
- B2B_G(4u, 14u, 16u, 26u, SIGMA82[i * 16u + 12u], SIGMA82[i * 16u + 13u]);
- B2B_G(6u, 8u, 18u, 28u, SIGMA82[i * 16u + 14u], SIGMA82[i * 16u + 15u]);
+ G(SIGMA82[i * 16u + 0u], SIGMA82[i * 16u + 1u], 0u, 8u, 16u, 24u);
+ G(SIGMA82[i * 16u + 2u], SIGMA82[i * 16u + 3u], 2u, 10u, 18u, 26u);
+ G(SIGMA82[i * 16u + 4u], SIGMA82[i * 16u + 5u], 4u, 12u, 20u, 28u);
+ G(SIGMA82[i * 16u + 6u], SIGMA82[i * 16u + 7u], 6u, 14u, 22u, 30u);
+ G(SIGMA82[i * 16u + 8u], SIGMA82[i * 16u + 9u], 0u, 10u, 20u, 30u);
+ G(SIGMA82[i * 16u + 10u], SIGMA82[i * 16u + 11u], 2u, 12u, 22u, 24u);
+ G(SIGMA82[i * 16u + 12u], SIGMA82[i * 16u + 13u], 4u, 14u, 16u, 26u);
+ G(SIGMA82[i * 16u + 14u], SIGMA82[i * 16u + 15u], 6u, 8u, 18u, 28u);
}
// Pixel data is multipled by threshold test result (0 or 1)
}`;
/** Used to set canvas size. Must be a multiple of 256. */
static #WORKLOAD = 256 * Math.max(1, Math.floor(navigator.hardwareConcurrency));
- static #hexify (arr) {
- let out = ""
+ static #hexify(arr) {
+ let out = "";
for (let i = arr.length - 1; i >= 0; i--) {
- out += arr[i].toString(16).padStart(2, "0")
- }
- return out
- }
- static #gl
- static #program
- static #vertexShader
- static #fragmentShader
- static #positionBuffer
- static #uvBuffer
- static #uboBuffer
- static #workBuffer
- static #query
- static #pixels
+ out += arr[i].toString(16).padStart(2, "0");
+ }
+ return out;
+ }
+ static #gl;
+ static #program;
+ static #vertexShader;
+ static #fragmentShader;
+ static #positionBuffer;
+ static #uvBuffer;
+ static #uboBuffer;
+ static #workBuffer;
+ static #query;
+ static #pixels;
// Vertex Positions, 2 triangles
static #positions = new Float32Array([
-1,
1
]);
static {
- this.#gl = new OffscreenCanvas(this.#WORKLOAD, this.#WORKLOAD).getContext("webgl2")
+ this.#gl = new OffscreenCanvas(this.#WORKLOAD, this.#WORKLOAD).getContext("webgl2");
if (this.#gl == null)
- throw new Error("WebGL 2 is required")
- this.#gl.clearColor(0, 0, 0, 1)
- this.#program = this.#gl.createProgram()
+ throw new Error("WebGL 2 is required");
+ this.#gl.clearColor(0, 0, 0, 1);
+ this.#program = this.#gl.createProgram();
if (this.#program == null)
- throw new Error("Failed to create shader program")
- this.#vertexShader = this.#gl.createShader(this.#gl.VERTEX_SHADER)
+ throw new Error("Failed to create shader program");
+ this.#vertexShader = this.#gl.createShader(this.#gl.VERTEX_SHADER);
if (this.#vertexShader == null)
- throw new Error("Failed to create vertex shader")
- this.#gl.shaderSource(this.#vertexShader, this.#vsSource)
- this.#gl.compileShader(this.#vertexShader)
+ throw new Error("Failed to create vertex shader");
+ this.#gl.shaderSource(this.#vertexShader, this.#vsSource);
+ this.#gl.compileShader(this.#vertexShader);
if (!this.#gl.getShaderParameter(this.#vertexShader, this.#gl.COMPILE_STATUS))
- throw new Error(this.#gl.getShaderInfoLog(this.#vertexShader) ?? `Failed to compile vertex shader`)
- this.#fragmentShader = this.#gl.createShader(this.#gl.FRAGMENT_SHADER)
+ throw new Error(this.#gl.getShaderInfoLog(this.#vertexShader) ?? `Failed to compile vertex shader`);
+ this.#fragmentShader = this.#gl.createShader(this.#gl.FRAGMENT_SHADER);
if (this.#fragmentShader == null)
- throw new Error("Failed to create fragment shader")
- this.#gl.shaderSource(this.#fragmentShader, this.#fsSource)
- this.#gl.compileShader(this.#fragmentShader)
+ throw new Error("Failed to create fragment shader");
+ this.#gl.shaderSource(this.#fragmentShader, this.#fsSource);
+ this.#gl.compileShader(this.#fragmentShader);
if (!this.#gl.getShaderParameter(this.#fragmentShader, this.#gl.COMPILE_STATUS))
- throw new Error(this.#gl.getShaderInfoLog(this.#fragmentShader) ?? `Failed to compile fragment shader`)
- this.#gl.attachShader(this.#program, this.#vertexShader)
- this.#gl.attachShader(this.#program, this.#fragmentShader)
- this.#gl.linkProgram(this.#program)
+ throw new Error(this.#gl.getShaderInfoLog(this.#fragmentShader) ?? `Failed to compile fragment shader`);
+ this.#gl.attachShader(this.#program, this.#vertexShader);
+ this.#gl.attachShader(this.#program, this.#fragmentShader);
+ this.#gl.linkProgram(this.#program);
if (!this.#gl.getProgramParameter(this.#program, this.#gl.LINK_STATUS))
- throw new Error(this.#gl.getProgramInfoLog(this.#program) ?? `Failed to link program`)
- this.#gl.useProgram(this.#program)
- const triangleArray = this.#gl.createVertexArray()
- this.#gl.bindVertexArray(triangleArray)
- this.#positionBuffer = this.#gl.createBuffer()
- this.#gl.bindBuffer(this.#gl.ARRAY_BUFFER, this.#positionBuffer)
- this.#gl.bufferData(this.#gl.ARRAY_BUFFER, this.#positions, this.#gl.STATIC_DRAW)
- this.#gl.vertexAttribPointer(0, 3, this.#gl.FLOAT, false, 0, 0)
- this.#gl.enableVertexAttribArray(0)
- this.#uvBuffer = this.#gl.createBuffer()
- this.#gl.bindBuffer(this.#gl.ARRAY_BUFFER, this.#uvBuffer)
- this.#gl.bufferData(this.#gl.ARRAY_BUFFER, this.#uvPosArray, this.#gl.STATIC_DRAW)
- this.#gl.vertexAttribPointer(1, 2, this.#gl.FLOAT, false, 0, 0)
- this.#gl.enableVertexAttribArray(1)
- this.#uboBuffer = this.#gl.createBuffer()
- this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#uboBuffer)
- this.#gl.bufferData(this.#gl.UNIFORM_BUFFER, 144, this.#gl.DYNAMIC_DRAW)
- this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null)
- this.#gl.bindBufferBase(this.#gl.UNIFORM_BUFFER, 0, this.#uboBuffer)
- this.#gl.uniformBlockBinding(this.#program, this.#gl.getUniformBlockIndex(this.#program, "UBO"), 0)
- this.#workBuffer = this.#gl.createBuffer()
- this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#workBuffer)
- this.#gl.bufferData(this.#gl.UNIFORM_BUFFER, 32, this.#gl.STREAM_DRAW)
- this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null)
- this.#gl.bindBufferBase(this.#gl.UNIFORM_BUFFER, 1, this.#workBuffer)
- this.#gl.uniformBlockBinding(this.#program, this.#gl.getUniformBlockIndex(this.#program, "WORK"), 1)
- this.#pixels = new Uint8Array(this.#gl.drawingBufferWidth * this.#gl.drawingBufferHeight * 4)
- this.#query = this.#gl.createQuery()
- }
- static #calculate (hashHex, callback, threshold) {
- if (_Pow.#gl == null)
- throw new Error("WebGL 2 is required")
- if (!/^[A-F-a-f0-9]{64}$/.test(hashHex))
- throw new Error(`invalid_hash ${hashHex}`)
+ throw new Error(this.#gl.getProgramInfoLog(this.#program) ?? `Failed to link program`);
+ this.#gl.useProgram(this.#program);
+ const triangleArray = this.#gl.createVertexArray();
+ this.#gl.bindVertexArray(triangleArray);
+ this.#positionBuffer = this.#gl.createBuffer();
+ this.#gl.bindBuffer(this.#gl.ARRAY_BUFFER, this.#positionBuffer);
+ this.#gl.bufferData(this.#gl.ARRAY_BUFFER, this.#positions, this.#gl.STATIC_DRAW);
+ this.#gl.vertexAttribPointer(0, 3, this.#gl.FLOAT, false, 0, 0);
+ this.#gl.enableVertexAttribArray(0);
+ this.#uvBuffer = this.#gl.createBuffer();
+ this.#gl.bindBuffer(this.#gl.ARRAY_BUFFER, this.#uvBuffer);
+ this.#gl.bufferData(this.#gl.ARRAY_BUFFER, this.#uvPosArray, this.#gl.STATIC_DRAW);
+ this.#gl.vertexAttribPointer(1, 2, this.#gl.FLOAT, false, 0, 0);
+ this.#gl.enableVertexAttribArray(1);
+ this.#uboBuffer = this.#gl.createBuffer();
+ this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#uboBuffer);
+ this.#gl.bufferData(this.#gl.UNIFORM_BUFFER, 144, this.#gl.DYNAMIC_DRAW);
+ this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
+ this.#gl.bindBufferBase(this.#gl.UNIFORM_BUFFER, 0, this.#uboBuffer);
+ this.#gl.uniformBlockBinding(this.#program, this.#gl.getUniformBlockIndex(this.#program, "UBO"), 0);
+ this.#workBuffer = this.#gl.createBuffer();
+ this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#workBuffer);
+ this.#gl.bufferData(this.#gl.UNIFORM_BUFFER, 32, this.#gl.STREAM_DRAW);
+ this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
+ this.#gl.bindBufferBase(this.#gl.UNIFORM_BUFFER, 1, this.#workBuffer);
+ this.#gl.uniformBlockBinding(this.#program, this.#gl.getUniformBlockIndex(this.#program, "WORK"), 1);
+ this.#pixels = new Uint8Array(this.#gl.drawingBufferWidth * this.#gl.drawingBufferHeight * 4);
+ this.#query = this.#gl.createQuery();
+ }
+ /**
+ * Finds a nonce that satisfies the Nano proof-of-work requirements.
+ *
+ * @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
+ * @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
+ */
+ static async search(hash2, threshold = 4294967288) {
+ if (_PowGl.#gl == null)
+ throw new Error("WebGL 2 is required");
+ if (!/^[A-F-a-f0-9]{64}$/.test(hash2))
+ throw new Error(`invalid_hash ${hash2}`);
if (typeof threshold !== "number")
- throw new TypeError(`Invalid threshold ${threshold}`)
+ throw new TypeError(`Invalid threshold ${threshold}`);
if (this.#gl == null)
- throw new Error("WebGL 2 is required")
- const uboView = new DataView(new ArrayBuffer(144))
+ throw new Error("WebGL 2 is required");
+ const uboView = new DataView(new ArrayBuffer(144));
for (let i = 0; i < 64; i += 8) {
- const uint32 = hashHex.slice(i, i + 8)
- uboView.setUint32(i * 2, parseInt(uint32, 16))
- }
- uboView.setUint32(128, threshold, true)
- uboView.setFloat32(132, _Pow.#WORKLOAD - 1, true)
- _Pow.#gl.bindBuffer(_Pow.#gl.UNIFORM_BUFFER, _Pow.#uboBuffer)
- _Pow.#gl.bufferSubData(_Pow.#gl.UNIFORM_BUFFER, 0, uboView)
- _Pow.#gl.bindBuffer(_Pow.#gl.UNIFORM_BUFFER, null)
- const work = new Uint8Array(8)
- let start
- const draw = () => {
- start = performance.now()
- if (_Pow.#gl == null)
- throw new Error("WebGL 2 is required")
- if (_Pow.#query == null)
- throw new Error("WebGL 2 is required to run queries")
- _Pow.#gl.clear(_Pow.#gl.COLOR_BUFFER_BIT)
- crypto.getRandomValues(work)
- _Pow.#gl.bindBuffer(_Pow.#gl.UNIFORM_BUFFER, _Pow.#workBuffer)
- _Pow.#gl.bufferSubData(_Pow.#gl.UNIFORM_BUFFER, 0, Uint32Array.from(work))
- _Pow.#gl.bindBuffer(_Pow.#gl.UNIFORM_BUFFER, null)
- _Pow.#gl.beginQuery(_Pow.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE, _Pow.#query)
- _Pow.#gl.drawArrays(_Pow.#gl.TRIANGLES, 0, 6)
- _Pow.#gl.endQuery(_Pow.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE)
- requestAnimationFrame(checkQueryResult)
- }
- function checkQueryResult () {
- if (_Pow.#gl == null)
- throw new Error("WebGL 2 is required to check query results")
- if (_Pow.#query == null)
- throw new Error("Query not found")
- console.log(`checking (${performance.now() - start} ms)`)
- if (_Pow.#gl.getQueryParameter(_Pow.#query, _Pow.#gl.QUERY_RESULT_AVAILABLE)) {
- console.log(`AVAILABLE (${performance.now() - start} ms)`)
- const anySamplesPassed = _Pow.#gl.getQueryParameter(_Pow.#query, _Pow.#gl.QUERY_RESULT)
- if (anySamplesPassed) {
- readBackResult()
- } else {
- console.log(`not found (${performance.now() - start} ms)`)
- requestAnimationFrame(draw)
- }
- } else {
- console.log(`not ready (${performance.now() - start} ms)`)
- requestAnimationFrame(checkQueryResult)
- }
- }
- function readBackResult () {
- if (_Pow.#gl == null)
- throw new Error("WebGL 2 is required to check read results")
- _Pow.#gl.readPixels(0, 0, _Pow.#gl.drawingBufferWidth, _Pow.#gl.drawingBufferHeight, _Pow.#gl.RGBA, _Pow.#gl.UNSIGNED_BYTE, _Pow.#pixels)
- for (let i = 0; i < _Pow.#pixels.length; i += 4) {
- if (_Pow.#pixels[i] !== 0) {
- console.log(`FOUND (${performance.now() - start} ms)`)
- const hex2 = _Pow.#hexify(work.subarray(4, 8)) + _Pow.#hexify([
- _Pow.#pixels[i + 2],
- _Pow.#pixels[i + 3],
- work[2] ^ _Pow.#pixels[i] - 1,
- work[3] ^ _Pow.#pixels[i + 1] - 1
- ])
- typeof callback === "function" && callback(hex2)
- return
- }
- }
+ const uint32 = hash2.slice(i, i + 8);
+ uboView.setUint32(i * 2, parseInt(uint32, 16));
+ }
+ uboView.setUint32(128, threshold, true);
+ uboView.setFloat32(132, _PowGl.#WORKLOAD - 1, true);
+ _PowGl.#gl.bindBuffer(_PowGl.#gl.UNIFORM_BUFFER, _PowGl.#uboBuffer);
+ _PowGl.#gl.bufferSubData(_PowGl.#gl.UNIFORM_BUFFER, 0, uboView);
+ _PowGl.#gl.bindBuffer(_PowGl.#gl.UNIFORM_BUFFER, null);
+ let nonce = null;
+ const work = new Uint8Array(8);
+ while (nonce == null) {
+ this.draw(work);
+ const found = await this.checkQueryResult();
+ if (found) {
+ nonce = this.readResult(work);
+ }
+ }
+ return nonce;
+ }
+ static draw(work) {
+ if (this.#gl == null || this.#query == null)
+ throw new Error("WebGL 2 is required to draw and query pixels");
+ if (this.#workBuffer == null)
+ throw new Error("Work buffer is required to draw");
+ this.#gl.clear(this.#gl.COLOR_BUFFER_BIT);
+ crypto.getRandomValues(work);
+ this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, this.#workBuffer);
+ this.#gl.bufferSubData(this.#gl.UNIFORM_BUFFER, 0, Uint32Array.from(work));
+ this.#gl.bindBuffer(this.#gl.UNIFORM_BUFFER, null);
+ this.#gl.beginQuery(this.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE, this.#query);
+ this.#gl.drawArrays(this.#gl.TRIANGLES, 0, 6);
+ this.#gl.endQuery(this.#gl.ANY_SAMPLES_PASSED_CONSERVATIVE);
+ }
+ static async checkQueryResult() {
+ if (this.#gl == null || this.#query == null)
+ throw new Error("WebGL 2 is required to check query results");
+ if (this.#gl.getQueryParameter(this.#query, this.#gl.QUERY_RESULT_AVAILABLE)) {
+ return this.#gl.getQueryParameter(this.#query, this.#gl.QUERY_RESULT);
}
- draw()
+ return new Promise((resolve, reject) => {
+ try {
+ requestAnimationFrame(async () => {
+ const result = await _PowGl.checkQueryResult();
+ resolve(result);
+ });
+ } catch (err) {
+ reject(err);
+ }
+ });
}
- }
+ /**
+ * Reads pixels into the work buffer, checks every 4th pixel for the 'found'
+ * byte, converts the subsequent 3 pixels with the nonce byte values to a hex
+ * string, and returns the result.
+ *
+ * @param work - Buffer with the original random nonce value
+ * @returns Nonce as an 8-byte (16-char) hexadecimal string
+ */
+ static readResult(work) {
+ if (this.#gl == null)
+ throw new Error("WebGL 2 is required to read pixels");
+ this.#gl.readPixels(0, 0, this.#gl.drawingBufferWidth, this.#gl.drawingBufferHeight, this.#gl.RGBA, this.#gl.UNSIGNED_BYTE, this.#pixels);
+ for (let i = 0; i < this.#pixels.length; i += 4) {
+ if (this.#pixels[i] !== 0) {
+ const hex2 = this.#hexify(work.subarray(4, 8)) + this.#hexify([
+ this.#pixels[i + 2],
+ this.#pixels[i + 3],
+ work[2] ^ this.#pixels[i] - 1,
+ work[3] ^ this.#pixels[i + 1] - 1
+ ]);
+ return hex2;
+ }
+ }
+ throw new Error("Query reported result but nonce value not found");
+ }
+ };
powgl_default = `
const WorkerInterface = ${WorkerInterface}
- const Pow = ${Pow}
-`
+ const PowGl = ${PowGl}
+`;
}
-})
+});
// dist/lib/workers/powgpu.js
-var PowGpu, powgpu_default
+var PowGpu, powgpu_default;
var init_powgpu = __esm({
- "dist/lib/workers/powgpu.js" () {
- "use strict"
- init_pool()
+ "dist/lib/workers/powgpu.js"() {
+ "use strict";
+ init_pool();
PowGpu = class _PowGpu extends WorkerInterface {
static {
- _PowGpu.listen()
+ _PowGpu.listen();
}
/**
* Calculates proof-of-work as described by the Nano cryptocurrency protocol.
* @param {any[]} data - Array of hashes and minimum thresholds
* @returns Promise for proof-of-work attached to original array objects
*/
- static async work (data) {
+ static async work(data) {
return new Promise(async (resolve, reject) => {
for (const d of data) {
try {
- d.work = await this.search(d.hash, d.threshold)
+ d.work = await this.search(d.hash, d.threshold);
} catch (err) {
- reject(err)
+ reject(err);
}
}
- resolve(data)
- })
+ resolve(data);
+ });
}
// WebGPU Compute Shader
static shader = `
* 8-byte work is split into two 4-byte u32. Low 4 bytes are random u32 from
* UBO. High 4 bytes are the random value XOR'd with index of each thread.
*/
- @compute @workgroup_size(256)
+ @compute @workgroup_size(64)
fn main(
@builtin(workgroup_id) workgroup_id: vec3<u32>,
@builtin(local_invocation_id) local_id: vec3<u32>
`;
// Initialize WebGPU
static #device = null;
- static #uboBuffer
- static #gpuBuffer
- static #cpuBuffer
- static #bindGroupLayout
- static #pipeline
+ static #uboBuffer;
+ static #gpuBuffer;
+ static #cpuBuffer;
+ static #bindGroupLayout;
+ static #pipeline;
static {
if (navigator.gpu == null) {
- throw new Error("WebGPU is not supported in this browser.")
+ throw new Error("WebGPU is not supported in this browser.");
}
navigator.gpu.requestAdapter().then((adapter) => {
if (adapter == null) {
- throw new Error("WebGPU adapter refused by browser.")
+ throw new Error("WebGPU adapter refused by browser.");
}
adapter.requestDevice().then((device) => {
- this.#device = device
+ this.#device = device;
this.#uboBuffer = this.#device.createBuffer({
size: 48,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
- })
+ });
this.#gpuBuffer = this.#device.createBuffer({
size: 16,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC
- })
+ });
this.#cpuBuffer = this.#device.createBuffer({
size: 16,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
- })
+ });
this.#bindGroupLayout = this.#device.createBindGroupLayout({
entries: [
{
}
}
]
- })
+ });
this.#pipeline = this.#device.createComputePipeline({
layout: this.#device.createPipelineLayout({
bindGroupLayouts: [this.#bindGroupLayout]
code: this.shader
})
}
- })
- })
+ });
+ });
}).catch((err) => {
- throw new Error(err.message)
- })
+ throw new Error(err.message);
+ });
}
/**
* Finds a nonce that satisfies the Nano proof-of-work requirements.
* @param {string} hash - Hexadecimal hash of previous block, or public key for new accounts
* @param {number} [threshold=0xfffffff8] - Difficulty of proof-of-work calculation
*/
- static async search (hashHex, threshold = 4294967288) {
- if (!/^[A-Fa-f0-9]{64}$/.test(hashHex))
- throw new TypeError(`Invalid hash ${hashHex}`)
+ static async search(hash2, threshold = 4294967288) {
+ if (!/^[A-Fa-f0-9]{64}$/.test(hash2))
+ throw new TypeError(`Invalid hash ${hash2}`);
if (typeof threshold !== "number")
- throw new TypeError(`Invalid threshold ${threshold}`)
- if (_PowGpu.#device == null) {
- if (performance.now() > 8e3) {
- throw new Error(`WebGPU device failed to load in time.`)
- }
- return await new Promise((resolve) => {
- setTimeout(() => {
- resolve(this.search(hashHex, threshold))
- }, 100)
- })
- }
- const uboView = new DataView(new ArrayBuffer(48))
+ throw new TypeError(`Invalid threshold ${threshold}`);
+ while (_PowGpu.#device == null && performance.now() < 8e3) {
+ await new Promise((resolve) => {
+ setTimeout(resolve, 500);
+ });
+ }
+ if (_PowGpu.#device == null)
+ throw new Error(`WebGPU device failed to load.`);
+ const uboView = new DataView(new ArrayBuffer(48));
for (let i = 0; i < 64; i += 8) {
- const uint32 = hashHex.slice(i, i + 8)
- uboView.setUint32(i / 2, parseInt(uint32, 16))
- }
- const random = Math.floor(Math.random() * 4294967295)
- uboView.setUint32(32, random, true)
- uboView.setUint32(36, threshold, true)
- _PowGpu.#device.queue.writeBuffer(_PowGpu.#uboBuffer, 0, uboView)
- _PowGpu.#device.queue.writeBuffer(_PowGpu.#gpuBuffer, 8, new Uint32Array([0]))
+ const uint32 = hash2.slice(i, i + 8);
+ uboView.setUint32(i / 2, parseInt(uint32, 16));
+ }
+ const random = Math.floor(Math.random() * 4294967295);
+ uboView.setUint32(32, random, true);
+ uboView.setUint32(36, threshold, true);
+ _PowGpu.#device.queue.writeBuffer(_PowGpu.#uboBuffer, 0, uboView);
+ _PowGpu.#device.queue.writeBuffer(_PowGpu.#gpuBuffer, 8, new Uint32Array([0]));
const bindGroup = _PowGpu.#device.createBindGroup({
layout: _PowGpu.#bindGroupLayout,
entries: [
}
}
]
- })
- const commandEncoder = _PowGpu.#device.createCommandEncoder()
- const passEncoder = commandEncoder.beginComputePass()
- passEncoder.setPipeline(_PowGpu.#pipeline)
- passEncoder.setBindGroup(0, bindGroup)
- passEncoder.dispatchWorkgroups(256, 256, 256)
- passEncoder.end()
- commandEncoder.copyBufferToBuffer(_PowGpu.#gpuBuffer, 0, _PowGpu.#cpuBuffer, 0, 12)
- _PowGpu.#device.queue.submit([commandEncoder.finish()])
- await _PowGpu.#cpuBuffer.mapAsync(GPUMapMode.READ)
- await _PowGpu.#device.queue.onSubmittedWorkDone()
- const data = new DataView(_PowGpu.#cpuBuffer.getMappedRange())
- const nonce = data.getBigUint64(0, true)
- const found = !!data.getUint32(8)
- _PowGpu.#cpuBuffer.unmap()
+ });
+ const commandEncoder = _PowGpu.#device.createCommandEncoder();
+ const passEncoder = commandEncoder.beginComputePass();
+ passEncoder.setPipeline(_PowGpu.#pipeline);
+ passEncoder.setBindGroup(0, bindGroup);
+ passEncoder.dispatchWorkgroups(256, 256, 256);
+ passEncoder.end();
+ commandEncoder.copyBufferToBuffer(_PowGpu.#gpuBuffer, 0, _PowGpu.#cpuBuffer, 0, 12);
+ _PowGpu.#device.queue.submit([commandEncoder.finish()]);
+ await _PowGpu.#cpuBuffer.mapAsync(GPUMapMode.READ);
+ await _PowGpu.#device.queue.onSubmittedWorkDone();
+ const data = new DataView(_PowGpu.#cpuBuffer.getMappedRange());
+ const nonce = data.getBigUint64(0, true);
+ const found = !!data.getUint32(8);
+ _PowGpu.#cpuBuffer.unmap();
if (found) {
- const hex2 = nonce.toString(16).padStart(16, "0")
- return hex2
+ const hex2 = nonce.toString(16).padStart(16, "0");
+ return hex2;
} else {
- return await this.search(hashHex, threshold)
+ return await this.search(hash2, threshold);
}
}
- }
+ };
powgpu_default = `
const WorkerInterface = ${WorkerInterface}
const PowGpu = ${PowGpu}
-`
+`;
}
-})
+});
// dist/lib/workers.js
var init_workers = __esm({
- "dist/lib/workers.js" () {
- "use strict"
- init_bip44_ckd()
- init_nano_nacl()
- init_powgl()
- init_powgpu()
+ "dist/lib/workers.js"() {
+ "use strict";
+ init_bip44_ckd();
+ init_nano_nacl();
+ init_powgl();
+ init_powgpu();
}
-})
+});
// node_modules/events/events.js
var require_events = __commonJS({
- "node_modules/events/events.js" (exports, module) {
- "use strict"
- var R = typeof Reflect === "object" ? Reflect : null
- var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2 (target, receiver, args) {
- return Function.prototype.apply.call(target, receiver, args)
- }
- var ReflectOwnKeys
+ "node_modules/events/events.js"(exports, module) {
+ "use strict";
+ var R = typeof Reflect === "object" ? Reflect : null;
+ var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
+ return Function.prototype.apply.call(target, receiver, args);
+ };
+ var ReflectOwnKeys;
if (R && typeof R.ownKeys === "function") {
- ReflectOwnKeys = R.ownKeys
+ ReflectOwnKeys = R.ownKeys;
} else if (Object.getOwnPropertySymbols) {
- ReflectOwnKeys = function ReflectOwnKeys2 (target) {
- return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))
- }
+ ReflectOwnKeys = function ReflectOwnKeys2(target) {
+ return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+ };
} else {
- ReflectOwnKeys = function ReflectOwnKeys2 (target) {
- return Object.getOwnPropertyNames(target)
- }
- }
- function ProcessEmitWarning (warning) {
- if (console && console.warn) console.warn(warning)
- }
- var NumberIsNaN = Number.isNaN || function NumberIsNaN2 (value) {
- return value !== value
- }
- function EventEmitter2 () {
- EventEmitter2.init.call(this)
+ ReflectOwnKeys = function ReflectOwnKeys2(target) {
+ return Object.getOwnPropertyNames(target);
+ };
}
- module.exports = EventEmitter2
- module.exports.once = once
- EventEmitter2.EventEmitter = EventEmitter2
- EventEmitter2.prototype._events = void 0
- EventEmitter2.prototype._eventsCount = 0
- EventEmitter2.prototype._maxListeners = void 0
- var defaultMaxListeners = 10
- function checkListener (listener) {
+ function ProcessEmitWarning(warning) {
+ if (console && console.warn) console.warn(warning);
+ }
+ var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+ return value !== value;
+ };
+ function EventEmitter2() {
+ EventEmitter2.init.call(this);
+ }
+ module.exports = EventEmitter2;
+ module.exports.once = once;
+ EventEmitter2.EventEmitter = EventEmitter2;
+ EventEmitter2.prototype._events = void 0;
+ EventEmitter2.prototype._eventsCount = 0;
+ EventEmitter2.prototype._maxListeners = void 0;
+ var defaultMaxListeners = 10;
+ function checkListener(listener) {
if (typeof listener !== "function") {
- throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener)
+ throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
Object.defineProperty(EventEmitter2, "defaultMaxListeners", {
enumerable: true,
- get: function () {
- return defaultMaxListeners
+ get: function() {
+ return defaultMaxListeners;
},
- set: function (arg) {
+ set: function(arg) {
if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
- throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".")
+ throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
}
- defaultMaxListeners = arg
+ defaultMaxListeners = arg;
}
- })
- EventEmitter2.init = function () {
+ });
+ EventEmitter2.init = function() {
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
- this._events = /* @__PURE__ */ Object.create(null)
- this._eventsCount = 0
+ this._events = /* @__PURE__ */ Object.create(null);
+ this._eventsCount = 0;
}
- this._maxListeners = this._maxListeners || void 0
- }
- EventEmitter2.prototype.setMaxListeners = function setMaxListeners (n) {
+ this._maxListeners = this._maxListeners || void 0;
+ };
+ EventEmitter2.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
- throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".")
+ throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
}
- this._maxListeners = n
- return this
- }
- function _getMaxListeners (that) {
+ this._maxListeners = n;
+ return this;
+ };
+ function _getMaxListeners(that) {
if (that._maxListeners === void 0)
- return EventEmitter2.defaultMaxListeners
- return that._maxListeners
- }
- EventEmitter2.prototype.getMaxListeners = function getMaxListeners () {
- return _getMaxListeners(this)
- }
- EventEmitter2.prototype.emit = function emit (type) {
- var args = []
- for (var i = 1; i < arguments.length; i++) args.push(arguments[i])
- var doError = type === "error"
- var events = this._events
+ return EventEmitter2.defaultMaxListeners;
+ return that._maxListeners;
+ }
+ EventEmitter2.prototype.getMaxListeners = function getMaxListeners() {
+ return _getMaxListeners(this);
+ };
+ EventEmitter2.prototype.emit = function emit(type) {
+ var args = [];
+ for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+ var doError = type === "error";
+ var events = this._events;
if (events !== void 0)
- doError = doError && events.error === void 0
+ doError = doError && events.error === void 0;
else if (!doError)
- return false
+ return false;
if (doError) {
- var er
+ var er;
if (args.length > 0)
- er = args[0]
+ er = args[0];
if (er instanceof Error) {
- throw er
+ throw er;
}
- var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""))
- err.context = er
- throw err
+ var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+ err.context = er;
+ throw err;
}
- var handler = events[type]
+ var handler = events[type];
if (handler === void 0)
- return false
+ return false;
if (typeof handler === "function") {
- ReflectApply(handler, this, args)
+ ReflectApply(handler, this, args);
} else {
- var len = handler.length
- var listeners = arrayClone(handler, len)
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
- ReflectApply(listeners[i], this, args)
- }
- return true
- }
- function _addListener (target, type, listener, prepend) {
- var m
- var events
- var existing
- checkListener(listener)
- events = target._events
+ ReflectApply(listeners[i], this, args);
+ }
+ return true;
+ };
+ function _addListener(target, type, listener, prepend) {
+ var m;
+ var events;
+ var existing;
+ checkListener(listener);
+ events = target._events;
if (events === void 0) {
- events = target._events = /* @__PURE__ */ Object.create(null)
- target._eventsCount = 0
+ events = target._events = /* @__PURE__ */ Object.create(null);
+ target._eventsCount = 0;
} else {
if (events.newListener !== void 0) {
target.emit(
"newListener",
type,
listener.listener ? listener.listener : listener
- )
- events = target._events
+ );
+ events = target._events;
}
- existing = events[type]
+ existing = events[type];
}
if (existing === void 0) {
- existing = events[type] = listener
- ++target._eventsCount
+ existing = events[type] = listener;
+ ++target._eventsCount;
} else {
if (typeof existing === "function") {
- existing = events[type] = prepend ? [listener, existing] : [existing, listener]
+ existing = events[type] = prepend ? [listener, existing] : [existing, listener];
} else if (prepend) {
- existing.unshift(listener)
+ existing.unshift(listener);
} else {
- existing.push(listener)
+ existing.push(listener);
}
- m = _getMaxListeners(target)
+ m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
- existing.warned = true
- var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit")
- w.name = "MaxListenersExceededWarning"
- w.emitter = target
- w.type = type
- w.count = existing.length
- ProcessEmitWarning(w)
- }
- }
- return target
- }
- EventEmitter2.prototype.addListener = function addListener (type, listener) {
- return _addListener(this, type, listener, false)
- }
- EventEmitter2.prototype.on = EventEmitter2.prototype.addListener
- EventEmitter2.prototype.prependListener = function prependListener (type, listener) {
- return _addListener(this, type, listener, true)
- }
- function onceWrapper () {
+ existing.warned = true;
+ var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+ w.name = "MaxListenersExceededWarning";
+ w.emitter = target;
+ w.type = type;
+ w.count = existing.length;
+ ProcessEmitWarning(w);
+ }
+ }
+ return target;
+ }
+ EventEmitter2.prototype.addListener = function addListener(type, listener) {
+ return _addListener(this, type, listener, false);
+ };
+ EventEmitter2.prototype.on = EventEmitter2.prototype.addListener;
+ EventEmitter2.prototype.prependListener = function prependListener(type, listener) {
+ return _addListener(this, type, listener, true);
+ };
+ function onceWrapper() {
if (!this.fired) {
- this.target.removeListener(this.type, this.wrapFn)
- this.fired = true
+ this.target.removeListener(this.type, this.wrapFn);
+ this.fired = true;
if (arguments.length === 0)
- return this.listener.call(this.target)
- return this.listener.apply(this.target, arguments)
- }
- }
- function _onceWrap (target, type, listener) {
- var state = { fired: false, wrapFn: void 0, target, type, listener }
- var wrapped = onceWrapper.bind(state)
- wrapped.listener = listener
- state.wrapFn = wrapped
- return wrapped
- }
- EventEmitter2.prototype.once = function once2 (type, listener) {
- checkListener(listener)
- this.on(type, _onceWrap(this, type, listener))
- return this
- }
- EventEmitter2.prototype.prependOnceListener = function prependOnceListener (type, listener) {
- checkListener(listener)
- this.prependListener(type, _onceWrap(this, type, listener))
- return this
- }
- EventEmitter2.prototype.removeListener = function removeListener (type, listener) {
- var list, events, position, i, originalListener
- checkListener(listener)
- events = this._events
+ return this.listener.call(this.target);
+ return this.listener.apply(this.target, arguments);
+ }
+ }
+ function _onceWrap(target, type, listener) {
+ var state = { fired: false, wrapFn: void 0, target, type, listener };
+ var wrapped = onceWrapper.bind(state);
+ wrapped.listener = listener;
+ state.wrapFn = wrapped;
+ return wrapped;
+ }
+ EventEmitter2.prototype.once = function once2(type, listener) {
+ checkListener(listener);
+ this.on(type, _onceWrap(this, type, listener));
+ return this;
+ };
+ EventEmitter2.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+ checkListener(listener);
+ this.prependListener(type, _onceWrap(this, type, listener));
+ return this;
+ };
+ EventEmitter2.prototype.removeListener = function removeListener(type, listener) {
+ var list, events, position, i, originalListener;
+ checkListener(listener);
+ events = this._events;
if (events === void 0)
- return this
- list = events[type]
+ return this;
+ list = events[type];
if (list === void 0)
- return this
+ return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
- this._events = /* @__PURE__ */ Object.create(null)
+ this._events = /* @__PURE__ */ Object.create(null);
else {
- delete events[type]
+ delete events[type];
if (events.removeListener)
- this.emit("removeListener", type, list.listener || listener)
+ this.emit("removeListener", type, list.listener || listener);
}
} else if (typeof list !== "function") {
- position = -1
+ position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
- originalListener = list[i].listener
- position = i
- break
+ originalListener = list[i].listener;
+ position = i;
+ break;
}
}
if (position < 0)
- return this
+ return this;
if (position === 0)
- list.shift()
+ list.shift();
else {
- spliceOne(list, position)
+ spliceOne(list, position);
}
if (list.length === 1)
- events[type] = list[0]
+ events[type] = list[0];
if (events.removeListener !== void 0)
- this.emit("removeListener", type, originalListener || listener)
- }
- return this
- }
- EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener
- EventEmitter2.prototype.removeAllListeners = function removeAllListeners (type) {
- var listeners, events, i
- events = this._events
+ this.emit("removeListener", type, originalListener || listener);
+ }
+ return this;
+ };
+ EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+ EventEmitter2.prototype.removeAllListeners = function removeAllListeners(type) {
+ var listeners, events, i;
+ events = this._events;
if (events === void 0)
- return this
+ return this;
if (events.removeListener === void 0) {
if (arguments.length === 0) {
- this._events = /* @__PURE__ */ Object.create(null)
- this._eventsCount = 0
+ this._events = /* @__PURE__ */ Object.create(null);
+ this._eventsCount = 0;
} else if (events[type] !== void 0) {
if (--this._eventsCount === 0)
- this._events = /* @__PURE__ */ Object.create(null)
+ this._events = /* @__PURE__ */ Object.create(null);
else
- delete events[type]
+ delete events[type];
}
- return this
+ return this;
}
if (arguments.length === 0) {
- var keys = Object.keys(events)
- var key
+ var keys = Object.keys(events);
+ var key;
for (i = 0; i < keys.length; ++i) {
- key = keys[i]
- if (key === "removeListener") continue
- this.removeAllListeners(key)
+ key = keys[i];
+ if (key === "removeListener") continue;
+ this.removeAllListeners(key);
}
- this.removeAllListeners("removeListener")
- this._events = /* @__PURE__ */ Object.create(null)
- this._eventsCount = 0
- return this
+ this.removeAllListeners("removeListener");
+ this._events = /* @__PURE__ */ Object.create(null);
+ this._eventsCount = 0;
+ return this;
}
- listeners = events[type]
+ listeners = events[type];
if (typeof listeners === "function") {
- this.removeListener(type, listeners)
+ this.removeListener(type, listeners);
} else if (listeners !== void 0) {
for (i = listeners.length - 1; i >= 0; i--) {
- this.removeListener(type, listeners[i])
+ this.removeListener(type, listeners[i]);
}
}
- return this
- }
- function _listeners (target, type, unwrap) {
- var events = target._events
+ return this;
+ };
+ function _listeners(target, type, unwrap) {
+ var events = target._events;
if (events === void 0)
- return []
- var evlistener = events[type]
+ return [];
+ var evlistener = events[type];
if (evlistener === void 0)
- return []
+ return [];
if (typeof evlistener === "function")
- return unwrap ? [evlistener.listener || evlistener] : [evlistener]
- return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length)
- }
- EventEmitter2.prototype.listeners = function listeners (type) {
- return _listeners(this, type, true)
- }
- EventEmitter2.prototype.rawListeners = function rawListeners (type) {
- return _listeners(this, type, false)
- }
- EventEmitter2.listenerCount = function (emitter, type) {
+ return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+ return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+ }
+ EventEmitter2.prototype.listeners = function listeners(type) {
+ return _listeners(this, type, true);
+ };
+ EventEmitter2.prototype.rawListeners = function rawListeners(type) {
+ return _listeners(this, type, false);
+ };
+ EventEmitter2.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === "function") {
- return emitter.listenerCount(type)
+ return emitter.listenerCount(type);
} else {
- return listenerCount.call(emitter, type)
+ return listenerCount.call(emitter, type);
}
- }
- EventEmitter2.prototype.listenerCount = listenerCount
- function listenerCount (type) {
- var events = this._events
+ };
+ EventEmitter2.prototype.listenerCount = listenerCount;
+ function listenerCount(type) {
+ var events = this._events;
if (events !== void 0) {
- var evlistener = events[type]
+ var evlistener = events[type];
if (typeof evlistener === "function") {
- return 1
+ return 1;
} else if (evlistener !== void 0) {
- return evlistener.length
+ return evlistener.length;
}
}
- return 0
+ return 0;
}
- EventEmitter2.prototype.eventNames = function eventNames () {
- return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []
- }
- function arrayClone (arr, n) {
- var copy = new Array(n)
+ EventEmitter2.prototype.eventNames = function eventNames() {
+ return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+ };
+ function arrayClone(arr, n) {
+ var copy = new Array(n);
for (var i = 0; i < n; ++i)
- copy[i] = arr[i]
- return copy
+ copy[i] = arr[i];
+ return copy;
}
- function spliceOne (list, index) {
+ function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
- list[index] = list[index + 1]
- list.pop()
+ list[index] = list[index + 1];
+ list.pop();
}
- function unwrapListeners (arr) {
- var ret = new Array(arr.length)
+ function unwrapListeners(arr) {
+ var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
- ret[i] = arr[i].listener || arr[i]
+ ret[i] = arr[i].listener || arr[i];
}
- return ret
+ return ret;
}
- function once (emitter, name) {
- return new Promise(function (resolve, reject) {
- function errorListener (err) {
- emitter.removeListener(name, resolver)
- reject(err)
+ function once(emitter, name) {
+ return new Promise(function(resolve, reject) {
+ function errorListener(err) {
+ emitter.removeListener(name, resolver);
+ reject(err);
}
- function resolver () {
+ function resolver() {
if (typeof emitter.removeListener === "function") {
- emitter.removeListener("error", errorListener)
+ emitter.removeListener("error", errorListener);
}
- resolve([].slice.call(arguments))
+ resolve([].slice.call(arguments));
}
;
- eventTargetAgnosticAddListener(emitter, name, resolver, { once: true })
+ eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== "error") {
- addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true })
+ addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
- })
+ });
}
- function addErrorHandlerIfEventEmitter (emitter, handler, flags) {
+ function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === "function") {
- eventTargetAgnosticAddListener(emitter, "error", handler, flags)
+ eventTargetAgnosticAddListener(emitter, "error", handler, flags);
}
}
- function eventTargetAgnosticAddListener (emitter, name, listener, flags) {
+ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === "function") {
if (flags.once) {
- emitter.once(name, listener)
+ emitter.once(name, listener);
} else {
- emitter.on(name, listener)
+ emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === "function") {
- emitter.addEventListener(name, function wrapListener (arg) {
+ emitter.addEventListener(name, function wrapListener(arg) {
if (flags.once) {
- emitter.removeEventListener(name, wrapListener)
+ emitter.removeEventListener(name, wrapListener);
}
- listener(arg)
- })
+ listener(arg);
+ });
} else {
- throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter)
+ throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
}
-})
+});
// node_modules/@ledgerhq/errors/lib-es/helpers.js
-function isObject (value) {
- return typeof value === "object"
+function isObject(value) {
+ return typeof value === "object";
}
-var errorClasses, deserializers, addCustomErrorDeserializer, createCustomErrorClass
+var errorClasses, deserializers, addCustomErrorDeserializer, createCustomErrorClass;
var init_helpers = __esm({
- "node_modules/@ledgerhq/errors/lib-es/helpers.js" () {
- errorClasses = {}
- deserializers = {}
+ "node_modules/@ledgerhq/errors/lib-es/helpers.js"() {
+ errorClasses = {};
+ deserializers = {};
addCustomErrorDeserializer = (name, deserializer) => {
- deserializers[name] = deserializer
- }
+ deserializers[name] = deserializer;
+ };
createCustomErrorClass = (name) => {
class CustomErrorClass extends Error {
constructor(message, fields, options) {
- super(message || name, options)
- Object.setPrototypeOf(this, CustomErrorClass.prototype)
- this.name = name
+ super(message || name, options);
+ Object.setPrototypeOf(this, CustomErrorClass.prototype);
+ this.name = name;
if (fields) {
for (const k in fields) {
- this[k] = fields[k]
+ this[k] = fields[k];
}
}
if (options && isObject(options) && "cause" in options && !("cause" in this)) {
- const cause = options.cause
- this.cause = cause
+ const cause = options.cause;
+ this.cause = cause;
if ("stack" in cause) {
- this.stack = this.stack + "\nCAUSE: " + cause.stack
+ this.stack = this.stack + "\nCAUSE: " + cause.stack;
}
}
}
}
- errorClasses[name] = CustomErrorClass
- return CustomErrorClass
- }
+ errorClasses[name] = CustomErrorClass;
+ return CustomErrorClass;
+ };
}
-})
+});
// node_modules/@ledgerhq/errors/lib-es/index.js
-function getAltStatusMessage (code) {
+function getAltStatusMessage(code) {
switch (code) {
// improve text of most common errors
case 26368:
- return "Incorrect length"
+ return "Incorrect length";
case 26624:
- return "Missing critical parameter"
+ return "Missing critical parameter";
case 27010:
- return "Security not satisfied (dongle locked or have invalid access rights)"
+ return "Security not satisfied (dongle locked or have invalid access rights)";
case 27013:
- return "Condition of use not satisfied (denied by the user?)"
+ return "Condition of use not satisfied (denied by the user?)";
case 27264:
- return "Invalid data received"
+ return "Invalid data received";
case 27392:
- return "Invalid parameter received"
+ return "Invalid parameter received";
case 21781:
- return "Locked device"
+ return "Locked device";
}
if (28416 <= code && code <= 28671) {
- return "Internal error, please report"
+ return "Internal error, please report";
}
}
-var AccountNameRequiredError, AccountNotSupported, AccountAwaitingSendPendingOperations, AmountRequired, BluetoothRequired, BtcUnmatchedApp, CantOpenDevice, CashAddrNotSupported, ClaimRewardsFeesWarning, CurrencyNotSupported, DeviceAppVerifyNotSupported, DeviceGenuineSocketEarlyClose, DeviceNotGenuineError, DeviceOnDashboardExpected, DeviceOnDashboardUnexpected, DeviceInOSUExpected, DeviceHalted, DeviceNameInvalid, DeviceSocketFail, DeviceSocketNoBulkStatus, DeviceNeedsRestart, UnresponsiveDeviceError, DisconnectedDevice, DisconnectedDeviceDuringOperation, DeviceExtractOnboardingStateError, DeviceOnboardingStatePollingError, EnpointConfigError, EthAppPleaseEnableContractData, FeeEstimationFailed, FirmwareNotRecognized, HardResetFail, InvalidXRPTag, InvalidAddress, InvalidNonce, InvalidAddressBecauseDestinationIsAlsoSource, LatestMCUInstalledError, UnknownMCU, LedgerAPIError, LedgerAPIErrorWithMessage, LedgerAPINotAvailable, ManagerAppAlreadyInstalledError, ManagerAppRelyOnBTCError, ManagerAppDepInstallRequired, ManagerAppDepUninstallRequired, ManagerDeviceLockedError, ManagerFirmwareNotEnoughSpaceError, ManagerNotEnoughSpaceError, ManagerUninstallBTCDep, NetworkDown, NetworkError, NoAddressesFound, NotEnoughBalance, NotEnoughBalanceSwap, NotEnoughBalanceToDelegate, NotEnoughBalanceInParentAccount, NotEnoughSpendableBalance, NotEnoughBalanceBecauseDestinationNotCreated, NoAccessToCamera, NotEnoughGas, NotEnoughGasSwap, TronEmptyAccount, MaybeKeepTronAccountAlive, NotSupportedLegacyAddress, GasLessThanEstimate, PriorityFeeTooLow, PriorityFeeTooHigh, PriorityFeeHigherThanMaxFee, MaxFeeTooLow, PasswordsDontMatchError, PasswordIncorrectError, RecommendSubAccountsToEmpty, RecommendUndelegation, TimeoutTagged, UnexpectedBootloader, MCUNotGenuineToDashboard, RecipientRequired, UnavailableTezosOriginatedAccountReceive, UnavailableTezosOriginatedAccountSend, UpdateFetchFileFail, UpdateIncorrectHash, UpdateIncorrectSig, UpdateYourApp, UserRefusedDeviceNameChange, UserRefusedAddress, UserRefusedFirmwareUpdate, UserRefusedAllowManager, UserRefusedOnDevice, PinNotSet, ExpertModeRequired, TransportOpenUserCancelled, TransportInterfaceNotAvailable, TransportRaceCondition, TransportWebUSBGestureRequired, TransactionHasBeenValidatedError, TransportExchangeTimeoutError, DeviceShouldStayInApp, WebsocketConnectionError, WebsocketConnectionFailed, WrongDeviceForAccount, WrongDeviceForAccountPayout, WrongDeviceForAccountRefund, WrongAppForCurrency, ETHAddressNonEIP, CantScanQRCode, FeeNotLoaded, FeeNotLoadedSwap, FeeRequired, FeeTooHigh, PendingOperation, SyncError, PairingFailed, PeerRemovedPairing, GenuineCheckFailed, LedgerAPI4xx, LedgerAPI5xx, FirmwareOrAppUpdateRequired, ReplacementTransactionUnderpriced, OpReturnDataSizeLimit, DustLimit, LanguageNotFound, NoDBPathGiven, DBWrongPassword, DBNotReset, SequenceNumberError, DisabledTransactionBroadcastError, HwTransportErrorType, TransportError, StatusCodes, TransportStatusError, LockedDeviceError
+var AccountNameRequiredError, AccountNotSupported, AccountAwaitingSendPendingOperations, AmountRequired, BluetoothRequired, BtcUnmatchedApp, CantOpenDevice, CashAddrNotSupported, ClaimRewardsFeesWarning, CurrencyNotSupported, DeviceAppVerifyNotSupported, DeviceGenuineSocketEarlyClose, DeviceNotGenuineError, DeviceOnDashboardExpected, DeviceOnDashboardUnexpected, DeviceInOSUExpected, DeviceHalted, DeviceNameInvalid, DeviceSocketFail, DeviceSocketNoBulkStatus, DeviceNeedsRestart, UnresponsiveDeviceError, DisconnectedDevice, DisconnectedDeviceDuringOperation, DeviceExtractOnboardingStateError, DeviceOnboardingStatePollingError, EnpointConfigError, EthAppPleaseEnableContractData, FeeEstimationFailed, FirmwareNotRecognized, HardResetFail, InvalidXRPTag, InvalidAddress, InvalidNonce, InvalidAddressBecauseDestinationIsAlsoSource, LatestMCUInstalledError, UnknownMCU, LedgerAPIError, LedgerAPIErrorWithMessage, LedgerAPINotAvailable, ManagerAppAlreadyInstalledError, ManagerAppRelyOnBTCError, ManagerAppDepInstallRequired, ManagerAppDepUninstallRequired, ManagerDeviceLockedError, ManagerFirmwareNotEnoughSpaceError, ManagerNotEnoughSpaceError, ManagerUninstallBTCDep, NetworkDown, NetworkError, NoAddressesFound, NotEnoughBalance, NotEnoughBalanceSwap, NotEnoughBalanceToDelegate, NotEnoughBalanceInParentAccount, NotEnoughSpendableBalance, NotEnoughBalanceBecauseDestinationNotCreated, NoAccessToCamera, NotEnoughGas, NotEnoughGasSwap, TronEmptyAccount, MaybeKeepTronAccountAlive, NotSupportedLegacyAddress, GasLessThanEstimate, PriorityFeeTooLow, PriorityFeeTooHigh, PriorityFeeHigherThanMaxFee, MaxFeeTooLow, PasswordsDontMatchError, PasswordIncorrectError, RecommendSubAccountsToEmpty, RecommendUndelegation, TimeoutTagged, UnexpectedBootloader, MCUNotGenuineToDashboard, RecipientRequired, UnavailableTezosOriginatedAccountReceive, UnavailableTezosOriginatedAccountSend, UpdateFetchFileFail, UpdateIncorrectHash, UpdateIncorrectSig, UpdateYourApp, UserRefusedDeviceNameChange, UserRefusedAddress, UserRefusedFirmwareUpdate, UserRefusedAllowManager, UserRefusedOnDevice, PinNotSet, ExpertModeRequired, TransportOpenUserCancelled, TransportInterfaceNotAvailable, TransportRaceCondition, TransportWebUSBGestureRequired, TransactionHasBeenValidatedError, TransportExchangeTimeoutError, DeviceShouldStayInApp, WebsocketConnectionError, WebsocketConnectionFailed, WrongDeviceForAccount, WrongDeviceForAccountPayout, WrongDeviceForAccountRefund, WrongAppForCurrency, ETHAddressNonEIP, CantScanQRCode, FeeNotLoaded, FeeNotLoadedSwap, FeeRequired, FeeTooHigh, PendingOperation, SyncError, PairingFailed, PeerRemovedPairing, GenuineCheckFailed, LedgerAPI4xx, LedgerAPI5xx, FirmwareOrAppUpdateRequired, ReplacementTransactionUnderpriced, OpReturnDataSizeLimit, DustLimit, LanguageNotFound, NoDBPathGiven, DBWrongPassword, DBNotReset, SequenceNumberError, DisabledTransactionBroadcastError, HwTransportErrorType, TransportError, StatusCodes, TransportStatusError, LockedDeviceError;
var init_lib_es = __esm({
- "node_modules/@ledgerhq/errors/lib-es/index.js" () {
- init_helpers()
- AccountNameRequiredError = createCustomErrorClass("AccountNameRequired")
- AccountNotSupported = createCustomErrorClass("AccountNotSupported")
- AccountAwaitingSendPendingOperations = createCustomErrorClass("AccountAwaitingSendPendingOperations")
- AmountRequired = createCustomErrorClass("AmountRequired")
- BluetoothRequired = createCustomErrorClass("BluetoothRequired")
- BtcUnmatchedApp = createCustomErrorClass("BtcUnmatchedApp")
- CantOpenDevice = createCustomErrorClass("CantOpenDevice")
- CashAddrNotSupported = createCustomErrorClass("CashAddrNotSupported")
- ClaimRewardsFeesWarning = createCustomErrorClass("ClaimRewardsFeesWarning")
- CurrencyNotSupported = createCustomErrorClass("CurrencyNotSupported")
- DeviceAppVerifyNotSupported = createCustomErrorClass("DeviceAppVerifyNotSupported")
- DeviceGenuineSocketEarlyClose = createCustomErrorClass("DeviceGenuineSocketEarlyClose")
- DeviceNotGenuineError = createCustomErrorClass("DeviceNotGenuine")
- DeviceOnDashboardExpected = createCustomErrorClass("DeviceOnDashboardExpected")
- DeviceOnDashboardUnexpected = createCustomErrorClass("DeviceOnDashboardUnexpected")
- DeviceInOSUExpected = createCustomErrorClass("DeviceInOSUExpected")
- DeviceHalted = createCustomErrorClass("DeviceHalted")
- DeviceNameInvalid = createCustomErrorClass("DeviceNameInvalid")
- DeviceSocketFail = createCustomErrorClass("DeviceSocketFail")
- DeviceSocketNoBulkStatus = createCustomErrorClass("DeviceSocketNoBulkStatus")
- DeviceNeedsRestart = createCustomErrorClass("DeviceSocketNoBulkStatus")
- UnresponsiveDeviceError = createCustomErrorClass("UnresponsiveDeviceError")
- DisconnectedDevice = createCustomErrorClass("DisconnectedDevice")
- DisconnectedDeviceDuringOperation = createCustomErrorClass("DisconnectedDeviceDuringOperation")
- DeviceExtractOnboardingStateError = createCustomErrorClass("DeviceExtractOnboardingStateError")
- DeviceOnboardingStatePollingError = createCustomErrorClass("DeviceOnboardingStatePollingError")
- EnpointConfigError = createCustomErrorClass("EnpointConfig")
- EthAppPleaseEnableContractData = createCustomErrorClass("EthAppPleaseEnableContractData")
- FeeEstimationFailed = createCustomErrorClass("FeeEstimationFailed")
- FirmwareNotRecognized = createCustomErrorClass("FirmwareNotRecognized")
- HardResetFail = createCustomErrorClass("HardResetFail")
- InvalidXRPTag = createCustomErrorClass("InvalidXRPTag")
- InvalidAddress = createCustomErrorClass("InvalidAddress")
- InvalidNonce = createCustomErrorClass("InvalidNonce")
- InvalidAddressBecauseDestinationIsAlsoSource = createCustomErrorClass("InvalidAddressBecauseDestinationIsAlsoSource")
- LatestMCUInstalledError = createCustomErrorClass("LatestMCUInstalledError")
- UnknownMCU = createCustomErrorClass("UnknownMCU")
- LedgerAPIError = createCustomErrorClass("LedgerAPIError")
- LedgerAPIErrorWithMessage = createCustomErrorClass("LedgerAPIErrorWithMessage")
- LedgerAPINotAvailable = createCustomErrorClass("LedgerAPINotAvailable")
- ManagerAppAlreadyInstalledError = createCustomErrorClass("ManagerAppAlreadyInstalled")
- ManagerAppRelyOnBTCError = createCustomErrorClass("ManagerAppRelyOnBTC")
- ManagerAppDepInstallRequired = createCustomErrorClass("ManagerAppDepInstallRequired")
- ManagerAppDepUninstallRequired = createCustomErrorClass("ManagerAppDepUninstallRequired")
- ManagerDeviceLockedError = createCustomErrorClass("ManagerDeviceLocked")
- ManagerFirmwareNotEnoughSpaceError = createCustomErrorClass("ManagerFirmwareNotEnoughSpace")
- ManagerNotEnoughSpaceError = createCustomErrorClass("ManagerNotEnoughSpace")
- ManagerUninstallBTCDep = createCustomErrorClass("ManagerUninstallBTCDep")
- NetworkDown = createCustomErrorClass("NetworkDown")
- NetworkError = createCustomErrorClass("NetworkError")
- NoAddressesFound = createCustomErrorClass("NoAddressesFound")
- NotEnoughBalance = createCustomErrorClass("NotEnoughBalance")
- NotEnoughBalanceSwap = createCustomErrorClass("NotEnoughBalanceSwap")
- NotEnoughBalanceToDelegate = createCustomErrorClass("NotEnoughBalanceToDelegate")
- NotEnoughBalanceInParentAccount = createCustomErrorClass("NotEnoughBalanceInParentAccount")
- NotEnoughSpendableBalance = createCustomErrorClass("NotEnoughSpendableBalance")
- NotEnoughBalanceBecauseDestinationNotCreated = createCustomErrorClass("NotEnoughBalanceBecauseDestinationNotCreated")
- NoAccessToCamera = createCustomErrorClass("NoAccessToCamera")
- NotEnoughGas = createCustomErrorClass("NotEnoughGas")
- NotEnoughGasSwap = createCustomErrorClass("NotEnoughGasSwap")
- TronEmptyAccount = createCustomErrorClass("TronEmptyAccount")
- MaybeKeepTronAccountAlive = createCustomErrorClass("MaybeKeepTronAccountAlive")
- NotSupportedLegacyAddress = createCustomErrorClass("NotSupportedLegacyAddress")
- GasLessThanEstimate = createCustomErrorClass("GasLessThanEstimate")
- PriorityFeeTooLow = createCustomErrorClass("PriorityFeeTooLow")
- PriorityFeeTooHigh = createCustomErrorClass("PriorityFeeTooHigh")
- PriorityFeeHigherThanMaxFee = createCustomErrorClass("PriorityFeeHigherThanMaxFee")
- MaxFeeTooLow = createCustomErrorClass("MaxFeeTooLow")
- PasswordsDontMatchError = createCustomErrorClass("PasswordsDontMatch")
- PasswordIncorrectError = createCustomErrorClass("PasswordIncorrect")
- RecommendSubAccountsToEmpty = createCustomErrorClass("RecommendSubAccountsToEmpty")
- RecommendUndelegation = createCustomErrorClass("RecommendUndelegation")
- TimeoutTagged = createCustomErrorClass("TimeoutTagged")
- UnexpectedBootloader = createCustomErrorClass("UnexpectedBootloader")
- MCUNotGenuineToDashboard = createCustomErrorClass("MCUNotGenuineToDashboard")
- RecipientRequired = createCustomErrorClass("RecipientRequired")
- UnavailableTezosOriginatedAccountReceive = createCustomErrorClass("UnavailableTezosOriginatedAccountReceive")
- UnavailableTezosOriginatedAccountSend = createCustomErrorClass("UnavailableTezosOriginatedAccountSend")
- UpdateFetchFileFail = createCustomErrorClass("UpdateFetchFileFail")
- UpdateIncorrectHash = createCustomErrorClass("UpdateIncorrectHash")
- UpdateIncorrectSig = createCustomErrorClass("UpdateIncorrectSig")
- UpdateYourApp = createCustomErrorClass("UpdateYourApp")
- UserRefusedDeviceNameChange = createCustomErrorClass("UserRefusedDeviceNameChange")
- UserRefusedAddress = createCustomErrorClass("UserRefusedAddress")
- UserRefusedFirmwareUpdate = createCustomErrorClass("UserRefusedFirmwareUpdate")
- UserRefusedAllowManager = createCustomErrorClass("UserRefusedAllowManager")
- UserRefusedOnDevice = createCustomErrorClass("UserRefusedOnDevice")
- PinNotSet = createCustomErrorClass("PinNotSet")
- ExpertModeRequired = createCustomErrorClass("ExpertModeRequired")
- TransportOpenUserCancelled = createCustomErrorClass("TransportOpenUserCancelled")
- TransportInterfaceNotAvailable = createCustomErrorClass("TransportInterfaceNotAvailable")
- TransportRaceCondition = createCustomErrorClass("TransportRaceCondition")
- TransportWebUSBGestureRequired = createCustomErrorClass("TransportWebUSBGestureRequired")
- TransactionHasBeenValidatedError = createCustomErrorClass("TransactionHasBeenValidatedError")
- TransportExchangeTimeoutError = createCustomErrorClass("TransportExchangeTimeoutError")
- DeviceShouldStayInApp = createCustomErrorClass("DeviceShouldStayInApp")
- WebsocketConnectionError = createCustomErrorClass("WebsocketConnectionError")
- WebsocketConnectionFailed = createCustomErrorClass("WebsocketConnectionFailed")
- WrongDeviceForAccount = createCustomErrorClass("WrongDeviceForAccount")
- WrongDeviceForAccountPayout = createCustomErrorClass("WrongDeviceForAccountPayout")
- WrongDeviceForAccountRefund = createCustomErrorClass("WrongDeviceForAccountRefund")
- WrongAppForCurrency = createCustomErrorClass("WrongAppForCurrency")
- ETHAddressNonEIP = createCustomErrorClass("ETHAddressNonEIP")
- CantScanQRCode = createCustomErrorClass("CantScanQRCode")
- FeeNotLoaded = createCustomErrorClass("FeeNotLoaded")
- FeeNotLoadedSwap = createCustomErrorClass("FeeNotLoadedSwap")
- FeeRequired = createCustomErrorClass("FeeRequired")
- FeeTooHigh = createCustomErrorClass("FeeTooHigh")
- PendingOperation = createCustomErrorClass("PendingOperation")
- SyncError = createCustomErrorClass("SyncError")
- PairingFailed = createCustomErrorClass("PairingFailed")
- PeerRemovedPairing = createCustomErrorClass("PeerRemovedPairing")
- GenuineCheckFailed = createCustomErrorClass("GenuineCheckFailed")
- LedgerAPI4xx = createCustomErrorClass("LedgerAPI4xx")
- LedgerAPI5xx = createCustomErrorClass("LedgerAPI5xx")
- FirmwareOrAppUpdateRequired = createCustomErrorClass("FirmwareOrAppUpdateRequired")
- ReplacementTransactionUnderpriced = createCustomErrorClass("ReplacementTransactionUnderpriced")
- OpReturnDataSizeLimit = createCustomErrorClass("OpReturnSizeLimit")
- DustLimit = createCustomErrorClass("DustLimit")
- LanguageNotFound = createCustomErrorClass("LanguageNotFound")
- NoDBPathGiven = createCustomErrorClass("NoDBPathGiven")
- DBWrongPassword = createCustomErrorClass("DBWrongPassword")
- DBNotReset = createCustomErrorClass("DBNotReset")
- SequenceNumberError = createCustomErrorClass("SequenceNumberError")
+ "node_modules/@ledgerhq/errors/lib-es/index.js"() {
+ init_helpers();
+ AccountNameRequiredError = createCustomErrorClass("AccountNameRequired");
+ AccountNotSupported = createCustomErrorClass("AccountNotSupported");
+ AccountAwaitingSendPendingOperations = createCustomErrorClass("AccountAwaitingSendPendingOperations");
+ AmountRequired = createCustomErrorClass("AmountRequired");
+ BluetoothRequired = createCustomErrorClass("BluetoothRequired");
+ BtcUnmatchedApp = createCustomErrorClass("BtcUnmatchedApp");
+ CantOpenDevice = createCustomErrorClass("CantOpenDevice");
+ CashAddrNotSupported = createCustomErrorClass("CashAddrNotSupported");
+ ClaimRewardsFeesWarning = createCustomErrorClass("ClaimRewardsFeesWarning");
+ CurrencyNotSupported = createCustomErrorClass("CurrencyNotSupported");
+ DeviceAppVerifyNotSupported = createCustomErrorClass("DeviceAppVerifyNotSupported");
+ DeviceGenuineSocketEarlyClose = createCustomErrorClass("DeviceGenuineSocketEarlyClose");
+ DeviceNotGenuineError = createCustomErrorClass("DeviceNotGenuine");
+ DeviceOnDashboardExpected = createCustomErrorClass("DeviceOnDashboardExpected");
+ DeviceOnDashboardUnexpected = createCustomErrorClass("DeviceOnDashboardUnexpected");
+ DeviceInOSUExpected = createCustomErrorClass("DeviceInOSUExpected");
+ DeviceHalted = createCustomErrorClass("DeviceHalted");
+ DeviceNameInvalid = createCustomErrorClass("DeviceNameInvalid");
+ DeviceSocketFail = createCustomErrorClass("DeviceSocketFail");
+ DeviceSocketNoBulkStatus = createCustomErrorClass("DeviceSocketNoBulkStatus");
+ DeviceNeedsRestart = createCustomErrorClass("DeviceSocketNoBulkStatus");
+ UnresponsiveDeviceError = createCustomErrorClass("UnresponsiveDeviceError");
+ DisconnectedDevice = createCustomErrorClass("DisconnectedDevice");
+ DisconnectedDeviceDuringOperation = createCustomErrorClass("DisconnectedDeviceDuringOperation");
+ DeviceExtractOnboardingStateError = createCustomErrorClass("DeviceExtractOnboardingStateError");
+ DeviceOnboardingStatePollingError = createCustomErrorClass("DeviceOnboardingStatePollingError");
+ EnpointConfigError = createCustomErrorClass("EnpointConfig");
+ EthAppPleaseEnableContractData = createCustomErrorClass("EthAppPleaseEnableContractData");
+ FeeEstimationFailed = createCustomErrorClass("FeeEstimationFailed");
+ FirmwareNotRecognized = createCustomErrorClass("FirmwareNotRecognized");
+ HardResetFail = createCustomErrorClass("HardResetFail");
+ InvalidXRPTag = createCustomErrorClass("InvalidXRPTag");
+ InvalidAddress = createCustomErrorClass("InvalidAddress");
+ InvalidNonce = createCustomErrorClass("InvalidNonce");
+ InvalidAddressBecauseDestinationIsAlsoSource = createCustomErrorClass("InvalidAddressBecauseDestinationIsAlsoSource");
+ LatestMCUInstalledError = createCustomErrorClass("LatestMCUInstalledError");
+ UnknownMCU = createCustomErrorClass("UnknownMCU");
+ LedgerAPIError = createCustomErrorClass("LedgerAPIError");
+ LedgerAPIErrorWithMessage = createCustomErrorClass("LedgerAPIErrorWithMessage");
+ LedgerAPINotAvailable = createCustomErrorClass("LedgerAPINotAvailable");
+ ManagerAppAlreadyInstalledError = createCustomErrorClass("ManagerAppAlreadyInstalled");
+ ManagerAppRelyOnBTCError = createCustomErrorClass("ManagerAppRelyOnBTC");
+ ManagerAppDepInstallRequired = createCustomErrorClass("ManagerAppDepInstallRequired");
+ ManagerAppDepUninstallRequired = createCustomErrorClass("ManagerAppDepUninstallRequired");
+ ManagerDeviceLockedError = createCustomErrorClass("ManagerDeviceLocked");
+ ManagerFirmwareNotEnoughSpaceError = createCustomErrorClass("ManagerFirmwareNotEnoughSpace");
+ ManagerNotEnoughSpaceError = createCustomErrorClass("ManagerNotEnoughSpace");
+ ManagerUninstallBTCDep = createCustomErrorClass("ManagerUninstallBTCDep");
+ NetworkDown = createCustomErrorClass("NetworkDown");
+ NetworkError = createCustomErrorClass("NetworkError");
+ NoAddressesFound = createCustomErrorClass("NoAddressesFound");
+ NotEnoughBalance = createCustomErrorClass("NotEnoughBalance");
+ NotEnoughBalanceSwap = createCustomErrorClass("NotEnoughBalanceSwap");
+ NotEnoughBalanceToDelegate = createCustomErrorClass("NotEnoughBalanceToDelegate");
+ NotEnoughBalanceInParentAccount = createCustomErrorClass("NotEnoughBalanceInParentAccount");
+ NotEnoughSpendableBalance = createCustomErrorClass("NotEnoughSpendableBalance");
+ NotEnoughBalanceBecauseDestinationNotCreated = createCustomErrorClass("NotEnoughBalanceBecauseDestinationNotCreated");
+ NoAccessToCamera = createCustomErrorClass("NoAccessToCamera");
+ NotEnoughGas = createCustomErrorClass("NotEnoughGas");
+ NotEnoughGasSwap = createCustomErrorClass("NotEnoughGasSwap");
+ TronEmptyAccount = createCustomErrorClass("TronEmptyAccount");
+ MaybeKeepTronAccountAlive = createCustomErrorClass("MaybeKeepTronAccountAlive");
+ NotSupportedLegacyAddress = createCustomErrorClass("NotSupportedLegacyAddress");
+ GasLessThanEstimate = createCustomErrorClass("GasLessThanEstimate");
+ PriorityFeeTooLow = createCustomErrorClass("PriorityFeeTooLow");
+ PriorityFeeTooHigh = createCustomErrorClass("PriorityFeeTooHigh");
+ PriorityFeeHigherThanMaxFee = createCustomErrorClass("PriorityFeeHigherThanMaxFee");
+ MaxFeeTooLow = createCustomErrorClass("MaxFeeTooLow");
+ PasswordsDontMatchError = createCustomErrorClass("PasswordsDontMatch");
+ PasswordIncorrectError = createCustomErrorClass("PasswordIncorrect");
+ RecommendSubAccountsToEmpty = createCustomErrorClass("RecommendSubAccountsToEmpty");
+ RecommendUndelegation = createCustomErrorClass("RecommendUndelegation");
+ TimeoutTagged = createCustomErrorClass("TimeoutTagged");
+ UnexpectedBootloader = createCustomErrorClass("UnexpectedBootloader");
+ MCUNotGenuineToDashboard = createCustomErrorClass("MCUNotGenuineToDashboard");
+ RecipientRequired = createCustomErrorClass("RecipientRequired");
+ UnavailableTezosOriginatedAccountReceive = createCustomErrorClass("UnavailableTezosOriginatedAccountReceive");
+ UnavailableTezosOriginatedAccountSend = createCustomErrorClass("UnavailableTezosOriginatedAccountSend");
+ UpdateFetchFileFail = createCustomErrorClass("UpdateFetchFileFail");
+ UpdateIncorrectHash = createCustomErrorClass("UpdateIncorrectHash");
+ UpdateIncorrectSig = createCustomErrorClass("UpdateIncorrectSig");
+ UpdateYourApp = createCustomErrorClass("UpdateYourApp");
+ UserRefusedDeviceNameChange = createCustomErrorClass("UserRefusedDeviceNameChange");
+ UserRefusedAddress = createCustomErrorClass("UserRefusedAddress");
+ UserRefusedFirmwareUpdate = createCustomErrorClass("UserRefusedFirmwareUpdate");
+ UserRefusedAllowManager = createCustomErrorClass("UserRefusedAllowManager");
+ UserRefusedOnDevice = createCustomErrorClass("UserRefusedOnDevice");
+ PinNotSet = createCustomErrorClass("PinNotSet");
+ ExpertModeRequired = createCustomErrorClass("ExpertModeRequired");
+ TransportOpenUserCancelled = createCustomErrorClass("TransportOpenUserCancelled");
+ TransportInterfaceNotAvailable = createCustomErrorClass("TransportInterfaceNotAvailable");
+ TransportRaceCondition = createCustomErrorClass("TransportRaceCondition");
+ TransportWebUSBGestureRequired = createCustomErrorClass("TransportWebUSBGestureRequired");
+ TransactionHasBeenValidatedError = createCustomErrorClass("TransactionHasBeenValidatedError");
+ TransportExchangeTimeoutError = createCustomErrorClass("TransportExchangeTimeoutError");
+ DeviceShouldStayInApp = createCustomErrorClass("DeviceShouldStayInApp");
+ WebsocketConnectionError = createCustomErrorClass("WebsocketConnectionError");
+ WebsocketConnectionFailed = createCustomErrorClass("WebsocketConnectionFailed");
+ WrongDeviceForAccount = createCustomErrorClass("WrongDeviceForAccount");
+ WrongDeviceForAccountPayout = createCustomErrorClass("WrongDeviceForAccountPayout");
+ WrongDeviceForAccountRefund = createCustomErrorClass("WrongDeviceForAccountRefund");
+ WrongAppForCurrency = createCustomErrorClass("WrongAppForCurrency");
+ ETHAddressNonEIP = createCustomErrorClass("ETHAddressNonEIP");
+ CantScanQRCode = createCustomErrorClass("CantScanQRCode");
+ FeeNotLoaded = createCustomErrorClass("FeeNotLoaded");
+ FeeNotLoadedSwap = createCustomErrorClass("FeeNotLoadedSwap");
+ FeeRequired = createCustomErrorClass("FeeRequired");
+ FeeTooHigh = createCustomErrorClass("FeeTooHigh");
+ PendingOperation = createCustomErrorClass("PendingOperation");
+ SyncError = createCustomErrorClass("SyncError");
+ PairingFailed = createCustomErrorClass("PairingFailed");
+ PeerRemovedPairing = createCustomErrorClass("PeerRemovedPairing");
+ GenuineCheckFailed = createCustomErrorClass("GenuineCheckFailed");
+ LedgerAPI4xx = createCustomErrorClass("LedgerAPI4xx");
+ LedgerAPI5xx = createCustomErrorClass("LedgerAPI5xx");
+ FirmwareOrAppUpdateRequired = createCustomErrorClass("FirmwareOrAppUpdateRequired");
+ ReplacementTransactionUnderpriced = createCustomErrorClass("ReplacementTransactionUnderpriced");
+ OpReturnDataSizeLimit = createCustomErrorClass("OpReturnSizeLimit");
+ DustLimit = createCustomErrorClass("DustLimit");
+ LanguageNotFound = createCustomErrorClass("LanguageNotFound");
+ NoDBPathGiven = createCustomErrorClass("NoDBPathGiven");
+ DBWrongPassword = createCustomErrorClass("DBWrongPassword");
+ DBNotReset = createCustomErrorClass("DBNotReset");
+ SequenceNumberError = createCustomErrorClass("SequenceNumberError");
DisabledTransactionBroadcastError = createCustomErrorClass("DisabledTransactionBroadcastError");
- (function (HwTransportErrorType2) {
- HwTransportErrorType2["Unknown"] = "Unknown"
- HwTransportErrorType2["LocationServicesDisabled"] = "LocationServicesDisabled"
- HwTransportErrorType2["LocationServicesUnauthorized"] = "LocationServicesUnauthorized"
- HwTransportErrorType2["BluetoothScanStartFailed"] = "BluetoothScanStartFailed"
- })(HwTransportErrorType || (HwTransportErrorType = {}))
+ (function(HwTransportErrorType2) {
+ HwTransportErrorType2["Unknown"] = "Unknown";
+ HwTransportErrorType2["LocationServicesDisabled"] = "LocationServicesDisabled";
+ HwTransportErrorType2["LocationServicesUnauthorized"] = "LocationServicesUnauthorized";
+ HwTransportErrorType2["BluetoothScanStartFailed"] = "BluetoothScanStartFailed";
+ })(HwTransportErrorType || (HwTransportErrorType = {}));
TransportError = class extends Error {
constructor(message, id2) {
- const name = "TransportError"
- super(message || name)
- this.name = name
- this.message = message
- this.stack = new Error(message).stack
- this.id = id2
- }
- }
- addCustomErrorDeserializer("TransportError", (e) => new TransportError(e.message, e.id))
+ const name = "TransportError";
+ super(message || name);
+ this.name = name;
+ this.message = message;
+ this.stack = new Error(message).stack;
+ this.id = id2;
+ }
+ };
+ addCustomErrorDeserializer("TransportError", (e) => new TransportError(e.message, e.id));
StatusCodes = {
ACCESS_CONDITION_NOT_FULFILLED: 38916,
ALGORITHM_NOT_SUPPORTED: 38020,
INVALID_BACKUP_HEADER: 26698,
// Not documented:
TRUSTCHAIN_WRONG_SEED: 45063
- }
+ };
TransportStatusError = class _TransportStatusError extends Error {
/**
* @param statusCode The error status code coming from a Transport implementation
* . Ex: LockedDeviceError. Default to true.
*/
constructor(statusCode, { canBeMappedToChildError = true } = {}) {
- const statusText = Object.keys(StatusCodes).find((k) => StatusCodes[k] === statusCode) || "UNKNOWN_ERROR"
- const smsg = getAltStatusMessage(statusCode) || statusText
- const statusCodeStr = statusCode.toString(16)
- const message = `Ledger device: ${smsg} (0x${statusCodeStr})`
- super(message)
- this.name = "TransportStatusError"
- this.statusCode = statusCode
- this.statusText = statusText
- Object.setPrototypeOf(this, _TransportStatusError.prototype)
+ const statusText = Object.keys(StatusCodes).find((k) => StatusCodes[k] === statusCode) || "UNKNOWN_ERROR";
+ const smsg = getAltStatusMessage(statusCode) || statusText;
+ const statusCodeStr = statusCode.toString(16);
+ const message = `Ledger device: ${smsg} (0x${statusCodeStr})`;
+ super(message);
+ this.name = "TransportStatusError";
+ this.statusCode = statusCode;
+ this.statusText = statusText;
+ Object.setPrototypeOf(this, _TransportStatusError.prototype);
if (canBeMappedToChildError && statusCode === StatusCodes.LOCKED_DEVICE) {
- return new LockedDeviceError(message)
+ return new LockedDeviceError(message);
}
}
- }
+ };
LockedDeviceError = class _LockedDeviceError extends TransportStatusError {
constructor(message) {
- super(StatusCodes.LOCKED_DEVICE, { canBeMappedToChildError: false })
+ super(StatusCodes.LOCKED_DEVICE, { canBeMappedToChildError: false });
if (message) {
- this.message = message
+ this.message = message;
}
- this.name = "LockedDeviceError"
- Object.setPrototypeOf(this, _LockedDeviceError.prototype)
+ this.name = "LockedDeviceError";
+ Object.setPrototypeOf(this, _LockedDeviceError.prototype);
}
- }
- addCustomErrorDeserializer("TransportStatusError", (e) => new TransportStatusError(e.statusCode))
+ };
+ addCustomErrorDeserializer("TransportStatusError", (e) => new TransportStatusError(e.statusCode));
}
-})
+});
// node_modules/@ledgerhq/logs/lib-es/index.js
-function dispatch (log2) {
+function dispatch(log2) {
for (let i = 0; i < subscribers.length; i++) {
try {
- subscribers[i](log2)
+ subscribers[i](log2);
} catch (e) {
- console.error(e)
+ console.error(e);
}
}
}
-var id, subscribers, log, trace, LocalTracer, listen
+var id, subscribers, log, trace, LocalTracer, listen;
var init_lib_es2 = __esm({
- "node_modules/@ledgerhq/logs/lib-es/index.js" () {
- id = 0
- subscribers = []
+ "node_modules/@ledgerhq/logs/lib-es/index.js"() {
+ id = 0;
+ subscribers = [];
log = (type, message, data) => {
const obj = {
type,
id: String(++id),
date: /* @__PURE__ */ new Date()
- }
+ };
if (message)
- obj.message = message
+ obj.message = message;
if (data)
- obj.data = data
- dispatch(obj)
- }
+ obj.data = data;
+ dispatch(obj);
+ };
trace = ({ type, message, data, context: context2 }) => {
const obj = {
type,
id: String(++id),
date: /* @__PURE__ */ new Date()
- }
+ };
if (message)
- obj.message = message
+ obj.message = message;
if (data)
- obj.data = data
+ obj.data = data;
if (context2)
- obj.context = context2
- dispatch(obj)
- }
+ obj.context = context2;
+ dispatch(obj);
+ };
LocalTracer = class _LocalTracer {
constructor(type, context2) {
- this.type = type
- this.context = context2
+ this.type = type;
+ this.context = context2;
}
- trace (message, data) {
+ trace(message, data) {
trace({
type: this.type,
message,
data,
context: this.context
- })
+ });
}
- getContext () {
- return this.context
+ getContext() {
+ return this.context;
}
- setContext (context2) {
- this.context = context2
+ setContext(context2) {
+ this.context = context2;
}
- updateContext (contextToAdd) {
- this.context = Object.assign(Object.assign({}, this.context), contextToAdd)
+ updateContext(contextToAdd) {
+ this.context = Object.assign(Object.assign({}, this.context), contextToAdd);
}
- getType () {
- return this.type
+ getType() {
+ return this.type;
}
- setType (type) {
- this.type = type
+ setType(type) {
+ this.type = type;
}
/**
* Create a new instance of the LocalTracer with an updated `type`
* It does not mutate the calling instance, but returns a new LocalTracer,
* following a simple builder pattern.
*/
- withType (type) {
- return new _LocalTracer(type, this.context)
+ withType(type) {
+ return new _LocalTracer(type, this.context);
}
/**
* Create a new instance of the LocalTracer with a new `context`
*
* @param context A TraceContext, that can undefined to reset the context
*/
- withContext (context2) {
- return new _LocalTracer(this.type, context2)
+ withContext(context2) {
+ return new _LocalTracer(this.type, context2);
}
/**
* Create a new instance of the LocalTracer with an updated `context`,
* It does not mutate the calling instance, but returns a new LocalTracer,
* following a simple builder pattern.
*/
- withUpdatedContext (contextToAdd) {
- return new _LocalTracer(this.type, Object.assign(Object.assign({}, this.context), contextToAdd))
+ withUpdatedContext(contextToAdd) {
+ return new _LocalTracer(this.type, Object.assign(Object.assign({}, this.context), contextToAdd));
}
- }
+ };
listen = (cb) => {
- subscribers.push(cb)
+ subscribers.push(cb);
return () => {
- const i = subscribers.indexOf(cb)
+ const i = subscribers.indexOf(cb);
if (i !== -1) {
- subscribers[i] = subscribers[subscribers.length - 1]
- subscribers.pop()
+ subscribers[i] = subscribers[subscribers.length - 1];
+ subscribers.pop();
}
- }
- }
+ };
+ };
if (typeof window !== "undefined") {
- window.__ledgerLogsListen = listen
+ window.__ledgerLogsListen = listen;
}
}
-})
+});
// node_modules/@ledgerhq/hw-transport/lib-es/Transport.js
-var import_events, __awaiter, DEFAULT_LOG_TYPE, Transport, Transport_default
+var import_events, __awaiter, DEFAULT_LOG_TYPE, Transport, Transport_default;
var init_Transport = __esm({
- "node_modules/@ledgerhq/hw-transport/lib-es/Transport.js" () {
- import_events = __toESM(require_events())
- init_lib_es()
- init_lib_es2()
- __awaiter = function (thisArg, _arguments, P, generator) {
- function adopt (value) {
- return value instanceof P ? value : new P(function (resolve) {
- resolve(value)
- })
- }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled (value) {
+ "node_modules/@ledgerhq/hw-transport/lib-es/Transport.js"() {
+ import_events = __toESM(require_events());
+ init_lib_es();
+ init_lib_es2();
+ __awaiter = function(thisArg, _arguments, P, generator) {
+ function adopt(value) {
+ return value instanceof P ? value : new P(function(resolve) {
+ resolve(value);
+ });
+ }
+ return new (P || (P = Promise))(function(resolve, reject) {
+ function fulfilled(value) {
try {
- step(generator.next(value))
+ step(generator.next(value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function rejected (value) {
+ function rejected(value) {
try {
- step(generator["throw"](value))
+ step(generator["throw"](value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function step (result) {
- result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+ function step(result) {
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
- step((generator = generator.apply(thisArg, _arguments || [])).next())
- })
- }
- DEFAULT_LOG_TYPE = "transport"
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+ };
+ DEFAULT_LOG_TYPE = "transport";
Transport = class {
constructor({ context: context2, logType } = {}) {
- this.exchangeTimeout = 3e4
- this.unresponsiveTimeout = 15e3
- this.deviceModel = null
- this._events = new import_events.default()
+ this.exchangeTimeout = 3e4;
+ this.unresponsiveTimeout = 15e3;
+ this.deviceModel = null;
+ this._events = new import_events.default();
this.send = (cla_1, ins_1, p1_1, p2_1, ...args_1) => __awaiter(this, [cla_1, ins_1, p1_1, p2_1, ...args_1], void 0, function* (cla, ins, p1, p2, data = Buffer.alloc(0), statusList = [StatusCodes.OK], { abortTimeoutMs } = {}) {
- const tracer = this.tracer.withUpdatedContext({ function: "send" })
+ const tracer = this.tracer.withUpdatedContext({ function: "send" });
if (data.length >= 256) {
- tracer.trace("data.length exceeded 256 bytes limit", { dataLength: data.length })
- throw new TransportError("data.length exceed 256 bytes limit. Got: " + data.length, "DataLengthTooBig")
+ tracer.trace("data.length exceeded 256 bytes limit", { dataLength: data.length });
+ throw new TransportError("data.length exceed 256 bytes limit. Got: " + data.length, "DataLengthTooBig");
}
- tracer.trace("Starting an exchange", { abortTimeoutMs })
+ tracer.trace("Starting an exchange", { abortTimeoutMs });
const response = yield this.exchange(
// The size of the data is added in 1 byte just before `data`
Buffer.concat([Buffer.from([cla, ins, p1, p2]), Buffer.from([data.length]), data]),
{ abortTimeoutMs }
- )
- tracer.trace("Received response from exchange")
- const sw = response.readUInt16BE(response.length - 2)
+ );
+ tracer.trace("Received response from exchange");
+ const sw = response.readUInt16BE(response.length - 2);
if (!statusList.some((s) => s === sw)) {
- throw new TransportStatusError(sw)
+ throw new TransportStatusError(sw);
}
- return response
- })
- this._appAPIlock = null
- this.tracer = new LocalTracer(logType !== null && logType !== void 0 ? logType : DEFAULT_LOG_TYPE, context2)
+ return response;
+ });
+ this._appAPIlock = null;
+ this.tracer = new LocalTracer(logType !== null && logType !== void 0 ? logType : DEFAULT_LOG_TYPE, context2);
}
/**
* Send data to the device using a low level API.
* to detect unresponsive device (see `unresponsiveTimeout`). This timeout aborts the exchange.
* @returns {Promise<Buffer>} A promise that resolves with the response data from the device.
*/
- exchange (_apdu, { abortTimeoutMs: _abortTimeoutMs } = {}) {
- throw new Error("exchange not implemented")
+ exchange(_apdu, { abortTimeoutMs: _abortTimeoutMs } = {}) {
+ throw new Error("exchange not implemented");
}
/**
* Send apdus in batch to the device using a low level API.
* @param {Observer<Buffer>} observer - an observer that will receive the response of each apdu.
* @returns {Subscription} A Subscription object on which you can call ".unsubscribe()" to stop sending apdus.
*/
- exchangeBulk (apdus, observer) {
- let unsubscribed = false
+ exchangeBulk(apdus, observer) {
+ let unsubscribed = false;
const unsubscribe = () => {
- unsubscribed = true
- }
+ unsubscribed = true;
+ };
const main = () => __awaiter(this, void 0, void 0, function* () {
if (unsubscribed)
- return
+ return;
for (const apdu of apdus) {
- const r = yield this.exchange(apdu)
+ const r = yield this.exchange(apdu);
if (unsubscribed)
- return
- const status = r.readUInt16BE(r.length - 2)
+ return;
+ const status = r.readUInt16BE(r.length - 2);
if (status !== StatusCodes.OK) {
- throw new TransportStatusError(status)
+ throw new TransportStatusError(status);
}
- observer.next(r)
+ observer.next(r);
}
- })
- main().then(() => !unsubscribed && observer.complete(), (e) => !unsubscribed && observer.error(e))
- return { unsubscribe }
+ });
+ main().then(() => !unsubscribed && observer.complete(), (e) => !unsubscribed && observer.error(e));
+ return { unsubscribe };
}
/**
* Set the "scramble key" for the next data exchanges with the device.
* no @ before deprecated as it breaks documentationjs on version 14.0.2
* https://github.com/documentationjs/documentation/issues/1596
*/
- setScrambleKey (_key) {
+ setScrambleKey(_key) {
}
/**
* Close the connection with the device.
*
* @returns {Promise<void>} A promise that resolves when the transport is closed.
*/
- close () {
- return Promise.resolve()
+ close() {
+ return Promise.resolve();
}
/**
* Listen for an event on the transport instance.
* @param {string} eventName - The name of the event to listen for.
* @param {(...args: Array<any>) => any} cb - The callback function to be invoked when the event occurs.
*/
- on (eventName, cb) {
- this._events.on(eventName, cb)
+ on(eventName, cb) {
+ this._events.on(eventName, cb);
}
/**
* Stop listening to an event on an instance of transport.
*/
- off (eventName, cb) {
- this._events.removeListener(eventName, cb)
+ off(eventName, cb) {
+ this._events.removeListener(eventName, cb);
}
- emit (event, ...args) {
- this._events.emit(event, ...args)
+ emit(event, ...args) {
+ this._events.emit(event, ...args);
}
/**
* Enable or not logs of the binary exchange
*/
- setDebugMode () {
- console.warn("setDebugMode is deprecated. use @ledgerhq/logs instead. No logs are emitted in this anymore.")
+ setDebugMode() {
+ console.warn("setDebugMode is deprecated. use @ledgerhq/logs instead. No logs are emitted in this anymore.");
}
/**
* Set a timeout (in milliseconds) for the exchange call. Only some transport might implement it. (e.g. U2F)
*/
- setExchangeTimeout (exchangeTimeout) {
- this.exchangeTimeout = exchangeTimeout
+ setExchangeTimeout(exchangeTimeout) {
+ this.exchangeTimeout = exchangeTimeout;
}
/**
* Define the delay before emitting "unresponsive" on an exchange that does not respond
*/
- setExchangeUnresponsiveTimeout (unresponsiveTimeout) {
- this.unresponsiveTimeout = unresponsiveTimeout
+ setExchangeUnresponsiveTimeout(unresponsiveTimeout) {
+ this.unresponsiveTimeout = unresponsiveTimeout;
}
/**
* create() allows to open the first descriptor available or
* @example
TransportFoo.create().then(transport => ...)
*/
- static create (openTimeout = 3e3, listenTimeout) {
+ static create(openTimeout = 3e3, listenTimeout) {
return new Promise((resolve, reject) => {
- let found = false
+ let found = false;
const sub = this.listen({
next: (e) => {
- found = true
+ found = true;
if (sub)
- sub.unsubscribe()
+ sub.unsubscribe();
if (listenTimeoutId)
- clearTimeout(listenTimeoutId)
- this.open(e.descriptor, openTimeout).then(resolve, reject)
+ clearTimeout(listenTimeoutId);
+ this.open(e.descriptor, openTimeout).then(resolve, reject);
},
error: (e) => {
if (listenTimeoutId)
- clearTimeout(listenTimeoutId)
- reject(e)
+ clearTimeout(listenTimeoutId);
+ reject(e);
},
complete: () => {
if (listenTimeoutId)
- clearTimeout(listenTimeoutId)
+ clearTimeout(listenTimeoutId);
if (!found) {
- reject(new TransportError(this.ErrorMessage_NoDeviceFound, "NoDeviceFound"))
+ reject(new TransportError(this.ErrorMessage_NoDeviceFound, "NoDeviceFound"));
}
}
- })
+ });
const listenTimeoutId = listenTimeout ? setTimeout(() => {
- sub.unsubscribe()
- reject(new TransportError(this.ErrorMessage_ListenTimeout, "ListenTimeout"))
- }, listenTimeout) : null
- })
+ sub.unsubscribe();
+ reject(new TransportError(this.ErrorMessage_ListenTimeout, "ListenTimeout"));
+ }, listenTimeout) : null;
+ });
}
/**
* Wrapper to make an exchange "atomic" (blocking any other exchange)
* @param f The exchange job, using the transport to run
* @returns a Promise resolving with the output of the given job
*/
- exchangeAtomicImpl (f) {
+ exchangeAtomicImpl(f) {
return __awaiter(this, void 0, void 0, function* () {
const tracer = this.tracer.withUpdatedContext({
function: "exchangeAtomicImpl",
unresponsiveTimeout: this.unresponsiveTimeout
- })
+ });
if (this.exchangeBusyPromise) {
- tracer.trace("Atomic exchange is already busy")
- throw new TransportRaceCondition("An action was already pending on the Ledger device. Please deny or reconnect.")
+ tracer.trace("Atomic exchange is already busy");
+ throw new TransportRaceCondition("An action was already pending on the Ledger device. Please deny or reconnect.");
}
- let resolveBusy
+ let resolveBusy;
const busyPromise = new Promise((r) => {
- resolveBusy = r
- })
- this.exchangeBusyPromise = busyPromise
- let unresponsiveReached = false
+ resolveBusy = r;
+ });
+ this.exchangeBusyPromise = busyPromise;
+ let unresponsiveReached = false;
const timeout = setTimeout(() => {
tracer.trace(`Timeout reached, emitting Transport event "unresponsive"`, {
unresponsiveTimeout: this.unresponsiveTimeout
- })
- unresponsiveReached = true
- this.emit("unresponsive")
- }, this.unresponsiveTimeout)
+ });
+ unresponsiveReached = true;
+ this.emit("unresponsive");
+ }, this.unresponsiveTimeout);
try {
- const res = yield f()
+ const res = yield f();
if (unresponsiveReached) {
- tracer.trace("Device was unresponsive, emitting responsive")
- this.emit("responsive")
+ tracer.trace("Device was unresponsive, emitting responsive");
+ this.emit("responsive");
}
- return res
+ return res;
} finally {
- tracer.trace("Finalize, clearing busy guard")
- clearTimeout(timeout)
+ tracer.trace("Finalize, clearing busy guard");
+ clearTimeout(timeout);
if (resolveBusy)
- resolveBusy()
- this.exchangeBusyPromise = null
+ resolveBusy();
+ this.exchangeBusyPromise = null;
}
- })
+ });
}
- decorateAppAPIMethods (self, methods, scrambleKey) {
+ decorateAppAPIMethods(self, methods, scrambleKey) {
for (const methodName of methods) {
- self[methodName] = this.decorateAppAPIMethod(methodName, self[methodName], self, scrambleKey)
+ self[methodName] = this.decorateAppAPIMethod(methodName, self[methodName], self, scrambleKey);
}
}
- decorateAppAPIMethod (methodName, f, ctx, scrambleKey) {
+ decorateAppAPIMethod(methodName, f, ctx, scrambleKey) {
return (...args) => __awaiter(this, void 0, void 0, function* () {
- const { _appAPIlock } = this
+ const { _appAPIlock } = this;
if (_appAPIlock) {
- return Promise.reject(new TransportError("Ledger Device is busy (lock " + _appAPIlock + ")", "TransportLocked"))
+ return Promise.reject(new TransportError("Ledger Device is busy (lock " + _appAPIlock + ")", "TransportLocked"));
}
try {
- this._appAPIlock = methodName
- this.setScrambleKey(scrambleKey)
- return yield f.apply(ctx, args)
+ this._appAPIlock = methodName;
+ this.setScrambleKey(scrambleKey);
+ return yield f.apply(ctx, args);
} finally {
- this._appAPIlock = null
+ this._appAPIlock = null;
}
- })
+ });
}
/**
* Sets the context used by the logging/tracing mechanism
*
* @param context A TraceContext, that can undefined to reset the context
*/
- setTraceContext (context2) {
- this.tracer = this.tracer.withContext(context2)
+ setTraceContext(context2) {
+ this.tracer = this.tracer.withContext(context2);
}
/**
* Updates the context used by the logging/tracing mechanism
*
* @param contextToAdd A TraceContext that will be added to the current context
*/
- updateTraceContext (contextToAdd) {
- this.tracer.updateContext(contextToAdd)
+ updateTraceContext(contextToAdd) {
+ this.tracer.updateContext(contextToAdd);
}
/**
* Gets the tracing context of the transport instance
*/
- getTraceContext () {
- return this.tracer.getContext()
+ getTraceContext() {
+ return this.tracer.getContext();
}
- }
- Transport.ErrorMessage_ListenTimeout = "No Ledger device found (timeout)"
- Transport.ErrorMessage_NoDeviceFound = "No Ledger device found"
- Transport_default = Transport
+ };
+ Transport.ErrorMessage_ListenTimeout = "No Ledger device found (timeout)";
+ Transport.ErrorMessage_NoDeviceFound = "No Ledger device found";
+ Transport_default = Transport;
}
-})
+});
// node_modules/semver/internal/constants.js
var require_constants = __commonJS({
- "node_modules/semver/internal/constants.js" (exports, module) {
- var SEMVER_SPEC_VERSION = "2.0.0"
- var MAX_LENGTH = 256
+ "node_modules/semver/internal/constants.js"(exports, module) {
+ var SEMVER_SPEC_VERSION = "2.0.0";
+ var MAX_LENGTH = 256;
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
- 9007199254740991
- var MAX_SAFE_COMPONENT_LENGTH = 16
- var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6
+ 9007199254740991;
+ var MAX_SAFE_COMPONENT_LENGTH = 16;
+ var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
var RELEASE_TYPES = [
"major",
"premajor",
"patch",
"prepatch",
"prerelease"
- ]
+ ];
module.exports = {
MAX_LENGTH,
MAX_SAFE_COMPONENT_LENGTH,
SEMVER_SPEC_VERSION,
FLAG_INCLUDE_PRERELEASE: 1,
FLAG_LOOSE: 2
- }
+ };
}
-})
+});
// node_modules/semver/internal/debug.js
var require_debug = __commonJS({
- "node_modules/semver/internal/debug.js" (exports, module) {
+ "node_modules/semver/internal/debug.js"(exports, module) {
var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
- }
- module.exports = debug
+ };
+ module.exports = debug;
}
-})
+});
// node_modules/semver/internal/re.js
var require_re = __commonJS({
- "node_modules/semver/internal/re.js" (exports, module) {
+ "node_modules/semver/internal/re.js"(exports, module) {
var {
MAX_SAFE_COMPONENT_LENGTH,
MAX_SAFE_BUILD_LENGTH,
MAX_LENGTH
- } = require_constants()
- var debug = require_debug()
- exports = module.exports = {}
- var re = exports.re = []
- var safeRe = exports.safeRe = []
- var src = exports.src = []
- var t = exports.t = {}
- var R = 0
- var LETTERDASHNUMBER = "[a-zA-Z0-9-]"
+ } = require_constants();
+ var debug = require_debug();
+ exports = module.exports = {};
+ var re = exports.re = [];
+ var safeRe = exports.safeRe = [];
+ var src = exports.src = [];
+ var t = exports.t = {};
+ var R = 0;
+ var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
var safeRegexReplacements = [
["\\s", 1],
["\\d", MAX_LENGTH],
[LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
- ]
+ ];
var makeSafeRegex = (value) => {
for (const [token, max] of safeRegexReplacements) {
- value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`)
+ value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
}
- return value
- }
+ return value;
+ };
var createToken = (name, value, isGlobal) => {
- const safe = makeSafeRegex(value)
- const index = R++
- debug(name, index, value)
- t[name] = index
- src[index] = value
- re[index] = new RegExp(value, isGlobal ? "g" : void 0)
- safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0)
- }
- createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*")
- createToken("NUMERICIDENTIFIERLOOSE", "\\d+")
- createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`)
- createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`)
- createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`)
- createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`)
- createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`)
- createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`)
- createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)
- createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`)
- createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`)
- createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`)
- createToken("FULL", `^${src[t.FULLPLAIN]}$`)
- createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`)
- createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`)
- createToken("GTLT", "((?:<|>)?=?)")
- createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
- createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
- createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`)
- createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`)
- createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`)
- createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`)
- createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`)
- createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`)
- createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`)
- createToken("COERCERTL", src[t.COERCE], true)
- createToken("COERCERTLFULL", src[t.COERCEFULL], true)
- createToken("LONETILDE", "(?:~>?)")
- createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true)
- exports.tildeTrimReplace = "$1~"
- createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)
- createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)
- createToken("LONECARET", "(?:\\^)")
- createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true)
- exports.caretTrimReplace = "$1^"
- createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)
- createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)
- createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`)
- createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`)
- createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)
- exports.comparatorTrimReplace = "$1$2$3"
- createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`)
- createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`)
- createToken("STAR", "(<|>)?=?\\s*\\*")
- createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$")
- createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$")
- }
-})
+ const safe = makeSafeRegex(value);
+ const index = R++;
+ debug(name, index, value);
+ t[name] = index;
+ src[index] = value;
+ re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+ safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+ };
+ createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+ createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+ createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+ createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+ createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+ createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
+ createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
+ createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
+ createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+ createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+ createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+ createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+ createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+ createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+ createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+ createToken("GTLT", "((?:<|>)?=?)");
+ createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+ createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+ createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+ createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+ createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+ createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+ createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+ createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
+ createToken("COERCERTL", src[t.COERCE], true);
+ createToken("COERCERTLFULL", src[t.COERCEFULL], true);
+ createToken("LONETILDE", "(?:~>?)");
+ createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
+ exports.tildeTrimReplace = "$1~";
+ createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
+ createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("LONECARET", "(?:\\^)");
+ createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
+ exports.caretTrimReplace = "$1^";
+ createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
+ createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
+ createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
+ createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
+ createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
+ exports.comparatorTrimReplace = "$1$2$3";
+ createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+ createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+ createToken("STAR", "(<|>)?=?\\s*\\*");
+ createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+ createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+ }
+});
// node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({
- "node_modules/semver/internal/parse-options.js" (exports, module) {
- var looseOption = Object.freeze({ loose: true })
- var emptyOpts = Object.freeze({})
+ "node_modules/semver/internal/parse-options.js"(exports, module) {
+ var looseOption = Object.freeze({ loose: true });
+ var emptyOpts = Object.freeze({});
var parseOptions = (options) => {
if (!options) {
- return emptyOpts
+ return emptyOpts;
}
if (typeof options !== "object") {
- return looseOption
+ return looseOption;
}
- return options
- }
- module.exports = parseOptions
+ return options;
+ };
+ module.exports = parseOptions;
}
-})
+});
// node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({
- "node_modules/semver/internal/identifiers.js" (exports, module) {
- var numeric = /^[0-9]+$/
+ "node_modules/semver/internal/identifiers.js"(exports, module) {
+ var numeric = /^[0-9]+$/;
var compareIdentifiers = (a, b) => {
- const anum = numeric.test(a)
- const bnum = numeric.test(b)
+ const anum = numeric.test(a);
+ const bnum = numeric.test(b);
if (anum && bnum) {
- a = +a
- b = +b
+ a = +a;
+ b = +b;
}
- return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1
- }
- var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
+ return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+ };
+ var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
module.exports = {
compareIdentifiers,
rcompareIdentifiers
- }
+ };
}
-})
+});
// node_modules/semver/classes/semver.js
var require_semver = __commonJS({
- "node_modules/semver/classes/semver.js" (exports, module) {
- var debug = require_debug()
- var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants()
- var { safeRe: re, t } = require_re()
- var parseOptions = require_parse_options()
- var { compareIdentifiers } = require_identifiers()
+ "node_modules/semver/classes/semver.js"(exports, module) {
+ var debug = require_debug();
+ var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+ var { safeRe: re, t } = require_re();
+ var parseOptions = require_parse_options();
+ var { compareIdentifiers } = require_identifiers();
var SemVer = class _SemVer {
constructor(version, options) {
- options = parseOptions(options)
+ options = parseOptions(options);
if (version instanceof _SemVer) {
if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
- return version
+ return version;
} else {
- version = version.version
+ version = version.version;
}
} else if (typeof version !== "string") {
- throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
+ throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
}
if (version.length > MAX_LENGTH) {
throw new TypeError(
`version is longer than ${MAX_LENGTH} characters`
- )
+ );
}
- debug("SemVer", version, options)
- this.options = options
- this.loose = !!options.loose
- this.includePrerelease = !!options.includePrerelease
- const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
+ debug("SemVer", version, options);
+ this.options = options;
+ this.loose = !!options.loose;
+ this.includePrerelease = !!options.includePrerelease;
+ const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
if (!m) {
- throw new TypeError(`Invalid Version: ${version}`)
+ throw new TypeError(`Invalid Version: ${version}`);
}
- this.raw = version
- this.major = +m[1]
- this.minor = +m[2]
- this.patch = +m[3]
+ this.raw = version;
+ this.major = +m[1];
+ this.minor = +m[2];
+ this.patch = +m[3];
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
- throw new TypeError("Invalid major version")
+ throw new TypeError("Invalid major version");
}
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
- throw new TypeError("Invalid minor version")
+ throw new TypeError("Invalid minor version");
}
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
- throw new TypeError("Invalid patch version")
+ throw new TypeError("Invalid patch version");
}
if (!m[4]) {
- this.prerelease = []
+ this.prerelease = [];
} else {
this.prerelease = m[4].split(".").map((id2) => {
if (/^[0-9]+$/.test(id2)) {
- const num = +id2
+ const num = +id2;
if (num >= 0 && num < MAX_SAFE_INTEGER) {
- return num
+ return num;
}
}
- return id2
- })
+ return id2;
+ });
}
- this.build = m[5] ? m[5].split(".") : []
- this.format()
+ this.build = m[5] ? m[5].split(".") : [];
+ this.format();
}
- format () {
- this.version = `${this.major}.${this.minor}.${this.patch}`
+ format() {
+ this.version = `${this.major}.${this.minor}.${this.patch}`;
if (this.prerelease.length) {
- this.version += `-${this.prerelease.join(".")}`
+ this.version += `-${this.prerelease.join(".")}`;
}
- return this.version
+ return this.version;
}
- toString () {
- return this.version
+ toString() {
+ return this.version;
}
- compare (other) {
- debug("SemVer.compare", this.version, this.options, other)
+ compare(other) {
+ debug("SemVer.compare", this.version, this.options, other);
if (!(other instanceof _SemVer)) {
if (typeof other === "string" && other === this.version) {
- return 0
+ return 0;
}
- other = new _SemVer(other, this.options)
+ other = new _SemVer(other, this.options);
}
if (other.version === this.version) {
- return 0
+ return 0;
}
- return this.compareMain(other) || this.comparePre(other)
+ return this.compareMain(other) || this.comparePre(other);
}
- compareMain (other) {
+ compareMain(other) {
if (!(other instanceof _SemVer)) {
- other = new _SemVer(other, this.options)
+ other = new _SemVer(other, this.options);
}
- return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch)
+ return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
}
- comparePre (other) {
+ comparePre(other) {
if (!(other instanceof _SemVer)) {
- other = new _SemVer(other, this.options)
+ other = new _SemVer(other, this.options);
}
if (this.prerelease.length && !other.prerelease.length) {
- return -1
+ return -1;
} else if (!this.prerelease.length && other.prerelease.length) {
- return 1
+ return 1;
} else if (!this.prerelease.length && !other.prerelease.length) {
- return 0
+ return 0;
}
- let i = 0
+ let i = 0;
do {
- const a = this.prerelease[i]
- const b = other.prerelease[i]
- debug("prerelease compare", i, a, b)
+ const a = this.prerelease[i];
+ const b = other.prerelease[i];
+ debug("prerelease compare", i, a, b);
if (a === void 0 && b === void 0) {
- return 0
+ return 0;
} else if (b === void 0) {
- return 1
+ return 1;
} else if (a === void 0) {
- return -1
+ return -1;
} else if (a === b) {
- continue
+ continue;
} else {
- return compareIdentifiers(a, b)
+ return compareIdentifiers(a, b);
}
- } while (++i)
+ } while (++i);
}
- compareBuild (other) {
+ compareBuild(other) {
if (!(other instanceof _SemVer)) {
- other = new _SemVer(other, this.options)
+ other = new _SemVer(other, this.options);
}
- let i = 0
+ let i = 0;
do {
- const a = this.build[i]
- const b = other.build[i]
- debug("build compare", i, a, b)
+ const a = this.build[i];
+ const b = other.build[i];
+ debug("build compare", i, a, b);
if (a === void 0 && b === void 0) {
- return 0
+ return 0;
} else if (b === void 0) {
- return 1
+ return 1;
} else if (a === void 0) {
- return -1
+ return -1;
} else if (a === b) {
- continue
+ continue;
} else {
- return compareIdentifiers(a, b)
+ return compareIdentifiers(a, b);
}
- } while (++i)
+ } while (++i);
}
// preminor will bump the version up to the next minor release, and immediately
// down to pre-release. premajor and prepatch work the same way.
- inc (release, identifier, identifierBase) {
+ inc(release, identifier, identifierBase) {
switch (release) {
case "premajor":
- this.prerelease.length = 0
- this.patch = 0
- this.minor = 0
- this.major++
- this.inc("pre", identifier, identifierBase)
- break
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor = 0;
+ this.major++;
+ this.inc("pre", identifier, identifierBase);
+ break;
case "preminor":
- this.prerelease.length = 0
- this.patch = 0
- this.minor++
- this.inc("pre", identifier, identifierBase)
- break
+ this.prerelease.length = 0;
+ this.patch = 0;
+ this.minor++;
+ this.inc("pre", identifier, identifierBase);
+ break;
case "prepatch":
- this.prerelease.length = 0
- this.inc("patch", identifier, identifierBase)
- this.inc("pre", identifier, identifierBase)
- break
+ this.prerelease.length = 0;
+ this.inc("patch", identifier, identifierBase);
+ this.inc("pre", identifier, identifierBase);
+ break;
// If the input is a non-prerelease version, this acts the same as
// prepatch.
case "prerelease":
if (this.prerelease.length === 0) {
- this.inc("patch", identifier, identifierBase)
+ this.inc("patch", identifier, identifierBase);
}
- this.inc("pre", identifier, identifierBase)
- break
+ this.inc("pre", identifier, identifierBase);
+ break;
case "major":
if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
- this.major++
+ this.major++;
}
- this.minor = 0
- this.patch = 0
- this.prerelease = []
- break
+ this.minor = 0;
+ this.patch = 0;
+ this.prerelease = [];
+ break;
case "minor":
if (this.patch !== 0 || this.prerelease.length === 0) {
- this.minor++
+ this.minor++;
}
- this.patch = 0
- this.prerelease = []
- break
+ this.patch = 0;
+ this.prerelease = [];
+ break;
case "patch":
if (this.prerelease.length === 0) {
- this.patch++
+ this.patch++;
}
- this.prerelease = []
- break
+ this.prerelease = [];
+ break;
// This probably shouldn't be used publicly.
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
case "pre": {
- const base = Number(identifierBase) ? 1 : 0
+ const base = Number(identifierBase) ? 1 : 0;
if (!identifier && identifierBase === false) {
- throw new Error("invalid increment argument: identifier is empty")
+ throw new Error("invalid increment argument: identifier is empty");
}
if (this.prerelease.length === 0) {
- this.prerelease = [base]
+ this.prerelease = [base];
} else {
- let i = this.prerelease.length
+ let i = this.prerelease.length;
while (--i >= 0) {
if (typeof this.prerelease[i] === "number") {
- this.prerelease[i]++
- i = -2
+ this.prerelease[i]++;
+ i = -2;
}
}
if (i === -1) {
if (identifier === this.prerelease.join(".") && identifierBase === false) {
- throw new Error("invalid increment argument: identifier already exists")
+ throw new Error("invalid increment argument: identifier already exists");
}
- this.prerelease.push(base)
+ this.prerelease.push(base);
}
}
if (identifier) {
- let prerelease = [identifier, base]
+ let prerelease = [identifier, base];
if (identifierBase === false) {
- prerelease = [identifier]
+ prerelease = [identifier];
}
if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
if (isNaN(this.prerelease[1])) {
- this.prerelease = prerelease
+ this.prerelease = prerelease;
}
} else {
- this.prerelease = prerelease
+ this.prerelease = prerelease;
}
}
- break
+ break;
}
default:
- throw new Error(`invalid increment argument: ${release}`)
+ throw new Error(`invalid increment argument: ${release}`);
}
- this.raw = this.format()
+ this.raw = this.format();
if (this.build.length) {
- this.raw += `+${this.build.join(".")}`
+ this.raw += `+${this.build.join(".")}`;
}
- return this
+ return this;
}
- }
- module.exports = SemVer
+ };
+ module.exports = SemVer;
}
-})
+});
// node_modules/semver/functions/parse.js
var require_parse = __commonJS({
- "node_modules/semver/functions/parse.js" (exports, module) {
- var SemVer = require_semver()
+ "node_modules/semver/functions/parse.js"(exports, module) {
+ var SemVer = require_semver();
var parse = (version, options, throwErrors = false) => {
if (version instanceof SemVer) {
- return version
+ return version;
}
try {
- return new SemVer(version, options)
+ return new SemVer(version, options);
} catch (er) {
if (!throwErrors) {
- return null
+ return null;
}
- throw er
+ throw er;
}
- }
- module.exports = parse
+ };
+ module.exports = parse;
}
-})
+});
// node_modules/semver/functions/valid.js
var require_valid = __commonJS({
- "node_modules/semver/functions/valid.js" (exports, module) {
- var parse = require_parse()
+ "node_modules/semver/functions/valid.js"(exports, module) {
+ var parse = require_parse();
var valid = (version, options) => {
- const v = parse(version, options)
- return v ? v.version : null
- }
- module.exports = valid
+ const v = parse(version, options);
+ return v ? v.version : null;
+ };
+ module.exports = valid;
}
-})
+});
// node_modules/semver/functions/clean.js
var require_clean = __commonJS({
- "node_modules/semver/functions/clean.js" (exports, module) {
- var parse = require_parse()
+ "node_modules/semver/functions/clean.js"(exports, module) {
+ var parse = require_parse();
var clean = (version, options) => {
- const s = parse(version.trim().replace(/^[=v]+/, ""), options)
- return s ? s.version : null
- }
- module.exports = clean
+ const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+ return s ? s.version : null;
+ };
+ module.exports = clean;
}
-})
+});
// node_modules/semver/functions/inc.js
var require_inc = __commonJS({
- "node_modules/semver/functions/inc.js" (exports, module) {
- var SemVer = require_semver()
+ "node_modules/semver/functions/inc.js"(exports, module) {
+ var SemVer = require_semver();
var inc = (version, release, options, identifier, identifierBase) => {
if (typeof options === "string") {
- identifierBase = identifier
- identifier = options
- options = void 0
+ identifierBase = identifier;
+ identifier = options;
+ options = void 0;
}
try {
return new SemVer(
version instanceof SemVer ? version.version : version,
options
- ).inc(release, identifier, identifierBase).version
+ ).inc(release, identifier, identifierBase).version;
} catch (er) {
- return null
+ return null;
}
- }
- module.exports = inc
+ };
+ module.exports = inc;
}
-})
+});
// node_modules/semver/functions/diff.js
var require_diff = __commonJS({
- "node_modules/semver/functions/diff.js" (exports, module) {
- var parse = require_parse()
+ "node_modules/semver/functions/diff.js"(exports, module) {
+ var parse = require_parse();
var diff = (version1, version2) => {
- const v1 = parse(version1, null, true)
- const v2 = parse(version2, null, true)
- const comparison = v1.compare(v2)
+ const v1 = parse(version1, null, true);
+ const v2 = parse(version2, null, true);
+ const comparison = v1.compare(v2);
if (comparison === 0) {
- return null
+ return null;
}
- const v1Higher = comparison > 0
- const highVersion = v1Higher ? v1 : v2
- const lowVersion = v1Higher ? v2 : v1
- const highHasPre = !!highVersion.prerelease.length
- const lowHasPre = !!lowVersion.prerelease.length
+ const v1Higher = comparison > 0;
+ const highVersion = v1Higher ? v1 : v2;
+ const lowVersion = v1Higher ? v2 : v1;
+ const highHasPre = !!highVersion.prerelease.length;
+ const lowHasPre = !!lowVersion.prerelease.length;
if (lowHasPre && !highHasPre) {
if (!lowVersion.patch && !lowVersion.minor) {
- return "major"
+ return "major";
}
if (highVersion.patch) {
- return "patch"
+ return "patch";
}
if (highVersion.minor) {
- return "minor"
+ return "minor";
}
- return "major"
+ return "major";
}
- const prefix = highHasPre ? "pre" : ""
+ const prefix = highHasPre ? "pre" : "";
if (v1.major !== v2.major) {
- return prefix + "major"
+ return prefix + "major";
}
if (v1.minor !== v2.minor) {
- return prefix + "minor"
+ return prefix + "minor";
}
if (v1.patch !== v2.patch) {
- return prefix + "patch"
+ return prefix + "patch";
}
- return "prerelease"
- }
- module.exports = diff
+ return "prerelease";
+ };
+ module.exports = diff;
}
-})
+});
// node_modules/semver/functions/major.js
var require_major = __commonJS({
- "node_modules/semver/functions/major.js" (exports, module) {
- var SemVer = require_semver()
- var major = (a, loose) => new SemVer(a, loose).major
- module.exports = major
+ "node_modules/semver/functions/major.js"(exports, module) {
+ var SemVer = require_semver();
+ var major = (a, loose) => new SemVer(a, loose).major;
+ module.exports = major;
}
-})
+});
// node_modules/semver/functions/minor.js
var require_minor = __commonJS({
- "node_modules/semver/functions/minor.js" (exports, module) {
- var SemVer = require_semver()
- var minor = (a, loose) => new SemVer(a, loose).minor
- module.exports = minor
+ "node_modules/semver/functions/minor.js"(exports, module) {
+ var SemVer = require_semver();
+ var minor = (a, loose) => new SemVer(a, loose).minor;
+ module.exports = minor;
}
-})
+});
// node_modules/semver/functions/patch.js
var require_patch = __commonJS({
- "node_modules/semver/functions/patch.js" (exports, module) {
- var SemVer = require_semver()
- var patch = (a, loose) => new SemVer(a, loose).patch
- module.exports = patch
+ "node_modules/semver/functions/patch.js"(exports, module) {
+ var SemVer = require_semver();
+ var patch = (a, loose) => new SemVer(a, loose).patch;
+ module.exports = patch;
}
-})
+});
// node_modules/semver/functions/prerelease.js
var require_prerelease = __commonJS({
- "node_modules/semver/functions/prerelease.js" (exports, module) {
- var parse = require_parse()
+ "node_modules/semver/functions/prerelease.js"(exports, module) {
+ var parse = require_parse();
var prerelease = (version, options) => {
- const parsed = parse(version, options)
- return parsed && parsed.prerelease.length ? parsed.prerelease : null
- }
- module.exports = prerelease
+ const parsed = parse(version, options);
+ return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+ };
+ module.exports = prerelease;
}
-})
+});
// node_modules/semver/functions/compare.js
var require_compare = __commonJS({
- "node_modules/semver/functions/compare.js" (exports, module) {
- var SemVer = require_semver()
- var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose))
- module.exports = compare
+ "node_modules/semver/functions/compare.js"(exports, module) {
+ var SemVer = require_semver();
+ var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+ module.exports = compare;
}
-})
+});
// node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({
- "node_modules/semver/functions/rcompare.js" (exports, module) {
- var compare = require_compare()
- var rcompare = (a, b, loose) => compare(b, a, loose)
- module.exports = rcompare
+ "node_modules/semver/functions/rcompare.js"(exports, module) {
+ var compare = require_compare();
+ var rcompare = (a, b, loose) => compare(b, a, loose);
+ module.exports = rcompare;
}
-})
+});
// node_modules/semver/functions/compare-loose.js
var require_compare_loose = __commonJS({
- "node_modules/semver/functions/compare-loose.js" (exports, module) {
- var compare = require_compare()
- var compareLoose = (a, b) => compare(a, b, true)
- module.exports = compareLoose
+ "node_modules/semver/functions/compare-loose.js"(exports, module) {
+ var compare = require_compare();
+ var compareLoose = (a, b) => compare(a, b, true);
+ module.exports = compareLoose;
}
-})
+});
// node_modules/semver/functions/compare-build.js
var require_compare_build = __commonJS({
- "node_modules/semver/functions/compare-build.js" (exports, module) {
- var SemVer = require_semver()
+ "node_modules/semver/functions/compare-build.js"(exports, module) {
+ var SemVer = require_semver();
var compareBuild = (a, b, loose) => {
- const versionA = new SemVer(a, loose)
- const versionB = new SemVer(b, loose)
- return versionA.compare(versionB) || versionA.compareBuild(versionB)
- }
- module.exports = compareBuild
+ const versionA = new SemVer(a, loose);
+ const versionB = new SemVer(b, loose);
+ return versionA.compare(versionB) || versionA.compareBuild(versionB);
+ };
+ module.exports = compareBuild;
}
-})
+});
// node_modules/semver/functions/sort.js
var require_sort = __commonJS({
- "node_modules/semver/functions/sort.js" (exports, module) {
- var compareBuild = require_compare_build()
- var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
- module.exports = sort
+ "node_modules/semver/functions/sort.js"(exports, module) {
+ var compareBuild = require_compare_build();
+ var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+ module.exports = sort;
}
-})
+});
// node_modules/semver/functions/rsort.js
var require_rsort = __commonJS({
- "node_modules/semver/functions/rsort.js" (exports, module) {
- var compareBuild = require_compare_build()
- var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
- module.exports = rsort
+ "node_modules/semver/functions/rsort.js"(exports, module) {
+ var compareBuild = require_compare_build();
+ var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+ module.exports = rsort;
}
-})
+});
// node_modules/semver/functions/gt.js
var require_gt = __commonJS({
- "node_modules/semver/functions/gt.js" (exports, module) {
- var compare = require_compare()
- var gt = (a, b, loose) => compare(a, b, loose) > 0
- module.exports = gt
+ "node_modules/semver/functions/gt.js"(exports, module) {
+ var compare = require_compare();
+ var gt = (a, b, loose) => compare(a, b, loose) > 0;
+ module.exports = gt;
}
-})
+});
// node_modules/semver/functions/lt.js
var require_lt = __commonJS({
- "node_modules/semver/functions/lt.js" (exports, module) {
- var compare = require_compare()
- var lt = (a, b, loose) => compare(a, b, loose) < 0
- module.exports = lt
+ "node_modules/semver/functions/lt.js"(exports, module) {
+ var compare = require_compare();
+ var lt = (a, b, loose) => compare(a, b, loose) < 0;
+ module.exports = lt;
}
-})
+});
// node_modules/semver/functions/eq.js
var require_eq = __commonJS({
- "node_modules/semver/functions/eq.js" (exports, module) {
- var compare = require_compare()
- var eq = (a, b, loose) => compare(a, b, loose) === 0
- module.exports = eq
+ "node_modules/semver/functions/eq.js"(exports, module) {
+ var compare = require_compare();
+ var eq = (a, b, loose) => compare(a, b, loose) === 0;
+ module.exports = eq;
}
-})
+});
// node_modules/semver/functions/neq.js
var require_neq = __commonJS({
- "node_modules/semver/functions/neq.js" (exports, module) {
- var compare = require_compare()
- var neq = (a, b, loose) => compare(a, b, loose) !== 0
- module.exports = neq
+ "node_modules/semver/functions/neq.js"(exports, module) {
+ var compare = require_compare();
+ var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+ module.exports = neq;
}
-})
+});
// node_modules/semver/functions/gte.js
var require_gte = __commonJS({
- "node_modules/semver/functions/gte.js" (exports, module) {
- var compare = require_compare()
- var gte = (a, b, loose) => compare(a, b, loose) >= 0
- module.exports = gte
+ "node_modules/semver/functions/gte.js"(exports, module) {
+ var compare = require_compare();
+ var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+ module.exports = gte;
}
-})
+});
// node_modules/semver/functions/lte.js
var require_lte = __commonJS({
- "node_modules/semver/functions/lte.js" (exports, module) {
- var compare = require_compare()
- var lte = (a, b, loose) => compare(a, b, loose) <= 0
- module.exports = lte
+ "node_modules/semver/functions/lte.js"(exports, module) {
+ var compare = require_compare();
+ var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+ module.exports = lte;
}
-})
+});
// node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({
- "node_modules/semver/functions/cmp.js" (exports, module) {
- var eq = require_eq()
- var neq = require_neq()
- var gt = require_gt()
- var gte = require_gte()
- var lt = require_lt()
- var lte = require_lte()
+ "node_modules/semver/functions/cmp.js"(exports, module) {
+ var eq = require_eq();
+ var neq = require_neq();
+ var gt = require_gt();
+ var gte = require_gte();
+ var lt = require_lt();
+ var lte = require_lte();
var cmp = (a, op, b, loose) => {
switch (op) {
case "===":
if (typeof a === "object") {
- a = a.version
+ a = a.version;
}
if (typeof b === "object") {
- b = b.version
+ b = b.version;
}
- return a === b
+ return a === b;
case "!==":
if (typeof a === "object") {
- a = a.version
+ a = a.version;
}
if (typeof b === "object") {
- b = b.version
+ b = b.version;
}
- return a !== b
+ return a !== b;
case "":
case "=":
case "==":
- return eq(a, b, loose)
+ return eq(a, b, loose);
case "!=":
- return neq(a, b, loose)
+ return neq(a, b, loose);
case ">":
- return gt(a, b, loose)
+ return gt(a, b, loose);
case ">=":
- return gte(a, b, loose)
+ return gte(a, b, loose);
case "<":
- return lt(a, b, loose)
+ return lt(a, b, loose);
case "<=":
- return lte(a, b, loose)
+ return lte(a, b, loose);
default:
- throw new TypeError(`Invalid operator: ${op}`)
+ throw new TypeError(`Invalid operator: ${op}`);
}
- }
- module.exports = cmp
+ };
+ module.exports = cmp;
}
-})
+});
// node_modules/semver/functions/coerce.js
var require_coerce = __commonJS({
- "node_modules/semver/functions/coerce.js" (exports, module) {
- var SemVer = require_semver()
- var parse = require_parse()
- var { safeRe: re, t } = require_re()
+ "node_modules/semver/functions/coerce.js"(exports, module) {
+ var SemVer = require_semver();
+ var parse = require_parse();
+ var { safeRe: re, t } = require_re();
var coerce = (version, options) => {
if (version instanceof SemVer) {
- return version
+ return version;
}
if (typeof version === "number") {
- version = String(version)
+ version = String(version);
}
if (typeof version !== "string") {
- return null
+ return null;
}
- options = options || {}
- let match = null
+ options = options || {};
+ let match = null;
if (!options.rtl) {
- match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE])
+ match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
} else {
- const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]
- let next
+ const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+ let next;
while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
if (!match || next.index + next[0].length !== match.index + match[0].length) {
- match = next
+ match = next;
}
- coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length
+ coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
}
- coerceRtlRegex.lastIndex = -1
+ coerceRtlRegex.lastIndex = -1;
}
if (match === null) {
- return null
- }
- const major = match[2]
- const minor = match[3] || "0"
- const patch = match[4] || "0"
- const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ""
- const build = options.includePrerelease && match[6] ? `+${match[6]}` : ""
- return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)
- }
- module.exports = coerce
+ return null;
+ }
+ const major = match[2];
+ const minor = match[3] || "0";
+ const patch = match[4] || "0";
+ const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
+ const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+ return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+ };
+ module.exports = coerce;
}
-})
+});
// node_modules/semver/internal/lrucache.js
var require_lrucache = __commonJS({
- "node_modules/semver/internal/lrucache.js" (exports, module) {
+ "node_modules/semver/internal/lrucache.js"(exports, module) {
var LRUCache = class {
constructor() {
- this.max = 1e3
- this.map = /* @__PURE__ */ new Map()
+ this.max = 1e3;
+ this.map = /* @__PURE__ */ new Map();
}
- get (key) {
- const value = this.map.get(key)
+ get(key) {
+ const value = this.map.get(key);
if (value === void 0) {
- return void 0
+ return void 0;
} else {
- this.map.delete(key)
- this.map.set(key, value)
- return value
+ this.map.delete(key);
+ this.map.set(key, value);
+ return value;
}
}
- delete (key) {
- return this.map.delete(key)
+ delete(key) {
+ return this.map.delete(key);
}
- set (key, value) {
- const deleted = this.delete(key)
+ set(key, value) {
+ const deleted = this.delete(key);
if (!deleted && value !== void 0) {
if (this.map.size >= this.max) {
- const firstKey = this.map.keys().next().value
- this.delete(firstKey)
+ const firstKey = this.map.keys().next().value;
+ this.delete(firstKey);
}
- this.map.set(key, value)
+ this.map.set(key, value);
}
- return this
+ return this;
}
- }
- module.exports = LRUCache
+ };
+ module.exports = LRUCache;
}
-})
+});
// node_modules/semver/classes/range.js
var require_range = __commonJS({
- "node_modules/semver/classes/range.js" (exports, module) {
- var SPACE_CHARACTERS = /\s+/g
+ "node_modules/semver/classes/range.js"(exports, module) {
+ var SPACE_CHARACTERS = /\s+/g;
var Range = class _Range {
constructor(range, options) {
- options = parseOptions(options)
+ options = parseOptions(options);
if (range instanceof _Range) {
if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
- return range
+ return range;
} else {
- return new _Range(range.raw, options)
+ return new _Range(range.raw, options);
}
}
if (range instanceof Comparator) {
- this.raw = range.value
- this.set = [[range]]
- this.formatted = void 0
- return this
- }
- this.options = options
- this.loose = !!options.loose
- this.includePrerelease = !!options.includePrerelease
- this.raw = range.trim().replace(SPACE_CHARACTERS, " ")
- this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length)
+ this.raw = range.value;
+ this.set = [[range]];
+ this.formatted = void 0;
+ return this;
+ }
+ this.options = options;
+ this.loose = !!options.loose;
+ this.includePrerelease = !!options.includePrerelease;
+ this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+ this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
if (!this.set.length) {
- throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
+ throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
}
if (this.set.length > 1) {
- const first2 = this.set[0]
- this.set = this.set.filter((c) => !isNullSet(c[0]))
+ const first2 = this.set[0];
+ this.set = this.set.filter((c) => !isNullSet(c[0]));
if (this.set.length === 0) {
- this.set = [first2]
+ this.set = [first2];
} else if (this.set.length > 1) {
for (const c of this.set) {
if (c.length === 1 && isAny(c[0])) {
- this.set = [c]
- break
+ this.set = [c];
+ break;
}
}
}
}
- this.formatted = void 0
+ this.formatted = void 0;
}
- get range () {
+ get range() {
if (this.formatted === void 0) {
- this.formatted = ""
+ this.formatted = "";
for (let i = 0; i < this.set.length; i++) {
if (i > 0) {
- this.formatted += "||"
+ this.formatted += "||";
}
- const comps = this.set[i]
+ const comps = this.set[i];
for (let k = 0; k < comps.length; k++) {
if (k > 0) {
- this.formatted += " "
+ this.formatted += " ";
}
- this.formatted += comps[k].toString().trim()
+ this.formatted += comps[k].toString().trim();
}
}
}
- return this.formatted
+ return this.formatted;
}
- format () {
- return this.range
+ format() {
+ return this.range;
}
- toString () {
- return this.range
+ toString() {
+ return this.range;
}
- parseRange (range) {
- const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE)
- const memoKey = memoOpts + ":" + range
- const cached = cache.get(memoKey)
+ parseRange(range) {
+ const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+ const memoKey = memoOpts + ":" + range;
+ const cached = cache.get(memoKey);
if (cached) {
- return cached
- }
- const loose = this.options.loose
- const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
- range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
- debug("hyphen replace", range)
- range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
- debug("comparator trim", range)
- range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
- debug("tilde trim", range)
- range = range.replace(re[t.CARETTRIM], caretTrimReplace)
- debug("caret trim", range)
- let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options))
+ return cached;
+ }
+ const loose = this.options.loose;
+ const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+ range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+ debug("hyphen replace", range);
+ range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+ debug("comparator trim", range);
+ range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+ debug("tilde trim", range);
+ range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+ debug("caret trim", range);
+ let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
if (loose) {
rangeList = rangeList.filter((comp) => {
- debug("loose invalid filter", comp, this.options)
- return !!comp.match(re[t.COMPARATORLOOSE])
- })
+ debug("loose invalid filter", comp, this.options);
+ return !!comp.match(re[t.COMPARATORLOOSE]);
+ });
}
- debug("range list", rangeList)
- const rangeMap = /* @__PURE__ */ new Map()
- const comparators = rangeList.map((comp) => new Comparator(comp, this.options))
+ debug("range list", rangeList);
+ const rangeMap = /* @__PURE__ */ new Map();
+ const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
for (const comp of comparators) {
if (isNullSet(comp)) {
- return [comp]
+ return [comp];
}
- rangeMap.set(comp.value, comp)
+ rangeMap.set(comp.value, comp);
}
if (rangeMap.size > 1 && rangeMap.has("")) {
- rangeMap.delete("")
+ rangeMap.delete("");
}
- const result = [...rangeMap.values()]
- cache.set(memoKey, result)
- return result
+ const result = [...rangeMap.values()];
+ cache.set(memoKey, result);
+ return result;
}
- intersects (range, options) {
+ intersects(range, options) {
if (!(range instanceof _Range)) {
- throw new TypeError("a Range is required")
+ throw new TypeError("a Range is required");
}
return this.set.some((thisComparators) => {
return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
return rangeComparators.every((rangeComparator) => {
- return thisComparator.intersects(rangeComparator, options)
- })
- })
- })
- })
+ return thisComparator.intersects(rangeComparator, options);
+ });
+ });
+ });
+ });
}
// if ANY of the sets match ALL of its comparators, then pass
- test (version) {
+ test(version) {
if (!version) {
- return false
+ return false;
}
if (typeof version === "string") {
try {
- version = new SemVer(version, this.options)
+ version = new SemVer(version, this.options);
} catch (er) {
- return false
+ return false;
}
}
for (let i = 0; i < this.set.length; i++) {
if (testSet(this.set[i], version, this.options)) {
- return true
+ return true;
}
}
- return false
+ return false;
}
- }
- module.exports = Range
- var LRU = require_lrucache()
- var cache = new LRU()
- var parseOptions = require_parse_options()
- var Comparator = require_comparator()
- var debug = require_debug()
- var SemVer = require_semver()
+ };
+ module.exports = Range;
+ var LRU = require_lrucache();
+ var cache = new LRU();
+ var parseOptions = require_parse_options();
+ var Comparator = require_comparator();
+ var debug = require_debug();
+ var SemVer = require_semver();
var {
safeRe: re,
t,
comparatorTrimReplace,
tildeTrimReplace,
caretTrimReplace
- } = require_re()
- var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants()
- var isNullSet = (c) => c.value === "<0.0.0-0"
- var isAny = (c) => c.value === ""
+ } = require_re();
+ var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+ var isNullSet = (c) => c.value === "<0.0.0-0";
+ var isAny = (c) => c.value === "";
var isSatisfiable = (comparators, options) => {
- let result = true
- const remainingComparators = comparators.slice()
- let testComparator = remainingComparators.pop()
+ let result = true;
+ const remainingComparators = comparators.slice();
+ let testComparator = remainingComparators.pop();
while (result && remainingComparators.length) {
result = remainingComparators.every((otherComparator) => {
- return testComparator.intersects(otherComparator, options)
- })
- testComparator = remainingComparators.pop()
+ return testComparator.intersects(otherComparator, options);
+ });
+ testComparator = remainingComparators.pop();
}
- return result
- }
+ return result;
+ };
var parseComparator = (comp, options) => {
- debug("comp", comp, options)
- comp = replaceCarets(comp, options)
- debug("caret", comp)
- comp = replaceTildes(comp, options)
- debug("tildes", comp)
- comp = replaceXRanges(comp, options)
- debug("xrange", comp)
- comp = replaceStars(comp, options)
- debug("stars", comp)
- return comp
- }
- var isX = (id2) => !id2 || id2.toLowerCase() === "x" || id2 === "*"
+ debug("comp", comp, options);
+ comp = replaceCarets(comp, options);
+ debug("caret", comp);
+ comp = replaceTildes(comp, options);
+ debug("tildes", comp);
+ comp = replaceXRanges(comp, options);
+ debug("xrange", comp);
+ comp = replaceStars(comp, options);
+ debug("stars", comp);
+ return comp;
+ };
+ var isX = (id2) => !id2 || id2.toLowerCase() === "x" || id2 === "*";
var replaceTildes = (comp, options) => {
- return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ")
- }
+ return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+ };
var replaceTilde = (comp, options) => {
- const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
+ const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
return comp.replace(r, (_, M, m, p, pr) => {
- debug("tilde", comp, _, M, m, p, pr)
- let ret
+ debug("tilde", comp, _, M, m, p, pr);
+ let ret;
if (isX(M)) {
- ret = ""
+ ret = "";
} else if (isX(m)) {
- ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
+ ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
} else if (isX(p)) {
- ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
+ ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
} else if (pr) {
- debug("replaceTilde pr", pr)
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`
+ debug("replaceTilde pr", pr);
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
} else {
- ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`
+ ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
}
- debug("tilde return", ret)
- return ret
- })
- }
+ debug("tilde return", ret);
+ return ret;
+ });
+ };
var replaceCarets = (comp, options) => {
- return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ")
- }
+ return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+ };
var replaceCaret = (comp, options) => {
- debug("caret", comp, options)
- const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
- const z = options.includePrerelease ? "-0" : ""
+ debug("caret", comp, options);
+ const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+ const z = options.includePrerelease ? "-0" : "";
return comp.replace(r, (_, M, m, p, pr) => {
- debug("caret", comp, _, M, m, p, pr)
- let ret
+ debug("caret", comp, _, M, m, p, pr);
+ let ret;
if (isX(M)) {
- ret = ""
+ ret = "";
} else if (isX(m)) {
- ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
+ ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
} else if (isX(p)) {
if (M === "0") {
- ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
+ ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
} else {
- ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
+ ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
}
} else if (pr) {
- debug("replaceCaret pr", pr)
+ debug("replaceCaret pr", pr);
if (M === "0") {
if (m === "0") {
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
} else {
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`
+ ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
}
} else {
- ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`
+ ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
}
} else {
- debug("no pr")
+ debug("no pr");
if (M === "0") {
if (m === "0") {
- ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`
+ ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
} else {
- ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`
+ ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
}
} else {
- ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`
+ ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
}
}
- debug("caret return", ret)
- return ret
- })
- }
+ debug("caret return", ret);
+ return ret;
+ });
+ };
var replaceXRanges = (comp, options) => {
- debug("replaceXRanges", comp, options)
- return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ")
- }
+ debug("replaceXRanges", comp, options);
+ return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+ };
var replaceXRange = (comp, options) => {
- comp = comp.trim()
- const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
+ comp = comp.trim();
+ const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
- debug("xRange", comp, ret, gtlt, M, m, p, pr)
- const xM = isX(M)
- const xm = xM || isX(m)
- const xp = xm || isX(p)
- const anyX = xp
+ debug("xRange", comp, ret, gtlt, M, m, p, pr);
+ const xM = isX(M);
+ const xm = xM || isX(m);
+ const xp = xm || isX(p);
+ const anyX = xp;
if (gtlt === "=" && anyX) {
- gtlt = ""
+ gtlt = "";
}
- pr = options.includePrerelease ? "-0" : ""
+ pr = options.includePrerelease ? "-0" : "";
if (xM) {
if (gtlt === ">" || gtlt === "<") {
- ret = "<0.0.0-0"
+ ret = "<0.0.0-0";
} else {
- ret = "*"
+ ret = "*";
}
} else if (gtlt && anyX) {
if (xm) {
- m = 0
+ m = 0;
}
- p = 0
+ p = 0;
if (gtlt === ">") {
- gtlt = ">="
+ gtlt = ">=";
if (xm) {
- M = +M + 1
- m = 0
- p = 0
+ M = +M + 1;
+ m = 0;
+ p = 0;
} else {
- m = +m + 1
- p = 0
+ m = +m + 1;
+ p = 0;
}
} else if (gtlt === "<=") {
- gtlt = "<"
+ gtlt = "<";
if (xm) {
- M = +M + 1
+ M = +M + 1;
} else {
- m = +m + 1
+ m = +m + 1;
}
}
if (gtlt === "<") {
- pr = "-0"
+ pr = "-0";
}
- ret = `${gtlt + M}.${m}.${p}${pr}`
+ ret = `${gtlt + M}.${m}.${p}${pr}`;
} else if (xm) {
- ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
+ ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
} else if (xp) {
- ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`
+ ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
}
- debug("xRange return", ret)
- return ret
- })
- }
+ debug("xRange return", ret);
+ return ret;
+ });
+ };
var replaceStars = (comp, options) => {
- debug("replaceStars", comp, options)
- return comp.trim().replace(re[t.STAR], "")
- }
+ debug("replaceStars", comp, options);
+ return comp.trim().replace(re[t.STAR], "");
+ };
var replaceGTE0 = (comp, options) => {
- debug("replaceGTE0", comp, options)
- return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "")
- }
+ debug("replaceGTE0", comp, options);
+ return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+ };
var hyphenReplace = (incPr) => ($0, from2, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
if (isX(fM)) {
- from2 = ""
+ from2 = "";
} else if (isX(fm)) {
- from2 = `>=${fM}.0.0${incPr ? "-0" : ""}`
+ from2 = `>=${fM}.0.0${incPr ? "-0" : ""}`;
} else if (isX(fp)) {
- from2 = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`
+ from2 = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
} else if (fpr) {
- from2 = `>=${from2}`
+ from2 = `>=${from2}`;
} else {
- from2 = `>=${from2}${incPr ? "-0" : ""}`
+ from2 = `>=${from2}${incPr ? "-0" : ""}`;
}
if (isX(tM)) {
- to = ""
+ to = "";
} else if (isX(tm)) {
- to = `<${+tM + 1}.0.0-0`
+ to = `<${+tM + 1}.0.0-0`;
} else if (isX(tp)) {
- to = `<${tM}.${+tm + 1}.0-0`
+ to = `<${tM}.${+tm + 1}.0-0`;
} else if (tpr) {
- to = `<=${tM}.${tm}.${tp}-${tpr}`
+ to = `<=${tM}.${tm}.${tp}-${tpr}`;
} else if (incPr) {
- to = `<${tM}.${tm}.${+tp + 1}-0`
+ to = `<${tM}.${tm}.${+tp + 1}-0`;
} else {
- to = `<=${to}`
+ to = `<=${to}`;
}
- return `${from2} ${to}`.trim()
- }
+ return `${from2} ${to}`.trim();
+ };
var testSet = (set, version, options) => {
for (let i = 0; i < set.length; i++) {
if (!set[i].test(version)) {
- return false
+ return false;
}
}
if (version.prerelease.length && !options.includePrerelease) {
for (let i = 0; i < set.length; i++) {
- debug(set[i].semver)
+ debug(set[i].semver);
if (set[i].semver === Comparator.ANY) {
- continue
+ continue;
}
if (set[i].semver.prerelease.length > 0) {
- const allowed = set[i].semver
+ const allowed = set[i].semver;
if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
- return true
+ return true;
}
}
}
- return false
+ return false;
}
- return true
- }
+ return true;
+ };
}
-})
+});
// node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({
- "node_modules/semver/classes/comparator.js" (exports, module) {
- var ANY = Symbol("SemVer ANY")
+ "node_modules/semver/classes/comparator.js"(exports, module) {
+ var ANY = Symbol("SemVer ANY");
var Comparator = class _Comparator {
- static get ANY () {
- return ANY
+ static get ANY() {
+ return ANY;
}
constructor(comp, options) {
- options = parseOptions(options)
+ options = parseOptions(options);
if (comp instanceof _Comparator) {
if (comp.loose === !!options.loose) {
- return comp
+ return comp;
} else {
- comp = comp.value
+ comp = comp.value;
}
}
- comp = comp.trim().split(/\s+/).join(" ")
- debug("comparator", comp, options)
- this.options = options
- this.loose = !!options.loose
- this.parse(comp)
+ comp = comp.trim().split(/\s+/).join(" ");
+ debug("comparator", comp, options);
+ this.options = options;
+ this.loose = !!options.loose;
+ this.parse(comp);
if (this.semver === ANY) {
- this.value = ""
+ this.value = "";
} else {
- this.value = this.operator + this.semver.version
+ this.value = this.operator + this.semver.version;
}
- debug("comp", this)
+ debug("comp", this);
}
- parse (comp) {
- const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
- const m = comp.match(r)
+ parse(comp) {
+ const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+ const m = comp.match(r);
if (!m) {
- throw new TypeError(`Invalid comparator: ${comp}`)
+ throw new TypeError(`Invalid comparator: ${comp}`);
}
- this.operator = m[1] !== void 0 ? m[1] : ""
+ this.operator = m[1] !== void 0 ? m[1] : "";
if (this.operator === "=") {
- this.operator = ""
+ this.operator = "";
}
if (!m[2]) {
- this.semver = ANY
+ this.semver = ANY;
} else {
- this.semver = new SemVer(m[2], this.options.loose)
+ this.semver = new SemVer(m[2], this.options.loose);
}
}
- toString () {
- return this.value
+ toString() {
+ return this.value;
}
- test (version) {
- debug("Comparator.test", version, this.options.loose)
+ test(version) {
+ debug("Comparator.test", version, this.options.loose);
if (this.semver === ANY || version === ANY) {
- return true
+ return true;
}
if (typeof version === "string") {
try {
- version = new SemVer(version, this.options)
+ version = new SemVer(version, this.options);
} catch (er) {
- return false
+ return false;
}
}
- return cmp(version, this.operator, this.semver, this.options)
+ return cmp(version, this.operator, this.semver, this.options);
}
- intersects (comp, options) {
+ intersects(comp, options) {
if (!(comp instanceof _Comparator)) {
- throw new TypeError("a Comparator is required")
+ throw new TypeError("a Comparator is required");
}
if (this.operator === "") {
if (this.value === "") {
- return true
+ return true;
}
- return new Range(comp.value, options).test(this.value)
+ return new Range(comp.value, options).test(this.value);
} else if (comp.operator === "") {
if (comp.value === "") {
- return true
+ return true;
}
- return new Range(this.value, options).test(comp.semver)
+ return new Range(this.value, options).test(comp.semver);
}
- options = parseOptions(options)
+ options = parseOptions(options);
if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
- return false
+ return false;
}
if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
- return false
+ return false;
}
if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
- return true
+ return true;
}
if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
- return true
+ return true;
}
if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
- return true
+ return true;
}
if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
- return true
+ return true;
}
if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
- return true
+ return true;
}
- return false
+ return false;
}
- }
- module.exports = Comparator
- var parseOptions = require_parse_options()
- var { safeRe: re, t } = require_re()
- var cmp = require_cmp()
- var debug = require_debug()
- var SemVer = require_semver()
- var Range = require_range()
+ };
+ module.exports = Comparator;
+ var parseOptions = require_parse_options();
+ var { safeRe: re, t } = require_re();
+ var cmp = require_cmp();
+ var debug = require_debug();
+ var SemVer = require_semver();
+ var Range = require_range();
}
-})
+});
// node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({
- "node_modules/semver/functions/satisfies.js" (exports, module) {
- var Range = require_range()
+ "node_modules/semver/functions/satisfies.js"(exports, module) {
+ var Range = require_range();
var satisfies = (version, range, options) => {
try {
- range = new Range(range, options)
+ range = new Range(range, options);
} catch (er) {
- return false
+ return false;
}
- return range.test(version)
- }
- module.exports = satisfies
+ return range.test(version);
+ };
+ module.exports = satisfies;
}
-})
+});
// node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS({
- "node_modules/semver/ranges/to-comparators.js" (exports, module) {
- var Range = require_range()
- var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "))
- module.exports = toComparators
+ "node_modules/semver/ranges/to-comparators.js"(exports, module) {
+ var Range = require_range();
+ var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+ module.exports = toComparators;
}
-})
+});
// node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS({
- "node_modules/semver/ranges/max-satisfying.js" (exports, module) {
- var SemVer = require_semver()
- var Range = require_range()
+ "node_modules/semver/ranges/max-satisfying.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
var maxSatisfying = (versions, range, options) => {
- let max = null
- let maxSV = null
- let rangeObj = null
+ let max = null;
+ let maxSV = null;
+ let rangeObj = null;
try {
- rangeObj = new Range(range, options)
+ rangeObj = new Range(range, options);
} catch (er) {
- return null
+ return null;
}
versions.forEach((v) => {
if (rangeObj.test(v)) {
if (!max || maxSV.compare(v) === -1) {
- max = v
- maxSV = new SemVer(max, options)
+ max = v;
+ maxSV = new SemVer(max, options);
}
}
- })
- return max
- }
- module.exports = maxSatisfying
+ });
+ return max;
+ };
+ module.exports = maxSatisfying;
}
-})
+});
// node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS({
- "node_modules/semver/ranges/min-satisfying.js" (exports, module) {
- var SemVer = require_semver()
- var Range = require_range()
+ "node_modules/semver/ranges/min-satisfying.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
var minSatisfying = (versions, range, options) => {
- let min = null
- let minSV = null
- let rangeObj = null
+ let min = null;
+ let minSV = null;
+ let rangeObj = null;
try {
- rangeObj = new Range(range, options)
+ rangeObj = new Range(range, options);
} catch (er) {
- return null
+ return null;
}
versions.forEach((v) => {
if (rangeObj.test(v)) {
if (!min || minSV.compare(v) === 1) {
- min = v
- minSV = new SemVer(min, options)
+ min = v;
+ minSV = new SemVer(min, options);
}
}
- })
- return min
- }
- module.exports = minSatisfying
+ });
+ return min;
+ };
+ module.exports = minSatisfying;
}
-})
+});
// node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS({
- "node_modules/semver/ranges/min-version.js" (exports, module) {
- var SemVer = require_semver()
- var Range = require_range()
- var gt = require_gt()
+ "node_modules/semver/ranges/min-version.js"(exports, module) {
+ var SemVer = require_semver();
+ var Range = require_range();
+ var gt = require_gt();
var minVersion = (range, loose) => {
- range = new Range(range, loose)
- let minver = new SemVer("0.0.0")
+ range = new Range(range, loose);
+ let minver = new SemVer("0.0.0");
if (range.test(minver)) {
- return minver
+ return minver;
}
- minver = new SemVer("0.0.0-0")
+ minver = new SemVer("0.0.0-0");
if (range.test(minver)) {
- return minver
+ return minver;
}
- minver = null
+ minver = null;
for (let i = 0; i < range.set.length; ++i) {
- const comparators = range.set[i]
- let setMin = null
+ const comparators = range.set[i];
+ let setMin = null;
comparators.forEach((comparator) => {
- const compver = new SemVer(comparator.semver.version)
+ const compver = new SemVer(comparator.semver.version);
switch (comparator.operator) {
case ">":
if (compver.prerelease.length === 0) {
- compver.patch++
+ compver.patch++;
} else {
- compver.prerelease.push(0)
+ compver.prerelease.push(0);
}
- compver.raw = compver.format()
+ compver.raw = compver.format();
/* fallthrough */
case "":
case ">=":
if (!setMin || gt(compver, setMin)) {
- setMin = compver
+ setMin = compver;
}
- break
+ break;
case "<":
case "<=":
- break
+ break;
/* istanbul ignore next */
default:
- throw new Error(`Unexpected operation: ${comparator.operator}`)
+ throw new Error(`Unexpected operation: ${comparator.operator}`);
}
- })
+ });
if (setMin && (!minver || gt(minver, setMin))) {
- minver = setMin
+ minver = setMin;
}
}
if (minver && range.test(minver)) {
- return minver
+ return minver;
}
- return null
- }
- module.exports = minVersion
+ return null;
+ };
+ module.exports = minVersion;
}
-})
+});
// node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS({
- "node_modules/semver/ranges/valid.js" (exports, module) {
- var Range = require_range()
+ "node_modules/semver/ranges/valid.js"(exports, module) {
+ var Range = require_range();
var validRange = (range, options) => {
try {
- return new Range(range, options).range || "*"
+ return new Range(range, options).range || "*";
} catch (er) {
- return null
+ return null;
}
- }
- module.exports = validRange
+ };
+ module.exports = validRange;
}
-})
+});
// node_modules/semver/ranges/outside.js
var require_outside = __commonJS({
- "node_modules/semver/ranges/outside.js" (exports, module) {
- var SemVer = require_semver()
- var Comparator = require_comparator()
- var { ANY } = Comparator
- var Range = require_range()
- var satisfies = require_satisfies()
- var gt = require_gt()
- var lt = require_lt()
- var lte = require_lte()
- var gte = require_gte()
+ "node_modules/semver/ranges/outside.js"(exports, module) {
+ var SemVer = require_semver();
+ var Comparator = require_comparator();
+ var { ANY } = Comparator;
+ var Range = require_range();
+ var satisfies = require_satisfies();
+ var gt = require_gt();
+ var lt = require_lt();
+ var lte = require_lte();
+ var gte = require_gte();
var outside = (version, range, hilo, options) => {
- version = new SemVer(version, options)
- range = new Range(range, options)
- let gtfn, ltefn, ltfn, comp, ecomp
+ version = new SemVer(version, options);
+ range = new Range(range, options);
+ let gtfn, ltefn, ltfn, comp, ecomp;
switch (hilo) {
case ">":
- gtfn = gt
- ltefn = lte
- ltfn = lt
- comp = ">"
- ecomp = ">="
- break
+ gtfn = gt;
+ ltefn = lte;
+ ltfn = lt;
+ comp = ">";
+ ecomp = ">=";
+ break;
case "<":
- gtfn = lt
- ltefn = gte
- ltfn = gt
- comp = "<"
- ecomp = "<="
- break
+ gtfn = lt;
+ ltefn = gte;
+ ltfn = gt;
+ comp = "<";
+ ecomp = "<=";
+ break;
default:
- throw new TypeError('Must provide a hilo val of "<" or ">"')
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
}
if (satisfies(version, range, options)) {
- return false
+ return false;
}
for (let i = 0; i < range.set.length; ++i) {
- const comparators = range.set[i]
- let high = null
- let low = null
+ const comparators = range.set[i];
+ let high = null;
+ let low = null;
comparators.forEach((comparator) => {
if (comparator.semver === ANY) {
- comparator = new Comparator(">=0.0.0")
+ comparator = new Comparator(">=0.0.0");
}
- high = high || comparator
- low = low || comparator
+ high = high || comparator;
+ low = low || comparator;
if (gtfn(comparator.semver, high.semver, options)) {
- high = comparator
+ high = comparator;
} else if (ltfn(comparator.semver, low.semver, options)) {
- low = comparator
+ low = comparator;
}
- })
+ });
if (high.operator === comp || high.operator === ecomp) {
- return false
+ return false;
}
if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
- return false
+ return false;
} else if (low.operator === ecomp && ltfn(version, low.semver)) {
- return false
+ return false;
}
}
- return true
- }
- module.exports = outside
+ return true;
+ };
+ module.exports = outside;
}
-})
+});
// node_modules/semver/ranges/gtr.js
var require_gtr = __commonJS({
- "node_modules/semver/ranges/gtr.js" (exports, module) {
- var outside = require_outside()
- var gtr = (version, range, options) => outside(version, range, ">", options)
- module.exports = gtr
+ "node_modules/semver/ranges/gtr.js"(exports, module) {
+ var outside = require_outside();
+ var gtr = (version, range, options) => outside(version, range, ">", options);
+ module.exports = gtr;
}
-})
+});
// node_modules/semver/ranges/ltr.js
var require_ltr = __commonJS({
- "node_modules/semver/ranges/ltr.js" (exports, module) {
- var outside = require_outside()
- var ltr = (version, range, options) => outside(version, range, "<", options)
- module.exports = ltr
+ "node_modules/semver/ranges/ltr.js"(exports, module) {
+ var outside = require_outside();
+ var ltr = (version, range, options) => outside(version, range, "<", options);
+ module.exports = ltr;
}
-})
+});
// node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS({
- "node_modules/semver/ranges/intersects.js" (exports, module) {
- var Range = require_range()
+ "node_modules/semver/ranges/intersects.js"(exports, module) {
+ var Range = require_range();
var intersects = (r1, r2, options) => {
- r1 = new Range(r1, options)
- r2 = new Range(r2, options)
- return r1.intersects(r2, options)
- }
- module.exports = intersects
+ r1 = new Range(r1, options);
+ r2 = new Range(r2, options);
+ return r1.intersects(r2, options);
+ };
+ module.exports = intersects;
}
-})
+});
// node_modules/semver/ranges/simplify.js
var require_simplify = __commonJS({
- "node_modules/semver/ranges/simplify.js" (exports, module) {
- var satisfies = require_satisfies()
- var compare = require_compare()
+ "node_modules/semver/ranges/simplify.js"(exports, module) {
+ var satisfies = require_satisfies();
+ var compare = require_compare();
module.exports = (versions, range, options) => {
- const set = []
- let first2 = null
- let prev = null
- const v = versions.sort((a, b) => compare(a, b, options))
+ const set = [];
+ let first2 = null;
+ let prev = null;
+ const v = versions.sort((a, b) => compare(a, b, options));
for (const version of v) {
- const included = satisfies(version, range, options)
+ const included = satisfies(version, range, options);
if (included) {
- prev = version
+ prev = version;
if (!first2) {
- first2 = version
+ first2 = version;
}
} else {
if (prev) {
- set.push([first2, prev])
+ set.push([first2, prev]);
}
- prev = null
- first2 = null
+ prev = null;
+ first2 = null;
}
}
if (first2) {
- set.push([first2, null])
+ set.push([first2, null]);
}
- const ranges = []
+ const ranges = [];
for (const [min, max] of set) {
if (min === max) {
- ranges.push(min)
+ ranges.push(min);
} else if (!max && min === v[0]) {
- ranges.push("*")
+ ranges.push("*");
} else if (!max) {
- ranges.push(`>=${min}`)
+ ranges.push(`>=${min}`);
} else if (min === v[0]) {
- ranges.push(`<=${max}`)
+ ranges.push(`<=${max}`);
} else {
- ranges.push(`${min} - ${max}`)
+ ranges.push(`${min} - ${max}`);
}
}
- const simplified = ranges.join(" || ")
- const original = typeof range.raw === "string" ? range.raw : String(range)
- return simplified.length < original.length ? simplified : range
- }
+ const simplified = ranges.join(" || ");
+ const original = typeof range.raw === "string" ? range.raw : String(range);
+ return simplified.length < original.length ? simplified : range;
+ };
}
-})
+});
// node_modules/semver/ranges/subset.js
var require_subset = __commonJS({
- "node_modules/semver/ranges/subset.js" (exports, module) {
- var Range = require_range()
- var Comparator = require_comparator()
- var { ANY } = Comparator
- var satisfies = require_satisfies()
- var compare = require_compare()
+ "node_modules/semver/ranges/subset.js"(exports, module) {
+ var Range = require_range();
+ var Comparator = require_comparator();
+ var { ANY } = Comparator;
+ var satisfies = require_satisfies();
+ var compare = require_compare();
var subset = (sub, dom, options = {}) => {
if (sub === dom) {
- return true
+ return true;
}
- sub = new Range(sub, options)
- dom = new Range(dom, options)
- let sawNonNull = false
+ sub = new Range(sub, options);
+ dom = new Range(dom, options);
+ let sawNonNull = false;
OUTER: for (const simpleSub of sub.set) {
for (const simpleDom of dom.set) {
- const isSub = simpleSubset(simpleSub, simpleDom, options)
- sawNonNull = sawNonNull || isSub !== null
+ const isSub = simpleSubset(simpleSub, simpleDom, options);
+ sawNonNull = sawNonNull || isSub !== null;
if (isSub) {
- continue OUTER
+ continue OUTER;
}
}
if (sawNonNull) {
- return false
+ return false;
}
}
- return true
- }
- var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")]
- var minimumVersion = [new Comparator(">=0.0.0")]
+ return true;
+ };
+ var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+ var minimumVersion = [new Comparator(">=0.0.0")];
var simpleSubset = (sub, dom, options) => {
if (sub === dom) {
- return true
+ return true;
}
if (sub.length === 1 && sub[0].semver === ANY) {
if (dom.length === 1 && dom[0].semver === ANY) {
- return true
+ return true;
} else if (options.includePrerelease) {
- sub = minimumVersionWithPreRelease
+ sub = minimumVersionWithPreRelease;
} else {
- sub = minimumVersion
+ sub = minimumVersion;
}
}
if (dom.length === 1 && dom[0].semver === ANY) {
if (options.includePrerelease) {
- return true
+ return true;
} else {
- dom = minimumVersion
+ dom = minimumVersion;
}
}
- const eqSet = /* @__PURE__ */ new Set()
- let gt, lt
+ const eqSet = /* @__PURE__ */ new Set();
+ let gt, lt;
for (const c of sub) {
if (c.operator === ">" || c.operator === ">=") {
- gt = higherGT(gt, c, options)
+ gt = higherGT(gt, c, options);
} else if (c.operator === "<" || c.operator === "<=") {
- lt = lowerLT(lt, c, options)
+ lt = lowerLT(lt, c, options);
} else {
- eqSet.add(c.semver)
+ eqSet.add(c.semver);
}
}
if (eqSet.size > 1) {
- return null
+ return null;
}
- let gtltComp
+ let gtltComp;
if (gt && lt) {
- gtltComp = compare(gt.semver, lt.semver, options)
+ gtltComp = compare(gt.semver, lt.semver, options);
if (gtltComp > 0) {
- return null
+ return null;
} else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
- return null
+ return null;
}
}
for (const eq of eqSet) {
if (gt && !satisfies(eq, String(gt), options)) {
- return null
+ return null;
}
if (lt && !satisfies(eq, String(lt), options)) {
- return null
+ return null;
}
for (const c of dom) {
if (!satisfies(eq, String(c), options)) {
- return false
+ return false;
}
}
- return true
+ return true;
}
- let higher, lower
- let hasDomLT, hasDomGT
- let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false
- let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false
+ let higher, lower;
+ let hasDomLT, hasDomGT;
+ let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+ let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
- needDomLTPre = false
+ needDomLTPre = false;
}
for (const c of dom) {
- hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">="
- hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<="
+ hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+ hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
if (gt) {
if (needDomGTPre) {
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
- needDomGTPre = false
+ needDomGTPre = false;
}
}
if (c.operator === ">" || c.operator === ">=") {
- higher = higherGT(gt, c, options)
+ higher = higherGT(gt, c, options);
if (higher === c && higher !== gt) {
- return false
+ return false;
}
} else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
- return false
+ return false;
}
}
if (lt) {
if (needDomLTPre) {
if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
- needDomLTPre = false
+ needDomLTPre = false;
}
}
if (c.operator === "<" || c.operator === "<=") {
- lower = lowerLT(lt, c, options)
+ lower = lowerLT(lt, c, options);
if (lower === c && lower !== lt) {
- return false
+ return false;
}
} else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
- return false
+ return false;
}
}
if (!c.operator && (lt || gt) && gtltComp !== 0) {
- return false
+ return false;
}
}
if (gt && hasDomLT && !lt && gtltComp !== 0) {
- return false
+ return false;
}
if (lt && hasDomGT && !gt && gtltComp !== 0) {
- return false
+ return false;
}
if (needDomGTPre || needDomLTPre) {
- return false
+ return false;
}
- return true
- }
+ return true;
+ };
var higherGT = (a, b, options) => {
if (!a) {
- return b
+ return b;
}
- const comp = compare(a.semver, b.semver, options)
- return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a
- }
+ const comp = compare(a.semver, b.semver, options);
+ return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+ };
var lowerLT = (a, b, options) => {
if (!a) {
- return b
+ return b;
}
- const comp = compare(a.semver, b.semver, options)
- return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a
- }
- module.exports = subset
+ const comp = compare(a.semver, b.semver, options);
+ return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+ };
+ module.exports = subset;
}
-})
+});
// node_modules/semver/index.js
var require_semver2 = __commonJS({
- "node_modules/semver/index.js" (exports, module) {
- var internalRe = require_re()
- var constants = require_constants()
- var SemVer = require_semver()
- var identifiers = require_identifiers()
- var parse = require_parse()
- var valid = require_valid()
- var clean = require_clean()
- var inc = require_inc()
- var diff = require_diff()
- var major = require_major()
- var minor = require_minor()
- var patch = require_patch()
- var prerelease = require_prerelease()
- var compare = require_compare()
- var rcompare = require_rcompare()
- var compareLoose = require_compare_loose()
- var compareBuild = require_compare_build()
- var sort = require_sort()
- var rsort = require_rsort()
- var gt = require_gt()
- var lt = require_lt()
- var eq = require_eq()
- var neq = require_neq()
- var gte = require_gte()
- var lte = require_lte()
- var cmp = require_cmp()
- var coerce = require_coerce()
- var Comparator = require_comparator()
- var Range = require_range()
- var satisfies = require_satisfies()
- var toComparators = require_to_comparators()
- var maxSatisfying = require_max_satisfying()
- var minSatisfying = require_min_satisfying()
- var minVersion = require_min_version()
- var validRange = require_valid2()
- var outside = require_outside()
- var gtr = require_gtr()
- var ltr = require_ltr()
- var intersects = require_intersects()
- var simplifyRange = require_simplify()
- var subset = require_subset()
+ "node_modules/semver/index.js"(exports, module) {
+ var internalRe = require_re();
+ var constants = require_constants();
+ var SemVer = require_semver();
+ var identifiers = require_identifiers();
+ var parse = require_parse();
+ var valid = require_valid();
+ var clean = require_clean();
+ var inc = require_inc();
+ var diff = require_diff();
+ var major = require_major();
+ var minor = require_minor();
+ var patch = require_patch();
+ var prerelease = require_prerelease();
+ var compare = require_compare();
+ var rcompare = require_rcompare();
+ var compareLoose = require_compare_loose();
+ var compareBuild = require_compare_build();
+ var sort = require_sort();
+ var rsort = require_rsort();
+ var gt = require_gt();
+ var lt = require_lt();
+ var eq = require_eq();
+ var neq = require_neq();
+ var gte = require_gte();
+ var lte = require_lte();
+ var cmp = require_cmp();
+ var coerce = require_coerce();
+ var Comparator = require_comparator();
+ var Range = require_range();
+ var satisfies = require_satisfies();
+ var toComparators = require_to_comparators();
+ var maxSatisfying = require_max_satisfying();
+ var minSatisfying = require_min_satisfying();
+ var minVersion = require_min_version();
+ var validRange = require_valid2();
+ var outside = require_outside();
+ var gtr = require_gtr();
+ var ltr = require_ltr();
+ var intersects = require_intersects();
+ var simplifyRange = require_simplify();
+ var subset = require_subset();
module.exports = {
parse,
valid,
RELEASE_TYPES: constants.RELEASE_TYPES,
compareIdentifiers: identifiers.compareIdentifiers,
rcompareIdentifiers: identifiers.rcompareIdentifiers
- }
+ };
}
-})
+});
// node_modules/@ledgerhq/devices/lib-es/index.js
-var import_semver, DeviceModelId, devices, productMap, devicesList, ledgerUSBVendorId, identifyUSBProductId, bluetoothServices, serviceUuidToInfos, getBluetoothServiceUuids, getInfosForServiceUuid
+var import_semver, DeviceModelId, devices, productMap, devicesList, ledgerUSBVendorId, identifyUSBProductId, bluetoothServices, serviceUuidToInfos, getBluetoothServiceUuids, getInfosForServiceUuid;
var init_lib_es3 = __esm({
- "node_modules/@ledgerhq/devices/lib-es/index.js" () {
+ "node_modules/@ledgerhq/devices/lib-es/index.js"() {
import_semver = __toESM(require_semver2());
- (function (DeviceModelId2) {
- DeviceModelId2["blue"] = "blue"
- DeviceModelId2["nanoS"] = "nanoS"
- DeviceModelId2["nanoSP"] = "nanoSP"
- DeviceModelId2["nanoX"] = "nanoX"
- DeviceModelId2["stax"] = "stax"
- DeviceModelId2["europa"] = "europa"
- })(DeviceModelId || (DeviceModelId = {}))
+ (function(DeviceModelId2) {
+ DeviceModelId2["blue"] = "blue";
+ DeviceModelId2["nanoS"] = "nanoS";
+ DeviceModelId2["nanoSP"] = "nanoSP";
+ DeviceModelId2["nanoX"] = "nanoX";
+ DeviceModelId2["stax"] = "stax";
+ DeviceModelId2["europa"] = "europa";
+ })(DeviceModelId || (DeviceModelId = {}));
devices = {
[DeviceModelId.blue]: {
id: DeviceModelId.blue,
memorySize: 320 * 1024,
masks: [823132160],
getBlockSize: (firmwareVersion) => {
- var _a2
- return import_semver.default.lt((_a2 = import_semver.default.coerce(firmwareVersion)) !== null && _a2 !== void 0 ? _a2 : "", "2.0.0") ? 4 * 1024 : 2 * 1024
+ var _a2;
+ return import_semver.default.lt((_a2 = import_semver.default.coerce(firmwareVersion)) !== null && _a2 !== void 0 ? _a2 : "", "2.0.0") ? 4 * 1024 : 2 * 1024;
}
},
[DeviceModelId.nanoX]: {
}
]
}
- }
+ };
productMap = {
Blue: DeviceModelId.blue,
"Nano S": DeviceModelId.nanoS,
"Nano X": DeviceModelId.nanoX,
Stax: DeviceModelId.stax,
Europa: DeviceModelId.europa
- }
- devicesList = Object.values(devices)
- ledgerUSBVendorId = 11415
+ };
+ devicesList = Object.values(devices);
+ ledgerUSBVendorId = 11415;
identifyUSBProductId = (usbProductId) => {
- const legacy = devicesList.find((d) => d.legacyUsbProductId === usbProductId)
+ const legacy = devicesList.find((d) => d.legacyUsbProductId === usbProductId);
if (legacy)
- return legacy
- const mm = usbProductId >> 8
- const deviceModel = devicesList.find((d) => d.productIdMM === mm)
- return deviceModel
- }
- bluetoothServices = []
- serviceUuidToInfos = {}
+ return legacy;
+ const mm = usbProductId >> 8;
+ const deviceModel = devicesList.find((d) => d.productIdMM === mm);
+ return deviceModel;
+ };
+ bluetoothServices = [];
+ serviceUuidToInfos = {};
for (const id2 in devices) {
- const deviceModel = devices[id2]
- const { bluetoothSpec } = deviceModel
+ const deviceModel = devices[id2];
+ const { bluetoothSpec } = deviceModel;
if (bluetoothSpec) {
for (let i = 0; i < bluetoothSpec.length; i++) {
- const spec = bluetoothSpec[i]
- bluetoothServices.push(spec.serviceUuid)
- serviceUuidToInfos[spec.serviceUuid] = serviceUuidToInfos[spec.serviceUuid.replace(/-/g, "")] = Object.assign({ deviceModel }, spec)
+ const spec = bluetoothSpec[i];
+ bluetoothServices.push(spec.serviceUuid);
+ serviceUuidToInfos[spec.serviceUuid] = serviceUuidToInfos[spec.serviceUuid.replace(/-/g, "")] = Object.assign({ deviceModel }, spec);
}
}
}
- getBluetoothServiceUuids = () => bluetoothServices
- getInfosForServiceUuid = (uuid) => serviceUuidToInfos[uuid.toLowerCase()]
+ getBluetoothServiceUuids = () => bluetoothServices;
+ getInfosForServiceUuid = (uuid) => serviceUuidToInfos[uuid.toLowerCase()];
}
-})
+});
// node_modules/tslib/tslib.es6.mjs
-function __extends (d, b) {
+function __extends(d, b) {
if (typeof b !== "function" && b !== null)
- throw new TypeError("Class extends value " + String(b) + " is not a constructor or null")
- extendStatics(d, b)
- function __ () {
- this.constructor = d
+ throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+ extendStatics(d, b);
+ function __() {
+ this.constructor = d;
}
- d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __())
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
-function __awaiter2 (thisArg, _arguments, P, generator) {
- function adopt (value) {
- return value instanceof P ? value : new P(function (resolve) {
- resolve(value)
- })
- }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled (value) {
+function __awaiter2(thisArg, _arguments, P, generator) {
+ function adopt(value) {
+ return value instanceof P ? value : new P(function(resolve) {
+ resolve(value);
+ });
+ }
+ return new (P || (P = Promise))(function(resolve, reject) {
+ function fulfilled(value) {
try {
- step(generator.next(value))
+ step(generator.next(value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function rejected (value) {
+ function rejected(value) {
try {
- step(generator["throw"](value))
+ step(generator["throw"](value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function step (result) {
- result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+ function step(result) {
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
- step((generator = generator.apply(thisArg, _arguments || [])).next())
- })
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
}
-function __generator (thisArg, body) {
- var _ = {
- label: 0, sent: function () {
- if (t[0] & 1) throw t[1]
- return t[1]
- }, trys: [], ops: []
- }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype)
- return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
- return this
- }), g
- function verb (n) {
- return function (v) {
- return step([n, v])
- }
- }
- function step (op) {
- if (f) throw new TypeError("Generator is already executing.")
+function __generator(thisArg, body) {
+ var _ = { label: 0, sent: function() {
+ if (t[0] & 1) throw t[1];
+ return t[1];
+ }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+ return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+ return this;
+ }), g;
+ function verb(n) {
+ return function(v) {
+ return step([n, v]);
+ };
+ }
+ function step(op) {
+ if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
- if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t
- if (y = 0, t) op = [op[0] & 2, t.value]
+ if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+ if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
- t = op
- break
+ t = op;
+ break;
case 4:
- _.label++
- return { value: op[1], done: false }
+ _.label++;
+ return { value: op[1], done: false };
case 5:
- _.label++
- y = op[1]
- op = [0]
- continue
+ _.label++;
+ y = op[1];
+ op = [0];
+ continue;
case 7:
- op = _.ops.pop()
- _.trys.pop()
- continue
+ op = _.ops.pop();
+ _.trys.pop();
+ continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
- _ = 0
- continue
+ _ = 0;
+ continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
- _.label = op[1]
- break
+ _.label = op[1];
+ break;
}
if (op[0] === 6 && _.label < t[1]) {
- _.label = t[1]
- t = op
- break
+ _.label = t[1];
+ t = op;
+ break;
}
if (t && _.label < t[2]) {
- _.label = t[2]
- _.ops.push(op)
- break
+ _.label = t[2];
+ _.ops.push(op);
+ break;
}
- if (t[2]) _.ops.pop()
- _.trys.pop()
- continue
+ if (t[2]) _.ops.pop();
+ _.trys.pop();
+ continue;
}
- op = body.call(thisArg, _)
+ op = body.call(thisArg, _);
} catch (e) {
- op = [6, e]
- y = 0
+ op = [6, e];
+ y = 0;
} finally {
- f = t = 0
- }
- if (op[0] & 5) throw op[1]
- return { value: op[0] ? op[1] : void 0, done: true }
+ f = t = 0;
+ }
+ if (op[0] & 5) throw op[1];
+ return { value: op[0] ? op[1] : void 0, done: true };
}
}
-function __values (o) {
- var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0
- if (m) return m.call(o)
+function __values(o) {
+ var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+ if (m) return m.call(o);
if (o && typeof o.length === "number") return {
- next: function () {
- if (o && i >= o.length) o = void 0
- return { value: o && o[i++], done: !o }
+ next: function() {
+ if (o && i >= o.length) o = void 0;
+ return { value: o && o[i++], done: !o };
}
- }
- throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.")
+ };
+ throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
-function __read (o, n) {
- var m = typeof Symbol === "function" && o[Symbol.iterator]
- if (!m) return o
- var i = m.call(o), r, ar = [], e
+function __read(o, n) {
+ var m = typeof Symbol === "function" && o[Symbol.iterator];
+ if (!m) return o;
+ var i = m.call(o), r, ar = [], e;
try {
- while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value)
+ while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
} catch (error) {
- e = { error }
+ e = { error };
} finally {
try {
- if (r && !r.done && (m = i["return"])) m.call(i)
+ if (r && !r.done && (m = i["return"])) m.call(i);
} finally {
- if (e) throw e.error
+ if (e) throw e.error;
}
}
- return ar
+ return ar;
}
-function __spreadArray (to, from2, pack) {
+function __spreadArray(to, from2, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from2.length, ar; i < l; i++) {
if (ar || !(i in from2)) {
- if (!ar) ar = Array.prototype.slice.call(from2, 0, i)
- ar[i] = from2[i]
+ if (!ar) ar = Array.prototype.slice.call(from2, 0, i);
+ ar[i] = from2[i];
}
}
- return to.concat(ar || Array.prototype.slice.call(from2))
+ return to.concat(ar || Array.prototype.slice.call(from2));
}
-function __await (v) {
- return this instanceof __await ? (this.v = v, this) : new __await(v)
+function __await(v) {
+ return this instanceof __await ? (this.v = v, this) : new __await(v);
}
-function __asyncGenerator (thisArg, _arguments, generator) {
- if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.")
- var g = generator.apply(thisArg, _arguments || []), i, q = []
- return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () {
- return this
- }, i
- function awaitReturn (f) {
- return function (v) {
- return Promise.resolve(v).then(f, reject)
- }
- }
- function verb (n, f) {
+function __asyncGenerator(thisArg, _arguments, generator) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var g = generator.apply(thisArg, _arguments || []), i, q = [];
+ return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+ return this;
+ }, i;
+ function awaitReturn(f) {
+ return function(v) {
+ return Promise.resolve(v).then(f, reject);
+ };
+ }
+ function verb(n, f) {
if (g[n]) {
- i[n] = function (v) {
- return new Promise(function (a, b) {
- q.push([n, v, a, b]) > 1 || resume(n, v)
- })
- }
- if (f) i[n] = f(i[n])
+ i[n] = function(v) {
+ return new Promise(function(a, b) {
+ q.push([n, v, a, b]) > 1 || resume(n, v);
+ });
+ };
+ if (f) i[n] = f(i[n]);
}
}
- function resume (n, v) {
+ function resume(n, v) {
try {
- step(g[n](v))
+ step(g[n](v));
} catch (e) {
- settle(q[0][3], e)
+ settle(q[0][3], e);
}
}
- function step (r) {
- r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r)
+ function step(r) {
+ r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
}
- function fulfill (value) {
- resume("next", value)
+ function fulfill(value) {
+ resume("next", value);
}
- function reject (value) {
- resume("throw", value)
+ function reject(value) {
+ resume("throw", value);
}
- function settle (f, v) {
- if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1])
+ function settle(f, v) {
+ if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
}
}
-function __asyncValues (o) {
- if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.")
- var m = o[Symbol.asyncIterator], i
- return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () {
- return this
- }, i)
- function verb (n) {
- i[n] = o[n] && function (v) {
- return new Promise(function (resolve, reject) {
- v = o[n](v), settle(resolve, reject, v.done, v.value)
- })
- }
- }
- function settle (resolve, reject, d, v) {
- Promise.resolve(v).then(function (v2) {
- resolve({ value: v2, done: d })
- }, reject)
+function __asyncValues(o) {
+ if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+ var m = o[Symbol.asyncIterator], i;
+ return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+ return this;
+ }, i);
+ function verb(n) {
+ i[n] = o[n] && function(v) {
+ return new Promise(function(resolve, reject) {
+ v = o[n](v), settle(resolve, reject, v.done, v.value);
+ });
+ };
+ }
+ function settle(resolve, reject, d, v) {
+ Promise.resolve(v).then(function(v2) {
+ resolve({ value: v2, done: d });
+ }, reject);
}
}
-var extendStatics
+var extendStatics;
var init_tslib_es6 = __esm({
- "node_modules/tslib/tslib.es6.mjs" () {
- extendStatics = function (d, b) {
- extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function (d2, b2) {
- d2.__proto__ = b2
- } || function (d2, b2) {
- for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p]
- }
- return extendStatics(d, b)
- }
+ "node_modules/tslib/tslib.es6.mjs"() {
+ extendStatics = function(d, b) {
+ extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+ d2.__proto__ = b2;
+ } || function(d2, b2) {
+ for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+ };
+ return extendStatics(d, b);
+ };
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/isFunction.js
-function isFunction (value) {
- return typeof value === "function"
+function isFunction(value) {
+ return typeof value === "function";
}
var init_isFunction = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/isFunction.js" () {
+ "node_modules/rxjs/dist/esm5/internal/util/isFunction.js"() {
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
-function createErrorClass (createImpl) {
- var _super = function (instance) {
- Error.call(instance)
- instance.stack = new Error().stack
- }
- var ctorFunc = createImpl(_super)
- ctorFunc.prototype = Object.create(Error.prototype)
- ctorFunc.prototype.constructor = ctorFunc
- return ctorFunc
+function createErrorClass(createImpl) {
+ var _super = function(instance) {
+ Error.call(instance);
+ instance.stack = new Error().stack;
+ };
+ var ctorFunc = createImpl(_super);
+ ctorFunc.prototype = Object.create(Error.prototype);
+ ctorFunc.prototype.constructor = ctorFunc;
+ return ctorFunc;
}
var init_createErrorClass = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js" () {
+ "node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js"() {
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
-var UnsubscriptionError
+var UnsubscriptionError;
var init_UnsubscriptionError = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js" () {
- init_createErrorClass()
- UnsubscriptionError = createErrorClass(function (_super) {
- return function UnsubscriptionErrorImpl (errors) {
- _super(this)
- this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) {
- return i + 1 + ") " + err.toString()
- }).join("\n ") : ""
- this.name = "UnsubscriptionError"
- this.errors = errors
- }
- })
+ "node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js"() {
+ init_createErrorClass();
+ UnsubscriptionError = createErrorClass(function(_super) {
+ return function UnsubscriptionErrorImpl(errors) {
+ _super(this);
+ this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+ return i + 1 + ") " + err.toString();
+ }).join("\n ") : "";
+ this.name = "UnsubscriptionError";
+ this.errors = errors;
+ };
+ });
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
-function arrRemove (arr, item) {
+function arrRemove(arr, item) {
if (arr) {
- var index = arr.indexOf(item)
- 0 <= index && arr.splice(index, 1)
+ var index = arr.indexOf(item);
+ 0 <= index && arr.splice(index, 1);
}
}
var init_arrRemove = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/arrRemove.js" () {
+ "node_modules/rxjs/dist/esm5/internal/util/arrRemove.js"() {
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/Subscription.js
-function isSubscription (value) {
- return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)
+function isSubscription(value) {
+ return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
}
-function execFinalizer (finalizer) {
+function execFinalizer(finalizer) {
if (isFunction(finalizer)) {
- finalizer()
+ finalizer();
} else {
- finalizer.unsubscribe()
+ finalizer.unsubscribe();
}
}
-var Subscription, EMPTY_SUBSCRIPTION
+var Subscription, EMPTY_SUBSCRIPTION;
var init_Subscription = __esm({
- "node_modules/rxjs/dist/esm5/internal/Subscription.js" () {
- init_tslib_es6()
- init_isFunction()
- init_UnsubscriptionError()
- init_arrRemove()
- Subscription = function () {
- function Subscription2 (initialTeardown) {
- this.initialTeardown = initialTeardown
- this.closed = false
- this._parentage = null
- this._finalizers = null
- }
- Subscription2.prototype.unsubscribe = function () {
- var e_1, _a2, e_2, _b
- var errors
+ "node_modules/rxjs/dist/esm5/internal/Subscription.js"() {
+ init_tslib_es6();
+ init_isFunction();
+ init_UnsubscriptionError();
+ init_arrRemove();
+ Subscription = function() {
+ function Subscription2(initialTeardown) {
+ this.initialTeardown = initialTeardown;
+ this.closed = false;
+ this._parentage = null;
+ this._finalizers = null;
+ }
+ Subscription2.prototype.unsubscribe = function() {
+ var e_1, _a2, e_2, _b;
+ var errors;
if (!this.closed) {
- this.closed = true
- var _parentage = this._parentage
+ this.closed = true;
+ var _parentage = this._parentage;
if (_parentage) {
- this._parentage = null
+ this._parentage = null;
if (Array.isArray(_parentage)) {
try {
for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
- var parent_1 = _parentage_1_1.value
- parent_1.remove(this)
+ var parent_1 = _parentage_1_1.value;
+ parent_1.remove(this);
}
} catch (e_1_1) {
- e_1 = { error: e_1_1 }
+ e_1 = { error: e_1_1 };
} finally {
try {
- if (_parentage_1_1 && !_parentage_1_1.done && (_a2 = _parentage_1.return)) _a2.call(_parentage_1)
+ if (_parentage_1_1 && !_parentage_1_1.done && (_a2 = _parentage_1.return)) _a2.call(_parentage_1);
} finally {
- if (e_1) throw e_1.error
+ if (e_1) throw e_1.error;
}
}
} else {
- _parentage.remove(this)
+ _parentage.remove(this);
}
}
- var initialFinalizer = this.initialTeardown
+ var initialFinalizer = this.initialTeardown;
if (isFunction(initialFinalizer)) {
try {
- initialFinalizer()
+ initialFinalizer();
} catch (e) {
- errors = e instanceof UnsubscriptionError ? e.errors : [e]
+ errors = e instanceof UnsubscriptionError ? e.errors : [e];
}
}
- var _finalizers = this._finalizers
+ var _finalizers = this._finalizers;
if (_finalizers) {
- this._finalizers = null
+ this._finalizers = null;
try {
for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
- var finalizer = _finalizers_1_1.value
+ var finalizer = _finalizers_1_1.value;
try {
- execFinalizer(finalizer)
+ execFinalizer(finalizer);
} catch (err) {
- errors = errors !== null && errors !== void 0 ? errors : []
+ errors = errors !== null && errors !== void 0 ? errors : [];
if (err instanceof UnsubscriptionError) {
- errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors))
+ errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
} else {
- errors.push(err)
+ errors.push(err);
}
}
}
} catch (e_2_1) {
- e_2 = { error: e_2_1 }
+ e_2 = { error: e_2_1 };
} finally {
try {
- if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1)
+ if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
} finally {
- if (e_2) throw e_2.error
+ if (e_2) throw e_2.error;
}
}
}
if (errors) {
- throw new UnsubscriptionError(errors)
+ throw new UnsubscriptionError(errors);
}
}
- }
- Subscription2.prototype.add = function (teardown) {
- var _a2
+ };
+ Subscription2.prototype.add = function(teardown) {
+ var _a2;
if (teardown && teardown !== this) {
if (this.closed) {
- execFinalizer(teardown)
+ execFinalizer(teardown);
} else {
if (teardown instanceof Subscription2) {
if (teardown.closed || teardown._hasParent(this)) {
- return
+ return;
}
- teardown._addParent(this)
+ teardown._addParent(this);
}
- (this._finalizers = (_a2 = this._finalizers) !== null && _a2 !== void 0 ? _a2 : []).push(teardown)
+ (this._finalizers = (_a2 = this._finalizers) !== null && _a2 !== void 0 ? _a2 : []).push(teardown);
}
}
- }
- Subscription2.prototype._hasParent = function (parent) {
- var _parentage = this._parentage
- return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent)
- }
- Subscription2.prototype._addParent = function (parent) {
- var _parentage = this._parentage
- this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent
- }
- Subscription2.prototype._removeParent = function (parent) {
- var _parentage = this._parentage
+ };
+ Subscription2.prototype._hasParent = function(parent) {
+ var _parentage = this._parentage;
+ return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+ };
+ Subscription2.prototype._addParent = function(parent) {
+ var _parentage = this._parentage;
+ this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+ };
+ Subscription2.prototype._removeParent = function(parent) {
+ var _parentage = this._parentage;
if (_parentage === parent) {
- this._parentage = null
+ this._parentage = null;
} else if (Array.isArray(_parentage)) {
- arrRemove(_parentage, parent)
+ arrRemove(_parentage, parent);
}
- }
- Subscription2.prototype.remove = function (teardown) {
- var _finalizers = this._finalizers
- _finalizers && arrRemove(_finalizers, teardown)
+ };
+ Subscription2.prototype.remove = function(teardown) {
+ var _finalizers = this._finalizers;
+ _finalizers && arrRemove(_finalizers, teardown);
if (teardown instanceof Subscription2) {
- teardown._removeParent(this)
+ teardown._removeParent(this);
}
- }
- Subscription2.EMPTY = function () {
- var empty = new Subscription2()
- empty.closed = true
- return empty
- }()
- return Subscription2
- }()
- EMPTY_SUBSCRIPTION = Subscription.EMPTY
+ };
+ Subscription2.EMPTY = function() {
+ var empty = new Subscription2();
+ empty.closed = true;
+ return empty;
+ }();
+ return Subscription2;
+ }();
+ EMPTY_SUBSCRIPTION = Subscription.EMPTY;
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/config.js
-var config
+var config;
var init_config = __esm({
- "node_modules/rxjs/dist/esm5/internal/config.js" () {
+ "node_modules/rxjs/dist/esm5/internal/config.js"() {
config = {
onUnhandledError: null,
onStoppedNotification: null,
Promise: void 0,
useDeprecatedSynchronousErrorHandling: false,
useDeprecatedNextContext: false
- }
+ };
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
-var timeoutProvider
+var timeoutProvider;
var init_timeoutProvider = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js" () {
- init_tslib_es6()
+ "node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js"() {
+ init_tslib_es6();
timeoutProvider = {
- setTimeout: function (handler, timeout) {
- var args = []
+ setTimeout: function(handler, timeout) {
+ var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
- args[_i - 2] = arguments[_i]
+ args[_i - 2] = arguments[_i];
}
- var delegate = timeoutProvider.delegate
+ var delegate = timeoutProvider.delegate;
if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
- return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)))
+ return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
}
- return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)))
+ return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
},
- clearTimeout: function (handle) {
- var delegate = timeoutProvider.delegate
- return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle)
+ clearTimeout: function(handle) {
+ var delegate = timeoutProvider.delegate;
+ return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
},
delegate: void 0
- }
+ };
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
-function reportUnhandledError (err) {
- timeoutProvider.setTimeout(function () {
- var onUnhandledError = config.onUnhandledError
+function reportUnhandledError(err) {
+ timeoutProvider.setTimeout(function() {
+ var onUnhandledError = config.onUnhandledError;
if (onUnhandledError) {
- onUnhandledError(err)
+ onUnhandledError(err);
} else {
- throw err
+ throw err;
}
- })
+ });
}
var init_reportUnhandledError = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js" () {
- init_config()
- init_timeoutProvider()
+ "node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js"() {
+ init_config();
+ init_timeoutProvider();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/noop.js
-function noop () {
+function noop() {
}
var init_noop = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/noop.js" () {
+ "node_modules/rxjs/dist/esm5/internal/util/noop.js"() {
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
-function errorNotification (error) {
- return createNotification("E", void 0, error)
+function errorNotification(error) {
+ return createNotification("E", void 0, error);
}
-function nextNotification (value) {
- return createNotification("N", value, void 0)
+function nextNotification(value) {
+ return createNotification("N", value, void 0);
}
-function createNotification (kind, value, error) {
+function createNotification(kind, value, error) {
return {
kind,
value,
error
- }
+ };
}
-var COMPLETE_NOTIFICATION
+var COMPLETE_NOTIFICATION;
var init_NotificationFactories = __esm({
- "node_modules/rxjs/dist/esm5/internal/NotificationFactories.js" () {
- COMPLETE_NOTIFICATION = function () {
- return createNotification("C", void 0, void 0)
- }()
+ "node_modules/rxjs/dist/esm5/internal/NotificationFactories.js"() {
+ COMPLETE_NOTIFICATION = function() {
+ return createNotification("C", void 0, void 0);
+ }();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/errorContext.js
-function errorContext (cb) {
+function errorContext(cb) {
if (config.useDeprecatedSynchronousErrorHandling) {
- var isRoot = !context
+ var isRoot = !context;
if (isRoot) {
- context = { errorThrown: false, error: null }
+ context = { errorThrown: false, error: null };
}
- cb()
+ cb();
if (isRoot) {
- var _a2 = context, errorThrown = _a2.errorThrown, error = _a2.error
- context = null
+ var _a2 = context, errorThrown = _a2.errorThrown, error = _a2.error;
+ context = null;
if (errorThrown) {
- throw error
+ throw error;
}
}
} else {
- cb()
+ cb();
}
}
-function captureError (err) {
+function captureError(err) {
if (config.useDeprecatedSynchronousErrorHandling && context) {
- context.errorThrown = true
- context.error = err
+ context.errorThrown = true;
+ context.error = err;
}
}
-var context
+var context;
var init_errorContext = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/errorContext.js" () {
- init_config()
- context = null
+ "node_modules/rxjs/dist/esm5/internal/util/errorContext.js"() {
+ init_config();
+ context = null;
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/Subscriber.js
-function bind (fn, thisArg) {
- return _bind.call(fn, thisArg)
+function bind(fn, thisArg) {
+ return _bind.call(fn, thisArg);
}
-function handleUnhandledError (error) {
+function handleUnhandledError(error) {
if (config.useDeprecatedSynchronousErrorHandling) {
- captureError(error)
+ captureError(error);
} else {
- reportUnhandledError(error)
+ reportUnhandledError(error);
}
}
-function defaultErrorHandler (err) {
- throw err
+function defaultErrorHandler(err) {
+ throw err;
}
-function handleStoppedNotification (notification, subscriber) {
- var onStoppedNotification = config.onStoppedNotification
- onStoppedNotification && timeoutProvider.setTimeout(function () {
- return onStoppedNotification(notification, subscriber)
- })
+function handleStoppedNotification(notification, subscriber) {
+ var onStoppedNotification = config.onStoppedNotification;
+ onStoppedNotification && timeoutProvider.setTimeout(function() {
+ return onStoppedNotification(notification, subscriber);
+ });
}
-var Subscriber, _bind, ConsumerObserver, SafeSubscriber, EMPTY_OBSERVER
+var Subscriber, _bind, ConsumerObserver, SafeSubscriber, EMPTY_OBSERVER;
var init_Subscriber = __esm({
- "node_modules/rxjs/dist/esm5/internal/Subscriber.js" () {
- init_tslib_es6()
- init_isFunction()
- init_Subscription()
- init_config()
- init_reportUnhandledError()
- init_noop()
- init_NotificationFactories()
- init_timeoutProvider()
- init_errorContext()
- Subscriber = function (_super) {
- __extends(Subscriber2, _super)
- function Subscriber2 (destination) {
- var _this = _super.call(this) || this
- _this.isStopped = false
+ "node_modules/rxjs/dist/esm5/internal/Subscriber.js"() {
+ init_tslib_es6();
+ init_isFunction();
+ init_Subscription();
+ init_config();
+ init_reportUnhandledError();
+ init_noop();
+ init_NotificationFactories();
+ init_timeoutProvider();
+ init_errorContext();
+ Subscriber = function(_super) {
+ __extends(Subscriber2, _super);
+ function Subscriber2(destination) {
+ var _this = _super.call(this) || this;
+ _this.isStopped = false;
if (destination) {
- _this.destination = destination
+ _this.destination = destination;
if (isSubscription(destination)) {
- destination.add(_this)
+ destination.add(_this);
}
} else {
- _this.destination = EMPTY_OBSERVER
+ _this.destination = EMPTY_OBSERVER;
}
- return _this
- }
- Subscriber2.create = function (next, error, complete) {
- return new SafeSubscriber(next, error, complete)
+ return _this;
}
- Subscriber2.prototype.next = function (value) {
+ Subscriber2.create = function(next, error, complete) {
+ return new SafeSubscriber(next, error, complete);
+ };
+ Subscriber2.prototype.next = function(value) {
if (this.isStopped) {
- handleStoppedNotification(nextNotification(value), this)
+ handleStoppedNotification(nextNotification(value), this);
} else {
- this._next(value)
+ this._next(value);
}
- }
- Subscriber2.prototype.error = function (err) {
+ };
+ Subscriber2.prototype.error = function(err) {
if (this.isStopped) {
- handleStoppedNotification(errorNotification(err), this)
+ handleStoppedNotification(errorNotification(err), this);
} else {
- this.isStopped = true
- this._error(err)
+ this.isStopped = true;
+ this._error(err);
}
- }
- Subscriber2.prototype.complete = function () {
+ };
+ Subscriber2.prototype.complete = function() {
if (this.isStopped) {
- handleStoppedNotification(COMPLETE_NOTIFICATION, this)
+ handleStoppedNotification(COMPLETE_NOTIFICATION, this);
} else {
- this.isStopped = true
- this._complete()
+ this.isStopped = true;
+ this._complete();
}
- }
- Subscriber2.prototype.unsubscribe = function () {
+ };
+ Subscriber2.prototype.unsubscribe = function() {
if (!this.closed) {
- this.isStopped = true
- _super.prototype.unsubscribe.call(this)
- this.destination = null
+ this.isStopped = true;
+ _super.prototype.unsubscribe.call(this);
+ this.destination = null;
}
- }
- Subscriber2.prototype._next = function (value) {
- this.destination.next(value)
- }
- Subscriber2.prototype._error = function (err) {
+ };
+ Subscriber2.prototype._next = function(value) {
+ this.destination.next(value);
+ };
+ Subscriber2.prototype._error = function(err) {
try {
- this.destination.error(err)
+ this.destination.error(err);
} finally {
- this.unsubscribe()
+ this.unsubscribe();
}
- }
- Subscriber2.prototype._complete = function () {
+ };
+ Subscriber2.prototype._complete = function() {
try {
- this.destination.complete()
+ this.destination.complete();
} finally {
- this.unsubscribe()
+ this.unsubscribe();
}
- }
- return Subscriber2
- }(Subscription)
- _bind = Function.prototype.bind
- ConsumerObserver = function () {
- function ConsumerObserver2 (partialObserver) {
- this.partialObserver = partialObserver
- }
- ConsumerObserver2.prototype.next = function (value) {
- var partialObserver = this.partialObserver
+ };
+ return Subscriber2;
+ }(Subscription);
+ _bind = Function.prototype.bind;
+ ConsumerObserver = function() {
+ function ConsumerObserver2(partialObserver) {
+ this.partialObserver = partialObserver;
+ }
+ ConsumerObserver2.prototype.next = function(value) {
+ var partialObserver = this.partialObserver;
if (partialObserver.next) {
try {
- partialObserver.next(value)
+ partialObserver.next(value);
} catch (error) {
- handleUnhandledError(error)
+ handleUnhandledError(error);
}
}
- }
- ConsumerObserver2.prototype.error = function (err) {
- var partialObserver = this.partialObserver
+ };
+ ConsumerObserver2.prototype.error = function(err) {
+ var partialObserver = this.partialObserver;
if (partialObserver.error) {
try {
- partialObserver.error(err)
+ partialObserver.error(err);
} catch (error) {
- handleUnhandledError(error)
+ handleUnhandledError(error);
}
} else {
- handleUnhandledError(err)
+ handleUnhandledError(err);
}
- }
- ConsumerObserver2.prototype.complete = function () {
- var partialObserver = this.partialObserver
+ };
+ ConsumerObserver2.prototype.complete = function() {
+ var partialObserver = this.partialObserver;
if (partialObserver.complete) {
try {
- partialObserver.complete()
+ partialObserver.complete();
} catch (error) {
- handleUnhandledError(error)
+ handleUnhandledError(error);
}
}
- }
- return ConsumerObserver2
- }()
- SafeSubscriber = function (_super) {
- __extends(SafeSubscriber2, _super)
- function SafeSubscriber2 (observerOrNext, error, complete) {
- var _this = _super.call(this) || this
- var partialObserver
+ };
+ return ConsumerObserver2;
+ }();
+ SafeSubscriber = function(_super) {
+ __extends(SafeSubscriber2, _super);
+ function SafeSubscriber2(observerOrNext, error, complete) {
+ var _this = _super.call(this) || this;
+ var partialObserver;
if (isFunction(observerOrNext) || !observerOrNext) {
partialObserver = {
next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
error: error !== null && error !== void 0 ? error : void 0,
complete: complete !== null && complete !== void 0 ? complete : void 0
- }
+ };
} else {
- var context_1
+ var context_1;
if (_this && config.useDeprecatedNextContext) {
- context_1 = Object.create(observerOrNext)
- context_1.unsubscribe = function () {
- return _this.unsubscribe()
- }
+ context_1 = Object.create(observerOrNext);
+ context_1.unsubscribe = function() {
+ return _this.unsubscribe();
+ };
partialObserver = {
next: observerOrNext.next && bind(observerOrNext.next, context_1),
error: observerOrNext.error && bind(observerOrNext.error, context_1),
complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
- }
+ };
} else {
- partialObserver = observerOrNext
+ partialObserver = observerOrNext;
}
}
- _this.destination = new ConsumerObserver(partialObserver)
- return _this
+ _this.destination = new ConsumerObserver(partialObserver);
+ return _this;
}
- return SafeSubscriber2
- }(Subscriber)
+ return SafeSubscriber2;
+ }(Subscriber);
EMPTY_OBSERVER = {
closed: true,
next: noop,
error: defaultErrorHandler,
complete: noop
- }
+ };
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/symbol/observable.js
-var observable
+var observable;
var init_observable = __esm({
- "node_modules/rxjs/dist/esm5/internal/symbol/observable.js" () {
- observable = function () {
- return typeof Symbol === "function" && Symbol.observable || "@@observable"
- }()
+ "node_modules/rxjs/dist/esm5/internal/symbol/observable.js"() {
+ observable = function() {
+ return typeof Symbol === "function" && Symbol.observable || "@@observable";
+ }();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/identity.js
-function identity (x) {
- return x
+function identity(x) {
+ return x;
}
var init_identity = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/identity.js" () {
+ "node_modules/rxjs/dist/esm5/internal/util/identity.js"() {
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/pipe.js
-function pipeFromArray (fns) {
+function pipeFromArray(fns) {
if (fns.length === 0) {
- return identity
+ return identity;
}
if (fns.length === 1) {
- return fns[0]
- }
- return function piped (input) {
- return fns.reduce(function (prev, fn) {
- return fn(prev)
- }, input)
+ return fns[0];
}
+ return function piped(input) {
+ return fns.reduce(function(prev, fn) {
+ return fn(prev);
+ }, input);
+ };
}
var init_pipe = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/pipe.js" () {
- init_identity()
+ "node_modules/rxjs/dist/esm5/internal/util/pipe.js"() {
+ init_identity();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/Observable.js
-function getPromiseCtor (promiseCtor) {
- var _a2
- return (_a2 = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a2 !== void 0 ? _a2 : Promise
+function getPromiseCtor(promiseCtor) {
+ var _a2;
+ return (_a2 = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a2 !== void 0 ? _a2 : Promise;
}
-function isObserver (value) {
- return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete)
+function isObserver(value) {
+ return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
}
-function isSubscriber (value) {
- return value && value instanceof Subscriber || isObserver(value) && isSubscription(value)
+function isSubscriber(value) {
+ return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
}
-var Observable
+var Observable;
var init_Observable = __esm({
- "node_modules/rxjs/dist/esm5/internal/Observable.js" () {
- init_Subscriber()
- init_Subscription()
- init_observable()
- init_pipe()
- init_config()
- init_isFunction()
- init_errorContext()
- Observable = function () {
- function Observable2 (subscribe) {
+ "node_modules/rxjs/dist/esm5/internal/Observable.js"() {
+ init_Subscriber();
+ init_Subscription();
+ init_observable();
+ init_pipe();
+ init_config();
+ init_isFunction();
+ init_errorContext();
+ Observable = function() {
+ function Observable2(subscribe) {
if (subscribe) {
- this._subscribe = subscribe
+ this._subscribe = subscribe;
}
}
- Observable2.prototype.lift = function (operator) {
- var observable2 = new Observable2()
- observable2.source = this
- observable2.operator = operator
- return observable2
- }
- Observable2.prototype.subscribe = function (observerOrNext, error, complete) {
- var _this = this
- var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete)
- errorContext(function () {
- var _a2 = _this, operator = _a2.operator, source = _a2.source
- subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber))
- })
- return subscriber
- }
- Observable2.prototype._trySubscribe = function (sink) {
+ Observable2.prototype.lift = function(operator) {
+ var observable2 = new Observable2();
+ observable2.source = this;
+ observable2.operator = operator;
+ return observable2;
+ };
+ Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+ var _this = this;
+ var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+ errorContext(function() {
+ var _a2 = _this, operator = _a2.operator, source = _a2.source;
+ subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+ });
+ return subscriber;
+ };
+ Observable2.prototype._trySubscribe = function(sink) {
try {
- return this._subscribe(sink)
+ return this._subscribe(sink);
} catch (err) {
- sink.error(err)
+ sink.error(err);
}
- }
- Observable2.prototype.forEach = function (next, promiseCtor) {
- var _this = this
- promiseCtor = getPromiseCtor(promiseCtor)
- return new promiseCtor(function (resolve, reject) {
+ };
+ Observable2.prototype.forEach = function(next, promiseCtor) {
+ var _this = this;
+ promiseCtor = getPromiseCtor(promiseCtor);
+ return new promiseCtor(function(resolve, reject) {
var subscriber = new SafeSubscriber({
- next: function (value) {
+ next: function(value) {
try {
- next(value)
+ next(value);
} catch (err) {
- reject(err)
- subscriber.unsubscribe()
+ reject(err);
+ subscriber.unsubscribe();
}
},
error: reject,
complete: resolve
- })
- _this.subscribe(subscriber)
- })
- }
- Observable2.prototype._subscribe = function (subscriber) {
- var _a2
- return (_a2 = this.source) === null || _a2 === void 0 ? void 0 : _a2.subscribe(subscriber)
- }
- Observable2.prototype[observable] = function () {
- return this
- }
- Observable2.prototype.pipe = function () {
- var operations = []
+ });
+ _this.subscribe(subscriber);
+ });
+ };
+ Observable2.prototype._subscribe = function(subscriber) {
+ var _a2;
+ return (_a2 = this.source) === null || _a2 === void 0 ? void 0 : _a2.subscribe(subscriber);
+ };
+ Observable2.prototype[observable] = function() {
+ return this;
+ };
+ Observable2.prototype.pipe = function() {
+ var operations = [];
for (var _i = 0; _i < arguments.length; _i++) {
- operations[_i] = arguments[_i]
+ operations[_i] = arguments[_i];
}
- return pipeFromArray(operations)(this)
- }
- Observable2.prototype.toPromise = function (promiseCtor) {
- var _this = this
- promiseCtor = getPromiseCtor(promiseCtor)
- return new promiseCtor(function (resolve, reject) {
- var value
- _this.subscribe(function (x) {
- return value = x
- }, function (err) {
- return reject(err)
- }, function () {
- return resolve(value)
- })
- })
- }
- Observable2.create = function (subscribe) {
- return new Observable2(subscribe)
- }
- return Observable2
- }()
+ return pipeFromArray(operations)(this);
+ };
+ Observable2.prototype.toPromise = function(promiseCtor) {
+ var _this = this;
+ promiseCtor = getPromiseCtor(promiseCtor);
+ return new promiseCtor(function(resolve, reject) {
+ var value;
+ _this.subscribe(function(x) {
+ return value = x;
+ }, function(err) {
+ return reject(err);
+ }, function() {
+ return resolve(value);
+ });
+ });
+ };
+ Observable2.create = function(subscribe) {
+ return new Observable2(subscribe);
+ };
+ return Observable2;
+ }();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/lift.js
-function hasLift (source) {
- return isFunction(source === null || source === void 0 ? void 0 : source.lift)
+function hasLift(source) {
+ return isFunction(source === null || source === void 0 ? void 0 : source.lift);
}
-function operate (init) {
- return function (source) {
+function operate(init) {
+ return function(source) {
if (hasLift(source)) {
- return source.lift(function (liftedSource) {
+ return source.lift(function(liftedSource) {
try {
- return init(liftedSource, this)
+ return init(liftedSource, this);
} catch (err) {
- this.error(err)
+ this.error(err);
}
- })
+ });
}
- throw new TypeError("Unable to lift unknown Observable type")
- }
+ throw new TypeError("Unable to lift unknown Observable type");
+ };
}
var init_lift = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/lift.js" () {
- init_isFunction()
+ "node_modules/rxjs/dist/esm5/internal/util/lift.js"() {
+ init_isFunction();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js
-function createOperatorSubscriber (destination, onNext, onComplete, onError, onFinalize) {
- return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize)
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+ return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
}
-var OperatorSubscriber
+var OperatorSubscriber;
var init_OperatorSubscriber = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js" () {
- init_tslib_es6()
- init_Subscriber()
- OperatorSubscriber = function (_super) {
- __extends(OperatorSubscriber2, _super)
- function OperatorSubscriber2 (destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
- var _this = _super.call(this, destination) || this
- _this.onFinalize = onFinalize
- _this.shouldUnsubscribe = shouldUnsubscribe
- _this._next = onNext ? function (value) {
+ "node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js"() {
+ init_tslib_es6();
+ init_Subscriber();
+ OperatorSubscriber = function(_super) {
+ __extends(OperatorSubscriber2, _super);
+ function OperatorSubscriber2(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+ var _this = _super.call(this, destination) || this;
+ _this.onFinalize = onFinalize;
+ _this.shouldUnsubscribe = shouldUnsubscribe;
+ _this._next = onNext ? function(value) {
try {
- onNext(value)
+ onNext(value);
} catch (err) {
- destination.error(err)
+ destination.error(err);
}
- } : _super.prototype._next
- _this._error = onError ? function (err) {
+ } : _super.prototype._next;
+ _this._error = onError ? function(err) {
try {
- onError(err)
+ onError(err);
} catch (err2) {
- destination.error(err2)
+ destination.error(err2);
} finally {
- this.unsubscribe()
+ this.unsubscribe();
}
- } : _super.prototype._error
- _this._complete = onComplete ? function () {
+ } : _super.prototype._error;
+ _this._complete = onComplete ? function() {
try {
- onComplete()
+ onComplete();
} catch (err) {
- destination.error(err)
+ destination.error(err);
} finally {
- this.unsubscribe()
+ this.unsubscribe();
}
- } : _super.prototype._complete
- return _this
+ } : _super.prototype._complete;
+ return _this;
}
- OperatorSubscriber2.prototype.unsubscribe = function () {
- var _a2
+ OperatorSubscriber2.prototype.unsubscribe = function() {
+ var _a2;
if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
- var closed_1 = this.closed
- _super.prototype.unsubscribe.call(this)
- !closed_1 && ((_a2 = this.onFinalize) === null || _a2 === void 0 ? void 0 : _a2.call(this))
+ var closed_1 = this.closed;
+ _super.prototype.unsubscribe.call(this);
+ !closed_1 && ((_a2 = this.onFinalize) === null || _a2 === void 0 ? void 0 : _a2.call(this));
}
- }
- return OperatorSubscriber2
- }(Subscriber)
+ };
+ return OperatorSubscriber2;
+ }(Subscriber);
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js
-var ObjectUnsubscribedError
+var ObjectUnsubscribedError;
var init_ObjectUnsubscribedError = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js" () {
- init_createErrorClass()
- ObjectUnsubscribedError = createErrorClass(function (_super) {
- return function ObjectUnsubscribedErrorImpl () {
- _super(this)
- this.name = "ObjectUnsubscribedError"
- this.message = "object unsubscribed"
- }
- })
+ "node_modules/rxjs/dist/esm5/internal/util/ObjectUnsubscribedError.js"() {
+ init_createErrorClass();
+ ObjectUnsubscribedError = createErrorClass(function(_super) {
+ return function ObjectUnsubscribedErrorImpl() {
+ _super(this);
+ this.name = "ObjectUnsubscribedError";
+ this.message = "object unsubscribed";
+ };
+ });
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/Subject.js
-var Subject, AnonymousSubject
+var Subject, AnonymousSubject;
var init_Subject = __esm({
- "node_modules/rxjs/dist/esm5/internal/Subject.js" () {
- init_tslib_es6()
- init_Observable()
- init_Subscription()
- init_ObjectUnsubscribedError()
- init_arrRemove()
- init_errorContext()
- Subject = function (_super) {
- __extends(Subject2, _super)
- function Subject2 () {
- var _this = _super.call(this) || this
- _this.closed = false
- _this.currentObservers = null
- _this.observers = []
- _this.isStopped = false
- _this.hasError = false
- _this.thrownError = null
- return _this
- }
- Subject2.prototype.lift = function (operator) {
- var subject = new AnonymousSubject(this, this)
- subject.operator = operator
- return subject
- }
- Subject2.prototype._throwIfClosed = function () {
+ "node_modules/rxjs/dist/esm5/internal/Subject.js"() {
+ init_tslib_es6();
+ init_Observable();
+ init_Subscription();
+ init_ObjectUnsubscribedError();
+ init_arrRemove();
+ init_errorContext();
+ Subject = function(_super) {
+ __extends(Subject2, _super);
+ function Subject2() {
+ var _this = _super.call(this) || this;
+ _this.closed = false;
+ _this.currentObservers = null;
+ _this.observers = [];
+ _this.isStopped = false;
+ _this.hasError = false;
+ _this.thrownError = null;
+ return _this;
+ }
+ Subject2.prototype.lift = function(operator) {
+ var subject = new AnonymousSubject(this, this);
+ subject.operator = operator;
+ return subject;
+ };
+ Subject2.prototype._throwIfClosed = function() {
if (this.closed) {
- throw new ObjectUnsubscribedError()
+ throw new ObjectUnsubscribedError();
}
- }
- Subject2.prototype.next = function (value) {
- var _this = this
- errorContext(function () {
- var e_1, _a2
- _this._throwIfClosed()
+ };
+ Subject2.prototype.next = function(value) {
+ var _this = this;
+ errorContext(function() {
+ var e_1, _a2;
+ _this._throwIfClosed();
if (!_this.isStopped) {
if (!_this.currentObservers) {
- _this.currentObservers = Array.from(_this.observers)
+ _this.currentObservers = Array.from(_this.observers);
}
try {
for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
- var observer = _c.value
- observer.next(value)
+ var observer = _c.value;
+ observer.next(value);
}
} catch (e_1_1) {
- e_1 = { error: e_1_1 }
+ e_1 = { error: e_1_1 };
} finally {
try {
- if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b)
+ if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
} finally {
- if (e_1) throw e_1.error
+ if (e_1) throw e_1.error;
}
}
}
- })
- }
- Subject2.prototype.error = function (err) {
- var _this = this
- errorContext(function () {
- _this._throwIfClosed()
+ });
+ };
+ Subject2.prototype.error = function(err) {
+ var _this = this;
+ errorContext(function() {
+ _this._throwIfClosed();
if (!_this.isStopped) {
- _this.hasError = _this.isStopped = true
- _this.thrownError = err
- var observers = _this.observers
+ _this.hasError = _this.isStopped = true;
+ _this.thrownError = err;
+ var observers = _this.observers;
while (observers.length) {
- observers.shift().error(err)
+ observers.shift().error(err);
}
}
- })
- }
- Subject2.prototype.complete = function () {
- var _this = this
- errorContext(function () {
- _this._throwIfClosed()
+ });
+ };
+ Subject2.prototype.complete = function() {
+ var _this = this;
+ errorContext(function() {
+ _this._throwIfClosed();
if (!_this.isStopped) {
- _this.isStopped = true
- var observers = _this.observers
+ _this.isStopped = true;
+ var observers = _this.observers;
while (observers.length) {
- observers.shift().complete()
+ observers.shift().complete();
}
}
- })
- }
- Subject2.prototype.unsubscribe = function () {
- this.isStopped = this.closed = true
- this.observers = this.currentObservers = null
- }
+ });
+ };
+ Subject2.prototype.unsubscribe = function() {
+ this.isStopped = this.closed = true;
+ this.observers = this.currentObservers = null;
+ };
Object.defineProperty(Subject2.prototype, "observed", {
- get: function () {
- var _a2
- return ((_a2 = this.observers) === null || _a2 === void 0 ? void 0 : _a2.length) > 0
+ get: function() {
+ var _a2;
+ return ((_a2 = this.observers) === null || _a2 === void 0 ? void 0 : _a2.length) > 0;
},
enumerable: false,
configurable: true
- })
- Subject2.prototype._trySubscribe = function (subscriber) {
- this._throwIfClosed()
- return _super.prototype._trySubscribe.call(this, subscriber)
- }
- Subject2.prototype._subscribe = function (subscriber) {
- this._throwIfClosed()
- this._checkFinalizedStatuses(subscriber)
- return this._innerSubscribe(subscriber)
- }
- Subject2.prototype._innerSubscribe = function (subscriber) {
- var _this = this
- var _a2 = this, hasError = _a2.hasError, isStopped = _a2.isStopped, observers = _a2.observers
+ });
+ Subject2.prototype._trySubscribe = function(subscriber) {
+ this._throwIfClosed();
+ return _super.prototype._trySubscribe.call(this, subscriber);
+ };
+ Subject2.prototype._subscribe = function(subscriber) {
+ this._throwIfClosed();
+ this._checkFinalizedStatuses(subscriber);
+ return this._innerSubscribe(subscriber);
+ };
+ Subject2.prototype._innerSubscribe = function(subscriber) {
+ var _this = this;
+ var _a2 = this, hasError = _a2.hasError, isStopped = _a2.isStopped, observers = _a2.observers;
if (hasError || isStopped) {
- return EMPTY_SUBSCRIPTION
- }
- this.currentObservers = null
- observers.push(subscriber)
- return new Subscription(function () {
- _this.currentObservers = null
- arrRemove(observers, subscriber)
- })
- }
- Subject2.prototype._checkFinalizedStatuses = function (subscriber) {
- var _a2 = this, hasError = _a2.hasError, thrownError = _a2.thrownError, isStopped = _a2.isStopped
+ return EMPTY_SUBSCRIPTION;
+ }
+ this.currentObservers = null;
+ observers.push(subscriber);
+ return new Subscription(function() {
+ _this.currentObservers = null;
+ arrRemove(observers, subscriber);
+ });
+ };
+ Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+ var _a2 = this, hasError = _a2.hasError, thrownError = _a2.thrownError, isStopped = _a2.isStopped;
if (hasError) {
- subscriber.error(thrownError)
+ subscriber.error(thrownError);
} else if (isStopped) {
- subscriber.complete()
+ subscriber.complete();
}
- }
- Subject2.prototype.asObservable = function () {
- var observable2 = new Observable()
- observable2.source = this
- return observable2
- }
- Subject2.create = function (destination, source) {
- return new AnonymousSubject(destination, source)
- }
- return Subject2
- }(Observable)
- AnonymousSubject = function (_super) {
- __extends(AnonymousSubject2, _super)
- function AnonymousSubject2 (destination, source) {
- var _this = _super.call(this) || this
- _this.destination = destination
- _this.source = source
- return _this
- }
- AnonymousSubject2.prototype.next = function (value) {
+ };
+ Subject2.prototype.asObservable = function() {
+ var observable2 = new Observable();
+ observable2.source = this;
+ return observable2;
+ };
+ Subject2.create = function(destination, source) {
+ return new AnonymousSubject(destination, source);
+ };
+ return Subject2;
+ }(Observable);
+ AnonymousSubject = function(_super) {
+ __extends(AnonymousSubject2, _super);
+ function AnonymousSubject2(destination, source) {
+ var _this = _super.call(this) || this;
+ _this.destination = destination;
+ _this.source = source;
+ return _this;
+ }
+ AnonymousSubject2.prototype.next = function(value) {
var _a2, _b;
- (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.next) === null || _b === void 0 ? void 0 : _b.call(_a2, value)
- }
- AnonymousSubject2.prototype.error = function (err) {
+ (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.next) === null || _b === void 0 ? void 0 : _b.call(_a2, value);
+ };
+ AnonymousSubject2.prototype.error = function(err) {
var _a2, _b;
- (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.error) === null || _b === void 0 ? void 0 : _b.call(_a2, err)
- }
- AnonymousSubject2.prototype.complete = function () {
+ (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.error) === null || _b === void 0 ? void 0 : _b.call(_a2, err);
+ };
+ AnonymousSubject2.prototype.complete = function() {
var _a2, _b;
- (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.complete) === null || _b === void 0 ? void 0 : _b.call(_a2)
- }
- AnonymousSubject2.prototype._subscribe = function (subscriber) {
- var _a2, _b
- return (_b = (_a2 = this.source) === null || _a2 === void 0 ? void 0 : _a2.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION
- }
- return AnonymousSubject2
- }(Subject)
+ (_b = (_a2 = this.destination) === null || _a2 === void 0 ? void 0 : _a2.complete) === null || _b === void 0 ? void 0 : _b.call(_a2);
+ };
+ AnonymousSubject2.prototype._subscribe = function(subscriber) {
+ var _a2, _b;
+ return (_b = (_a2 = this.source) === null || _a2 === void 0 ? void 0 : _a2.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+ };
+ return AnonymousSubject2;
+ }(Subject);
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduler/dateTimestampProvider.js
-var dateTimestampProvider
+var dateTimestampProvider;
var init_dateTimestampProvider = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduler/dateTimestampProvider.js" () {
+ "node_modules/rxjs/dist/esm5/internal/scheduler/dateTimestampProvider.js"() {
dateTimestampProvider = {
- now: function () {
- return (dateTimestampProvider.delegate || Date).now()
+ now: function() {
+ return (dateTimestampProvider.delegate || Date).now();
},
delegate: void 0
- }
+ };
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/ReplaySubject.js
-var ReplaySubject
+var ReplaySubject;
var init_ReplaySubject = __esm({
- "node_modules/rxjs/dist/esm5/internal/ReplaySubject.js" () {
- init_tslib_es6()
- init_Subject()
- init_dateTimestampProvider()
- ReplaySubject = function (_super) {
- __extends(ReplaySubject2, _super)
- function ReplaySubject2 (_bufferSize, _windowTime, _timestampProvider) {
+ "node_modules/rxjs/dist/esm5/internal/ReplaySubject.js"() {
+ init_tslib_es6();
+ init_Subject();
+ init_dateTimestampProvider();
+ ReplaySubject = function(_super) {
+ __extends(ReplaySubject2, _super);
+ function ReplaySubject2(_bufferSize, _windowTime, _timestampProvider) {
if (_bufferSize === void 0) {
- _bufferSize = Infinity
+ _bufferSize = Infinity;
}
if (_windowTime === void 0) {
- _windowTime = Infinity
+ _windowTime = Infinity;
}
if (_timestampProvider === void 0) {
- _timestampProvider = dateTimestampProvider
- }
- var _this = _super.call(this) || this
- _this._bufferSize = _bufferSize
- _this._windowTime = _windowTime
- _this._timestampProvider = _timestampProvider
- _this._buffer = []
- _this._infiniteTimeWindow = true
- _this._infiniteTimeWindow = _windowTime === Infinity
- _this._bufferSize = Math.max(1, _bufferSize)
- _this._windowTime = Math.max(1, _windowTime)
- return _this
- }
- ReplaySubject2.prototype.next = function (value) {
- var _a2 = this, isStopped = _a2.isStopped, _buffer = _a2._buffer, _infiniteTimeWindow = _a2._infiniteTimeWindow, _timestampProvider = _a2._timestampProvider, _windowTime = _a2._windowTime
+ _timestampProvider = dateTimestampProvider;
+ }
+ var _this = _super.call(this) || this;
+ _this._bufferSize = _bufferSize;
+ _this._windowTime = _windowTime;
+ _this._timestampProvider = _timestampProvider;
+ _this._buffer = [];
+ _this._infiniteTimeWindow = true;
+ _this._infiniteTimeWindow = _windowTime === Infinity;
+ _this._bufferSize = Math.max(1, _bufferSize);
+ _this._windowTime = Math.max(1, _windowTime);
+ return _this;
+ }
+ ReplaySubject2.prototype.next = function(value) {
+ var _a2 = this, isStopped = _a2.isStopped, _buffer = _a2._buffer, _infiniteTimeWindow = _a2._infiniteTimeWindow, _timestampProvider = _a2._timestampProvider, _windowTime = _a2._windowTime;
if (!isStopped) {
- _buffer.push(value)
- !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime)
- }
- this._trimBuffer()
- _super.prototype.next.call(this, value)
- }
- ReplaySubject2.prototype._subscribe = function (subscriber) {
- this._throwIfClosed()
- this._trimBuffer()
- var subscription = this._innerSubscribe(subscriber)
- var _a2 = this, _infiniteTimeWindow = _a2._infiniteTimeWindow, _buffer = _a2._buffer
- var copy = _buffer.slice()
+ _buffer.push(value);
+ !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+ }
+ this._trimBuffer();
+ _super.prototype.next.call(this, value);
+ };
+ ReplaySubject2.prototype._subscribe = function(subscriber) {
+ this._throwIfClosed();
+ this._trimBuffer();
+ var subscription = this._innerSubscribe(subscriber);
+ var _a2 = this, _infiniteTimeWindow = _a2._infiniteTimeWindow, _buffer = _a2._buffer;
+ var copy = _buffer.slice();
for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
- subscriber.next(copy[i])
+ subscriber.next(copy[i]);
}
- this._checkFinalizedStatuses(subscriber)
- return subscription
- }
- ReplaySubject2.prototype._trimBuffer = function () {
- var _a2 = this, _bufferSize = _a2._bufferSize, _timestampProvider = _a2._timestampProvider, _buffer = _a2._buffer, _infiniteTimeWindow = _a2._infiniteTimeWindow
- var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize
- _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize)
+ this._checkFinalizedStatuses(subscriber);
+ return subscription;
+ };
+ ReplaySubject2.prototype._trimBuffer = function() {
+ var _a2 = this, _bufferSize = _a2._bufferSize, _timestampProvider = _a2._timestampProvider, _buffer = _a2._buffer, _infiniteTimeWindow = _a2._infiniteTimeWindow;
+ var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+ _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
if (!_infiniteTimeWindow) {
- var now = _timestampProvider.now()
- var last2 = 0
+ var now = _timestampProvider.now();
+ var last2 = 0;
for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
- last2 = i
+ last2 = i;
}
- last2 && _buffer.splice(0, last2 + 1)
+ last2 && _buffer.splice(0, last2 + 1);
}
- }
- return ReplaySubject2
- }(Subject)
+ };
+ return ReplaySubject2;
+ }(Subject);
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/observable/empty.js
-var EMPTY
+var EMPTY;
var init_empty = __esm({
- "node_modules/rxjs/dist/esm5/internal/observable/empty.js" () {
- init_Observable()
- EMPTY = new Observable(function (subscriber) {
- return subscriber.complete()
- })
+ "node_modules/rxjs/dist/esm5/internal/observable/empty.js"() {
+ init_Observable();
+ EMPTY = new Observable(function(subscriber) {
+ return subscriber.complete();
+ });
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/isScheduler.js
-function isScheduler (value) {
- return value && isFunction(value.schedule)
+function isScheduler(value) {
+ return value && isFunction(value.schedule);
}
var init_isScheduler = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/isScheduler.js" () {
- init_isFunction()
+ "node_modules/rxjs/dist/esm5/internal/util/isScheduler.js"() {
+ init_isFunction();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/args.js
-function last (arr) {
- return arr[arr.length - 1]
+function last(arr) {
+ return arr[arr.length - 1];
}
-function popScheduler (args) {
- return isScheduler(last(args)) ? args.pop() : void 0
+function popScheduler(args) {
+ return isScheduler(last(args)) ? args.pop() : void 0;
}
-function popNumber (args, defaultValue) {
- return typeof last(args) === "number" ? args.pop() : defaultValue
+function popNumber(args, defaultValue) {
+ return typeof last(args) === "number" ? args.pop() : defaultValue;
}
var init_args = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/args.js" () {
- init_isScheduler()
+ "node_modules/rxjs/dist/esm5/internal/util/args.js"() {
+ init_isScheduler();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js
-var isArrayLike
+var isArrayLike;
var init_isArrayLike = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js" () {
- isArrayLike = function (x) {
- return x && typeof x.length === "number" && typeof x !== "function"
- }
+ "node_modules/rxjs/dist/esm5/internal/util/isArrayLike.js"() {
+ isArrayLike = function(x) {
+ return x && typeof x.length === "number" && typeof x !== "function";
+ };
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/isPromise.js
-function isPromise (value) {
- return isFunction(value === null || value === void 0 ? void 0 : value.then)
+function isPromise(value) {
+ return isFunction(value === null || value === void 0 ? void 0 : value.then);
}
var init_isPromise = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/isPromise.js" () {
- init_isFunction()
+ "node_modules/rxjs/dist/esm5/internal/util/isPromise.js"() {
+ init_isFunction();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js
-function isInteropObservable (input) {
- return isFunction(input[observable])
+function isInteropObservable(input) {
+ return isFunction(input[observable]);
}
var init_isInteropObservable = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js" () {
- init_observable()
- init_isFunction()
+ "node_modules/rxjs/dist/esm5/internal/util/isInteropObservable.js"() {
+ init_observable();
+ init_isFunction();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js
-function isAsyncIterable (obj) {
- return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator])
+function isAsyncIterable(obj) {
+ return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
}
var init_isAsyncIterable = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js" () {
- init_isFunction()
+ "node_modules/rxjs/dist/esm5/internal/util/isAsyncIterable.js"() {
+ init_isFunction();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js
-function createInvalidObservableTypeError (input) {
- return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.")
+function createInvalidObservableTypeError(input) {
+ return new TypeError("You provided " + (input !== null && typeof input === "object" ? "an invalid object" : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
}
var init_throwUnobservableError = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js" () {
+ "node_modules/rxjs/dist/esm5/internal/util/throwUnobservableError.js"() {
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/symbol/iterator.js
-function getSymbolIterator () {
+function getSymbolIterator() {
if (typeof Symbol !== "function" || !Symbol.iterator) {
- return "@@iterator"
+ return "@@iterator";
}
- return Symbol.iterator
+ return Symbol.iterator;
}
-var iterator
+var iterator;
var init_iterator = __esm({
- "node_modules/rxjs/dist/esm5/internal/symbol/iterator.js" () {
- iterator = getSymbolIterator()
+ "node_modules/rxjs/dist/esm5/internal/symbol/iterator.js"() {
+ iterator = getSymbolIterator();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/isIterable.js
-function isIterable (input) {
- return isFunction(input === null || input === void 0 ? void 0 : input[iterator])
+function isIterable(input) {
+ return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
}
var init_isIterable = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/isIterable.js" () {
- init_iterator()
- init_isFunction()
+ "node_modules/rxjs/dist/esm5/internal/util/isIterable.js"() {
+ init_iterator();
+ init_isFunction();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js
-function readableStreamLikeToAsyncGenerator (readableStream) {
- return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1 () {
- var reader, _a2, value, done
- return __generator(this, function (_b) {
+function readableStreamLikeToAsyncGenerator(readableStream) {
+ return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+ var reader, _a2, value, done;
+ return __generator(this, function(_b) {
switch (_b.label) {
case 0:
- reader = readableStream.getReader()
- _b.label = 1
+ reader = readableStream.getReader();
+ _b.label = 1;
case 1:
- _b.trys.push([1, , 9, 10])
- _b.label = 2
+ _b.trys.push([1, , 9, 10]);
+ _b.label = 2;
case 2:
- if (false) return [3, 8]
- return [4, __await(reader.read())]
+ if (false) return [3, 8];
+ return [4, __await(reader.read())];
case 3:
- _a2 = _b.sent(), value = _a2.value, done = _a2.done
- if (!done) return [3, 5]
- return [4, __await(void 0)]
+ _a2 = _b.sent(), value = _a2.value, done = _a2.done;
+ if (!done) return [3, 5];
+ return [4, __await(void 0)];
case 4:
- return [2, _b.sent()]
+ return [2, _b.sent()];
case 5:
- return [4, __await(value)]
+ return [4, __await(value)];
case 6:
- return [4, _b.sent()]
+ return [4, _b.sent()];
case 7:
- _b.sent()
- return [3, 2]
+ _b.sent();
+ return [3, 2];
case 8:
- return [3, 10]
+ return [3, 10];
case 9:
- reader.releaseLock()
- return [7]
+ reader.releaseLock();
+ return [7];
case 10:
- return [2]
+ return [2];
}
- })
- })
+ });
+ });
}
-function isReadableStreamLike (obj) {
- return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader)
+function isReadableStreamLike(obj) {
+ return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
}
var init_isReadableStreamLike = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js" () {
- init_tslib_es6()
- init_isFunction()
+ "node_modules/rxjs/dist/esm5/internal/util/isReadableStreamLike.js"() {
+ init_tslib_es6();
+ init_isFunction();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js
-function innerFrom (input) {
+function innerFrom(input) {
if (input instanceof Observable) {
- return input
+ return input;
}
if (input != null) {
if (isInteropObservable(input)) {
- return fromInteropObservable(input)
+ return fromInteropObservable(input);
}
if (isArrayLike(input)) {
- return fromArrayLike(input)
+ return fromArrayLike(input);
}
if (isPromise(input)) {
- return fromPromise(input)
+ return fromPromise(input);
}
if (isAsyncIterable(input)) {
- return fromAsyncIterable(input)
+ return fromAsyncIterable(input);
}
if (isIterable(input)) {
- return fromIterable(input)
+ return fromIterable(input);
}
if (isReadableStreamLike(input)) {
- return fromReadableStreamLike(input)
+ return fromReadableStreamLike(input);
}
}
- throw createInvalidObservableTypeError(input)
+ throw createInvalidObservableTypeError(input);
}
-function fromInteropObservable (obj) {
- return new Observable(function (subscriber) {
- var obs = obj[observable]()
+function fromInteropObservable(obj) {
+ return new Observable(function(subscriber) {
+ var obs = obj[observable]();
if (isFunction(obs.subscribe)) {
- return obs.subscribe(subscriber)
+ return obs.subscribe(subscriber);
}
- throw new TypeError("Provided object does not correctly implement Symbol.observable")
- })
+ throw new TypeError("Provided object does not correctly implement Symbol.observable");
+ });
}
-function fromArrayLike (array) {
- return new Observable(function (subscriber) {
+function fromArrayLike(array) {
+ return new Observable(function(subscriber) {
for (var i = 0; i < array.length && !subscriber.closed; i++) {
- subscriber.next(array[i])
+ subscriber.next(array[i]);
}
- subscriber.complete()
- })
+ subscriber.complete();
+ });
}
-function fromPromise (promise) {
- return new Observable(function (subscriber) {
- promise.then(function (value) {
+function fromPromise(promise) {
+ return new Observable(function(subscriber) {
+ promise.then(function(value) {
if (!subscriber.closed) {
- subscriber.next(value)
- subscriber.complete()
+ subscriber.next(value);
+ subscriber.complete();
}
- }, function (err) {
- return subscriber.error(err)
- }).then(null, reportUnhandledError)
- })
+ }, function(err) {
+ return subscriber.error(err);
+ }).then(null, reportUnhandledError);
+ });
}
-function fromIterable (iterable) {
- return new Observable(function (subscriber) {
- var e_1, _a2
+function fromIterable(iterable) {
+ return new Observable(function(subscriber) {
+ var e_1, _a2;
try {
for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
- var value = iterable_1_1.value
- subscriber.next(value)
+ var value = iterable_1_1.value;
+ subscriber.next(value);
if (subscriber.closed) {
- return
+ return;
}
}
} catch (e_1_1) {
- e_1 = { error: e_1_1 }
+ e_1 = { error: e_1_1 };
} finally {
try {
- if (iterable_1_1 && !iterable_1_1.done && (_a2 = iterable_1.return)) _a2.call(iterable_1)
+ if (iterable_1_1 && !iterable_1_1.done && (_a2 = iterable_1.return)) _a2.call(iterable_1);
} finally {
- if (e_1) throw e_1.error
+ if (e_1) throw e_1.error;
}
}
- subscriber.complete()
- })
+ subscriber.complete();
+ });
}
-function fromAsyncIterable (asyncIterable) {
- return new Observable(function (subscriber) {
- process2(asyncIterable, subscriber).catch(function (err) {
- return subscriber.error(err)
- })
- })
+function fromAsyncIterable(asyncIterable) {
+ return new Observable(function(subscriber) {
+ process2(asyncIterable, subscriber).catch(function(err) {
+ return subscriber.error(err);
+ });
+ });
}
-function fromReadableStreamLike (readableStream) {
- return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream))
+function fromReadableStreamLike(readableStream) {
+ return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
}
-function process2 (asyncIterable, subscriber) {
- var asyncIterable_1, asyncIterable_1_1
- var e_2, _a2
- return __awaiter2(this, void 0, void 0, function () {
- var value, e_2_1
- return __generator(this, function (_b) {
+function process2(asyncIterable, subscriber) {
+ var asyncIterable_1, asyncIterable_1_1;
+ var e_2, _a2;
+ return __awaiter2(this, void 0, void 0, function() {
+ var value, e_2_1;
+ return __generator(this, function(_b) {
switch (_b.label) {
case 0:
- _b.trys.push([0, 5, 6, 11])
- asyncIterable_1 = __asyncValues(asyncIterable)
- _b.label = 1
+ _b.trys.push([0, 5, 6, 11]);
+ asyncIterable_1 = __asyncValues(asyncIterable);
+ _b.label = 1;
case 1:
- return [4, asyncIterable_1.next()]
+ return [4, asyncIterable_1.next()];
case 2:
- if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4]
- value = asyncIterable_1_1.value
- subscriber.next(value)
+ if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+ value = asyncIterable_1_1.value;
+ subscriber.next(value);
if (subscriber.closed) {
- return [2]
+ return [2];
}
- _b.label = 3
+ _b.label = 3;
case 3:
- return [3, 1]
+ return [3, 1];
case 4:
- return [3, 11]
+ return [3, 11];
case 5:
- e_2_1 = _b.sent()
- e_2 = { error: e_2_1 }
- return [3, 11]
+ e_2_1 = _b.sent();
+ e_2 = { error: e_2_1 };
+ return [3, 11];
case 6:
- _b.trys.push([6, , 9, 10])
- if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a2 = asyncIterable_1.return))) return [3, 8]
- return [4, _a2.call(asyncIterable_1)]
+ _b.trys.push([6, , 9, 10]);
+ if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a2 = asyncIterable_1.return))) return [3, 8];
+ return [4, _a2.call(asyncIterable_1)];
case 7:
- _b.sent()
- _b.label = 8
+ _b.sent();
+ _b.label = 8;
case 8:
- return [3, 10]
+ return [3, 10];
case 9:
- if (e_2) throw e_2.error
- return [7]
+ if (e_2) throw e_2.error;
+ return [7];
case 10:
- return [7]
+ return [7];
case 11:
- subscriber.complete()
- return [2]
+ subscriber.complete();
+ return [2];
}
- })
- })
+ });
+ });
}
var init_innerFrom = __esm({
- "node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js" () {
- init_tslib_es6()
- init_isArrayLike()
- init_isPromise()
- init_Observable()
- init_isInteropObservable()
- init_isAsyncIterable()
- init_throwUnobservableError()
- init_isIterable()
- init_isReadableStreamLike()
- init_isFunction()
- init_reportUnhandledError()
- init_observable()
- }
-})
+ "node_modules/rxjs/dist/esm5/internal/observable/innerFrom.js"() {
+ init_tslib_es6();
+ init_isArrayLike();
+ init_isPromise();
+ init_Observable();
+ init_isInteropObservable();
+ init_isAsyncIterable();
+ init_throwUnobservableError();
+ init_isIterable();
+ init_isReadableStreamLike();
+ init_isFunction();
+ init_reportUnhandledError();
+ init_observable();
+ }
+});
// node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js
-function executeSchedule (parentSubscription, scheduler, work, delay, repeat) {
+function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
if (delay === void 0) {
- delay = 0
+ delay = 0;
}
if (repeat === void 0) {
- repeat = false
+ repeat = false;
}
- var scheduleSubscription = scheduler.schedule(function () {
- work()
+ var scheduleSubscription = scheduler.schedule(function() {
+ work();
if (repeat) {
- parentSubscription.add(this.schedule(null, delay))
+ parentSubscription.add(this.schedule(null, delay));
} else {
- this.unsubscribe()
+ this.unsubscribe();
}
- }, delay)
- parentSubscription.add(scheduleSubscription)
+ }, delay);
+ parentSubscription.add(scheduleSubscription);
if (!repeat) {
- return scheduleSubscription
+ return scheduleSubscription;
}
}
var init_executeSchedule = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js" () {
+ "node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js"() {
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/observeOn.js
-function observeOn (scheduler, delay) {
+function observeOn(scheduler, delay) {
if (delay === void 0) {
- delay = 0
- }
- return operate(function (source, subscriber) {
- source.subscribe(createOperatorSubscriber(subscriber, function (value) {
- return executeSchedule(subscriber, scheduler, function () {
- return subscriber.next(value)
- }, delay)
- }, function () {
- return executeSchedule(subscriber, scheduler, function () {
- return subscriber.complete()
- }, delay)
- }, function (err) {
- return executeSchedule(subscriber, scheduler, function () {
- return subscriber.error(err)
- }, delay)
- }))
- })
+ delay = 0;
+ }
+ return operate(function(source, subscriber) {
+ source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+ return executeSchedule(subscriber, scheduler, function() {
+ return subscriber.next(value);
+ }, delay);
+ }, function() {
+ return executeSchedule(subscriber, scheduler, function() {
+ return subscriber.complete();
+ }, delay);
+ }, function(err) {
+ return executeSchedule(subscriber, scheduler, function() {
+ return subscriber.error(err);
+ }, delay);
+ }));
+ });
}
var init_observeOn = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/observeOn.js" () {
- init_executeSchedule()
- init_lift()
- init_OperatorSubscriber()
+ "node_modules/rxjs/dist/esm5/internal/operators/observeOn.js"() {
+ init_executeSchedule();
+ init_lift();
+ init_OperatorSubscriber();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/subscribeOn.js
-function subscribeOn (scheduler, delay) {
+function subscribeOn(scheduler, delay) {
if (delay === void 0) {
- delay = 0
+ delay = 0;
}
- return operate(function (source, subscriber) {
- subscriber.add(scheduler.schedule(function () {
- return source.subscribe(subscriber)
- }, delay))
- })
+ return operate(function(source, subscriber) {
+ subscriber.add(scheduler.schedule(function() {
+ return source.subscribe(subscriber);
+ }, delay));
+ });
}
var init_subscribeOn = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/subscribeOn.js" () {
- init_lift()
+ "node_modules/rxjs/dist/esm5/internal/operators/subscribeOn.js"() {
+ init_lift();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleObservable.js
-function scheduleObservable (input, scheduler) {
- return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler))
+function scheduleObservable(input, scheduler) {
+ return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
}
var init_scheduleObservable = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleObservable.js" () {
- init_innerFrom()
- init_observeOn()
- init_subscribeOn()
+ "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleObservable.js"() {
+ init_innerFrom();
+ init_observeOn();
+ init_subscribeOn();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduled/schedulePromise.js
-function schedulePromise (input, scheduler) {
- return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler))
+function schedulePromise(input, scheduler) {
+ return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
}
var init_schedulePromise = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduled/schedulePromise.js" () {
- init_innerFrom()
- init_observeOn()
- init_subscribeOn()
+ "node_modules/rxjs/dist/esm5/internal/scheduled/schedulePromise.js"() {
+ init_innerFrom();
+ init_observeOn();
+ init_subscribeOn();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleArray.js
-function scheduleArray (input, scheduler) {
- return new Observable(function (subscriber) {
- var i = 0
- return scheduler.schedule(function () {
+function scheduleArray(input, scheduler) {
+ return new Observable(function(subscriber) {
+ var i = 0;
+ return scheduler.schedule(function() {
if (i === input.length) {
- subscriber.complete()
+ subscriber.complete();
} else {
- subscriber.next(input[i++])
+ subscriber.next(input[i++]);
if (!subscriber.closed) {
- this.schedule()
+ this.schedule();
}
}
- })
- })
+ });
+ });
}
var init_scheduleArray = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleArray.js" () {
- init_Observable()
+ "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleArray.js"() {
+ init_Observable();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleIterable.js
-function scheduleIterable (input, scheduler) {
- return new Observable(function (subscriber) {
- var iterator2
- executeSchedule(subscriber, scheduler, function () {
- iterator2 = input[iterator]()
- executeSchedule(subscriber, scheduler, function () {
- var _a2
- var value
- var done
+function scheduleIterable(input, scheduler) {
+ return new Observable(function(subscriber) {
+ var iterator2;
+ executeSchedule(subscriber, scheduler, function() {
+ iterator2 = input[iterator]();
+ executeSchedule(subscriber, scheduler, function() {
+ var _a2;
+ var value;
+ var done;
try {
- _a2 = iterator2.next(), value = _a2.value, done = _a2.done
+ _a2 = iterator2.next(), value = _a2.value, done = _a2.done;
} catch (err) {
- subscriber.error(err)
- return
+ subscriber.error(err);
+ return;
}
if (done) {
- subscriber.complete()
+ subscriber.complete();
} else {
- subscriber.next(value)
- }
- }, 0, true)
- })
- return function () {
- return isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return()
- }
- })
+ subscriber.next(value);
+ }
+ }, 0, true);
+ });
+ return function() {
+ return isFunction(iterator2 === null || iterator2 === void 0 ? void 0 : iterator2.return) && iterator2.return();
+ };
+ });
}
var init_scheduleIterable = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleIterable.js" () {
- init_Observable()
- init_iterator()
- init_isFunction()
- init_executeSchedule()
+ "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleIterable.js"() {
+ init_Observable();
+ init_iterator();
+ init_isFunction();
+ init_executeSchedule();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleAsyncIterable.js
-function scheduleAsyncIterable (input, scheduler) {
+function scheduleAsyncIterable(input, scheduler) {
if (!input) {
- throw new Error("Iterable cannot be null")
+ throw new Error("Iterable cannot be null");
}
- return new Observable(function (subscriber) {
- executeSchedule(subscriber, scheduler, function () {
- var iterator2 = input[Symbol.asyncIterator]()
- executeSchedule(subscriber, scheduler, function () {
- iterator2.next().then(function (result) {
+ return new Observable(function(subscriber) {
+ executeSchedule(subscriber, scheduler, function() {
+ var iterator2 = input[Symbol.asyncIterator]();
+ executeSchedule(subscriber, scheduler, function() {
+ iterator2.next().then(function(result) {
if (result.done) {
- subscriber.complete()
+ subscriber.complete();
} else {
- subscriber.next(result.value)
+ subscriber.next(result.value);
}
- })
- }, 0, true)
- })
- })
+ });
+ }, 0, true);
+ });
+ });
}
var init_scheduleAsyncIterable = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleAsyncIterable.js" () {
- init_Observable()
- init_executeSchedule()
+ "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleAsyncIterable.js"() {
+ init_Observable();
+ init_executeSchedule();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduleReadableStreamLike.js
-function scheduleReadableStreamLike (input, scheduler) {
- return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler)
+function scheduleReadableStreamLike(input, scheduler) {
+ return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
}
var init_scheduleReadableStreamLike = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleReadableStreamLike.js" () {
- init_scheduleAsyncIterable()
- init_isReadableStreamLike()
+ "node_modules/rxjs/dist/esm5/internal/scheduled/scheduleReadableStreamLike.js"() {
+ init_scheduleAsyncIterable();
+ init_isReadableStreamLike();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/scheduled/scheduled.js
-function scheduled (input, scheduler) {
+function scheduled(input, scheduler) {
if (input != null) {
if (isInteropObservable(input)) {
- return scheduleObservable(input, scheduler)
+ return scheduleObservable(input, scheduler);
}
if (isArrayLike(input)) {
- return scheduleArray(input, scheduler)
+ return scheduleArray(input, scheduler);
}
if (isPromise(input)) {
- return schedulePromise(input, scheduler)
+ return schedulePromise(input, scheduler);
}
if (isAsyncIterable(input)) {
- return scheduleAsyncIterable(input, scheduler)
+ return scheduleAsyncIterable(input, scheduler);
}
if (isIterable(input)) {
- return scheduleIterable(input, scheduler)
+ return scheduleIterable(input, scheduler);
}
if (isReadableStreamLike(input)) {
- return scheduleReadableStreamLike(input, scheduler)
+ return scheduleReadableStreamLike(input, scheduler);
}
}
- throw createInvalidObservableTypeError(input)
+ throw createInvalidObservableTypeError(input);
}
var init_scheduled = __esm({
- "node_modules/rxjs/dist/esm5/internal/scheduled/scheduled.js" () {
- init_scheduleObservable()
- init_schedulePromise()
- init_scheduleArray()
- init_scheduleIterable()
- init_scheduleAsyncIterable()
- init_isInteropObservable()
- init_isPromise()
- init_isArrayLike()
- init_isIterable()
- init_isAsyncIterable()
- init_throwUnobservableError()
- init_isReadableStreamLike()
- init_scheduleReadableStreamLike()
- }
-})
+ "node_modules/rxjs/dist/esm5/internal/scheduled/scheduled.js"() {
+ init_scheduleObservable();
+ init_schedulePromise();
+ init_scheduleArray();
+ init_scheduleIterable();
+ init_scheduleAsyncIterable();
+ init_isInteropObservable();
+ init_isPromise();
+ init_isArrayLike();
+ init_isIterable();
+ init_isAsyncIterable();
+ init_throwUnobservableError();
+ init_isReadableStreamLike();
+ init_scheduleReadableStreamLike();
+ }
+});
// node_modules/rxjs/dist/esm5/internal/observable/from.js
-function from (input, scheduler) {
- return scheduler ? scheduled(input, scheduler) : innerFrom(input)
+function from(input, scheduler) {
+ return scheduler ? scheduled(input, scheduler) : innerFrom(input);
}
var init_from = __esm({
- "node_modules/rxjs/dist/esm5/internal/observable/from.js" () {
- init_scheduled()
- init_innerFrom()
+ "node_modules/rxjs/dist/esm5/internal/observable/from.js"() {
+ init_scheduled();
+ init_innerFrom();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/util/EmptyError.js
-var EmptyError
+var EmptyError;
var init_EmptyError = __esm({
- "node_modules/rxjs/dist/esm5/internal/util/EmptyError.js" () {
- init_createErrorClass()
- EmptyError = createErrorClass(function (_super) {
- return function EmptyErrorImpl () {
- _super(this)
- this.name = "EmptyError"
- this.message = "no elements in sequence"
- }
- })
+ "node_modules/rxjs/dist/esm5/internal/util/EmptyError.js"() {
+ init_createErrorClass();
+ EmptyError = createErrorClass(function(_super) {
+ return function EmptyErrorImpl() {
+ _super(this);
+ this.name = "EmptyError";
+ this.message = "no elements in sequence";
+ };
+ });
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/firstValueFrom.js
-function firstValueFrom (source, config2) {
- var hasConfig = typeof config2 === "object"
- return new Promise(function (resolve, reject) {
+function firstValueFrom(source, config2) {
+ var hasConfig = typeof config2 === "object";
+ return new Promise(function(resolve, reject) {
var subscriber = new SafeSubscriber({
- next: function (value) {
- resolve(value)
- subscriber.unsubscribe()
+ next: function(value) {
+ resolve(value);
+ subscriber.unsubscribe();
},
error: reject,
- complete: function () {
+ complete: function() {
if (hasConfig) {
- resolve(config2.defaultValue)
+ resolve(config2.defaultValue);
} else {
- reject(new EmptyError())
+ reject(new EmptyError());
}
}
- })
- source.subscribe(subscriber)
- })
+ });
+ source.subscribe(subscriber);
+ });
}
var init_firstValueFrom = __esm({
- "node_modules/rxjs/dist/esm5/internal/firstValueFrom.js" () {
- init_EmptyError()
- init_Subscriber()
+ "node_modules/rxjs/dist/esm5/internal/firstValueFrom.js"() {
+ init_EmptyError();
+ init_Subscriber();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/map.js
-function map (project, thisArg) {
- return operate(function (source, subscriber) {
- var index = 0
- source.subscribe(createOperatorSubscriber(subscriber, function (value) {
- subscriber.next(project.call(thisArg, value, index++))
- }))
- })
+function map(project, thisArg) {
+ return operate(function(source, subscriber) {
+ var index = 0;
+ source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+ subscriber.next(project.call(thisArg, value, index++));
+ }));
+ });
}
var init_map = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/map.js" () {
- init_lift()
- init_OperatorSubscriber()
+ "node_modules/rxjs/dist/esm5/internal/operators/map.js"() {
+ init_lift();
+ init_OperatorSubscriber();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/mergeInternals.js
-function mergeInternals (source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
- var buffer2 = []
- var active = 0
- var index = 0
- var isComplete = false
- var checkComplete = function () {
+function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+ var buffer2 = [];
+ var active = 0;
+ var index = 0;
+ var isComplete = false;
+ var checkComplete = function() {
if (isComplete && !buffer2.length && !active) {
- subscriber.complete()
- }
- }
- var outerNext = function (value) {
- return active < concurrent ? doInnerSub(value) : buffer2.push(value)
- }
- var doInnerSub = function (value) {
- expand && subscriber.next(value)
- active++
- var innerComplete = false
- innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function (innerValue) {
- onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue)
+ subscriber.complete();
+ }
+ };
+ var outerNext = function(value) {
+ return active < concurrent ? doInnerSub(value) : buffer2.push(value);
+ };
+ var doInnerSub = function(value) {
+ expand && subscriber.next(value);
+ active++;
+ var innerComplete = false;
+ innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function(innerValue) {
+ onBeforeNext === null || onBeforeNext === void 0 ? void 0 : onBeforeNext(innerValue);
if (expand) {
- outerNext(innerValue)
+ outerNext(innerValue);
} else {
- subscriber.next(innerValue)
+ subscriber.next(innerValue);
}
- }, function () {
- innerComplete = true
- }, void 0, function () {
+ }, function() {
+ innerComplete = true;
+ }, void 0, function() {
if (innerComplete) {
try {
- active--
- var _loop_1 = function () {
- var bufferedValue = buffer2.shift()
+ active--;
+ var _loop_1 = function() {
+ var bufferedValue = buffer2.shift();
if (innerSubScheduler) {
- executeSchedule(subscriber, innerSubScheduler, function () {
- return doInnerSub(bufferedValue)
- })
+ executeSchedule(subscriber, innerSubScheduler, function() {
+ return doInnerSub(bufferedValue);
+ });
} else {
- doInnerSub(bufferedValue)
+ doInnerSub(bufferedValue);
}
- }
+ };
while (buffer2.length && active < concurrent) {
- _loop_1()
+ _loop_1();
}
- checkComplete()
+ checkComplete();
} catch (err) {
- subscriber.error(err)
- }
- }
- }))
- }
- source.subscribe(createOperatorSubscriber(subscriber, outerNext, function () {
- isComplete = true
- checkComplete()
- }))
- return function () {
- additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer()
- }
+ subscriber.error(err);
+ }
+ }
+ }));
+ };
+ source.subscribe(createOperatorSubscriber(subscriber, outerNext, function() {
+ isComplete = true;
+ checkComplete();
+ }));
+ return function() {
+ additionalFinalizer === null || additionalFinalizer === void 0 ? void 0 : additionalFinalizer();
+ };
}
var init_mergeInternals = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/mergeInternals.js" () {
- init_innerFrom()
- init_executeSchedule()
- init_OperatorSubscriber()
+ "node_modules/rxjs/dist/esm5/internal/operators/mergeInternals.js"() {
+ init_innerFrom();
+ init_executeSchedule();
+ init_OperatorSubscriber();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/mergeMap.js
-function mergeMap (project, resultSelector, concurrent) {
+function mergeMap(project, resultSelector, concurrent) {
if (concurrent === void 0) {
- concurrent = Infinity
+ concurrent = Infinity;
}
if (isFunction(resultSelector)) {
- return mergeMap(function (a, i) {
- return map(function (b, ii) {
- return resultSelector(a, b, i, ii)
- })(innerFrom(project(a, i)))
- }, concurrent)
+ return mergeMap(function(a, i) {
+ return map(function(b, ii) {
+ return resultSelector(a, b, i, ii);
+ })(innerFrom(project(a, i)));
+ }, concurrent);
} else if (typeof resultSelector === "number") {
- concurrent = resultSelector
+ concurrent = resultSelector;
}
- return operate(function (source, subscriber) {
- return mergeInternals(source, subscriber, project, concurrent)
- })
+ return operate(function(source, subscriber) {
+ return mergeInternals(source, subscriber, project, concurrent);
+ });
}
var init_mergeMap = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/mergeMap.js" () {
- init_map()
- init_innerFrom()
- init_lift()
- init_mergeInternals()
- init_isFunction()
+ "node_modules/rxjs/dist/esm5/internal/operators/mergeMap.js"() {
+ init_map();
+ init_innerFrom();
+ init_lift();
+ init_mergeInternals();
+ init_isFunction();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/mergeAll.js
-function mergeAll (concurrent) {
+function mergeAll(concurrent) {
if (concurrent === void 0) {
- concurrent = Infinity
+ concurrent = Infinity;
}
- return mergeMap(identity, concurrent)
+ return mergeMap(identity, concurrent);
}
var init_mergeAll = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/mergeAll.js" () {
- init_mergeMap()
- init_identity()
+ "node_modules/rxjs/dist/esm5/internal/operators/mergeAll.js"() {
+ init_mergeMap();
+ init_identity();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/observable/defer.js
-function defer (observableFactory) {
- return new Observable(function (subscriber) {
- innerFrom(observableFactory()).subscribe(subscriber)
- })
+function defer(observableFactory) {
+ return new Observable(function(subscriber) {
+ innerFrom(observableFactory()).subscribe(subscriber);
+ });
}
var init_defer = __esm({
- "node_modules/rxjs/dist/esm5/internal/observable/defer.js" () {
- init_Observable()
- init_innerFrom()
+ "node_modules/rxjs/dist/esm5/internal/observable/defer.js"() {
+ init_Observable();
+ init_innerFrom();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/observable/merge.js
-function merge () {
- var args = []
+function merge() {
+ var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
- args[_i] = arguments[_i]
+ args[_i] = arguments[_i];
}
- var scheduler = popScheduler(args)
- var concurrent = popNumber(args, Infinity)
- var sources = args
- return !sources.length ? EMPTY : sources.length === 1 ? innerFrom(sources[0]) : mergeAll(concurrent)(from(sources, scheduler))
+ var scheduler = popScheduler(args);
+ var concurrent = popNumber(args, Infinity);
+ var sources = args;
+ return !sources.length ? EMPTY : sources.length === 1 ? innerFrom(sources[0]) : mergeAll(concurrent)(from(sources, scheduler));
}
var init_merge = __esm({
- "node_modules/rxjs/dist/esm5/internal/observable/merge.js" () {
- init_mergeAll()
- init_innerFrom()
- init_empty()
- init_args()
- init_from()
+ "node_modules/rxjs/dist/esm5/internal/observable/merge.js"() {
+ init_mergeAll();
+ init_innerFrom();
+ init_empty();
+ init_args();
+ init_from();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/filter.js
-function filter (predicate, thisArg) {
- return operate(function (source, subscriber) {
- var index = 0
- source.subscribe(createOperatorSubscriber(subscriber, function (value) {
- return predicate.call(thisArg, value, index++) && subscriber.next(value)
- }))
- })
+function filter(predicate, thisArg) {
+ return operate(function(source, subscriber) {
+ var index = 0;
+ source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+ return predicate.call(thisArg, value, index++) && subscriber.next(value);
+ }));
+ });
}
var init_filter = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/filter.js" () {
- init_lift()
- init_OperatorSubscriber()
+ "node_modules/rxjs/dist/esm5/internal/operators/filter.js"() {
+ init_lift();
+ init_OperatorSubscriber();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/types.js
var init_types = __esm({
- "node_modules/rxjs/dist/esm5/internal/types.js" () {
+ "node_modules/rxjs/dist/esm5/internal/types.js"() {
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/defaultIfEmpty.js
-function defaultIfEmpty (defaultValue) {
- return operate(function (source, subscriber) {
- var hasValue = false
- source.subscribe(createOperatorSubscriber(subscriber, function (value) {
- hasValue = true
- subscriber.next(value)
- }, function () {
+function defaultIfEmpty(defaultValue) {
+ return operate(function(source, subscriber) {
+ var hasValue = false;
+ source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+ hasValue = true;
+ subscriber.next(value);
+ }, function() {
if (!hasValue) {
- subscriber.next(defaultValue)
+ subscriber.next(defaultValue);
}
- subscriber.complete()
- }))
- })
+ subscriber.complete();
+ }));
+ });
}
var init_defaultIfEmpty = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/defaultIfEmpty.js" () {
- init_lift()
- init_OperatorSubscriber()
+ "node_modules/rxjs/dist/esm5/internal/operators/defaultIfEmpty.js"() {
+ init_lift();
+ init_OperatorSubscriber();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/take.js
-function take (count) {
- return count <= 0 ? function () {
- return EMPTY
- } : operate(function (source, subscriber) {
- var seen = 0
- source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+function take(count) {
+ return count <= 0 ? function() {
+ return EMPTY;
+ } : operate(function(source, subscriber) {
+ var seen = 0;
+ source.subscribe(createOperatorSubscriber(subscriber, function(value) {
if (++seen <= count) {
- subscriber.next(value)
+ subscriber.next(value);
if (count <= seen) {
- subscriber.complete()
+ subscriber.complete();
}
}
- }))
- })
+ }));
+ });
}
var init_take = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/take.js" () {
- init_empty()
- init_lift()
- init_OperatorSubscriber()
+ "node_modules/rxjs/dist/esm5/internal/operators/take.js"() {
+ init_empty();
+ init_lift();
+ init_OperatorSubscriber();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/ignoreElements.js
-function ignoreElements () {
- return operate(function (source, subscriber) {
- source.subscribe(createOperatorSubscriber(subscriber, noop))
- })
+function ignoreElements() {
+ return operate(function(source, subscriber) {
+ source.subscribe(createOperatorSubscriber(subscriber, noop));
+ });
}
var init_ignoreElements = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/ignoreElements.js" () {
- init_lift()
- init_OperatorSubscriber()
- init_noop()
+ "node_modules/rxjs/dist/esm5/internal/operators/ignoreElements.js"() {
+ init_lift();
+ init_OperatorSubscriber();
+ init_noop();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/throwIfEmpty.js
-function throwIfEmpty (errorFactory) {
+function throwIfEmpty(errorFactory) {
if (errorFactory === void 0) {
- errorFactory = defaultErrorFactory
- }
- return operate(function (source, subscriber) {
- var hasValue = false
- source.subscribe(createOperatorSubscriber(subscriber, function (value) {
- hasValue = true
- subscriber.next(value)
- }, function () {
- return hasValue ? subscriber.complete() : subscriber.error(errorFactory())
- }))
- })
+ errorFactory = defaultErrorFactory;
+ }
+ return operate(function(source, subscriber) {
+ var hasValue = false;
+ source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+ hasValue = true;
+ subscriber.next(value);
+ }, function() {
+ return hasValue ? subscriber.complete() : subscriber.error(errorFactory());
+ }));
+ });
}
-function defaultErrorFactory () {
- return new EmptyError()
+function defaultErrorFactory() {
+ return new EmptyError();
}
var init_throwIfEmpty = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/throwIfEmpty.js" () {
- init_EmptyError()
- init_lift()
- init_OperatorSubscriber()
+ "node_modules/rxjs/dist/esm5/internal/operators/throwIfEmpty.js"() {
+ init_EmptyError();
+ init_lift();
+ init_OperatorSubscriber();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/first.js
-function first (predicate, defaultValue) {
- var hasDefaultValue = arguments.length >= 2
- return function (source) {
- return source.pipe(predicate ? filter(function (v, i) {
- return predicate(v, i, source)
- }) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function () {
- return new EmptyError()
- }))
- }
+function first(predicate, defaultValue) {
+ var hasDefaultValue = arguments.length >= 2;
+ return function(source) {
+ return source.pipe(predicate ? filter(function(v, i) {
+ return predicate(v, i, source);
+ }) : identity, take(1), hasDefaultValue ? defaultIfEmpty(defaultValue) : throwIfEmpty(function() {
+ return new EmptyError();
+ }));
+ };
}
var init_first = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/first.js" () {
- init_EmptyError()
- init_filter()
- init_take()
- init_defaultIfEmpty()
- init_throwIfEmpty()
- init_identity()
+ "node_modules/rxjs/dist/esm5/internal/operators/first.js"() {
+ init_EmptyError();
+ init_filter();
+ init_take();
+ init_defaultIfEmpty();
+ init_throwIfEmpty();
+ init_identity();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/share.js
-function share (options) {
+function share(options) {
if (options === void 0) {
- options = {}
- }
- var _a2 = options.connector, connector = _a2 === void 0 ? function () {
- return new Subject()
- } : _a2, _b = options.resetOnError, resetOnError = _b === void 0 ? true : _b, _c = options.resetOnComplete, resetOnComplete = _c === void 0 ? true : _c, _d = options.resetOnRefCountZero, resetOnRefCountZero = _d === void 0 ? true : _d
- return function (wrapperSource) {
- var connection
- var resetConnection
- var subject
- var refCount = 0
- var hasCompleted = false
- var hasErrored = false
- var cancelReset = function () {
- resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe()
- resetConnection = void 0
- }
- var reset = function () {
- cancelReset()
- connection = subject = void 0
- hasCompleted = hasErrored = false
- }
- var resetAndUnsubscribe = function () {
- var conn = connection
- reset()
- conn === null || conn === void 0 ? void 0 : conn.unsubscribe()
- }
- return operate(function (source, subscriber) {
- refCount++
+ options = {};
+ }
+ var _a2 = options.connector, connector = _a2 === void 0 ? function() {
+ return new Subject();
+ } : _a2, _b = options.resetOnError, resetOnError = _b === void 0 ? true : _b, _c = options.resetOnComplete, resetOnComplete = _c === void 0 ? true : _c, _d = options.resetOnRefCountZero, resetOnRefCountZero = _d === void 0 ? true : _d;
+ return function(wrapperSource) {
+ var connection;
+ var resetConnection;
+ var subject;
+ var refCount = 0;
+ var hasCompleted = false;
+ var hasErrored = false;
+ var cancelReset = function() {
+ resetConnection === null || resetConnection === void 0 ? void 0 : resetConnection.unsubscribe();
+ resetConnection = void 0;
+ };
+ var reset = function() {
+ cancelReset();
+ connection = subject = void 0;
+ hasCompleted = hasErrored = false;
+ };
+ var resetAndUnsubscribe = function() {
+ var conn = connection;
+ reset();
+ conn === null || conn === void 0 ? void 0 : conn.unsubscribe();
+ };
+ return operate(function(source, subscriber) {
+ refCount++;
if (!hasErrored && !hasCompleted) {
- cancelReset()
+ cancelReset();
}
- var dest = subject = subject !== null && subject !== void 0 ? subject : connector()
- subscriber.add(function () {
- refCount--
+ var dest = subject = subject !== null && subject !== void 0 ? subject : connector();
+ subscriber.add(function() {
+ refCount--;
if (refCount === 0 && !hasErrored && !hasCompleted) {
- resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero)
+ resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
}
- })
- dest.subscribe(subscriber)
+ });
+ dest.subscribe(subscriber);
if (!connection && refCount > 0) {
connection = new SafeSubscriber({
- next: function (value) {
- return dest.next(value)
+ next: function(value) {
+ return dest.next(value);
},
- error: function (err) {
- hasErrored = true
- cancelReset()
- resetConnection = handleReset(reset, resetOnError, err)
- dest.error(err)
+ error: function(err) {
+ hasErrored = true;
+ cancelReset();
+ resetConnection = handleReset(reset, resetOnError, err);
+ dest.error(err);
},
- complete: function () {
- hasCompleted = true
- cancelReset()
- resetConnection = handleReset(reset, resetOnComplete)
- dest.complete()
+ complete: function() {
+ hasCompleted = true;
+ cancelReset();
+ resetConnection = handleReset(reset, resetOnComplete);
+ dest.complete();
}
- })
- innerFrom(source).subscribe(connection)
+ });
+ innerFrom(source).subscribe(connection);
}
- })(wrapperSource)
- }
+ })(wrapperSource);
+ };
}
-function handleReset (reset, on) {
- var args = []
+function handleReset(reset, on) {
+ var args = [];
for (var _i = 2; _i < arguments.length; _i++) {
- args[_i - 2] = arguments[_i]
+ args[_i - 2] = arguments[_i];
}
if (on === true) {
- reset()
- return
+ reset();
+ return;
}
if (on === false) {
- return
+ return;
}
var onSubscriber = new SafeSubscriber({
- next: function () {
- onSubscriber.unsubscribe()
- reset()
+ next: function() {
+ onSubscriber.unsubscribe();
+ reset();
}
- })
- return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber)
+ });
+ return innerFrom(on.apply(void 0, __spreadArray([], __read(args)))).subscribe(onSubscriber);
}
var init_share = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/share.js" () {
- init_tslib_es6()
- init_innerFrom()
- init_Subject()
- init_Subscriber()
- init_lift()
+ "node_modules/rxjs/dist/esm5/internal/operators/share.js"() {
+ init_tslib_es6();
+ init_innerFrom();
+ init_Subject();
+ init_Subscriber();
+ init_lift();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js
-function takeUntil (notifier) {
- return operate(function (source, subscriber) {
- innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function () {
- return subscriber.complete()
- }, noop))
- !subscriber.closed && source.subscribe(subscriber)
- })
+function takeUntil(notifier) {
+ return operate(function(source, subscriber) {
+ innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function() {
+ return subscriber.complete();
+ }, noop));
+ !subscriber.closed && source.subscribe(subscriber);
+ });
}
var init_takeUntil = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js" () {
- init_lift()
- init_OperatorSubscriber()
- init_innerFrom()
- init_noop()
+ "node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js"() {
+ init_lift();
+ init_OperatorSubscriber();
+ init_innerFrom();
+ init_noop();
}
-})
+});
// node_modules/rxjs/dist/esm5/internal/operators/tap.js
-function tap (observerOrNext, error, complete) {
- var tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext
- return tapObserver ? operate(function (source, subscriber) {
+function tap(observerOrNext, error, complete) {
+ var tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
+ return tapObserver ? operate(function(source, subscriber) {
var _a2;
- (_a2 = tapObserver.subscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver)
- var isUnsub = true
- source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+ (_a2 = tapObserver.subscribe) === null || _a2 === void 0 ? void 0 : _a2.call(tapObserver);
+ var isUnsub = true;
+ source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+ var _a3;
+ (_a3 = tapObserver.next) === null || _a3 === void 0 ? void 0 : _a3.call(tapObserver, value);
+ subscriber.next(value);
+ }, function() {
var _a3;
- (_a3 = tapObserver.next) === null || _a3 === void 0 ? void 0 : _a3.call(tapObserver, value)
- subscriber.next(value)
- }, function () {
- var _a3
isUnsub = false;
- (_a3 = tapObserver.complete) === null || _a3 === void 0 ? void 0 : _a3.call(tapObserver)
- subscriber.complete()
- }, function (err) {
- var _a3
+ (_a3 = tapObserver.complete) === null || _a3 === void 0 ? void 0 : _a3.call(tapObserver);
+ subscriber.complete();
+ }, function(err) {
+ var _a3;
isUnsub = false;
- (_a3 = tapObserver.error) === null || _a3 === void 0 ? void 0 : _a3.call(tapObserver, err)
- subscriber.error(err)
- }, function () {
- var _a3, _b
+ (_a3 = tapObserver.error) === null || _a3 === void 0 ? void 0 : _a3.call(tapObserver, err);
+ subscriber.error(err);
+ }, function() {
+ var _a3, _b;
if (isUnsub) {
- (_a3 = tapObserver.unsubscribe) === null || _a3 === void 0 ? void 0 : _a3.call(tapObserver)
+ (_a3 = tapObserver.unsubscribe) === null || _a3 === void 0 ? void 0 : _a3.call(tapObserver);
}
- (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver)
- }))
- }) : identity
+ (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+ }));
+ }) : identity;
}
var init_tap = __esm({
- "node_modules/rxjs/dist/esm5/internal/operators/tap.js" () {
- init_isFunction()
- init_lift()
- init_OperatorSubscriber()
- init_identity()
+ "node_modules/rxjs/dist/esm5/internal/operators/tap.js"() {
+ init_isFunction();
+ init_lift();
+ init_OperatorSubscriber();
+ init_identity();
}
-})
+});
// node_modules/rxjs/dist/esm5/index.js
var init_esm5 = __esm({
- "node_modules/rxjs/dist/esm5/index.js" () {
- init_Observable()
- init_ReplaySubject()
- init_firstValueFrom()
- init_defer()
- init_from()
- init_merge()
- init_types()
- init_takeUntil()
- }
-})
+ "node_modules/rxjs/dist/esm5/index.js"() {
+ init_Observable();
+ init_ReplaySubject();
+ init_firstValueFrom();
+ init_defer();
+ init_from();
+ init_merge();
+ init_types();
+ init_takeUntil();
+ }
+});
// node_modules/@ledgerhq/devices/lib-es/ble/sendAPDU.js
-function createChunkedBuffers (buffer2, sizeForIndex) {
- const chunks = []
+function createChunkedBuffers(buffer2, sizeForIndex) {
+ const chunks = [];
for (let i = 0, size = sizeForIndex(0); i < buffer2.length; i += size, size = sizeForIndex(i)) {
- chunks.push(buffer2.slice(i, i + size))
+ chunks.push(buffer2.slice(i, i + size));
}
- return chunks
+ return chunks;
}
-var __awaiter3, TagId, sendAPDU
+var __awaiter3, TagId, sendAPDU;
var init_sendAPDU = __esm({
- "node_modules/@ledgerhq/devices/lib-es/ble/sendAPDU.js" () {
- init_esm5()
- init_lib_es2()
- __awaiter3 = function (thisArg, _arguments, P, generator) {
- function adopt (value) {
- return value instanceof P ? value : new P(function (resolve) {
- resolve(value)
- })
- }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled (value) {
+ "node_modules/@ledgerhq/devices/lib-es/ble/sendAPDU.js"() {
+ init_esm5();
+ init_lib_es2();
+ __awaiter3 = function(thisArg, _arguments, P, generator) {
+ function adopt(value) {
+ return value instanceof P ? value : new P(function(resolve) {
+ resolve(value);
+ });
+ }
+ return new (P || (P = Promise))(function(resolve, reject) {
+ function fulfilled(value) {
try {
- step(generator.next(value))
+ step(generator.next(value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function rejected (value) {
+ function rejected(value) {
try {
- step(generator["throw"](value))
+ step(generator["throw"](value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function step (result) {
- result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+ function step(result) {
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
- step((generator = generator.apply(thisArg, _arguments || [])).next())
- })
- }
- TagId = 5
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+ };
+ TagId = 5;
sendAPDU = (write, apdu, mtuSize, { context: context2 } = {}) => {
const chunks = createChunkedBuffers(apdu, (i) => mtuSize - (i === 0 ? 5 : 3)).map((buffer2, i) => {
- const head = Buffer.alloc(i === 0 ? 5 : 3)
- head.writeUInt8(TagId, 0)
- head.writeUInt16BE(i, 1)
+ const head = Buffer.alloc(i === 0 ? 5 : 3);
+ head.writeUInt8(TagId, 0);
+ head.writeUInt16BE(i, 1);
if (i === 0) {
- head.writeUInt16BE(apdu.length, 3)
+ head.writeUInt16BE(apdu.length, 3);
}
- return Buffer.concat([head, buffer2])
- })
+ return Buffer.concat([head, buffer2]);
+ });
return new Observable((o) => {
- let terminated = false
- function main () {
+ let terminated = false;
+ function main() {
return __awaiter3(this, void 0, void 0, function* () {
for (const chunk of chunks) {
if (terminated)
- return
- yield write(chunk)
+ return;
+ yield write(chunk);
}
- })
+ });
}
main().then(() => {
- terminated = true
- o.complete()
+ terminated = true;
+ o.complete();
}, (error) => {
- terminated = true
+ terminated = true;
trace({
type: "ble-error",
message: `sendAPDU failure: ${error}`,
data: { error },
context: context2
- })
- o.error(error)
- })
+ });
+ o.error(error);
+ });
const unsubscribe = () => {
if (!terminated) {
trace({
type: "ble-error",
message: "sendAPDU interruption",
context: context2
- })
- terminated = true
+ });
+ terminated = true;
}
- }
- return unsubscribe
- })
- }
+ };
+ return unsubscribe;
+ });
+ };
}
-})
+});
// node_modules/@ledgerhq/devices/lib-es/ble/receiveAPDU.js
-var TagId2, receiveAPDU
+var TagId2, receiveAPDU;
var init_receiveAPDU = __esm({
- "node_modules/@ledgerhq/devices/lib-es/ble/receiveAPDU.js" () {
- init_lib_es()
- init_esm5()
- init_lib_es2()
- TagId2 = 5
+ "node_modules/@ledgerhq/devices/lib-es/ble/receiveAPDU.js"() {
+ init_lib_es();
+ init_esm5();
+ init_lib_es2();
+ TagId2 = 5;
receiveAPDU = (rawStream, { context: context2 } = {}) => new Observable((o) => {
- let notifiedIndex = 0
- let notifiedDataLength = 0
- let notifiedData = Buffer.alloc(0)
- const subscriptionCleaner = new ReplaySubject()
+ let notifiedIndex = 0;
+ let notifiedDataLength = 0;
+ let notifiedData = Buffer.alloc(0);
+ const subscriptionCleaner = new ReplaySubject();
rawStream.pipe(takeUntil(subscriptionCleaner)).subscribe({
complete: () => {
- o.error(new DisconnectedDevice())
+ o.error(new DisconnectedDevice());
},
error: (error) => {
trace({
message: `Error in receiveAPDU: ${error}`,
data: { error },
context: context2
- })
- o.error(error)
+ });
+ o.error(error);
},
next: (value) => {
if (value instanceof Error) {
message: `Error emitted to receiveAPDU next: ${value}`,
data: { error: value },
context: context2
- })
- return
+ });
+ return;
}
- const tag = value.readUInt8(0)
- const chunkIndex = value.readUInt16BE(1)
- let chunkData = value.slice(3)
+ const tag = value.readUInt8(0);
+ const chunkIndex = value.readUInt16BE(1);
+ let chunkData = value.slice(3);
if (tag !== TagId2) {
- o.error(new TransportError("Invalid tag " + tag.toString(16), "InvalidTag"))
- return
+ o.error(new TransportError("Invalid tag " + tag.toString(16), "InvalidTag"));
+ return;
}
if (notifiedIndex !== chunkIndex) {
- o.error(new TransportError(`BLE: Invalid sequence number. discontinued chunk. Received ${chunkIndex} but expected ${notifiedIndex}`, "InvalidSequence"))
- return
+ o.error(new TransportError(`BLE: Invalid sequence number. discontinued chunk. Received ${chunkIndex} but expected ${notifiedIndex}`, "InvalidSequence"));
+ return;
}
if (chunkIndex === 0) {
- notifiedDataLength = chunkData.readUInt16BE(0)
- chunkData = chunkData.slice(2)
+ notifiedDataLength = chunkData.readUInt16BE(0);
+ chunkData = chunkData.slice(2);
}
- notifiedIndex++
- notifiedData = Buffer.concat([notifiedData, chunkData])
+ notifiedIndex++;
+ notifiedData = Buffer.concat([notifiedData, chunkData]);
if (notifiedData.length > notifiedDataLength) {
- o.error(new TransportError(`BLE: received too much data. discontinued chunk. Received ${notifiedData.length} but expected ${notifiedDataLength}`, "BLETooMuchData"))
- return
+ o.error(new TransportError(`BLE: received too much data. discontinued chunk. Received ${notifiedData.length} but expected ${notifiedDataLength}`, "BLETooMuchData"));
+ return;
}
if (notifiedData.length === notifiedDataLength) {
- o.next(notifiedData)
- o.complete()
- subscriptionCleaner.next()
+ o.next(notifiedData);
+ o.complete();
+ subscriptionCleaner.next();
}
}
- })
+ });
return () => {
- subscriptionCleaner.next()
- }
- })
+ subscriptionCleaner.next();
+ };
+ });
}
-})
+});
// node_modules/rxjs/dist/esm5/operators/index.js
var init_operators = __esm({
- "node_modules/rxjs/dist/esm5/operators/index.js" () {
- init_first()
- init_ignoreElements()
- init_map()
- init_share()
- init_tap()
+ "node_modules/rxjs/dist/esm5/operators/index.js"() {
+ init_first();
+ init_ignoreElements();
+ init_map();
+ init_share();
+ init_tap();
}
-})
+});
// node_modules/@ledgerhq/hw-transport-web-ble/lib-es/monitorCharacteristic.js
-var monitorCharacteristic
+var monitorCharacteristic;
var init_monitorCharacteristic = __esm({
- "node_modules/@ledgerhq/hw-transport-web-ble/lib-es/monitorCharacteristic.js" () {
- init_esm5()
- init_lib_es2()
+ "node_modules/@ledgerhq/hw-transport-web-ble/lib-es/monitorCharacteristic.js"() {
+ init_esm5();
+ init_lib_es2();
monitorCharacteristic = (characteristic) => Observable.create((o) => {
- log("ble-verbose", "start monitor " + characteristic.uuid)
- function onCharacteristicValueChanged (event) {
- const characteristic2 = event.target
+ log("ble-verbose", "start monitor " + characteristic.uuid);
+ function onCharacteristicValueChanged(event) {
+ const characteristic2 = event.target;
if (characteristic2.value) {
- o.next(Buffer.from(characteristic2.value.buffer))
+ o.next(Buffer.from(characteristic2.value.buffer));
}
}
characteristic.startNotifications().then(() => {
- characteristic.addEventListener("characteristicvaluechanged", onCharacteristicValueChanged)
- })
+ characteristic.addEventListener("characteristicvaluechanged", onCharacteristicValueChanged);
+ });
return () => {
- log("ble-verbose", "end monitor " + characteristic.uuid)
- characteristic.stopNotifications()
- }
- })
+ log("ble-verbose", "end monitor " + characteristic.uuid);
+ characteristic.stopNotifications();
+ };
+ });
}
-})
+});
// node_modules/@ledgerhq/hw-transport-web-ble/lib-es/TransportWebBLE.js
-function open (deviceOrId, needsReconnect) {
+function open(deviceOrId, needsReconnect) {
return __awaiter4(this, void 0, void 0, function* () {
- let device
+ let device;
if (typeof deviceOrId === "string") {
if (transportsCache[deviceOrId]) {
- log("ble-verbose", "Transport in cache, using that.")
- return transportsCache[deviceOrId]
+ log("ble-verbose", "Transport in cache, using that.");
+ return transportsCache[deviceOrId];
}
- const bluetooth = requiresBluetooth()
- device = yield bluetooth.requestDevice(requestDeviceParam())
+ const bluetooth = requiresBluetooth();
+ device = yield bluetooth.requestDevice(requestDeviceParam());
} else {
- device = deviceOrId
+ device = deviceOrId;
}
if (!device.gatt.connected) {
- log("ble-verbose", "not connected. connecting...")
- yield device.gatt.connect()
+ log("ble-verbose", "not connected. connecting...");
+ yield device.gatt.connect();
}
- const [service, infos] = yield retrieveService(device)
- const { deviceModel, writeUuid, notifyUuid } = infos
+ const [service, infos] = yield retrieveService(device);
+ const { deviceModel, writeUuid, notifyUuid } = infos;
const [writeC, notifyC] = yield Promise.all([
service.getCharacteristic(writeUuid),
service.getCharacteristic(notifyUuid)
- ])
+ ]);
const notifyObservable = monitorCharacteristic(notifyC).pipe(tap((value) => {
- log("ble-frame", "<= " + value.toString("hex"))
- }), share())
- const notif = notifyObservable.subscribe()
- const transport = new BluetoothTransport(device, writeC, notifyObservable, deviceModel)
+ log("ble-frame", "<= " + value.toString("hex"));
+ }), share());
+ const notif = notifyObservable.subscribe();
+ const transport = new BluetoothTransport(device, writeC, notifyObservable, deviceModel);
if (!device.gatt.connected) {
- throw new DisconnectedDevice()
+ throw new DisconnectedDevice();
}
- transportsCache[transport.id] = transport
+ transportsCache[transport.id] = transport;
const onDisconnect = (e) => {
- console.log("onDisconnect!", e)
- delete transportsCache[transport.id]
- transport.notYetDisconnected = false
- notif.unsubscribe()
- device.removeEventListener("gattserverdisconnected", onDisconnect)
- log("ble-verbose", `BleTransport(${transport.id}) disconnected`)
- transport.emit("disconnect", e)
- }
- device.addEventListener("gattserverdisconnected", onDisconnect)
- const beforeMTUTime = Date.now()
+ console.log("onDisconnect!", e);
+ delete transportsCache[transport.id];
+ transport.notYetDisconnected = false;
+ notif.unsubscribe();
+ device.removeEventListener("gattserverdisconnected", onDisconnect);
+ log("ble-verbose", `BleTransport(${transport.id}) disconnected`);
+ transport.emit("disconnect", e);
+ };
+ device.addEventListener("gattserverdisconnected", onDisconnect);
+ const beforeMTUTime = Date.now();
try {
- yield transport.inferMTU()
+ yield transport.inferMTU();
} finally {
- const afterMTUTime = Date.now()
+ const afterMTUTime = Date.now();
if (afterMTUTime - beforeMTUTime < 1e3) {
- needsReconnect = false
+ needsReconnect = false;
}
if (needsReconnect) {
- yield device.gatt.disconnect()
- yield new Promise((s) => setTimeout(s, 4e3))
+ yield device.gatt.disconnect();
+ yield new Promise((s) => setTimeout(s, 4e3));
}
}
if (needsReconnect) {
- return open(device, false)
+ return open(device, false);
}
- return transport
- })
+ return transport;
+ });
}
-var __awaiter4, _a, requiresBluetooth, availability, transportsCache, requestDeviceParam, retrieveService, BluetoothTransport, TransportWebBLE_default
+var __awaiter4, _a, requiresBluetooth, availability, transportsCache, requestDeviceParam, retrieveService, BluetoothTransport, TransportWebBLE_default;
var init_TransportWebBLE = __esm({
- "node_modules/@ledgerhq/hw-transport-web-ble/lib-es/TransportWebBLE.js" () {
- init_Transport()
- init_lib_es()
- init_lib_es3()
- init_sendAPDU()
- init_receiveAPDU()
- init_lib_es2()
- init_esm5()
- init_operators()
- init_monitorCharacteristic()
- __awaiter4 = function (thisArg, _arguments, P, generator) {
- function adopt (value) {
- return value instanceof P ? value : new P(function (resolve) {
- resolve(value)
- })
- }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled (value) {
+ "node_modules/@ledgerhq/hw-transport-web-ble/lib-es/TransportWebBLE.js"() {
+ init_Transport();
+ init_lib_es();
+ init_lib_es3();
+ init_sendAPDU();
+ init_receiveAPDU();
+ init_lib_es2();
+ init_esm5();
+ init_operators();
+ init_monitorCharacteristic();
+ __awaiter4 = function(thisArg, _arguments, P, generator) {
+ function adopt(value) {
+ return value instanceof P ? value : new P(function(resolve) {
+ resolve(value);
+ });
+ }
+ return new (P || (P = Promise))(function(resolve, reject) {
+ function fulfilled(value) {
try {
- step(generator.next(value))
+ step(generator.next(value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function rejected (value) {
+ function rejected(value) {
try {
- step(generator["throw"](value))
+ step(generator["throw"](value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function step (result) {
- result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+ function step(result) {
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
- step((generator = generator.apply(thisArg, _arguments || [])).next())
- })
- }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+ };
requiresBluetooth = () => {
- const { bluetooth } = navigator
+ const { bluetooth } = navigator;
if (typeof bluetooth === "undefined") {
- throw new Error("web bluetooth not supported")
+ throw new Error("web bluetooth not supported");
}
- return bluetooth
- }
+ return bluetooth;
+ };
availability = () => Observable.create((observer) => {
- const bluetooth = requiresBluetooth()
+ const bluetooth = requiresBluetooth();
const onAvailabilityChanged = (e) => {
- observer.next(e.value)
- }
- bluetooth.addEventListener("availabilitychanged", onAvailabilityChanged)
- let unsubscribed = false
+ observer.next(e.value);
+ };
+ bluetooth.addEventListener("availabilitychanged", onAvailabilityChanged);
+ let unsubscribed = false;
bluetooth.getAvailability().then((available) => {
if (!unsubscribed) {
- observer.next(available)
+ observer.next(available);
}
- })
+ });
return () => {
- unsubscribed = true
- bluetooth.removeEventListener("availabilitychanged", onAvailabilityChanged)
- }
- })
- transportsCache = {}
+ unsubscribed = true;
+ bluetooth.removeEventListener("availabilitychanged", onAvailabilityChanged);
+ };
+ });
+ transportsCache = {};
requestDeviceParam = () => ({
filters: getBluetoothServiceUuids().map((uuid) => ({
services: [uuid]
}))
- })
+ });
retrieveService = (device) => __awaiter4(void 0, void 0, void 0, function* () {
if (!device.gatt)
- throw new Error("bluetooth gatt not found")
- const [service] = yield device.gatt.getPrimaryServices()
+ throw new Error("bluetooth gatt not found");
+ const [service] = yield device.gatt.getPrimaryServices();
if (!service)
- throw new Error("bluetooth service not found")
- const infos = getInfosForServiceUuid(service.uuid)
+ throw new Error("bluetooth service not found");
+ const infos = getInfosForServiceUuid(service.uuid);
if (!infos)
- throw new Error("bluetooth service infos not found")
- return [service, infos]
- })
+ throw new Error("bluetooth service infos not found");
+ return [service, infos];
+ });
BluetoothTransport = class extends Transport_default {
/**
* Scan for Ledger Bluetooth devices.
* On this web implementation, it only emits ONE device, the one that was selected in the UI (if any).
*/
- static listen (observer) {
- log("ble-verbose", "listen...")
- let unsubscribed
- const bluetooth = requiresBluetooth()
+ static listen(observer) {
+ log("ble-verbose", "listen...");
+ let unsubscribed;
+ const bluetooth = requiresBluetooth();
bluetooth.requestDevice(requestDeviceParam()).then((device) => {
if (!unsubscribed) {
observer.next({
type: "add",
descriptor: device
- })
- observer.complete()
+ });
+ observer.complete();
}
}, (error) => {
- observer.error(new TransportOpenUserCancelled(error.message))
- })
- function unsubscribe () {
- unsubscribed = true
+ observer.error(new TransportOpenUserCancelled(error.message));
+ });
+ function unsubscribe() {
+ unsubscribed = true;
}
return {
unsubscribe
- }
+ };
}
/**
* open a bluetooth device.
*/
- static open (deviceOrId) {
+ static open(deviceOrId) {
return __awaiter4(this, void 0, void 0, function* () {
- return open(deviceOrId, true)
- })
+ return open(deviceOrId, true);
+ });
}
constructor(device, writeCharacteristic, notifyObservable, deviceModel) {
- super()
- this.mtuSize = 20
- this.notYetDisconnected = true
+ super();
+ this.mtuSize = 20;
+ this.notYetDisconnected = true;
this.write = (buffer2) => __awaiter4(this, void 0, void 0, function* () {
- log("ble-frame", "=> " + buffer2.toString("hex"))
- yield this.writeCharacteristic.writeValue(buffer2)
- })
- this.id = device.id
- this.device = device
- this.writeCharacteristic = writeCharacteristic
- this.notifyObservable = notifyObservable
- this.deviceModel = deviceModel
- log("ble-verbose", `BleTransport(${String(this.id)}) new instance`)
- }
- inferMTU () {
+ log("ble-frame", "=> " + buffer2.toString("hex"));
+ yield this.writeCharacteristic.writeValue(buffer2);
+ });
+ this.id = device.id;
+ this.device = device;
+ this.writeCharacteristic = writeCharacteristic;
+ this.notifyObservable = notifyObservable;
+ this.deviceModel = deviceModel;
+ log("ble-verbose", `BleTransport(${String(this.id)}) new instance`);
+ }
+ inferMTU() {
return __awaiter4(this, void 0, void 0, function* () {
- let mtu = 23
+ let mtu = 23;
yield this.exchangeAtomicImpl(() => __awaiter4(this, void 0, void 0, function* () {
try {
- mtu = (yield firstValueFrom(merge(this.notifyObservable.pipe(first((buffer2) => buffer2.readUInt8(0) === 8), map((buffer2) => buffer2.readUInt8(5))), defer(() => from(this.write(Buffer.from([8, 0, 0, 0, 0])))).pipe(ignoreElements())))) + 3
+ mtu = (yield firstValueFrom(merge(this.notifyObservable.pipe(first((buffer2) => buffer2.readUInt8(0) === 8), map((buffer2) => buffer2.readUInt8(5))), defer(() => from(this.write(Buffer.from([8, 0, 0, 0, 0])))).pipe(ignoreElements())))) + 3;
} catch (e) {
- log("ble-error", "inferMTU got " + String(e))
- this.device.gatt.disconnect()
- throw e
+ log("ble-error", "inferMTU got " + String(e));
+ this.device.gatt.disconnect();
+ throw e;
}
- }))
+ }));
if (mtu > 23) {
- const mtuSize = mtu - 3
- log("ble-verbose", `BleTransport(${String(this.id)}) mtu set to ${String(mtuSize)}`)
- this.mtuSize = mtuSize
+ const mtuSize = mtu - 3;
+ log("ble-verbose", `BleTransport(${String(this.id)}) mtu set to ${String(mtuSize)}`);
+ this.mtuSize = mtuSize;
}
- return this.mtuSize
- })
+ return this.mtuSize;
+ });
}
/**
* Exchange with the device using APDU protocol.
* @param apdu
* @returns a promise of apdu response
*/
- exchange (apdu) {
+ exchange(apdu) {
return __awaiter4(this, void 0, void 0, function* () {
const b = yield this.exchangeAtomicImpl(() => __awaiter4(this, void 0, void 0, function* () {
try {
- const msgIn = apdu.toString("hex")
- log("apdu", `=> ${msgIn}`)
- const data = yield firstValueFrom(merge(this.notifyObservable.pipe(receiveAPDU), sendAPDU(this.write, apdu, this.mtuSize)))
- const msgOut = data.toString("hex")
- log("apdu", `<= ${msgOut}`)
- return data
+ const msgIn = apdu.toString("hex");
+ log("apdu", `=> ${msgIn}`);
+ const data = yield firstValueFrom(merge(this.notifyObservable.pipe(receiveAPDU), sendAPDU(this.write, apdu, this.mtuSize)));
+ const msgOut = data.toString("hex");
+ log("apdu", `<= ${msgOut}`);
+ return data;
} catch (e) {
- log("ble-error", "exchange got " + String(e))
+ log("ble-error", "exchange got " + String(e));
if (this.notYetDisconnected) {
- this.device.gatt.disconnect()
+ this.device.gatt.disconnect();
}
- throw e
+ throw e;
}
- }))
- return b
- })
+ }));
+ return b;
+ });
}
- setScrambleKey () {
+ setScrambleKey() {
}
- close () {
+ close() {
return __awaiter4(this, void 0, void 0, function* () {
if (this.exchangeBusyPromise) {
- yield this.exchangeBusyPromise
+ yield this.exchangeBusyPromise;
}
- })
+ });
}
- }
- _a = BluetoothTransport
- BluetoothTransport.isSupported = () => Promise.resolve().then(requiresBluetooth).then(() => true, () => false)
- BluetoothTransport.observeAvailability = (observer) => availability().subscribe(observer)
- BluetoothTransport.list = () => Promise.resolve([])
+ };
+ _a = BluetoothTransport;
+ BluetoothTransport.isSupported = () => Promise.resolve().then(requiresBluetooth).then(() => true, () => false);
+ BluetoothTransport.observeAvailability = (observer) => availability().subscribe(observer);
+ BluetoothTransport.list = () => Promise.resolve([]);
BluetoothTransport.disconnect = (id2) => __awaiter4(void 0, void 0, void 0, function* () {
- log("ble-verbose", `user disconnect(${id2})`)
- const transport = transportsCache[id2]
+ log("ble-verbose", `user disconnect(${id2})`);
+ const transport = transportsCache[id2];
if (transport) {
- transport.device.gatt.disconnect()
+ transport.device.gatt.disconnect();
}
- })
- TransportWebBLE_default = BluetoothTransport
+ });
+ TransportWebBLE_default = BluetoothTransport;
}
-})
+});
// node_modules/@ledgerhq/devices/lib-es/hid-framing.js
-function asUInt16BE (value) {
- const b = Buffer.alloc(2)
- b.writeUInt16BE(value, 0)
- return b
+function asUInt16BE(value) {
+ const b = Buffer.alloc(2);
+ b.writeUInt16BE(value, 0);
+ return b;
}
-var Tag, initialAcc, createHIDframing, hid_framing_default
+var Tag, initialAcc, createHIDframing, hid_framing_default;
var init_hid_framing = __esm({
- "node_modules/@ledgerhq/devices/lib-es/hid-framing.js" () {
- init_lib_es()
- Tag = 5
+ "node_modules/@ledgerhq/devices/lib-es/hid-framing.js"() {
+ init_lib_es();
+ Tag = 5;
initialAcc = {
data: Buffer.alloc(0),
dataLength: 0,
sequence: 0
- }
+ };
createHIDframing = (channel, packetSize) => {
return {
/**
* @param apdu The APDU message to send, in a Buffer containing [cla, ins, p1, p2, data length, data(if not empty)]
* @returns an array of HID USB frames ready to be sent
*/
- makeBlocks (apdu) {
- let data = Buffer.concat([asUInt16BE(apdu.length), apdu])
- const blockSize = packetSize - 5
- const nbBlocks = Math.ceil(data.length / blockSize)
- data = Buffer.concat([data, Buffer.alloc(nbBlocks * blockSize - data.length + 1).fill(0)])
- const blocks = []
+ makeBlocks(apdu) {
+ let data = Buffer.concat([asUInt16BE(apdu.length), apdu]);
+ const blockSize = packetSize - 5;
+ const nbBlocks = Math.ceil(data.length / blockSize);
+ data = Buffer.concat([data, Buffer.alloc(nbBlocks * blockSize - data.length + 1).fill(0)]);
+ const blocks = [];
for (let i = 0; i < nbBlocks; i++) {
- const head = Buffer.alloc(5)
- head.writeUInt16BE(channel, 0)
- head.writeUInt8(Tag, 2)
- head.writeUInt16BE(i, 3)
- const chunk = data.slice(i * blockSize, (i + 1) * blockSize)
- blocks.push(Buffer.concat([head, chunk]))
- }
- return blocks
+ const head = Buffer.alloc(5);
+ head.writeUInt16BE(channel, 0);
+ head.writeUInt8(Tag, 2);
+ head.writeUInt16BE(i, 3);
+ const chunk = data.slice(i * blockSize, (i + 1) * blockSize);
+ blocks.push(Buffer.concat([head, chunk]));
+ }
+ return blocks;
},
/**
* Reduces HID USB packets/frames to one response.
* @param chunk Current chunk to reduce into accumulator
* @returns An accumulator value updated with the current chunk
*/
- reduceResponse (acc, chunk) {
- let { data, dataLength, sequence } = acc || initialAcc
+ reduceResponse(acc, chunk) {
+ let { data, dataLength, sequence } = acc || initialAcc;
if (chunk.readUInt16BE(0) !== channel) {
- throw new TransportError("Invalid channel", "InvalidChannel")
+ throw new TransportError("Invalid channel", "InvalidChannel");
}
if (chunk.readUInt8(2) !== Tag) {
- throw new TransportError("Invalid tag", "InvalidTag")
+ throw new TransportError("Invalid tag", "InvalidTag");
}
if (chunk.readUInt16BE(3) !== sequence) {
- throw new TransportError("Invalid sequence", "InvalidSequence")
+ throw new TransportError("Invalid sequence", "InvalidSequence");
}
if (!acc) {
- dataLength = chunk.readUInt16BE(5)
+ dataLength = chunk.readUInt16BE(5);
}
- sequence++
- const chunkData = chunk.slice(acc ? 5 : 7)
- data = Buffer.concat([data, chunkData])
+ sequence++;
+ const chunkData = chunk.slice(acc ? 5 : 7);
+ data = Buffer.concat([data, chunkData]);
if (data.length > dataLength) {
- data = data.slice(0, dataLength)
+ data = data.slice(0, dataLength);
}
return {
data,
dataLength,
sequence
- }
+ };
},
/**
* Returns the response message that has been reduced from the HID USB frames
* @returns A Buffer containing the cleaned response message, or null if no response message, or undefined if the
* accumulator is incorrect (message length is not valid)
*/
- getReducedResult (acc) {
+ getReducedResult(acc) {
if (acc && acc.dataLength === acc.data.length) {
- return acc.data
+ return acc.data;
}
}
- }
- }
- hid_framing_default = createHIDframing
+ };
+ };
+ hid_framing_default = createHIDframing;
}
-})
+});
// node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js
-function requestLedgerDevice () {
+function requestLedgerDevice() {
return __awaiter5(this, void 0, void 0, function* () {
const device = yield navigator.usb.requestDevice({
filters: ledgerDevices
- })
- return device
- })
+ });
+ return device;
+ });
}
-function getLedgerDevices () {
+function getLedgerDevices() {
return __awaiter5(this, void 0, void 0, function* () {
- const devices2 = yield navigator.usb.getDevices()
- return devices2.filter((d) => d.vendorId === ledgerUSBVendorId)
- })
+ const devices2 = yield navigator.usb.getDevices();
+ return devices2.filter((d) => d.vendorId === ledgerUSBVendorId);
+ });
}
-function getFirstLedgerDevice () {
+function getFirstLedgerDevice() {
return __awaiter5(this, void 0, void 0, function* () {
- const existingDevices = yield getLedgerDevices()
+ const existingDevices = yield getLedgerDevices();
if (existingDevices.length > 0)
- return existingDevices[0]
- return requestLedgerDevice()
- })
+ return existingDevices[0];
+ return requestLedgerDevice();
+ });
}
-var __awaiter5, ledgerDevices, isSupported
+var __awaiter5, ledgerDevices, isSupported;
var init_webusb = __esm({
- "node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js" () {
- init_lib_es3()
- __awaiter5 = function (thisArg, _arguments, P, generator) {
- function adopt (value) {
- return value instanceof P ? value : new P(function (resolve) {
- resolve(value)
- })
- }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled (value) {
+ "node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js"() {
+ init_lib_es3();
+ __awaiter5 = function(thisArg, _arguments, P, generator) {
+ function adopt(value) {
+ return value instanceof P ? value : new P(function(resolve) {
+ resolve(value);
+ });
+ }
+ return new (P || (P = Promise))(function(resolve, reject) {
+ function fulfilled(value) {
try {
- step(generator.next(value))
+ step(generator.next(value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function rejected (value) {
+ function rejected(value) {
try {
- step(generator["throw"](value))
+ step(generator["throw"](value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function step (result) {
- result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+ function step(result) {
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
- step((generator = generator.apply(thisArg, _arguments || [])).next())
- })
- }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+ };
ledgerDevices = [
{
vendorId: ledgerUSBVendorId
}
- ]
- isSupported = () => Promise.resolve(!!navigator && !!navigator.usb && typeof navigator.usb.getDevices === "function")
+ ];
+ isSupported = () => Promise.resolve(!!navigator && !!navigator.usb && typeof navigator.usb.getDevices === "function");
}
-})
+});
// node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js
-function gracefullyResetDevice (device) {
+function gracefullyResetDevice(device) {
return __awaiter6(this, void 0, void 0, function* () {
try {
- yield device.reset()
+ yield device.reset();
} catch (err) {
- console.warn(err)
+ console.warn(err);
}
- })
+ });
}
-var __awaiter6, configurationValue, endpointNumber, TransportWebUSB, TransportWebUSB_default
+var __awaiter6, configurationValue, endpointNumber, TransportWebUSB, TransportWebUSB_default;
var init_TransportWebUSB = __esm({
- "node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js" () {
- init_Transport()
- init_hid_framing()
- init_lib_es3()
- init_lib_es2()
- init_lib_es()
- init_webusb()
- __awaiter6 = function (thisArg, _arguments, P, generator) {
- function adopt (value) {
- return value instanceof P ? value : new P(function (resolve) {
- resolve(value)
- })
- }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled (value) {
+ "node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js"() {
+ init_Transport();
+ init_hid_framing();
+ init_lib_es3();
+ init_lib_es2();
+ init_lib_es();
+ init_webusb();
+ __awaiter6 = function(thisArg, _arguments, P, generator) {
+ function adopt(value) {
+ return value instanceof P ? value : new P(function(resolve) {
+ resolve(value);
+ });
+ }
+ return new (P || (P = Promise))(function(resolve, reject) {
+ function fulfilled(value) {
try {
- step(generator.next(value))
+ step(generator.next(value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function rejected (value) {
+ function rejected(value) {
try {
- step(generator["throw"](value))
+ step(generator["throw"](value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function step (result) {
- result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+ function step(result) {
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
- step((generator = generator.apply(thisArg, _arguments || [])).next())
- })
- }
- configurationValue = 1
- endpointNumber = 3
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+ };
+ configurationValue = 1;
+ endpointNumber = 3;
TransportWebUSB = class _TransportWebUSB extends Transport_default {
constructor(device, interfaceNumber) {
- super()
- this.channel = Math.floor(Math.random() * 65535)
- this.packetSize = 64
- this._disconnectEmitted = false
+ super();
+ this.channel = Math.floor(Math.random() * 65535);
+ this.packetSize = 64;
+ this._disconnectEmitted = false;
this._emitDisconnect = (e) => {
if (this._disconnectEmitted)
- return
- this._disconnectEmitted = true
- this.emit("disconnect", e)
- }
- this.device = device
- this.interfaceNumber = interfaceNumber
- this.deviceModel = identifyUSBProductId(device.productId)
+ return;
+ this._disconnectEmitted = true;
+ this.emit("disconnect", e);
+ };
+ this.device = device;
+ this.interfaceNumber = interfaceNumber;
+ this.deviceModel = identifyUSBProductId(device.productId);
}
/**
* Similar to create() except it will always display the device permission (even if some devices are already accepted).
*/
- static request () {
+ static request() {
return __awaiter6(this, void 0, void 0, function* () {
- const device = yield requestLedgerDevice()
- return _TransportWebUSB.open(device)
- })
+ const device = yield requestLedgerDevice();
+ return _TransportWebUSB.open(device);
+ });
}
/**
* Similar to create() except it will never display the device permission (it returns a Promise<?Transport>, null if it fails to find a device).
*/
- static openConnected () {
+ static openConnected() {
return __awaiter6(this, void 0, void 0, function* () {
- const devices2 = yield getLedgerDevices()
+ const devices2 = yield getLedgerDevices();
if (devices2.length === 0)
- return null
- return _TransportWebUSB.open(devices2[0])
- })
+ return null;
+ return _TransportWebUSB.open(devices2[0]);
+ });
}
/**
* Create a Ledger transport with a USBDevice
*/
- static open (device) {
+ static open(device) {
return __awaiter6(this, void 0, void 0, function* () {
- yield device.open()
+ yield device.open();
if (device.configuration === null) {
- yield device.selectConfiguration(configurationValue)
+ yield device.selectConfiguration(configurationValue);
}
- yield gracefullyResetDevice(device)
- const iface = device.configurations[0].interfaces.find(({ alternates }) => alternates.some((a) => a.interfaceClass === 255))
+ yield gracefullyResetDevice(device);
+ const iface = device.configurations[0].interfaces.find(({ alternates }) => alternates.some((a) => a.interfaceClass === 255));
if (!iface) {
- throw new TransportInterfaceNotAvailable("No WebUSB interface found for your Ledger device. Please upgrade firmware or contact techsupport.")
+ throw new TransportInterfaceNotAvailable("No WebUSB interface found for your Ledger device. Please upgrade firmware or contact techsupport.");
}
- const interfaceNumber = iface.interfaceNumber
+ const interfaceNumber = iface.interfaceNumber;
try {
- yield device.claimInterface(interfaceNumber)
+ yield device.claimInterface(interfaceNumber);
} catch (e) {
- yield device.close()
- throw new TransportInterfaceNotAvailable(e.message)
+ yield device.close();
+ throw new TransportInterfaceNotAvailable(e.message);
}
- const transport = new _TransportWebUSB(device, interfaceNumber)
+ const transport = new _TransportWebUSB(device, interfaceNumber);
const onDisconnect = (e) => {
if (device === e.device) {
- navigator.usb.removeEventListener("disconnect", onDisconnect)
- transport._emitDisconnect(new DisconnectedDevice())
+ navigator.usb.removeEventListener("disconnect", onDisconnect);
+ transport._emitDisconnect(new DisconnectedDevice());
}
- }
- navigator.usb.addEventListener("disconnect", onDisconnect)
- return transport
- })
+ };
+ navigator.usb.addEventListener("disconnect", onDisconnect);
+ return transport;
+ });
}
/**
* Release the transport device
*/
- close () {
+ close() {
return __awaiter6(this, void 0, void 0, function* () {
- yield this.exchangeBusyPromise
- yield this.device.releaseInterface(this.interfaceNumber)
- yield gracefullyResetDevice(this.device)
- yield this.device.close()
- })
+ yield this.exchangeBusyPromise;
+ yield this.device.releaseInterface(this.interfaceNumber);
+ yield gracefullyResetDevice(this.device);
+ yield this.device.close();
+ });
}
/**
* Exchange with the device using APDU protocol.
* @param apdu
* @returns a promise of apdu response
*/
- exchange (apdu) {
+ exchange(apdu) {
return __awaiter6(this, void 0, void 0, function* () {
const b = yield this.exchangeAtomicImpl(() => __awaiter6(this, void 0, void 0, function* () {
- const { channel, packetSize } = this
- log("apdu", "=> " + apdu.toString("hex"))
- const framing = hid_framing_default(channel, packetSize)
- const blocks = framing.makeBlocks(apdu)
+ const { channel, packetSize } = this;
+ log("apdu", "=> " + apdu.toString("hex"));
+ const framing = hid_framing_default(channel, packetSize);
+ const blocks = framing.makeBlocks(apdu);
for (let i = 0; i < blocks.length; i++) {
- yield this.device.transferOut(endpointNumber, blocks[i])
+ yield this.device.transferOut(endpointNumber, blocks[i]);
}
- let result
- let acc
+ let result;
+ let acc;
while (!(result = framing.getReducedResult(acc))) {
- const r = yield this.device.transferIn(endpointNumber, packetSize)
- const buffer2 = Buffer.from(r.data.buffer)
- acc = framing.reduceResponse(acc, buffer2)
+ const r = yield this.device.transferIn(endpointNumber, packetSize);
+ const buffer2 = Buffer.from(r.data.buffer);
+ acc = framing.reduceResponse(acc, buffer2);
}
- log("apdu", "<= " + result.toString("hex"))
- return result
+ log("apdu", "<= " + result.toString("hex"));
+ return result;
})).catch((e) => {
if (e && e.message && e.message.includes("disconnected")) {
- this._emitDisconnect(e)
- throw new DisconnectedDeviceDuringOperation(e.message)
+ this._emitDisconnect(e);
+ throw new DisconnectedDeviceDuringOperation(e.message);
}
- throw e
- })
- return b
- })
+ throw e;
+ });
+ return b;
+ });
}
- setScrambleKey () {
+ setScrambleKey() {
}
- }
- TransportWebUSB.isSupported = isSupported
- TransportWebUSB.list = getLedgerDevices
+ };
+ TransportWebUSB.isSupported = isSupported;
+ TransportWebUSB.list = getLedgerDevices;
TransportWebUSB.listen = (observer) => {
- let unsubscribed = false
+ let unsubscribed = false;
getFirstLedgerDevice().then((device) => {
if (!unsubscribed) {
- const deviceModel = identifyUSBProductId(device.productId)
+ const deviceModel = identifyUSBProductId(device.productId);
observer.next({
type: "add",
descriptor: device,
deviceModel
- })
- observer.complete()
+ });
+ observer.complete();
}
}, (error) => {
if (window.DOMException && error instanceof window.DOMException && error.code === 18) {
- observer.error(new TransportWebUSBGestureRequired(error.message))
+ observer.error(new TransportWebUSBGestureRequired(error.message));
} else {
- observer.error(new TransportOpenUserCancelled(error.message))
+ observer.error(new TransportOpenUserCancelled(error.message));
}
- })
- function unsubscribe () {
- unsubscribed = true
+ });
+ function unsubscribe() {
+ unsubscribed = true;
}
return {
unsubscribe
- }
- }
- TransportWebUSB_default = TransportWebUSB
+ };
+ };
+ TransportWebUSB_default = TransportWebUSB;
}
-})
+});
// node_modules/@ledgerhq/hw-transport-webhid/lib-es/TransportWebHID.js
-function requestLedgerDevices () {
+function requestLedgerDevices() {
return __awaiter7(this, void 0, void 0, function* () {
const device = yield getHID().requestDevice({
filters: ledgerDevices2
- })
+ });
if (Array.isArray(device))
- return device
- return [device]
- })
+ return device;
+ return [device];
+ });
}
-function getLedgerDevices2 () {
+function getLedgerDevices2() {
return __awaiter7(this, void 0, void 0, function* () {
- const devices2 = yield getHID().getDevices()
- return devices2.filter((d) => d.vendorId === ledgerUSBVendorId)
- })
+ const devices2 = yield getHID().getDevices();
+ return devices2.filter((d) => d.vendorId === ledgerUSBVendorId);
+ });
}
-function getFirstLedgerDevice2 () {
+function getFirstLedgerDevice2() {
return __awaiter7(this, void 0, void 0, function* () {
- const existingDevices = yield getLedgerDevices2()
+ const existingDevices = yield getLedgerDevices2();
if (existingDevices.length > 0)
- return existingDevices[0]
- const devices2 = yield requestLedgerDevices()
- return devices2[0]
- })
+ return existingDevices[0];
+ const devices2 = yield requestLedgerDevices();
+ return devices2[0];
+ });
}
-var __awaiter7, ledgerDevices2, isSupported2, getHID, TransportWebHID, TransportWebHID_default
+var __awaiter7, ledgerDevices2, isSupported2, getHID, TransportWebHID, TransportWebHID_default;
var init_TransportWebHID = __esm({
- "node_modules/@ledgerhq/hw-transport-webhid/lib-es/TransportWebHID.js" () {
- init_Transport()
- init_hid_framing()
- init_lib_es3()
- init_lib_es2()
- init_lib_es()
- __awaiter7 = function (thisArg, _arguments, P, generator) {
- function adopt (value) {
- return value instanceof P ? value : new P(function (resolve) {
- resolve(value)
- })
- }
- return new (P || (P = Promise))(function (resolve, reject) {
- function fulfilled (value) {
+ "node_modules/@ledgerhq/hw-transport-webhid/lib-es/TransportWebHID.js"() {
+ init_Transport();
+ init_hid_framing();
+ init_lib_es3();
+ init_lib_es2();
+ init_lib_es();
+ __awaiter7 = function(thisArg, _arguments, P, generator) {
+ function adopt(value) {
+ return value instanceof P ? value : new P(function(resolve) {
+ resolve(value);
+ });
+ }
+ return new (P || (P = Promise))(function(resolve, reject) {
+ function fulfilled(value) {
try {
- step(generator.next(value))
+ step(generator.next(value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function rejected (value) {
+ function rejected(value) {
try {
- step(generator["throw"](value))
+ step(generator["throw"](value));
} catch (e) {
- reject(e)
+ reject(e);
}
}
- function step (result) {
- result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+ function step(result) {
+ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
}
- step((generator = generator.apply(thisArg, _arguments || [])).next())
- })
- }
+ step((generator = generator.apply(thisArg, _arguments || [])).next());
+ });
+ };
ledgerDevices2 = [
{
vendorId: ledgerUSBVendorId
}
- ]
- isSupported2 = () => Promise.resolve(!!(window.navigator && window.navigator.hid))
+ ];
+ isSupported2 = () => Promise.resolve(!!(window.navigator && window.navigator.hid));
getHID = () => {
- const { hid } = navigator
+ const { hid } = navigator;
if (!hid)
- throw new TransportError("navigator.hid is not supported", "HIDNotSupported")
- return hid
- }
+ throw new TransportError("navigator.hid is not supported", "HIDNotSupported");
+ return hid;
+ };
TransportWebHID = class _TransportWebHID extends Transport_default {
constructor(device) {
- super()
- this.channel = Math.floor(Math.random() * 65535)
- this.packetSize = 64
- this.inputs = []
+ super();
+ this.channel = Math.floor(Math.random() * 65535);
+ this.packetSize = 64;
+ this.inputs = [];
this.read = () => {
if (this.inputs.length) {
- return Promise.resolve(this.inputs.shift())
+ return Promise.resolve(this.inputs.shift());
}
return new Promise((success) => {
- this.inputCallback = success
- })
- }
+ this.inputCallback = success;
+ });
+ };
this.onInputReport = (e) => {
- const buffer2 = Buffer.from(e.data.buffer)
+ const buffer2 = Buffer.from(e.data.buffer);
if (this.inputCallback) {
- this.inputCallback(buffer2)
- this.inputCallback = null
+ this.inputCallback(buffer2);
+ this.inputCallback = null;
} else {
- this.inputs.push(buffer2)
+ this.inputs.push(buffer2);
}
- }
- this._disconnectEmitted = false
+ };
+ this._disconnectEmitted = false;
this._emitDisconnect = (e) => {
if (this._disconnectEmitted)
- return
- this._disconnectEmitted = true
- this.emit("disconnect", e)
- }
+ return;
+ this._disconnectEmitted = true;
+ this.emit("disconnect", e);
+ };
this.exchange = (apdu) => __awaiter7(this, void 0, void 0, function* () {
const b = yield this.exchangeAtomicImpl(() => __awaiter7(this, void 0, void 0, function* () {
- const { channel, packetSize } = this
- log("apdu", "=> " + apdu.toString("hex"))
- const framing = hid_framing_default(channel, packetSize)
- const blocks = framing.makeBlocks(apdu)
+ const { channel, packetSize } = this;
+ log("apdu", "=> " + apdu.toString("hex"));
+ const framing = hid_framing_default(channel, packetSize);
+ const blocks = framing.makeBlocks(apdu);
for (let i = 0; i < blocks.length; i++) {
- yield this.device.sendReport(0, blocks[i])
+ yield this.device.sendReport(0, blocks[i]);
}
- let result
- let acc
+ let result;
+ let acc;
while (!(result = framing.getReducedResult(acc))) {
- const buffer2 = yield this.read()
- acc = framing.reduceResponse(acc, buffer2)
+ const buffer2 = yield this.read();
+ acc = framing.reduceResponse(acc, buffer2);
}
- log("apdu", "<= " + result.toString("hex"))
- return result
+ log("apdu", "<= " + result.toString("hex"));
+ return result;
})).catch((e) => {
if (e && e.message && e.message.includes("write")) {
- this._emitDisconnect(e)
- throw new DisconnectedDeviceDuringOperation(e.message)
+ this._emitDisconnect(e);
+ throw new DisconnectedDeviceDuringOperation(e.message);
}
- throw e
- })
- return b
- })
- this.device = device
- this.deviceModel = typeof device.productId === "number" ? identifyUSBProductId(device.productId) : void 0
- device.addEventListener("inputreport", this.onInputReport)
+ throw e;
+ });
+ return b;
+ });
+ this.device = device;
+ this.deviceModel = typeof device.productId === "number" ? identifyUSBProductId(device.productId) : void 0;
+ device.addEventListener("inputreport", this.onInputReport);
}
/**
* Similar to create() except it will always display the device permission (even if some devices are already accepted).
*/
- static request () {
+ static request() {
return __awaiter7(this, void 0, void 0, function* () {
- const [device] = yield requestLedgerDevices()
- return _TransportWebHID.open(device)
- })
+ const [device] = yield requestLedgerDevices();
+ return _TransportWebHID.open(device);
+ });
}
/**
* Similar to create() except it will never display the device permission (it returns a Promise<?Transport>, null if it fails to find a device).
*/
- static openConnected () {
+ static openConnected() {
return __awaiter7(this, void 0, void 0, function* () {
- const devices2 = yield getLedgerDevices2()
+ const devices2 = yield getLedgerDevices2();
if (devices2.length === 0)
- return null
- return _TransportWebHID.open(devices2[0])
- })
+ return null;
+ return _TransportWebHID.open(devices2[0]);
+ });
}
/**
* Create a Ledger transport with a HIDDevice
*/
- static open (device) {
+ static open(device) {
return __awaiter7(this, void 0, void 0, function* () {
- yield device.open()
- const transport = new _TransportWebHID(device)
+ yield device.open();
+ const transport = new _TransportWebHID(device);
const onDisconnect = (e) => {
if (device === e.device) {
- getHID().removeEventListener("disconnect", onDisconnect)
- transport._emitDisconnect(new DisconnectedDevice())
+ getHID().removeEventListener("disconnect", onDisconnect);
+ transport._emitDisconnect(new DisconnectedDevice());
}
- }
- getHID().addEventListener("disconnect", onDisconnect)
- return transport
- })
+ };
+ getHID().addEventListener("disconnect", onDisconnect);
+ return transport;
+ });
}
/**
* Release the transport device
*/
- close () {
+ close() {
return __awaiter7(this, void 0, void 0, function* () {
- yield this.exchangeBusyPromise
- this.device.removeEventListener("inputreport", this.onInputReport)
- yield this.device.close()
- })
+ yield this.exchangeBusyPromise;
+ this.device.removeEventListener("inputreport", this.onInputReport);
+ yield this.device.close();
+ });
}
- setScrambleKey () {
+ setScrambleKey() {
}
- }
- TransportWebHID.isSupported = isSupported2
- TransportWebHID.list = getLedgerDevices2
+ };
+ TransportWebHID.isSupported = isSupported2;
+ TransportWebHID.list = getLedgerDevices2;
TransportWebHID.listen = (observer) => {
- let unsubscribed = false
+ let unsubscribed = false;
getFirstLedgerDevice2().then((device) => {
if (!device) {
- observer.error(new TransportOpenUserCancelled("Access denied to use Ledger device"))
+ observer.error(new TransportOpenUserCancelled("Access denied to use Ledger device"));
} else if (!unsubscribed) {
- const deviceModel = typeof device.productId === "number" ? identifyUSBProductId(device.productId) : void 0
+ const deviceModel = typeof device.productId === "number" ? identifyUSBProductId(device.productId) : void 0;
observer.next({
type: "add",
descriptor: device,
deviceModel
- })
- observer.complete()
+ });
+ observer.complete();
}
}, (error) => {
- observer.error(new TransportOpenUserCancelled(error.message))
- })
- function unsubscribe () {
- unsubscribed = true
+ observer.error(new TransportOpenUserCancelled(error.message));
+ });
+ function unsubscribe() {
+ unsubscribed = true;
}
return {
unsubscribe
- }
- }
- TransportWebHID_default = TransportWebHID
+ };
+ };
+ TransportWebHID_default = TransportWebHID;
}
-})
+});
// dist/lib/ledger.js
-var ledger_exports = {}
+var ledger_exports = {};
__export(ledger_exports, {
Ledger: () => Ledger
-})
-var Ledger
+});
+var Ledger;
var init_ledger = __esm({
- "dist/lib/ledger.js" () {
- "use strict"
- init_TransportWebBLE()
- init_TransportWebUSB()
- init_TransportWebHID()
- init_constants()
- init_convert()
- init_rpc()
- init_block()
+ "dist/lib/ledger.js"() {
+ "use strict";
+ init_TransportWebBLE();
+ init_TransportWebUSB();
+ init_TransportWebHID();
+ init_constants();
+ init_convert();
+ init_rpc();
+ init_block();
Ledger = class _Ledger {
static #isInternal = false;
#status = "DISCONNECTED";
- get status () {
- return this.#status
+ get status() {
+ return this.#status;
}
openTimeout = 3e3;
listenTimeout = 3e4;
DynamicTransport = TransportWebHID_default;
constructor() {
if (!_Ledger.#isInternal) {
- throw new Error("Ledger cannot be instantiated directly. Use Ledger.init()")
+ throw new Error("Ledger cannot be instantiated directly. Use Ledger.init()");
}
- _Ledger.#isInternal = false
+ _Ledger.#isInternal = false;
}
- static async init () {
- _Ledger.#isInternal = true
- const self = new this()
- await self.checkBrowserSupport()
- await self.listen()
- return self
+ static async init() {
+ _Ledger.#isInternal = true;
+ const self = new this();
+ await self.checkBrowserSupport();
+ await self.listen();
+ return self;
}
/**
* Check which transport protocols are supported by the browser and set the
* transport type according to the following priorities: Bluetooth, USB, HID.
*/
- async checkBrowserSupport () {
- console.log("Checking browser Ledger support...")
+ async checkBrowserSupport() {
+ console.log("Checking browser Ledger support...");
const supports = {
ble: await TransportWebBLE_default.isSupported(),
usb: await TransportWebUSB_default.isSupported(),
hid: await TransportWebHID_default.isSupported()
- }
- console.log(`ble: ${supports.ble}; usb: ${supports.usb}; hid: ${supports.hid}`)
+ };
+ console.log(`ble: ${supports.ble}; usb: ${supports.usb}; hid: ${supports.hid}`);
if (supports.ble) {
- this.DynamicTransport = TransportWebBLE_default
+ this.DynamicTransport = TransportWebBLE_default;
} else if (supports.usb) {
- this.DynamicTransport = TransportWebUSB_default
+ this.DynamicTransport = TransportWebUSB_default;
} else if (supports.hid) {
- this.DynamicTransport = TransportWebHID_default
+ this.DynamicTransport = TransportWebHID_default;
} else {
- throw new Error("Unsupported browser")
+ throw new Error("Unsupported browser");
}
}
- async listen () {
- const { usb } = globalThis.navigator
+ async listen() {
+ const { usb } = globalThis.navigator;
if (usb) {
- usb.addEventListener("connect", console.log.bind(console))
- usb.addEventListener("disconnect", console.log.bind(console))
+ usb.addEventListener("connect", console.log.bind(console));
+ usb.addEventListener("disconnect", console.log.bind(console));
}
}
- async connect () {
- const { usb } = globalThis.navigator
+ async connect() {
+ const { usb } = globalThis.navigator;
if (usb) {
- usb.removeEventListener("disconnect", this.onDisconnectUsb.bind(this))
- usb.addEventListener("disconnect", this.onDisconnectUsb.bind(this))
+ usb.removeEventListener("disconnect", this.onDisconnectUsb.bind(this));
+ usb.addEventListener("disconnect", this.onDisconnectUsb.bind(this));
}
- const version = await this.version()
+ const version = await this.version();
if (version.status === "OK") {
if (version.name === "Nano") {
- const account = await this.account()
+ const account = await this.account();
if (account.status === "OK") {
- this.#status = "CONNECTED"
+ this.#status = "CONNECTED";
} else if (account.status === "SECURITY_STATUS_NOT_SATISFIED") {
- this.#status = "LOCKED"
+ this.#status = "LOCKED";
} else {
- this.#status = "DISCONNECTED"
+ this.#status = "DISCONNECTED";
}
} else if (version.name === "BOLOS") {
- const open2 = await this.open()
- this.#status = open2.status === "OK" ? "CONNECTED" : "DISCONNECTED"
+ const open2 = await this.open();
+ this.#status = open2.status === "OK" ? "CONNECTED" : "DISCONNECTED";
} else {
- this.#status = "BUSY"
+ this.#status = "BUSY";
}
} else {
- this.#status = "DISCONNECTED"
+ this.#status = "DISCONNECTED";
}
- return this.status
+ return this.status;
}
- async onDisconnectUsb (e) {
+ async onDisconnectUsb(e) {
if (e.device?.manufacturerName === "Ledger") {
- const { usb } = globalThis.navigator
- usb.removeEventListener("disconnect", this.onDisconnectUsb)
- this.#status = "DISCONNECTED"
+ const { usb } = globalThis.navigator;
+ usb.removeEventListener("disconnect", this.onDisconnectUsb);
+ this.#status = "DISCONNECTED";
}
}
/**
*
* @returns Status of command
*/
- async open () {
- const name = new TextEncoder().encode("Nano")
- const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout)
- const response = await transport.send(224, 216, 0, 0, name).then((res) => bytes.toDec(res)).catch((err) => err.statusCode)
- return new Promise((resolve) => setTimeout(resolve, 1e3, { status: LEDGER_STATUS_CODES[response] }))
+ async open() {
+ const name = new TextEncoder().encode("Nano");
+ const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout);
+ const response = await transport.send(224, 216, 0, 0, name).then((res) => bytes.toDec(res)).catch((err) => err.statusCode);
+ return new Promise((resolve) => setTimeout(resolve, 1e3, { status: LEDGER_STATUS_CODES[response] }));
}
/**
* Close the currently running app.
*
* @returns Status of command
*/
- async close () {
- const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout)
- const response = await transport.send(176, 167, 0, 0).then((res) => bytes.toDec(res)).catch((err) => err.statusCode)
- return new Promise((resolve) => setTimeout(resolve, 1e3, { status: LEDGER_STATUS_CODES[response] }))
+ async close() {
+ const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout);
+ const response = await transport.send(176, 167, 0, 0).then((res) => bytes.toDec(res)).catch((err) => err.statusCode);
+ return new Promise((resolve) => setTimeout(resolve, 1e3, { status: LEDGER_STATUS_CODES[response] }));
}
/**
* Get the version of the current process. If a specific app is running, get
*
* @returns Status, process name, and version
*/
- async version () {
- const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout)
- const response = await transport.send(176, 1, 0, 0).catch((err) => dec.toBytes(err.statusCode))
- await transport.close()
+ async version() {
+ const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout);
+ const response = await transport.send(176, 1, 0, 0).catch((err) => dec.toBytes(err.statusCode));
+ await transport.close();
if (response.length === 2) {
- const statusCode2 = bytes.toDec(response)
- const status2 = LEDGER_STATUS_CODES[statusCode2] ?? "UNKNOWN_ERROR"
- return { status: status2, name: null, version: null }
- }
- const nameLength = response[1]
- const name = response.slice(2, 2 + nameLength).toString()
- const versionLength = response[2 + nameLength]
- const version = response.slice(2 + nameLength + 1, 2 + nameLength + 1 + versionLength).toString()
- const statusCode = bytes.toDec(response.slice(-2))
- const status = LEDGER_STATUS_CODES[statusCode]
- return { status, name, version }
+ const statusCode2 = bytes.toDec(response);
+ const status2 = LEDGER_STATUS_CODES[statusCode2] ?? "UNKNOWN_ERROR";
+ return { status: status2, name: null, version: null };
+ }
+ const nameLength = response[1];
+ const name = response.slice(2, 2 + nameLength).toString();
+ const versionLength = response[2 + nameLength];
+ const version = response.slice(2 + nameLength + 1, 2 + nameLength + 1 + versionLength).toString();
+ const statusCode = bytes.toDec(response.slice(-2));
+ const status = LEDGER_STATUS_CODES[statusCode];
+ return { status, name, version };
}
/**
* Get an account at a specific BIP-44 index.
*
* @returns Response object containing command status, public key, and address
*/
- async account (index = 0, show = false) {
+ async account(index = 0, show = false) {
if (typeof index !== "number" || index < 0 || index >= HARDENED_OFFSET) {
- throw new TypeError("Invalid account index")
- }
- const purpose = dec.toBytes(BIP44_PURPOSE + HARDENED_OFFSET, 4)
- const coin = dec.toBytes(BIP44_COIN_NANO + HARDENED_OFFSET, 4)
- const account = dec.toBytes(index + HARDENED_OFFSET, 4)
- const data = new Uint8Array([3, ...purpose, ...coin, ...account])
- const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout)
- const response = await transport.send(161, 2, show ? 1 : 0, 0, data).catch((err) => dec.toBytes(err.statusCode))
- await transport.close()
+ throw new TypeError("Invalid account index");
+ }
+ const purpose = dec.toBytes(BIP44_PURPOSE + HARDENED_OFFSET, 4);
+ const coin = dec.toBytes(BIP44_COIN_NANO + HARDENED_OFFSET, 4);
+ const account = dec.toBytes(index + HARDENED_OFFSET, 4);
+ const data = new Uint8Array([3, ...purpose, ...coin, ...account]);
+ const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout);
+ const response = await transport.send(161, 2, show ? 1 : 0, 0, data).catch((err) => dec.toBytes(err.statusCode));
+ await transport.close();
if (response.length === 2) {
- const statusCode = bytes.toDec(response)
- const status = LEDGER_STATUS_CODES[statusCode] ?? "UNKNOWN_ERROR"
- return { status, publicKey: null, address: null }
+ const statusCode = bytes.toDec(response);
+ const status = LEDGER_STATUS_CODES[statusCode] ?? "UNKNOWN_ERROR";
+ return { status, publicKey: null, address: null };
}
try {
- const publicKey = bytes.toHex(response.slice(0, 32))
- const addressLength = response[32]
- const address = response.slice(33, 33 + addressLength).toString()
- const statusCode = bytes.toDec(response.slice(33 + addressLength))
- const status = LEDGER_STATUS_CODES[statusCode]
- return { status, publicKey, address }
+ const publicKey = bytes.toHex(response.slice(0, 32));
+ const addressLength = response[32];
+ const address = response.slice(33, 33 + addressLength).toString();
+ const statusCode = bytes.toDec(response.slice(33 + addressLength));
+ const status = LEDGER_STATUS_CODES[statusCode];
+ return { status, publicKey, address };
} catch (err) {
- return { status: "ERROR_PARSING_ACCOUNT", publicKey: null, address: null }
+ return { status: "ERROR_PARSING_ACCOUNT", publicKey: null, address: null };
}
}
/**
* @param {any} block - Block data to cache
* @returns Status of command
*/
- async cacheBlock (index = 0, block) {
+ async cacheBlock(index = 0, block) {
if (typeof index !== "number" || index < 0 || index >= HARDENED_OFFSET) {
- throw new TypeError("Invalid account index")
+ throw new TypeError("Invalid account index");
}
if (!(block instanceof SendBlock) && !(block instanceof ReceiveBlock) && !(block instanceof ChangeBlock)) {
- throw new TypeError("Invalid block format")
+ throw new TypeError("Invalid block format");
}
if (!block.signature) {
- throw new ReferenceError("Cannot cache unsigned block")
- }
- const purpose = dec.toBytes(BIP44_PURPOSE + HARDENED_OFFSET, 4)
- const coin = dec.toBytes(BIP44_COIN_NANO + HARDENED_OFFSET, 4)
- const account = dec.toBytes(index + HARDENED_OFFSET, 4)
- const previous = hex.toBytes(block.previous)
- const link = hex.toBytes(block.link)
- const representative = hex.toBytes(block.representative.publicKey)
- const balance = hex.toBytes(BigInt(block.balance).toString(16), 16)
- const signature = hex.toBytes(block.signature)
- const data = new Uint8Array([3, ...purpose, ...coin, ...account, ...previous, ...link, ...representative, ...balance, ...signature])
- const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout)
- const response = await transport.send(161, 3, 0, 0, data).then((res) => bytes.toDec(res)).catch((err) => err.statusCode)
- await transport.close()
- return { status: LEDGER_STATUS_CODES[response] }
- }
- async sign (index = 0, input) {
+ throw new ReferenceError("Cannot cache unsigned block");
+ }
+ const purpose = dec.toBytes(BIP44_PURPOSE + HARDENED_OFFSET, 4);
+ const coin = dec.toBytes(BIP44_COIN_NANO + HARDENED_OFFSET, 4);
+ const account = dec.toBytes(index + HARDENED_OFFSET, 4);
+ const previous = hex.toBytes(block.previous);
+ const link = hex.toBytes(block.link);
+ const representative = hex.toBytes(block.representative.publicKey);
+ const balance = hex.toBytes(BigInt(block.balance).toString(16), 16);
+ const signature = hex.toBytes(block.signature);
+ const data = new Uint8Array([3, ...purpose, ...coin, ...account, ...previous, ...link, ...representative, ...balance, ...signature]);
+ const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout);
+ const response = await transport.send(161, 3, 0, 0, data).then((res) => bytes.toDec(res)).catch((err) => err.statusCode);
+ await transport.close();
+ return { status: LEDGER_STATUS_CODES[response] };
+ }
+ async sign(index = 0, input) {
if (typeof index !== "number" || index < 0 || index >= HARDENED_OFFSET) {
- throw new TypeError("Invalid account index")
+ throw new TypeError("Invalid account index");
}
- const purpose = dec.toBytes(BIP44_PURPOSE + HARDENED_OFFSET, 4)
- const coin = dec.toBytes(BIP44_COIN_NANO + HARDENED_OFFSET, 4)
- const account = dec.toBytes(index + HARDENED_OFFSET, 4)
- const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout)
+ const purpose = dec.toBytes(BIP44_PURPOSE + HARDENED_OFFSET, 4);
+ const coin = dec.toBytes(BIP44_COIN_NANO + HARDENED_OFFSET, 4);
+ const account = dec.toBytes(index + HARDENED_OFFSET, 4);
+ const transport = await this.DynamicTransport.create(this.openTimeout, this.listenTimeout);
if (typeof input === "string") {
- const nonce = utf8.toBytes(input)
+ const nonce = utf8.toBytes(input);
if (nonce.length !== 16) {
- throw new RangeError("Nonce must be 16-byte string")
+ throw new RangeError("Nonce must be 16-byte string");
}
- const data = new Uint8Array([3, ...purpose, ...coin, ...account, ...nonce])
- const response = await transport.send(161, 5, 0, 0, data).catch((err) => dec.toBytes(err.statusCode))
- await transport.close()
+ const data = new Uint8Array([3, ...purpose, ...coin, ...account, ...nonce]);
+ const response = await transport.send(161, 5, 0, 0, data).catch((err) => dec.toBytes(err.statusCode));
+ await transport.close();
if (response.length === 2) {
- const statusCode2 = bytes.toDec(response)
- const status2 = LEDGER_STATUS_CODES[statusCode2] ?? "UNKNOWN_ERROR"
- return { status: status2, signature: null }
- }
- const signature = bytes.toHex(response.slice(0, 64))
- const statusCode = bytes.toDec(response.slice(-2))
- const status = LEDGER_STATUS_CODES[statusCode]
- return { status, signature }
+ const statusCode2 = bytes.toDec(response);
+ const status2 = LEDGER_STATUS_CODES[statusCode2] ?? "UNKNOWN_ERROR";
+ return { status: status2, signature: null };
+ }
+ const signature = bytes.toHex(response.slice(0, 64));
+ const statusCode = bytes.toDec(response.slice(-2));
+ const status = LEDGER_STATUS_CODES[statusCode];
+ return { status, signature };
} else {
- const previous = hex.toBytes(input.previous)
- const link = hex.toBytes(input.link)
- const representative = hex.toBytes(input.representative.publicKey)
- const balance = hex.toBytes(BigInt(input.balance).toString(16), 16)
- const data = new Uint8Array([3, ...purpose, ...coin, ...account, ...previous, ...link, ...representative, ...balance])
- const response = await transport.send(161, 4, 0, 0, data).catch((err) => dec.toBytes(err.statusCode))
- await transport.close()
+ const previous = hex.toBytes(input.previous);
+ const link = hex.toBytes(input.link);
+ const representative = hex.toBytes(input.representative.publicKey);
+ const balance = hex.toBytes(BigInt(input.balance).toString(16), 16);
+ const data = new Uint8Array([3, ...purpose, ...coin, ...account, ...previous, ...link, ...representative, ...balance]);
+ const response = await transport.send(161, 4, 0, 0, data).catch((err) => dec.toBytes(err.statusCode));
+ await transport.close();
if (response.length === 2) {
- const statusCode2 = bytes.toDec(response)
- const status2 = LEDGER_STATUS_CODES[statusCode2] ?? "UNKNOWN_ERROR"
- return { status: status2, signature: null, hash: null }
+ const statusCode2 = bytes.toDec(response);
+ const status2 = LEDGER_STATUS_CODES[statusCode2] ?? "UNKNOWN_ERROR";
+ return { status: status2, signature: null, hash: null };
}
- const hash2 = bytes.toHex(response.slice(0, 32))
- const signature = bytes.toHex(response.slice(32, 96))
- const statusCode = bytes.toDec(response.slice(-2))
- const status = LEDGER_STATUS_CODES[statusCode]
- return { status, signature, hash: hash2 }
+ const hash2 = bytes.toHex(response.slice(0, 32));
+ const signature = bytes.toHex(response.slice(32, 96));
+ const statusCode = bytes.toDec(response.slice(-2));
+ const status = LEDGER_STATUS_CODES[statusCode];
+ return { status, signature, hash: hash2 };
}
}
- async updateCache (index, input, node) {
+ async updateCache(index, input, node) {
if (typeof input === "string" && node?.constructor === Rpc) {
const data = {
"json_block": "true",
"hash": input
- }
- const res = await node.call("block_info", data)
+ };
+ const res = await node.call("block_info", data);
if (!res || res.ok === false) {
- throw new Error(`Unable to fetch block info`, res)
+ throw new Error(`Unable to fetch block info`, res);
}
- input = res.contents
+ input = res.contents;
}
- return this.cacheBlock(index, input)
+ return this.cacheBlock(index, input);
}
- }
+ };
}
-})
+});
// dist/lib/block.js
-function validate (block) {
+function validate(block) {
if (block.account == null) {
- throw new Error("Account missing")
+ throw new Error("Account missing");
}
if (block.previous == null || block.previous === "") {
- throw new Error("Frontier missing")
+ throw new Error("Frontier missing");
}
if (block.representative == null) {
- throw new Error("Representative missing")
+ throw new Error("Representative missing");
}
if (block.balance == null) {
- throw new Error("Balance missing")
+ throw new Error("Balance missing");
}
if (block.balance < 0) {
- throw new Error("Negative balance")
+ throw new Error("Negative balance");
}
switch (block.constructor) {
case SendBlock: {
if (block.link == null || block.link === "") {
- throw new Error("Recipient missing")
+ throw new Error("Recipient missing");
}
- break
+ break;
}
case ReceiveBlock: {
if (block.link == null) {
- throw new Error("Origin send block hash missing")
+ throw new Error("Origin send block hash missing");
}
- break
+ break;
}
case ChangeBlock: {
if (block.link == null) {
- throw new Error("Change block link missing")
+ throw new Error("Change block link missing");
}
if (+block.link !== 0) {
- throw new Error("Invalid change block link")
+ throw new Error("Invalid change block link");
}
- break
+ break;
}
}
}
-var Block, SendBlock, ReceiveBlock, ChangeBlock
+var Block, SendBlock, ReceiveBlock, ChangeBlock;
var init_block = __esm({
- "dist/lib/block.js" () {
- "use strict"
- init_constants()
- init_account()
- init_blake2b()
- init_convert()
- init_nano_nacl()
- init_pool()
- init_workers()
+ "dist/lib/block.js"() {
+ "use strict";
+ init_constants();
+ init_account();
+ init_blake2b();
+ init_convert();
+ init_nano_nacl();
+ init_pool();
+ init_workers();
Block = class _Block {
static #pool = new Pool(powgpu_default);
- account
+ account;
type = "state";
constructor(account) {
if (this.constructor === _Block) {
- throw new Error("Block is an abstract class and cannot be instantiated directly.")
+ throw new Error("Block is an abstract class and cannot be instantiated directly.");
}
if (account.constructor === Account) {
- this.account = account
+ this.account = account;
} else if (typeof account === "string") {
- this.account = Account.fromAddress(account)
+ this.account = Account.fromAddress(account);
} else {
- throw new TypeError("Invalid account")
+ throw new TypeError("Invalid account");
}
}
/**
*
* @returns {string} JSON representation of the block
*/
- json () {
+ json() {
return {
"type": this.type,
"account": this.account.address,
"link": this.link,
"signature": this.signature ?? "",
"work": this.work ?? ""
- }
+ };
}
/**
* Hashes the block using Blake2b.
*
* @returns {Promise<string>} Block data hashed to a byte array
*/
- async hash () {
+ async hash() {
const data = [
PREAMBLE,
this.account.publicKey,
this.representative.publicKey,
dec.toHex(this.balance, 32),
this.link
- ]
- const hash2 = new Blake2b(32)
- data.forEach((str) => hash2.update(hex.toBytes(str)))
- return hash2.digest("hex").toUpperCase()
+ ];
+ const hash2 = new Blake2b(32);
+ data.forEach((str) => hash2.update(hex.toBytes(str)));
+ return hash2.digest("hex").toUpperCase();
}
/**
* Calculates proof-of-work using a pool of WebGL workers.
*
* A successful response sets the `work` property.
*/
- async pow () {
+ async pow() {
const data = {
"hash": this.previous,
"threshold": this instanceof SendBlock || this instanceof ChangeBlock ? THRESHOLD_SEND : THRESHOLD_RECEIVE
- }
- const [{ work }] = await _Block.#pool.assign([data])
- this.work = work
+ };
+ const [{ work }] = await _Block.#pool.assign([data]);
+ this.work = work;
}
- async sign (input, block) {
+ async sign(input, block) {
if (typeof input === "number") {
- const index = input
- const { Ledger: Ledger2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports))
- const ledger = await Ledger2.init()
- await ledger.open()
+ const index = input;
+ const { Ledger: Ledger2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports));
+ const ledger = await Ledger2.init();
+ await ledger.open();
if (block) {
try {
- await ledger.updateCache(index, block)
+ await ledger.updateCache(index, block);
} catch (err) {
- console.warn("Error updating Ledger cache of previous block, attempting signature anyway", err)
+ console.warn("Error updating Ledger cache of previous block, attempting signature anyway", err);
}
}
- const result = await ledger.sign(index, this)
+ const result = await ledger.sign(index, this);
if (result.status !== "OK") {
- throw new Error(result.status)
+ throw new Error(result.status);
}
- this.signature = result.signature
+ this.signature = result.signature;
} else {
- const key = input ?? this.account.privateKey
+ const key = input ?? this.account.privateKey;
if (key == null) {
- throw new Error("No valid key found to sign block")
+ throw new Error("No valid key found to sign block");
}
- const account = await Account.fromPrivateKey(key)
+ const account = await Account.fromPrivateKey(key);
try {
- const signature = NanoNaCl.detached(hex.toBytes(await this.hash()), hex.toBytes(`${account.privateKey}`))
- this.signature = signature
+ const signature = NanoNaCl.detached(hex.toBytes(await this.hash()), hex.toBytes(`${account.privateKey}`));
+ this.signature = signature;
} catch (err) {
- throw new Error(`Failed to sign block with key ${key}: ${err}`)
+ throw new Error(`Failed to sign block with key ${key}: ${err}`);
}
}
}
* @param {Rpc|string|URL} rpc - RPC node information required to call `process`
* @returns {Promise<string>} Hash of the processed block
*/
- async process (rpc) {
+ async process(rpc) {
if (!this.signature) {
- throw new Error("Block is missing signature. Use sign() and try again.")
+ throw new Error("Block is missing signature. Use sign() and try again.");
}
if (!this.work == null) {
- throw new Error("Block is missing proof-of-work. Generate PoW and try again.")
+ throw new Error("Block is missing proof-of-work. Generate PoW and try again.");
}
const data = {
"subtype": this.subtype,
"json_block": "true",
"block": this.json()
- }
- const res = await rpc.call("process", data)
+ };
+ const res = await rpc.call("process", data);
if (res.hash == null) {
- throw new Error("Block could not be processed", res)
+ throw new Error("Block could not be processed", res);
}
- return res.hash
+ return res.hash;
}
/**
* Verifies the signature of the block. If a key is not provided, the public
* @param {string} [key] - Hexadecimal-formatted public key to use for verification
* @returns {boolean} True if block was signed by the matching private key
*/
- async verify (key) {
- key ??= this.account.publicKey
+ async verify(key) {
+ key ??= this.account.publicKey;
if (!key) {
- throw new Error("Provide a key for block signature verification.")
+ throw new Error("Provide a key for block signature verification.");
}
const data = [
PREAMBLE,
this.representative.publicKey,
dec.toHex(this.balance, 32),
this.link
- ]
- const hash2 = new Blake2b(32)
- data.forEach((str) => hash2.update(hex.toBytes(str)))
- const blockHash = hash2.digest("hex").toUpperCase()
- return NanoNaCl.verify(hex.toBytes(blockHash), hex.toBytes(this.signature ?? ""), hex.toBytes(key))
+ ];
+ const hash2 = new Blake2b(32);
+ data.forEach((str) => hash2.update(hex.toBytes(str)));
+ const blockHash = hash2.digest("hex").toUpperCase();
+ return NanoNaCl.verify(hex.toBytes(blockHash), hex.toBytes(this.signature ?? ""), hex.toBytes(key));
}
- }
+ };
SendBlock = class extends Block {
type = "state";
subtype = "send";
- previous
- representative
- balance
- link
- signature
- work
+ previous;
+ representative;
+ balance;
+ link;
+ signature;
+ work;
constructor(sender, balance, recipient, amount, representative, frontier, work) {
- super(sender)
- this.previous = frontier
- this.representative = Account.fromAddress(representative)
- this.link = Account.fromAddress(recipient).publicKey
- this.work = work ?? ""
- const bigBalance = BigInt(balance)
- const bigAmount = BigInt(amount)
- this.balance = bigBalance - bigAmount
- validate(this)
- }
- }
+ super(sender);
+ this.previous = frontier;
+ this.representative = Account.fromAddress(representative);
+ this.link = Account.fromAddress(recipient).publicKey;
+ this.work = work ?? "";
+ const bigBalance = BigInt(balance);
+ const bigAmount = BigInt(amount);
+ this.balance = bigBalance - bigAmount;
+ validate(this);
+ }
+ };
ReceiveBlock = class extends Block {
type = "state";
subtype = "receive";
- previous
- representative
- balance
- link
- signature
- work
+ previous;
+ representative;
+ balance;
+ link;
+ signature;
+ work;
constructor(recipient, balance, origin, amount, representative, frontier, work) {
- super(recipient)
- this.previous = frontier ?? Account.fromAddress(recipient).publicKey
- this.representative = Account.fromAddress(representative)
- this.link = origin
- this.work = work ?? ""
- const bigBalance = BigInt(balance)
- const bigAmount = BigInt(amount)
- this.balance = bigBalance + bigAmount
- validate(this)
- }
- }
+ super(recipient);
+ this.previous = frontier ?? Account.fromAddress(recipient).publicKey;
+ this.representative = Account.fromAddress(representative);
+ this.link = origin;
+ this.work = work ?? "";
+ const bigBalance = BigInt(balance);
+ const bigAmount = BigInt(amount);
+ this.balance = bigBalance + bigAmount;
+ validate(this);
+ }
+ };
ChangeBlock = class extends Block {
type = "state";
subtype = "change";
- previous
- representative
- balance
+ previous;
+ representative;
+ balance;
link = Account.fromAddress(BURN_ADDRESS).publicKey;
- signature
- work
+ signature;
+ work;
constructor(account, balance, representative, frontier, work) {
- super(account)
- this.previous = frontier
- this.representative = Account.fromAddress(representative)
- this.balance = BigInt(balance)
- this.work = work ?? ""
- validate(this)
+ super(account);
+ this.previous = frontier;
+ this.representative = Account.fromAddress(representative);
+ this.balance = BigInt(balance);
+ this.work = work ?? "";
+ validate(this);
}
- }
+ };
}
-})
+});
// dist/lib/tools.js
-var tools_exports = {}
+var tools_exports = {};
__export(tools_exports, {
Tools: () => Tools,
convert: () => convert,
sign: () => sign,
sweep: () => sweep,
verify: () => verify
-})
-function hash (data, encoding) {
+});
+function hash(data, encoding) {
if (!Array.isArray(data))
- data = [data]
- const hash2 = new Blake2b(32)
+ data = [data];
+ const hash2 = new Blake2b(32);
if (encoding === "hex") {
- data.forEach((str) => hash2.update(hex.toBytes(str)))
+ data.forEach((str) => hash2.update(hex.toBytes(str)));
} else {
- const enc = new TextEncoder()
- data.forEach((str) => hash2.update(enc.encode(str)))
+ const enc = new TextEncoder();
+ data.forEach((str) => hash2.update(enc.encode(str)));
}
- return hash2.digest("hex").toUpperCase()
+ return hash2.digest("hex").toUpperCase();
}
-async function convert (amount, inputUnit, outputUnit) {
+async function convert(amount, inputUnit, outputUnit) {
if (typeof amount === "bigint") {
- amount = amount.toString()
+ amount = amount.toString();
}
if (typeof amount !== "string" || amount === "" || !/^[0-9]*\.?[0-9]*$/.test(amount)) {
- throw new Error("Invalid amount")
+ throw new Error("Invalid amount");
}
- let [i = "", f = ""] = amount.toString().split(".")
- i = i.replace(/^0*/g, "")
- f = f.replace(/0*$/g, "")
- inputUnit = inputUnit.toUpperCase()
- outputUnit = outputUnit.toUpperCase()
+ let [i = "", f = ""] = amount.toString().split(".");
+ i = i.replace(/^0*/g, "");
+ f = f.replace(/0*$/g, "");
+ inputUnit = inputUnit.toUpperCase();
+ outputUnit = outputUnit.toUpperCase();
if (!(inputUnit in UNITS)) {
- throw new Error(`Unknown denomination ${inputUnit}, expected one of the following: ${Object.keys(UNITS)}`)
+ throw new Error(`Unknown denomination ${inputUnit}, expected one of the following: ${Object.keys(UNITS)}`);
}
if (!(outputUnit in UNITS)) {
- throw new Error(`Unknown denomination ${outputUnit}, expected one of the following: ${Object.keys(UNITS)}`)
+ throw new Error(`Unknown denomination ${outputUnit}, expected one of the following: ${Object.keys(UNITS)}`);
}
- i = `${i}${f.slice(0, UNITS[inputUnit])}`.padEnd(i.length + UNITS[inputUnit], "0")
- f = f.slice(UNITS[inputUnit])
+ i = `${i}${f.slice(0, UNITS[inputUnit])}`.padEnd(i.length + UNITS[inputUnit], "0");
+ f = f.slice(UNITS[inputUnit]);
if (i.length > 39) {
- throw new Error("Amount exceeds Nano limits")
+ throw new Error("Amount exceeds Nano limits");
}
if (i.length < 1) {
- throw new Error("Amount must be at least 1 raw")
+ throw new Error("Amount must be at least 1 raw");
}
if (f.length > 0) {
- throw new Error("Amount contains fractional raw")
+ throw new Error("Amount contains fractional raw");
}
if (UNITS[outputUnit] !== 0) {
- f = i.padStart(40, "0").slice(-UNITS[outputUnit]) + f
- i = i.slice(0, -UNITS[outputUnit])
+ f = i.padStart(40, "0").slice(-UNITS[outputUnit]) + f;
+ i = i.slice(0, -UNITS[outputUnit]);
}
- i = i.replace(/^0*/g, "") ?? "0"
- f = f.replace(/0*$/g, "")
- return `${i}${f ? "." : ""}${f}`
+ i = i.replace(/^0*/g, "") ?? "0";
+ f = f.replace(/0*$/g, "");
+ return `${i}${f ? "." : ""}${f}`;
}
-async function sign (key, ...input) {
- const account = await Account.fromPrivateKey(key)
- const data = hash(input)
- const signature = NanoNaCl.detached(hex.toBytes(data), hex.toBytes(`${account.privateKey}`))
- return signature
+async function sign(key, ...input) {
+ const account = await Account.fromPrivateKey(key);
+ const data = hash(input);
+ const signature = NanoNaCl.detached(hex.toBytes(data), hex.toBytes(`${account.privateKey}`));
+ return signature;
}
-async function sweep (rpc, wallet, recipient, from2 = 0, to = from2) {
+async function sweep(rpc, wallet, recipient, from2 = 0, to = from2) {
if (rpc == null || wallet == null || recipient == null) {
- throw new ReferenceError("Missing required sweep arguments")
+ throw new ReferenceError("Missing required sweep arguments");
}
if (typeof rpc === "string" || rpc.constructor === URL) {
- rpc = new Rpc(rpc)
+ rpc = new Rpc(rpc);
}
if (rpc.constructor !== Rpc) {
- throw new TypeError("RPC must be a valid node")
+ throw new TypeError("RPC must be a valid node");
}
- const blockQueue = []
- const results = []
- const recipientAccount = Account.fromAddress(recipient)
- const accounts = await wallet.refresh(rpc, from2, to)
+ const blockQueue = [];
+ const results = [];
+ const recipientAccount = Account.fromAddress(recipient);
+ const accounts = await wallet.refresh(rpc, from2, to);
for (const account of accounts) {
if (account.representative?.address && account.frontier) {
- const block = new SendBlock(account, account.balance?.toString() ?? "0", recipientAccount.address, account.balance?.toString() ?? "0", account.representative.address, account.frontier)
+ const block = new SendBlock(account, account.balance?.toString() ?? "0", recipientAccount.address, account.balance?.toString() ?? "0", account.representative.address, account.frontier);
const blockRequest = new Promise(async (resolve) => {
try {
- await block.pow()
- await block.sign()
- const hash2 = await block.process(rpc)
- results.push({ status: "success", address: block.account.address, message: hash2 })
+ await block.pow();
+ await block.sign();
+ const hash2 = await block.process(rpc);
+ results.push({ status: "success", address: block.account.address, message: hash2 });
} catch (err) {
- results.push({ status: "error", address: block.account.address, message: err.message })
+ results.push({ status: "error", address: block.account.address, message: err.message });
} finally {
- resolve()
+ resolve();
}
- })
- blockQueue.push(blockRequest)
+ });
+ blockQueue.push(blockRequest);
}
}
- await Promise.allSettled(blockQueue)
- return results
+ await Promise.allSettled(blockQueue);
+ return results;
}
-async function verify (key, signature, ...input) {
- const data = hash(input)
+async function verify(key, signature, ...input) {
+ const data = hash(input);
try {
- return await NanoNaCl.verify(hex.toBytes(data), hex.toBytes(signature), hex.toBytes(key))
+ return await NanoNaCl.verify(hex.toBytes(data), hex.toBytes(signature), hex.toBytes(key));
} catch (err) {
- console.error(err)
- return false
+ console.error(err);
+ return false;
}
}
-var Tools
+var Tools;
var init_tools = __esm({
- "dist/lib/tools.js" () {
- "use strict"
- init_account()
- init_blake2b()
- init_constants()
- init_convert()
- init_rpc()
- init_block()
- init_nano_nacl()
- Tools = { convert, sign, sweep, verify }
- }
-})
+ "dist/lib/tools.js"() {
+ "use strict";
+ init_account();
+ init_blake2b();
+ init_constants();
+ init_convert();
+ init_rpc();
+ init_block();
+ init_nano_nacl();
+ Tools = { convert, sign, sweep, verify };
+ }
+});
// dist/main.js
-var main_exports = {}
+var main_exports = {};
__export(main_exports, {
Account: () => Account,
Bip44Wallet: () => Bip44Wallet,
Blake2bWallet: () => Blake2bWallet,
ChangeBlock: () => ChangeBlock,
LedgerWallet: () => LedgerWallet,
- Pow: () => Pow,
+ PowGl: () => PowGl,
PowGpu: () => PowGpu,
ReceiveBlock: () => ReceiveBlock,
Rolodex: () => Rolodex,
Safe: () => Safe,
SendBlock: () => SendBlock,
Tools: () => Tools
-})
-init_account()
-init_blake2b()
-init_block()
-init_powgl()
-init_powgpu()
-init_rpc()
+});
+init_account();
+init_blake2b();
+init_block();
+init_powgl();
+init_powgpu();
+init_rpc();
// dist/lib/rolodex.js
-init_account()
+init_account();
var Rolodex = class {
#entries = [];
/**
* @param {string} name - Alias for the address
* @param {string} address - Nano account address
*/
- async add (name, address) {
+ async add(name, address) {
if (name == null || name === "") {
- throw new Error("Name is required for rolodex entries")
+ throw new Error("Name is required for rolodex entries");
}
if (typeof name !== "string") {
- throw new Error("Name must be a string for rolodex entries")
+ throw new Error("Name must be a string for rolodex entries");
}
if (address == null || address === "") {
- throw new Error("Address is required for rolodex entries")
+ throw new Error("Address is required for rolodex entries");
}
if (typeof address !== "string") {
- throw new Error("Address must be a string for rolodex entries")
+ throw new Error("Address must be a string for rolodex entries");
}
- name = name.replaceAll("/", "\\u002f").replaceAll("<", "\\u003c").replaceAll(">", "\\u003d").replaceAll("\\", "\\u005c")
- const account = Account.fromAddress(address)
- const nameResult = this.#entries.find((e) => e.name === name)
- const accountResult = this.#entries.find((e) => e.account.address === address)
+ name = name.replaceAll("/", "\\u002f").replaceAll("<", "\\u003c").replaceAll(">", "\\u003d").replaceAll("\\", "\\u005c");
+ const account = Account.fromAddress(address);
+ const nameResult = this.#entries.find((e) => e.name === name);
+ const accountResult = this.#entries.find((e) => e.account.address === address);
if (!accountResult) {
- this.#entries.push({ name, account })
+ this.#entries.push({ name, account });
} else if (!nameResult) {
- accountResult.name = name
+ accountResult.name = name;
}
}
/**
* @param {string} address - Nano account address
* @returns {string|null} Name associated with the address, or null if not found
*/
- getName (address) {
- const result = this.#entries.find((e) => e.account.address === address)
- return result?.name ?? null
+ getName(address) {
+ const result = this.#entries.find((e) => e.account.address === address);
+ return result?.name ?? null;
}
/**
* Gets all Nano addresses associated with a name from the rolodex.
* @param {string} name - Alias to look up
* @returns {string[]} List of Nano addresses associated with the name
*/
- getAddresses (name) {
- const entries = this.#entries.filter((e) => e.name === name)
- return entries.map((a) => a.account.address)
+ getAddresses(name) {
+ const entries = this.#entries.filter((e) => e.name === name);
+ return entries.map((a) => a.account.address);
}
/**
* Gets all names stored in the rolodex.
*
* @returns {string[]} List of names stored in the rolodex
*/
- getAllNames () {
- return this.#entries.map((e) => e.name)
+ getAllNames() {
+ return this.#entries.map((e) => e.name);
}
/**
* Verifies whether the public key of any Nano address saved under a specific
* @param {...string} data - Signed data to verify
* @returns {Promise<boolean>} True if the signature was used to sign the data, else false
*/
- async verify (name, signature, ...data) {
- const { Tools: Tools2 } = await Promise.resolve().then(() => (init_tools(), tools_exports))
- const entries = this.#entries.filter((e) => e.name === name)
+ async verify(name, signature, ...data) {
+ const { Tools: Tools2 } = await Promise.resolve().then(() => (init_tools(), tools_exports));
+ const entries = this.#entries.filter((e) => e.name === name);
for (const entry of entries) {
- const key = entry.account.publicKey
- const verified = await Tools2.verify(key, signature, ...data)
+ const key = entry.account.publicKey;
+ const verified = await Tools2.verify(key, signature, ...data);
if (verified) {
- return true
+ return true;
}
}
- return false
+ return false;
}
-}
+};
// dist/main.js
-init_safe()
-init_tools()
+init_safe();
+init_tools();
// dist/lib/wallet.js
-init_account()
-init_blake2b()
+init_account();
+init_blake2b();
// dist/lib/bip39-wordlist.js
var Bip39Words = Object.freeze([
"zero",
"zone",
"zoo"
-])
+]);
// dist/lib/bip39-mnemonic.js
-init_convert()
-init_constants()
-init_entropy()
-var { subtle: subtle2 } = globalThis.crypto
+init_convert();
+init_constants();
+init_entropy();
+var { subtle: subtle2 } = globalThis.crypto;
var Bip39Mnemonic = class _Bip39Mnemonic {
static #isInternal = false;
#bip44Seed = "";
#blake2bSeed = "";
#phrase = "";
- get phrase () {
- return this.#phrase.normalize("NFKD")
+ get phrase() {
+ return this.#phrase.normalize("NFKD");
}
constructor() {
if (!_Bip39Mnemonic.#isInternal) {
- throw new Error(`Bip39Mnemonic cannot be instantiated directly. Use 'await Bip39Mnemonic.fromPhrase()' or 'await Bip39Mnemonic.fromEntropy() instead.`)
+ throw new Error(`Bip39Mnemonic cannot be instantiated directly. Use 'await Bip39Mnemonic.fromPhrase()' or 'await Bip39Mnemonic.fromEntropy() instead.`);
}
- _Bip39Mnemonic.#isInternal = false
+ _Bip39Mnemonic.#isInternal = false;
}
/**
* Imports and validates an existing mnemonic phrase.
* @param {string} phrase - String of 12, 15, 18, 21, or 24 words
* @returns {string} Mnemonic phrase validated using the BIP-39 wordlist
*/
- static async fromPhrase (phrase) {
- _Bip39Mnemonic.#isInternal = true
- const self = new this()
- const isValid = await _Bip39Mnemonic.validate(phrase)
+ static async fromPhrase(phrase) {
+ _Bip39Mnemonic.#isInternal = true;
+ const self = new this();
+ const isValid = await _Bip39Mnemonic.validate(phrase);
if (isValid) {
- self.#phrase = phrase.normalize("NFKD")
- return self
+ self.#phrase = phrase.normalize("NFKD");
+ return self;
} else {
- throw new Error("Invalid mnemonic phrase.")
+ throw new Error("Invalid mnemonic phrase.");
}
}
/**
* @param {string} entropy - Hexadecimal string
* @returns {string} Mnemonic phrase created using the BIP-39 wordlist
*/
- static async fromEntropy (entropy) {
- const e = await Entropy.import(entropy)
- const checksum = await this.checksum(e)
- let concatenation = `${e.bits}${checksum}`
- const words = []
+ static async fromEntropy(entropy) {
+ const e = await Entropy.import(entropy);
+ const checksum = await this.checksum(e);
+ let concatenation = `${e.bits}${checksum}`;
+ const words = [];
while (concatenation.length > 0) {
- const wordBits = concatenation.substring(0, 11)
- const wordIndex = parseInt(wordBits, 2)
- words.push(Bip39Words[wordIndex])
- concatenation = concatenation.substring(11)
+ const wordBits = concatenation.substring(0, 11);
+ const wordIndex = parseInt(wordBits, 2);
+ words.push(Bip39Words[wordIndex]);
+ concatenation = concatenation.substring(11);
}
- const sentence = words.join(" ")
- return _Bip39Mnemonic.fromPhrase(sentence)
+ const sentence = words.join(" ");
+ return _Bip39Mnemonic.fromPhrase(sentence);
}
/**
* SHA-256 hash of entropy that is appended to the entropy and subsequently
* @param {Entropy} entropy - Cryptographically strong pseudorandom data of length N bits
* @returns {Promise<string>} First N/32 bits of the hash as a hexadecimal string
*/
- static async checksum (entropy) {
- const hashBuffer = await subtle2.digest("SHA-256", entropy.bytes)
- const hashBytes = new Uint8Array(hashBuffer)
- const hashBits = bytes.toBin(hashBytes)
- const checksumLength = entropy.bits.length / 32
- const checksum = hashBits.substring(0, checksumLength)
- return checksum
+ static async checksum(entropy) {
+ const hashBuffer = await subtle2.digest("SHA-256", entropy.bytes);
+ const hashBytes = new Uint8Array(hashBuffer);
+ const hashBits = bytes.toBin(hashBytes);
+ const checksumLength = entropy.bits.length / 32;
+ const checksum = hashBits.substring(0, checksumLength);
+ return checksum;
}
/**
* Validates a mnemonic phrase.
* @param {string} mnemonic - Mnemonic phrase to validate
* @returns {boolean} True if the mnemonic phrase is valid
*/
- static async validate (mnemonic) {
- const words = mnemonic.normalize("NFKD").split(" ")
+ static async validate(mnemonic) {
+ const words = mnemonic.normalize("NFKD").split(" ");
if (words.length % 3 !== 0) {
- return false
+ return false;
}
const wordBits = words.map((word) => {
- const wordIndex = Bip39Words.indexOf(word)
+ const wordIndex = Bip39Words.indexOf(word);
if (wordIndex === -1) {
- return false
- }
- return dec.toBin(wordIndex, 11)
- }).join("")
- const checksumLength = wordBits.length / 33
- const entropyLength = wordBits.length - checksumLength
- const entropyBits = wordBits.substring(0, entropyLength)
- const checksumBits = wordBits.substring(entropyLength)
+ return false;
+ }
+ return dec.toBin(wordIndex, 11);
+ }).join("");
+ const checksumLength = wordBits.length / 33;
+ const entropyLength = wordBits.length - checksumLength;
+ const entropyBits = wordBits.substring(0, entropyLength);
+ const checksumBits = wordBits.substring(entropyLength);
if (entropyBits == null || entropyBits.length < 128 || entropyBits.length > 256 || entropyBits.length % 32 !== 0) {
- return false
+ return false;
}
- const entropy = await Entropy.import(bin.toBytes(entropyBits))
- const expectedChecksum = await this.checksum(entropy)
+ const entropy = await Entropy.import(bin.toBytes(entropyBits));
+ const expectedChecksum = await this.checksum(entropy);
if (expectedChecksum !== checksumBits) {
- return false
+ return false;
}
- return true
+ return true;
}
/**
* Converts the mnemonic phrase to a BIP-39 seed.
* @param {string} [passphrase=''] - Used as the PBKDF2 salt. Default: ""
* @returns {string} Hexadecimal seed
*/
- async toBip39Seed (passphrase) {
+ async toBip39Seed(passphrase) {
if (this.#blake2bSeed === "") {
if (passphrase == null || typeof passphrase !== "string") {
- passphrase = ""
+ passphrase = "";
}
- passphrase = `mnemonic${passphrase.normalize("NFKD")}`
+ passphrase = `mnemonic${passphrase.normalize("NFKD")}`;
const derivationAlgorithm = {
name: "PBKDF2",
hash: "SHA-512",
salt: utf8.toBytes(passphrase),
iterations: BIP39_ITERATIONS
- }
- const phraseKey = await subtle2.importKey("raw", utf8.toBytes(this.phrase), "PBKDF2", false, ["deriveBits", "deriveKey"])
+ };
+ const phraseKey = await subtle2.importKey("raw", utf8.toBytes(this.phrase), "PBKDF2", false, ["deriveBits", "deriveKey"]);
const derivedKeyType = {
name: "HMAC",
hash: "SHA-512",
length: 512
- }
- const isSeedKeyExtractable = true
- const seedKeyUsages = ["sign"]
- const seedKey = await subtle2.deriveKey(derivationAlgorithm, phraseKey, derivedKeyType, isSeedKeyExtractable, seedKeyUsages)
- const seedBuffer = await subtle2.exportKey("raw", seedKey)
- const seedBytes = new Uint8Array(seedBuffer)
- const seed = bytes.toHex(seedBytes)
- this.#bip44Seed = seed
+ };
+ const isSeedKeyExtractable = true;
+ const seedKeyUsages = ["sign"];
+ const seedKey = await subtle2.deriveKey(derivationAlgorithm, phraseKey, derivedKeyType, isSeedKeyExtractable, seedKeyUsages);
+ const seedBuffer = await subtle2.exportKey("raw", seedKey);
+ const seedBytes = new Uint8Array(seedBuffer);
+ const seed = bytes.toHex(seedBytes);
+ this.#bip44Seed = seed;
}
- return this.#bip44Seed
+ return this.#bip44Seed;
}
/**
* Converts the mnemonic phrase to a BLAKE2b seed.
*
* @returns {string} Hexadecimal seed
*/
- async toBlake2bSeed () {
+ async toBlake2bSeed() {
if (this.#blake2bSeed === "") {
- const wordArray = this.phrase.split(" ")
+ const wordArray = this.phrase.split(" ");
const bits = wordArray.map((w) => {
- const wordIndex = Bip39Words.indexOf(w)
+ const wordIndex = Bip39Words.indexOf(w);
if (wordIndex === -1) {
- return false
+ return false;
}
- return dec.toBin(wordIndex, 11)
- }).join("")
- const dividerIndex = Math.floor(bits.length / 33) * 32
- const entropyBits = bits.slice(0, dividerIndex)
- const entropyBytes = entropyBits.match(/(.{1,8})/g)?.map((bin2) => parseInt(bin2, 2))
+ return dec.toBin(wordIndex, 11);
+ }).join("");
+ const dividerIndex = Math.floor(bits.length / 33) * 32;
+ const entropyBits = bits.slice(0, dividerIndex);
+ const entropyBytes = entropyBits.match(/(.{1,8})/g)?.map((bin2) => parseInt(bin2, 2));
if (entropyBytes == null) {
- throw new Error("Invalid mnemonic phrase")
+ throw new Error("Invalid mnemonic phrase");
}
- this.#blake2bSeed = bytes.toHex(Uint8Array.from(entropyBytes))
+ this.#blake2bSeed = bytes.toHex(Uint8Array.from(entropyBytes));
}
- return this.#blake2bSeed
+ return this.#blake2bSeed;
}
-}
+};
// dist/lib/wallet.js
-init_constants()
-init_entropy()
-init_pool()
-init_rpc()
-init_safe()
-init_workers()
+init_constants();
+init_entropy();
+init_pool();
+init_rpc();
+init_safe();
+init_workers();
var Wallet = class _Wallet {
- #accounts
- #id
+ #accounts;
+ #id;
#locked = true;
- #mnemonic
- #poolNanoNacl
- #safe
- #seed
- get id () {
- return this.#id.hex
+ #mnemonic;
+ #poolNanoNacl;
+ #safe;
+ #seed;
+ get id() {
+ return this.#id.hex;
}
- get isLocked () {
- return this.#locked
+ get isLocked() {
+ return this.#locked;
}
- get isUnlocked () {
- return !this.#locked
+ get isUnlocked() {
+ return !this.#locked;
}
- get mnemonic () {
+ get mnemonic() {
if (this.#mnemonic instanceof Bip39Mnemonic) {
- return this.#mnemonic.phrase
+ return this.#mnemonic.phrase;
}
- return ""
+ return "";
}
- get seed () {
+ get seed() {
if (typeof this.#seed === "string") {
- return this.#seed
+ return this.#seed;
}
- return ""
+ return "";
}
constructor(id2, seed, mnemonic) {
if (this.constructor === _Wallet) {
- throw new Error("Wallet is an abstract class and cannot be instantiated directly.")
+ throw new Error("Wallet is an abstract class and cannot be instantiated directly.");
}
- this.#accounts = []
- this.#id = id2
- this.#mnemonic = mnemonic ?? null
- this.#poolNanoNacl = new Pool(nano_nacl_default)
- this.#safe = new Safe()
- this.#seed = seed ?? null
+ this.#accounts = [];
+ this.#id = id2;
+ this.#mnemonic = mnemonic ?? null;
+ this.#poolNanoNacl = new Pool(nano_nacl_default);
+ this.#safe = new Safe();
+ this.#seed = seed ?? null;
}
/**
* Retrieves accounts from a wallet using its child key derivation function.
* @param {number} from - Start index of secret keys. Default: 0
* @param {number} to - End index of secret keys. Default: `from`
*/
- async accounts (from2 = 0, to = from2) {
+ async accounts(from2 = 0, to = from2) {
if (from2 > to) {
- const swap = from2
- from2 = to
- to = swap
+ const swap = from2;
+ from2 = to;
+ to = swap;
}
- const indexes = []
+ const indexes = [];
for (let i = from2; i <= to; i++) {
if (this.#accounts[i] == null) {
- indexes.push(i)
+ indexes.push(i);
}
}
if (indexes.length > 0) {
- let results = await this.ckd(indexes)
- const data = []
- results.forEach((r) => data.push({ privateKey: r.privateKey, index: r.index }))
- const keypairs = await this.#poolNanoNacl.assign(data)
+ let results = await this.ckd(indexes);
+ const data = [];
+ results.forEach((r) => data.push({ privateKey: r.privateKey, index: r.index }));
+ const keypairs = await this.#poolNanoNacl.assign(data);
for (const keypair of keypairs) {
if (keypair.privateKey == null)
- throw new RangeError("Account private key missing")
+ throw new RangeError("Account private key missing");
if (keypair.publicKey == null)
- throw new RangeError("Account public key missing")
+ throw new RangeError("Account public key missing");
if (keypair.index == null)
- throw new RangeError("Account keys derived but index missing")
- const { privateKey, publicKey, index } = keypair
- this.#accounts[keypair.index] = Account.fromKeypair(privateKey, publicKey, index)
+ throw new RangeError("Account keys derived but index missing");
+ const { privateKey, publicKey, index } = keypair;
+ this.#accounts[keypair.index] = Account.fromKeypair(privateKey, publicKey, index);
}
}
- return this.#accounts.slice(from2, to + 1)
+ return this.#accounts.slice(from2, to + 1);
}
/**
* Fetches the lowest-indexed unopened account from a wallet in sequential
* @param {number} from - Account index from which to start the search
* @returns {Promise<Account>} The lowest-indexed unopened account belonging to the wallet
*/
- async getNextNewAccount (rpc, batchSize = ADDRESS_GAP, from2 = 0) {
+ async getNextNewAccount(rpc, batchSize = ADDRESS_GAP, from2 = 0) {
if (!Number.isSafeInteger(batchSize) || batchSize < 1) {
- throw new RangeError(`Invalid batch size ${batchSize}`)
+ throw new RangeError(`Invalid batch size ${batchSize}`);
}
- const accounts = await this.accounts(from2, from2 + batchSize - 1)
- const addresses = accounts.map(({ address }) => address)
+ const accounts = await this.accounts(from2, from2 + batchSize - 1);
+ const addresses = accounts.map(({ address }) => address);
const data = {
"accounts": addresses
- }
- const { errors } = await rpc.call("accounts_frontiers", data)
+ };
+ const { errors } = await rpc.call("accounts_frontiers", data);
for (const key of Object.keys(errors ?? {})) {
- const value = errors[key]
+ const value = errors[key];
if (value === "Account not found") {
- return Account.fromAddress(key)
+ return Account.fromAddress(key);
}
}
- return await this.getNextNewAccount(rpc, batchSize, from2 + batchSize)
+ return await this.getNextNewAccount(rpc, batchSize, from2 + batchSize);
}
/**
* Refreshes wallet account balances, frontiers, and representatives from the
* @param {Rpc|string|URL} rpc - RPC node information required to refresh accounts, calculate PoW, and process blocks
* @returns {Promise<Account[]>} Accounts with updated balances, frontiers, and representatives
*/
- async refresh (rpc, from2 = 0, to = from2) {
+ async refresh(rpc, from2 = 0, to = from2) {
if (typeof rpc === "string" || rpc.constructor === URL) {
- rpc = new Rpc(rpc)
+ rpc = new Rpc(rpc);
}
if (rpc.constructor !== Rpc) {
- throw new TypeError("RPC must be a valid node")
+ throw new TypeError("RPC must be a valid node");
}
- const accounts = await this.accounts(from2, to)
+ const accounts = await this.accounts(from2, to);
for (let i = 0; i < accounts.length; i++) {
try {
- await accounts[i].refresh(rpc)
+ await accounts[i].refresh(rpc);
} catch (err) {
- accounts.splice(i--, 1)
+ accounts.splice(i--, 1);
}
}
- return accounts
+ return accounts;
}
- async lock (passkey) {
- let success = true
+ async lock(passkey) {
+ let success = true;
try {
const data = {
id: this.id,
mnemonic: null,
seed: null
- }
+ };
if (this.#mnemonic instanceof Bip39Mnemonic) {
- data.mnemonic = this.#mnemonic.phrase
+ data.mnemonic = this.#mnemonic.phrase;
}
if (typeof this.#seed === "string") {
- data.seed = this.#seed
+ data.seed = this.#seed;
}
- success &&= await this.#safe.put(this.id, passkey, data)
- await Promise.all(this.#accounts.map((a) => a.lock(passkey)))
+ success &&= await this.#safe.put(this.id, passkey, data);
+ await Promise.all(this.#accounts.map((a) => a.lock(passkey)));
if (!success) {
- throw null
+ throw null;
}
} catch (err) {
- throw new Error("Failed to lock wallet")
+ throw new Error("Failed to lock wallet");
}
- this.#locked = true
- this.#mnemonic = null
- this.#seed = null
- return true
+ this.#locked = true;
+ this.#mnemonic = null;
+ this.#seed = null;
+ return true;
}
- async unlock (passkey) {
+ async unlock(passkey) {
try {
- const { id: id2, mnemonic, seed } = await this.#safe.get(this.id, passkey)
+ const { id: id2, mnemonic, seed } = await this.#safe.get(this.id, passkey);
if (id2 !== this.id) {
- throw null
+ throw null;
}
- await Promise.all(this.#accounts.map((a) => a.unlock(passkey)))
+ await Promise.all(this.#accounts.map((a) => a.unlock(passkey)));
if (mnemonic != null) {
- this.#mnemonic = await Bip39Mnemonic.fromPhrase(mnemonic)
+ this.#mnemonic = await Bip39Mnemonic.fromPhrase(mnemonic);
}
if (seed != null) {
- this.#seed = seed
+ this.#seed = seed;
}
- this.#locked = false
+ this.#locked = false;
} catch (err) {
- throw new Error("Failed to unlock wallet")
+ throw new Error("Failed to unlock wallet");
}
- return true
+ return true;
}
-}
+};
var Bip44Wallet = class _Bip44Wallet extends Wallet {
static #isInternal = false;
static #poolBip44Ckd = new Pool(bip44_ckd_default);
constructor(id2, seed, mnemonic) {
if (!_Bip44Wallet.#isInternal) {
- throw new Error(`Bip44Wallet cannot be instantiated directly. Use 'await Bip44Wallet.create()' instead.`)
+ throw new Error(`Bip44Wallet cannot be instantiated directly. Use 'await Bip44Wallet.create()' instead.`);
}
- _Bip44Wallet.#isInternal = false
- super(id2, seed, mnemonic)
+ _Bip44Wallet.#isInternal = false;
+ super(id2, seed, mnemonic);
}
- static async create (passkey, salt = "") {
+ static async create(passkey, salt = "") {
try {
- const e = await Entropy.create()
- return await _Bip44Wallet.fromEntropy(passkey, e.hex, salt)
+ const e = await Entropy.create();
+ return await _Bip44Wallet.fromEntropy(passkey, e.hex, salt);
} catch (err) {
- throw new Error(`Error creating new Bip44Wallet: ${err}`)
+ throw new Error(`Error creating new Bip44Wallet: ${err}`);
}
}
- static async fromEntropy (passkey, entropy, salt = "") {
+ static async fromEntropy(passkey, entropy, salt = "") {
try {
- const id2 = await Entropy.create(16)
- const e = await Entropy.import(entropy)
- const m = await Bip39Mnemonic.fromEntropy(e.hex)
- const s = await m.toBip39Seed(salt)
- _Bip44Wallet.#isInternal = true
- const wallet = new this(id2, s, m)
- await wallet.lock(passkey)
- return wallet
+ const id2 = await Entropy.create(16);
+ const e = await Entropy.import(entropy);
+ const m = await Bip39Mnemonic.fromEntropy(e.hex);
+ const s = await m.toBip39Seed(salt);
+ _Bip44Wallet.#isInternal = true;
+ const wallet = new this(id2, s, m);
+ await wallet.lock(passkey);
+ return wallet;
} catch (err) {
- throw new Error(`Error importing Bip44Wallet from entropy: ${err}`)
+ throw new Error(`Error importing Bip44Wallet from entropy: ${err}`);
}
}
- static async fromMnemonic (passkey, mnemonic, salt = "") {
+ static async fromMnemonic(passkey, mnemonic, salt = "") {
try {
- const id2 = await Entropy.create(16)
- const m = await Bip39Mnemonic.fromPhrase(mnemonic)
- const s = await m.toBip39Seed(salt)
- _Bip44Wallet.#isInternal = true
- const wallet = new this(id2, s, m)
- await wallet.lock(passkey)
- return wallet
+ const id2 = await Entropy.create(16);
+ const m = await Bip39Mnemonic.fromPhrase(mnemonic);
+ const s = await m.toBip39Seed(salt);
+ _Bip44Wallet.#isInternal = true;
+ const wallet = new this(id2, s, m);
+ await wallet.lock(passkey);
+ return wallet;
} catch (err) {
- throw new Error(`Error importing Bip44Wallet from mnemonic: ${err}`)
+ throw new Error(`Error importing Bip44Wallet from mnemonic: ${err}`);
}
}
- static async fromSeed (passkey, seed) {
+ static async fromSeed(passkey, seed) {
if (seed.length !== SEED_LENGTH_BIP44) {
- throw new Error(`Expected a ${SEED_LENGTH_BIP44}-character seed, but received ${seed.length}-character string.`)
+ throw new Error(`Expected a ${SEED_LENGTH_BIP44}-character seed, but received ${seed.length}-character string.`);
}
if (!/^[0-9a-fA-F]+$/i.test(seed)) {
- throw new Error("Seed contains invalid hexadecimal characters.")
+ throw new Error("Seed contains invalid hexadecimal characters.");
}
- const id2 = await Entropy.create(16)
- _Bip44Wallet.#isInternal = true
- const wallet = new this(id2, seed)
- await wallet.lock(passkey)
- return wallet
+ const id2 = await Entropy.create(16);
+ _Bip44Wallet.#isInternal = true;
+ const wallet = new this(id2, seed);
+ await wallet.lock(passkey);
+ return wallet;
}
/**
* Retrieves an existing HD wallet from session storage using its ID.
* @param {string} id - Generated when the wallet was initially created
* @returns {Bip44Wallet} Restored locked Bip44Wallet
*/
- static async restore (id2) {
+ static async restore(id2) {
if (typeof id2 !== "string" || id2 === "") {
- throw new TypeError("Wallet ID is required to restore")
+ throw new TypeError("Wallet ID is required to restore");
}
- _Bip44Wallet.#isInternal = true
- return new this(await Entropy.import(id2), "")
+ _Bip44Wallet.#isInternal = true;
+ return new this(await Entropy.import(id2), "");
}
/**
* Derives BIP-44 Nano account private keys.
* @param {number[]} indexes - Indexes of the accounts
* @returns {Promise<Account>}
*/
- async ckd (indexes) {
- const data = []
- indexes.forEach((i) => data.push({ seed: this.seed, index: i }))
- const privateKeys = await _Bip44Wallet.#poolBip44Ckd.assign(data)
- return privateKeys
+ async ckd(indexes) {
+ const data = [];
+ indexes.forEach((i) => data.push({ seed: this.seed, index: i }));
+ const privateKeys = await _Bip44Wallet.#poolBip44Ckd.assign(data);
+ return privateKeys;
}
-}
+};
var Blake2bWallet = class _Blake2bWallet extends Wallet {
static #isInternal = false;
constructor(id2, seed, mnemonic) {
if (!_Blake2bWallet.#isInternal) {
- throw new Error(`Blake2bWallet cannot be instantiated directly. Use 'await Blake2bWallet.create()' instead.`)
+ throw new Error(`Blake2bWallet cannot be instantiated directly. Use 'await Blake2bWallet.create()' instead.`);
}
- _Blake2bWallet.#isInternal = false
- super(id2, seed, mnemonic)
+ _Blake2bWallet.#isInternal = false;
+ super(id2, seed, mnemonic);
}
- static async create (passkey) {
+ static async create(passkey) {
try {
- const seed = await Entropy.create()
- return await _Blake2bWallet.fromSeed(passkey, seed.hex)
+ const seed = await Entropy.create();
+ return await _Blake2bWallet.fromSeed(passkey, seed.hex);
} catch (err) {
- throw new Error(`Error creating new Blake2bWallet: ${err}`)
+ throw new Error(`Error creating new Blake2bWallet: ${err}`);
}
}
- static async fromSeed (passkey, seed) {
+ static async fromSeed(passkey, seed) {
if (seed.length !== SEED_LENGTH_BLAKE2B) {
- throw new Error(`Expected a ${SEED_LENGTH_BLAKE2B}-character seed, but received ${seed.length}-character string.`)
+ throw new Error(`Expected a ${SEED_LENGTH_BLAKE2B}-character seed, but received ${seed.length}-character string.`);
}
if (!/^[0-9a-fA-F]+$/i.test(seed)) {
- throw new Error("Seed contains invalid hexadecimal characters.")
+ throw new Error("Seed contains invalid hexadecimal characters.");
}
- const id2 = await Entropy.create(16)
- const s = seed
- const m = await Bip39Mnemonic.fromEntropy(seed)
- _Blake2bWallet.#isInternal = true
- const wallet = new this(id2, s, m)
- await wallet.lock(passkey)
- return wallet
- }
- static async fromMnemonic (passkey, mnemonic) {
+ const id2 = await Entropy.create(16);
+ const s = seed;
+ const m = await Bip39Mnemonic.fromEntropy(seed);
+ _Blake2bWallet.#isInternal = true;
+ const wallet = new this(id2, s, m);
+ await wallet.lock(passkey);
+ return wallet;
+ }
+ static async fromMnemonic(passkey, mnemonic) {
try {
- const id2 = await Entropy.create(16)
- const m = await Bip39Mnemonic.fromPhrase(mnemonic)
- const s = await m.toBlake2bSeed()
- _Blake2bWallet.#isInternal = true
- const wallet = new this(id2, s, m)
- await wallet.lock(passkey)
- return wallet
+ const id2 = await Entropy.create(16);
+ const m = await Bip39Mnemonic.fromPhrase(mnemonic);
+ const s = await m.toBlake2bSeed();
+ _Blake2bWallet.#isInternal = true;
+ const wallet = new this(id2, s, m);
+ await wallet.lock(passkey);
+ return wallet;
} catch (err) {
- throw new Error(`Error importing Blake2bWallet from mnemonic: ${err}`)
+ throw new Error(`Error importing Blake2bWallet from mnemonic: ${err}`);
}
}
/**
* @param {string} id - Generated when the wallet was initially created
* @returns {Blake2bWallet} Restored locked Blake2bWallet
*/
- static async restore (id2) {
+ static async restore(id2) {
if (typeof id2 !== "string" || id2 === "") {
- throw new TypeError("Wallet ID is required to restore")
+ throw new TypeError("Wallet ID is required to restore");
}
- _Blake2bWallet.#isInternal = true
- return new this(await Entropy.import(id2), "")
+ _Blake2bWallet.#isInternal = true;
+ return new this(await Entropy.import(id2), "");
}
/**
* Derives BLAKE2b account private keys.
* @param {number[]} indexes - Indexes of the accounts
* @returns {Promise<Account>}
*/
- async ckd (indexes) {
+ async ckd(indexes) {
const results = indexes.map((index) => {
- const indexHex = index.toString(16).padStart(8, "0").toUpperCase()
- const inputHex = `${this.seed}${indexHex}`.padStart(72, "0")
- const inputArray = (inputHex.match(/.{1,2}/g) ?? []).map((h) => parseInt(h, 16))
- const inputBytes = Uint8Array.from(inputArray)
- const privateKey = new Blake2b(32).update(inputBytes).digest("hex")
- return { privateKey, index }
- })
- return results
+ const indexHex = index.toString(16).padStart(8, "0").toUpperCase();
+ const inputHex = `${this.seed}${indexHex}`.padStart(72, "0");
+ const inputArray = (inputHex.match(/.{1,2}/g) ?? []).map((h) => parseInt(h, 16));
+ const inputBytes = Uint8Array.from(inputArray);
+ const privateKey = new Blake2b(32).update(inputBytes).digest("hex");
+ return { privateKey, index };
+ });
+ return results;
}
-}
+};
var LedgerWallet = class _LedgerWallet extends Wallet {
static #isInternal = false;
- #ledger
- get ledger () {
- return this.#ledger
+ #ledger;
+ get ledger() {
+ return this.#ledger;
}
constructor(id2, ledger) {
if (!_LedgerWallet.#isInternal) {
- throw new Error(`LedgerWallet cannot be instantiated directly. Use 'await LedgerWallet.create()' instead.`)
+ throw new Error(`LedgerWallet cannot be instantiated directly. Use 'await LedgerWallet.create()' instead.`);
}
- _LedgerWallet.#isInternal = false
- super(id2)
- this.#ledger = ledger
+ _LedgerWallet.#isInternal = false;
+ super(id2);
+ this.#ledger = ledger;
}
/**
* Creates a new Ledger hardware wallet communication layer by dynamically
*
* @returns {LedgerWallet} A wallet containing accounts and a Ledger device communication object
*/
- static async create () {
- const { Ledger: Ledger2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports))
- const l = await Ledger2.init()
- const id2 = await Entropy.create(16)
- _LedgerWallet.#isInternal = true
- return new this(id2, l)
+ static async create() {
+ const { Ledger: Ledger2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports));
+ const l = await Ledger2.init();
+ const id2 = await Entropy.create(16);
+ _LedgerWallet.#isInternal = true;
+ return new this(id2, l);
}
/**
* Retrieves an existing Ledger wallet from session storage using its ID.
* @param {string} id - Generated when the wallet was initially created
* @returns {LedgerWallet} Restored LedgerWallet
*/
- static async restore (id2) {
+ static async restore(id2) {
if (typeof id2 !== "string" || id2 === "") {
- throw new TypeError("Wallet ID is required to restore")
+ throw new TypeError("Wallet ID is required to restore");
}
- const { Ledger: Ledger2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports))
- const l = await Ledger2.init()
- _LedgerWallet.#isInternal = true
- return new this(await Entropy.import(id2), l)
+ const { Ledger: Ledger2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports));
+ const l = await Ledger2.init();
+ _LedgerWallet.#isInternal = true;
+ return new this(await Entropy.import(id2), l);
}
/**
* Gets the public key for an account from the Ledger device.
* @param {number[]} indexes - Indexes of the accounts
* @returns {Promise<Account>}
*/
- async ckd (indexes) {
- const results = []
+ async ckd(indexes) {
+ const results = [];
for (const index of indexes) {
- const { status, publicKey } = await this.ledger.account(index)
+ const { status, publicKey } = await this.ledger.account(index);
if (status === "OK" && publicKey != null) {
- results.push({ publicKey, index })
+ results.push({ publicKey, index });
} else {
- throw new Error(`Error getting Ledger account: ${status}`)
+ throw new Error(`Error getting Ledger account: ${status}`);
}
}
- return results
+ return results;
}
/**
* Attempts to close the current process on the Ledger device.
*
* @returns True if successfully locked
*/
- async lock () {
+ async lock() {
if (this.ledger == null) {
- return false
+ return false;
}
- const result = await this.ledger.close()
- return result === "OK"
+ const result = await this.ledger.close();
+ return result === "OK";
}
/**
* Attempts to connect to the Ledger device.
*
* @returns True if successfully unlocked
*/
- async unlock () {
+ async unlock() {
if (this.ledger == null) {
- return false
+ return false;
}
- const result = await this.ledger.connect()
- return result === "OK"
+ const result = await this.ledger.connect();
+ return result === "OK";
}
-}
+};
// dist/global.js
-globalThis.libnemo ??= main_exports
+globalThis.libnemo ??= main_exports;
//# sourceMappingURL=global.min.js.map
projects / libnemo.git / commitdiff