functionalscript 0.9.2 → 0.10.0

package/io/virtual/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Virtual I/O adapter implementations for deterministic testing.
+ *
+ * @module
+ */
 import type { Io } from '../module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 export declare const createVirtualIo: (files: OrderedMap<Uint8Array>) => Io;

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

@@ -1,3 +1,8 @@
+/**
+ * JSON parser that consumes tokenizer output into JSON values.
+ *
+ * @module
+ */
 import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import { type JsonToken } from '../tokenizer/module.f.ts';

package/json/parser/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * JSON parser that consumes tokenizer output into JSON values.
+ *
+ * @module
+ */
 import { error, ok } from "../../types/result/module.f.js";
 import { fold, first, drop, toArray, concat } from "../../types/list/module.f.js";
 import {} from "../../types/function/operator/module.f.js";

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

@@ -1,3 +1,8 @@
+/**
+ * JSON serializer for deterministic string output.
+ *
+ * @module
+ */
 import { type List } from '../../types/list/module.f.ts';
 export declare const stringSerialize: (_: string) => List<string>;
 export declare const numberSerialize: (_: number) => List<string>;

package/json/serializer/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * JSON serializer for deterministic string output.
+ *
+ * @module
+ */
 import { flat, reduce, empty } from "../../types/list/module.f.js";
 import {} from "../../types/object/module.f.js";
 import {} from "../../types/function/operator/module.f.js";

