@ohos-ports/crypto 0.0.0-stage → 0.3.1-beta.1

package/dist/hasGlobalWebCrypto.d.ts

@@ -0,0 +1 @@
+export declare const hasGlobalWebCrypto: boolean;

package/dist/hasGlobalWebCrypto.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasGlobalWebCrypto = void 0;
+var hasGlobalThis = true;
+try {
+    hasGlobalThis = typeof globalThis !== "undefined";
+}
+catch (_a) {
+    hasGlobalThis = false;
+}
+var _hasGlobalWebCrypto = hasGlobalThis;
+if (hasGlobalThis) {
+    try {
+        _hasGlobalWebCrypto = (typeof globalThis.crypto !== "undefined" &&
+            typeof globalThis.crypto.subtle !== "undefined");
+    }
+    catch (_b) {
+        _hasGlobalWebCrypto = false;
+    }
+}
+exports.hasGlobalWebCrypto = _hasGlobalWebCrypto;

package/dist/hmacSHA512.d.ts

@@ -0,0 +1,6 @@
+/**
+ * here because we need it in `@harmoniclabs/bip32_ed25519`
+ *
+ * and in particular, because it is a dependency of `pbkdf2` (which could also be calculated using native webcrypto)
+ */
+export declare function hmacSHA512(key: Uint8Array, data: Uint8Array): Uint8Array;

package/dist/hmacSHA512.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hmacSHA512 = void 0;
+var hmac_1 = require("./noble/hmac.js");
+var sha512_1 = require("./noble/sha512.js");
+/**
+ * here because we need it in `@harmoniclabs/bip32_ed25519`
+ *
+ * and in particular, because it is a dependency of `pbkdf2` (which could also be calculated using native webcrypto)
+ */
+function hmacSHA512(key, data) {
+    return new Uint8Array((0, hmac_1.hmac)(sha512_1.sha512, key, data));
+}
+exports.hmacSHA512 = hmacSHA512;

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./bech32.js";
+export * from "./blake2b.js";
+export * from "./bls12_318.js";
+export * from "./ed25519.js";
+export * from "./hmacSHA512.js";
+export * from "./keccak.js";
+export * from "./secp256k1.js";
+export * from "./sha2_256.js";
+export * from "./sha2_512.js";
+export * from "./sha3.js";
+export * from "./types.js";
+export * from "./utils/index.js";
+export * from "./vrf.js";
+export * from "./ripemd_160.js";

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bech32.js"), exports);
+__exportStar(require("./blake2b.js"), exports);
+__exportStar(require("./bls12_318.js"), exports);
+__exportStar(require("./ed25519.js"), exports);
+__exportStar(require("./hmacSHA512.js"), exports);
+__exportStar(require("./keccak.js"), exports);
+__exportStar(require("./secp256k1.js"), exports);
+__exportStar(require("./sha2_256.js"), exports);
+__exportStar(require("./sha2_512.js"), exports);
+__exportStar(require("./sha3.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./utils/index.js"), exports);
+__exportStar(require("./vrf.js"), exports);
+__exportStar(require("./ripemd_160.js"), exports);

package/dist/keccak.d.ts

@@ -0,0 +1,4 @@
+export declare function keccak_256(msg: Uint8Array): Uint8Array;
+export declare function keccak_224(msg: Uint8Array): Uint8Array;
+export declare function keccak_384(msg: Uint8Array): Uint8Array;
+export declare function keccak_512(msg: Uint8Array): Uint8Array;

package/dist/keccak.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak_512 = exports.keccak_384 = exports.keccak_224 = exports.keccak_256 = void 0;
+var noble = __importStar(require("./noble/keccak.js"));
+function keccak_256(msg) {
+    return noble.keccak_256(msg);
+}
+exports.keccak_256 = keccak_256;
+function keccak_224(msg) {
+    return noble.keccak_224(msg);
+}
+exports.keccak_224 = keccak_224;
+function keccak_384(msg) {
+    return noble.keccak_384(msg);
+}
+exports.keccak_384 = keccak_384;
+function keccak_512(msg) {
+    return noble.keccak_512(msg);
+}
+exports.keccak_512 = keccak_512;

