wiki-plugin-allyabase 0.0.1

package/test/node_modules/@noble/curves/p384.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p384.d.ts","sourceRoot":"","sources":["src/p384.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAiC07rB,CAAC;;;;;;kFAAwmB,CAAC;+HAA2F,CAAC;2GAAuE,CAAC;;;;qGAAoH,CAAC;;;;;;;+BAA+R,CAAC,eAAe,CAAC;;EAtB3muB,CAAC;AACpB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAqBq7rB,CAAC;;;;;;kFAAwmB,CAAC;+HAA2F,CAAC;2GAAuE,CAAC;;;;qGAAoH,CAAC;;;;;;;+BAA+R,CAAC,eAAe,CAAC;;EArBjmuB,CAAC;AAmB9B,eAAO,MAAM,WAAW,2IAA4C,CAAC;AACrE,eAAO,MAAM,aAAa,2IAA8C,CAAC"}

package/test/node_modules/@noble/curves/p384.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeToCurve = exports.hashToCurve = exports.secp384r1 = exports.p384 = void 0;
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const sha512_1 = require("@noble/hashes/sha512");
+const _shortw_utils_js_1 = require("./_shortw_utils.js");
+const hash_to_curve_js_1 = require("./abstract/hash-to-curve.js");
+const modular_js_1 = require("./abstract/modular.js");
+const weierstrass_js_1 = require("./abstract/weierstrass.js");
+// NIST secp384r1 aka p384
+// https://www.secg.org/sec2-v2.pdf, https://neuromancer.sk/std/nist/P-384
+// Field over which we'll do calculations.
+// prettier-ignore
+const P = BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffff');
+const Fp = (0, modular_js_1.Field)(P);
+const CURVE_A = Fp.create(BigInt('-3'));
+// prettier-ignore
+const CURVE_B = BigInt('0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef');
+// prettier-ignore
+exports.p384 = (0, _shortw_utils_js_1.createCurve)({
+    a: CURVE_A, // Equation params: a, b
+    b: CURVE_B,
+    Fp, // Field: 2n**384n - 2n**128n - 2n**96n + 2n**32n - 1n
+    // Curve order, total count of valid points in the field.
+    n: BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973'),
+    // Base (generator) point (x, y)
+    Gx: BigInt('0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7'),
+    Gy: BigInt('0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f'),
+    h: BigInt(1),
+    lowS: false,
+}, sha512_1.sha384);
+exports.secp384r1 = exports.p384;
+const mapSWU = /* @__PURE__ */ (() => (0, weierstrass_js_1.mapToCurveSimpleSWU)(Fp, {
+    A: CURVE_A,
+    B: CURVE_B,
+    Z: Fp.create(BigInt('-12')),
+}))();
+const htf = /* @__PURE__ */ (() => (0, hash_to_curve_js_1.createHasher)(exports.secp384r1.ProjectivePoint, (scalars) => mapSWU(scalars[0]), {
+    DST: 'P384_XMD:SHA-384_SSWU_RO_',
+    encodeDST: 'P384_XMD:SHA-384_SSWU_NU_',
+    p: Fp.ORDER,
+    m: 1,
+    k: 192,
+    expand: 'xmd',
+    hash: sha512_1.sha384,
+}))();
+exports.hashToCurve = (() => htf.hashToCurve)();
+exports.encodeToCurve = (() => htf.encodeToCurve)();
+//# sourceMappingURL=p384.js.map

