@overdeck/desktop 0.50.0 → 0.50.3

package/server/node_modules/@types/node/stream/iter.d.ts

@@ -1,452 +0,0 @@
-declare module "node:stream/iter" {
-    import { Abortable } from "node:events";
-    import { Readable, Writable } from "node:stream";
-    // Symbols and custom typedefs
-    const broadcastProtocol: unique symbol;
-    const drainableProtocol: unique symbol;
-    const shareProtocol: unique symbol;
-    const shareSyncProtocol: unique symbol;
-    const toAsyncStreamable: unique symbol;
-    const toStreamable: unique symbol;
-    type Source =
-        | string
-        | ArrayBufferLike
-        | ArrayBufferView
-        | Iterable<SyncSource>
-        | AsyncIterable<Source>
-        | Streamable
-        | AsyncStreamable;
-    type SyncSource = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncSource> | Streamable;
-    type Transform = StatelessTransformFn | StatefulTransform;
-    type SyncTransform = SyncStatelessTransformFn | SyncStatefulTransform;
-    type TransformResult =
-        | string
-        | ArrayBufferLike
-        | ArrayBufferView
-        | Iterable<SyncTransformResult>
-        | AsyncIterable<TransformResult>;
-    type SyncTransformResult = string | ArrayBufferLike | ArrayBufferView | Iterable<SyncTransformResult>;
-    interface AsyncStreamable {
-        [toAsyncStreamable](): Source;
-    }
-    interface Broadcastable {
-        [broadcastProtocol](options: BroadcastOptions): Broadcast;
-    }
-    interface Drainable {
-        [drainableProtocol](): Promise<boolean> | null;
-    }
-    interface Shareable {
-        [shareProtocol](options: ShareOptions): Share;
-    }
-    interface Streamable {
-        [toStreamable](): SyncSource;
-    }
-    interface SyncShareable {
-        [shareSyncProtocol](options: ShareSyncOptions): SyncShare;
-    }
-    // IDL dictionaries, enums, typedefs
-    type BackpressurePolicy = "strict" | "block" | "drop-oldest" | "drop-newest";
-    type ByteReadableStream = AsyncIterable<Uint8Array[]>;
-    type SyncByteReadableStream = Iterable<Uint8Array[]>;
-    interface WriteOptions {
-        signal?: AbortSignal;
-    }
-    interface PushStreamOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-        signal?: AbortSignal;
-    }
-    interface PullOptions {
-        signal?: AbortSignal;
-    }
-    interface PipeToOptions {
-        signal?: AbortSignal;
-        preventClose?: boolean;
-        preventFail?: boolean;
-    }
-    interface PipeToSyncOptions {
-        preventClose?: boolean;
-        preventFail?: boolean;
-    }
-    interface ConsumeOptions {
-        signal?: AbortSignal;
-        limit?: number;
-    }
-    interface ConsumeSyncOptions {
-        limit?: number;
-    }
-    interface TextConsumeOptions extends ConsumeOptions {
-        encoding?: string;
-    }
-    interface TextConsumeSyncOptions extends ConsumeSyncOptions {
-        encoding?: string;
-    }
-    interface MergeOptions {
-        signal?: AbortSignal;
-    }
-    interface BroadcastOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-        signal?: AbortSignal;
-    }
-    interface ShareOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-        signal?: AbortSignal;
-    }
-    interface ShareSyncOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-    }
-    interface DuplexDirectionOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-    }
-    interface DuplexOptions {
-        highWaterMark?: number;
-        backpressure?: BackpressurePolicy;
-        a?: DuplexDirectionOptions;
-        b?: DuplexDirectionOptions;
-        signal?: AbortSignal;
-    }
-    interface TransformCallbackOptions {
-        signal: AbortSignal;
-    }
-    interface StatelessTransformFn {
-        (
-            chunks: Uint8Array[] | null,
-            options: TransformCallbackOptions,
-        ): Promise<TransformResult | null> | TransformResult | null;
-    }
-    interface SyncStatelessTransformFn {
-        (chunks: Uint8Array[] | null): SyncTransformResult | null;
-    }
-    interface StatefulTransform {
-        transform(
-            source: AsyncIterable<Uint8Array[] | null>,
-            options: TransformCallbackOptions,
-        ): AsyncIterable<TransformResult>;
-    }
-    interface SyncStatefulTransform {
-        transform(source: Iterable<Uint8Array[] | null>): Iterable<SyncTransformResult>;
-    }
-    // IDL interfaces
-    interface PushWriter extends Writer, Drainable {}
-    interface PushStreamResult {
-        writer: PushWriter;
-        readable: ByteReadableStream;
-    }
-    interface BroadcastWriter extends Writer, Drainable {}
-    interface BroadcastResult {
-        writer: BroadcastWriter;
-        broadcast: Broadcast;
-    }
-    interface Writer extends Disposable, AsyncDisposable {
-        readonly desiredSize: number | null;
-        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
-        writev(chunks: Array<Uint8Array | string>, options?: WriteOptions): Promise<void>;
-        writeSync(chunk: Uint8Array | string): boolean;
-        writevSync(chunks: Array<Uint8Array | string>): boolean;
-        end(options?: WriteOptions): Promise<number>;
-        endSync(): number;
-        fail(reason?: any): void;
-    }
-    interface PartialWriter extends Partial<Writer> {
-        write(chunk: Uint8Array | string, options?: WriteOptions): Promise<void>;
-    }
-    interface SyncWriter extends Disposable {
-        readonly desiredSize: number | null;
-        writeSync(chunk: Uint8Array | string): number;
-        writevSync(chunks: Array<Uint8Array | string>): number;
-        endSync(): number;
-        fail(reason?: any): void;
-    }
-    interface PartialSyncWriter extends Partial<SyncWriter> {
-        writeSync(chunk: Uint8Array | string): number;
-    }
-    interface Broadcast extends Disposable {
-        readonly consumerCount: number;
-        readonly bufferSize: number;
-        push(...args: any[]): ByteReadableStream;
-        cancel(reason?: any): void;
-    }
-    interface Share extends Disposable {
-        readonly consumerCount: number;
-        readonly bufferSize: number;
-        pull(...args: any[]): ByteReadableStream;
-        cancel(reason?: any): void;
-    }
-    interface SyncShare extends Disposable {
-        readonly consumerCount: number;
-        readonly bufferSize: number;
-        pull(...args: any): SyncByteReadableStream;
-        cancel(reason?: any): void;
-    }
-    interface DuplexChannel extends AsyncDisposable {
-        readonly writer: Writer;
-        readonly readable: ByteReadableStream;
-        close(): Promise<void>;
-    }
-    // Push stream creation
-    function push(...transforms: Transform[]): PushStreamResult;
-    function push(...args: [...transforms: Transform[], options: PushStreamOptions]): PushStreamResult;
-    // Stream factories
-    function from(input: Source): ByteReadableStream;
-    function fromSync(input: SyncSource): SyncByteReadableStream;
-    // Pull pipelines
-    function pull(source: Source, ...transforms: Transform[]): ByteReadableStream;
-    function pull(
-        source: Source,
-        ...args: [...transforms: Transform[], options: PullOptions]
-    ): ByteReadableStream;
-    function pullSync(source: SyncSource, ...transforms: SyncTransform[]): SyncByteReadableStream;
-    // Pipe operations
-    function pipeTo(source: Source, writer: PartialWriter, options?: PipeToOptions): Promise<number>;
-    function pipeTo(source: Source, ...args: [...transforms: Transform[], writer: PartialWriter]): Promise<number>;
-    function pipeTo(
-        source: Source,
-        ...args: [...transforms: Transform[], writer: PartialWriter, options: PipeToOptions]
-    ): Promise<number>;
-    function pipeToSync(source: SyncSource, writer: PartialSyncWriter, options?: PipeToSyncOptions): number;
-    function pipeToSync(
-        source: SyncSource,
-        ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter]
-    ): number;
-    function pipeToSync(
-        source: SyncSource,
-        ...args: [...transforms: SyncTransform[], writer: PartialSyncWriter, options: PipeToSyncOptions]
-    ): number;
-    // Consumers
-    function bytes(source: Source, options?: ConsumeOptions): Promise<Uint8Array>;
-    function bytesSync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array;
-    function text(source: Source, options?: TextConsumeOptions): Promise<string>;
-    function textSync(source: SyncSource, options?: TextConsumeSyncOptions): string;
-    function arrayBuffer(source: Source, options?: ConsumeOptions): Promise<ArrayBuffer>;
-    function arrayBufferSync(source: SyncSource, options?: ConsumeSyncOptions): ArrayBuffer;
-    function array(source: Source, options?: ConsumeOptions): Promise<Uint8Array[]>;
-    function arraySync(source: SyncSource, options?: ConsumeSyncOptions): Uint8Array[];
-    // Utilities
-    function tap(callback: StatelessTransformFn): StatelessTransformFn;
-    function tapSync(callback: SyncStatelessTransformFn): SyncStatelessTransformFn;
-    function merge(...sources: Source[]): ByteReadableStream;
-    function merge(...args: [...sources: Source[], options: MergeOptions]): ByteReadableStream;
-    function ondrain(drainable: any): Promise<boolean> | null;
-    // Multi-consumer
-    function broadcast(options?: BroadcastOptions): BroadcastResult;
-    function share(source: Source, options?: ShareOptions): Share;
-    function shareSync(source: SyncSource, options?: ShareSyncOptions): SyncShare;
-    // Duplex
-    function duplex(options?: DuplexOptions): [DuplexChannel, DuplexChannel];
-    // Node.js-specific extensions
-    namespace Broadcast {
-        /**
-         * Create a `Broadcast` from an existing source. The source is consumed
-         * automatically and pushed to all subscribers.
-         * @since v25.9.0
-         * @param options Same as `broadcast()`.
-         */
-        function from(
-            input: ByteReadableStream | SyncByteReadableStream | Broadcastable,
-            options?: BroadcastOptions,
-        ): BroadcastResult;
-    }
-    namespace Share {
-        /**
-         * Create a `Share` from an existing source.
-         * @since v25.9.0
-         * @param options Same as `share()`.
-         */
-        function from(input: ByteReadableStream | SyncByteReadableStream | Shareable, options?: ShareOptions): Share;
-    }
-    namespace SyncShare {
-        /**
-         * @since v25.9.0
-         */
-        function from(input: SyncByteReadableStream | SyncShareable, options?: ShareSyncOptions): SyncShare;
-    }
-    /**
-     * Converts a classic Readable stream (or duck-typed equivalent) into a
-     * stream/iter async iterable source that can be passed to `from()`,
-     * `pull()`, `text()`, etc.
-     *
-     * If the object implements the `toAsyncStreamable` protocol (as
-     * `stream.Readable` does), that protocol is used. Otherwise, the function
-     * duck-types on `read()` and `on()` (EventEmitter) and wraps the stream with
-     * a batched async iterator.
-     *
-     * The result is cached per instance -- calling `fromReadable()` twice with the
-     * same stream returns the same iterable.
-     *
-     * For object-mode or encoded Readable streams, chunks are automatically
-     * normalized to `Uint8Array`.
-     *
-     * ```js
-     * import { Readable } from 'node:stream';
-     * import { fromReadable, text } from 'node:stream/iter';
-     *
-     * const readable = new Readable({
-     *   read() { this.push('hello world'); this.push(null); },
-     * });
-     *
-     * const result = await text(fromReadable(readable));
-     * console.log(result); // 'hello world'
-     * ```
-     * @since v26.1.0
-     * @experimental
-     * @param readable A classic Readable stream or any object
-     * with `read()` and `on()` methods.
-     * @returns A stream/iter async iterable source.
-     */
-    function fromReadable(readable: NodeJS.ReadableStream): ByteReadableStream;
-    interface FromWritableOptions {
-        backpressure?: BackpressurePolicy | undefined;
-    }
-    /**
-     * Creates a stream/iter Writer adapter from a classic Writable stream (or
-     * duck-typed equivalent). The adapter can be passed to `pipeTo()` as a
-     * destination.
-     *
-     * Since all writes on a classic Writable are fundamentally asynchronous,
-     * the synchronous Writer methods (`writeSync`, `writevSync`, `endSync`) always
-     * return `false` or `-1`, deferring to the async path. The per-write
-     * `options.signal` parameter from the Writer interface is also ignored.
-     *
-     * The result is cached per instance and backpressure policy -- calling
-     * `fromWritable()` twice with the same stream and `backpressure` option returns
-     * the same Writer.
-     *
-     * For duck-typed streams that do not expose `writableHighWaterMark`,
-     * `writableLength`, or similar properties, sensible defaults are used.
-     * Object-mode writables (if detectable) are rejected since the Writer
-     * interface is bytes-only.
-     *
-     * ```js
-     * import { Writable } from 'node:stream';
-     * import { from, fromWritable, pipeTo } from 'node:stream/iter';
-     *
-     * const writable = new Writable({
-     *   write(chunk, encoding, cb) { console.log(chunk.toString()); cb(); },
-     * });
-     *
-     * await pipeTo(from('hello world'),
-     *              fromWritable(writable, { backpressure: 'block' }));
-     * ```
-     * @since v26.1.0
-     * @experimental
-     * @param writable A classic Writable stream or any object
-     * with `write()` and `on()` methods.
-     * @returns A stream/iter Writer adapter.
-     */
-    function fromWritable(writable: NodeJS.WritableStream, options?: FromWritableOptions): Writer;
-    interface ToReadableOptions extends Abortable {
-        highWaterMark?: number | undefined;
-    }
-    /**
-     * Creates a byte-mode `stream.Readable` from an `AsyncIterable<Uint8Array[]>`
-     * (the native batch format used by the stream/iter API). Each `Uint8Array` in a
-     * yielded batch is pushed as a separate chunk into the Readable.
-     *
-     * ```js
-     * import { createWriteStream } from 'node:fs';
-     * import { from, pull, toReadable } from 'node:stream/iter';
-     * import { compressGzip } from 'node:zlib/iter';
-     *
-     * const source = pull(from('hello world'), compressGzip());
-     * const readable = toReadable(source);
-     *
-     * readable.pipe(createWriteStream('output.gz'));
-     * ```
-     * @since v26.1.0
-     * @experimental
-     * @param source An `AsyncIterable<Uint8Array[]>` source, such as
-     * the return value of `pull()` or `from()`.
-     */
-    function toReadable(source: Source, options?: ToReadableOptions): Readable;
-    interface ToReadableSyncOptions {
-        highWaterMark?: number | undefined;
-    }
-    /**
-     * Creates a byte-mode `stream.Readable` from a synchronous
-     * `Iterable<Uint8Array[]>`. The `_read()` method pulls from the iterator
-     * synchronously, so data is available immediately via `readable.read()`.
-     *
-     * ```js
-     * import { fromSync, toReadableSync } from 'node:stream/iter';
-     *
-     * const source = fromSync('hello world');
-     * const readable = toReadableSync(source);
-     *
-     * console.log(readable.read().toString()); // 'hello world'
-     * ```
-     * @since v26.1.0
-     * @experimental
-     * @param source An `Iterable<Uint8Array[]>` source, such as the
-     * return value of `pullSync()` or `fromSync()`.
-     */
-    function toReadableSync(source: SyncSource, options?: ToReadableSyncOptions): Readable;
-    /**
-     * Creates a classic `stream.Writable` backed by a stream/iter Writer.
-     *
-     * Each `_write()` / `_writev()` call attempts the Writer's synchronous method
-     * first (`writeSync` / `writevSync`), falling back to the async method if the
-     * sync path returns `false` or throws. Similarly, `_final()` tries `endSync()`
-     * before `end()`. When the sync path succeeds, the callback is deferred via
-     * `queueMicrotask` to preserve the async resolution contract.
-     *
-     * The Writable's `highWaterMark` is set to `Number.MAX_SAFE_INTEGER` to
-     * effectively disable its internal buffering, allowing the underlying Writer
-     * to manage backpressure directly.
-     *
-     * ```js
-     * import { push, toWritable } from 'node:stream/iter';
-     *
-     * const { writer, readable } = push();
-     * const writable = toWritable(writer);
-     *
-     * writable.write('hello');
-     * writable.end();
-     * ```
-     * @since v26.1.0
-     * @experimental
-     * @param writer A stream/iter Writer. Only the `write()` method is
-     * required; `end()`, `fail()`, `writeSync()`, `writevSync()`, `endSync()`,
-     * and `writev()` are optional.
-     */
-    function toWritable(writer: PartialWriter): Writable;
-    namespace Stream {
-        export {
-            array,
-            arrayBuffer,
-            arrayBufferSync,
-            arraySync,
-            broadcast,
-            broadcastProtocol,
-            bytes,
-            bytesSync,
-            drainableProtocol,
-            duplex,
-            from,
-            fromSync,
-            merge,
-            ondrain,
-            pipeTo,
-            pipeToSync,
-            pull,
-            pullSync,
-            push,
-            share,
-            shareProtocol,
-            shareSync,
-            shareSyncProtocol,
-            tap,
-            tapSync,
-            text,
-            textSync,
-            toAsyncStreamable,
-            toStreamable,
-        };
-    }
-}
-declare module "stream/iter" {
-    export * from "node:stream/iter";
-}

