@lakutata/ffi 0.0.0-stage → 3.1.5

package/dist/types/lib/Memory.d.ts

@@ -0,0 +1,188 @@
+import { type Pointer } from './Runtime.js';
+/**
+ * An output parameter of a pointer or an integer: an array of one element, null before the call, set by the function
+ * (`[null]` given to `_Out_ sqlite3 **db`, then `db[0]`)
+ */
+export type Out<T> = [T | null];
+/**
+ * Read a C string (UTF-8, ended by a NUL byte) from native memory: a `char *` given as a pointer (a `void *` result, an
+ * argument of a callback, a member of a struct).
+ * @param pointer Its address.
+ * @param length Its length in bytes, when it is not ended by a NUL byte.
+ * @returns The string.
+ * @example
+ * ```typescript
+ * import {readCString, type Pointer} from '@lakutata/ffi'
+ *
+ * export function messageOf(pointer: Pointer): string {
+ *     return readCString(pointer)
+ * }
+ * ```
+ */
+export declare function readCString(pointer: Pointer, length?: number): string;
+/**
+ * Read a wide string from native memory: a `wchar_t *` (UTF-16 on Windows, UTF-32 elsewhere), ended by a NUL character.
+ * @param pointer Its address.
+ * @param length Its length in characters, when it is not ended by a NUL character.
+ * @returns The string.
+ * @example
+ * ```typescript
+ * import {readWString, type Pointer} from '@lakutata/ffi'
+ *
+ * export function titleOf(pointer: Pointer): string {
+ *     return readWString(pointer)
+ * }
+ * ```
+ */
+export declare function readWString(pointer: Pointer, length?: number): string;
+/**
+ * Copy native memory into a buffer of its own, which stays valid once the native memory is freed (about 10 GB/s).
+ * @param pointer The address of the memory.
+ * @param length Its length in bytes.
+ * @returns The copy.
+ * @example
+ * ```typescript
+ * import {readBuffer, type Pointer} from '@lakutata/ffi'
+ *
+ * export function frameOf(pixels: Pointer, width: number, height: number): Buffer {
+ *     return readBuffer(pixels, width * height * 4)
+ * }
+ * ```
+ */
+export declare function readBuffer(pointer: Pointer, length: number): Buffer;
+/**
+ * A view of native memory, without copy: worth it for large blocks read often (8 MiB: about 0.13 ms rather than 1 ms
+ * for a copy). The view must not be used once the native memory is freed: the process would crash. Electron forbids
+ * these views: it throws there (use readBuffer).
+ * @param pointer The address of the memory.
+ * @param length Its length in bytes.
+ * @returns The memory, as an ArrayBuffer.
+ * @throws {NativeMemoryException} In Electron, or for a null pointer.
+ * @example
+ * ```typescript
+ * import {viewBuffer, type Pointer} from '@lakutata/ffi'
+ *
+ * export function firstPixel(pixels: Pointer): number {
+ *     return new Uint32Array(viewBuffer(pixels, 4))[0]
+ * }
+ * ```
+ */
+export declare function viewBuffer(pointer: Pointer, length: number): ArrayBuffer;
+/**
+ * Read a value of a built-in type from native memory (`int`, `double`, `uint64_t`, `char *`…): the 64-bit integers as
+ * bigints. The types of a library are read by `read()` of the library.
+ * @param pointer Its address.
+ * @param type Its type.
+ * @returns The value.
+ * @example
+ * ```typescript
+ * import {readValue, type Pointer} from '@lakutata/ffi'
+ *
+ * export function countAt(pointer: Pointer): number {
+ *     return readValue(pointer, 'int32_t') as number
+ * }
+ * ```
+ */
+export declare function readValue(pointer: Pointer, type: string): unknown;
+/**
+ * Read an array of values of a built-in type from native memory.
+ * @param pointer The address of its first element.
+ * @param type The type of its elements (`char *` reads strings).
+ * @param count Its length.
+ * @returns The values.
+ * @example
+ * ```typescript
+ * import {readArray, type Pointer} from '@lakutata/ffi'
+ *
+ * //The row of a callback of sqlite3_exec: char **values
+ * export function rowOf(values: Pointer, count: number): string[] {
+ *     return readArray(values, 'char *', count) as string[]
+ * }
+ * ```
+ */
+export declare function readArray(pointer: Pointer, type: string, count: number): unknown[];
+/**
+ * Write a value of a built-in type to native memory.
+ * @param pointer Its address.
+ * @param type Its type.
+ * @param value The value.
+ * @example
+ * ```typescript
+ * import {allocMemory, freeMemory, readValue, writeValue} from '@lakutata/ffi'
+ *
+ * const counter: bigint = allocMemory('int64_t')
+ * writeValue(counter, 'int64_t', 42n)
+ * console.log(readValue(counter, 'int64_t'))
+ * freeMemory(counter)
+ * ```
+ */
+export declare function writeValue(pointer: Pointer, type: string, value: unknown): void;
+/**
+ * Allocate native memory for values of a built-in type: memory that does not move, which a library can keep (a buffer
+ * given to a function is valid during the call only). Freed by freeMemory.
+ * @param type The type of the values.
+ * @param count Their number.
+ * @returns Its address.
+ * @example
+ * ```typescript
+ * import {allocMemory, freeMemory} from '@lakutata/ffi'
+ *
+ * const buffer: bigint = allocMemory('uint8_t', 4096)
+ * freeMemory(buffer)
+ * ```
+ */
+export declare function allocMemory(type: string, count?: number): Pointer;
+/**
+ * Free native memory allocated by allocMemory.
+ * @param pointer Its address.
+ * @example
+ * ```typescript
+ * import {allocMemory, freeMemory} from '@lakutata/ffi'
+ *
+ * freeMemory(allocMemory('double', 16))
+ * ```
+ */
+export declare function freeMemory(pointer: Pointer): void;
+/**
+ * The size of a built-in type on the platform, in bytes (`long` is 8 on 64-bit Linux and macOS, 4 on Windows).
+ * @param type The type.
+ * @returns Its size.
+ * @example
+ * ```typescript
+ * import {sizeOf} from '@lakutata/ffi'
+ *
+ * console.log(sizeOf('long'), sizeOf('wchar_t'), sizeOf('void *'))
+ * ```
+ */
+export declare function sizeOf(type: string): number;
+/**
+ * The errno of the last native call of the thread. On Windows, each C library has its own errno: the one of the C
+ * library of Microsoft (ucrtbase.dll) by default.
+ * @param crt On Windows, the C library the function called uses (`msvcrt.dll` for the old libraries).
+ * @returns The errno.
+ * @example
+ * ```typescript
+ * import {lastErrno, loadNativeLibrary} from '@lakutata/ffi'
+ *
+ * const libc = loadNativeLibrary('c')
+ * const open = libc.func<(path: string, flags: number) => number>('int open(const char *path, int flags, ...)')
+ * if (open('/surely/missing', 0) < 0) console.log('errno', lastErrno())
+ * ```
+ */
+export declare function lastErrno(crt?: string): number;
+/**
+ * The last error of the Windows API of the thread (GetLastError), kept after each native call; undefined on the other
+ * systems.
+ * @returns The error.
+ * @example
+ * ```typescript
+ * import {lastWindowsError, loadNativeLibrary} from '@lakutata/ffi'
+ *
+ * if (process.platform === 'win32') {
+ *     const kernel32 = loadNativeLibrary('kernel32.dll')
+ *     const attributes = kernel32.func<(path: string) => number>('DWORD WINAPI GetFileAttributesW(LPCWSTR path)')
+ *     if (attributes('C:\\missing') === 0xFFFFFFFF) console.log('error', lastWindowsError())
+ * }
+ * ```
+ */
+export declare function lastWindowsError(): number | undefined;