package/test/node_modules/@noble/curves/p384.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"p384.js","sourceRoot":"","sources":["src/p384.ts"],"names":[],"mappings":";;;AAAA,sEAAsE;AACtE,iDAA8C;AAC9C,yDAAiD;AACjD,kEAA2D;AAC3D,sDAA8C;AAC9C,8DAAgE;AAEhE,0BAA0B;AAC1B,0EAA0E;AAE1E,0CAA0C;AAC1C,kBAAkB;AAClB,MAAM,CAAC,GAAG,MAAM,CAAC,oGAAoG,CAAC,CAAC;AACvH,MAAM,EAAE,GAAG,IAAA,kBAAK,EAAC,CAAC,CAAC,CAAC;AACpB,MAAM,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AACxC,kBAAkB;AAClB,MAAM,OAAO,GAAG,MAAM,CAAC,oGAAoG,CAAC,CAAC;AAE7H,kBAAkB;AACL,QAAA,IAAI,GAAG,IAAA,8BAAW,EAAC;IAC9B,CAAC,EAAE,OAAO,EAAE,wBAAwB;IACpC,CAAC,EAAE,OAAO;IACV,EAAE,EAAE,sDAAsD;IAC1D,yDAAyD;IACzD,CAAC,EAAE,MAAM,CAAC,oGAAoG,CAAC;IAC/G,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC,oGAAoG,CAAC;IAChH,EAAE,EAAE,MAAM,CAAC,oGAAoG,CAAC;IAChH,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACZ,IAAI,EAAE,KAAK;CACH,EAAE,eAAM,CAAC,CAAC;AACP,QAAA,SAAS,GAAG,YAAI,CAAC;AAE9B,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,GAAG,EAAE,CACnC,IAAA,oCAAmB,EAAC,EAAE,EAAE;IACtB,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,OAAO;IACV,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;CAC5B,CAAC,CAAC,EAAE,CAAC;AAER,MAAM,GAAG,GAAG,eAAe,CAAC,CAAC,GAAG,EAAE,CAChC,IAAA,+BAAY,EAAC,iBAAS,CAAC,eAAe,EAAE,CAAC,OAAiB,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE;IACjF,GAAG,EAAE,2BAA2B;IAChC,SAAS,EAAE,2BAA2B;IACtC,CAAC,EAAE,EAAE,CAAC,KAAK;IACX,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,GAAG;IACN,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,eAAM;CACb,CAAC,CAAC,EAAE,CAAC;AACK,QAAA,WAAW,GAAmB,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;AACxD,QAAA,aAAa,GAAmB,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC"}

package/test/node_modules/@noble/curves/p521.d.ts