package/server/node_modules/@types/node/test/reporters.d.ts

@@ -1,59 +0,0 @@
-declare module "node:test/reporters" {
-    import { Transform, TransformOptions } from "node:stream";
-    import { EventData } from "node:test";
-    type TestEvent =
-        | { type: "test:coverage"; data: EventData.TestCoverage }
-        | { type: "test:complete"; data: EventData.TestComplete }
-        | { type: "test:dequeue"; data: EventData.TestDequeue }
-        | { type: "test:diagnostic"; data: EventData.TestDiagnostic }
-        | { type: "test:enqueue"; data: EventData.TestEnqueue }
-        | { type: "test:fail"; data: EventData.TestFail }
-        | { type: "test:interrupted"; data: EventData.TestInterrupted }
-        | { type: "test:pass"; data: EventData.TestPass }
-        | { type: "test:plan"; data: EventData.TestPlan }
-        | { type: "test:start"; data: EventData.TestStart }
-        | { type: "test:stderr"; data: EventData.TestStderr }
-        | { type: "test:stdout"; data: EventData.TestStdout }
-        | { type: "test:summary"; data: EventData.TestSummary }
-        | { type: "test:watch:drained"; data: undefined }
-        | { type: "test:watch:restarted"; data: undefined };
-    interface ReporterConstructorWrapper<T extends new(...args: any[]) => Transform> {
-        new(...args: ConstructorParameters<T>): InstanceType<T>;
-        (...args: ConstructorParameters<T>): InstanceType<T>;
-    }
-    /**
-     * The `dot` reporter outputs the test results in a compact format,
-     * where each passing test is represented by a `.`,
-     * and each failing test is represented by a `X`.
-     * @since v20.0.0
-     */
-    function dot(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
-    /**
-     * The `tap` reporter outputs the test results in the [TAP](https://testanything.org/) format.
-     * @since v20.0.0
-     */
-    function tap(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
-    class SpecReporter extends Transform {
-        constructor();
-    }
-    /**
-     * The `spec` reporter outputs the test results in a human-readable format.
-     * @since v20.0.0
-     */
-    const spec: ReporterConstructorWrapper<typeof SpecReporter>;
-    /**
-     * The `junit` reporter outputs test results in a jUnit XML format.
-     * @since v21.0.0
-     */
-    function junit(source: AsyncIterable<TestEvent>): NodeJS.AsyncIterator<string>;
-    class LcovReporter extends Transform {
-        constructor(options?: Omit<TransformOptions, "writableObjectMode">);
-    }
-    /**
-     * The `lcov` reporter outputs test coverage when used with the
-     * [`--experimental-test-coverage`](https://nodejs.org/docs/latest-v26.x/api/cli.html#--experimental-test-coverage) flag.
-     * @since v22.0.0
-     */
-    const lcov: ReporterConstructorWrapper<typeof LcovReporter>;
-    export { dot, junit, lcov, spec, tap, TestEvent };
-}

package/server/node_modules/@types/node/ts5.6/compatibility/float16array.d.ts

@@ -1,71 +0,0 @@
-// Interface declaration for Float16Array, required in @types/node v24+.
-// These definitions are specific to TS <=5.6.
-
-// This needs all of the "common" properties/methods of the TypedArrays,
-// otherwise the type unions `TypedArray` and `ArrayBufferView` will be
-// empty objects.
-interface Float16Array extends Pick<Float32Array, typeof Symbol.iterator | "entries" | "keys" | "values"> {
-    readonly BYTES_PER_ELEMENT: number;
-    readonly buffer: ArrayBufferLike;
-    readonly byteLength: number;
-    readonly byteOffset: number;
-    readonly length: number;
-    readonly [Symbol.toStringTag]: "Float16Array";
-    at(index: number): number | undefined;
-    copyWithin(target: number, start: number, end?: number): this;
-    every(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): boolean;
-    fill(value: number, start?: number, end?: number): this;
-    filter(predicate: (value: number, index: number, array: Float16Array) => any, thisArg?: any): Float16Array;
-    find(predicate: (value: number, index: number, obj: Float16Array) => boolean, thisArg?: any): number | undefined;
-    findIndex(predicate: (value: number, index: number, obj: Float16Array) => boolean, thisArg?: any): number;
-    findLast<S extends number>(
-        predicate: (value: number, index: number, array: Float16Array) => value is S,
-        thisArg?: any,
-    ): S | undefined;
-    findLast(
-        predicate: (value: number, index: number, array: Float16Array) => unknown,
-        thisArg?: any,
-    ): number | undefined;
-    findLastIndex(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): number;
-    forEach(callbackfn: (value: number, index: number, array: Float16Array) => void, thisArg?: any): void;
-    includes(searchElement: number, fromIndex?: number): boolean;
-    indexOf(searchElement: number, fromIndex?: number): number;
-    join(separator?: string): string;
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-    map(callbackfn: (value: number, index: number, array: Float16Array) => number, thisArg?: any): Float16Array;
-    reduce(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
-    ): number;
-    reduce(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
-        initialValue: number,
-    ): number;
-    reduce<U>(
-        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float16Array) => U,
-        initialValue: U,
-    ): U;
-    reduceRight(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
-    ): number;
-    reduceRight(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Float16Array) => number,
-        initialValue: number,
-    ): number;
-    reduceRight<U>(
-        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Float16Array) => U,
-        initialValue: U,
-    ): U;
-    reverse(): Float16Array;
-    set(array: ArrayLike<number>, offset?: number): void;
-    slice(start?: number, end?: number): Float16Array;
-    some(predicate: (value: number, index: number, array: Float16Array) => unknown, thisArg?: any): boolean;
-    sort(compareFn?: (a: number, b: number) => number): this;
-    subarray(begin?: number, end?: number): Float16Array;
-    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
-    toReversed(): Float16Array;
-    toSorted(compareFn?: (a: number, b: number) => number): Float16Array;
-    toString(): string;
-    valueOf(): Float16Array;
-    with(index: number, value: number): Float16Array;
-    [index: number]: number;
-}