package/dist/types/lib/Runtime.d.ts

@@ -0,0 +1,98 @@
+import { type KoffiType, KoffiTypes } from './backend/KoffiTypes.js';
+import { DeclarationParser } from './declarations/Parser.js';
+import type { CType } from './declarations/Types.js';
+/**
+ * The koffi types of the process: one per C type, whatever library declares it
+ */
+export declare const TYPES: KoffiTypes;
+/**
+ * A pointer to native memory: a bigint (its address), null for NULL
+ */
+export type Pointer = bigint;
+/**
+ * The C types read from their names, with the declarations of a library or the built-in types only
+ */
+export declare class TypeNames {
+    #private;
+    /**
+     * The type names of a library.
+     * @param parser Its declarations.
+     */
+    constructor(parser: DeclarationParser);
+    /**
+     * A type, from its name.
+     * @param text Its name: `int`, `struct timeval`, `const char *`.
+     */
+    type(text: string): CType;
+    /**
+     * The koffi type of a type name.
+     * @param text Its name.
+     */
+    koffi(text: string): KoffiType;
+}
+/**
+ * The type names of the built-in types (of no library)
+ */
+export declare const BUILTIN_TYPES: TypeNames;
+/**
+ * A pointer checked: not null, a bigint or a number
+ * @param pointer
+ * @param what
+ */
+export declare function checkedPointer(pointer: unknown, what: string): Pointer;
+/**
+ * A copy of native memory, in a buffer of its own.
+ * @param pointer The address of the memory.
+ * @param length Its length in bytes.
+ */
+export declare function copyBuffer(pointer: Pointer, length: number): Buffer;
+/**
+ * A view of native memory, without copy: refused in Electron, which forbids them (koffi would end the process).
+ * @param pointer The address of the memory.
+ * @param length Its length in bytes.
+ */
+export declare function nativeView(pointer: Pointer, length: number): ArrayBuffer;
+/**
+ * A value read from native memory, converted as the package gives values (64-bit integers as bigints).
+ * @param names The type names to read the type with.
+ * @param pointer The address.
+ * @param type The type name.
+ * @param count The number of values, for an array.
+ */
+export declare function readNative(names: TypeNames, pointer: Pointer, type: string, count?: number): unknown;
+/**
+ * A value written to native memory.
+ * @param names The type names to read the type with.
+ * @param pointer The address.
+ * @param type The type name.
+ * @param value The value.
+ */
+export declare function writeNative(names: TypeNames, pointer: Pointer, type: string, value: unknown): void;
+/**
+ * Native memory allocated for values of a type (C's malloc: freed by freeNative).
+ * @param names The type names to read the type with.
+ * @param type The type name.
+ * @param count The number of values.
+ */
+export declare function allocateNative(names: TypeNames, type: string, count?: number): Pointer;
+/**
+ * Free native memory allocated by allocateNative (or by the malloc of the C library the package is built with).
+ * @param pointer The address.
+ */
+export declare function freeNative(pointer: Pointer): void;
+/**
+ * The errno of the last call made by the thread: on Windows, the one of the C library of Microsoft (ucrtbase.dll), each
+ * C library having its own; elsewhere the one koffi keeps after each call.
+ * @param crt On Windows, the C library the function called uses.
+ */
+export declare function nativeErrno(crt?: string): number;
+/**
+ * The last error of the Windows API of the thread (GetLastError), kept by koffi after each call; undefined elsewhere.
+ */
+export declare function nativeWindowsError(): number | undefined;
+/**
+ * The size of a type on the platform, by its name.
+ * @param names The type names.
+ * @param type The type name.
+ */
+export declare function typeSize(names: TypeNames, type: string): number;

