quantumcoin 6.14.5 → 7.0.2

package/lib.commonjs/crypto/keccak.js

@@ -1,52 +0,0 @@
-"use strict";
-/**
- *  Cryptographic hashing functions
- *
- *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.keccak256 = void 0;
-const sha3_1 = require("@noble/hashes/sha3");
-const index_js_1 = require("../utils/index.js");
-let locked = false;
-const _keccak256 = function (data) {
-    return (0, sha3_1.keccak_256)(data);
-};
-let __keccak256 = _keccak256;
-/**
- *  Compute the cryptographic KECCAK256 hash of %%data%%.
- *
- *  The %%data%% **must** be a data representation, to compute the
- *  hash of UTF-8 data use the [[id]] function.
- *
- *  @returns DataHexstring
- *  @example:
- *    keccak256("0x")
- *    //_result:
- *
- *    keccak256("0x1337")
- *    //_result:
- *
- *    keccak256(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- *
- *    // Strings are assumed to be DataHexString, otherwise it will
- *    // throw. To hash UTF-8 data, see the note above.
- *    keccak256("Hello World")
- *    //_error:
- */
-function keccak256(_data) {
-    const data = (0, index_js_1.getBytes)(_data, "data");
-    return (0, index_js_1.hexlify)(__keccak256(data));
-}
-exports.keccak256 = keccak256;
-keccak256._ = _keccak256;
-keccak256.lock = function () { locked = true; };
-keccak256.register = function (func) {
-    if (locked) {
-        throw new TypeError("keccak256 is locked");
-    }
-    __keccak256 = func;
-};
-Object.freeze(keccak256);
-//# sourceMappingURL=keccak.js.map

package/lib.commonjs/crypto/keccak.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keccak.js","sourceRoot":"","sources":["../../src.ts/crypto/keccak.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,6CAAgD;AAEhD,gDAAsD;AAKtD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,UAAU,GAAG,UAAS,IAAgB;IACxC,OAAO,IAAA,iBAAU,EAAC,IAAI,CAAC,CAAC;AAC5B,CAAC,CAAA;AAED,IAAI,WAAW,GAAoC,UAAU,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,SAAS,CAAC,KAAgB;IACtC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AACtC,CAAC;AAHD,8BAGC;AACD,SAAS,CAAC,CAAC,GAAG,UAAU,CAAC;AACzB,SAAS,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,SAAS,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC/D,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,SAAS,CAAC,qBAAqB,CAAC,CAAC;KAAE;IAC3D,WAAW,GAAG,IAAI,CAAC;AACvB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC"}

package/lib.commonjs/crypto/pbkdf2.d.ts

@@ -1,35 +0,0 @@
-/**
- *  A **Password-Based Key-Derivation Function** is designed to create
- *  a sequence of bytes suitible as a **key** from a human-rememberable
- *  password.
- *
- *  @_subsection: api/crypto:Passwords  [about-pbkdf]
- */
-import type { BytesLike } from "../utils/index.js";
-/**
- *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
- *  the %%salt%% and using %%iterations%% of %%algo%%.
- *
- *  This PBKDF is outdated and should not be used in new projects, but is
- *  required to decrypt older files.
- *
- *  @example:
- *    // The password must be converted to bytes, and it is generally
- *    // best practices to ensure the string has been normalized. Many
- *    // formats explicitly indicate the normalization form to use.
- *    password = "hello"
- *    passwordBytes = toUtf8Bytes(password, "NFKC")
- *
- *    salt = id("some-salt")
- *
- *    // Compute the PBKDF2
- *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
- *    //_result:
- */
-export declare function pbkdf2(_password: BytesLike, _salt: BytesLike, iterations: number, keylen: number, algo: "sha256" | "sha512"): string;
-export declare namespace pbkdf2 {
-    var _: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike;
-    var lock: () => void;
-    var register: (func: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike) => void;
-}
-//# sourceMappingURL=pbkdf2.d.ts.map

package/lib.commonjs/crypto/pbkdf2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pbkdf2.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/pbkdf2.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAIpI;yBAJe,MAAM"}

