@lakutata/ffi 0.0.0-stage → 3.1.2

package/dist/esm/lib/generator/Generator.js

@@ -0,0 +1,388 @@
+import path from 'node:path';
+import { NativeLibrary } from '../../components/NativeLibrary.js';
+import { builtinTypes } from '../declarations/Builtins.js';
+import { DeclarationParser } from '../declarations/Parser.js';
+import { CURRENT_PLATFORM } from '../declarations/Platform.js';
+import { loadNativeLibrary } from '../library/NativeLibraryHandle.js';
+import { declarationText, prunedTokens } from './CText.js';
+import { preprocessHeader } from './Preprocessor.js';
+import { TypeScriptTypes } from './TypeScriptTypes.js';
+/**
+ * The tokens that are not names of types or constants
+ */
+const KEYWORDS = new Set(['struct', 'union', 'enum', 'typedef', 'extern', 'static', 'const', 'volatile', 'signed', 'unsigned', 'inline']);
+/**
+ * The names the generated file imports or uses: not names of interfaces
+ */
+const TAKEN = new Set(['Library', 'Native', 'NativeLibrary', 'NativeVariable', 'Pointer', 'Out', 'Buffer', 'ArrayBufferView', 'Array', 'Object', 'Function', 'String', 'Number', 'Date', 'Error', 'Map', 'Set', 'Promise']);
+/**
+ * The options of the configuration of the component of a library: not names of properties
+ */
+const CONFIGURATION = ['path', 'search', 'keepLoaded', 'drainTimeout', 'threads'];
+/**
+ * The names of the members of a NativeLibrary: a function named as one of them gets another property
+ */
+function memberNames() {
+    const names = new Set(CONFIGURATION);
+    for (let prototype = NativeLibrary.prototype; prototype && prototype !== Object.prototype; prototype = Object.getPrototypeOf(prototype)) {
+        for (const name of Object.getOwnPropertyNames(prototype))
+            names.add(name);
+    }
+    return names;
+}
+/**
+ * A path as the paths of the line markers are compared (case-insensitive on Windows)
+ * @param file
+ */
+function comparable(file) {
+    const resolved = path.resolve(file);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+/**
+ * Whether a file is inside a directory
+ * @param file
+ * @param directory
+ */
+function inside(file, directory) {
+    const relative = path.relative(directory, file);
+    return !!relative && !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+/**
+ * Which files are the ones of the library: the header, the headers of its directory when it is not a directory of the
+ * system, the ones of the directories given
+ * @param header
+ * @param systemDirectories
+ * @param own
+ */
+function ownFiles(header, systemDirectories, own) {
+    const main = comparable(header);
+    const system = systemDirectories.map(comparable);
+    const directory = path.dirname(main);
+    const directories = [...system.includes(directory) ? [] : [directory], ...own.map(comparable)];
+    const known = new Map();
+    return (file) => {
+        if (!file || file.startsWith('<'))
+            return false;
+        let result = known.get(file);
+        if (result === undefined) {
+            const candidate = comparable(file);
+            result = candidate === main || directories.some((dir) => inside(candidate, dir) && !system.some((sys) => sys !== dir && inside(candidate, sys) && inside(sys, dir)));
+            known.set(file, result);
+        }
+        return result;
+    };
+}
+/**
+ * The names a declaration uses: of types (\`type x\`, \`struct x\`) and of constants
+ * @param tokens
+ */
+function referencesOf(tokens) {
+    const references = [];
+    tokens.forEach((token, index) => {
+        if (token.kind !== 'identifier' || KEYWORDS.has(token.text))
+            return;
+        const before = tokens[index - 1];
+        if (before?.kind === 'identifier' && (before.text === 'struct' || before.text === 'union' || before.text === 'enum'))
+            references.push(`${before.text} ${token.text}`);
+        else
+            references.push(`type ${token.text}`, `constant ${token.text}`);
+    });
+    return references;
+}
+/**
+ * A name in PascalCase (\`sqlite3\`: \`Sqlite3\`, \`vendor_sdk\`: \`VendorSdk\`)
+ * @param name
+ */
+function pascalCase(name) {
+    const words = name.split(/[^A-Za-z0-9]+/).filter(Boolean);
+    const joined = words.map((word) => word[0].toUpperCase() + word.slice(1)).join('') || 'Library';
+    return /^[0-9]/.test(joined) ? `Library${joined}` : joined;
+}
+/**
+ * The name \`@Library\` gets for a library given as a name or a file: \`libsqlite3.dylib\`, \`libsqlite3.so\`, \`sqlite3.dll\`
+ * give \`sqlite3\` (completed on each platform); a file with a version is kept as it is
+ * @param library
+ */
+function libraryName(library) {
+    const file = path.basename(library);
+    const plain = file.match(/^(?:lib)?(.+?)\.(?:dylib|so|dll)$/i);
+    if (plain && !/\.(?:dylib|so|dll)/i.test(plain[1]))
+        return plain[1];
+    return file;
+}
+/**
+ * A text as the lines of a comment of TypeScript, wrapped at 120 characters
+ * @param text
+ */
+function commentLines(text) {
+    const lines = [];
+    let line = '//';
+    for (const word of text.split(' ')) {
+        if (line.length > 2 && line.length + 1 + word.length > 120) {
+            lines.push(line);
+            line = '//';
+        }
+        line += line.length > 2 ? ` ${word}` : word;
+    }
+    lines.push(line);
+    return lines;
+}
+/**
+ * Text put in a template literal of TypeScript
+ * @param text
+ */
+function templateText(text) {
+    return text.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+/**
+ * The first line of the message of an error
+ * @param error
+ */
+function reasonOf(error) {
+    return (error instanceof Error ? error.message : String(error)).split('\n')[0].replace(/ \(line \d+, column \d+\)$/, '');
+}
+/**
+ * Generate the class of a library from a header already run through the preprocessor (see generateNativeLibrary).
+ * @param preprocessed The output of the preprocessor, the header, the directories of the system.
+ * @param options The library, the class, the directories of the library.
+ * @param platform The platform the header was preprocessed for.
+ * @returns The code of the class and the report.
+ */
+export async function generateFromPreprocessed(preprocessed, options = {}, platform = CURRENT_PLATFORM) {
+    const header = preprocessed.header;
+    const headerName = path.basename(header).replace(/\.[^.]+$/, '');
+    const source = new DeclarationParser(platform).readSource(preprocessed.text);
+    const items = source.items;
+    const isOwn = ownFiles(header, preprocessed.systemDirectories, options.own ?? []);
+    const builtins = builtinTypes(platform);
+    const skipped = [];
+    const where = (item) => ({ ...item.file !== undefined ? { file: item.file } : {}, ...item.line !== undefined ? { line: item.line } : {} });
+    //The declarations of the library, and the ones of the system they use
+    const definers = new Map();
+    items.forEach((item, index) => {
+        if (item.error)
+            return;
+        for (const name of item.names)
+            definers.set(name, [...definers.get(name) ?? [], index]);
+    });
+    const selected = new Set();
+    const queue = [];
+    items.forEach((item, index) => {
+        if (!isOwn(item.file))
+            return;
+        if (item.error) {
+            skipped.push({ name: declarationText(prunedTokens(item.tokens.slice(0, 16)), '').join(' ').slice(0, 80), ...where(item), reason: item.error });
+            return;
+        }
+        if (!item.names.length)
+            return;
+        selected.add(index);
+        queue.push(index);
+    });
+    while (queue.length) {
+        const index = queue.pop();
+        const item = items[index];
+        for (const reference of referencesOf(item.tokens)) {
+            if (item.names.includes(reference))
+                continue;
+            if (reference.startsWith('type ') && builtins.has(reference.slice(5)))
+                continue;
+            //The definition seen at that point: the last one before it
+            const candidates = definers.get(reference) ?? [];
+            const definer = candidates.filter((candidate) => candidate < index).pop() ?? candidates[0];
+            if (definer === undefined || selected.has(definer))
+                continue;
+            //A typedef of the system redefining a type the package knows is not needed
+            if (!isOwn(items[definer].file) && items[definer].names.every((name) => name.startsWith('type ') && builtins.has(name.slice(5))))
+                continue;
+            selected.add(definer);
+            queue.push(definer);
+        }
+    }
+    //The macros of the library whose value is an integer, written with their values
+    const itemConstants = new Set(items.flatMap((item) => [...item.names]).filter((name) => name.startsWith('constant ')).map((name) => name.slice(9)));
+    const macroConstants = [...source.macros]
+        .filter(([name, origin]) => isOwn(origin.file) && source.declarations.constants.has(name) && !itemConstants.has(name))
+        .map(([name]) => [name, source.declarations.constants.get(name)]);
+    //The declarations written again, each one checked: read alone, after the ones before it
+    const checker = new DeclarationParser(platform);
+    const chunks = [];
+    for (const index of [...selected].sort((a, b) => a - b)) {
+        const item = items[index];
+        const body = declarationText(prunedTokens(item.tokens));
+        const lines = item.pack !== undefined && item.names.some((name) => name.startsWith('struct ') || name.startsWith('union ') || name.startsWith('type '))
+            ? [`#pragma pack(push, ${item.pack})`, ...body, '#pragma pack(pop)']
+            : body;
+        try {
+            checker.parse(lines.join('\n'));
+            chunks.push({ index: index, lines: lines });
+        }
+        catch (error) {
+            selected.delete(index);
+            if (isOwn(item.file))
+                skipped.push({ name: item.names.join(', '), ...where(item), reason: `its declaration cannot be read again: ${reasonOf(error)}` });
+        }
+    }
+    const constantLines = macroConstants.map(([name, value]) => `#define ${name} ${value}`);
+    const declarations = [...chunks.flatMap((chunk) => chunk.lines), ...constantLines].join('\n');
+    //The functions and the variables of the library, as the declarations written are read (the types the package knows
+    //replace the ones of the system of the same name: DWORD, LPCWSTR)
+    const emitted = checker.declarations;
+    let functions = [];
+    let variables = [];
+    const prototypes = new Map();
+    for (const chunk of chunks) {
+        const item = items[chunk.index];
+        if (!isOwn(item.file))
+            continue;
+        for (const name of item.names) {
+            if (name.startsWith('function ')) {
+                const fn = emitted.functions.get(name.slice(9));
+                if (fn)
+                    functions.push(fn);
+                prototypes.set(name.slice(9), declarationText(prunedTokens(item.tokens), '').join(' '));
+            }
+            else if (name.startsWith('variable ')) {
+                const variable = emitted.variables.get(name.slice(9));
+                if (variable)
+                    variables.push(variable);
+            }
+        }
+    }
+    const ownConstants = macroConstants.length + chunks.filter((chunk) => isOwn(items[chunk.index].file)).flatMap((chunk) => items[chunk.index].names).filter((name) => name.startsWith('constant ')).length;
+    //Checked against the library: the functions and the variables it cannot give left out
+    let libraryFile;
+    let unchecked;
+    const library = options.library ?? headerName;
+    if (options.check === false) {
+        unchecked = 'not asked';
+    }
+    else {
+        let handle;
+        try {
+            handle = loadNativeLibrary(library, declarations);
+        }
+        catch (error) {
+            unchecked = reasonOf(error).replace(/:$/, '').replace(/^The /, 'the ');
+        }
+        if (handle) {
+            libraryFile = handle.file;
+            const usable = (declared, bind) => declared.filter((declaration) => {
+                try {
+                    bind(declaration.name);
+                    return true;
+                }
+                catch (error) {
+                    skipped.push({ name: declaration.name, reason: reasonOf(error) });
+                    return false;
+                }
+            });
+            functions = usable(functions, (name) => handle.function(name));
+            variables = usable(variables, (name) => handle.variable(name));
+            await handle.close();
+        }
+    }
+    //The interfaces of the structs and unions of the library
+    const records = [];
+    const names = new Map();
+    const used = new Set([...TAKEN]);
+    const className = options.className ?? pascalCase(headerName);
+    used.add(className);
+    const nameRecord = (record, preferred) => {
+        if (names.has(record))
+            return;
+        let name = preferred;
+        while (used.has(name))
+            name = `${name}_`;
+        used.add(name);
+        names.set(record, name);
+        records.push({ name: name, record: record });
+    };
+    for (const chunk of chunks) {
+        const item = items[chunk.index];
+        if (!isOwn(item.file))
+            continue;
+        for (const name of item.names) {
+            const type = name.startsWith('type ') ? emitted.types.get(name.slice(5)) : name.startsWith('struct ') || name.startsWith('union ') ? emitted.tags.get(name) : undefined;
+            if ((type?.kind === 'struct' || type?.kind === 'union') && type.members)
+                nameRecord(type, name.startsWith('type ') ? name.slice(5) : name.split(' ')[1]);
+        }
+    }
+    const types = new TypeScriptTypes(names);
+    //The class: a property by function and variable, named as it (another name when the component has a member of that name)
+    const reserved = memberNames();
+    const property = (name) => {
+        if (!reserved.has(name))
+            return { name: name, argument: '' };
+        let renamed = `${name}_`;
+        while (reserved.has(renamed))
+            renamed = `${renamed}_`;
+        return { name: renamed, argument: `'${name}'` };
+    };
+    const members = [];
+    for (const fn of functions) {
+        const prototype = prototypes.get(fn.name);
+        const { name, argument } = property(fn.name);
+        members.push([...prototype ? [`    //${prototype}`] : [], `    @Native(${argument})`, `    public readonly ${name}: ${types.functionType(fn.type)}`].join('\n'));
+    }
+    for (const variable of variables) {
+        const { name, argument } = property(variable.name);
+        members.push([`    @NativeVariable(${argument})`, `    public readonly ${name}: ${types.type(variable.type, 'received')}`].join('\n'));
+    }
+    const interfaces = records.map(({ name, record }) => [`export interface ${name} {`, ...types.members(record, '    '), '}'].join('\n'));
+    const body = [...interfaces, ...members].join('\n');
+    const imports = ['Library', 'Native', 'NativeLibrary', ...variables.length ? ['NativeVariable'] : [], ...body.includes('Out<') ? ['type Out'] : [], ...body.includes('Pointer') ? ['type Pointer'] : []];
+    const platformName = `${platform.os}-${platform.arch}`;
+    const code = [
+        ...commentLines(`Generated from ${path.basename(header)} by the generator of @lakutata/ffi (lakutata ffi generate), for ${platformName}${libraryFile ? `; checked against ${libraryFile}` : ''}: ${functions.length} functions, ${variables.length} variables, ${ownConstants} constants.`),
+        ...commentLines('The functions are synchronous, and their pointer parameters are inputs: where needed, mark the output parameters _Out_ in the declarations and the functions that block {async: true} (see the guide of @lakutata/ffi). Another build of the library may lack some of these functions: the component then refuses to start, naming the function.'),
+        `import {${imports.join(', ')}} from '@lakutata/ffi'`,
+        '',
+        ...interfaces.flatMap((text) => [text, '']),
+        '@Library({',
+        `    names: ${JSON.stringify(libraryName(library)).replace(/^"|"$/g, '\'')},`,
+        '    declarations: `',
+        ...templateText(declarations).split('\n').map((line) => `        ${line}`),
+        '    `',
+        '})',
+        `export class ${className} extends NativeLibrary {`,
+        members.join('\n\n'),
+        '}',
+        ''
+    ].join('\n');
+    return {
+        className: className,
+        code: code,
+        declarations: declarations,
+        report: {
+            command: preprocessed.command,
+            platform: platformName,
+            ...libraryFile ? { library: libraryFile } : {},
+            ...unchecked ? { unchecked: unchecked } : {},
+            functions: functions.length,
+            variables: variables.length,
+            interfaces: records.length,
+            constants: ownConstants,
+            skipped: skipped
+        }
+    };
+}
+/**
+ * Generate the class of a native library from its header: the header is run through the preprocessor of the C compiler,
+ * its declarations are read, the functions and the variables the library cannot give are left out, and the class gets a
+ * property by function (named as the function) with its TypeScript type.
+ * @param options The header, the library, the class, the compiler and its options.
+ * @returns The code of the class, and what was generated and left out.
+ * @example
+ * ```typescript
+ * import {writeFileSync} from 'node:fs'
+ * import {generateNativeLibrary} from '@lakutata/ffi/generator'
+ *
+ * const {code, report} = await generateNativeLibrary({header: 'vendor/include/vendor.h', library: 'vendor/lib/libvendor.so'})
+ * writeFileSync('src/native/Vendor.ts', code)
+ * for (const skipped of report.skipped) console.log(`${skipped.name}: ${skipped.reason}`)
+ * ```
+ */
+export async function generateNativeLibrary(options) {
+    return await generateFromPreprocessed(preprocessHeader(options), options);
+}

package/dist/esm/lib/generator/Preprocessor.js

@@ -0,0 +1,87 @@
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { devNull, tmpdir } from 'node:os';
+import path from 'node:path';
+import { NativeDeclarationException } from '../../exceptions/NativeDeclarationException.js';
+/**
+ * The C compiler whose preprocessor reads the headers by default: the one of the CC variable, else cl on Windows (run
+ * in the Developer Command Prompt of Visual Studio), cc elsewhere.
+ * @returns The command of the compiler.
+ * @example
+ * ```typescript
+ * import {defaultCompiler} from '@lakutata/ffi/generator'
+ *
+ * console.log(defaultCompiler())
+ * ```
+ */
+export function defaultCompiler() {
+    return process.env.CC?.trim() || (process.platform === 'win32' ? 'cl' : 'cc');
+}
+/**
+ * Whether a compiler takes the options of Microsoft (cl, clang-cl)
+ * @param compiler
+ */
+function microsoft(compiler) {
+    return /^(?:cl|clang-cl)(?:\.exe)?$/i.test(path.basename(compiler));
+}
+/**
+ * Run a compiler: its output, its errors
+ * @param compiler
+ * @param args
+ */
+function run(compiler, args) {
+    const result = spawnSync(compiler, args, { encoding: 'latin1', maxBuffer: 1 << 30, windowsHide: true });
+    if (result.error?.code === 'ENOENT') {
+        throw new NativeDeclarationException(microsoft(compiler)
+            ? `The compiler ${compiler} is not found: run in the Developer Command Prompt (or PowerShell) of Visual Studio, or give another compiler`
+            : `The compiler ${compiler} is not found: install a C compiler (the Command Line Tools of Xcode, gcc, clang), or give another one`);
+    }
+    if (result.error)
+        throw result.error;
+    return { stdout: result.stdout, stderr: result.stderr, status: result.status };
+}
+/**
+ * The directories of the headers of the system of GCC and Clang, as -v lists them (without the ones given by -I)
+ * @param compiler
+ */
+function systemDirectoriesOf(compiler) {
+    const { stdout, stderr } = run(compiler, ['-E', '-v', '-x', 'c', devNull]);
+    const lines = `${stdout}\n${stderr}`.split(/\r?\n/);
+    const start = lines.findIndex((line) => line.startsWith('#include <...> search starts here'));
+    const end = lines.findIndex((line, index) => index > start && line.startsWith('End of search list'));
+    if (start < 0 || end < 0)
+        return [];
+    return lines.slice(start + 1, end).map((line) => path.resolve(line.replace(/\(framework directory\)$/, '').trim()));
+}
+/**
+ * Run a header through the preprocessor of a compiler, keeping its #define and the line markers naming the files.
+ * @param options The header, the compiler, the directories and the macros.
+ * @returns The output, the header as the line markers name it, the directories of the system.
+ */
+export function preprocessHeader(options) {
+    const header = path.resolve(options.header);
+    const compiler = options.compiler ?? defaultCompiler();
+    const include = (options.include ?? []).map((directory) => path.resolve(directory));
+    const define = options.define ?? [];
+    if (microsoft(compiler)) {
+        //cl /P writes a file; /d1PP keeps the #define in it
+        const directory = mkdtempSync(path.join(tmpdir(), 'lakutata-ffi-preprocess-'));
+        const output = path.join(directory, 'header.i');
+        const args = ['/nologo', '/P', '/TC', '/d1PP', `/Fi${output}`, ...include.map((dir) => `/I${dir}`), ...define.map((macro) => `/D${macro}`), header];
+        try {
+            const { stderr, status } = run(compiler, args);
+            if (status !== 0)
+                throw new NativeDeclarationException(`The preprocessor failed (${compiler} ${args.join(' ')}): ${stderr.trim()}`);
+            const systemDirectories = (process.env.INCLUDE ?? '').split(';').filter(Boolean).map((dir) => path.resolve(dir));
+            return { text: readFileSync(output, 'latin1'), header: header, systemDirectories: systemDirectories, command: [compiler, ...args.filter((arg) => !arg.startsWith('/Fi'))].join(' ') };
+        }
+        finally {
+            rmSync(directory, { recursive: true, force: true });
+        }
+    }
+    const args = ['-E', '-dD', '-x', 'c', ...include.map((dir) => `-I${dir}`), ...define.map((macro) => `-D${macro}`), header];
+    const { stdout, stderr, status } = run(compiler, args);
+    if (status !== 0)
+        throw new NativeDeclarationException(`The preprocessor failed (${compiler} ${args.join(' ')}): ${stderr.trim()}`);
+    return { text: stdout, header: header, systemDirectories: systemDirectoriesOf(compiler), command: [compiler, ...args].join(' ') };
+}

package/dist/esm/lib/generator/TypeScriptTypes.js

@@ -0,0 +1,149 @@
+import { primitiveBig } from '../declarations/Types.js';
+/**
+ * The words TypeScript reserves: not names of parameters
+ */
+const RESERVED = new Set([
+    'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false',
+    'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super', 'switch', 'this', 'throw', 'true', 'try',
+    'typeof', 'var', 'void', 'while', 'with', 'as', 'implements', 'interface', 'let', 'package', 'private', 'protected', 'public', 'static',
+    'yield', 'await', 'arguments', 'eval'
+]);
+/**
+ * The typed arrays of the arrays of numbers of the structs
+ */
+const TYPED_ARRAYS = {
+    schar: 'Int8Array', int8: 'Int8Array', uchar: 'Uint8Array', uint8: 'Uint8Array', short: 'Int16Array', int16: 'Int16Array',
+    ushort: 'Uint16Array', uint16: 'Uint16Array', char16: 'Uint16Array', int: 'Int32Array', int32: 'Int32Array', uint: 'Uint32Array',
+    uint32: 'Uint32Array', char32: 'Uint32Array', float: 'Float32Array', double: 'Float64Array'
+};
+/**
+ * The name of a parameter in TypeScript: its C name, not a reserved word, not one of the others
+ * @param parameter
+ * @param index
+ * @param taken
+ */
+function parameterName(parameter, index, taken) {
+    let name = parameter.name ?? `arg${index}`;
+    if (RESERVED.has(name))
+        name = `${name}_`;
+    while (taken.has(name))
+        name = `${name}_`;
+    taken.add(name);
+    return name;
+}
+/**
+ * The TypeScript types of C types, as the package converts their values
+ */
+export class TypeScriptTypes {
+    #names;
+    /**
+     * Types for the declarations of a library.
+     * @param names The TypeScript names of its structs and unions.
+     */
+    constructor(names) {
+        this.#names = names;
+    }
+    /**
+     * The TypeScript type of a value of a C type.
+     * @param type The C type.
+     * @param flow Whether the value is given to the native code or received from it.
+     */
+    type(type, flow) {
+        switch (type.kind) {
+            case 'primitive':
+                return this.#primitive(type.name, flow);
+            case 'enum':
+                return this.#primitive(type.base, flow);
+            case 'pointer':
+                return this.#pointer(type.to, type.constTarget, flow);
+            case 'array':
+                return this.#array(type.of);
+            case 'struct':
+            case 'union':
+                return this.#names.get(type) ?? this.#inline(type);
+            case 'function':
+                return this.#pointer(type, false, flow);
+        }
+    }
+    /**
+     * The TypeScript type of a function: of a native function, or of a JS callback the native code calls.
+     * @param type The function type.
+     * @param callback Whether it is a JS callback (its arguments received, its result given).
+     */
+    functionType(type, callback = false) {
+        const taken = new Set();
+        const parameters = type.parameters.map((parameter, index) => {
+            return `${parameterName(parameter, index, taken)}: ${callback ? this.type(parameter.type, 'received') : this.#parameter(parameter)}`;
+        });
+        if (type.variadic)
+            parameters.push('...args: unknown[]');
+        return `(${parameters.join(', ')}) => ${this.type(type.result, callback ? 'given' : 'received')}`;
+    }
+    /**
+     * The members of a struct or a union, as the lines of an interface (or of an object type).
+     * @param record The struct or the union.
+     * @param indent The indentation of the lines.
+     */
+    members(record, indent) {
+        return (record.members ?? []).map((member) => `${indent}${member.name}: ${this.type(member.type, 'received')}`);
+    }
+    /**
+     * A parameter of a native function: an output parameter as the array or the object filled
+     * @param parameter
+     */
+    #parameter(parameter) {
+        if (parameter.direction !== 'in' && parameter.type.kind === 'pointer') {
+            const to = parameter.type.to;
+            if ((to.kind === 'struct' || to.kind === 'union') && to.members)
+                return this.type(to, 'received');
+            return `Out<${this.type(to, 'received')}>`;
+        }
+        return this.type(parameter.type, 'given');
+    }
+    #primitive(name, flow) {
+        if (name === 'void')
+            return 'void';
+        if (name === 'bool')
+            return 'boolean';
+        if (primitiveBig(name))
+            return flow === 'given' ? 'bigint | number' : 'bigint';
+        return 'number';
+    }
+    #pointer(to, constTarget, flow) {
+        //The strings: char, char16_t, wchar_t
+        if (to.kind === 'primitive' && (to.name === 'char' || to.name === 'char16' || to.name === 'wchar')) {
+            return flow === 'given' && !constTarget ? 'string | Buffer | null' : 'string | null';
+        }
+        if (to.kind === 'function' && flow === 'given')
+            return `(${this.functionType(to, true)}) | Pointer | null`;
+        if (flow !== 'given' || to.kind === 'function')
+            return 'Pointer | null';
+        //A struct or a union given to the function: its object too
+        if ((to.kind === 'struct' || to.kind === 'union') && to.members)
+            return `${this.type(to, 'received')} | Pointer | Buffer | ArrayBufferView | null`;
+        return 'Pointer | Buffer | ArrayBufferView | null';
+    }
+    #array(of) {
+        if (of.kind === 'primitive' || of.kind === 'enum') {
+            const name = of.kind === 'enum' ? of.base : of.name;
+            if (name === 'char' || name === 'wchar')
+                return 'string';
+            if (primitiveBig(name))
+                return 'bigint[]';
+            if (name === 'bool')
+                return 'boolean[]';
+            return TYPED_ARRAYS[name] ?? 'number[]';
+        }
+        const element = this.type(of, 'received');
+        return /^[\w.]+$/.test(element) ? `${element}[]` : `Array<${element}>`;
+    }
+    /**
+     * A struct or a union without a name (an anonymous member): an object type
+     * @param record
+     */
+    #inline(record) {
+        if (!record.members)
+            return 'Pointer';
+        return `{${record.members.map((member) => `${member.name}: ${this.type(member.type, 'received')}`).join(', ')}}`;
+    }
+}