package/dist/types/lib/backend/Functions.d.ts

@@ -0,0 +1,65 @@
+import { type LibraryHandle } from 'koffi';
+import { type FunctionDeclaration, type FunctionType } from '../declarations/Types.js';
+import { type KoffiType, type KoffiTypes } from './KoffiTypes.js';
+/**
+ * How a function is bound
+ */
+export interface BindOptions {
+    /**
+     * Whether it runs in a thread of the pool, returning a promise
+     */
+    readonly async?: boolean;
+    /**
+     * Frees the strings it gives (its result, its output strings) once read
+     */
+    readonly free?: (pointer: unknown) => void;
+    /**
+     * Its 64-bit integers (its result, its output integers) as numbers rather than bigints: a RangeError when one is not
+     * a safe integer
+     */
+    readonly int64?: 'bigint' | 'number';
+    /**
+     * The asynchronous calls of the library: counted, refused once it is closed
+     */
+    readonly calls?: CallTracker;
+}
+/**
+ * Counts the asynchronous calls of a library
+ */
+export interface CallTracker {
+    /**
+     * Before a call: throws once the library is closed
+     */
+    start(): void;
+    /**
+     * Once a call has returned
+     */
+    end(): void;
+}
+/**
+ * The koffi types of the extra arguments of a variadic function, by the C type names given before them
+ */
+export type VariadicTypes = (text: string) => KoffiType;
+/**
+ * A 64-bit integer as a number, when it is a safe one
+ * @param value
+ */
+export declare function toSafeNumber(value: unknown): unknown;
+/**
+ * A JS function given as a callback, its arguments and its result converted when its prototype has 64-bit integers or
+ * structs with bitfields; the same function otherwise
+ * @param type
+ * @param types
+ * @param callback
+ */
+export declare function convertedCallback(type: FunctionType, types: KoffiTypes, callback: (...args: any[]) => any): (...args: any[]) => any;
+/**
+ * A function of a library, bound by its declaration: the function of koffi itself when nothing has to be converted,
+ * else a function converting its arguments and its result; a function returning a promise when asynchronous
+ * @param library
+ * @param declaration
+ * @param types
+ * @param variadicTypes
+ * @param options
+ */
+export declare function bindFunction(library: LibraryHandle, declaration: FunctionDeclaration, types: KoffiTypes, variadicTypes: VariadicTypes, options?: BindOptions): (...args: any[]) => any;