package/lib.commonjs/crypto/pbkdf2.js

@@ -1,53 +0,0 @@
-"use strict";
-/**
- *  A **Password-Based Key-Derivation Function** is designed to create
- *  a sequence of bytes suitible as a **key** from a human-rememberable
- *  password.
- *
- *  @_subsection: api/crypto:Passwords  [about-pbkdf]
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pbkdf2 = void 0;
-const crypto_js_1 = require("./crypto.js");
-const index_js_1 = require("../utils/index.js");
-let locked = false;
-const _pbkdf2 = function (password, salt, iterations, keylen, algo) {
-    return (0, crypto_js_1.pbkdf2Sync)(password, salt, iterations, keylen, algo);
-};
-let __pbkdf2 = _pbkdf2;
-/**
- *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
- *  the %%salt%% and using %%iterations%% of %%algo%%.
- *
- *  This PBKDF is outdated and should not be used in new projects, but is
- *  required to decrypt older files.
- *
- *  @example:
- *    // The password must be converted to bytes, and it is generally
- *    // best practices to ensure the string has been normalized. Many
- *    // formats explicitly indicate the normalization form to use.
- *    password = "hello"
- *    passwordBytes = toUtf8Bytes(password, "NFKC")
- *
- *    salt = id("some-salt")
- *
- *    // Compute the PBKDF2
- *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
- *    //_result:
- */
-function pbkdf2(_password, _salt, iterations, keylen, algo) {
-    const password = (0, index_js_1.getBytes)(_password, "password");
-    const salt = (0, index_js_1.getBytes)(_salt, "salt");
-    return (0, index_js_1.hexlify)(__pbkdf2(password, salt, iterations, keylen, algo));
-}
-exports.pbkdf2 = pbkdf2;
-pbkdf2._ = _pbkdf2;
-pbkdf2.lock = function () { locked = true; };
-pbkdf2.register = function (func) {
-    if (locked) {
-        throw new Error("pbkdf2 is locked");
-    }
-    __pbkdf2 = func;
-};
-Object.freeze(pbkdf2);
-//# sourceMappingURL=pbkdf2.js.map

package/lib.commonjs/crypto/pbkdf2.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pbkdf2.js","sourceRoot":"","sources":["../../src.ts/crypto/pbkdf2.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,2CAAyC;AAEzC,gDAAsD;AAKtD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,OAAO,GAAG,UAAS,QAAoB,EAAE,IAAgB,EAAE,UAAkB,EAAE,MAAc,EAAE,IAAyB;IAC1H,OAAO,IAAA,sBAAU,EAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;AAChE,CAAC,CAAA;AAED,IAAI,QAAQ,GAAG,OAAO,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,MAAM,CAAC,SAAoB,EAAE,KAAgB,EAAE,UAAkB,EAAE,MAAc,EAAE,IAAyB;IACxH,MAAM,QAAQ,GAAG,IAAA,mBAAQ,EAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;AACvE,CAAC;AAJD,wBAIC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACjD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAA0H;IACjJ,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACpD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC"}

package/lib.commonjs/crypto/random.d.ts

@@ -1,14 +0,0 @@
-/**
- *  Return %%length%% bytes of cryptographically secure random data.
- *
- *  @example:
- *    randomBytes(8)
- *    //_result:
- */
-export declare function randomBytes(length: number): Uint8Array;
-export declare namespace randomBytes {
-    var _: (length: number) => Uint8Array;
-    var lock: () => void;
-    var register: (func: (length: number) => Uint8Array) => void;
-}
-//# sourceMappingURL=random.d.ts.map

package/lib.commonjs/crypto/random.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/random.ts"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAEtD;yBAFe,WAAW"}

