functionalscript 0.1.608 → 0.2.0

package/commonjs/path/test.f.mjs

@@ -1,17 +1,17 @@
-import _ from './module.f.mjs'
-import dev from '../../dev/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as dev from '../../dev/module.f.mjs'
 const { todo } = dev
-import json, * as Json from '../../json/module.f.mjs'
-import f from '../../types/function/module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as f from '../../types/function/module.f.mjs'
 const { identity } = f
-import object, * as O from '../../types/object/module.f.mjs'
+import * as object from '../../types/object/module.f.mjs'
 const { at } = object
 import * as Package from '../package/module.f.mjs'
 
-/** @type {<T>(o: O.Map<T>) => (s: string) => T|null} */
+/** @type {<T>(o: object.Map<T>) => (s: string) => T|null} */
 const i = o => s => at(s)(o)
 
-/** @type {(g: Json.Unknown) => string} */
+/** @type {(g: json.Unknown) => string} */
 const stringify = json.stringify(identity)
 
 export default {
@@ -70,7 +70,7 @@ export default {
         },
     },
     9: () => {
-        /** @type {O.Map<Package.Package>} */
+        /** @type {object.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<Package.Package>} */
+        /** @type {object.Map<Package.Package>} */
         const packages = {
             '': {
                 dependency: x => {
@@ -131,7 +131,7 @@ export default {
         }
     },
     11: () => {
-        /** @type {O.Map<Package.Package>} */
+        /** @type {object.Map<Package.Package>} */
         const packages = {
             '': {
                 dependency: x => {
@@ -158,7 +158,7 @@ export default {
         }
     },
     12: () => {
-        /** @type {O.Map<Package.Package>} */
+        /** @type {object.Map<Package.Package>} */
         const packages = {
             '': {
                 dependency: x => {

package/commonjs/test.mjs

@@ -1,4 +1,4 @@
-import _ from './module.mjs'
+import * as _ from './module.mjs'
 import * as Run from './module/function/module.f.mjs'
 
 export default {

package/dev/module.f.d.mts

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

package/dev/module.f.mjs

@@ -1,6 +1,3 @@
 // @ts-self-types="./module.f.d.mts"
 
-export default {
-    /** @readonly */
-    todo: () => { throw 'not implemented' },
-}
+export const todo = () => { throw 'not implemented' }

package/dev/module.mjs

@@ -86,7 +86,7 @@ export const loadModuleMap = async () => {
                     const file = `${p}/${name}`
                     if (i.isDirectory()) {
                         await f(file)
-                    } else if (name.endsWith('.f.cjs') || name.endsWith('.f.mjs') || name.endsWith('.f.js')) {
+                    } else if (name.endsWith('.f.mjs') || name.endsWith('.f.js')) {
                         const source = await import(`../${file}`)
                         map.push([file, source.default])
                     }

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

@@ -1,4 +1,5 @@
-export default main;
+declare const _default: <T>(input: Input<T>) => readonly [number, T];
+export default _default;
 export type DependencyMap = { readonly [k in string]?: Module; };
 export type Module = {
     readonly default?: unknown;
@@ -21,6 +22,4 @@ export type TestState = {
     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/module.f.mjs

@@ -1,8 +1,8 @@
 // @ts-self-types="./module.f.d.mts"
-import list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { fold } = list
-import sgr from '../../text/sgr/module.f.mjs'
-const { reset, fgGreen, fgRed, bold } = sgr
+import * as sgr from '../../text/sgr/module.f.mjs'
+const { reset, fgGreen, fgRed, bold } = sgr.codes
 import * as Result from '../../types/result/module.f.mjs'
 
 /**
@@ -47,7 +47,7 @@ import * as Result from '../../types/result/module.f.mjs'
  */
 
 /** @type {(s: string) => boolean} */
-const isTest = s => s.endsWith('test.f.cjs') || s.endsWith('test.f.mjs') || s.endsWith('test.f.js')
+const isTest = s => s.endsWith('test.f.mjs') || s.endsWith('test.f.js')
 
 /**
  * @typedef {{
@@ -80,7 +80,7 @@ const timeFormat = a => {
 }
 
 /** @type {<T>(input: Input<T>) => readonly[number, T]} */
-const main = input => {
+export default input => {
     let { moduleMap, log, error, measure, tryCatch, env, state } = input
     const isGitHub = env('GITHUB_ACTION') !== void 0
     /** @typedef {input extends Input<infer T> ? T : never} T */
@@ -146,5 +146,3 @@ const main = input => {
     state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
     return [ts.fail !== 0 ? 1 : 0, state]
 }
-
-export default main

package/djs/module.f.d.mts

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

package/djs/module.f.mjs

@@ -1,16 +1,16 @@
 // @ts-self-types="./module.f.d.mts"
 
-import list, * as List from '../types/list/module.f.mjs'
+import * as list from '../types/list/module.f.mjs'
 const { flat, map } = list
-import string from '../types/string/module.f.mjs'
+import * as string from '../types/string/module.f.mjs'
 const { concat } = string
 import * as O from '../types/object/module.f.mjs'
-import f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { compose, fn } = f
 const { entries } = Object
-import bi from '../types/bigint/module.f.mjs'
+import * as bi from '../types/bigint/module.f.mjs'
 const { serialize: bigintSerialize } = bi
-import j from '../json/serializer/module.f.mjs'
+import * as j from '../json/serializer/module.f.mjs'
 const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j
 
 /**
@@ -27,26 +27,26 @@ const colon = [':']
 
 /** @typedef {O.Entry<Unknown>} Entry*/
 
-/** @typedef {(List.List<Entry>)} Entries */
+/** @typedef {(list.List<Entry>)} Entries */
 
 /** @typedef {(entries: Entries) => Entries} MapEntries */
 
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => List.List<string>} */
-const serialize = sort => {
-    /** @type {(kv: readonly[string, Unknown]) => List.List<string>} */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+export const serialize = sort => {
+    /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
     const propertySerialize = ([k, v]) => flat([
         stringSerialize(k),
         colon,
         f(v)
     ])
     const mapPropertySerialize = map(propertySerialize)
-    /** @type {(object: Object) => List.List<string>} */
+    /** @type {(object: Object) => list.List<string>} */
     const objectSerialize = fn(entries)
         .then(sort)
         .then(mapPropertySerialize)
         .then(objectWrap)
         .result
-    /** @type {(value: Unknown) => List.List<string>} */
+    /** @type {(value: Unknown) => list.List<string>} */
     const f = value => {
         switch (typeof value) {
             case 'boolean': { return boolSerialize(value) }
@@ -70,11 +70,4 @@ const serialize = sort => {
  *
  * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
  */
-const stringify = sort => compose(serialize(sort))(concat)
-
-export default {
-    /** @readonly */
-    stringify,
-    /** @readonly */
-    serialize,
-}
+export const stringify = sort => compose(serialize(sort))(concat)

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

@@ -1,40 +1,56 @@
-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";
+/** @type {(tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>} */
+export const parse: (tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>;
+export type DjsModule = [readonly string[], readonly DjsConst[]];
+export type DjsConst = boolean | string | number | null | bigint | DjsModuleRef | DjsArray | DjsObject;
+export type DjsModuleRef = ["aref" | "cref", number];
+export type DjsArray = ["array", readonly DjsConst[]];
+export type DjsObject = { readonly [k in string]: DjsConst; };
+export type DjsStackArray = ["array", list.List<DjsConst>];
+export type DjsStackObject = ["object", map.Map<DjsConst>, string];
+export type DjsStackElement = DjsStackArray | DjsStackObject;
+export type DjsStack = list.List<DjsStackElement>;
+export type ParserState = InitialState | NewLineRequiredState | ImportState | ConstState | ExportState | ParseValueState | ResultState | ErrorState;
+export type ModuleState = {
+    readonly refs: map.Map<DjsModuleRef>;
+    readonly modules: list.List<string>;
+    readonly consts: list.List<DjsConst>;
+};
+export type InitialState = {
+    readonly state: "";
+    readonly module: ModuleState;
+};
+export type NewLineRequiredState = {
+    readonly state: "nl";
+    readonly module: ModuleState;
+};
+export type ImportState = {
+    readonly state: "import" | "import+name" | "import+from";
+    readonly module: ModuleState;
+};
+export type ConstState = {
+    readonly state: "const" | "const+name";
+    readonly module: ModuleState;
+};
+export type ExportState = {
+    readonly state: "export";
+    readonly module: ModuleState;
+};
+export type ParseValueState = {
+    readonly state: "constValue" | "exportValue";
+    readonly module: ModuleState;
+    readonly valueState: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
+    readonly top: DjsStackElement | null;
+    readonly stack: DjsStack;
+};
+export type ResultState = {
+    readonly state: "result";
+    readonly module: ModuleState;
+};
+export type ErrorState = {
+    readonly state: "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 list from '../../types/list/module.f.mjs';
 import * as tokenizerT from '../tokenizer/module.f.mjs';
-import * as Result from '../../types/result/module.f.mjs';
+import * as result from '../../types/result/module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';