functionalscript 0.1.593 → 0.1.596

package/fsc/module.f.d.mts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    export { terminal };
+    export { init };
+}
+export default _default;
+export type Result = readonly [readonly string[], ToResult];
+export type ToResult = (codePoint: number) => Result;
+export type CreateToResult<T> = (state: T) => ToResult;
+export type State<T> = RM.RangeMapArray<CreateToResult<T>>;
+declare const terminal: -1;
+declare const init: ToResult;
+import * as RM from '../types/range_map/module.f.mjs';

package/fsc/test.f.d.mts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function a(): void;
+}
+export default _default;

package/fsm/module.f.d.mts

@@ -0,0 +1,21 @@
+declare namespace _default {
+    export { dfa };
+    export { run };
+    export { toRange };
+    export { toUnion };
+}
+export default _default;
+export type Rule = readonly [string, byteSetT.ByteSet, string];
+export type Grammar = List.List<Rule>;
+export type Dfa = { readonly [state in string]: RM.RangeMapArray<string>; };
+/** @type {(grammar: Grammar) => Dfa} */
+declare const dfa: (grammar: Grammar) => Dfa;
+/** @type {(dfa: Dfa) => (input: List.List<number>) => List.List<string>} */
+declare const run: (dfa: Dfa) => (input: List.List<number>) => List.List<string>;
+/** @type {(s: string) => byteSetT.ByteSet} */
+declare const toRange: (s: string) => byteSetT.ByteSet;
+/** @type {(s: string) => byteSetT.ByteSet} */
+declare const toUnion: (s: string) => byteSetT.ByteSet;
+import * as byteSetT from '../types/byte_set/module.f.mjs';
+import * as List from '../types/list/module.f.mjs';
+import * as RM from '../types/range_map/module.f.mjs';

package/fsm/test.f.d.mts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    function dfa(): void;
+    let run: (() => void)[];
+}
+export default _default;

package/html/module.f.d.mts

@@ -0,0 +1,20 @@
+declare namespace _default {
+    export { element };
+    export { html };
+    export { htmlToString };
+}
+export default _default;
+export type Tag = string;
+export type Element1 = readonly [Tag];
+export type Element2A = readonly [Tag, Attributes];
+export type Element2N = readonly [Tag, readonly Node[]];
+export type Element3 = readonly [Tag, Attributes, Nodes];
+export type Element = Element1 | Element2A | Element2N | Element3;
+export type Attributes = { readonly [k in string]: string; };
+export type Nodes = List.List<Node>;
+export type Node = Element | string;
+/** @type {(element: Element) => List.List<string>} */
+declare const element: (element: Element) => List.List<string>;
+declare const html: import("../types/function/module.f.mjs").Func<Element, List.List<string>>;
+declare const htmlToString: import("../types/function/module.f.mjs").Func<Element, string>;
+import * as List from '../types/list/module.f.mjs';

package/html/test.f.d.mts

@@ -0,0 +1,10 @@
+declare namespace _default {
+    export function empty(): void;
+    export function empty2(): void;
+    export function _void(): void;
+    export { _void as void };
+    export function some(): void;
+    export function some2(): void;
+    export function someVoid(): void;
+}
+export default _default;

package/index.f.d.mts