package/lib.commonjs/crypto/random.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.randomBytes = void 0;
-/**
- *  A **Cryptographically Secure Random Value** is one that has been
- *  generated with additional care take to prevent side-channels
- *  from allowing others to detect it and prevent others from through
- *  coincidence generate the same values.
- *
- *  @_subsection: api/crypto:Random Values  [about-crypto-random]
- */
-const crypto_js_1 = require("./crypto.js");
-let locked = false;
-const _randomBytes = function (length) {
-    return new Uint8Array((0, crypto_js_1.randomBytes)(length));
-};
-let __randomBytes = _randomBytes;
-/**
- *  Return %%length%% bytes of cryptographically secure random data.
- *
- *  @example:
- *    randomBytes(8)
- *    //_result:
- */
-function randomBytes(length) {
-    return __randomBytes(length);
-}
-exports.randomBytes = randomBytes;
-randomBytes._ = _randomBytes;
-randomBytes.lock = function () { locked = true; };
-randomBytes.register = function (func) {
-    if (locked) {
-        throw new Error("randomBytes is locked");
-    }
-    __randomBytes = func;
-};
-Object.freeze(randomBytes);
-//# sourceMappingURL=random.js.map

package/lib.commonjs/crypto/random.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"random.js","sourceRoot":"","sources":["../../src.ts/crypto/random.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,2CAA2D;AAE3D,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,YAAY,GAAG,UAAS,MAAc;IACxC,OAAO,IAAI,UAAU,CAAC,IAAA,uBAAa,EAAC,MAAM,CAAC,CAAC,CAAC;AACjD,CAAC,CAAA;AAED,IAAI,aAAa,GAAG,YAAY,CAAC;AAEjC;;;;;;GAMG;AACH,SAAgB,WAAW,CAAC,MAAc;IACtC,OAAO,aAAa,CAAC,MAAM,CAAC,CAAC;AACjC,CAAC;AAFD,kCAEC;AAED,WAAW,CAAC,CAAC,GAAG,YAAY,CAAC;AAC7B,WAAW,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACtD,WAAW,CAAC,QAAQ,GAAG,UAAS,IAAoC;IAChE,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;KAAE;IACzD,aAAa,GAAG,IAAI,CAAC;AACzB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC"}

package/lib.commonjs/crypto/ripemd160.d.ts

@@ -1,25 +0,0 @@
-import type { BytesLike } from "../utils/index.js";
-/**
- *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    ripemd160("0x")
- *    //_result:
- *
- *    ripemd160("0x1337")
- *    //_result:
- *
- *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- *
- */
-export declare function ripemd160(_data: BytesLike): string;
-export declare namespace ripemd160 {
-    var _: (data: Uint8Array) => Uint8Array;
-    var lock: () => void;
-    var register: (func: (data: Uint8Array) => BytesLike) => void;
-}
-//# sourceMappingURL=ripemd160.d.ts.map

package/lib.commonjs/crypto/ripemd160.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ripemd160.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/ripemd160.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAWnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAGlD;yBAHe,SAAS"}

package/lib.commonjs/crypto/ripemd160.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ripemd160 = void 0;
-const ripemd160_1 = require("@noble/hashes/ripemd160");
-const index_js_1 = require("../utils/index.js");
-let locked = false;
-const _ripemd160 = function (data) {
-    return (0, ripemd160_1.ripemd160)(data);
-};
-let __ripemd160 = _ripemd160;
-/**
- *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    ripemd160("0x")
- *    //_result:
- *
- *    ripemd160("0x1337")
- *    //_result:
- *
- *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- *
- */
-function ripemd160(_data) {
-    const data = (0, index_js_1.getBytes)(_data, "data");
-    return (0, index_js_1.hexlify)(__ripemd160(data));
-}
-exports.ripemd160 = ripemd160;
-ripemd160._ = _ripemd160;
-ripemd160.lock = function () { locked = true; };
-ripemd160.register = function (func) {
-    if (locked) {
-        throw new TypeError("ripemd160 is locked");
-    }
-    __ripemd160 = func;
-};
-Object.freeze(ripemd160);
-//# sourceMappingURL=ripemd160.js.map

