functionalscript 0.8.1 → 0.9.1

package/README.md

@@ -29,19 +29,19 @@ Install FunctionalScript via npm:
 npm install functionalscript
 ```
 
-The FunctionalScript compiler (`fsc`) currently supports:
+The FunctionalScript compiler command (`fjs compile`) currently supports:
 
 * `import` statements
 * `const` declarations
 
 It does **not** yet support functions or complex expressions.
 
-Example usage with `fsc`:
+Example usage with `fjs`:
 
 ```bash
-npx fsc example.f.js output.json
+npx fjs compile example.f.js output.json
 # or
-npx fsc example.f.js output.f.js
+npx fjs compile example.f.js output.f.js
 ```
 
 FunctionalScript code can be compiled directly into either JSON or JavaScript without imports.

package/bnf/data/module.f.d.ts

@@ -29,7 +29,15 @@ type DispatchMap = {
 type EmptyTagMap = {
     readonly [id in string]: EmptyTagEntry;
 };
-export type DescentMatchRule = (r: Rule, s: readonly CodePoint[], idx: number) => MatchResult;
+export type DescentMatchRule<T> = (name: string, tag: AstTag, s: readonly CodePointMeta<T>[], idx: number) => DescentMatchResult<T>;
+export type DescentMatchResult<T> = readonly [AstRuleMeta<T>, boolean, number];
+export type DescentMatch<T> = (name: string, s: readonly CodePointMeta<T>[]) => DescentMatchResult<T>;
+export type CodePointMeta<T> = readonly [CodePoint, T];
+export type AstSequenceMeta<T> = readonly (AstRuleMeta<T> | CodePointMeta<T>)[];
+export type AstRuleMeta<T> = {
+    readonly tag: AstTag;
+    readonly sequence: AstSequenceMeta<T>;
+};
 /**
  * Represents a parsed Abstract Syntax Tree (AST) sequence.
  */
@@ -58,6 +66,7 @@ export type MatchRule = (dr: DispatchRule, s: readonly CodePoint[]) => MatchResu
 export declare const toData: (fr: FRule) => readonly [RuleSet, string];
 export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
 export declare const createEmptyTagMap: (data: readonly [RuleSet, string]) => EmptyTagMap;
+export declare const descentParser: <T>(fr: FRule) => DescentMatch<T>;
 export declare const parser: (fr: FRule) => Match;
 export declare const parserRuleSet: (ruleSet: RuleSet) => Match;
 export {};

package/bnf/data/module.f.js

@@ -3,6 +3,7 @@ import { strictEqual } from "../../types/function/operator/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
 import { rangeMap } from "../../types/range_map/module.f.js";
 import { contains, set } from "../../types/string_set/module.f.js";
+import { contains as rangeContains } from "../../types/range/module.f.js";
 import { oneEncode, rangeDecode, } from "../module.f.js";
 const { entries } = Object;
 const find = (map) => (fr) => {
@@ -198,25 +199,63 @@ const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
 export const createEmptyTagMap = (data) => {
     return emptyTagMapAdd(data[0])({})(data[1])[1];
 };
-// export const parserDescent = (fr: FRule): Match => {
-//     const data = toData(fr)
-//     const getEmptyTag = (rule: Rule): EmptyTag => {
-//         return todo()
-//     }
-//     const f: DescentMatchRule = (r, cp, idx): MatchResult => {
-//         const mrSuccess = (tag: AstTag, sequence: AstSequence, r: Remainder): MatchResult => [{tag, sequence}, true, r]
-//         const mrFail = (tag: AstTag, sequence: AstSequence, r: Remainder): MatchResult => [{tag, sequence}, false, r]
-//         if (idx >= cp.length) {
-//             const emptyTag = getEmptyTag(r)
-//             return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp)
-//         }
-//         return todo()
-//     }
-//     const match: Match = (name, cp): MatchResult => {
-//         return f(data[0][name], cp, 0)
-//     }
-//     return match
-// }
+export const descentParser = (fr) => {
+    const data = toData(fr);
+    const emptyTagMap = createEmptyTagMap(data);
+    const getEmptyTag = (name) => {
+        const res = emptyTagMap[name];
+        return res === false ? undefined : res;
+    };
+    const f = (name, tag, cp, idx) => {
+        const mrSuccess = (tag, sequence, idx) => [{ tag, sequence }, true, idx];
+        const mrFail = (tag, sequence, idx) => [{ tag, sequence }, false, idx];
+        const rule = data[0][name];
+        if (typeof rule === 'number') {
+            const emptyTag = getEmptyTag(name);
+            if (idx >= cp.length) {
+                return emptyTag === undefined ? mrFail(emptyTag, [], idx) : mrSuccess(emptyTag, [], idx);
+            }
+            const cpi = cp[idx];
+            const range = rangeDecode(rule);
+            if (rangeContains(range)(cpi[0])) {
+                return mrSuccess(tag, [cpi], idx + 1);
+            }
+            return mrFail(emptyTag, [], idx);
+        }
+        else if (rule instanceof Array) {
+            let seq = [];
+            let tidx = idx;
+            for (const item of rule) {
+                const m = f(item, undefined, cp, tidx);
+                const [astRule, success, nidx] = m;
+                tidx = nidx;
+                if (success === false) {
+                    return mrFail(tag, [], idx);
+                }
+                seq = [...seq, astRule];
+            }
+            return mrSuccess(tag, seq, tidx);
+        }
+        else {
+            const entries = Object.entries(rule);
+            const emptyTag = getEmptyTag(name);
+            let emptyResult = mrFail(emptyTag, [], idx);
+            for (const [tag, item] of entries) {
+                const m = f(item, tag, cp, idx);
+                if (m[1]) {
+                    if (idx !== m[2])
+                        return m;
+                    emptyResult = m;
+                }
+            }
+            return emptyResult;
+        }
+    };
+    const match = (name, cp) => {
+        return f(name, undefined, cp, 0);
+    };
+    return match;
+};
 export const parser = (fr) => {
     const data = toData(fr);
     return parserRuleSet(data[0]);

package/bnf/data/test.f.d.ts

@@ -4,6 +4,8 @@ declare const _default: {
     variantTest: () => void;
     dispatch: (() => void)[];
     parser: (() => void)[];
+    descentParser: (() => void)[];
+    descentParserWithMeta: (() => void)[];
     repeat: (() => void)[];
     repeatParser: (() => void)[];
     example: () => void;

package/bnf/data/test.f.js

@@ -1,11 +1,16 @@
 import { stringify } from "../../json/module.f.js";
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { identity } from "../../types/function/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-import { join0Plus, max, option, range, remove, repeat, repeat0Plus, set } from "../module.f.js";
+import { join0Plus, option, range, repeat0Plus, set } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
-import { dispatchMap, parser, parserRuleSet, toData, createEmptyTagMap } from "./module.f.js";
+import { dispatchMap, parser, parserRuleSet, toData, createEmptyTagMap, descentParser } from "./module.f.js";
+const mapCodePoint = (cp) => [cp, undefined];
+const descentParserCpOnly = (m, name, cp) => {
+    const cpm = toArray(map(mapCodePoint)(cp));
+    return m(name, cpm);
+};
 export default {
     toData: [
         () => {
@@ -366,6 +371,19 @@ export default {
                 throw result;
             }
         },
+        () => {
+            const emptyRule = '';
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = parser(numberRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},true,null]') {
+                throw result;
+            } //if remainder is null it means failed
+        },
         () => {
             const m = parser(option('a'));
             const isSuccess = (mr) => mr[1] && mr[2]?.length === 0;
@@ -401,6 +419,7 @@ export default {
                     throw mr;
                 }
             };
+            expect('', false);
             expect('[]', true);
             expect('[a]', true);
             expect('[a, a]', true);
@@ -437,6 +456,228 @@ export default {
             expect('   [{ "q": [ 12, false, [}], "a"] }]  ', false);
         }
     ],
+    descentParser: [
+        () => {
+            const emptyRule = '';
+            const m = descentParser(emptyRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},true,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const m = descentParser(emptyRule);
+            const mr = descentParserCpOnly(m, "", [65, 70]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},true,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const m = descentParser(terminalRangeRule);
+            const mr = descentParserCpOnly(m, "", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[[65,null]]},true,1]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const m = descentParser(terminalRangeRule);
+            const mr = descentParserCpOnly(m, "", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const m = descentParser(variantRule);
+            const mr = descentParserCpOnly(m, "", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"a","sequence":[[65,null]]},true,1]') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const m = descentParser(variantRule);
+            const mr = descentParserCpOnly(m, "", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const m = descentParser(variantRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"e","sequence":[]},true,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const m = descentParser(variantRule);
+            const mr = descentParserCpOnly(m, "", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"e","sequence":[]},true,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const m = descentParser(stringRule);
+            const mr = descentParserCpOnly(m, "", [65, 66]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[{"sequence":[[65,null]]},{"sequence":[[66,null]]}]},true,2]') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const m = descentParser(stringRule);
+            const mr = descentParserCpOnly(m, "", [65, 67]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minursRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = descentParser(numberRule);
+            const mr = descentParserCpOnly(m, "", [50]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[{"tag":"none","sequence":[]},{"sequence":[[50,null]]}]},true,1]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = descentParser(numberRule);
+            const mr = descentParserCpOnly(m, "", [45, 50]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[{"tag":"minus","sequence":[[45,null]]},{"sequence":[[50,null]]}]},true,2]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minursRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = descentParser(numberRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const m = descentParser(option('a'));
+            const expect = (s, expected) => {
+                const cp = toArray(stringToCodePointList(s));
+                const mr = descentParserCpOnly(m, '', cp);
+                const success = mr[1] && mr[2] === cp.length;
+                if (success !== expected) {
+                    throw mr;
+                }
+            };
+            expect('a', true);
+            expect('', true);
+            expect('aa', false);
+            expect('b', false);
+        },
+        () => {
+            const ws = repeat0Plus(set(' \n\r\t'));
+            const commaJoin0Plus = ([open, close], a) => [
+                open,
+                ws,
+                join0Plus([a, ws], [',', ws]),
+                close,
+            ];
+            const value = () => ({
+                object: commaJoin0Plus('{}', 'a'),
+                array: commaJoin0Plus('[]', 'a')
+            });
+            value.name; //bun will fail if no usage of name found
+            const m = descentParser(value);
+            const expect = (s, expected) => {
+                const cp = toArray(stringToCodePointList(s));
+                const mr = descentParserCpOnly(m, 'value', cp);
+                const success = mr[1] && mr[2] === cp.length;
+                if (success !== expected) {
+                    throw mr;
+                }
+            };
+            expect('', false);
+            expect('[]', true);
+            expect('[a]', true);
+            expect('[a, a]', true);
+            expect('{a}', true);
+        },
+        () => {
+            const m = descentParser(deterministic());
+            const expect = (s, expected) => {
+                const cp = toArray(stringToCodePointList(s));
+                const mr = descentParserCpOnly(m, '', cp);
+                const success = mr[1] && mr[2] === cp.length;
+                if (success !== expected) {
+                    throw mr;
+                }
+            };
+            expect('   true   ', true);
+            expect('   tr2ue   ', false);
+            expect('   true"   ', false);
+            expect('   "Hello"   ', true);
+            expect('   "Hello   ', false);
+            expect('   "Hello\\n\\r\\""   ', true);
+            expect('   -56.7e+5  ', true);
+            expect('   h-56.7e+5   ', false);
+            expect('   -56.7e+5   3', false);
+            expect('   [] ', true);
+            expect('   {} ', true);
+            expect('   [[[]]] ', true);
+            expect('   [1] ', true);
+            expect('   [ 12, false, "a"]  ', true);
+            expect('   [ 12, false2, "a"]  ', false);
+            expect('   { "q": [ 12, false, [{"b" : "c"}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [}], "a"] }  ', false);
+            expect('   [{ "q": [ 12, false, [{}], "a"] }]  ', true);
+            expect('   [{ "q": [ 12, false, [}], "a"] }]  ', false);
+        }
+    ],
+    descentParserWithMeta: [
+        () => {
+            const emptyRule = '';
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = descentParser(numberRule);
+            const mr = m("", [[45, 'minus'], [50, 'two']]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[{"tag":"minus","sequence":[[45,"minus"]]},{"sequence":[[50,"two"]]}]},true,2]') {
+                throw result;
+            }
+        },
+    ],
     repeat: [
         () => {
             const repeatData = [{ "": ["ws", "repa"], "ws": [], "repa": ["a", ""], "a": 1090519105 }, ""];

package/cas/module.f.d.ts

@@ -0,0 +1,17 @@
+import { type Sha2 } from "../crypto/sha2/module.f.ts";
+import type { Io } from "../io/module.f.ts";
+import { type Vec } from "../types/bit_vec/module.f.ts";
+export type KvStore = {
+    readonly read: (key: Vec) => Promise<Vec | undefined>;
+    readonly write: (key: Vec, value: Vec) => Promise<KvStore>;
+    readonly list: () => Promise<Iterable<Vec>>;
+};
+export type Kv = readonly [Vec, Vec];
+export declare const memKvStore: () => KvStore;
+export declare const fileKvStore: (io: Io) => (path: string) => KvStore;
+export type Cas = {
+    readonly read: (key: Vec) => Promise<Vec | undefined>;
+    readonly write: (value: Vec) => Promise<readonly [Cas, Vec]>;
+    readonly list: () => Promise<Iterable<Vec>>;
+};
+export declare const cas: (sha2: Sha2) => (s: KvStore) => Cas;

package/cas/module.f.js

@@ -0,0 +1,77 @@
+import { computeSync } from "../crypto/sha2/module.f.js";
+import { todo } from "../dev/module.f.js";
+import {} from "../types/bit_vec/module.f.js";
+import { cBase32ToVec, vecToCBase32 } from "../types/cbase32/module.f.js";
+import { compose } from "../types/function/module.f.js";
+import { toOption } from "../types/nullable/module.f.js";
+import { fromVec, toVec } from "../types/uint8array/module.f.js";
+export const memKvStore = () => {
+    const create = (...i) => {
+        const store = new Map(i);
+        return {
+            read: async (key) => store.get(key),
+            write: async (...kv) => create(...store, kv),
+            list: async () => store.keys(),
+        };
+    };
+    return create();
+};
+const o = { withFileTypes: true };
+const split = (s) => [s.substring(0, 2), s.substring(2)];
+const toPath = (key) => {
+    const s = vecToCBase32(key);
+    const [a, bc] = split(s);
+    const [b, c] = split(bc);
+    return `${a}/${b}/${c}`;
+};
+export const fileKvStore = (io) => (path) => {
+    const { readdir, readFile, writeFile } = io.fs.promises;
+    const { asyncTryCatch } = io;
+    const result = {
+        read: async (key) => {
+            const p = toPath(key);
+            const [s, v] = await asyncTryCatch(() => readFile(`${path}/${p}`));
+            if (s === 'error') {
+                return undefined;
+            }
+            return toVec(v);
+        },
+        write: async (key, value) => {
+            const p = toPath(key);
+            await writeFile(`${path}/${p}`, fromVec(value));
+            return result;
+        },
+        list: async () => {
+            const f = async (p) => {
+                const dir = await readdir(p, o);
+                let result = [];
+                for (const entry of dir) {
+                    const { name } = entry;
+                    if (entry.isFile()) {
+                        result = [...result, name];
+                        continue;
+                    }
+                    // directory
+                    const sub = await f(`${p}/${name}`);
+                    result = [...result, ...sub.map(x => `${name}${x}`)];
+                }
+                return result;
+            };
+            const all = await f(path);
+            return all.flatMap(compose(cBase32ToVec)(toOption));
+        },
+    };
+    return result;
+};
+export const cas = (sha2) => {
+    const compute = computeSync(sha2);
+    const f = ({ read, list, write }) => ({
+        read,
+        write: async (value) => {
+            const hash = compute([value]);
+            return [f(await write(hash, value)), hash];
+        },
+        list,
+    });
+    return f;
+};

package/cas/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/cas/test.f.js

@@ -0,0 +1 @@
+export default () => { };

package/ci/module.f.js

@@ -1,3 +1,4 @@
+import { encodeUtf8 } from "../types/uint8array/module.f.js";
 const os = ['ubuntu', 'macos', 'windows'];
 const architecture = ['intel', 'arm'];
 // https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
@@ -73,7 +74,7 @@ const toSteps = (m) => {
         ...(rust ? [{
                 // wasm32-wasip1-threads doesn't work on Rust 1.91 in the release mode.
                 // See https://github.com/sergey-shandar/wasmtime-crash
-                uses: 'dtolnay/rust-toolchain@1.90.0',
+                uses: 'dtolnay/rust-toolchain@1.92.0',
                 with: {
                     components: 'rustfmt,clippy',
                     targets
@@ -128,8 +129,8 @@ const steps = (v) => (a) => {
             // publishing
             test({ run: 'npm pack' }),
             test({ run: `npm install -g ${findTgz(v)}` }),
-            test({ run: 'fsc issues/demo/data/tree.json _tree.f.js' }),
-            test({ run: 'fst' }),
+            test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
+            test({ run: 'fjs t' }),
             test({ run: 'npm uninstall functionalscript -g' }),
         ]),
         // Deno
@@ -137,14 +138,15 @@ const steps = (v) => (a) => {
             installDeno(v)(a),
             test({ run: 'deno install' }),
             test({ run: 'deno task test' }),
-            test({ run: 'deno task fst' }),
+            test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
+            test({ run: 'deno task fjs t' }),
             test({ run: 'deno publish --dry-run' }),
         ]),
         // Bun
         ...clean([
             installBun(v)(a),
             test({ run: 'bun test --timeout 20000' }),
-            test({ run: 'bun ./dev/tf/module.ts' }),
+            test({ run: 'bun ./fjs/module.ts t' }),
         ]),
     ];
     return toSteps(result);
@@ -164,6 +166,6 @@ const gha = {
     jobs,
 };
 export default async (io) => {
-    io.fs.writeFileSync('.github/workflows/ci.yml', JSON.stringify(gha, null, '  '));
+    io.fs.writeFileSync('.github/workflows/ci.yml', encodeUtf8(JSON.stringify(gha, null, '  ')));
     return 0;
 };

package/crypto/secp/module.f.d.ts

@@ -1,5 +1,5 @@
 import type { Equal, Fold, Reduce } from '../../types/function/operator/module.f.ts';
-import { type PrimeField } from '../prime_field/module.f.ts';
+import { type PrimeField } from '../../types/prime_field/module.f.ts';
 /**
  * A 2D point represented as a pair of `bigint` values `[x, y]`.
  */
@@ -24,6 +24,7 @@ export type Init = {
 export type Curve = {
     readonly pf: PrimeField;
     readonly nf: PrimeField;
+    readonly g: Point;
     readonly y2: (x: bigint) => bigint;
     readonly y: (x: bigint) => bigint | null;
     readonly neg: (a: Point) => Point;
@@ -50,27 +51,29 @@ export type Curve = {
  * const mulPoint = curveInstance.mul([1n, 1n])(3n); // Multiply a point by 3
  * ```
  */
-export declare const curve: ({ p, a: [a0, a1], n }: Init) => Curve;
+export declare const curve: ({ p, a: [a0, a1], n, g }: Init) => Curve;
 export declare const eq: Equal<Point>;
 /**
  * https://neuromancer.sk/std/secg/secp192r1
+ * NIST P-192
  */
-export declare const secp192r1: Init;
+export declare const secp192r1: Curve;
 /**
  * https://en.bitcoin.it/wiki/Secp256k1
  * https://neuromancer.sk/std/secg/secp256k1
  */
-export declare const secp256k1: Init;
+export declare const secp256k1: Curve;
 /**
  * https://neuromancer.sk/std/secg/secp256r1
+ * NIST P-256
  */
-export declare const secp256r1: Init;
+export declare const secp256r1: Curve;
 /**
  * https://neuromancer.sk/std/secg/secp384r1
  */
-export declare const secp384r1: Init;
+export declare const secp384r1: Curve;
 /**
  * https://neuromancer.sk/std/secg/secp521r1
  */
-export declare const secp521r1: Init;
+export declare const secp521r1: Curve;
 export {};