functionalscript 0.2.5 → 0.3.0

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

@@ -1,23 +0,0 @@
-export function rust(library: types.Library): Text.Block;
-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;
-};
-import * as types from '../types/module.f.mjs';
-import * as Text from '../../text/module.f.mjs';

package/out/com/rust/module.f.mjs

@@ -1,224 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/**
- * This module generates Rust code for COM interop from a high-level type library definition.
- *
- * The module provides functions to define structs, traits, and implementations in Rust,
- * specifically tailored for `nanocom` interoperation.
- */
-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 * as list from '../../types/list/module.f.mjs';
-const { flat, map, flatMap } = list;
-const { entries } = Object;
-import * as func from '../../types/function/module.f.mjs';
-const { fn } = func;
-import * as string from '../../types/string/module.f.mjs';
-const { join } = string;
-/** @type {(field: string) => string} */
-const rustField = field => `pub ${field},`;
-const mapRustField = map(rustField);
-/** @type {(b: list.Thunk<string>) => (name: string) => Text.Block} */
-const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`];
-const commaJoin = join(', ');
-/** @type {(name: string) => string} */
-const ref = name => `${name}::Ref`;
-/** @type {(name: string) => string} */
-const obj = name => `&${name}::Object`;
-const self = ['&self'];
-/** @type {(p: types.Field) => string} */
-const paramName = ([n]) => n;
-/** @type {(p: types.FieldArray) => list.Thunk<string>} */
-const callList = p => map(paramName)(paramList(p));
-/** @type {(p: types.FieldArray) => string} */
-const call = p => commaJoin(callList(p));
-/** @type {(p: types.FieldArray) => string} */
-const virtualCall = p => commaJoin(flat([['self'], callList(p)]));
-const super_ = 'super::';
-/** @type {(m: types.Method) => string} */
-const assign = ([n]) => `${n}: Self::${n},`;
-const mapAssign = map(assign);
-const this_ = ['this: &Object'];
-/** @type {(n: string) => string} */
-const rustType = n => `pub type ${n} = nanocom::${n}<Interface>;`;
-/**
- * @template T
- * @typedef {T|{}} OptionalProperty
- */
-/** @typedef {{readonly where: readonly string[]}} Where */
-/**
- * @typedef {OptionalProperty<Where> & {readonly content: Text.Block}} WhereContent
- */
-/** @type {(h: string) => (wh: WhereContent) => Text.Block} */
-const whereContent = h => wh => {
-    const w = 'where' in wh ? [
-        h,
-        `where`,
-        mapComma(wh.where),
-        '{'
-    ] : [`${h} {`];
-    const x = [
-        wh.content,
-        '}',
-    ];
-    return flat([w, x]);
-};
-/**
- * @typedef {{
- *  readonly param?: string
- *  readonly trait: string
- *  readonly type: string
- *  readonly where?: readonly string[]
- *  readonly content: Text.Block
- * }} Impl
- */
-/** @type {(impl: Impl) => Text.Block} */
-const rustImpl = i => {
-    const p = 'param' in i ? `<${i.param}>` : '';
-    const header = `impl${p} ${i.trait} for ${i.type}`;
-    return whereContent(header)(i);
-};
-/**
- * @typedef {{
- *  readonly pub?: true
- *  readonly type: string
- *  readonly where?: readonly string[]
- *  readonly content: Text.Block
- * }} Trait
- */
-/** @type {(s: string) => string} */
-const comma = s => `${s},`;
-const mapComma = map(comma);
-/** @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) => Text.Block} */
-const traitImpl = t => {
-    const i = rustImpl({
-        param: 'T',
-        trait: t.type,
-        type: 'T',
-        where,
-        content: [],
-    });
-    return flat([trait({ ...t, where }), i]);
-};
-const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<Self>: Ex'];
-/**
- * Generates Rust code for the given type library.
- *
- * @param {types.Library} library - The library of type definitions to generate Rust code for.
- * @returns {Text.Block} - A block of Rust code representing the library.
- */
-export const rust = library => {
-    /** @type {(p: string) => (o: (_: string) => string) => (t: types.Type) => string} */
-    const type = p => {
-        /** @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])}`;
-            }
-            const [id] = t;
-            const fullId = `${p}${id}`;
-            return 'interface' in library[id] ? o(fullId) : fullId;
-        };
-        return f;
-    };
-    /** @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);
-    const mapParam = map(param);
-    const mapField = map(pf('')(ref));
-    /** @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} */
-    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} */
-    const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`;
-    /** @type {(m: types.Method) => string} */
-    const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`;
-    const mapVirtualFn = map(virtualFn);
-    /** @type {(m: types.Method) => string} */
-    const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`;
-    /** @type {(m: types.Method) => string} */
-    const traitFn = m => `${headerFn(m)};`;
-    const mapTraitFn = map(traitFn);
-    /** @type {(m: types.Method) => Text.Block} */
-    const implFn = m => {
-        const [n, p] = m;
-        return [
-            `${headerFn(m)} {`,
-            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
-            '}'
-        ];
-    };
-    const flatMapImplFn = flatMap(implFn);
-    /** @type {(m: types.Method) => Text.Block} */
-    const impl = ([n, p]) => {
-        const type = virtualFnType(` ${n}`)(p);
-        return [
-            `${type} {`,
-            [`unsafe { nanocom::CObject::from_object_unchecked(this) }.${n}(${call(p)})`],
-            '}'
-        ];
-    };
-    const flatMapImpl = flatMap(impl);
-    /** @type {(i: types.Interface) => (name: string) => Text.Block} */
-    const interface_ = ({ interface: i, guid }) => name => {
-        const e = entries(i);
-        return [
-            `pub mod ${name} {`,
-            [
-                rustType('Object'),
-                rustType('Ref'),
-                rustType('Vmt'),
-            ],
-            rustStruct(mapVirtualFn(e))('Interface'),
-            rustImpl({
-                trait: 'nanocom::Interface',
-                type: 'Interface',
-                content: [`const GUID: nanocom::GUID = 0x${guid.replaceAll('-', '_')};`]
-            }),
-            trait({ pub: true, type: 'Ex', content: mapTraitFn(e) }),
-            rustImpl({
-                trait: 'Ex',
-                type: 'Object',
-                content: flatMapImplFn(e)
-            }),
-            traitImpl({
-                pub: true,
-                type: 'ClassEx',
-                content: ['const VMT: Vmt = Vmt {',
-                    ['iunknown: nanocom::CObject::<Self>::IUNKNOWN,',
-                        'interface: Interface {',
-                        mapAssign(e),
-                        '},',
-                    ],
-                    '};'
-                ]
-            }),
-            traitImpl({
-                type: 'PrivateClassEx',
-                content: flatMapImpl(e)
-            }),
-            '}'
-        ];
-    };
-    /** @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/out/com/rust/test.f.d.mts

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

package/out/com/rust/test.f.mjs

@@ -1,123 +0,0 @@
-import rust from './testlib.f.mjs';
-export default () => {
-    const e = '#![allow(non_snake_case)]\n' +
-        '#[repr(C)]\n' +
-        'pub struct Slice {\n' +
-        '    pub Start: *const u8,\n' +
-        '    pub Size: usize,\n' +
-        '}\n' +
-        '#[repr(C)]\n' +
-        'pub struct ManagedStruct {\n' +
-        '    pub M: IMy::Ref,\n' +
-        '}\n' +
-        'pub mod IMy {\n' +
-        '    pub type Object = nanocom::Object<Interface>;\n' +
-        '    pub type Ref = nanocom::Ref<Interface>;\n' +
-        '    pub type Vmt = nanocom::Vmt<Interface>;\n' +
-        '    #[repr(C)]\n' +
-        '    pub struct Interface {\n' +
-        '        pub GetSlice: unsafe extern "system" fn(this: &Object) -> super::Slice,\n' +
-        '        pub SetSlice: unsafe extern "system" fn(this: &Object, slice: super::Slice),\n' +
-        '        pub GetUnsafe: unsafe extern "system" fn(this: &Object) -> *const bool,\n' +
-        '        pub SetUnsafe: unsafe extern "system" fn(this: &Object, p: *const super::Slice, size: u32),\n' +
-        '        pub Some: unsafe extern "system" fn(this: &Object, p: &super::IMy::Object) -> bool,\n' +
-        '        pub GetIMy: unsafe extern "system" fn(this: &Object, a: u16, b: i16) -> super::IMy::Ref,\n' +
-        '        pub SetManagedStruct: unsafe extern "system" fn(this: &Object, a: super::ManagedStruct),\n' +
-        '    }\n' +
-        '    impl nanocom::Interface for Interface {\n' +
-        '        const GUID: nanocom::GUID = 0xC66FB270_2D80_49AD_BB6E_88C1F90B805D;\n' +
-        '    }\n' +
-        '    pub trait Ex {\n' +
-        '        fn GetSlice(&self) -> super::Slice;\n' +
-        '        fn SetSlice(&self, slice: super::Slice);\n' +
-        '        fn GetUnsafe(&self) -> *const bool;\n' +
-        '        fn SetUnsafe(&self, p: *const super::Slice, size: u32);\n' +
-        '        fn Some(&self, p: &super::IMy::Object) -> bool;\n' +
-        '        fn GetIMy(&self, a: u16, b: i16) -> super::IMy::Ref;\n' +
-        '        fn SetManagedStruct(&self, a: super::ManagedStruct);\n' +
-        '    }\n' +
-        '    impl Ex for Object {\n' +
-        '        fn GetSlice(&self) -> super::Slice {\n' +
-        '            unsafe { (self.interface().GetSlice)(self) }\n' +
-        '        }\n' +
-        '        fn SetSlice(&self, slice: super::Slice) {\n' +
-        '            unsafe { (self.interface().SetSlice)(self, slice) }\n' +
-        '        }\n' +
-        '        fn GetUnsafe(&self) -> *const bool {\n' +
-        '            unsafe { (self.interface().GetUnsafe)(self) }\n' +
-        '        }\n' +
-        '        fn SetUnsafe(&self, p: *const super::Slice, size: u32) {\n' +
-        '            unsafe { (self.interface().SetUnsafe)(self, p, size) }\n' +
-        '        }\n' +
-        '        fn Some(&self, p: &super::IMy::Object) -> bool {\n' +
-        '            unsafe { (self.interface().Some)(self, p) }\n' +
-        '        }\n' +
-        '        fn GetIMy(&self, a: u16, b: i16) -> super::IMy::Ref {\n' +
-        '            unsafe { (self.interface().GetIMy)(self, a, b) }\n' +
-        '        }\n' +
-        '        fn SetManagedStruct(&self, a: super::ManagedStruct) {\n' +
-        '            unsafe { (self.interface().SetManagedStruct)(self, a) }\n' +
-        '        }\n' +
-        '    }\n' +
-        '    pub trait ClassEx\n' +
-        '    where\n' +
-        '        Self: nanocom::Class<Interface = Interface>,\n' +
-        '        nanocom::CObject<Self>: Ex,\n' +
-        '    {\n' +
-        '        const VMT: Vmt = Vmt {\n' +
-        '            iunknown: nanocom::CObject::<Self>::IUNKNOWN,\n' +
-        '            interface: Interface {\n' +
-        '                GetSlice: Self::GetSlice,\n' +
-        '                SetSlice: Self::SetSlice,\n' +
-        '                GetUnsafe: Self::GetUnsafe,\n' +
-        '                SetUnsafe: Self::SetUnsafe,\n' +
-        '                Some: Self::Some,\n' +
-        '                GetIMy: Self::GetIMy,\n' +
-        '                SetManagedStruct: Self::SetManagedStruct,\n' +
-        '            },\n' +
-        '        };\n' +
-        '    }\n' +
-        '    impl<T> ClassEx for T\n' +
-        '    where\n' +
-        '        Self: nanocom::Class<Interface = Interface>,\n' +
-        '        nanocom::CObject<Self>: Ex,\n' +
-        '    {\n' +
-        '    }\n' +
-        '    trait PrivateClassEx\n' +
-        '    where\n' +
-        '        Self: nanocom::Class<Interface = Interface>,\n' +
-        '        nanocom::CObject<Self>: Ex,\n' +
-        '    {\n' +
-        '        extern "system" fn GetSlice(this: &Object) -> super::Slice {\n' +
-        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetSlice()\n' +
-        '        }\n' +
-        '        extern "system" fn SetSlice(this: &Object, slice: super::Slice) {\n' +
-        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetSlice(slice)\n' +
-        '        }\n' +
-        '        extern "system" fn GetUnsafe(this: &Object) -> *const bool {\n' +
-        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetUnsafe()\n' +
-        '        }\n' +
-        '        extern "system" fn SetUnsafe(this: &Object, p: *const super::Slice, size: u32) {\n' +
-        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetUnsafe(p, size)\n' +
-        '        }\n' +
-        '        extern "system" fn Some(this: &Object, p: &super::IMy::Object) -> bool {\n' +
-        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.Some(p)\n' +
-        '        }\n' +
-        '        extern "system" fn GetIMy(this: &Object, a: u16, b: i16) -> super::IMy::Ref {\n' +
-        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetIMy(a, b)\n' +
-        '        }\n' +
-        '        extern "system" fn SetManagedStruct(this: &Object, a: super::ManagedStruct) {\n' +
-        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetManagedStruct(a)\n' +
-        '        }\n' +
-        '    }\n' +
-        '    impl<T> PrivateClassEx for T\n' +
-        '    where\n' +
-        '        Self: nanocom::Class<Interface = Interface>,\n' +
-        '        nanocom::CObject<Self>: Ex,\n' +
-        '    {\n' +
-        '    }\n' +
-        '}';
-    if (rust !== e) {
-        throw rust;
-    }
-};

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

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

package/out/com/rust/testlib.f.mjs

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

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

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

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

@@ -1,26 +0,0 @@
-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/out/com/test/build.f.mjs

@@ -1,98 +0,0 @@
-import * as list from '../../types/list/module.f.mjs';
-const { flat } = list;
-import cppContent from '../cpp/testlib.f.mjs';
-import csContent from '../cs/testlib.f.mjs';
-import rustContent from '../rust/testlib.f.mjs';
-/**
- * @typedef {|
- *  'aix' |
- *  'android' |
- *  'darwin' |
- *  'freebsd' |
- *  'haiku' |
- *  'linux' |
- *  'openbsd' |
- *  'sunos' |
- *  'win32' |
- *  'cygwin' |
- *  'netbsd'
- * } Platform
- */
-/**
- * @typedef {{
- *  readonly dirname: string
- *  readonly platform: Platform
- * }} NodeJs
- */
-/**
- * @typedef {{
- *  readonly file: {
- *      readonly name: string
- *      readonly content: string
- *  }
- *  readonly line: list.List<list.List<string>>
- * }} Output
- */
-/** @typedef {(nodejs: NodeJs) => Output} Func */
-/** @type {(platform: Platform) => readonly string[]} */
-const flags = platform => {
-    switch (platform) {
-        case 'win32':
-            return [];
-        case 'linux':
-            return ['-std=c++17', '-lstdc++', '-fPIC'];
-        default:
-            return ['-std=c++17', '-lc++'];
-    }
-};
-/** @type {(platform: Platform) => (name: string) => string} */
-const output = platform => name => {
-    switch (platform) {
-        case 'win32': return `${name}.dll`;
-        case 'darwin': return `lib${name}.dylib`;
-        default: return `lib${name}.so`;
-    }
-};
-/** @type {Func} */
-const cpp = ({ dirname, platform }) => ({
-    file: {
-        name: `${dirname}/cpp/_result.hpp`,
-        content: cppContent(),
-    },
-    line: [
-        flat([
-            ['clang', '-shared', '-o', output(platform)('testc')],
-            flags(platform),
-            [`${dirname}/cpp/main.cpp`],
-        ]),
-    ],
-});
-/** @type {Func} */
-const cs = ({ dirname, platform }) => ({
-    file: {
-        name: `${dirname}/cs/_result.cs`,
-        content: csContent,
-    },
-    line: [
-        platform === 'win32'
-            ? ['dotnet', 'run', '--project', `${dirname}/cs/cs.csproj`]
-            // .Net on Linux and MacOS doesn't properly support COM object marshalling
-            : ['dotnet', 'build', `${dirname}/cs/cs.csproj`]
-    ],
-});
-/** @type {Func} */
-const rust = ({ dirname }) => ({
-    file: {
-        name: `${dirname}/rust/src/_result.rs`,
-        content: rustContent,
-    },
-    line: [['cargo', 'build' /**, '--locked' */]]
-});
-export default {
-    /** @readonly */
-    cpp,
-    /** @readonly */
-    cs,
-    /** @readonly */
-    rust,
-};

package/out/com/test/build.mjs

@@ -1,40 +0,0 @@
-import { writeFileSync } from 'node:fs';
-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 * as string from '../../types/string/module.f.mjs';
-const { join } = string;
-const { log, error } = console;
-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';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const nodeJs = {
-    dirname: __dirname,
-    platform,
-};
-/** @type {(f: Build.Func) => void} */
-const run = f => {
-    const { file: { name, content }, line } = f(nodeJs);
-    log(`${bold}writing: ${name}${reset}`);
-    writeFileSync(name, content);
-    for (const i of list.iterable(line)) {
-        const cmd = join(' ')(i);
-        log(`${bold}running: ${cmd}${reset}`);
-        try {
-            log(execSync(cmd).toString());
-        }
-        catch (e) {
-            // @ts-ignore
-            error(e.output.toString());
-            exit(-1);
-        }
-    }
-};
-run(cpp);
-run(rust);
-run(cs);

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

@@ -1,23 +0,0 @@
-/** @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 = {
-    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];
-import * as list from '../../types/list/module.f.mjs';
-import * as O from '../../types/object/module.f.mjs';

package/out/com/types/module.f.mjs

@@ -1,51 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as O from '../../types/object/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;
-/** @typedef {{readonly[k in string]: Definition}} Library */
-/** @typedef {Struct|Interface} Definition */
-/**
- * @typedef {{
- *  readonly struct: FieldArray
- * }} Struct
- */
-/** @typedef {{readonly[k in string]: Type}} FieldArray */
-/** @typedef {O.Entry<Type>} Field */
-/**
- * @typedef {{
- *  readonly interface: MethodArray
- *  readonly guid: string
- * }} Interface
- */
-/** @typedef {{readonly[k in string]: FieldArray}} MethodArray */
-/** @typedef {O.Entry<FieldArray>} Method */
-/** @typedef {BaseType|Id|Pointer} Type */
-/** @typedef {readonly[string]} Id */
-/**
- * @typedef {|
- *  'u8'|
- *  'i8'|
- *  'u16'|
- *  'i16'|
- *  'u32'|
- *  'i32'|
- *  'u64'|
- *  'i64'|
- *  'usize'|
- *  'isize'|
- *  'f32'|
- *  'f64'|
- *  'bool'
- * } BaseType
- */
-/** @typedef {readonly['*', Type]} Pointer */
-/** @type {(kv: O.Entry<Type>) => boolean} */
-const isParam = ([name]) => name !== '_';
-const filterParam = filter(isParam);
-/** @type {(fa: FieldArray) => list.List<Field> } */
-export const paramList = compose(entries)(filterParam);
-/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
-export const result = v => f => fa => '_' in fa ? f(fa._) : v;

package/out/com/types/testlib.f.d.mts

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