package/lib.commonjs/crypto/ripemd160.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ripemd160.js","sourceRoot":"","sources":["../../src.ts/crypto/ripemd160.ts"],"names":[],"mappings":";;;AAAA,uDAAuE;AAEvE,gDAAuD;AAKvD,IAAI,MAAM,GAAG,KAAK,CAAC;AAEnB,MAAM,UAAU,GAAG,UAAS,IAAgB;IACxC,OAAO,IAAA,qBAAe,EAAC,IAAI,CAAC,CAAC;AACjC,CAAC,CAAA;AAED,IAAI,WAAW,GAAoC,UAAU,CAAC;AAE9D;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,SAAS,CAAC,KAAgB;IACtC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;AACtC,CAAC;AAHD,8BAGC;AACD,SAAS,CAAC,CAAC,GAAG,UAAU,CAAC;AACzB,SAAS,CAAC,IAAI,GAAG,cAAmB,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,SAAS,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC/D,IAAI,MAAM,EAAE;QAAE,MAAM,IAAI,SAAS,CAAC,qBAAqB,CAAC,CAAC;KAAE;IAC3D,WAAW,GAAG,IAAI,CAAC;AACvB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC"}

package/lib.commonjs/crypto/scrypt.d.ts

@@ -1,82 +0,0 @@
-import type { BytesLike } from "../utils/index.js";
-/**
- *  A callback during long-running operations to update any
- *  UI or provide programatic access to the progress.
- *
- *  The %%percent%% is a value between ``0`` and ``1``.
- *
- *  @_docloc: api/crypto:Passwords
- */
-export type ProgressCallback = (percent: number) => void;
-/**
- *  The [[link-wiki-scrypt]] uses a memory and cpu hard method of
- *  derivation to increase the resource cost to brute-force a password
- *  for a given key.
- *
- *  This means this algorithm is intentionally slow, and can be tuned to
- *  become slower. As computation and memory speed improve over time,
- *  increasing the difficulty maintains the cost of an attacker.
- *
- *  For example, if a target time of 5 seconds is used, a legitimate user
- *  which knows their password requires only 5 seconds to unlock their
- *  account. A 6 character password has 68 billion possibilities, which
- *  would require an attacker to invest over 10,000 years of CPU time. This
- *  is of course a crude example (as password generally aren't random),
- *  but demonstrates to value of imposing large costs to decryption.
- *
- *  For this reason, if building a UI which involved decrypting or
- *  encrypting datsa using scrypt, it is recommended to use a
- *  [[ProgressCallback]] (as event short periods can seem lik an eternity
- *  if the UI freezes). Including the phrase //"decrypting"// in the UI
- *  can also help, assuring the user their waiting is for a good reason.
- *
- *  @_docloc: api/crypto:Passwords
- *
- *  @example:
- *    // The password must be converted to bytes, and it is generally
- *    // best practices to ensure the string has been normalized. Many
- *    // formats explicitly indicate the normalization form to use.
- *    password = "hello"
- *    passwordBytes = toUtf8Bytes(password, "NFKC")
- *
- *    salt = id("some-salt")
- *
- *    // Compute the scrypt
- *    scrypt(passwordBytes, salt, 1024, 8, 1, 16)
- *    //_result:
- */
-export declare function scrypt(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback): Promise<string>;
-export declare namespace scrypt {
-    var _: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, onProgress?: ProgressCallback | undefined) => Promise<Uint8Array>;
-    var lock: () => void;
-    var register: (func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback | undefined) => Promise<BytesLike>) => void;
-}
-/**
- *  Provides a synchronous variant of [[scrypt]].
- *
- *  This will completely lock up and freeze the UI in a browser and will
- *  prevent any event loop from progressing. For this reason, it is
- *  preferred to use the [async variant](scrypt).
- *
- *  @_docloc: api/crypto:Passwords
- *
- *  @example:
- *    // The password must be converted to bytes, and it is generally
- *    // best practices to ensure the string has been normalized. Many
- *    // formats explicitly indicate the normalization form to use.
- *    password = "hello"
- *    passwordBytes = toUtf8Bytes(password, "NFKC")
- *
- *    salt = id("some-salt")
- *
- *    // Compute the scrypt
- *    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)
- *    //_result:
- */
-export declare function scryptSync(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number): string;
-export declare namespace scryptSync {
-    var _: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => Uint8Array;
-    var lock: () => void;
-    var register: (func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => BytesLike) => void;
-}
-//# sourceMappingURL=scrypt.d.ts.map