package/dist/types/lib/backend/KoffiTypes.d.ts

@@ -0,0 +1,53 @@
+import koffi, { type TypeObject } from 'koffi';
+import type { Platform } from '../declarations/Platform.js';
+import { type CType, type FunctionType } from '../declarations/Types.js';
+/**
+ * A type as koffi takes it: its name, its object, or its object with a direction (an output parameter)
+ */
+export type KoffiType = string | TypeObject | ReturnType<typeof koffi.out>;
+/**
+ * How a value goes between the user and koffi, when koffi does not give or take it as the package does: the 64-bit
+ * integers always bigints, the bitfields of a struct read and written by their names
+ */
+export interface Converter {
+    /**
+     * A value of the user to the value koffi takes
+     */
+    readonly toNative?: (value: any) => any;
+    /**
+     * A value koffi gives to the value of the user
+     */
+    readonly fromNative?: (value: any) => any;
+}
+/**
+ * A value of a 64-bit integer type, as a bigint
+ * @param value
+ */
+export declare function toBigInt(value: unknown): unknown;
+/**
+ * The koffi types of the C types of the declarations, made once each (koffi never frees a type): anonymous, so the
+ * types of two libraries never meet; the structs koffi cannot lay out (bitfields, packing) laid out by the package
+ */
+export declare class KoffiTypes {
+    #private;
+    /**
+     * The koffi types of a platform.
+     * @param platform The platform of the process.
+     */
+    constructor(platform: Platform);
+    /**
+     * The koffi type of a C type, as a value: a member, a result, a parameter without direction.
+     * @param type The C type.
+     */
+    type(type: CType): KoffiType;
+    /**
+     * The koffi prototype of a function type: the type of its callbacks.
+     * @param type The function type.
+     */
+    prototype(type: FunctionType): TypeObject;
+    /**
+     * The converter of a C type, null when koffi gives and takes its values as the package does.
+     * @param type The C type.
+     */
+    converter(type: CType): Converter | null;
+}

package/dist/types/lib/declarations/Builtins.d.ts

@@ -0,0 +1,33 @@
+import type { Platform } from './Platform.js';
+import type { CallingConvention, CType, Direction } from './Types.js';
+/**
+ * The types every declaration knows without declaring them: the ones of stdint.h and stddef.h, the ones of POSIX with
+ * their size on the platform, the ones of the Windows API (the same on every platform: DWORD is 32-bit everywhere).
+ * A declaration of the same name replaces them
+ * @param platform
+ */
+export declare function builtinTypes(platform: Platform): Map<string, CType>;
+/**
+ * The words naming a calling convention: the keywords of the compilers, the macros of the Windows API
+ */
+export declare const CONVENTIONS: ReadonlyMap<string, CallingConvention>;
+/**
+ * The words read and ignored where qualifiers go: the qualifiers that do not change how a value is passed, the macros of
+ * the Windows API that are empty
+ */
+export declare const IGNORED: ReadonlySet<string>;
+/**
+ * The words read as const
+ */
+export declare const CONSTS: ReadonlySet<string>;
+/**
+ * The words of inline functions, whose bodies are skipped
+ */
+export declare const INLINES: ReadonlySet<string>;
+/**
+ * The direction an annotation gives a parameter, if it is one: the ones of Microsoft (_Out_, _Inout_opt_,
+ * _Outptr_result_maybenull_…) and the macros IN and OUT of the Windows API; null for an annotation that gives none,
+ * undefined for a word that is not an annotation
+ * @param word
+ */
+export declare function annotationDirection(word: string): Direction | null | undefined;