package/server/node_modules/@types/node/ts5.7/compatibility/float16array.d.ts

@@ -1,72 +0,0 @@
-// Interface declaration for Float16Array, required in @types/node v24+.
-// These definitions are specific to TS 5.7.
-
-// This needs all of the "common" properties/methods of the TypedArrays,
-// otherwise the type unions `TypedArray` and `ArrayBufferView` will be
-// empty objects.
-interface Float16Array<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> {
-    readonly BYTES_PER_ELEMENT: number;
-    readonly buffer: TArrayBuffer;
-    readonly byteLength: number;
-    readonly byteOffset: number;
-    readonly length: number;
-    readonly [Symbol.toStringTag]: "Float16Array";
-    at(index: number): number | undefined;
-    copyWithin(target: number, start: number, end?: number): this;
-    entries(): ArrayIterator<[number, number]>;
-    every(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean;
-    fill(value: number, start?: number, end?: number): this;
-    filter(predicate: (value: number, index: number, array: this) => any, thisArg?: any): Float16Array<ArrayBuffer>;
-    find(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number | undefined;
-    findIndex(predicate: (value: number, index: number, obj: this) => boolean, thisArg?: any): number;
-    findLast<S extends number>(
-        predicate: (value: number, index: number, array: this) => value is S,
-        thisArg?: any,
-    ): S | undefined;
-    findLast(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number | undefined;
-    findLastIndex(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): number;
-    forEach(callbackfn: (value: number, index: number, array: this) => void, thisArg?: any): void;
-    includes(searchElement: number, fromIndex?: number): boolean;
-    indexOf(searchElement: number, fromIndex?: number): number;
-    join(separator?: string): string;
-    keys(): ArrayIterator<number>;
-    lastIndexOf(searchElement: number, fromIndex?: number): number;
-    map(callbackfn: (value: number, index: number, array: this) => number, thisArg?: any): Float16Array<ArrayBuffer>;
-    reduce(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number,
-    ): number;
-    reduce(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number,
-        initialValue: number,
-    ): number;
-    reduce<U>(
-        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U,
-        initialValue: U,
-    ): U;
-    reduceRight(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number,
-    ): number;
-    reduceRight(
-        callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: this) => number,
-        initialValue: number,
-    ): number;
-    reduceRight<U>(
-        callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: this) => U,
-        initialValue: U,
-    ): U;
-    reverse(): this;
-    set(array: ArrayLike<number>, offset?: number): void;
-    slice(start?: number, end?: number): Float16Array<ArrayBuffer>;
-    some(predicate: (value: number, index: number, array: this) => unknown, thisArg?: any): boolean;
-    sort(compareFn?: (a: number, b: number) => number): this;
-    subarray(begin?: number, end?: number): Float16Array<TArrayBuffer>;
-    toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions): string;
-    toReversed(): Float16Array<ArrayBuffer>;
-    toSorted(compareFn?: (a: number, b: number) => number): Float16Array<ArrayBuffer>;
-    toString(): string;
-    valueOf(): this;
-    values(): ArrayIterator<number>;
-    with(index: number, value: number): Float16Array<ArrayBuffer>;
-    [Symbol.iterator](): ArrayIterator<number>;
-    [index: number]: number;
-}