@@ -0,0 +1,105 @@
+export declare const p521: Readonly<{
+    create: (hash: import("./abstract/utils.js").CHash) => import("./abstract/weierstrass.js").CurveFn;
+    CURVE: ReturnType<(curve: import("./abstract/weierstrass.js").CurveType) => Readonly<{
+        readonly nBitLength: number;
+        readonly nByteLength: number;
+        readonly Fp: import("./abstract/modular.js").IField<bigint>;
+        readonly n: bigint;
+        readonly h: bigint;
+        readonly hEff?: bigint;
+        readonly Gx: bigint;
+        readonly Gy: bigint;
+        readonly allowInfinityPoint?: boolean;
+        readonly a: bigint;
+        readonly b: bigint;
+        readonly allowedPrivateKeyLengths?: readonly number[];
+        readonly wrapPrivateKey?: boolean;
+        readonly endo?: {
+            beta: bigint;
+            splitScalar: (k: bigint) => {
+                k1neg: boolean;
+                k1: bigint;
+                k2neg: boolean;
+                k2: bigint;
+            };
+        };
+        readonly isTorsionFree?: ((c: import("./abstract/weierstrass.js").ProjConstructor<bigint>, point: import("./abstract/weierstrass.js").ProjPointType<bigint>) => boolean) | undefined;
+        readonly clearCofactor?: ((c: import("./abstract/weierstrass.js").ProjConstructor<bigint>, point: import("./abstract/weierstrass.js").ProjPointType<bigint>) => import("./abstract/weierstrass.js").ProjPointType<bigint>) | undefined;
+        readonly hash: import("./abstract/utils.js").CHash;
+        readonly hmac: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
+        readonly randomBytes: (bytesLength?: number) => Uint8Array;
+        lowS: boolean;
+        readonly bits2int?: (bytes: Uint8Array) => bigint;
+        readonly bits2int_modN?: (bytes: Uint8Array) => bigint;
+        readonly p: bigint;
+    }>>;
+    getPublicKey: (privateKey: import("./abstract/utils.js").PrivKey, isCompressed?: boolean) => Uint8Array;
+    getSharedSecret: (privateA: import("./abstract/utils.js").PrivKey, publicB: import("./abstract/utils.js").Hex, isCompressed?: boolean) => Uint8Array;
+    sign: (msgHash: import("./abstract/utils.js").Hex, privKey: import("./abstract/utils.js").PrivKey, opts?: import("./abstract/weierstrass.js").SignOpts) => import("./abstract/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("./abstract/weierstrass.js").VerOpts) => boolean;
+    ProjectivePoint: import("./abstract/weierstrass.js").ProjConstructor<bigint>;
+    Signature: import("./abstract/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, point?: import("./abstract/weierstrass.js").ProjPointType<bigint>) => import("./abstract/weierstrass.js").ProjPointType<bigint>;
+    };
+}>;
+export declare const secp521r1: Readonly<{
+    create: (hash: import("./abstract/utils.js").CHash) => import("./abstract/weierstrass.js").CurveFn;
+    CURVE: ReturnType<(curve: import("./abstract/weierstrass.js").CurveType) => Readonly<{
+        readonly nBitLength: number;
+        readonly nByteLength: number;
+        readonly Fp: import("./abstract/modular.js").IField<bigint>;
+        readonly n: bigint;
+        readonly h: bigint;
+        readonly hEff?: bigint;
+        readonly Gx: bigint;
+        readonly Gy: bigint;
+        readonly allowInfinityPoint?: boolean;
+        readonly a: bigint;
+        readonly b: bigint;
+        readonly allowedPrivateKeyLengths?: readonly number[];
+        readonly wrapPrivateKey?: boolean;
+        readonly endo?: {
+            beta: bigint;
+            splitScalar: (k: bigint) => {
+                k1neg: boolean;
+                k1: bigint;
+                k2neg: boolean;
+                k2: bigint;
+            };
+        };
+        readonly isTorsionFree?: ((c: import("./abstract/weierstrass.js").ProjConstructor<bigint>, point: import("./abstract/weierstrass.js").ProjPointType<bigint>) => boolean) | undefined;
+        readonly clearCofactor?: ((c: import("./abstract/weierstrass.js").ProjConstructor<bigint>, point: import("./abstract/weierstrass.js").ProjPointType<bigint>) => import("./abstract/weierstrass.js").ProjPointType<bigint>) | undefined;
+        readonly hash: import("./abstract/utils.js").CHash;
+        readonly hmac: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
+        readonly randomBytes: (bytesLength?: number) => Uint8Array;
+        lowS: boolean;
+        readonly bits2int?: (bytes: Uint8Array) => bigint;
+        readonly bits2int_modN?: (bytes: Uint8Array) => bigint;
+        readonly p: bigint;
+    }>>;
+    getPublicKey: (privateKey: import("./abstract/utils.js").PrivKey, isCompressed?: boolean) => Uint8Array;
+    getSharedSecret: (privateA: import("./abstract/utils.js").PrivKey, publicB: import("./abstract/utils.js").Hex, isCompressed?: boolean) => Uint8Array;
+    sign: (msgHash: import("./abstract/utils.js").Hex, privKey: import("./abstract/utils.js").PrivKey, opts?: import("./abstract/weierstrass.js").SignOpts) => import("./abstract/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("./abstract/weierstrass.js").VerOpts) => boolean;
+    ProjectivePoint: import("./abstract/weierstrass.js").ProjConstructor<bigint>;
+    Signature: import("./abstract/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, point?: import("./abstract/weierstrass.js").ProjPointType<bigint>) => import("./abstract/weierstrass.js").ProjPointType<bigint>;
+    };
+}>;
+export declare const hashToCurve: (msg: Uint8Array, options?: import("./abstract/hash-to-curve.js").htfBasicOpts) => import("./abstract/hash-to-curve.js").H2CPoint<bigint>;
+export declare const encodeToCurve: (msg: Uint8Array, options?: import("./abstract/hash-to-curve.js").htfBasicOpts) => import("./abstract/hash-to-curve.js").H2CPoint<bigint>;
+//# sourceMappingURL=p521.d.ts.map

package/test/node_modules/@noble/curves/p521.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p521.d.ts","sourceRoot":"","sources":["src/p521.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAiCijrB,CAAC;;;;;;kFAAwmB,CAAC;+HAA2F,CAAC;2GAAuE,CAAC;;;;qGAAoH,CAAC;;;;;;;+BAA+R,CAAC,eAAe,CAAC;;EAtBlutB,CAAC;AACpB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAqB4irB,CAAC;;;;;;kFAAwmB,CAAC;+HAA2F,CAAC;2GAAuE,CAAC;;;;qGAAoH,CAAC;;;;;;;+BAA+R,CAAC,eAAe,CAAC;;EArBxttB,CAAC;AAmB9B,eAAO,MAAM,WAAW,2IAA4C,CAAC;AACrE,eAAO,MAAM,aAAa,2IAA8C,CAAC"}

package/test/node_modules/@noble/curves/p521.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeToCurve = exports.hashToCurve = exports.secp521r1 = exports.p521 = void 0;
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const sha512_1 = require("@noble/hashes/sha512");
+const _shortw_utils_js_1 = require("./_shortw_utils.js");
+const hash_to_curve_js_1 = require("./abstract/hash-to-curve.js");
+const modular_js_1 = require("./abstract/modular.js");
+const weierstrass_js_1 = require("./abstract/weierstrass.js");
+// NIST secp521r1 aka p521
+// Note that it's 521, which differs from 512 of its hash function.
+// https://www.secg.org/sec2-v2.pdf, https://neuromancer.sk/std/nist/P-521
+// Field over which we'll do calculations.
+// prettier-ignore
+const P = BigInt('0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
+const Fp = (0, modular_js_1.Field)(P);
+const CURVE = {
+    a: Fp.create(BigInt('-3')),
+    b: BigInt('0x0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00'),
+    Fp,
+    n: BigInt('0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409'),
+    Gx: BigInt('0x00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66'),
+    Gy: BigInt('0x011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650'),
+    h: BigInt(1),
+};
+// prettier-ignore
+exports.p521 = (0, _shortw_utils_js_1.createCurve)({
+    a: CURVE.a, // Equation params: a, b
+    b: CURVE.b,
+    Fp, // Field: 2n**521n - 1n
+    // Curve order, total count of valid points in the field
+    n: CURVE.n,
+    Gx: CURVE.Gx, // Base point (x, y) aka generator point
+    Gy: CURVE.Gy,
+    h: CURVE.h,
+    lowS: false,
+    allowedPrivateKeyLengths: [130, 131, 132] // P521 keys are variable-length. Normalize to 132b
+}, sha512_1.sha512);
+exports.secp521r1 = exports.p521;
+const mapSWU = /* @__PURE__ */ (() => (0, weierstrass_js_1.mapToCurveSimpleSWU)(Fp, {
+    A: CURVE.a,
+    B: CURVE.b,
+    Z: Fp.create(BigInt('-4')),
+}))();
+const htf = /* @__PURE__ */ (() => (0, hash_to_curve_js_1.createHasher)(exports.secp521r1.ProjectivePoint, (scalars) => mapSWU(scalars[0]), {
+    DST: 'P521_XMD:SHA-512_SSWU_RO_',
+    encodeDST: 'P521_XMD:SHA-512_SSWU_NU_',
+    p: Fp.ORDER,
+    m: 1,
+    k: 256,
+    expand: 'xmd',
+    hash: sha512_1.sha512,
+}))();
+exports.hashToCurve = (() => htf.hashToCurve)();
+exports.encodeToCurve = (() => htf.encodeToCurve)();
+//# sourceMappingURL=p521.js.map

package/test/node_modules/@noble/curves/p521.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"p521.js","sourceRoot":"","sources":["src/p521.ts"],"names":[],"mappings":";;;AAAA,sEAAsE;AACtE,iDAA8C;AAC9C,yDAAiD;AACjD,kEAA2D;AAC3D,sDAA8C;AAC9C,8DAAgE;AAEhE,0BAA0B;AAC1B,mEAAmE;AACnE,0EAA0E;AAE1E,0CAA0C;AAC1C,kBAAkB;AAClB,MAAM,CAAC,GAAG,MAAM,CAAC,uIAAuI,CAAC,CAAC;AAC1J,MAAM,EAAE,GAAG,IAAA,kBAAK,EAAC,CAAC,CAAC,CAAC;AAEpB,MAAM,KAAK,GAAG;IACZ,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC,EAAE,MAAM,CACP,wIAAwI,CACzI;IACD,EAAE;IACF,CAAC,EAAE,MAAM,CACP,wIAAwI,CACzI;IACD,EAAE,EAAE,MAAM,CACR,wIAAwI,CACzI;IACD,EAAE,EAAE,MAAM,CACR,wIAAwI,CACzI;IACD,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;CACb,CAAC;AAEF,kBAAkB;AACL,QAAA,IAAI,GAAG,IAAA,8BAAW,EAAC;IAC9B,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,wBAAwB;IACpC,CAAC,EAAE,KAAK,CAAC,CAAC;IACV,EAAE,EAAE,uBAAuB;IAC3B,wDAAwD;IACxD,CAAC,EAAE,KAAK,CAAC,CAAC;IACV,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,wCAAwC;IACtD,EAAE,EAAE,KAAK,CAAC,EAAE;IACZ,CAAC,EAAE,KAAK,CAAC,CAAC;IACV,IAAI,EAAE,KAAK;IACX,wBAAwB,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,mDAAmD;CACrF,EAAE,eAAM,CAAC,CAAC;AACP,QAAA,SAAS,GAAG,YAAI,CAAC;AAE9B,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,GAAG,EAAE,CACnC,IAAA,oCAAmB,EAAC,EAAE,EAAE;IACtB,CAAC,EAAE,KAAK,CAAC,CAAC;IACV,CAAC,EAAE,KAAK,CAAC,CAAC;IACV,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAC3B,CAAC,CAAC,EAAE,CAAC;AAER,MAAM,GAAG,GAAG,eAAe,CAAC,CAAC,GAAG,EAAE,CAChC,IAAA,+BAAY,EAAC,iBAAS,CAAC,eAAe,EAAE,CAAC,OAAiB,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE;IACjF,GAAG,EAAE,2BAA2B;IAChC,SAAS,EAAE,2BAA2B;IACtC,CAAC,EAAE,EAAE,CAAC,KAAK;IACX,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,GAAG;IACN,MAAM,EAAE,KAAK;IACb,IAAI,EAAE,eAAM;CACb,CAAC,CAAC,EAAE,CAAC;AACK,QAAA,WAAW,GAAmB,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;AACxD,QAAA,aAAa,GAAmB,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC"}

package/test/node_modules/@noble/curves/package.json

@@ -0,0 +1,159 @@
+{
+  "name": "@noble/curves",
+  "version": "1.4.2",
+  "description": "Audited & minimal JS implementation of elliptic curve cryptography",
+  "files": [
+    "abstract",
+    "esm",
+    "src",
+    "*.js",
+    "*.js.map",
+    "*.d.ts",
+    "*.d.ts.map"
+  ],
+  "scripts": {
+    "bench": "cd benchmark; node secp256k1.js; node curves.js; node ecdh.js; node hash-to-curve.js; node modular.js; node bls.js; node ristretto255.js; node decaf448.js",
+    "build": "tsc && tsc -p tsconfig.esm.json",
+    "build:release": "cd build && npm i && npm run build",
+    "build:clean": "rm *.{js,d.ts,d.ts.map,js.map} esm/*.{js,d.ts,d.ts.map,js.map} 2> /dev/null",
+    "lint": "prettier --check 'src/**/*.{js,ts}' 'test/*.js'",
+    "format": "prettier --write 'src/**/*.{js,ts}' 'test/*.js'",
+    "test": "node test/index.test.js"
+  },
+  "author": "Paul Miller (https://paulmillr.com)",
+  "homepage": "https://paulmillr.com/noble/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paulmillr/noble-curves.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@noble/hashes": "1.4.0"
+  },
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.2.1",
+    "fast-check": "3.0.0",
+    "micro-bmark": "0.3.1",
+    "micro-should": "0.4.0",
+    "prettier": "3.3.2",
+    "typescript": "5.5.2"
+  },
+  "sideEffects": false,
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    },
+    "./abstract/edwards": {
+      "import": "./esm/abstract/edwards.js",
+      "require": "./abstract/edwards.js"
+    },
+    "./abstract/modular": {
+      "import": "./esm/abstract/modular.js",
+      "require": "./abstract/modular.js"
+    },
+    "./abstract/montgomery": {
+      "import": "./esm/abstract/montgomery.js",
+      "require": "./abstract/montgomery.js"
+    },
+    "./abstract/weierstrass": {
+      "import": "./esm/abstract/weierstrass.js",
+      "require": "./abstract/weierstrass.js"
+    },
+    "./abstract/bls": {
+      "import": "./esm/abstract/bls.js",
+      "require": "./abstract/bls.js"
+    },
+    "./abstract/hash-to-curve": {
+      "import": "./esm/abstract/hash-to-curve.js",
+      "require": "./abstract/hash-to-curve.js"
+    },
+    "./abstract/curve": {
+      "import": "./esm/abstract/curve.js",
+      "require": "./abstract/curve.js"
+    },
+    "./abstract/utils": {
+      "import": "./esm/abstract/utils.js",
+      "require": "./abstract/utils.js"
+    },
+    "./abstract/poseidon": {
+      "import": "./esm/abstract/poseidon.js",
+      "require": "./abstract/poseidon.js"
+    },
+    "./_shortw_utils": {
+      "import": "./esm/_shortw_utils.js",
+      "require": "./_shortw_utils.js"
+    },
+    "./bls12-381": {
+      "import": "./esm/bls12-381.js",
+      "require": "./bls12-381.js"
+    },
+    "./bn254": {
+      "import": "./esm/bn254.js",
+      "require": "./bn254.js"
+    },
+    "./ed25519": {
+      "import": "./esm/ed25519.js",
+      "require": "./ed25519.js"
+    },
+    "./ed448": {
+      "import": "./esm/ed448.js",
+      "require": "./ed448.js"
+    },
+    "./index": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    },
+    "./jubjub": {
+      "import": "./esm/jubjub.js",
+      "require": "./jubjub.js"
+    },
+    "./p256": {
+      "import": "./esm/p256.js",
+      "require": "./p256.js"
+    },
+    "./p384": {
+      "import": "./esm/p384.js",
+      "require": "./p384.js"
+    },
+    "./p521": {
+      "import": "./esm/p521.js",
+      "require": "./p521.js"
+    },
+    "./pasta": {
+      "import": "./esm/pasta.js",
+      "require": "./pasta.js"
+    },
+    "./secp256k1": {
+      "import": "./esm/secp256k1.js",
+      "require": "./secp256k1.js"
+    }
+  },
+  "keywords": [
+    "elliptic",
+    "curve",
+    "cryptography",
+    "secp256k1",
+    "ed25519",
+    "p256",
+    "p384",
+    "p521",
+    "secp256r1",
+    "ed448",
+    "x25519",
+    "ed25519",
+    "bls12-381",
+    "bn254",
+    "bls",
+    "noble",
+    "ecc",
+    "ecdsa",
+    "eddsa",
+    "weierstrass",
+    "montgomery",
+    "edwards",
+    "schnorr"
+  ],
+  "funding": "https://paulmillr.com/funding/"
+}

