functionalscript 0.9.1 → 0.9.3

package/djs/parser-new/module.f.js

@@ -0,0 +1,149 @@
+import { descentParser } from "../../bnf/data/module.f.js";
+import { eof, join0Plus, max, none, not, notSet, oneEncode, option, range, remove, repeat, repeat0Plus, repeat1Plus, set, unicodeRange } from "../../bnf/module.f.js";
+import { todo } from "../../dev/module.f.js";
+export const parse = (input) => {
+    const m = descentParser(jsGrammar());
+    return todo();
+};
+export const jsGrammar = () => {
+    const onenine = range('19');
+    const digit = range('09');
+    const string = [
+        '"',
+        repeat0Plus({
+            ...remove(range(` ${max}`), set('"\\')),
+            escape: [
+                '\\',
+                {
+                    ...set('"\\/bfnrt'),
+                    u: [
+                        'u',
+                        ...repeat(4)({
+                            digit,
+                            AF: range('AF'),
+                            af: range('af'),
+                        })
+                    ],
+                }
+            ],
+        }),
+        '"'
+    ];
+    const digits0 = repeat0Plus(digit);
+    const digits = [digit, digits0];
+    const number = [
+        {
+            0: '0',
+            onenine: [onenine, digits0],
+        },
+        option({
+            bigint: 'n',
+            frac: [
+                option(['.', digits]),
+                option([set('Ee'), option(set('+-')), digits])
+            ]
+        })
+    ];
+    const ws = set(' \t');
+    const newLine = set('\n\r');
+    const idStart = {
+        smallLetter: range('az'),
+        bigLetter: range('AZ'),
+        lowLine: '_',
+        dollarSign: '$'
+    };
+    const idChar = {
+        ...idStart,
+        digit
+    };
+    const id = [idStart, repeat0Plus(idChar)];
+    const operator = {
+        '.': '.',
+        '=>': '=>',
+        '===': '===',
+        '==': '==',
+        '=': '=',
+        '!==': '!==',
+        '!=': '!=',
+        '!': '!',
+        '>>>=': '>>>=',
+        '>>>': '>>>',
+        '>>=': '>>=',
+        '>>': '>>',
+        '>=': '>=',
+        '>': '>',
+        '<<<<=': '<<<=',
+        '<<<': '<<<',
+        '<<=': '<<=',
+        '<<': '<<',
+        '<=': '<=',
+        '<': '<',
+        '+=': '+=',
+        '++': '++',
+        '+': '+',
+        '-=': '-=',
+        '--': '--',
+        '-': '-',
+        '**=': '**=',
+        '**': '**',
+        '*=': '*=',
+        '*': '*',
+        '/=': '/=',
+        '/': '/',
+        '%=': '%=',
+        '%': '%',
+        '&&=': '&&=',
+        '&&': '&&',
+        '&=': '&=',
+        '&': '&',
+        '||=': '||=',
+        '||': '||',
+        '|=': '|=',
+        '|': '|',
+        '^=': '^=',
+        '^': '^',
+        '~': '~',
+        '??=': '??=',
+        '??': '??',
+        '?.': '?.',
+        '?': '?',
+        '[': '[',
+        ']': ']',
+        '{': '{',
+        '}': '}',
+        '(': '(',
+        ')': ')',
+        ',': ',',
+        ':': ':'
+    };
+    const commentEnd = {
+        ...newLine,
+        eof
+    };
+    const comment = ['/', {
+            // TODO: investigate why `not(commentEnd)` instead of `remove(unicodeRange, newLine)` fail tests.
+            // TODO: should it be `repeat0Plus(not(commentEnd))` instead of `option(remove(unicodeRange, newLine))`.
+            oneline: ['/', option(remove(unicodeRange, newLine)), commentEnd],
+            multiline: [
+                '*',
+                repeat0Plus({
+                    na: notSet('*'),
+                    a: ['*', notSet('/')]
+                }),
+                '*/'
+            ]
+        }
+    ];
+    const token = {
+        number,
+        string,
+        id,
+        comment,
+        operator,
+        ws,
+        newLine,
+        eof
+    };
+    const tokens = repeat0Plus(token);
+    return tokens;
+};

package/djs/parser-new/test.f.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    isValid: (() => void)[];
+    parser: (() => void)[];
+};
+export default _default;

package/djs/parser-new/test.f.js