package/lib.commonjs/crypto/scrypt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scrypt.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/scrypt.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAgBzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,MAAM,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAI/J;yBAJqB,MAAM;;;;;AAa5B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIvH;yBAJe,UAAU"}

package/lib.commonjs/crypto/scrypt.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scryptSync = exports.scrypt = void 0;
-const scrypt_1 = require("@noble/hashes/scrypt");
-const index_js_1 = require("../utils/index.js");
-let lockedSync = false, lockedAsync = false;
-const _scryptAsync = async function (passwd, salt, N, r, p, dkLen, onProgress) {
-    return await (0, scrypt_1.scryptAsync)(passwd, salt, { N, r, p, dkLen, onProgress });
-};
-const _scryptSync = function (passwd, salt, N, r, p, dkLen) {
-    return (0, scrypt_1.scrypt)(passwd, salt, { N, r, p, dkLen });
-};
-let __scryptAsync = _scryptAsync;
-let __scryptSync = _scryptSync;
-/**
- *  The [[link-wiki-scrypt]] uses a memory and cpu hard method of
- *  derivation to increase the resource cost to brute-force a password
- *  for a given key.
- *
- *  This means this algorithm is intentionally slow, and can be tuned to
- *  become slower. As computation and memory speed improve over time,
- *  increasing the difficulty maintains the cost of an attacker.
- *
- *  For example, if a target time of 5 seconds is used, a legitimate user
- *  which knows their password requires only 5 seconds to unlock their
- *  account. A 6 character password has 68 billion possibilities, which
- *  would require an attacker to invest over 10,000 years of CPU time. This
- *  is of course a crude example (as password generally aren't random),
- *  but demonstrates to value of imposing large costs to decryption.
- *
- *  For this reason, if building a UI which involved decrypting or
- *  encrypting datsa using scrypt, it is recommended to use a
- *  [[ProgressCallback]] (as event short periods can seem lik an eternity
- *  if the UI freezes). Including the phrase //"decrypting"// in the UI
- *  can also help, assuring the user their waiting is for a good reason.
- *
- *  @_docloc: api/crypto:Passwords
- *
- *  @example:
- *    // The password must be converted to bytes, and it is generally
- *    // best practices to ensure the string has been normalized. Many
- *    // formats explicitly indicate the normalization form to use.
- *    password = "hello"
- *    passwordBytes = toUtf8Bytes(password, "NFKC")
- *
- *    salt = id("some-salt")
- *
- *    // Compute the scrypt
- *    scrypt(passwordBytes, salt, 1024, 8, 1, 16)
- *    //_result:
- */
-async function scrypt(_passwd, _salt, N, r, p, dkLen, progress) {
-    const passwd = (0, index_js_1.getBytes)(_passwd, "passwd");
-    const salt = (0, index_js_1.getBytes)(_salt, "salt");
-    return (0, index_js_1.hexlify)(await __scryptAsync(passwd, salt, N, r, p, dkLen, progress));
-}
-exports.scrypt = scrypt;
-scrypt._ = _scryptAsync;
-scrypt.lock = function () { lockedAsync = true; };
-scrypt.register = function (func) {
-    if (lockedAsync) {
-        throw new Error("scrypt is locked");
-    }
-    __scryptAsync = func;
-};
-Object.freeze(scrypt);
-/**
- *  Provides a synchronous variant of [[scrypt]].
- *
- *  This will completely lock up and freeze the UI in a browser and will
- *  prevent any event loop from progressing. For this reason, it is
- *  preferred to use the [async variant](scrypt).
- *
- *  @_docloc: api/crypto:Passwords
- *
- *  @example:
- *    // The password must be converted to bytes, and it is generally
- *    // best practices to ensure the string has been normalized. Many
- *    // formats explicitly indicate the normalization form to use.
- *    password = "hello"
- *    passwordBytes = toUtf8Bytes(password, "NFKC")
- *
- *    salt = id("some-salt")
- *
- *    // Compute the scrypt
- *    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)
- *    //_result:
- */
-function scryptSync(_passwd, _salt, N, r, p, dkLen) {
-    const passwd = (0, index_js_1.getBytes)(_passwd, "passwd");
-    const salt = (0, index_js_1.getBytes)(_salt, "salt");
-    return (0, index_js_1.hexlify)(__scryptSync(passwd, salt, N, r, p, dkLen));
-}
-exports.scryptSync = scryptSync;
-scryptSync._ = _scryptSync;
-scryptSync.lock = function () { lockedSync = true; };
-scryptSync.register = function (func) {
-    if (lockedSync) {
-        throw new Error("scryptSync is locked");
-    }
-    __scryptSync = func;
-};
-Object.freeze(scryptSync);
-//# sourceMappingURL=scrypt.js.map

