functionalscript 0.1.594 → 0.1.597

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/js/tokenizer/test.f.mjs

@@ -1,12 +1,12 @@
-import tokenizer, * as tokenizerT from './module.f.mjs'
+import tokenizer, * as Tokenizer from './module.f.mjs'
 import list from '../../types/list/module.f.mjs'
-const { toArray, countdown } = list
+const { toArray } = list
 import djs from '../../djs/module.f.mjs'
 import o from '../../types/object/module.f.mjs'
 const { sort } = o
 import encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizerT.JsToken[]} */
+/** @type {(s: string) => readonly Tokenizer.JsToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)

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<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
+declare const parse: (tokenList: List.List<Tokenizer.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 Tokenizer from '../tokenizer/module.f.mjs';
+import * as Result from '../../types/result/module.f.mjs';

package/json/parser/module.f.mjs

@@ -2,7 +2,7 @@ import result, * as Result from '../../types/result/module.f.mjs'
 import list, * as List from '../../types/list/module.f.mjs'
 const { fold, first, drop, toArray } = list
 import * as Operator from '../../types/function/operator/module.f.mjs'
-import * as tokenizerT from '../tokenizer/module.f.mjs'
+import * as Tokenizer from '../tokenizer/module.f.mjs'
 import map, * as Map from '../../types/map/module.f.mjs'
 const { setReplace } = map
 import * as Json from '../module.f.mjs'
@@ -114,7 +114,7 @@ const endObject = state => {
     return pushValue(newState)(obj)
 }
 
-/** @type {(token: tokenizerT.JsonToken) => Json.Unknown} */
+/** @type {(token: Tokenizer.JsonToken) => Json.Unknown} */
 const tokenToValue = token => {
     switch (token.kind) {
         case 'null': return null
@@ -126,7 +126,7 @@ const tokenToValue = token => {
     }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => boolean} */
+/** @type {(token: Tokenizer.JsonToken) => boolean} */
 const isValueToken = token => {
     switch (token.kind) {
         case 'null':
@@ -138,7 +138,7 @@ const isValueToken = token => {
     }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseValueOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -146,7 +146,7 @@ const parseValueOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseArrayStartOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -155,40 +155,40 @@ const parseArrayStartOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseArrayValueOp = token => state => {
     if (token.kind === ']') { return endArray(state) }
     if (token.kind === ',') { return { status: '[,', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectStartOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     if (token.kind === '}') { return endObject(state) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectKeyOp = token => state => {
     if (token.kind === ':') { return { status: '{:', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectNextOp = token => state => {
     if (token.kind === '}') { return endObject(state) }
     if (token.kind === ',') { return { status: '{,', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectCommaOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {Operator.Fold<tokenizerT.JsonToken, JsonState>} */
+/** @type {Operator.Fold<Tokenizer.JsonToken, JsonState>} */
 const foldOp = token => state => {
     switch (state.status) {
         case 'result': return { status: 'error', message: 'unexpected token' }
@@ -205,7 +205,7 @@ const foldOp = token => state => {
     }
 }
 
-/** @type {(tokenList: List.List<tokenizerT.JsonToken>) => Result.Result<Json.Unknown, string>} */
+/** @type {(tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
 const parse = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
     switch (state.status) {

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/parser/test.f.mjs

@@ -1,5 +1,5 @@
 import parser from './module.f.mjs'
-import tokenizer, * as tokenizerT from '../tokenizer/module.f.mjs'
+import tokenizer, * as Tokenizer from '../tokenizer/module.f.mjs'
 import list from '../../types/list/module.f.mjs'
 const { toArray } = list
 import json from '../module.f.mjs'
@@ -7,7 +7,7 @@ import o from '../../types/object/module.f.mjs'
 const { sort } = o
 import encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizerT.JsonToken[]} */
+/** @type {(s: string) => readonly Tokenizer.JsonToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = json.stringify(sort)

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/module.f.mjs

@@ -1,7 +1,7 @@
 import list, * as List from '../../types/list/module.f.mjs'
 const { flat, reduce, empty } = list
-import object, * as O from '../../types/object/module.f.mjs'
-import operator, * as Operator from '../../types/function/operator/module.f.mjs'
+import * as O from '../../types/object/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.mjs'
 
 /**
  * @template T

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: "{" | "}" | ":" | "," | "[" | "]";
+} | JsTokenizer.StringToken | JsTokenizer.NumberToken | JsTokenizer.ErrorToken;
+export type ScanState = {
+    readonly kind: "def" | "-";
+};
+export type ScanInput = JsTokenizer.JsToken | null;
+/** @type {(input: List.List<number>) => List.List<JsonToken>} */
+declare const tokenize: (input: List.List<number>) => List.List<JsonToken>;
+import * as JsTokenizer from '../../js/tokenizer/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';

package/json/tokenizer/module.f.mjs

@@ -1,17 +1,17 @@
-import operator, * as Operator from '../../types/function/operator/module.f.mjs'
+import * as Operator from '../../types/function/operator/module.f.mjs'
 import list, * as List from '../../types/list/module.f.mjs'
 const { empty, flat, stateScan } = list
 import bf from '../../types/bigfloat/module.f.mjs'
 const { multiply } = bf
-import jsTokenizer, * as jsTokenizerT from '../../js/tokenizer/module.f.mjs'
+import jsTokenizer, * as JsTokenizer from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
 * {readonly kind: 'true' | 'false' | 'null' } |
 * {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' } |
-* jsTokenizerT.StringToken |
-* jsTokenizerT.NumberToken |
-* jsTokenizerT.ErrorToken
+* JsTokenizer.StringToken |
+* JsTokenizer.NumberToken |
+* JsTokenizer.ErrorToken
 * } JsonToken
 */
 
@@ -23,11 +23,11 @@ import jsTokenizer, * as jsTokenizerT from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
-* jsTokenizerT.JsToken | null
+* JsTokenizer.JsToken | null
 * } ScanInput
 */
 
-/** @type {(input: jsTokenizerT.JsToken) => List.List<JsonToken>} */
+/** @type {(input: JsTokenizer.JsToken) => List.List<JsonToken>} */
 const mapToken = input =>
 {
     switch(input.kind)

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/json/tokenizer/test.f.mjs

@@ -1,12 +1,12 @@
-import tokenizer, * as tokenizerT from './module.f.mjs'
+import tokenizer, * as Tokenizer from './module.f.mjs'
 import list from '../../types/list/module.f.mjs'
-const { toArray, countdown } = list
+const { toArray } = list
 import djs from '../../djs/module.f.mjs'
 import o from '../../types/object/module.f.mjs'
 const { sort } = o
 import encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizerT.JsonToken[]} */
+/** @type {(s: string) => readonly Tokenizer.JsonToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)

package/jsr.json

@@ -1,5 +1,5 @@
 {
   "name": "@functionalscript/functionalscript",
-  "version": "0.1.594",
+  "version": "0.1.597",
   "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;