@@ -0,0 +1,83 @@
+declare namespace _default {
+    export namespace com {
+        export { com$cpp as cpp };
+        export { com$cs as cs };
+        export { com$rust as rust };
+        export { com$types as types };
+    }
+    export { commonjs };
+    export { dev };
+    export { djs };
+    export { fsc };
+    export { fsm };
+    export { html };
+    export namespace js {
+        export { js$tokenizer as tokenizer };
+    }
+    export { json };
+    export namespace nodejs {
+        export { nodejs$version as version };
+    }
+    export { prime_field };
+    export { secp };
+    export { sha2 };
+    export { text };
+    export namespace types {
+        export { types$array as array };
+        export { types$bigfloat as bigfloat };
+        export { types$bigint as bigint };
+        export { types$btree as btree };
+        export { types$byte_set as byte_set };
+        export { types$function as function };
+        export { types$list as list };
+        export { types$map as map };
+        export { types$nibble_set as nibble_set };
+        export { types$nullable as nullable };
+        export { types$number as number };
+        export { types$object as object };
+        export { types$range as range };
+        export { types$range_map as range_map };
+        export { types$result as result };
+        export { types$sorted_list as sorted_list };
+        export { types$sorted_set as sorted_set };
+        export { types$string as string };
+        export { types$string_set as string_set };
+    }
+}
+export default _default;
+import com$cpp from './com/cpp/module.f.mjs';
+import com$cs from './com/cs/module.f.mjs';
+import com$rust from './com/rust/module.f.mjs';
+import com$types from './com/types/module.f.mjs';
+import commonjs from './commonjs/module.f.mjs';
+import dev from './dev/module.f.mjs';
+import djs from './djs/module.f.mjs';
+import fsc from './fsc/module.f.mjs';
+import fsm from './fsm/module.f.mjs';
+import html from './html/module.f.mjs';
+import js$tokenizer from './js/tokenizer/module.f.mjs';
+import json from './json/module.f.mjs';
+import nodejs$version from './nodejs/version/module.f.mjs';
+import prime_field from './prime_field/module.f.mjs';
+import secp from './secp/module.f.mjs';
+import sha2 from './sha2/module.f.mjs';
+import text from './text/module.f.mjs';
+import types$array from './types/array/module.f.mjs';
+import types$bigfloat from './types/bigfloat/module.f.mjs';
+import types$bigint from './types/bigint/module.f.mjs';
+import types$btree from './types/btree/module.f.mjs';
+import types$byte_set from './types/byte_set/module.f.mjs';
+import types$function from './types/function/module.f.mjs';
+import types$list from './types/list/module.f.mjs';
+import types$map from './types/map/module.f.mjs';
+import types$nibble_set from './types/nibble_set/module.f.mjs';
+import types$nullable from './types/nullable/module.f.mjs';
+import types$number from './types/number/module.f.mjs';
+import types$object from './types/object/module.f.mjs';
+import types$range from './types/range/module.f.mjs';
+import types$range_map from './types/range_map/module.f.mjs';
+import types$result from './types/result/module.f.mjs';
+import types$sorted_list from './types/sorted_list/module.f.mjs';
+import types$sorted_set from './types/sorted_set/module.f.mjs';
+import types$string from './types/string/module.f.mjs';
+import types$string_set from './types/string_set/module.f.mjs';

package/js/tokenizer/module.f.d.mts