package/test/node_modules/@noble/curves/pasta.d.ts

@@ -0,0 +1,5 @@
+export declare const p: bigint;
+export declare const q: bigint;
+export declare const pallas: import("./abstract/weierstrass.js").CurveFn;
+export declare const vesta: import("./abstract/weierstrass.js").CurveFn;
+//# sourceMappingURL=pasta.d.ts.map

package/test/node_modules/@noble/curves/pasta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pasta.d.ts","sourceRoot":"","sources":["src/pasta.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,CAAC,QAA+E,CAAC;AAC9F,eAAO,MAAM,CAAC,QAA+E,CAAC;AAG9F,eAAO,MAAM,MAAM,6CASjB,CAAC;AAEH,eAAO,MAAM,KAAK,6CAShB,CAAC"}

package/test/node_modules/@noble/curves/pasta.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vesta = exports.pallas = exports.q = exports.p = void 0;
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const sha256_1 = require("@noble/hashes/sha256");
+const _shortw_utils_js_1 = require("./_shortw_utils.js");
+const modular_js_1 = require("./abstract/modular.js");
+const weierstrass_js_1 = require("./abstract/weierstrass.js");
+exports.p = BigInt('0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001');
+exports.q = BigInt('0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001');
+// https://neuromancer.sk/std/other/Pallas
+exports.pallas = (0, weierstrass_js_1.weierstrass)({
+    a: BigInt(0),
+    b: BigInt(5),
+    Fp: (0, modular_js_1.Field)(exports.p),
+    n: exports.q,
+    Gx: (0, modular_js_1.mod)(BigInt(-1), exports.p),
+    Gy: BigInt(2),
+    h: BigInt(1),
+    ...(0, _shortw_utils_js_1.getHash)(sha256_1.sha256),
+});
+// https://neuromancer.sk/std/other/Vesta
+exports.vesta = (0, weierstrass_js_1.weierstrass)({
+    a: BigInt(0),
+    b: BigInt(5),
+    Fp: (0, modular_js_1.Field)(exports.q),
+    n: exports.p,
+    Gx: (0, modular_js_1.mod)(BigInt(-1), exports.q),
+    Gy: BigInt(2),
+    h: BigInt(1),
+    ...(0, _shortw_utils_js_1.getHash)(sha256_1.sha256),
+});
+//# sourceMappingURL=pasta.js.map

