functionalscript 0.1.609 → 0.2.1

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.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.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.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.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.mjs

@@ -1,30 +1,30 @@
 // @ts-self-types="./module.f.d.mts"
-import * as packageT from '../package/module.f.mjs'
-import module_, * as moduleT from '../module/module.f.mjs'
-const { idToString, dir } = module_
+import * as package_ from '../package/module.f.mjs'
+import * as module from '../module/module.f.mjs'
+const { idToString, dir } = module
 import * as function_ from '../module/function/module.f.mjs'
-import map, * as Map from '../../types/map/module.f.mjs'
+import * as map from '../../types/map/module.f.mjs'
 const { empty: mapEmpty, setReplace } = map
-import object from '../../types/object/module.f.mjs'
+import * as object from '../../types/object/module.f.mjs'
 const { fromMap } = object
-import path from '../path/module.f.mjs'
+import * as path from '../path/module.f.mjs'
 const { parseAndFind } = path
-import stringSet, * as StringSet from '../../types/string_set/module.f.mjs'
+import * as stringSet from '../../types/string_set/module.f.mjs'
 const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet
 
 /**
  * @template M
  * @typedef {{
- *  readonly packageGet: packageT.Get
- *  readonly moduleMapInterface: moduleT.MapInterface<M>
- *  readonly moduleId: moduleT.Id
+ *  readonly packageGet: package_.Get
+ *  readonly moduleMapInterface: module.MapInterface<M>
+ *  readonly moduleId: module.Id
  *  readonly moduleMap: M
  * }} Config
  */
 
 /**
  * @template M
- * @typedef {readonly[moduleT.State, M]} Result
+ * @typedef {readonly[module.State, M]} Result
  */
 
 /** @type {<M>(moduleMap: M) => Result<M>} */
@@ -32,19 +32,19 @@ const notFound = moduleMap => [['error', ['file not found']], moduleMap]
 
 /**
  * @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>
  * }
  */
-const getOrBuild = compile => packageGet => moduleMapInterface =>  {
-    /** @typedef {typeof moduleMapInterface extends moduleT.MapInterface<infer M> ? M : never} M */
+export const getOrBuild = compile => packageGet => moduleMapInterface =>  {
+    /** @typedef {typeof moduleMapInterface extends module.MapInterface<infer M> ? M : never} M */
 
     /**
-     * @type {(buildSet: StringSet.StringSet) =>
-     *  (moduleId: moduleT.Id) =>
+     * @type {(buildSet: stringSet.StringSet) =>
+     *  (moduleId: module.Id) =>
      *  (source: string) =>
      *  (moduleMap: M) =>
      *  Result<M>}
@@ -53,9 +53,9 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
         const moduleIdStr = idToString(moduleId)
         const buildSet1 = setSet(moduleIdStr)(buildSet)
         const moduleDir = dir(moduleId)
-        /** @type {function_.Require<readonly[Map.Map<string>, M]>} */
+        /** @type {function_.Require<readonly[map.Map<string>, M]>} */
         const require_ = p => ([requireMap, m]) => {
-            /** @type {(e: unknown) => function_.Result<readonly[Map.Map<string>, M]>} */
+            /** @type {(e: unknown) => function_.Result<readonly[map.Map<string>, M]>} */
             const error = e => [['error', e], [requireMap, m]]
             if (moduleDir === null) { return error('file not found') }
             const r = parseAndFind(packageGet)(moduleDir)(p)
@@ -66,9 +66,9 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
             return [state[0] === 'error' ? state : ['ok', state[1].exports], [setReplace(p)(rIdStr)(requireMap), m1]]
         }
         return source => moduleMap => {
-            /** @type {(s: moduleT.State) => (m: M) => Result<M>} */
+            /** @type {(s: module.State) => (m: M) => Result<M>} */
             const set = s => m => [s, moduleMapInterface.setReplace(moduleIdStr)(s)(m)]
-            /** @type {(e: moduleT.Error) => (m: M) => Result<M>} */
+            /** @type {(e: module.Error) => (m: M) => Result<M>} */
             const error = e => set(['error', e])
             // check compilation
             const [kind, result] = compile(source)
@@ -81,7 +81,7 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
             return x(moduleMap2)
         }
     }
-    /** @type {(moduleId: moduleT.Id) => (moduleMap: M) => Result<M>} */
+    /** @type {(moduleId: module.Id) => (moduleMap: M) => Result<M>} */
     const f = moduleId => moduleMap => {
         const moduleIdStr = idToString(moduleId)
         // check moduleMap
@@ -98,8 +98,3 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
     }
     return f
 }
-
-export default {
-    /** @readonly */
-    getOrBuild,
-}

package/commonjs/build/test.f.mjs

@@ -1,10 +1,10 @@
-import _ from './module.f.mjs'
-import map, * as Map from '../../types/map/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as map from '../../types/map/module.f.mjs'
 import * as Module from '../module/module.f.mjs'
 import * as ModuleFunction from '../module/function/module.f.mjs'
 import * as Result from '../../types/result/module.f.mjs'
 import * as Package from '../package/module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { at } = o
 
 /** @type {{ readonly [k in string]?: Result.Result<ModuleFunction.Function_, unknown> }} */
@@ -69,7 +69,7 @@ const packageGet = packageId => {
 const getOrBuild = _.getOrBuild
     (compile)
     (packageGet)
-    (/** @type {Module.MapInterface<Map.Map<Module.State>>} */(map))
+    (/** @type {Module.MapInterface<map.Map<Module.State>>} */(map))
 
 export default () => {
     let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(map.empty)

package/commonjs/module/function/module.f.mjs

@@ -19,5 +19,3 @@ import * as TypesResult from '../../../types/result/module.f.mjs'
  */
 
 /** @typedef {(source: string) => TypesResult.Result<Function_, unknown>} Compile */
-
-export default {}