@@ -0,0 +1,150 @@
+declare namespace _default {
+    export { tokenize };
+    export { isKeywordToken };
+}
+export default _default;
+export type StringToken = {
+    readonly kind: "string";
+    readonly value: string;
+};
+export type NumberToken = {
+    readonly kind: "number";
+    readonly value: string;
+    readonly bf: bigfloatT.BigFloat;
+};
+export type BigIntToken = {
+    readonly kind: "bigint";
+    readonly value: bigint;
+};
+export type ErrorToken = {
+    readonly kind: "error";
+    message: ErrorMessage;
+};
+export type WhitespaceToken = {
+    readonly kind: "ws";
+};
+export type TrueToken = {
+    readonly kind: "true";
+};
+export type FalseToken = {
+    readonly kind: "false";
+};
+export type NullToken = {
+    readonly kind: "null";
+};
+export type KeywordToken = {
+    readonly kind: "arguments" | "await" | "break" | "case" | "catch" | "class" | "const" | "continue";
+} | {
+    readonly kind: "debugger" | "default" | "delete" | "do" | "else" | "enum" | "eval" | "export";
+} | {
+    readonly kind: "extends" | "finally" | "for" | "function" | "if" | "implements" | "import" | "in";
+} | {
+    readonly kind: "instanceof" | "interface" | "let" | "new" | "package" | "private" | "protected" | "public";
+} | {
+    readonly kind: "return" | "static" | "super" | "switch" | "this" | "throw" | "try" | "typeof";
+} | {
+    readonly kind: "var" | "void" | "while" | "with" | "yield";
+};
+export type IdToken = {
+    readonly kind: "id";
+    readonly value: string;
+};
+export type OperatorToken = {
+    readonly kind: "{" | "}" | ":" | "," | "[" | "]";
+} | {
+    readonly kind: "." | "=";
+} | {
+    readonly kind: "(" | ")";
+} | {
+    readonly kind: "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=";
+} | {
+    readonly kind: "+" | "-" | "*" | "/" | "%" | "++" | "--" | "**";
+} | {
+    readonly kind: "+=" | "-=" | "*=" | "/=" | "%=" | "**=";
+} | {
+    readonly kind: "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>";
+} | {
+    readonly kind: "&=" | "|=" | "^=" | "<<=" | ">>=" | ">>>=";
+} | {
+    readonly kind: "&&" | "||" | "!" | "??";
+} | {
+    readonly kind: "&&=" | "||=" | "??=";
+} | {
+    readonly kind: "?" | "?." | "=>";
+};
+export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | OperatorToken;
+export type TokenizerState = InitialState | ParseIdState | ParseStringState | ParseEscapeCharState | ParseUnicodeCharState | ParseNumberState | InvalidNumberState | ParseOperatorState | ParseMinusState | ParseWhitespaceState | EofState;
+export type ErrorMessage = "\" are missing" | "unescaped character" | "invalid hex value" | "unexpected character" | "invalid number" | "invalid token" | "eof";
+export type InitialState = {
+    readonly kind: "initial";
+};
+export type ParseIdState = {
+    readonly kind: "id";
+    readonly value: string;
+};
+export type ParseWhitespaceState = {
+    readonly kind: "ws";
+};
+export type ParseStringState = {
+    readonly kind: "string";
+    readonly value: string;
+};
+export type ParseEscapeCharState = {
+    readonly kind: "escapeChar";
+    readonly value: string;
+};
+export type ParseOperatorState = {
+    readonly kind: "op";
+    readonly value: string;
+};
+export type ParseMinusState = {
+    readonly kind: "-";
+};
+export type ParseUnicodeCharState = {
+    readonly kind: "unicodeChar";
+    readonly value: string;
+    readonly unicode: number;
+    readonly hexIndex: number;
+};
+export type ParseNumberState = {
+    readonly kind: "number";
+    readonly numberKind: "0" | "int" | "." | "fractional" | "e" | "e+" | "e-" | "expDigits" | "bigint";
+    readonly value: string;
+    readonly b: ParseNumberBuffer;
+};
+export type ParseNumberBuffer = {
+    readonly s: -1n | 1n;
+    readonly m: bigint;
+    readonly f: number;
+    readonly es: -1 | 1;
+    readonly e: number;
+};
+export type InvalidNumberState = {
+    readonly kind: "invalidNumber";
+};
+export type EofState = {
+    readonly kind: "eof";
+};
+export type CharCodeOrEof = number | null;
+export type ToToken = (input: number) => readonly [List.List<JsToken>, TokenizerState];
+/**
+ * <T>
+ */
+export type CreateToToken<T> = (state: T) => ToToken;
+export type RangeSet = List.List<Range.Range>;
+/**
+ * <T>
+ */
+export type RangeFunc<T> = (def: CreateToToken<T>) => (RangeMapToToken<T>);
+/**
+ * <T>
+ */
+export type RangeMapToToken<T> = RangeMap.RangeMapArray<CreateToToken<T>>;
+/** @type {(input: List.List<number>) => List.List<JsToken>} */
+declare const tokenize: (input: List.List<number>) => List.List<JsToken>;
+/** @type {(token: JsToken) => Boolean} */
+declare const isKeywordToken: (token: JsToken) => boolean;
+import * as bigfloatT from '../../types/bigfloat/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';
+import * as Range from '../../types/range/module.f.mjs';
+import * as RangeMap from '../../types/range_map/module.f.mjs';