package/dist/types/lib/declarations/Layout.d.ts

@@ -0,0 +1,41 @@
+import type { Platform } from './Platform.js';
+import { type CType, type Member, type RecordType } from './Types.js';
+/**
+ * Where a member of a struct is: its offset in bytes; for a bitfield, its first bit (from the start of the struct, the
+ * lowest bits first) and its width
+ */
+export interface MemberLayout {
+    readonly member: Member;
+    readonly offset: number;
+    readonly size: number;
+    readonly bitOffset?: number;
+    readonly bits?: number;
+}
+export interface RecordLayout {
+    readonly size: number;
+    readonly alignment: number;
+    readonly members: readonly MemberLayout[];
+    /**
+     * Whether it has bitfields (koffi does not lay them out: the package does)
+     */
+    readonly bitfields: boolean;
+}
+/**
+ * The size of a type, in bytes
+ * @param type
+ * @param platform
+ */
+export declare function sizeOf(type: CType, platform: Platform): number;
+/**
+ * The alignment of a type, in bytes
+ * @param type
+ * @param platform
+ */
+export declare function alignmentOf(type: CType, platform: Platform): number;
+/**
+ * The layout of a struct or of a union, as the compilers of the platform lay it out (GCC and Clang, or Microsoft's for
+ * the bitfields): the alignment of each member capped by #pragma pack, raised by its aligned attribute
+ * @param record
+ * @param platform
+ */
+export declare function layoutOf(record: RecordType, platform: Platform): RecordLayout;

package/dist/types/lib/declarations/Lexer.d.ts

@@ -0,0 +1,40 @@
+import { NativeDeclarationException } from '../../exceptions/NativeDeclarationException.js';
+export type TokenKind = 'identifier' | 'number' | 'char' | 'string' | 'punctuator' | 'pragma' | 'define' | 'undef' | 'end';
+export interface Token {
+    readonly kind: TokenKind;
+    readonly text: string;
+    /**
+     * The value of an integer or of a character
+     */
+    readonly value?: bigint;
+    /**
+     * Whether a number is a floating-point one
+     */
+    readonly float?: boolean;
+    readonly line: number;
+    readonly column: number;
+    /**
+     * In a preprocessed text, the file it comes from and its line there (from the line markers)
+     */
+    readonly file?: string;
+    readonly fileLine?: number;
+    /**
+     * The text of a string as written, its quotes and escapes included
+     */
+    readonly source?: string;
+}
+/**
+ * The exception of a declaration that cannot be read, at a line and a column
+ * @param message
+ * @param line
+ * @param column
+ */
+export declare function declarationError(message: string, line: number, column: number): NativeDeclarationException;
+/**
+ * The tokens of C declarations. Comments are skipped; of the directives of the preprocessor, #pragma pack, #define and
+ * #undef are kept (as tokens holding the rest of their line), #include and the other #pragma are skipped, and the
+ * conditional ones (#if, #ifdef…) are refused: what they select is the work of a preprocessor. The line markers of a
+ * preprocessed text give each token the file and the line it comes from
+ * @param text
+ */
+export declare function tokenize(text: string): Token[];

package/dist/types/lib/declarations/Parser.d.ts

