functionalscript 0.1.609 → 0.2.0

package/com/cpp/module.f.d.mts

@@ -1,8 +1,4 @@
-declare namespace _default {
-    export { cpp };
-}
-export default _default;
-/** @type {(name: string) => (lib: Types.Library) => Text.Block} */
-declare const cpp: (name: string) => (lib: Types.Library) => Text.Block;
-import * as Types from '../types/module.f.mjs';
-import * as Text from '../../text/module.f.mjs';
+/** @type {(name: string) => (lib: types.Library) => text.Block} */
+export const cpp: (name: string) => (lib: types.Library) => text.Block;
+import * as types from '../types/module.f.mjs';
+import * as text from '../../text/module.f.mjs';

package/com/cpp/module.f.mjs

@@ -1,15 +1,15 @@
 // @ts-self-types="./module.f.d.mts"
-import types, * as Types from '../types/module.f.mjs'
-import text, * as Text from '../../text/module.f.mjs'
+import * as types from '../types/module.f.mjs'
+import * as text from '../../text/module.f.mjs'
 import * as O from '../../types/object/module.f.mjs'
-import list from '../../types/list/module.f.mjs'
-import string from '../../types/string/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
+import * as string from '../../types/string/module.f.mjs'
 const { join } = string
 const { paramList } = types
 const { map, flatMap, flat } = list
 const { entries } = Object
 
