functionalscript 0.1.596 → 0.1.597

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

@@ -2,7 +2,7 @@ declare namespace _default {
     export { cpp };
 }
 export default _default;
-/** @type {(name: string) => (lib: typesT.Library) => textT.Block} */
-declare const cpp: (name: string) => (lib: typesT.Library) => textT.Block;
-import * as typesT from '../types/module.f.mjs';
-import * as textT from '../../text/module.f.mjs';
+/** @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';

package/com/cpp/module.f.mjs

@@ -1,6 +1,6 @@
-import types, * as typesT from '../types/module.f.mjs'
-import text, * as textT from '../../text/module.f.mjs'
-import obj, * as O from '../../types/object/module.f.mjs'
+import types, * as Types from '../types/module.f.mjs'
+import text, * 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'
 const { join } = string
@@ -8,7 +8,7 @@ const { paramList } = types
 const { map, flatMap, flat } = list
 const { entries } = Object
 
-/** @type {(name: string) => (body: textT.Block) => textT.Block} */
+/** @type {(name: string) => (body: Text.Block) => Text.Block} */
 const struct = name => body => [`struct ${name}`, '{', body, '};']
 
 const baseTypeMap = {
@@ -27,7 +27,7 @@ const baseTypeMap = {
     bool: 'bool',
 }
 
-/** @type {(t: typesT.BaseType) => string} */
+/** @type {(t: Types.BaseType) => string} */
 const baseType = t => baseTypeMap[t]
 
 const resultVoid = types.result('void')
@@ -43,17 +43,17 @@ const ptr = id => `${id} const*`
 /** @type {(id: string) => string} */
 const ref = id => `${id} const&`
 
-/** @type {(p: typesT.Field) => string} */
+/** @type {(p: Types.Field) => string} */
 const paramName = ([name]) => name
 
 const mapParamName = map(paramName)
 
 const joinComma = join(', ')
 
-/** @type {(name: string) => (lib: typesT.Library) => textT.Block} */
+/** @type {(name: string) => (lib: Types.Library) => Text.Block} */
 const cpp = name => lib => {
 
-    /** @type {(t: typesT.Type) => string|null} */
+    /** @type {(t: Types.Type) => string|null} */
     const interface_ = t => {
         if (!(t instanceof Array) || t.length !== 1) {
             return null
@@ -62,7 +62,7 @@ const cpp = name => lib => {
         return 'interface' in lib[name] ? name : null
     }
 
-    /** @type {(i: (t: string) => string) => (t: typesT.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*` }
@@ -74,27 +74,27 @@ const cpp = name => lib => {
 
     const resultType = objectType(ptr)
 
-    /** @type {(s: typesT.Field) => textT.Item} */
+    /** @type {(s: Types.Field) => Text.Item} */
     const field = ([name, t]) => `${type(t)} ${name};`
 
     const mapField = map(field)
 
-    /** @type {(s: typesT.Struct) => textT.Block} */
+    /** @type {(s: Types.Struct) => Text.Block} */
     const defStruct = s => mapField(entries(s.struct))
 
-    /** @type {(fa: typesT.FieldArray) => string} */
+    /** @type {(fa: Types.FieldArray) => string} */
     const cppResult = resultVoid(resultType)
 
-    /** @type {(p: typesT.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) => textT.Item} */
+    /** @type {(result: string) => (paramArrayStr: string) => (name: string) => Text.Item} */
     const methodHeader = result => paramArrayStr => name =>
         `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`
 
-    /** @type {(m: typesT.Method) => readonly textT.Item[]} */
+    /** @type {(m: Types.Method) => readonly Text.Item[]} */
     const method = ([name, paramArray]) => {
         const result = cppResult(paramArray)
         const paramL = paramList(paramArray)
@@ -115,7 +115,7 @@ const cpp = name => lib => {
 
     const mapMethod = flatMap(method)
 
-    /** @type {(i: typesT.Interface) => textT.Block} */
+    /** @type {(i: Types.Interface) => Text.Block} */
     const defInterface = ({ guid, interface: i }) => {
         const g = guid.replaceAll('-', '');
         const lo = g.substring(0, 16);
@@ -126,7 +126,7 @@ const cpp = name => lib => {
         ])
     }
 
-    /** @type {(kv: O.Entry<typesT.Definition>) => textT.Block} */
+    /** @type {(kv: O.Entry<Types.Definition>) => Text.Block} */
     const def = ([name, d]) => 'interface' in d
         ? [
             `class ${name} : public ::nanocom::IUnknown`,
@@ -137,7 +137,7 @@ const cpp = name => lib => {
         ]
         : struct(name)(defStruct(d))
 
-    /** @type {(kv: O.Entry<typesT.Definition>) => textT.Block} */
+    /** @type {(kv: O.Entry<Types.Definition>) => Text.Block} */
     const forward = ([name]) => [`struct ${name};`]
 
     const e = entries(lib)

package/com/cs/module.f.mjs

@@ -6,7 +6,7 @@ import list, * as List from '../../types/list/module.f.mjs'
 const { flat, map, some, flatMap } = list
 import string from '../../types/string/module.f.mjs'
 const { join } = string
-import obj, * as O from '../../types/object/module.f.mjs'
+import * as O from '../../types/object/module.f.mjs'
 const { entries } = Object
 
 /** @type {(v: string) => string} */

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

@@ -7,22 +7,22 @@ export type Where = {
     readonly where: readonly string[];
 };
 export type WhereContent = OptionalProperty<Where> & {
-    readonly content: textT.Block;
+    readonly content: Text.Block;
 };
 export type Impl = {
     readonly param?: string;
     readonly trait: string;
     readonly type: string;
     readonly where?: readonly string[];
-    readonly content: textT.Block;
+    readonly content: Text.Block;
 };
 export type Trait = {
     readonly pub?: true;
     readonly type: string;
     readonly where?: readonly string[];
-    readonly content: textT.Block;
+    readonly content: Text.Block;
 };
-/** @type {(library: typesT.Library) => textT.Block} */
-declare const rust: (library: typesT.Library) => textT.Block;
-import * as textT from '../../text/module.f.mjs';
-import * as typesT from '../types/module.f.mjs';
+/** @type {(library: Types.Library) => Text.Block} */
+declare const rust: (library: Types.Library) => Text.Block;
+import * as Text from '../../text/module.f.mjs';
+import * as Types from '../types/module.f.mjs';

package/com/rust/module.f.mjs

@@ -1,7 +1,7 @@
-import types, * as typesT from '../types/module.f.mjs'
+import types, * as Types from '../types/module.f.mjs'
 const { paramList } = types
-import text, * as textT from '../../text/module.f.mjs'
-import object, * as O from '../../types/object/module.f.mjs'
+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'
 const { flat, map, flatMap } = list
 const { entries } = Object
@@ -15,7 +15,7 @@ const rustField = field => `pub ${field},`
 
 const mapRustField = map(rustField)
 
-/** @type {(b: List.Thunk<string>) => (name: string) => textT.Block} */
+/** @type {(b: List.Thunk<string>) => (name: string) => Text.Block} */
 const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`]
 
 const commaJoin = join(', ')
@@ -28,21 +28,21 @@ const obj = name => `&${name}::Object`
 
 const self = ['&self']
 
-/** @type {(p: typesT.Field) => string} */
+/** @type {(p: Types.Field) => string} */
 const paramName = ([n]) => n
 
-/** @type {(p: typesT.FieldArray) => List.Thunk<string>} */
+/** @type {(p: Types.FieldArray) => List.Thunk<string>} */
 const callList = p => map(paramName)(paramList(p))
 
-/** @type {(p: typesT.FieldArray) => string} */
+/** @type {(p: Types.FieldArray) => string} */
 const call = p => commaJoin(callList(p))
 
-/** @type {(p: typesT.FieldArray) => string} */
+/** @type {(p: Types.FieldArray) => string} */
 const virtualCall = p => commaJoin(flat([['self'], callList(p)]))
 
 const super_ = 'super::'
 
-/** @type {(m: typesT.Method) => string} */
+/** @type {(m: Types.Method) => string} */
 const assign = ([n]) => `${n}: Self::${n},`
 
 const mapAssign = map(assign)
@@ -60,10 +60,10 @@ const rustType = n => `pub type ${n} = nanocom::${n}<Interface>;`
 /** @typedef {{readonly where: readonly string[]}} Where */
 
 /**
- * @typedef {OptionalProperty<Where> & {readonly content: textT.Block}} WhereContent
+ * @typedef {OptionalProperty<Where> & {readonly content: Text.Block}} WhereContent
  */
 
-/** @type {(h: string) => (wh: WhereContent) => textT.Block} */
+/** @type {(h: string) => (wh: WhereContent) => Text.Block} */
 const whereContent = h => wh => {
     const w = 'where' in wh ? [
         h,
@@ -84,11 +84,11 @@ const whereContent = h => wh => {
  *  readonly trait: string
  *  readonly type: string
  *  readonly where?: readonly string[]
- *  readonly content: textT.Block
+ *  readonly content: Text.Block
  * }} Impl
  */
 
-/** @type {(impl: Impl) => textT.Block} */
+/** @type {(impl: Impl) => Text.Block} */
 const rustImpl = i => {
     const p = 'param' in i ? `<${i.param}>` : ''
     const header = `impl${p} ${i.trait} for ${i.type}`
@@ -100,7 +100,7 @@ const rustImpl = i => {
  *  readonly pub?: true
  *  readonly type: string
  *  readonly where?: readonly string[]
- *  readonly content: textT.Block
+ *  readonly content: Text.Block
  * }} Trait
  */
 
@@ -109,14 +109,14 @@ const comma = s => `${s},`
 
 const mapComma = map(comma)
 
-/** @type {(t: Trait) => textT.Block} */
+/** @type {(t: Trait) => Text.Block} */
 const trait = t => {
     const p = t.pub === true ? 'pub ' : ''
     const h = `${p}trait ${t.type}`
     return whereContent(h)(t)
 }
 
-/** @type {(t: Trait) => textT.Block} */
+/** @type {(t: Trait) => Text.Block} */
 const traitImpl = t => {
     const i = rustImpl({
         param: 'T',
@@ -130,12 +130,12 @@ const traitImpl = t => {
 
 const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<Self>: Ex']
 
-/** @type {(library: typesT.Library) => textT.Block} */
+/** @type {(library: Types.Library) => Text.Block} */
 const rust = library => {
 
-    /** @type {(p: string) => (o: (_: string) => string) => (t: typesT.Type) => string} */
+    /** @type {(p: string) => (o: (_: string) => string) => (t: Types.Type) => string} */
     const type = p => {
-        /** @type {(o: (_: string) => string) => (t: typesT.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])}` }
@@ -146,7 +146,7 @@ const rust = library => {
         return f
     }
 
-    /** @type {(p: string) => (o: (_: string) => string) => (f: typesT.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)
@@ -155,36 +155,36 @@ const rust = library => {
 
     const mapField = map(pf('')(ref))
 
-    /** @type {(fa: typesT.FieldArray) => (name: string) => textT.Block} */
+    /** @type {(fa: Types.FieldArray) => (name: string) => Text.Block} */
     const struct = fn(entries)
         .then(mapField)
         .then(rustStruct)
         .result
 
-    /** @type {(first: readonly string[]) => (p: typesT.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: typesT.FieldArray) => string} */
+    /** @type {(n: string) => (p: Types.FieldArray) => string} */
     const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`
 
-    /** @type {(m: typesT.Method) => string} */
+    /** @type {(m: Types.Method) => string} */
     const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`
 
     const mapVirtualFn = map(virtualFn)
 
-    /** @type {(m: typesT.Method) => string} */
+    /** @type {(m: Types.Method) => string} */
     const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`
 
-    /** @type {(m: typesT.Method) => string} */
+    /** @type {(m: Types.Method) => string} */
     const traitFn = m => `${headerFn(m)};`
 
     const mapTraitFn = map(traitFn)
 
-    /** @type {(m: typesT.Method) => textT.Block} */
+    /** @type {(m: Types.Method) => Text.Block} */
     const implFn = m => {
         const [n, p] = m
         return [
@@ -196,7 +196,7 @@ const rust = library => {
 
     const flatMapImplFn = flatMap(implFn)
 
-    /** @type {(m: typesT.Method) => textT.Block} */
+    /** @type {(m: Types.Method) => Text.Block} */
     const impl = ([n, p]) => {
         const type = virtualFnType(` ${n}`)(p)
         return [
@@ -208,7 +208,7 @@ const rust = library => {
 
     const flatMapImpl = flatMap(impl)
 
-    /** @type {(i: typesT.Interface) => (name: string) => textT.Block} */
+    /** @type {(i: Types.Interface) => (name: string) => Text.Block} */
     const interface_ = ({ interface: i, guid }) => name => {
 
         const e = entries(i)
@@ -252,7 +252,7 @@ const rust = library => {
         ]
     }
 
-    /** @type {(type: O.Entry<typesT.Definition>) => textT.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))])

package/com/test/build.mjs

@@ -1,7 +1,7 @@
 import { writeFileSync } from 'node:fs'
 import { execSync } from 'node:child_process'
 import { platform, exit } from 'node:process'
-import build, * as buildT from './build.f.mjs'
+import build, * as Build from './build.f.mjs'
 const { cpp, cs, rust } = build
 import string from '../../types/string/module.f.mjs'
 const { join } = string
@@ -21,7 +21,7 @@ const nodeJs = {
     platform,
 }
 
-/** @type {(f: buildT.Func) => void} */
+/** @type {(f: Build.Func) => void} */
 const run = f => {
     const { file: { name, content }, line } = f(nodeJs)
     log(`${bold}writing: ${name}${reset}`)

package/com/types/module.f.mjs

@@ -1,4 +1,4 @@
-import obj, * as O from '../../types/object/module.f.mjs'
+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'
 const { compose } = f

package/commonjs/module/module.f.mjs

@@ -1,4 +1,4 @@
-import object, * as O from '../../types/object/module.f.mjs'
+import * as O from '../../types/object/module.f.mjs'
 
 /**
  * @template M

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

@@ -5,6 +5,6 @@ export default _default;
 export type DependencyJson = readonly [string, string];
 export type DependencyMapJson = { readonly [k in string]: string; };
 export type DependenciesJson = DependencyMapJson | null;
-/** @type {(j: jsonT.Unknown) => j is DependenciesJson} */
-declare const isDependenciesJson: (j: jsonT.Unknown) => j is DependenciesJson;
-import * as jsonT from '../../../json/module.f.mjs';
+/** @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/module.f.d.mts

@@ -6,7 +6,7 @@ export default _default;
 export type PackageJson = {
     readonly name: string;
     readonly version: string;
-    readonly dependencies?: dependenciesT.DependenciesJson;
+    readonly dependencies?: Dependencies.DependenciesJson;
 };
 export type Package = {
     readonly dependency: (localPackageId: string) => string | null;
@@ -18,10 +18,10 @@ import dependencies from './dependencies/module.f.mjs';
  * @typedef {{
  *  readonly name: string
  *  readonly version: string
- *  readonly dependencies?: dependenciesT.DependenciesJson
+ *  readonly dependencies?: Dependencies.DependenciesJson
  * }} PackageJson
  */
-/** @type {(j: jsonT.Unknown) => j is PackageJson} */
-declare const isPackageJson: (j: jsonT.Unknown) => j is PackageJson;
-import * as dependenciesT from './dependencies/module.f.mjs';
-import * as jsonT from '../../json/module.f.mjs';
+/** @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/path/module.f.d.mts

@@ -19,7 +19,7 @@ export type Path = {
     readonly dir: boolean;
 };
 export type FoundResult = {
-    readonly id: moduleT.Id;
+    readonly id: Module.Id;
     readonly source: string;
 };
 export type Result = FoundResult | null;
@@ -49,19 +49,19 @@ declare const parseGlobal: (d: (local: string) => string | null) => (dir: boolea
 declare const parse: (packageId: string) => (dependencies: (local: string) => string | null) => (local: string) => (path: string) => Path | null;
 /**
  * @typedef {{
- *  readonly id: moduleT.Id
+ *  readonly id: Module.Id
  *  readonly source: string
  * }} FoundResult
  */
 /** @typedef {FoundResult| null} Result */
 /**
- * @type {(packageGet: packageT.Get) =>
- *  (moduleId: moduleT.Id) =>
+ * @type {(packageGet: Package.Get) =>
+ *  (moduleId: Module.Id) =>
  *  (path: string) =>
  *  Result
  * }
  */
-declare const parseAndFind: (packageGet: packageT.Get) => (moduleId: moduleT.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 moduleT from '../module/module.f.mjs';
-import * as packageT from '../package/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.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.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/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/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.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/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'