package/dist/kes/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const KES_SIG_LENGTH = 448;
+export declare const KES_SIZE = 32;

package/dist/kes/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KES_SIZE = exports.KES_SIG_LENGTH = void 0;
+exports.KES_SIG_LENGTH = 448;
+exports.KES_SIZE = 32;

package/dist/kes/macro/sum_kes.d.ts

@@ -0,0 +1,15 @@
+export interface IKesSk {
+    sign(msg: Uint8Array): Uint8Array;
+}
+export interface KesSkClass {
+    new (): IKesSk;
+}
+export interface IKesSig {
+    sigma: IKesSig;
+    lhs_pk: Uint8Array;
+    rhs_pk: Uint8Array;
+}
+export interface KesSigClass {
+    new (): IKesSig;
+}
+export declare function sum_kes(prev_kes_class: KesSkClass, prev_sig_class: KesSigClass): void;

package/dist/kes/macro/sum_kes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum_kes = void 0;
+;
+;
+;
+function sum_kes(prev_kes_class, prev_sig_class) {
+}
+exports.sum_kes = sum_kes;

package/dist/noble/_assert.d.ts

@@ -0,0 +1,23 @@
+declare function number(n: number): void;
+declare function bool(b: boolean): void;
+export declare function isBytes(a: unknown): a is Uint8Array;
+declare function bytes(b: Uint8Array | undefined, ...lengths: number[]): void;
+type Hash = {
+    (data: Uint8Array): Uint8Array;
+    blockLen: number;
+    outputLen: number;
+    create: any;
+};
+declare function hash(hash: Hash): void;
+declare function exists(instance: any, checkFinished?: boolean): void;
+declare function output(out: any, instance: any): void;
+export { number, bool, bytes, hash, exists, output };
+declare const assert: {
+    number: typeof number;
+    bool: typeof bool;
+    bytes: typeof bytes;
+    hash: typeof hash;
+    exists: typeof exists;
+    output: typeof output;
+};
+export default assert;

package/dist/noble/_assert.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = exports.isBytes = void 0;
+function number(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error("positive integer expected, not ".concat(n));
+}
+exports.number = number;
+function bool(b) {
+    if (typeof b !== 'boolean')
+        throw new Error("boolean expected, not ".concat(b));
+}
+exports.bool = bool;
+// copied from utils
+function isBytes(a) {
+    return (a instanceof Uint8Array ||
+        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+}
+exports.isBytes = isBytes;
+function bytes(b) {
+    var lengths = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        lengths[_i - 1] = arguments[_i];
+    }
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error("Uint8Array expected of length ".concat(lengths, ", not of length=").concat(b.length));
+}
+exports.bytes = bytes;
+function hash(hash) {
+    if (typeof hash !== 'function' || typeof hash.create !== 'function')
+        throw new Error('Hash should be wrapped by utils.wrapConstructor');
+    number(hash.outputLen);
+    number(hash.blockLen);
+}
+exports.hash = hash;
+function exists(instance, checkFinished) {
+    if (checkFinished === void 0) { checkFinished = true; }
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+exports.exists = exists;
+function output(out, instance) {
+    bytes(out);
+    var min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error("digestInto() expects output buffer of length at least ".concat(min));
+    }
+}
+exports.output = output;
+var assert = { number: number, bool: bool, bytes: bytes, hash: hash, exists: exists, output: output };
+exports.default = assert;

package/dist/noble/_md.d.ts

@@ -0,0 +1,29 @@
+import { Hash, Input } from './utils.js';
+export declare const Chi: (a: number, b: number, c: number) => number;
+export declare const Maj: (a: number, b: number, c: number) => number;
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+export declare abstract class HashMD<T extends HashMD<T>> extends Hash<T> {
+    readonly blockLen: number;
+    outputLen: number;
+    readonly padOffset: number;
+    readonly isLE: boolean;
+    protected abstract process(buf: DataView, offset: number): void;
+    protected abstract get(): number[];
+    protected abstract set(...args: number[]): void;
+    abstract destroy(): void;
+    protected abstract roundClean(): void;
+    protected buffer: Uint8Array;
+    protected view: DataView;
+    protected finished: boolean;
+    protected length: number;
+    protected pos: number;
+    protected destroyed: boolean;
+    constructor(blockLen: number, outputLen: number, padOffset: number, isLE: boolean);
+    update(data: Input): this;
+    digestInto(out: Uint8Array): void;
+    digest(): Uint8Array;
+    _cloneInto(to?: T): T;
+}