package/json/tokenizer/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Tokenizer for JSON lexical analysis.
+ *
+ * @module
+ */
 import {} from "../../types/function/operator/module.f.js";
 import { concat, empty, flat, stateScan } from "../../types/list/module.f.js";
 import { multiply } from "../../types/bigfloat/module.f.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "type": "module",
   "files": [
     "**/*.js",

package/path/module.f.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Path parsing and normalization helpers for portable module paths.
+ *
+ * @module
+ */
 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>;

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 {};

package/types/asn.1/module.f.js

@@ -0,0 +1,276 @@
+import { bitLength, max } from "../bigint/module.f.js";
+import { empty, isVec, length, listToVec, msb, msbCmp, uint, unpack, vec, vec8 } from "../bit_vec/module.f.js";
+import { identity } from "../function/module.f.js";
+import { encode as b128encode, decode as b128decode } from "../base128/module.f.js";
+const pop = msb.popFront;
+const pop8 = pop(8n);
+const concat = listToVec(msb);
+const classPcMask = 224n;
+const tagNumberMask = 31n;
+const parsedTagEncode = ([classPc, number]) => {
+    const [firstByteNumber, rest] = number < tagNumberMask
+        ? [number, empty]
+        : [tagNumberMask, b128encode(number)];
+    return concat([vec8(classPc | firstByteNumber), rest]);
+};
+const parsedTagDecode = (v) => {
+    const [firstByte, rest] = pop8(v);
+    const classPc = (firstByte & classPcMask);
+    const firstByteNumber = firstByte & tagNumberMask;
+    const [number, rest1] = firstByteNumber < tagNumberMask
+        ? [firstByteNumber, rest]
+        : b128decode(rest);
+    return [[classPc, number], rest1];
+};
+const tagEncode = (tag) => vec(max((bitLength(tag) + 7n) >> 3n)(1n) << 3n)(tag);
+const tagDecode = (v) => {
+    const [parsedTag, rest] = parsedTagDecode(v);
+    return [uint(parsedTagEncode(parsedTag)), rest];
+};
+//
+const eoc = 0x00n;
+/** ASN.1 universal BOOLEAN tag. */
+export const boolean = 0x01n;
+/** ASN.1 universal INTEGER tag. */
+export const integer = 0x02n;
+const bitString = 0x03n;
+/** ASN.1 universal OCTET STRING tag. */
+export const octetString = 0x04n;
+const null_ = 0x05;
+/** ASN.1 universal OBJECT IDENTIFIER tag. */
+export const objectIdentifier = 0x06n;
+const objectDescriptor = 0x07;
+const external = 0x08;
+const real = 0x09;
+const enumerated = 0x0A;
+const embeddedPdv = 0x0B;
+const utf8string = 0x0C;
+const relativeOid = 0x0D;
+const time = 0x0E;
+const sequence = 0x10;
+const set = 0x11;
+const numericString = 0x12;
+const printableString = 0x13;
+const t61String = 0x14;
+const videotexString = 0x15;
+const ia5String = 0x16;
+const utcTime = 0x17;
+const generalizedTime = 0x18;
+const graphicString = 0x19;
+const visibleString = 0x1A;
+const generalString = 0x1B;
+const universalString = 0x1C;
+const characterString = 0x1D;
+const bmpString = 0x1E;
+const date = 0x1F;
+const timeOfDay = 0x20;
+const dateTime = 0x21;
+const duration = 0x22;
+const oidIri = 0x23;
+const relativeOidIri = 0x24;
+const constructed = 0x20;
+export const constructedSequence = 0x30n; // constructed | sequence
+export const constructedSet = 0x31n; // constructed | set
+const round8 = ({ length, uint }) => {
+    const byteLen = (length + 7n) >> 3n;
+    return { byteLen, v: vec(byteLen << 3n)(uint) };
+};
+const lenEncode = (uint) => {
+    if (uint < 0x80n) {
+        return vec8(uint);
+    }
+    const { byteLen, v } = round8({ length: bitLength(uint), uint });
+    return concat([vec8(0x80n | byteLen), v]);
+};
+/**
+ * Decodes the length field of an ASN.1 TLV and returns the length in bits and the remaining input.
+ *
+ * @param v - The input bit vector starting with the length field.
+ * @returns A tuple containing the length in bits and the remaining input after the length field.
+ */
+const lenDecode = (v) => {
+    const firstAndRest = pop8(v);
+    const [first, rest1] = firstAndRest;
+    const [byteLen, rest2] = first < 0x80n ? firstAndRest : pop((first & 0x7fn) << 3n)(rest1);
+    return [byteLen << 3n, rest2];
+};
+/** Encodes a raw ASN.1 TLV tuple into a bit vector. */
+export const encodeRaw = ([tag, value]) => {
+    const tagVec = tagEncode(tag);
+    const { byteLen, v } = round8(unpack(value));
+    return concat([tagVec, lenEncode(byteLen), v]);
+};
+/** Decodes a raw ASN.1 TLV tuple and returns the remaining input. */
+export const decodeRaw = (v) => {
+    const [tag, v1] = tagDecode(v);
+    const [len, v2] = lenDecode(v1);
+    const [result, next] = pop(len)(v2);
+    return [[tag, vec(len)(result)], next];
+};
+// boolean
+/** Encodes a JavaScript boolean as an ASN.1 BOOLEAN value. */
+export const encodeBoolean = (b) => vec8(b ? 0xffn : 0x00n);
+/** Decodes an ASN.1 BOOLEAN value. */
+export const decodeBoolean = (v) => uint(v) !== 0n;
+// integer (two's compliment)
+/** Encodes a signed bigint using ASN.1 INTEGER two's complement representation. */
+export const encodeInteger = (uint) => {
+    const offset = uint < 0n ? 1n : 0n;
+    return round8({ length: bitLength(uint + offset) + 1n, uint }).v;
+};
+/** Decodes an ASN.1 INTEGER encoded in two's complement. */
+export const decodeInteger = (v) => {
+    const { length, uint } = unpack(v);
+    const sign = uint >> (length - 1n);
+    return sign === 0n ? uint : uint - (1n << length);
+};
+// octet string
+/** Encodes an OCTET STRING value. */
+export const encodeOctetString = (v) => v;
+/** Decodes an OCTET STRING value. */
+export const decodeOctetString = (v) => v;
+/** Encodes an OBJECT IDENTIFIER value. */
+export const encodeObjectIdentifier = (oid) => {
+    const [first, second, ...rest] = oid;
+    const firstByte = first * 40n + second;
+    return concat([vec8(firstByte), ...rest.map(b128encode)]);
+};
+/** Decodes an OBJECT IDENTIFIER value. */
+export const decodeObjectIdentifier = (v) => {
+    const [firstByte, rest] = pop8(v);
+    const first = firstByte / 40n;
+    const second = firstByte % 40n;
+    let result = [first, second];
+    let tail = rest;
+    while (length(tail) > 0n) {
+        const [value, next] = b128decode(tail);
+        result = [...result, value];
+        tail = next;
+    }
+    return result;
+};
+const genericEncodeSequence = (map) => (...records) => concat(map(records.map(encode)));
+/** Encodes a SEQUENCE payload from ordered records. */
+export const encodeSequence = genericEncodeSequence(identity);
+/** Decodes a SEQUENCE payload into records. */
+export const decodeSequence = (v) => {
+    let result = [];
+    while (length(v) !== 0n) {
+        const [record, rest] = decode(v);
+        result = [...result, record];
+        v = rest;
+    }
+    return result;
+};
+/** Encodes a SET payload with canonical byte ordering. */
+export const encodeSet = genericEncodeSequence(v => v.toSorted((a, b) => msbCmp(a)(b)));
+/** Decodes a SET payload. */
+export const decodeSet = decodeSequence;
+// encode
+const recordToRaw = ([tag, value]) => {
+    switch (tag) {
+        case boolean: return encodeBoolean(value);
+        case integer: return encodeInteger(value);
+        case octetString: return encodeOctetString(value);
+        case objectIdentifier: return encodeObjectIdentifier(value);
+        case constructedSequence: return encodeSequence(...value);
+        case constructedSet: return encodeSet(...value);
+    }
+};
+/** Encodes a supported ASN.1 record as TLV. */
+export const encode = (record) => isVec(record) ? record : encodeRaw([record[0], recordToRaw(record)]);
+// decode
+const rawToRecord = (raw) => {
+    const [tag, value] = raw;
+    switch (tag) {
+        case boolean: return [boolean, decodeBoolean(value)];
+        case integer: return [integer, decodeInteger(value)];
+        case octetString: return [octetString, decodeOctetString(value)];
+        case objectIdentifier: return [objectIdentifier, decodeObjectIdentifier(value)];
+        case constructedSequence: return [constructedSequence, decodeSequence(value)];
+        case constructedSet: return [constructedSet, decodeSet(value)];
+        default: return encodeRaw(raw);
+    }
+};
+/** Decodes one supported ASN.1 record and returns the remaining input. */
+export const decode = (v) => {
+    const [raw, rest] = decodeRaw(v);
+    return [rawToRecord(raw), rest];
+};
+/*
+TimeStampReq ::= SEQUENCE {
+    version        INTEGER { v1(1) },               // [x]
+    messageImprint MessageImprint,
+    reqPolicy      TSAPolicyId OPTIONAL,
+    nonce          INTEGER OPTIONAL,                // [X]
+    certReq        BOOLEAN DEFAULT FALSE,           // [X]
+    extensions     [0] IMPLICIT Extensions OPTIONAL // [X]
+}
+
+MessageImprint ::= SEQUENCE {
+    hashAlgorithm  AlgorithmIdentifier,
+    hashedMessage  OCTET STRING         // [X]
+}
+
+TSAPolicyId ::= OBJECT IDENTIFIER // [X]
+*/
+/*
+TimeStampResp ::= SEQUENCE {
+    status          PKIStatusInfo,
+    timeStampToken  TimeStampToken OPTIONAL
+}
+
+PKIStatusInfo ::= SEQUENCE {
+    status        PKIStatus,
+    statusString  PKIFreeText OPTIONAL,
+    failInfo      PKIFailureInfo OPTIONAL
+}
+
+PKIStatus ::= INTEGER {         // [X]
+    granted                (0),
+    grantedWithMods        (1),
+    rejection              (2),
+    waiting                (3),
+    revocationWarning      (4),
+    revocationNotification (5)
+}
+
+TimeStampToken ::= ContentInfo
+
+ContentInfo ::= SEQUENCE {
+    contentType ContentType,
+    content     [0] EXPLICIT ANY DEFINED BY contentType
+}
+
+ContentType ::= OBJECT IDENTIFIER
+
+SignedData ::= SEQUENCE {
+    version          CMSVersion,
+    digestAlgorithms SET OF DigestAlgorithmIdentifier,            // [X]
+    encapContentInfo EncapsulatedContentInfo,
+    certificates     [0] IMPLICIT CertificateSet OPTIONAL,
+    crls             [1] IMPLICIT RevocationInfoChoices OPTIONAL,
+    signerInfos      SET OF SignerInfo                            // [X]
+}
+
+EncapsulatedContentInfo ::= SEQUENCE {
+    eContentType ContentType,
+    eContent     [0] EXPLICIT OCTET STRING OPTIONAL
+}
+
+TSTInfo ::= SEQUENCE  {
+    version        INTEGER  { v1(1) },
+    policy         TSAPolicyId,
+    messageImprint MessageImprint,
+    serialNumber   INTEGER,
+    genTime        GeneralizedTime,
+    accuracy       Accuracy OPTIONAL,
+    ordering       BOOLEAN DEFAULT FALSE,
+    nonce          INTEGER OPTIONAL,
+    tsa            [0] GeneralName OPTIONAL,
+    extensions     [1] IMPLICIT Extensions OPTIONAL
+}
+
+Bits:  8 7   | 6    | 5 4 3 2 1
+       Class | P/C  | Tag number
+*/

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

@@ -0,0 +1,44 @@
+declare const _default: {
+    encodeSmall: () => void;
+    encode7F: () => void;
+    encode80: () => void;
+    encodeFF: () => void;
+    encode103: () => void;
+    ed: ((() => void) | {
+        x80: () => void;
+        x100: () => void;
+        x1000: () => void;
+        x10000: () => void;
+        x20000: () => void;
+        x40000: () => void;
+        x80000: () => void;
+        xC0000: () => void;
+        xE0000: () => void;
+        xF0000: () => void;
+        xFFF00: () => void;
+        xFFF80: () => void;
+        xFFFC0: () => void;
+        xFFFD0: () => void;
+    })[];
+    integerValue: {
+        zero: () => void;
+        one: () => void;
+        minusOne: () => void;
+        x7F: () => void;
+        x80: () => void;
+        xFF: () => void;
+        nx7F: () => void;
+        nx80: () => void;
+        nx81: () => void;
+        nx7FFF: () => void;
+        nx8000: () => void;
+        nx8001: () => void;
+    };
+    encodeDecode: {
+        integer: () => void;
+        sequence: () => void;
+        set: () => void;
+    };
+    raw: (() => void)[];
+};
+export default _default;