package/js/tokenizer/test.f.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    let djs: (() => void)[];
+    let operators: (() => void)[];
+    let ws: (() => void)[];
+    let id: (() => void)[];
+    let keywords: (() => void)[];
+}
+export default _default;

package/json/module.f.d.mts

@@ -0,0 +1,41 @@
+declare namespace _default {
+    export { setProperty };
+    export { stringify };
+    export { serialize };
+    export { parse };
+    export { isObject };
+}
+export default _default;
+export type Object = { readonly [k in string]: Unknown; };
+export type Array = readonly Unknown[];
+export type Unknown = Object | boolean | string | number | null | Array;
+export type Entry = O.Entry<Unknown>;
+export type Entries = (List.List<Entry>);
+export type MapEntries = (entries: Entries) => Entries;
+/**
+ * @typedef {{
+ *  readonly [k in string]: Unknown
+ * }} Object
+ */
+/** @typedef {readonly Unknown[]} Array */
+/** @typedef {Object|boolean|string|number|null|Array} Unknown */
+/** @type {(value: Unknown) => (path: List.List<string>) => (src: Unknown) => Unknown} */
+declare const setProperty: (value: Unknown) => (path: List.List<string>) => (src: Unknown) => Unknown;
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ *
+ * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
+ */
+declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
+/** @typedef {O.Entry<Unknown>} Entry*/
+/** @typedef {(List.List<Entry>)} Entries */
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => List.List<string>} */
+declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => List.List<string>;
+/** @type {(value: string) => Unknown} */
+declare const parse: (value: string) => Unknown;
+/** @type {(value: Unknown) => value is Object} */
+declare const isObject: (value: Unknown) => value is Object;
+import * as O from '../types/object/module.f.mjs';
+import * as List from '../types/list/module.f.mjs';

package/json/parser/module.f.d.mts

@@ -0,0 +1,36 @@
+declare namespace _default {
+    export { parse };
+}
+export default _default;
+export type JsonObject = {
+    readonly kind: "object";
+    readonly values: Map.Map<Json.Unknown>;
+    readonly key: string;
+};
+export type JsonArray = {
+    readonly kind: "array";
+    readonly values: List.List<Json.Unknown>;
+};
+export type JsonStackElement = JsonObject | JsonArray;
+export type JsonStack = List.List<JsonStackElement>;
+export type StateParse = {
+    readonly status: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
+    readonly top: JsonStackElement | null;
+    readonly stack: JsonStack;
+};
+export type StateResult = {
+    readonly status: "result";
+    readonly value: Json.Unknown;
+};
+export type StateError = {
+    readonly status: "error";
+    readonly message: string;
+};
+export type JsonState = StateParse | StateResult | StateError;
+/** @type {(tokenList: List.List<tokenizerT.JsonToken>) => Result.Result<Json.Unknown, string>} */
+declare const parse: (tokenList: List.List<tokenizerT.JsonToken>) => Result.Result<Json.Unknown, string>;
+import * as Map from '../../types/map/module.f.mjs';
+import * as Json from '../module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';
+import * as tokenizerT from '../tokenizer/module.f.mjs';
+import * as Result from '../../types/result/module.f.mjs';

package/json/parser/test.f.d.mts

@@ -0,0 +1,5 @@
+declare namespace _default {
+    let valid: (() => void)[];
+    let invalid: (() => void)[];
+}
+export default _default;

package/json/serializer/module.f.d.mts