package/dist/noble/_md.js

@@ -0,0 +1,170 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (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; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (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);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashMD = exports.Maj = exports.Chi = void 0;
+var _assert_1 = require("./_assert.js");
+var utils_1 = require("./utils.js");
+// Polyfill for Safari 14
+function setBigUint64(view, byteOffset, value, isLE) {
+    if (typeof view.setBigUint64 === 'function')
+        return view.setBigUint64(byteOffset, value, isLE);
+    var _32n = BigInt(32);
+    var _u32_max = BigInt(0xffffffff);
+    var wh = Number((value >> _32n) & _u32_max);
+    var wl = Number(value & _u32_max);
+    var h = isLE ? 4 : 0;
+    var l = isLE ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE);
+    view.setUint32(byteOffset + l, wl, isLE);
+}
+// Choice: a ? b : c
+var Chi = function (a, b, c) { return (a & b) ^ (~a & c); };
+exports.Chi = Chi;
+// Majority function, true if any two inpust is true
+var Maj = function (a, b, c) { return (a & b) ^ (a & c) ^ (b & c); };
+exports.Maj = Maj;
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+var HashMD = /** @class */ (function (_super) {
+    __extends(HashMD, _super);
+    function HashMD(blockLen, outputLen, padOffset, isLE) {
+        var _this = _super.call(this) || this;
+        _this.blockLen = blockLen;
+        _this.outputLen = outputLen;
+        _this.padOffset = padOffset;
+        _this.isLE = isLE;
+        _this.finished = false;
+        _this.length = 0;
+        _this.pos = 0;
+        _this.destroyed = false;
+        _this.buffer = new Uint8Array(blockLen);
+        _this.view = (0, utils_1.createView)(_this.buffer);
+        return _this;
+    }
+    HashMD.prototype.update = function (data) {
+        (0, _assert_1.exists)(this);
+        var _a = this, view = _a.view, buffer = _a.buffer, blockLen = _a.blockLen;
+        data = (0, utils_1.toBytes)(data);
+        var len = data.length;
+        for (var pos = 0; pos < len;) {
+            var take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                var dataView = (0, utils_1.createView)(data);
+                for (; blockLen <= len - pos; pos += blockLen)
+                    this.process(dataView, pos);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            pos += take;
+            if (this.pos === blockLen) {
+                this.process(view, 0);
+                this.pos = 0;
+            }
+        }
+        this.length += data.length;
+        this.roundClean();
+        return this;
+    };
+    HashMD.prototype.digestInto = function (out) {
+        (0, _assert_1.exists)(this);
+        (0, _assert_1.output)(out, this);
+        this.finished = true;
+        // Padding
+        // We can avoid allocation of buffer for padding completely if it
+        // was previously not allocated here. But it won't change performance.
+        var _a = this, buffer = _a.buffer, view = _a.view, blockLen = _a.blockLen, isLE = _a.isLE;
+        var pos = this.pos;
+        // append the bit '1' to the message
+        buffer[pos++] = 128;
+        this.buffer.subarray(pos).fill(0);
+        // we have less than padOffset left in buffer, so we cannot put length in
+        // current block, need process it and pad again
+        if (this.padOffset > blockLen - pos) {
+            this.process(view, 0);
+            pos = 0;
+        }
+        // Pad until full block byte with zeros
+        for (var i = pos; i < blockLen; i++)
+            buffer[i] = 0;
+        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+        // So we just write lowest 64 bits of that value.
+        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+        this.process(view, 0);
+        var oview = (0, utils_1.createView)(out);
+        var len = this.outputLen;
+        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
+        if (len % 4)
+            throw new Error('_sha2: outputLen should be aligned to 32bit');
+        var outLen = len / 4;
+        var state = this.get();
+        if (outLen > state.length)
+            throw new Error('_sha2: outputLen bigger than state');
+        for (var i = 0; i < outLen; i++)
+            oview.setUint32(4 * i, state[i], isLE);
+    };
+    HashMD.prototype.digest = function () {
+        var _a = this, buffer = _a.buffer, outputLen = _a.outputLen;
+        this.digestInto(buffer);
+        var res = Uint8Array.prototype.slice.call(buffer, 0, outputLen);
+        this.destroy();
+        return res;
+    };
+    HashMD.prototype._cloneInto = function (to) {
+        to || (to = new this.constructor());
+        to.set.apply(to, __spreadArray([], __read(this.get()), false));
+        var _a = this, blockLen = _a.blockLen, buffer = _a.buffer, length = _a.length, finished = _a.finished, destroyed = _a.destroyed, pos = _a.pos;
+        to.length = length;
+        to.pos = pos;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        if (length % blockLen)
+            to.buffer.set(buffer);
+        return to;
+    };
+    return HashMD;
+}(utils_1.Hash));
+exports.HashMD = HashMD;