package/lib.commonjs/crypto/scrypt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"scrypt.js","sourceRoot":"","sources":["../../src.ts/crypto/scrypt.ts"],"names":[],"mappings":";;;AAAA,iDAAwF;AAExF,gDAA2D;AAe3D,IAAI,UAAU,GAAG,KAAK,EAAE,WAAW,GAAG,KAAK,CAAC;AAE5C,MAAM,YAAY,GAAG,KAAK,WAAU,MAAkB,EAAE,IAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,UAA6B;IACnJ,OAAO,MAAM,IAAA,oBAAW,EAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;AAC3E,CAAC,CAAA;AACD,MAAM,WAAW,GAAG,UAAS,MAAkB,EAAE,IAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa;IAC7G,OAAO,IAAA,eAAU,EAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACxD,CAAC,CAAA;AAED,IAAI,aAAa,GAAgJ,YAAY,CAAC;AAC9K,IAAI,YAAY,GAAwG,WAAW,CAAA;AAGnI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACI,KAAK,UAAU,MAAM,CAAC,OAAkB,EAAE,KAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,QAA2B;IAC1I,MAAM,MAAM,GAAG,IAAA,mBAAQ,EAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAC,EAAC,MAAM,aAAa,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;AAC1E,CAAC;AAJD,wBAIC;AACD,MAAM,CAAC,CAAC,GAAG,YAAY,CAAC;AACxB,MAAM,CAAC,IAAI,GAAG,cAAmB,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACtD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAA+I;IACtK,IAAI,WAAW,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACzD,aAAa,GAAG,IAAI,CAAC;AACzB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,UAAU,CAAC,OAAkB,EAAE,KAAgB,EAAE,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,KAAa;IAC3G,MAAM,MAAM,GAAG,IAAA,mBAAQ,EAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3C,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAC,EAAC,YAAY,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;AACzD,CAAC;AAJD,gCAIC;AACD,UAAU,CAAC,CAAC,GAAG,WAAW,CAAC;AAC3B,UAAU,CAAC,IAAI,GAAG,cAAmB,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACzD,UAAU,CAAC,QAAQ,GAAG,UAAS,IAAyG;IACpI,IAAI,UAAU,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;KAAE;IAC5D,YAAY,GAAG,IAAI,CAAC;AACxB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC"}

package/lib.commonjs/crypto/sha2.d.ts

@@ -1,47 +0,0 @@
-import type { BytesLike } from "../utils/index.js";
-/**
- *  Compute the cryptographic SHA2-256 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    sha256("0x")
- *    //_result:
- *
- *    sha256("0x1337")
- *    //_result:
- *
- *    sha256(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- *
- */
-export declare function sha256(_data: BytesLike): string;
-export declare namespace sha256 {
-    var _: (data: Uint8Array) => Uint8Array;
-    var lock: () => void;
-    var register: (func: (data: Uint8Array) => BytesLike) => void;
-}
-/**
- *  Compute the cryptographic SHA2-512 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    sha512("0x")
- *    //_result:
- *
- *    sha512("0x1337")
- *    //_result:
- *
- *    sha512(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- */
-export declare function sha512(_data: BytesLike): string;
-export declare namespace sha512 {
-    var _: (data: Uint8Array) => Uint8Array;
-    var lock: () => void;
-    var register: (func: (data: Uint8Array) => BytesLike) => void;
-}
-//# sourceMappingURL=sha2.d.ts.map