@@ -0,0 +1,45 @@
+declare namespace _default {
+    export { objectWrap };
+    export { arrayWrap };
+    export { stringSerialize };
+    export { numberSerialize };
+    export { nullSerialize };
+    export { boolSerialize };
+}
+export default _default;
+/**
+ * <T>
+ */
+export type Obj<T> = { readonly [k in string]: Unknown<T>; };
+/**
+ * <T>
+ */
+export type Arr<T> = readonly Unknown<T>[];
+export type Primitive = boolean | string | number | null;
+/**
+ * <T>
+ */
+export type Unknown<T> = Arr<T> | Obj<T> | null | T;
+/**
+ * <T>
+ */
+export type Entry<T> = O.Entry<Unknown<T>>;
+/**
+ * <T>
+ */
+export type Entries<T> = (List.List<Entry<T>>);
+/**
+ * <T>
+ */
+export type MapEntries<T> = (entries: Entries<T>) => Entries<T>;
+declare const objectWrap: (input: List.List<List.List<string>>) => List.List<string>;
+declare const arrayWrap: (input: List.List<List.List<string>>) => List.List<string>;
+/** @type {(_: string) => List.List<string>} */
+declare const stringSerialize: (_: string) => List.List<string>;
+/** @type {(_: number) => List.List<string>} */
+declare const numberSerialize: (_: number) => List.List<string>;
+declare const nullSerialize: string[];
+/** @type {(_: boolean) => List.List<string>} */
+declare const boolSerialize: (_: boolean) => List.List<string>;
+import * as O from '../../types/object/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';

package/json/serializer/test.f.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    let arrayWrap: (() => void)[];
+    let objectWrap: (() => void)[];
+    let stringSerialize: (() => void)[];
+    let numberSerialize: (() => void)[];
+    let boolSerialize: (() => void)[];
+}
+export default _default;

package/json/test.f.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    function setProperty(): void;
+    let stringify: {
+        sort: () => void;
+        identity: () => void;
+    }[];
+}
+export default _default;

package/json/tokenizer/module.f.d.mts

@@ -0,0 +1,17 @@
+declare namespace _default {
+    export { tokenize };
+}
+export default _default;
+export type JsonToken = {
+    readonly kind: "true" | "false" | "null";
+} | {
+    readonly kind: "{" | "}" | ":" | "," | "[" | "]";
+} | jsTokenizerT.StringToken | jsTokenizerT.NumberToken | jsTokenizerT.ErrorToken;
+export type ScanState = {
+    readonly kind: "def" | "-";
+};
+export type ScanInput = jsTokenizerT.JsToken | null;
+/** @type {(input: List.List<number>) => List.List<JsonToken>} */
+declare const tokenize: (input: List.List<number>) => List.List<JsonToken>;
+import * as jsTokenizerT from '../../js/tokenizer/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';

package/json/tokenizer/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let json: (() => void)[];
+    let id: (() => void)[];
+    let keywords: (() => void)[];
+}
+export default _default;

package/jsr.json

@@ -1,5 +1,5 @@
 {
   "name": "@functionalscript/functionalscript",
-  "version": "0.1.593",
+  "version": "0.1.596",
   "exports": "./index.f.mjs"
 }

package/nodejs/version/main.d.mts

@@ -0,0 +1 @@
+export {};

package/nodejs/version/module.f.d.mts

@@ -0,0 +1,18 @@
+declare namespace _default {
+    export { version };
+}
+export default _default;
+export type ChildProcess = {
+    readonly execSync: (cmd: string) => Buffer;
+};
+export type Buffer = {};
+export type Fs<T> = {
+    readonly readFileSync: (name: string) => Buffer;
+    readonly writeFileSync: (name: string, content: string) => T;
+};
+export type Node<T> = {
+    readonly child_process: ChildProcess;
+    readonly fs: Fs<T>;
+};
+/** @type {<T>(node: Node<T>) => readonly[T, T]} */
+declare const version: <T>(node: Node<T>) => readonly [T, T];