package/test/node_modules/@noble/curves/pasta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pasta.js","sourceRoot":"","sources":["src/pasta.ts"],"names":[],"mappings":";;;AAAA,sEAAsE;AACtE,iDAA8C;AAC9C,yDAA6C;AAC7C,sDAAmD;AACnD,8DAAwD;AAE3C,QAAA,CAAC,GAAG,MAAM,CAAC,oEAAoE,CAAC,CAAC;AACjF,QAAA,CAAC,GAAG,MAAM,CAAC,oEAAoE,CAAC,CAAC;AAE9F,0CAA0C;AAC7B,QAAA,MAAM,GAAG,IAAA,4BAAW,EAAC;IAChC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACZ,EAAE,EAAE,IAAA,kBAAK,EAAC,SAAC,CAAC;IACZ,CAAC,EAAE,SAAC;IACJ,EAAE,EAAE,IAAA,gBAAG,EAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,SAAC,CAAC;IACtB,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;IACb,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACZ,GAAG,IAAA,0BAAO,EAAC,eAAM,CAAC;CACnB,CAAC,CAAC;AACH,yCAAyC;AAC5B,QAAA,KAAK,GAAG,IAAA,4BAAW,EAAC;IAC/B,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACZ,EAAE,EAAE,IAAA,kBAAK,EAAC,SAAC,CAAC;IACZ,CAAC,EAAE,SAAC;IACJ,EAAE,EAAE,IAAA,gBAAG,EAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,SAAC,CAAC;IACtB,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;IACb,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IACZ,GAAG,IAAA,0BAAO,EAAC,eAAM,CAAC;CACnB,CAAC,CAAC"}

