functionalscript 0.1.594 → 0.1.597

package/.github/workflows/npm-publish.yml

@@ -24,9 +24,10 @@ jobs:
       - uses: denoland/setup-deno@v1
         with:
           deno-version: 2
-      # - run: npm ci
+      - run: npm ci
       - run: npm run version
       - run: npm run index
+      - run: npm run tscp
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}

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

@@ -0,0 +1,8 @@
+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';

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/cpp/test.f.d.mts

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

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

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

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

@@ -0,0 +1,8 @@
+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';

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/cs/test.f.d.mts

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

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

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

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

@@ -0,0 +1,28 @@
+declare namespace _default {
+    export { rust };
+}
+export default _default;
+export type OptionalProperty<T> = T | {};
+export type Where = {
+    readonly where: readonly string[];
+};
+export type WhereContent = OptionalProperty<Where> & {
+    readonly content: Text.Block;
+};
+export type Impl = {
+    readonly param?: string;
+    readonly trait: string;
+    readonly type: string;
+    readonly where?: readonly string[];
+    readonly content: Text.Block;
+};
+export type Trait = {
+    readonly pub?: true;
+    readonly type: string;
+    readonly where?: readonly string[];
+    readonly content: Text.Block;
+};
+/** @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/rust/test.f.d.mts

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

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

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/com/test/build.d.mts

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

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

@@ -0,0 +1,26 @@
+declare namespace _default {
+    export { cpp };
+    export { cs };
+    export { rust };
+}
+export default _default;
+export type Platform = "aix" | "android" | "darwin" | "freebsd" | "haiku" | "linux" | "openbsd" | "sunos" | "win32" | "cygwin" | "netbsd";
+export type NodeJs = {
+    readonly dirname: string;
+    readonly platform: Platform;
+};
+export type Output = {
+    readonly file: {
+        readonly name: string;
+        readonly content: string;
+    };
+    readonly line: List.List<List.List<string>>;
+};
+export type Func = (nodejs: NodeJs) => Output;
+/** @type {Func} */
+declare const cpp: Func;
+/** @type {Func} */
+declare const cs: Func;
+/** @type {Func} */
+declare const rust: Func;
+import * as List from '../../types/list/module.f.mjs';

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.d.mts

@@ -0,0 +1,28 @@
+declare namespace _default {
+    export { paramList };
+    export { result };
+}
+export default _default;
+export type Library = { readonly [k in string]: Definition; };
+export type Definition = Struct | Interface;
+export type Struct = {
+    readonly struct: FieldArray;
+};
+export type FieldArray = { readonly [k in string]: Type; };
+export type Field = O.Entry<Type>;
+export type Interface = {
+    readonly interface: MethodArray;
+    readonly guid: string;
+};
+export type MethodArray = { readonly [k in string]: FieldArray; };
+export type Method = O.Entry<FieldArray>;
+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 O from '../../types/object/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';

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/com/types/testlib.f.d.mts

@@ -0,0 +1,44 @@
+declare const _default: {
+    Slice: {
+        struct: {
+            Start: ["*", "u8"];
+            Size: "usize";
+        };
+    };
+    ManagedStruct: {
+        struct: {
+            M: ["IMy"];
+        };
+    };
+    IMy: {
+        guid: string;
+        interface: {
+            GetSlice: {
+                _: ["Slice"];
+            };
+            SetSlice: {
+                slice: ["Slice"];
+            };
+            GetUnsafe: {
+                _: ["*", "bool"];
+            };
+            SetUnsafe: {
+                p: ["*", ["Slice"]];
+                size: "u32";
+            };
+            Some: {
+                p: ["IMy"];
+                _: "bool";
+            };
+            GetIMy: {
+                a: "u16";
+                b: "i16";
+                _: ["IMy"];
+            };
+            SetManagedStruct: {
+                a: ["ManagedStruct"];
+            };
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,24 @@
+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) =>
+ *  (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';
+import * as function_ from '../module/function/module.f.mjs';

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

@@ -0,0 +1,3 @@
+declare function _default(): void;
+export default _default;
+export type StringMap = { readonly [k in string]: string; };

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

@@ -0,0 +1,7 @@
+declare const _default: {};
+export default _default;
+export type Function_ = <M>(require: Require<M>) => (prior: M) => Result<M>;
+export type Result<M> = readonly [Result.Result<unknown, unknown>, M];
+export type Require<M> = (path: string) => (prior: M) => Result<M>;
+export type Compile = (source: string) => Result.Result<Function_, unknown>;
+import * as Result from '../../../types/result/module.f.mjs';

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

@@ -0,0 +1,57 @@
+declare namespace _default {
+    export { dir };
+    export { idToString };
+}
+export default _default;
+export type MapInterface<M> = {
+    readonly at: (moduleId: string) => (moduleMap: M) => State | null;
+    readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M;
+};
+export type State = readonly ["ok", Module] | readonly ["error", Error];
+export type Module = {
+    readonly exports: unknown;
+    readonly requireMap: O.Map<string>;
+};
+export type Error = ["file not found"] | ["compilation error", unknown] | ["runtime error", unknown] | ["circular reference"];
+export type Id = {
+    readonly package: string;
+    readonly path: readonly string[];
+};
+/**
+ * @template M
+ * @typedef {{
+ *  readonly at: (moduleId: string) => (moduleMap: M) => State | null
+ *  readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
+ * }} MapInterface
+ */
+/**
+ * @typedef {|
+ *  readonly['ok', Module] |
+ *  readonly['error', Error]
+ * } State
+ */
+/**
+ * @typedef {{
+ *  readonly exports: unknown
+ *  readonly requireMap: O.Map<string>
+ * }} Module
+ */
+/**
+ * @typedef {|
+ *  ['file not found'] |
+ *  ['compilation error', unknown] |
+ *  ['runtime error', unknown] |
+ *  ['circular reference']
+ * } Error
+ */
+/**
+ * @typedef {{
+ *  readonly package: string
+ *  readonly path: readonly string[]
+ * }} Id
+ */
+/** @type {(id: Id) => Id | null} */
+declare const dir: (id: Id) => Id | null;
+/** @type {(id: Id) => string} */
+declare const idToString: (id: Id) => string;
+import * as O from '../../types/object/module.f.mjs';

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/module.d.mts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    export { compile };
+}
+export default _default;
+/** @type {ModuleFunction.Compile} */
+declare const compile: ModuleFunction.Compile;
+import * as ModuleFunction from './module/function/module.f.mjs';

package/commonjs/module.f.d.mts

@@ -0,0 +1,4 @@
+declare const _default: {};
+export default _default;
+export type PackageMap = (packageName: string) => PackageMap | Package | null;
+export type Package = readonly [string, PackageMap, (fileName: string) => string | null];