@@ -0,0 +1,202 @@
+import { descentParser } from "../../bnf/data/module.f.js";
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
+import { jsGrammar } 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 {
+    isValid: [() => {
+            const m = descentParser(jsGrammar());
+            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 JSON.stringify([s, mr]);
+                }
+            };
+            expect('"', false);
+            expect('   true   ', true);
+            expect('   tr2ue   ', true);
+            expect('   2true   ', true);
+            expect('   true"   ', false);
+            expect('   "Hello"   ', true);
+            expect('   "Hello   ', false);
+            expect('   "Hello\\n\\r\\""   ', true);
+            expect('   56.7e+5  ', true);
+            expect('   -56.7e+5  ', true);
+            expect('   h-56.7e+5   ', true);
+            expect('   -56.7e+5   3', true);
+            expect('   [] ', true);
+            expect('   {} ', true);
+            expect('   [[[]]] ', true);
+            expect('   [1] ', true);
+            expect('   [ 12, false, "a"]  ', true);
+            expect('   [ 12, false2, "a"]  ', true);
+            expect('   { "q": [ 12, false, [{"b" : "c"}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [}], "a"] }  ', true);
+            expect('   [{ "q": [ 12, false, [{}], "a"] }]  ', true);
+            expect('   [{ "q": [ 12, false, [}], "a"] }]  ', true);
+            expect('. + ++ +=', true);
+            expect('//12\n', true);
+            expect('/*12*/', true);
+            expect('/* 1*2 */', true);
+        }
+    ],
+    parser: [
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('tr'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'id')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('"tr"'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'string')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('56.7e+5'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'number')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('56n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'number')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('*'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '*')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('**'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '**')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('=>'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '=>')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('=='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '==')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('==='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '===')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '=')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList(' '));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== ' ')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '\n')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('/\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '/')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('//\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'comment')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('/*1*/'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'comment')
+                throw JSON.stringify(mr);
+        }
+    ]
+};

package/djs/serializer/module.f.js