package/test/node_modules/@noble/curves/secp256k1.d.ts

@@ -0,0 +1,93 @@
+import { mod } from './abstract/modular.js';
+import type { Hex, PrivKey } from './abstract/utils.js';
+import { bytesToNumberBE, numberToBytesBE } from './abstract/utils.js';
+import { ProjPointType as PointType } from './abstract/weierstrass.js';
+export declare const secp256k1: Readonly<{
+    create: (hash: import("./abstract/utils.js").CHash) => import("./abstract/weierstrass.js").CurveFn;
+    CURVE: ReturnType<(curve: import("./abstract/weierstrass.js").CurveType) => Readonly<{
+        readonly nBitLength: number;
+        readonly nByteLength: number;
+        readonly Fp: import("./abstract/modular.js").IField<bigint>;
+        readonly n: bigint;
+        readonly h: bigint;
+        readonly hEff?: bigint;
+        readonly Gx: bigint;
+        readonly Gy: bigint;
+        readonly allowInfinityPoint?: boolean;
+        readonly a: bigint;
+        readonly b: bigint;
+        readonly allowedPrivateKeyLengths?: readonly number[];
+        readonly wrapPrivateKey?: boolean;
+        readonly endo?: {
+            beta: bigint;
+            splitScalar: (k: bigint) => {
+                k1neg: boolean;
+                k1: bigint;
+                k2neg: boolean;
+                k2: bigint;
+            };
+        };
+        readonly isTorsionFree?: ((c: import("./abstract/weierstrass.js").ProjConstructor<bigint>, point: PointType<bigint>) => boolean) | undefined;
+        readonly clearCofactor?: ((c: import("./abstract/weierstrass.js").ProjConstructor<bigint>, point: PointType<bigint>) => PointType<bigint>) | undefined;
+        readonly hash: import("./abstract/utils.js").CHash;
+        readonly hmac: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
+        readonly randomBytes: (bytesLength?: number) => Uint8Array;
+        lowS: boolean;
+        readonly bits2int?: (bytes: Uint8Array) => bigint;
+        readonly bits2int_modN?: (bytes: Uint8Array) => bigint;
+        readonly p: bigint;
+    }>>;
+    getPublicKey: (privateKey: PrivKey, isCompressed?: boolean) => Uint8Array;
+    getSharedSecret: (privateA: PrivKey, publicB: Hex, isCompressed?: boolean) => Uint8Array;
+    sign: (msgHash: Hex, privKey: PrivKey, opts?: import("./abstract/weierstrass.js").SignOpts) => import("./abstract/weierstrass.js").RecoveredSignatureType;
+    verify: (signature: Hex | {
+        r: bigint;
+        s: bigint;
+    }, msgHash: Hex, publicKey: Hex, opts?: import("./abstract/weierstrass.js").VerOpts) => boolean;
+    ProjectivePoint: import("./abstract/weierstrass.js").ProjConstructor<bigint>;
+    Signature: import("./abstract/weierstrass.js").SignatureConstructor;
+    utils: {
+        normPrivateKeyToScalar: (key: PrivKey) => bigint;
+        isValidPrivateKey(privateKey: PrivKey): boolean;
+        randomPrivateKey: () => Uint8Array;
+        precompute: (windowSize?: number, point?: PointType<bigint>) => PointType<bigint>;
+    };
+}>;
+declare function taggedHash(tag: string, ...messages: Uint8Array[]): Uint8Array;
+/**
+ * lift_x from BIP340. Convert 32-byte x coordinate to elliptic curve point.
+ * @returns valid point checked for being on-curve
+ */
+declare function lift_x(x: bigint): PointType<bigint>;
+/**
+ * Schnorr public key is just `x` coordinate of Point as per BIP340.
+ */
+declare function schnorrGetPublicKey(privateKey: Hex): Uint8Array;
+/**
+ * Creates Schnorr signature as per BIP340. Verifies itself before returning anything.
+ * auxRand is optional and is not the sole source of k generation: bad CSPRNG won't be dangerous.
+ */
+declare function schnorrSign(message: Hex, privateKey: PrivKey, auxRand?: Hex): Uint8Array;
+/**
+ * Verifies Schnorr signature.
+ * Will swallow errors & return false except for initial type validation of arguments.
+ */
+declare function schnorrVerify(signature: Hex, message: Hex, publicKey: Hex): boolean;
+export declare const schnorr: {
+    getPublicKey: typeof schnorrGetPublicKey;
+    sign: typeof schnorrSign;
+    verify: typeof schnorrVerify;
+    utils: {
+        randomPrivateKey: () => Uint8Array;
+        lift_x: typeof lift_x;
+        pointToBytes: (point: PointType<bigint>) => Uint8Array;
+        numberToBytesBE: typeof numberToBytesBE;
+        bytesToNumberBE: typeof bytesToNumberBE;
+        taggedHash: typeof taggedHash;
+        mod: typeof mod;
+    };
+};
+export declare const hashToCurve: (msg: Uint8Array, options?: import("./abstract/hash-to-curve.js").htfBasicOpts) => import("./abstract/hash-to-curve.js").H2CPoint<bigint>;
+export declare const encodeToCurve: (msg: Uint8Array, options?: import("./abstract/hash-to-curve.js").htfBasicOpts) => import("./abstract/hash-to-curve.js").H2CPoint<bigint>;
+export {};
+//# sourceMappingURL=secp256k1.d.ts.map