package/dist/noble/_shortw_utils.d.ts

@@ -0,0 +1,61 @@
+import { randomBytes } from './utils.js';
+import { CurveType } from './curves/weierstrass.js';
+import { CHash } from './abstract/utils.js';
+export declare function getHash(hash: CHash): {
+    hash: CHash;
+    hmac: (key: Uint8Array, ...msgs: Uint8Array[]) => Uint8Array;
+    randomBytes: typeof randomBytes;
+};
+type CurveDef = Readonly<Omit<CurveType, 'hash' | 'hmac' | 'randomBytes'>>;
+export declare function createCurve(curveDef: CurveDef, defHash: CHash): Readonly<{
+    create: (hash: CHash) => import("./curves/weierstrass.js").CurveFn;
+    CURVE: Readonly<{
+        readonly nBitLength: number;
+        readonly nByteLength: number;
+        readonly Fp: import("./abstract/modular.js").IField<bigint>;
+        readonly n: bigint;
+        readonly h: bigint;
+        readonly hEff?: bigint | undefined;
+        readonly Gx: bigint;
+        readonly Gy: bigint;
+        readonly allowInfinityPoint?: boolean | undefined;
+        readonly a: bigint;
+        readonly b: bigint;
+        readonly allowedPrivateKeyLengths?: readonly number[] | undefined;
+        readonly wrapPrivateKey?: boolean | undefined;
+        readonly endo?: {
+            beta: bigint;
+            splitScalar: (k: bigint) => {
+                k1neg: boolean;
+                k1: bigint;
+                k2neg: boolean;
+                k2: bigint;
+            };
+        } | undefined;
+        readonly isTorsionFree?: ((c: import("./curves/weierstrass.js").ProjConstructor<bigint>, point: import("./curves/weierstrass.js").ProjPointType<bigint>) => boolean) | undefined;
+        readonly clearCofactor?: ((c: import("./curves/weierstrass.js").ProjConstructor<bigint>, point: import("./curves/weierstrass.js").ProjPointType<bigint>) => import("./curves/weierstrass.js").ProjPointType<bigint>) | undefined;
+        readonly hash: CHash;
+        readonly hmac: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
+        readonly randomBytes: (bytesLength?: number | undefined) => Uint8Array;
+        lowS: boolean;
+        readonly bits2int?: ((bytes: Uint8Array) => bigint) | undefined;
+        readonly bits2int_modN?: ((bytes: Uint8Array) => bigint) | undefined;
+        readonly p: bigint;
+    }>;
+    getPublicKey: (privateKey: import("./abstract/utils.js").PrivKey, isCompressed?: boolean | undefined) => Uint8Array;
+    getSharedSecret: (privateA: import("./abstract/utils.js").PrivKey, publicB: import("./abstract/utils.js").Hex, isCompressed?: boolean | undefined) => Uint8Array;
+    sign: (msgHash: import("./abstract/utils.js").Hex, privKey: import("./abstract/utils.js").PrivKey, opts?: import("./curves/weierstrass.js").SignOpts | undefined) => import("./curves/weierstrass.js").RecoveredSignatureType;
+    verify: (signature: import("./abstract/utils.js").Hex | {
+        r: bigint;
+        s: bigint;
+    }, msgHash: import("./abstract/utils.js").Hex, publicKey: import("./abstract/utils.js").Hex, opts?: import("./curves/weierstrass.js").VerOpts | undefined) => boolean;
+    ProjectivePoint: import("./curves/weierstrass.js").ProjConstructor<bigint>;
+    Signature: import("./curves/weierstrass.js").SignatureConstructor;
+    utils: {
+        normPrivateKeyToScalar: (key: import("./abstract/utils.js").PrivKey) => bigint;
+        isValidPrivateKey(privateKey: import("./abstract/utils.js").PrivKey): boolean;
+        randomPrivateKey: () => Uint8Array;
+        precompute: (windowSize?: number | undefined, point?: import("./curves/weierstrass.js").ProjPointType<bigint> | undefined) => import("./curves/weierstrass.js").ProjPointType<bigint>;
+    };
+}>;
+export {};