-/** @type {(name: string) => (body: Text.Block) => Text.Block} */
+/** @type {(name: string) => (body: text.Block) => text.Block} */
 const struct = name => body => [`struct ${name}`, '{', body, '};']
 
 const baseTypeMap = {
@@ -28,7 +28,7 @@ const baseTypeMap = {
     bool: 'bool',
 }
 
-/** @type {(t: Types.BaseType) => string} */
+/** @type {(t: types.BaseType) => string} */
 const baseType = t => baseTypeMap[t]
 
 const resultVoid = types.result('void')
@@ -44,17 +44,17 @@ const ptr = id => `${id} const*`
 /** @type {(id: string) => string} */
 const ref = id => `${id} const&`
 
-/** @type {(p: Types.Field) => string} */
+/** @type {(p: types.Field) => string} */
 const paramName = ([name]) => name
 
 const mapParamName = map(paramName)
 
 const joinComma = join(', ')
 
-/** @type {(name: string) => (lib: Types.Library) => Text.Block} */
-const cpp = name => lib => {
+/** @type {(name: string) => (lib: types.Library) => text.Block} */
+export const cpp = name => lib => {
 
-    /** @type {(t: Types.Type) => string|null} */
+    /** @type {(t: types.Type) => string|null} */
     const interface_ = t => {
         if (!(t instanceof Array) || t.length !== 1) {
             return null
@@ -63,7 +63,7 @@ const cpp = name => lib => {
         return 'interface' in lib[name] ? name : null
     }
 
-    /** @type {(i: (t: string) => string) => (t: Types.Type) => string} */
+    /** @type {(i: (t: string) => string) => (t: types.Type) => string} */
     const objectType = i => t => {
         if (typeof (t) === 'string') { return baseType(t) }
         if (t.length === 2) { return `${type(t[1])} const*` }
@@ -75,27 +75,27 @@ const cpp = name => lib => {
 
     const resultType = objectType(ptr)
 
-    /** @type {(s: Types.Field) => Text.Item} */
+    /** @type {(s: types.Field) => text.Item} */
     const field = ([name, t]) => `${type(t)} ${name};`
 
     const mapField = map(field)
 
-    /** @type {(s: Types.Struct) => Text.Block} */
+    /** @type {(s: types.Struct) => text.Block} */
     const defStruct = s => mapField(entries(s.struct))
 
-    /** @type {(fa: Types.FieldArray) => string} */
+    /** @type {(fa: types.FieldArray) => string} */
     const cppResult = resultVoid(resultType)
 
-    /** @type {(p: Types.Field) => string} */
+    /** @type {(p: types.Field) => string} */
     const param = ([name, t]) => `${objectType(ref)(t)} ${name}`
 
     const mapParam = map(param)
 
-    /** @type {(result: string) => (paramArrayStr: string) => (name: string) => Text.Item} */
+    /** @type {(result: string) => (paramArrayStr: string) => (name: string) => text.Item} */
     const methodHeader = result => paramArrayStr => name =>
         `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`
 
-    /** @type {(m: Types.Method) => readonly Text.Item[]} */
+    /** @type {(m: types.Method) => readonly text.Item[]} */
     const method = ([name, paramArray]) => {
         const result = cppResult(paramArray)
         const paramL = paramList(paramArray)
@@ -116,7 +116,7 @@ const cpp = name => lib => {
 
     const mapMethod = flatMap(method)
 
-    /** @type {(i: Types.Interface) => Text.Block} */
+    /** @type {(i: types.Interface) => text.Block} */
     const defInterface = ({ guid, interface: i }) => {
         const g = guid.replaceAll('-', '');
         const lo = g.substring(0, 16);
@@ -127,7 +127,7 @@ const cpp = name => lib => {
         ])
     }
 
-    /** @type {(kv: O.Entry<Types.Definition>) => Text.Block} */
+    /** @type {(kv: O.Entry<types.Definition>) => text.Block} */
     const def = ([name, d]) => 'interface' in d
         ? [
             `class ${name} : public ::nanocom::IUnknown`,
@@ -138,7 +138,7 @@ const cpp = name => lib => {
         ]
         : struct(name)(defStruct(d))
 
-    /** @type {(kv: O.Entry<Types.Definition>) => Text.Block} */
+    /** @type {(kv: O.Entry<types.Definition>) => text.Block} */
     const forward = ([name]) => [`struct ${name};`]
 
     const e = entries(lib)
@@ -148,8 +148,3 @@ const cpp = name => lib => {
         namespace(name)(flat([flatMap(forward)(e), flatMap(def)(e)]))
     ])
 }
-
-export default {
-    /** @readonly */
-    cpp,
-}

package/com/cpp/testlib.f.mjs

@@ -1,9 +1,8 @@
-import string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.mjs'
 const { join } = string
-import text from '../../text/module.f.mjs'
+import * as text from '../../text/module.f.mjs'
 const { flat } = text
 import library from '../types/testlib.f.mjs'
-import m from './module.f.mjs'
-const { cpp } = m
+import { cpp } from './module.f.mjs'
 
 export default () => join('\n')(flat('    ')(cpp('My')(library)))

package/com/cs/module.f.d.mts

@@ -1,8 +1,4 @@
-declare namespace _default {
-    export { cs };
-}
-export default _default;
-/** @type {(name: string) => (library: typesT.Library) => textT.Block} */
-declare const cs: (name: string) => (library: typesT.Library) => textT.Block;
-import * as typesT from '../types/module.f.mjs';
-import * as textT from '../../text/module.f.mjs';
+/** @type {(name: string) => (library: types.Library) => text.Block} */
+export const cs: (name: string) => (library: types.Library) => text.Block;
+import * as types from '../types/module.f.mjs';
+import * as text from '../../text/module.f.mjs';

package/com/cs/module.f.mjs

@@ -1,11 +1,11 @@
 // @ts-self-types="./module.f.d.mts"
-import types, * as typesT from '../types/module.f.mjs'
+import * as types from '../types/module.f.mjs'
 const { result, paramList } = types
-import text, * as textT from '../../text/module.f.mjs'
+import * as text from '../../text/module.f.mjs'
 const { curly } = text
-import list, * as List from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { flat, map, some, flatMap } = list
-import string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.mjs'
 const { join } = string
 import * as O from '../../types/object/module.f.mjs'
 const { entries } = Object
@@ -14,11 +14,11 @@ const { entries } = Object
 const using = v => `using ${v};`
 
 /**
- * @type {(attributes: List.List<string>) =>
+ * @type {(attributes: list.List<string>) =>
  *  (type: string) =>
  *  (name: string) =>
- *  (body: textT.Block) =>
- *  List.List<textT.Item>}
+ *  (body: text.Block) =>
+ *  list.List<text.Item>}
  */
 const typeDef = attributes => type => name => body =>
     flat([
@@ -42,33 +42,33 @@ const baseTypeMap = {
     usize: 'UIntPtr',
 }
 
-/** @type {(t: typesT.BaseType) => string} */
+/** @type {(t: types.BaseType) => string} */
 const baseType = t => baseTypeMap[t]
 
 /** @type {(isUnsafe: boolean) => string} */
 const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : ''
 
-/** @type {(t: typesT.Type) => readonly[boolean, string]} */
+/** @type {(t: types.Type) => readonly[boolean, string]} */
 const fullType = t =>
     typeof (t) === 'string' ? [false, baseType(t)] :
         t.length === 1 ? [false, t[0]] :
             [true, `${type(t[1])}*`]
 
-/** @type {(m: typesT.Type) => string} */
+/** @type {(m: types.Type) => string} */
 const type = t => fullType(t)[1]
 
-/** @type {(f: typesT.Field) => string} */
+/** @type {(f: types.Field) => string} */
 const param = ([name, t]) => `${type(t)} ${name}`
 
 const mapParam = map(param)
 
-/** @type {(f: typesT.Field) => string} */
+/** @type {(f: types.Field) => string} */
 const field = ([name, comType]) => {
     const [isUnsafe, t] = fullType(comType)
     return `public ${unsafe(isUnsafe)}${t} ${name};`
 }
 
-/** @type {(field: typesT.Field) => boolean} */
+/** @type {(field: types.Field) => boolean} */
 const isUnsafeField = field => fullType(field[1])[0]
 
 const mapIsUnsafeField = map(isUnsafeField)
@@ -77,7 +77,7 @@ const resultVoid = result('void')
 
 const joinComma = join(', ')
 
-/** @type {(e: O.Entry<typesT.FieldArray>) => readonly string[]} */
+/** @type {(e: O.Entry<types.FieldArray>) => readonly string[]} */
 const method = ([name, m]) => {
     const paramAndResultList = entries(m)
     const pl = paramList(m)
@@ -96,7 +96,7 @@ const mapField = map(field)
 
 const flatMapMethod = flatMap(method)
 
-/** @type {(e: O.Entry<typesT.Definition>) => List.List<textT.Item>} */
+/** @type {(e: O.Entry<types.Definition>) => list.List<text.Item>} */
 const def = ([n, d]) => {
     return !('interface' in d) ?
         struct(n)(mapField(entries(d.struct))) :
@@ -111,21 +111,16 @@ const flatMapDef = flatMap(def)
 
 const namespace = curly('namespace')
 
-/** @type {textT.Block} */
+/** @type {text.Block} */
 const header = [
     using('System'),
     using('System.Runtime.InteropServices'),
     ''
 ]
 
-/** @type {(name: string) => (library: typesT.Library) => textT.Block} */
-const cs = name => library => {
+/** @type {(name: string) => (library: types.Library) => text.Block} */
+export const cs = name => library => {
     const v = flatMapDef(entries(library))
     const ns = namespace(name)(v)
     return flat([header, ns])
 }
-
-export default {
-    /** @readonly */
-    cs,
-}

package/com/cs/testlib.f.mjs

@@ -1,10 +1,8 @@
-import text from '../../text/module.f.mjs'
+import * as text from '../../text/module.f.mjs'
 const { flat } = text
-import string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.mjs'
 const { join } = string
-import x from './module.f.mjs'
+import { cs } from './module.f.mjs'
 import library from '../types/testlib.f.mjs'
 
-const { cs } = x
-
 export default join('\n')(flat('    ')(cs('My')(library)))

package/com/rust/module.f.d.mts

@@ -1,7 +1,5 @@
-declare namespace _default {
-    export { rust };
-}
-export default _default;
+/** @type {(library: types.Library) => Text.Block} */
+export const rust: (library: types.Library) => Text.Block;
 export type OptionalProperty<T> = T | {};
 export type Where = {
     readonly where: readonly string[];
@@ -22,7 +20,5 @@ export type Trait = {
     readonly where?: readonly string[];
     readonly content: Text.Block;
 };
-/** @type {(library: Types.Library) => Text.Block} */
-declare const rust: (library: Types.Library) => Text.Block;
+import * as types from '../types/module.f.mjs';
 import * as Text from '../../text/module.f.mjs';
-import * as Types from '../types/module.f.mjs';

package/com/rust/module.f.mjs

@@ -1,14 +1,14 @@
 // @ts-self-types="./module.f.d.mts"
-import types, * as Types from '../types/module.f.mjs'
+import * as types from '../types/module.f.mjs'
 const { paramList } = types
 import * as Text from '../../text/module.f.mjs'
 import * as O from '../../types/object/module.f.mjs'
-import list, * as List from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { flat, map, flatMap } = list
 const { entries } = Object
-import func from '../../types/function/module.f.mjs'
+import * as func from '../../types/function/module.f.mjs'
 const { fn } = func
-import string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.mjs'
 const { join } = string
 
 /** @type {(field: string) => string} */
@@ -16,7 +16,7 @@ const rustField = field => `pub ${field},`
 
 const mapRustField = map(rustField)
 
-/** @type {(b: List.Thunk<string>) => (name: string) => Text.Block} */
+/** @type {(b: list.Thunk<string>) => (name: string) => Text.Block} */
 const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`]
 
 const commaJoin = join(', ')
@@ -29,21 +29,21 @@ const obj = name => `&${name}::Object`
 
 const self = ['&self']
 
-/** @type {(p: Types.Field) => string} */
+/** @type {(p: types.Field) => string} */
 const paramName = ([n]) => n
 
-/** @type {(p: Types.FieldArray) => List.Thunk<string>} */
+/** @type {(p: types.FieldArray) => list.Thunk<string>} */
 const callList = p => map(paramName)(paramList(p))
 
-/** @type {(p: Types.FieldArray) => string} */
+/** @type {(p: types.FieldArray) => string} */
 const call = p => commaJoin(callList(p))
 
-/** @type {(p: Types.FieldArray) => string} */
+/** @type {(p: types.FieldArray) => string} */
 const virtualCall = p => commaJoin(flat([['self'], callList(p)]))
 
 const super_ = 'super::'
 
-/** @type {(m: Types.Method) => string} */
+/** @type {(m: types.Method) => string} */
 const assign = ([n]) => `${n}: Self::${n},`
 
 const mapAssign = map(assign)
@@ -131,12 +131,12 @@ const traitImpl = t => {
 
 const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<Self>: Ex']
 
-/** @type {(library: Types.Library) => Text.Block} */
-const rust = library => {
+/** @type {(library: types.Library) => Text.Block} */
+export const rust = library => {
 
-    /** @type {(p: string) => (o: (_: string) => string) => (t: Types.Type) => string} */
+    /** @type {(p: string) => (o: (_: string) => string) => (t: types.Type) => string} */
     const type = p => {
-        /** @type {(o: (_: string) => string) => (t: Types.Type) => string} */
+        /** @type {(o: (_: string) => string) => (t: types.Type) => string} */
         const f = o => t => {
             if (typeof t === 'string') { return t }
             if (t.length === 2) { return `*const ${f(ref)(t[1])}` }
@@ -147,7 +147,7 @@ const rust = library => {
         return f
     }
 
-    /** @type {(p: string) => (o: (_: string) => string) => (f: Types.Field) => string} */
+    /** @type {(p: string) => (o: (_: string) => string) => (f: types.Field) => string} */
     const pf = p => o => ([name, t]) => `${name}: ${type(p)(o)(t)}`
 
     const param = pf(super_)(obj)
@@ -156,36 +156,36 @@ const rust = library => {
 
     const mapField = map(pf('')(ref))
 
-    /** @type {(fa: Types.FieldArray) => (name: string) => Text.Block} */
+    /** @type {(fa: types.FieldArray) => (name: string) => Text.Block} */
     const struct = fn(entries)
         .then(mapField)
         .then(rustStruct)
         .result
 
-    /** @type {(first: readonly string[]) => (p: Types.FieldArray) => string} */
+    /** @type {(first: readonly string[]) => (p: types.FieldArray) => string} */
     const func = first => p => {
         const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : ''
         const params = commaJoin(flat([first, mapParam(paramList(p))]))
         return `(${params})${resultStr}`
     }
 
-    /** @type {(n: string) => (p: Types.FieldArray) => string} */
+    /** @type {(n: string) => (p: types.FieldArray) => string} */
     const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`
 
-    /** @type {(m: Types.Method) => string} */
+    /** @type {(m: types.Method) => string} */
     const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`
 
     const mapVirtualFn = map(virtualFn)
 
-    /** @type {(m: Types.Method) => string} */
+    /** @type {(m: types.Method) => string} */
     const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`
 
-    /** @type {(m: Types.Method) => string} */
+    /** @type {(m: types.Method) => string} */
     const traitFn = m => `${headerFn(m)};`
 
     const mapTraitFn = map(traitFn)
 
-    /** @type {(m: Types.Method) => Text.Block} */
+    /** @type {(m: types.Method) => Text.Block} */
     const implFn = m => {
         const [n, p] = m
         return [
@@ -197,7 +197,7 @@ const rust = library => {
 
     const flatMapImplFn = flatMap(implFn)
 
-    /** @type {(m: Types.Method) => Text.Block} */
+    /** @type {(m: types.Method) => Text.Block} */
     const impl = ([n, p]) => {
         const type = virtualFnType(` ${n}`)(p)
         return [
@@ -209,7 +209,7 @@ const rust = library => {
 
     const flatMapImpl = flatMap(impl)
 
-    /** @type {(i: Types.Interface) => (name: string) => Text.Block} */
+    /** @type {(i: types.Interface) => (name: string) => Text.Block} */
     const interface_ = ({ interface: i, guid }) => name => {
 
         const e = entries(i)
@@ -253,13 +253,8 @@ const rust = library => {
         ]
     }
 
-    /** @type {(type: O.Entry<Types.Definition>) => Text.Block} */
+    /** @type {(type: O.Entry<types.Definition>) => Text.Block} */
     const def = ([name, type]) => ('interface' in type ? interface_(type) : struct(type.struct))(name)
 
     return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))])
 }
-
-export default {
-    /** @readonly */
-    rust,
-}

package/com/rust/testlib.f.mjs

@@ -1,10 +1,8 @@
-import text from '../../text/module.f.mjs'
+import * as text from '../../text/module.f.mjs'
 const { flat } = text
-import string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.mjs'
 const { join } = string
-import x from './module.f.mjs'
+import { rust } from './module.f.mjs'
 import library from '../types/testlib.f.mjs'
 
-const { rust } = x
-
 export default join('\n')(flat('    ')(rust(library)))

package/com/test/build.f.d.mts

@@ -14,7 +14,7 @@ export type Output = {
         readonly name: string;
         readonly content: string;
     };
-    readonly line: List.List<List.List<string>>;
+    readonly line: list.List<list.List<string>>;
 };
 export type Func = (nodejs: NodeJs) => Output;
 /** @type {Func} */
@@ -23,4 +23,4 @@ declare const cpp: Func;
 declare const cs: Func;
 /** @type {Func} */
 declare const rust: Func;
-import * as List from '../../types/list/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';

package/com/test/build.f.mjs

@@ -1,4 +1,4 @@
-import list, * as List from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { flat } = list
 
 import cppContent from '../cpp/testlib.f.mjs'
@@ -34,7 +34,7 @@ import rustContent from '../rust/testlib.f.mjs'
  *      readonly name: string
  *      readonly content: string
  *  }
- *  readonly line: List.List<List.List<string>>
+ *  readonly line: list.List<list.List<string>>
  * }} Output
  */
 

package/com/test/build.mjs

@@ -3,12 +3,12 @@ import { execSync } from 'node:child_process'
 import { platform, exit } from 'node:process'
 import build, * as Build from './build.f.mjs'
 const { cpp, cs, rust } = build
-import string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.mjs'
 const { join } = string
 const { log, error } = console
-import sgr from '../../text/sgr/module.f.mjs'
-const { bold, reset } = sgr
-import list from '../../types/list/module.f.mjs'
+import * as sgr from '../../text/sgr/module.f.mjs'
+const { bold, reset } = sgr.codes
+import * as list from '../../types/list/module.f.mjs'
 
 import { fileURLToPath } from 'node:url'
 import { dirname } from 'node:path'

package/com/types/module.f.d.mts

@@ -1,8 +1,7 @@
-declare namespace _default {
-    export { paramList };
-    export { result };
-}
-export default _default;
+/** @type {(fa: FieldArray) => list.List<Field> } */
+export const paramList: (fa: FieldArray) => list.List<Field>;
+/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
+export const result: <T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T;
 export type Library = { readonly [k in string]: Definition; };
 export type Definition = Struct | Interface;
 export type Struct = {
@@ -20,9 +19,5 @@ export type Type = BaseType | Id | Pointer;
 export type Id = readonly [string];
 export type BaseType = "u8" | "i8" | "u16" | "i16" | "u32" | "i32" | "u64" | "i64" | "usize" | "isize" | "f32" | "f64" | "bool";
 export type Pointer = readonly ["*", Type];
-/** @type {(fa: FieldArray) => List.List<Field> } */
-declare const paramList: (fa: FieldArray) => List.List<Field>;
-/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
-declare const result: <T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T;
+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/com/types/module.f.mjs

@@ -1,7 +1,7 @@
 // @ts-self-types="./module.f.d.mts"
 import * as O from '../../types/object/module.f.mjs'
-import list, * as List from '../../types/list/module.f.mjs'
-import f from '../../types/function/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
+import * as f from '../../types/function/module.f.mjs'
 const { compose } = f
 const { filter } = list
 const { entries } = Object
@@ -60,15 +60,8 @@ const isParam = ([name]) => name !== '_'
 
 const filterParam = filter(isParam)
 
-/** @type {(fa: FieldArray) => List.List<Field> } */
-const paramList = compose(entries)(filterParam)
+/** @type {(fa: FieldArray) => list.List<Field> } */
+export const paramList = compose(entries)(filterParam)
 
 /** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
-const result = v => f => fa => '_' in fa ? f(fa._) : v
-
-export default {
-    /** @readonly */
-    paramList,
-    /** @readonly */
-    result,
-}
+export const result = v => f => fa => '_' in fa ? f(fa._) : v

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

@@ -1,24 +1,20 @@
-declare namespace _default {
-    export { getOrBuild };
-}
-export default _default;
-export type Config<M> = {
-    readonly packageGet: packageT.Get;
-    readonly moduleMapInterface: moduleT.MapInterface<M>;
-    readonly moduleId: moduleT.Id;
-    readonly moduleMap: M;
-};
-export type Result<M> = readonly [moduleT.State, M];
 /**
  * @type {(compile: function_.Compile) =>
- *  (packageGet: packageT.Get) =>
- *  <M>(moduleMapInterface: moduleT.MapInterface<M>) =>
- *  (moduleId: moduleT.Id) =>
+ *  (packageGet: package_.Get) =>
+ *  <M>(moduleMapInterface: module.MapInterface<M>) =>
+ *  (moduleId: module.Id) =>
  *  (moduleMap: M) =>
  *  Result<M>
  * }
  */
-declare const getOrBuild: (compile: function_.Compile) => (packageGet: packageT.Get) => <M>(moduleMapInterface: moduleT.MapInterface<M>) => (moduleId: moduleT.Id) => (moduleMap: M) => Result<M>;
-import * as packageT from '../package/module.f.mjs';
-import * as moduleT from '../module/module.f.mjs';
+export const getOrBuild: (compile: function_.Compile) => (packageGet: package_.Get) => <M>(moduleMapInterface: module.MapInterface<M>) => (moduleId: module.Id) => (moduleMap: M) => Result<M>;
+export type Config<M> = {
+    readonly packageGet: package_.Get;
+    readonly moduleMapInterface: module.MapInterface<M>;
+    readonly moduleId: module.Id;
+    readonly moduleMap: M;
+};
+export type Result<M> = readonly [module.State, M];
 import * as function_ from '../module/function/module.f.mjs';
+import * as package_ from '../package/module.f.mjs';
+import * as module from '../module/module.f.mjs';