package/test/node_modules/@noble/curves/secp256k1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1.d.ts","sourceRoot":"","sources":["src/secp256k1.ts"],"names":[],"mappings":"AAKA,OAAO,EAAS,GAAG,EAAQ,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,eAAe,EAA4B,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACjG,OAAO,EAAE,aAAa,IAAI,SAAS,EAAuB,MAAM,2BAA2B,CAAC;AAsC5F,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAoOq0Y,CAAC;;;;;;oDAAwmB,CAAC;mEAA2F,CAAC;+CAAuE,CAAC;;;;yCAAoH,CAAC;;;;;;;+BAA+R,CAAC,eAAe,CAAC;;EAzL7gb,CAAC;AASF,iBAAS,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,CAQtE;AAkBD;;;GAGG;AACH,iBAAS,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC,CAS5C;AAQD;;GAEG;AACH,iBAAS,mBAAmB,CAAC,UAAU,EAAE,GAAG,GAAG,UAAU,CAExD;AAED;;;GAGG;AACH,iBAAS,WAAW,CAClB,OAAO,EAAE,GAAG,EACZ,UAAU,EAAE,OAAO,EACnB,OAAO,GAAE,GAAqB,GAC7B,UAAU,CAgBZ;AAED;;;GAGG;AACH,iBAAS,aAAa,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,GAAG,OAAO,CAiB5E;AAED,eAAO,MAAM,OAAO;;;;;;;8BA5FS,SAAS,CAAC,MAAM,CAAC;;;;;;CAyGzC,CAAC;AA0DN,eAAO,MAAM,WAAW,2IAA4C,CAAC;AACrE,eAAO,MAAM,aAAa,2IAA8C,CAAC"}