@@ -0,0 +1,90 @@
+import { type Token } from './Lexer.js';
+import type { Platform } from './Platform.js';
+import { type CType, type Declarations, type FunctionDeclaration } from './Types.js';
+/**
+ * A declaration of a preprocessed header, as readSource reads it (for the generator of libraries)
+ */
+export interface SourceDeclaration {
+    /**
+     * The file it comes from, and its line there (from the line markers of the preprocessor)
+     */
+    readonly file?: string;
+    readonly line?: number;
+    /**
+     * Its tokens, the macros expanded
+     */
+    readonly tokens: readonly Token[];
+    /**
+     * What it declares: `type name`, `struct tag`, `union tag`, `enum tag` (defined, not only named), `function name`,
+     * `variable name`, `constant name`
+     */
+    readonly names: readonly string[];
+    /**
+     * The packing of #pragma pack it was read with
+     */
+    readonly pack?: number;
+    /**
+     * Why it could not be read
+     */
+    readonly error?: string;
+}
+/**
+ * Where a macro is defined, in a preprocessed header
+ */
+export interface MacroOrigin {
+    readonly file?: string;
+    readonly line?: number;
+}
+/**
+ * A preprocessed header read by readSource: its declarations, each one as it is written, and where its macros are
+ */
+export interface SourceDeclarations {
+    readonly declarations: Declarations;
+    readonly items: readonly SourceDeclaration[];
+    readonly macros: ReadonlyMap<string, MacroOrigin>;
+}
+/**
+ * Reads C declarations: typedefs, structs, unions, enums, function prototypes and variables, for one platform. Each
+ * library has its own declarations: their names do not meet the ones of another library
+ */
+export declare class DeclarationParser {
+    #private;
+    /**
+     * Read declarations for a platform.
+     * @param platform The platform: the sizes of the types and the layout of the structs depend on it.
+     * @param declarations Declarations already read, added to (the ones of the library, when a prototype is read).
+     */
+    constructor(platform: Platform, declarations?: Declarations);
+    /**
+     * The declarations read so far.
+     */
+    get declarations(): Declarations;
+    /**
+     * Read a text of declarations, adding what it declares.
+     * @param text The declarations, as a header writes them (preprocessed or not: #pragma pack is read, #define and
+     * #include are skipped, #if and its kind are refused).
+     */
+    parse(text: string): Declarations;
+    /**
+     * Read a preprocessed header for the generator of libraries: each declaration kept with the file it comes from and
+     * what it declares; one that cannot be read is skipped, its error kept, and the next ones are read.
+     * @param text The output of the preprocessor (`cc -E -dD`, `cl /P`): its line markers give the files.
+     * @returns The declarations, each declaration as it is written, and where the macros are defined.
+     */
+    readSource(text: string): SourceDeclarations;
+    /**
+     * Read the prototype of one function (a trailing semicolon is optional).
+     * @param text The prototype: `int sqlite3_open(const char *filename, _Out_ sqlite3 **db)`.
+     */
+    prototype(text: string): FunctionDeclaration;
+    /**
+     * Read a type name: `struct timeval`, `const char *`, `int[4]`.
+     * @param text The type.
+     */
+    typeName(text: string): CType;
+    /**
+     * The value of a constant expression of the declarations (`SQLITE_OK + 1`, `1 << 4`).
+     * @param text The expression.
+     */
+    constant(text: string): bigint;
+}

package/dist/types/lib/declarations/Platform.d.ts

@@ -0,0 +1,50 @@
+/**
+ * What the sizes of the C types and the layout of the structs depend on
+ */
+export interface Platform {
+    /**
+     * The operating system, as process.platform names it
+     */
+    readonly os: string;
+    /**
+     * The architecture, as process.arch names it
+     */
+    readonly arch: string;
+    /**
+     * The size of a pointer (and of size_t), in bytes
+     */
+    readonly pointerSize: 4 | 8;
+    /**
+     * The size of long: 8 on 64-bit Unix systems (LP64), 4 on Windows (LLP64) and on 32-bit systems
+     */
+    readonly longSize: 4 | 8;
+    /**
+     * The size of wchar_t: 2 on Windows, 4 elsewhere
+     */
+    readonly wcharSize: 2 | 4;
+    /**
+     * The alignment of the 8-byte types (long long, double) as members: 4 on 32-bit Linux (i386), 8 elsewhere
+     */
+    readonly int64Alignment: 4 | 8;
+    /**
+     * How bitfields are laid out: by the rules of GCC and Clang (sysv), of the ARM procedure call standard where the
+     * type of every bitfield aligns the struct, the unnamed and the empty ones too (aapcs: ARM but on Apple systems), or
+     * of the compiler of Microsoft (msvc)
+     */
+    readonly bitfields: 'sysv' | 'aapcs' | 'msvc';
+    /**
+     * Whether the symbols of the C functions start with an underscore in the binaries (macOS): the labels of __asm
+     * name them so
+     */
+    readonly underscoredSymbols: boolean;
+}
+/**
+ * The platform of a system and an architecture
+ * @param os
+ * @param arch
+ */
+export declare function platformOf(os: string, arch: string): Platform;
+/**
+ * The platform the process runs on
+ */
+export declare const CURRENT_PLATFORM: Platform;