functionalscript 0.1.594 → 0.1.597

package/commonjs/package/dependencies/module.f.d.mts

@@ -0,0 +1,10 @@
+declare namespace _default {
+    export { isDependenciesJson };
+}
+export default _default;
+export type DependencyJson = readonly [string, string];
+export type DependencyMapJson = { readonly [k in string]: string; };
+export type DependenciesJson = DependencyMapJson | null;
+/** @type {(j: Json.Unknown) => j is DependenciesJson} */
+declare const isDependenciesJson: (j: Json.Unknown) => j is DependenciesJson;
+import * as Json from '../../../json/module.f.mjs';

package/commonjs/package/dependencies/module.f.mjs

@@ -1,4 +1,4 @@
-import json, * as jsonT from '../../../json/module.f.mjs'
+import json, * as Json from '../../../json/module.f.mjs'
 const { isObject } = json
 import list from '../../../types/list/module.f.mjs'
 const { map, every } = list
@@ -10,10 +10,10 @@ const { entries } = Object
 
 /** @typedef {DependencyMapJson|null} DependenciesJson */
 
-/** @type {(entry: jsonT.Entry) => boolean} */
+/** @type {(entry: Json.Entry) => boolean} */
 const isDependencyJson = ([, v]) => typeof v === 'string'
 