@@ -53,9 +53,9 @@ export const serializeWithoutConst = sort => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         switch (typeof value) {
@@ -96,9 +96,9 @@ const serializeWithConst = sort => refs => root => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         if (value !== root) {

package/fjs/module.f.d.ts

@@ -1,2 +1,2 @@
-import type { Io } from '../io/module.f.ts';
+import { type Io } from '../io/module.f.ts';
 export declare const main: (io: Io) => Promise<number>;

package/fjs/module.f.js

@@ -1,5 +1,7 @@
+import { fromIo } from "../io/module.f.js";
 import { compile } from "../djs/module.f.js";
 import { main as testMain } from "../dev/tf/module.f.js";
+import { main as casMain } from "../cas/module.f.js";
 export const main = (io) => {
     const { error } = io.console;
     const [command, ...rest] = io.process.argv.slice(2);
@@ -12,8 +14,7 @@ export const main = (io) => {
             return compile(io)(rest);
         case 'cas':
         case 's':
-            error('cas command is not implemented yet');
-            return Promise.resolve(1);
+            return fromIo(io)(casMain(rest));
         case undefined:
             error('Error: command is required');
             return Promise.resolve(1);

package/fsc/module.f.js

@@ -26,7 +26,7 @@ const reduce = (a) => {
     return toArray(listReduce(merge)(empty)(a));
 };
 const codePointRange = fromRange(def);
-const range = fn(asciiRange).then(codePointRange).result;
+const range = fn(asciiRange).map(codePointRange).result;
 const rangeSet = (l) => (f) => {
     const codePointRange = fromRange(def);
     const g = r => codePointRange(asciiRange(r))(f);

package/io/module.d.ts

@@ -1,4 +1,8 @@
 import { type Io, type Run } from './module.f.ts';
+import type { NodeProgram } from '../types/effect/node/module.f.ts';
 export declare const io: Io;
 declare const runDefault: Run;
 export default runDefault;
+export type NodeRun = (p: NodeProgram) => Promise<number>;
+export declare const ioRun: (io: Io) => NodeRun;
+export declare const nodeRun: NodeRun;

package/io/module.f.d.ts

@@ -1,10 +1,12 @@
-import type { Result } from '../types/result/module.f.ts';
+import type { NodeEffect } from '../types/effect/node/module.f.ts';
+import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
  * @see https://nodejs.org/api/fs.html#class-fsdirent
  */
 export type Dirent = {
     readonly name: string;
+    readonly parentPath: string;
     readonly isDirectory: () => boolean;
     readonly isFile: () => boolean;
 };
@@ -15,6 +17,11 @@ export type RmOptions = {
 export type MakeDirectoryOptions = {
     readonly recursive?: boolean;
 };
+export type ReadDir = ((path: string, options: {
+    withFileTypes: true;
+}) => Promise<Dirent[]>) & ((path: string, options: {
+    recursive?: true;
+}) => Promise<readonly string[]>);
 /**
  * File system operations interface
  * @see https://nodejs.org/api/fs.html
@@ -27,9 +34,7 @@ export type Fs = {
     readonly promises: {
         readonly readFile: (path: string) => Promise<Uint8Array>;
         readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
-        readonly readdir: (path: string, options: {
-            withFileTypes: true;
-        }) => Promise<Dirent[]>;
+        readonly readdir: ReadDir;
         readonly rm: (path: string, options?: RmOptions) => Promise<void>;
         readonly mkdir: (path: string, options?: MakeDirectoryOptions) => Promise<string | undefined>;
         readonly copyFile: (src: string, dest: string) => Promise<void>;
@@ -99,3 +104,4 @@ export type Run = (f: App) => Promise<never>;
  * Handles errors by exiting with code 1
  */
 export declare const run: (io: Io) => Run;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }: Io) => <T>(effect: NodeEffect<T>) => Promise<T>;

package/io/module.f.js

@@ -1,3 +1,7 @@
+import { normalize } from "../path/module.f.js";
+import { asyncRun } from "../types/effect/module.js";
+import { error, ok } from "../types/result/module.f.js";
+import { fromVec, toVec } from "../types/uint8array/module.f.js";
 /**
  * Runs a function and exits the process with the returned code
  * Handles errors by exiting with code 1
@@ -14,3 +18,27 @@ export const run = (io) => {
     };
     return async (f) => io.process.exit(code(await io.asyncTryCatch(() => f(io))));
 };
+const tc = async (f) => {
+    try {
+        return ok(await f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }) => asyncRun({
+    error: async (message) => error(message),
+    log: async (message) => log(message),
+    fetch: async (url) => tc(async () => {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Fetch error: ${response.status} ${response.statusText}`);
+        }
+        return toVec(new Uint8Array(await response.arrayBuffer()));
+    }),
+    mkdir: param => tc(async () => { await mkdir(...param); }),
+    readFile: path => tc(async () => toVec(await readFile(path))),
+    readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
+        .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
+    writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
+});

package/io/module.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { run } from "./module.f.js";
+import { fromIo, run } from "./module.f.js";
 import fs from 'node:fs';
 import process from "node:process";
 import { concat } from "../path/module.f.js";
@@ -41,3 +41,9 @@ export const io = {
 };
 const runDefault = run(io);
 export default runDefault;
+export const ioRun = (io) => {
+    const r = fromIo(io);
+    const { argv } = io.process;
+    return p => r(p(argv));
+};
+export const nodeRun = ioRun(io);

package/json/module.f.js

@@ -25,9 +25,9 @@ export const serialize = sort => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         switch (typeof value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "type": "module",
   "files": [
     "**/*.js",
@@ -15,7 +15,8 @@
     "fst": "node ./fjs/module.ts t",
     "fjs": "node ./fjs/module.ts",
     "ci-update": "node ./ci/module.ts",
-    "update": "git clean -fdx && npm install && npm run index && npm run ci-update"
+    "update": "git clean -fdx && npm install && npm run index && npm run ci-update",
+    "website": "node --experimental-strip-types ./website/module.ts"
   },
   "engines": {
     "node": ">=20"

package/path/module.f.d.ts

@@ -1,3 +1,4 @@
 import type { Reduce, Unary } from "../types/function/operator/module.f.ts";
+export declare const parse: (path: string) => readonly string[];
 export declare const normalize: Unary<string, string>;
 export declare const concat: Reduce<string>;

package/path/module.f.js

@@ -1,4 +1,4 @@
-import { fold, last, take, length, concat as listConcat } from "../types/list/module.f.js";
+import { fold, last, take, length, concat as listConcat, toArray } from "../types/list/module.f.js";
 import { join } from "../types/string/module.f.js";
 import { concat as stringConcat } from "../types/string/module.f.js";
 const foldNormalizeOp = input => state => {
@@ -21,9 +21,12 @@ const foldNormalizeOp = input => state => {
         }
     }
 };
-export const normalize = path => {
+export const parse = (path) => {
     const split = path.replaceAll('\\', '/').split('/');
-    const foldResult = fold(foldNormalizeOp)([])(split);
+    return toArray(fold(foldNormalizeOp)([])(split));
+};
+export const normalize = path => {
+    const foldResult = parse(path);
     return join('/')(foldResult);
 };
 export const concat = a => b => {

package/text/utf16/module.f.js

@@ -332,7 +332,7 @@ export const stringToCodePointList = (input) => toCodePointList(stringToList(inp
  * ```
  */
 export const listToString = fn(map(String.fromCharCode))
-    .then(reduce(concat)(''))
+    .map(reduce(concat)(''))
     .result;
 /**
  * Converts a list of Unicode code points (CodePoint) to a string.

package/text/utf8/module.f.d.ts

@@ -9,7 +9,7 @@ export type U8 = number;
  */
 export type I32 = number;
 /**
- * Represents an unsigend 8-bit type - U8 or the end-of-file indicator.
+ * Represents an unsigned 8-bit type - U8 or the end-of-file indicator.
  * The U8 represents the byte itself, and null indicates that reading does not return anything else.
  */
 export type ByteOrEof = U8 | null;

package/types/asn.1/module.f.d.ts

@@ -0,0 +1,62 @@
+import { type Vec } from "../bit_vec/module.f.ts";
+/** ASN.1 tag number. */
+type Tag = bigint;
+/** ASN.1 universal BOOLEAN tag. */
+export declare const boolean = 1n;
+/** ASN.1 universal INTEGER tag. */
+export declare const integer = 2n;
+/** ASN.1 universal OCTET STRING tag. */
+export declare const octetString = 4n;
+/** ASN.1 universal OBJECT IDENTIFIER tag. */
+export declare const objectIdentifier = 6n;
+export declare const constructedSequence = 48n;
+export declare const constructedSet = 49n;
+/** Raw ASN.1 TLV tuple. */
+export type Raw = readonly [Tag, Vec];
+/** Encodes a raw ASN.1 TLV tuple into a bit vector. */
+export declare const encodeRaw: ([tag, value]: Raw) => Vec;
+/** Decodes a raw ASN.1 TLV tuple and returns the remaining input. */
+export declare const decodeRaw: (v: Vec) => readonly [Raw, Vec];
+/** Encodes a JavaScript boolean as an ASN.1 BOOLEAN value. */
+export declare const encodeBoolean: (b: boolean) => Vec;
+/** Decodes an ASN.1 BOOLEAN value. */
+export declare const decodeBoolean: (v: Vec) => boolean;
+/** Encodes a signed bigint using ASN.1 INTEGER two's complement representation. */
+export declare const encodeInteger: (uint: bigint) => Vec;
+/** Decodes an ASN.1 INTEGER encoded in two's complement. */
+export declare const decodeInteger: (v: Vec) => bigint;
+/** Encodes an OCTET STRING value. */
+export declare const encodeOctetString: (v: Vec) => Vec;
+/** Decodes an OCTET STRING value. */
+export declare const decodeOctetString: (v: Vec) => Vec;
+/** ASN.1 OBJECT IDENTIFIER components. */
+export type ObjectIdentifier = readonly bigint[];
+/** Encodes an OBJECT IDENTIFIER value. */
+export declare const encodeObjectIdentifier: (oid: ObjectIdentifier) => Vec;
+/** Decodes an OBJECT IDENTIFIER value. */
+export declare const decodeObjectIdentifier: (v: Vec) => ObjectIdentifier;
+/** ASN.1 ordered collection of records. */
+export type Sequence = readonly Record[];
+/** Encodes a SEQUENCE payload from ordered records. */
+export declare const encodeSequence: (...records: Sequence) => Vec;
+/** Decodes a SEQUENCE payload into records. */
+export declare const decodeSequence: (v: Vec) => Sequence;
+/** ASN.1 SET represented as a sequence of records. */
+export type Set = Sequence;
+/** Encodes a SET payload with canonical byte ordering. */
+export declare const encodeSet: (...records: Sequence) => Vec;
+/** Decodes a SET payload. */
+export declare const decodeSet: (v: Vec) => Sequence;
+/** Supported ASN.1 record variants. */
+export type SupportedRecord = readonly [typeof boolean, boolean] | readonly [typeof integer, bigint] | readonly [typeof octetString, Vec] | readonly [typeof objectIdentifier, ObjectIdentifier] | readonly [typeof constructedSequence, Sequence] | readonly [typeof constructedSet, Set];
+/**
+ * For unsupported tags, we just store the raw value including the tag and length,
+ * so that it can be re-encoded without loss of information.
+ */
+export type UnsupportedRecord = Vec;
+export type Record = SupportedRecord | UnsupportedRecord;
+/** Encodes a supported ASN.1 record as TLV. */
+export declare const encode: (record: Record) => Vec;
+/** Decodes one supported ASN.1 record and returns the remaining input. */
+export declare const decode: (v: Vec) => readonly [Record, Vec];
+export {};