package/nodejs/version/test.f.d.mts

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

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "functionalscript",
-  "version": "0.1.593",
+  "version": "0.1.596",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.f.mjs",
   "scripts": {
+    "tscp": "tsc --declaration --emitDeclarationOnly --noEmit false",
     "tsc": "tsc",
     "test": "tsc && npm run test-only",
     "index": "node ./dev/index.mjs",

package/prime_field/module.f.d.mts

@@ -0,0 +1,44 @@
+declare namespace _default {
+    export { prime_field };
+    export let sqrt: (f: PrimeField) => (a: bigint) => bigint | null;
+}
+export default _default;
+export type Reduce = Operator.Reduce<bigint>;
+export type Unary = Operator.Unary<bigint, bigint>;
+export type PrimeField = {
+    readonly p: bigint;
+    readonly middle: bigint;
+    readonly max: bigint;
+    readonly neg: Unary;
+    readonly sub: Reduce;
+    readonly add: Reduce;
+    readonly abs: Unary;
+    readonly mul: Reduce;
+    readonly reciprocal: Unary;
+    readonly div: Reduce;
+    readonly pow: Reduce;
+    readonly pow2: Unary;
+    readonly pow3: Unary;
+};
+/** @typedef {Operator.Reduce<bigint>} Reduce */
+/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
+/**
+ * @typedef {{
+ *  readonly p: bigint
+ *  readonly middle: bigint
+ *  readonly max: bigint
+ *  readonly neg: Unary
+ *  readonly sub: Reduce
+ *  readonly add: Reduce
+ *  readonly abs: Unary
+ *  readonly mul: Reduce
+ *  readonly reciprocal: Unary
+ *  readonly div: Reduce
+ *  readonly pow: Reduce
+ *  readonly pow2: Unary
+ *  readonly pow3: Unary
+ * }} PrimeField
+ */
+/** @type {(p: bigint) => PrimeField} */
+declare const prime_field: (p: bigint) => PrimeField;
+import * as Operator from '../types/function/operator/module.f.mjs';

package/prime_field/test.f.d.mts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    function prime_field_test(): {
+        neg: () => void;
+        sub: () => void;
+        add: () => void;
+        mul: () => void;
+        reciprocal: () => void;
+        pow: () => void;
+        sqrt: () => void;
+    };
+}
+export default _default;

package/secp/module.f.d.mts

@@ -0,0 +1,49 @@
+declare namespace _default {
+    export { curve };
+    export let eq: (a: Point) => (b: Point) => boolean;
+    export let secp256k1: Init;
+    export let secp192r1: Init;
+}
+export default _default;
+export type Point2D = readonly [bigint, bigint];
+export type Point = Point2D | null;
+export type Init = {
+    readonly p: bigint;
+    readonly a: readonly [bigint, bigint];
+    readonly g: readonly [bigint, bigint];
+    readonly n: bigint;
+};
+export type Curve = {
+    readonly pf: pfT.PrimeField;
+    readonly nf: pfT.PrimeField;
+    readonly y2: (x: bigint) => bigint;
+    readonly y: (x: bigint) => bigint | null;
+    readonly neg: (a: Point) => Point;
+    readonly add: op.Reduce<Point>;
+    readonly mul: (a: Point) => (n: bigint) => Point;
+};
+/** @typedef {readonly[bigint, bigint]} Point2D */
+/** @typedef {Point2D|null} Point */
+/**
+ * @typedef {{
+ *  readonly p: bigint
+ *  readonly a: readonly[bigint, bigint]
+ *  readonly g: readonly[bigint, bigint]
+ *  readonly n: bigint
+ * }} Init
+ */
+/**
+ * @typedef {{
+ *  readonly pf: pfT.PrimeField
+ *  readonly nf: pfT.PrimeField
+ *  readonly y2: (x: bigint) => bigint
+ *  readonly y: (x: bigint) => bigint|null
+ *  readonly neg: (a: Point) => Point
+ *  readonly add: op.Reduce<Point>
+ *  readonly mul: (a: Point) => (n: bigint) => Point
+ * }} Curve
+ */
+/** @type {(i: Init) => Curve} */
+declare const curve: (i: Init) => Curve;
+import * as pfT from '../prime_field/module.f.mjs';
+import * as op from '../types/function/operator/module.f.mjs';

package/secp/test.f.d.mts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function test(): void;
+}
+export default _default;