-/** @type {(j: jsonT.Unknown) => j is DependenciesJson} */
+/** @type {(j: Json.Unknown) => j is DependenciesJson} */
 const isDependenciesJson = j => {
     if (j === null) { return true }
     if (!isObject(j)) { return false }

package/commonjs/package/dependencies/test.f.d.mts

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

package/commonjs/package/module.f.d.mts

@@ -0,0 +1,27 @@
+declare namespace _default {
+    export { dependencies };
+    export { isPackageJson };
+}
+export default _default;
+export type PackageJson = {
+    readonly name: string;
+    readonly version: string;
+    readonly dependencies?: Dependencies.DependenciesJson;
+};
+export type Package = {
+    readonly dependency: (localPackageId: string) => string | null;
+    readonly file: (localFileId: string) => string | null;
+};
+export type Get = (packageId: string) => Package | null;
+import dependencies from './dependencies/module.f.mjs';
+/**
+ * @typedef {{
+ *  readonly name: string
+ *  readonly version: string
+ *  readonly dependencies?: Dependencies.DependenciesJson
+ * }} PackageJson
+ */
+/** @type {(j: Json.Unknown) => j is PackageJson} */
+declare const isPackageJson: (j: Json.Unknown) => j is PackageJson;
+import * as Dependencies from './dependencies/module.f.mjs';
+import * as Json from '../../json/module.f.mjs';

package/commonjs/package/module.f.mjs

@@ -1,6 +1,6 @@
-import json, * as jsonT from '../../json/module.f.mjs'
+import json, * as Json from '../../json/module.f.mjs'
 const { isObject } = json
-import dependencies, * as dependenciesT from './dependencies/module.f.mjs'
+import dependencies, * as Dependencies from './dependencies/module.f.mjs'
 const { isDependenciesJson } = dependencies
 import o from '../../types/object/module.f.mjs'
 const { at } = o
@@ -9,11 +9,11 @@ const { at } = o
  * @typedef {{
  *  readonly name: string
  *  readonly version: string
- *  readonly dependencies?: dependenciesT.DependenciesJson
+ *  readonly dependencies?: Dependencies.DependenciesJson
  * }} PackageJson
  */
 
-/** @type {(j: jsonT.Unknown) => j is PackageJson} */
+/** @type {(j: Json.Unknown) => j is PackageJson} */
 const isPackageJson = j => {
     if (!isObject(j)) { return false }
     if (typeof j.name !== 'string') { return false }

package/commonjs/package/test.f.d.mts

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

package/commonjs/path/module.f.d.mts

@@ -0,0 +1,67 @@
+declare namespace _default {
+    export { parseLocal };
+    export { parseGlobal };
+    export { parse };
+    export { parseAndFind };
+}
+export default _default;
+export type Items = readonly string[];
+export type LocalPath = {
+    readonly external: boolean;
+    readonly dir: boolean;
+    readonly items: Items;
+};
+export type OptionList = readonly [List.List<string>] | null;
+export type IdPath = readonly [string, List.List<string>];
+export type Path = {
+    readonly package: string;
+    readonly items: Items;
+    readonly dir: boolean;
+};
+export type FoundResult = {
+    readonly id: Module.Id;
+    readonly source: string;
+};
+export type Result = FoundResult | null;
+/** @type {(local: string) => (path: string) => LocalPath|null} */
+declare const parseLocal: (local: string) => (path: string) => LocalPath | null;
+/**
+ * @typedef {{
+ *  readonly package: string,
+ *  readonly items: Items,
+ *  readonly dir: boolean,
+ * }} Path
+ */
+/**
+ * @type {(d: (local: string) => string|null) =>
+ *  (dir: boolean) =>
+ *  (items: List.List<string>) =>
+ *  Path|null}
+ */
+declare const parseGlobal: (d: (local: string) => string | null) => (dir: boolean) => (items: List.List<string>) => Path | null;
+/**
+ * @type {(packageId: string) =>
+ *  (dependencies: (local: string) => string|null) =>
+ *  (local: string) =>
+ *  (path: string) =>
+ *  Path|null }
+ */
+declare const parse: (packageId: string) => (dependencies: (local: string) => string | null) => (local: string) => (path: string) => Path | null;
+/**
+ * @typedef {{
+ *  readonly id: Module.Id
+ *  readonly source: string
+ * }} FoundResult
+ */
+/** @typedef {FoundResult| null} Result */
+/**
+ * @type {(packageGet: Package.Get) =>
+ *  (moduleId: Module.Id) =>
+ *  (path: string) =>
+ *  Result
+ * }
+ */
+declare const parseAndFind: (packageGet: Package.Get) => (moduleId: Module.Id) => (path: string) => Result;
+import * as List from '../../types/list/module.f.mjs';
+import * as Module from '../module/module.f.mjs';
+import * as Package from '../package/module.f.mjs';

package/commonjs/path/module.f.mjs

@@ -2,8 +2,8 @@ import list, * as List from '../../types/list/module.f.mjs'
 const { next, fold, reverse, first, flat, toArray, filterMap, isEmpty, concat } = list
 import string from '../../types/string/module.f.mjs'
 const { join } = string
-import package_, * as packageT from '../package/module.f.mjs'
-import module_, * as moduleT from '../module/module.f.mjs'
+import * as Package from '../package/module.f.mjs'
+import * as Module from '../module/module.f.mjs'
 
 /** @typedef {readonly string[]} Items */
 
@@ -132,7 +132,7 @@ const parse = packageId => dependencies => {
 
 /**
  * @typedef {{
- *  readonly id: moduleT.Id
+ *  readonly id: Module.Id
  *  readonly source: string
  * }} FoundResult
  */
@@ -140,8 +140,8 @@ const parse = packageId => dependencies => {
 /** @typedef {FoundResult| null} Result */
 
 /**
- * @type {(packageGet: packageT.Get) =>
- *  (moduleId: moduleT.Id) =>
+ * @type {(packageGet: Package.Get) =>
+ *  (moduleId: Module.Id) =>
  *  (path: string) =>
  *  Result
  * }

package/commonjs/path/test.f.d.mts

@@ -0,0 +1,25 @@
+declare const _default: {
+    0: () => void;
+    1: () => void;
+    2: () => void;
+    3: () => void;
+    4: () => void;
+    5: () => void;
+    6: () => void;
+    7: () => void;
+    8: {
+        0: () => void;
+        1: () => void;
+        2: () => void;
+        3: () => void;
+        4: () => void;
+        5: () => void;
+        6: () => void;
+        7: () => void;
+    };
+    9: () => void;
+    10: () => void;
+    11: () => void;
+    12: () => void;
+};
+export default _default;

package/commonjs/path/test.f.mjs

@@ -1,17 +1,17 @@
 import _ from './module.f.mjs'
 import dev from '../../dev/module.f.mjs'
 const { todo } = dev
-import json, * as jsonT from '../../json/module.f.mjs'
+import json, * as Json from '../../json/module.f.mjs'
 import f from '../../types/function/module.f.mjs'
 const { identity } = f
 import object, * as O from '../../types/object/module.f.mjs'
 const { at } = object
-import * as packageT from '../package/module.f.mjs'
+import * as Package from '../package/module.f.mjs'
 
 /** @type {<T>(o: O.Map<T>) => (s: string) => T|null} */
 const i = o => s => at(s)(o)
 
-/** @type {(g: jsonT.Unknown) => string} */
+/** @type {(g: Json.Unknown) => string} */
 const stringify = json.stringify(identity)
 
 export default {
@@ -70,7 +70,7 @@ export default {
         },
     },
     9: () => {
-        /** @type {O.Map<packageT.Package>} */
+        /** @type {O.Map<Package.Package>} */
         const packages = {
             '': {
                 dependency: () => todo(),
@@ -81,7 +81,7 @@ export default {
         if (result !== '{"id":{"package":"","path":["a","c"]},"source":"return \\"a/c\\""}') { throw result }
     },
     10: () => {
-        /** @type {O.Map<packageT.Package>} */
+        /** @type {O.Map<Package.Package>} */
         const packages = {
             '': {
                 dependency: x => {
@@ -131,7 +131,7 @@ export default {
         }
     },
     11: () => {
-        /** @type {O.Map<packageT.Package>} */
+        /** @type {O.Map<Package.Package>} */
         const packages = {
             '': {
                 dependency: x => {
@@ -158,7 +158,7 @@ export default {
         }
     },
     12: () => {
-        /** @type {O.Map<packageT.Package>} */
+        /** @type {O.Map<Package.Package>} */
         const packages = {
             '': {
                 dependency: x => {

package/commonjs/test.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    function ok(): void;
+    function compilationError(): void;
+    function compilationErrorStrict(): void;
+    function runtimeError(): void;
+    function test(): void;
+}
+export default _default;

package/commonjs/test.mjs

@@ -1,5 +1,5 @@
 import _ from './module.mjs'
-import run, * as runT from './module/function/module.f.mjs'
+import * as Run from './module/function/module.f.mjs'
 
 export default {
     ok: () => {
@@ -32,7 +32,7 @@ export default {
         const d = _.compile(depSource)
         if (d[0] !== 'ok') { throw d }
 
-        /** @type {runT.Require<number>} */
+        /** @type {Run.Require<number>} */
         const req = path => prior => {
             if (path !== 'm') { throw path }
             return d[1](req)(prior + 1)

package/dev/index.d.mts

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

package/dev/module.d.mts

@@ -0,0 +1,26 @@
+/** @type {(code: number) => never} */
+export const exit: (code: number) => never;
+/** @type {(v: string) => string|undefined} */
+export const env: (v: string) => string | undefined;
+export function loadModuleMap(): Promise<ModuleMap>;
+export function index(): Promise<void>;
+export type Options = {
+    readonly withFileTypes: true;
+};
+export type Dirent = {
+    readonly name: string;
+    readonly isDirectory: () => boolean;
+};
+export type FsPromises = {
+    readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>;
+    readonly readFile: (path: string, options: "utf8") => Promise<string>;
+};
+export type Module = {
+    readonly default?: unknown;
+};
+export type Require = (name: string) => unknown;
+export type UnknownMap = { readonly [k in string]: unknown; };
+export type Entry<T> = readonly [string, T];
+export type MutableModuleMap = { [k in string]: Module; };
+export type ModuleMap = { readonly [k in string]: Module; };
+export type FolderMap = { readonly [k in string]: string | FolderMap; };

package/dev/module.f.d.mts

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

package/dev/test/module.f.d.mts

@@ -0,0 +1,26 @@
+export default main;
+export type DependencyMap = { readonly [k in string]?: Module; };
+export type Module = {
+    readonly default?: unknown;
+};
+export type ModuleMap = { readonly [k in string]: Module; };
+export type Log<T> = (v: string) => (state: T) => T;
+export type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
+export type Input<T> = {
+    readonly moduleMap: ModuleMap;
+    readonly log: Log<T>;
+    readonly error: Log<T>;
+    readonly measure: Measure<T>;
+    readonly state: T;
+    readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>;
+    readonly env: (n: string) => string | undefined;
+};
+export type TestState = {
+    readonly time: number;
+    readonly pass: number;
+    readonly fail: number;
+};
+export type FullState<T> = readonly [TestState, T];
+/** @type {<T>(input: Input<T>) => readonly[number, T]} */
+declare const main: <T>(input: Input<T>) => readonly [number, T];
+import * as Result from '../../types/result/module.f.mjs';

package/dev/test.d.mts

@@ -0,0 +1,3 @@
+export type Ok<T> = readonly ["ok", T];
+export type Error<E> = readonly ["error", E];
+export type Result<T, E> = Ok<T> | Error<E>;

package/dev/test.f.d.mts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    function ctor(): void;
+    function ctorEmpty(): void;
+    function ctorUndefined(): void;
+    function number(): void;
+    function properties(): void;
+    function getOwnPropertyDescriptor(): void;
+}
+export default _default;

package/djs/module.f.d.mts

@@ -0,0 +1,25 @@
+declare namespace _default {
+    export { stringify };
+    export { serialize };
+}
+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 | bigint;
+export type Entry = O.Entry<Unknown>;
+export type Entries = (List.List<Entry>);
+export type MapEntries = (entries: Entries) => Entries;
+/**
+ * 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>;
+import * as O from '../types/object/module.f.mjs';
+import * as List from '../types/list/module.f.mjs';

package/djs/module.f.mjs

@@ -2,7 +2,7 @@ import list, * as List from '../types/list/module.f.mjs'
 const { flat, map } = list
 import string from '../types/string/module.f.mjs'
 const { concat } = string
-import object, * as O from '../types/object/module.f.mjs'
+import * as O from '../types/object/module.f.mjs'
 import f from '../types/function/module.f.mjs'
 const { compose, fn } = f
 const { entries } = Object

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

@@ -0,0 +1,40 @@
+declare namespace _default {
+    export { parse };
+}
+export default _default;
+export type JsonObject = {
+    readonly kind: "object";
+    readonly values: Map.Map<Djs.Unknown>;
+    readonly key: string;
+};
+export type JsonArray = {
+    readonly kind: "array";
+    readonly values: List.List<Djs.Unknown>;
+};
+export type JsonStackElement = JsonObject | JsonArray;
+export type JsonStack = List.List<JsonStackElement>;
+export type StateModule = {
+    readonly status: "module";
+    readonly stage: "module" | "." | "exports" | "=";
+};
+export type StateParse = {
+    readonly status: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
+    readonly top: JsonStackElement | null;
+    readonly stack: JsonStack;
+};
+export type StateResult = {
+    readonly status: "result";
+    readonly value: Djs.Unknown;
+};
+export type StateError = {
+    readonly status: "error";
+    readonly message: string;
+};
+export type DjsState = StateModule | StateParse | StateResult | StateError;
+/** @type {(tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<Djs.Unknown, string>} */
+declare const parse: (tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<Djs.Unknown, string>;
+import * as Map from '../../types/map/module.f.mjs';
+import * as Djs 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/djs/parser/test.f.d.mts

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

package/djs/test.f.d.mts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    let stringify: ({
+        sort: () => void;
+        identity: () => void;
+        stringify?: undefined;
+    } | {
+        stringify: () => void;
+        sort?: undefined;
+        identity?: undefined;
+    })[];
+}
+export default _default;

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

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

package/djs/tokenizer/module.f.mjs

@@ -1,4 +1,4 @@
-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'

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

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

package/djs/tokenizer/test.f.mjs

@@ -1,6 +1,6 @@
 import tokenizer, * as tokenizerT from './module.f.mjs'
 import list from '../../types/list/module.f.mjs'
-const { toArray, countdown } = list
+const { toArray } = list
 import djs from '../module.f.mjs'
 import o from '../../types/object/module.f.mjs'
 const { sort } = o

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

@@ -2,7 +2,7 @@ import list, * as List from '../types/list/module.f.mjs'
 const { map, flatMap, flat, concat: listConcat } = list
 import s from '../types/string/module.f.mjs'
 const { concat: stringConcat } = s
-import object, * as O from '../types/object/module.f.mjs'
+import * as O from '../types/object/module.f.mjs'
 import f from '../types/function/module.f.mjs'
 const { compose } = f
 import utf16 from '../text/utf16/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;