package/dist/noble/_shortw_utils.js

@@ -0,0 +1,63 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (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);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCurve = exports.getHash = void 0;
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+var hmac_1 = require("./hmac.js");
+var utils_1 = require("./utils.js");
+var weierstrass_1 = require("./curves/weierstrass.js");
+// connects noble-curves to noble-hashes
+function getHash(hash) {
+    return {
+        hash: hash,
+        hmac: function (key) {
+            var msgs = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                msgs[_i - 1] = arguments[_i];
+            }
+            return (0, hmac_1.hmac)(hash, key, utils_1.concatBytes.apply(void 0, __spreadArray([], __read(msgs), false)));
+        },
+        randomBytes: utils_1.randomBytes,
+    };
+}
+exports.getHash = getHash;
+function createCurve(curveDef, defHash) {
+    var create = function (hash) { return (0, weierstrass_1.weierstrass)(__assign(__assign({}, curveDef), getHash(hash))); };
+    return Object.freeze(__assign(__assign({}, create(defHash)), { create: create }));
+}
+exports.createCurve = createCurve;

package/dist/noble/_u64.d.ts

@@ -0,0 +1,28 @@
+export declare function fromBig(n: bigint, le?: boolean): {
+    h: number;
+    l: number;
+};
+export declare function split(lst: bigint[], le?: boolean): Uint32Array[];
+export declare const toBig: (h: number, l: number) => bigint;
+export declare const shrSH: (h: number, _l: number, s: number) => number;
+export declare const shrSL: (h: number, l: number, s: number) => number;
+export declare const rotrSH: (h: number, l: number, s: number) => number;
+export declare const rotrSL: (h: number, l: number, s: number) => number;
+export declare const rotrBH: (h: number, l: number, s: number) => number;
+export declare const rotrBL: (h: number, l: number, s: number) => number;
+export declare const rotr32H: (_h: number, l: number) => number;
+export declare const rotr32L: (h: number, _l: number) => number;
+export declare const rotlSH: (h: number, l: number, s: number) => number;
+export declare const rotlSL: (h: number, l: number, s: number) => number;
+export declare const rotlBH: (h: number, l: number, s: number) => number;
+export declare const rotlBL: (h: number, l: number, s: number) => number;
+export declare function add(Ah: number, Al: number, Bh: number, Bl: number): {
+    h: number;
+    l: number;
+};
+export declare const add3L: (Al: number, Bl: number, Cl: number) => number;
+export declare const add3H: (low: number, Ah: number, Bh: number, Ch: number) => number;
+export declare const add4L: (Al: number, Bl: number, Cl: number, Dl: number) => number;
+export declare const add4H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number) => number;
+export declare const add5L: (Al: number, Bl: number, Cl: number, Dl: number, El: number) => number;
+export declare const add5H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number) => number;