package/lib.commonjs/crypto/sha2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sha2.d.ts","sourceRoot":"","sources":["../../src.ts/crypto/sha2.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAiBnD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAG/C;yBAHe,MAAM;;;;;AAatB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAG/C;yBAHe,MAAM"}

package/lib.commonjs/crypto/sha2.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha512 = exports.sha256 = void 0;
-const crypto_js_1 = require("./crypto.js");
-const index_js_1 = require("../utils/index.js");
-const _sha256 = function (data) {
-    return (0, crypto_js_1.createHash)("sha256").update(data).digest();
-};
-const _sha512 = function (data) {
-    return (0, crypto_js_1.createHash)("sha512").update(data).digest();
-};
-let __sha256 = _sha256;
-let __sha512 = _sha512;
-let locked256 = false, locked512 = false;
-/**
- *  Compute the cryptographic SHA2-256 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    sha256("0x")
- *    //_result:
- *
- *    sha256("0x1337")
- *    //_result:
- *
- *    sha256(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- *
- */
-function sha256(_data) {
-    const data = (0, index_js_1.getBytes)(_data, "data");
-    return (0, index_js_1.hexlify)(__sha256(data));
-}
-exports.sha256 = sha256;
-sha256._ = _sha256;
-sha256.lock = function () { locked256 = true; };
-sha256.register = function (func) {
-    if (locked256) {
-        throw new Error("sha256 is locked");
-    }
-    __sha256 = func;
-};
-Object.freeze(sha256);
-/**
- *  Compute the cryptographic SHA2-512 hash of %%data%%.
- *
- *  @_docloc: api/crypto:Hash Functions
- *  @returns DataHexstring
- *
- *  @example:
- *    sha512("0x")
- *    //_result:
- *
- *    sha512("0x1337")
- *    //_result:
- *
- *    sha512(new Uint8Array([ 0x13, 0x37 ]))
- *    //_result:
- */
-function sha512(_data) {
-    const data = (0, index_js_1.getBytes)(_data, "data");
-    return (0, index_js_1.hexlify)(__sha512(data));
-}
-exports.sha512 = sha512;
-sha512._ = _sha512;
-sha512.lock = function () { locked512 = true; };
-sha512.register = function (func) {
-    if (locked512) {
-        throw new Error("sha512 is locked");
-    }
-    __sha512 = func;
-};
-Object.freeze(sha256);
-//# sourceMappingURL=sha2.js.map

package/lib.commonjs/crypto/sha2.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sha2.js","sourceRoot":"","sources":["../../src.ts/crypto/sha2.ts"],"names":[],"mappings":";;;AAAA,2CAAyC;AAEzC,gDAAsD;AAKtD,MAAM,OAAO,GAAG,UAAS,IAAgB;IACrC,OAAO,IAAA,sBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;AACtD,CAAC,CAAA;AAED,MAAM,OAAO,GAAG,UAAS,IAAgB;IACrC,OAAO,IAAA,sBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;AACtD,CAAC,CAAA;AAED,IAAI,QAAQ,GAAoC,OAAO,CAAC;AACxD,IAAI,QAAQ,GAAoC,OAAO,CAAC;AAExD,IAAI,SAAS,GAAG,KAAK,EAAE,SAAS,GAAG,KAAK,CAAC;AAGzC;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,MAAM,CAAC,KAAgB;IACnC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACnC,CAAC;AAHD,wBAGC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC5D,IAAI,SAAS,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACvD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AAGtB;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,MAAM,CAAC,KAAgB;IACnC,MAAM,IAAI,GAAG,IAAA,mBAAQ,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,OAAO,IAAA,kBAAO,EAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AACnC,CAAC;AAHD,wBAGC;AACD,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC;AACnB,MAAM,CAAC,IAAI,GAAG,cAAmB,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;AACpD,MAAM,CAAC,QAAQ,GAAG,UAAS,IAAqC;IAC5D,IAAI,SAAS,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KAAE;IACvD,QAAQ,GAAG,IAAI,CAAC;AACpB,CAAC,CAAA;AACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC"}