node-red-contrib-tak-registration 0.16.1 → 0.16.3

package/node_modules/@types/node/web-globals/streams.d.ts

@@ -0,0 +1,22 @@
+export {};
+
+import * as webstreams from "stream/web";
+
+type _CompressionStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.CompressionStream;
+type _DecompressionStream = typeof globalThis extends { onmessage: any } ? {} : webstreams.DecompressionStream;
+
+declare global {
+    interface CompressionStream extends _CompressionStream {}
+    var CompressionStream: typeof globalThis extends {
+        onmessage: any;
+        CompressionStream: infer T;
+    } ? T
+        : typeof webstreams.CompressionStream;
+
+    interface DecompressionStream extends _DecompressionStream {}
+    var DecompressionStream: typeof globalThis extends {
+        onmessage: any;
+        DecompressionStream: infer T;
+    } ? T
+        : typeof webstreams.DecompressionStream;
+}

package/node_modules/@types/node/worker_threads.d.ts

@@ -56,19 +56,21 @@
  */
 declare module "worker_threads" {
     import { Context } from "node:vm";
-    import { EventEmitter } from "node:events";
+    import { EventEmitter, NodeEventTarget } from "node:events";
     import { EventLoopUtilityFunction } from "node:perf_hooks";
     import { FileHandle } from "node:fs/promises";
     import { Readable, Writable } from "node:stream";
     import { ReadableStream, TransformStream, WritableStream } from "node:stream/web";
     import { URL } from "node:url";
-    import { HeapInfo } from "node:v8";
+    import { CPUProfileHandle, HeapInfo, HeapProfileHandle } from "node:v8";
+    import { MessageEvent } from "undici-types";
     const isInternalThread: boolean;
     const isMainThread: boolean;
     const parentPort: null | MessagePort;
     const resourceLimits: ResourceLimits;
     const SHARE_ENV: unique symbol;
     const threadId: number;
+    const threadName: string | null;
     const workerData: any;
     /**
      * Instances of the `worker.MessageChannel` class represent an asynchronous,
@@ -111,7 +113,7 @@ declare module "worker_threads" {
      * This implementation matches [browser `MessagePort`](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort) s.
      * @since v10.5.0
      */
-    class MessagePort extends EventEmitter {
+    class MessagePort implements EventTarget {
         /**
          * Disables further sending of messages on either side of the connection.
          * This method can be called when no further communication will happen over this `MessagePort`.
@@ -224,42 +226,32 @@ declare module "worker_threads" {
          * @since v10.5.0
          */
         start(): void;
-        addListener(event: "close", listener: () => void): this;
+        addListener(event: "close", listener: (ev: Event) => void): this;
         addListener(event: "message", listener: (value: any) => void): this;
         addListener(event: "messageerror", listener: (error: Error) => void): this;
-        addListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        emit(event: "close"): boolean;
+        addListener(event: string, listener: (arg: any) => void): this;
+        emit(event: "close", ev: Event): boolean;
         emit(event: "message", value: any): boolean;
         emit(event: "messageerror", error: Error): boolean;
-        emit(event: string | symbol, ...args: any[]): boolean;
-        on(event: "close", listener: () => void): this;
+        emit(event: string, arg: any): boolean;
+        off(event: "close", listener: (ev: Event) => void, options?: EventListenerOptions): this;
+        off(event: "message", listener: (value: any) => void, options?: EventListenerOptions): this;
+        off(event: "messageerror", listener: (error: Error) => void, options?: EventListenerOptions): this;
+        off(event: string, listener: (arg: any) => void, options?: EventListenerOptions): this;
+        on(event: "close", listener: (ev: Event) => void): this;
         on(event: "message", listener: (value: any) => void): this;
         on(event: "messageerror", listener: (error: Error) => void): this;
-        on(event: string | symbol, listener: (...args: any[]) => void): this;
-        once(event: "close", listener: () => void): this;
+        on(event: string, listener: (arg: any) => void): this;
+        once(event: "close", listener: (ev: Event) => void): this;
         once(event: "message", listener: (value: any) => void): this;
         once(event: "messageerror", listener: (error: Error) => void): this;
-        once(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependListener(event: "close", listener: () => void): this;
-        prependListener(event: "message", listener: (value: any) => void): this;
-        prependListener(event: "messageerror", listener: (error: Error) => void): this;
-        prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        prependOnceListener(event: "close", listener: () => void): this;
-        prependOnceListener(event: "message", listener: (value: any) => void): this;
-        prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
-        prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        removeListener(event: "close", listener: () => void): this;
-        removeListener(event: "message", listener: (value: any) => void): this;
-        removeListener(event: "messageerror", listener: (error: Error) => void): this;
-        removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
-        off(event: "close", listener: () => void): this;
-        off(event: "message", listener: (value: any) => void): this;
-        off(event: "messageerror", listener: (error: Error) => void): this;
-        off(event: string | symbol, listener: (...args: any[]) => void): this;
-        addEventListener: EventTarget["addEventListener"];
-        dispatchEvent: EventTarget["dispatchEvent"];
-        removeEventListener: EventTarget["removeEventListener"];
+        once(event: string, listener: (arg: any) => void): this;
+        removeListener(event: "close", listener: (ev: Event) => void, options?: EventListenerOptions): this;
+        removeListener(event: "message", listener: (value: any) => void, options?: EventListenerOptions): this;
+        removeListener(event: "messageerror", listener: (error: Error) => void, options?: EventListenerOptions): this;
+        removeListener(event: string, listener: (arg: any) => void, options?: EventListenerOptions): this;
     }
+    interface MessagePort extends NodeEventTarget {}
     interface WorkerOptions {
         /**
          * List of arguments which would be stringified and appended to
@@ -401,6 +393,12 @@ declare module "worker_threads" {
          * @since v10.5.0
          */
         readonly threadId: number;
+        /**
+         * A string identifier for the referenced thread or null if the thread is not running.
+         * Inside the worker thread, it is available as `require('node:worker_threads').threadName`.
+         * @since v24.6.0
+         */
+        readonly threadName: string | null;
         /**
          * Provides the set of JS engine resource constraints for this Worker thread.
          * If the `resourceLimits` option was passed to the `Worker` constructor,
@@ -428,24 +426,6 @@ declare module "worker_threads" {
          * @since v10.5.0
          */
         postMessage(value: any, transferList?: readonly Transferable[]): void;
-        /**
-         * Sends a value to another worker, identified by its thread ID.
-         * @param threadId The target thread ID. If the thread ID is invalid, a `ERR_WORKER_MESSAGING_FAILED` error will be thrown.
-         * If the target thread ID is the current thread ID, a `ERR_WORKER_MESSAGING_SAME_THREAD` error will be thrown.
-         * @param value The value to send.
-         * @param transferList If one or more `MessagePort`-like objects are passed in value, a `transferList` is required for those items
-         * or `ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST` is thrown. See `port.postMessage()` for more information.
-         * @param timeout Time to wait for the message to be delivered in milliseconds. By default it's `undefined`, which means wait forever.
-         * If the operation times out, a `ERR_WORKER_MESSAGING_TIMEOUT` error is thrown.
-         * @since v22.5.0
-         */
-        postMessageToThread(threadId: number, value: any, timeout?: number): Promise<void>;
-        postMessageToThread(
-            threadId: number,
-            value: any,
-            transferList: readonly Transferable[],
-            timeout?: number,
-        ): Promise<void>;
         /**
          * Opposite of `unref()`, calling `ref()` on a previously `unref()`ed worker does _not_ let the program exit if it's the only active handle left (the default
          * behavior). If the worker is `ref()`ed, calling `ref()` again has
@@ -465,6 +445,13 @@ declare module "worker_threads" {
          * @since v10.5.0
          */
         terminate(): Promise<number>;
+        /**
+         * This method returns a `Promise` that will resolve to an object identical to `process.threadCpuUsage()`,
+         * or reject with an `ERR_WORKER_NOT_RUNNING` error if the worker is no longer running.
+         * This methods allows the statistics to be observed from outside the actual thread.
+         * @since v24.6.0
+         */
+        cpuUsage(prev?: NodeJS.CpuUsage): Promise<NodeJS.CpuUsage>;
         /**
          * Returns a readable stream for a V8 snapshot of the current state of the Worker.
          * See `v8.getHeapSnapshot()` for more details.
@@ -482,6 +469,81 @@ declare module "worker_threads" {
          * @since v24.0.0
          */
         getHeapStatistics(): Promise<HeapInfo>;
+        /**
+         * Starting a CPU profile then return a Promise that fulfills with an error
+         * or an `CPUProfileHandle` object. This API supports `await using` syntax.
+         *
+         * ```js
+         * const { Worker } = require('node:worker_threads');
+         *
+         * const worker = new Worker(`
+         *   const { parentPort } = require('worker_threads');
+         *   parentPort.on('message', () => {});
+         *   `, { eval: true });
+         *
+         * worker.on('online', async () => {
+         *   const handle = await worker.startCpuProfile();
+         *   const profile = await handle.stop();
+         *   console.log(profile);
+         *   worker.terminate();
+         * });
+         * ```
+         *
+         * `await using` example.
+         *
+         * ```js
+         * const { Worker } = require('node:worker_threads');
+         *
+         * const w = new Worker(`
+         *   const { parentPort } = require('node:worker_threads');
+         *   parentPort.on('message', () => {});
+         *   `, { eval: true });
+         *
+         * w.on('online', async () => {
+         *   // Stop profile automatically when return and profile will be discarded
+         *   await using handle = await w.startCpuProfile();
+         * });
+         * ```
+         * @since v24.8.0
+         */
+        startCpuProfile(): Promise<CPUProfileHandle>;
+        /**
+         * Starting a Heap profile then return a Promise that fulfills with an error
+         * or an `HeapProfileHandle` object. This API supports `await using` syntax.
+         *
+         * ```js
+         * const { Worker } = require('node:worker_threads');
+         *
+         * const worker = new Worker(`
+         *   const { parentPort } = require('worker_threads');
+         *   parentPort.on('message', () => {});
+         *   `, { eval: true });
+         *
+         * worker.on('online', async () => {
+         *   const handle = await worker.startHeapProfile();
+         *   const profile = await handle.stop();
+         *   console.log(profile);
+         *   worker.terminate();
+         * });
+         * ```
+         *
+         * `await using` example.
+         *
+         * ```js
+         * const { Worker } = require('node:worker_threads');
+         *
+         * const w = new Worker(`
+         *   const { parentPort } = require('node:worker_threads');
+         *   parentPort.on('message', () => {});
+         *   `, { eval: true });
+         *
+         * w.on('online', async () => {
+         *   // Stop profile automatically when return and profile will be discarded
+         *   await using handle = await w.startHeapProfile();
+         * });
+         * ```
+         */
+        startHeapProfile(): Promise<HeapProfileHandle>;
         /**
          * Calls `worker.terminate()` when the dispose scope is exited.
          *
@@ -574,18 +636,18 @@ declare module "worker_threads" {
      * ```
      * @since v15.4.0
      */
-    class BroadcastChannel {
+    class BroadcastChannel extends EventTarget {
         readonly name: string;
         /**
          * Invoked with a single \`MessageEvent\` argument when a message is received.
          * @since v15.4.0
          */
-        onmessage: (message: unknown) => void;
+        onmessage: (message: MessageEvent) => void;
         /**
          * Invoked with a received message cannot be deserialized.
          * @since v15.4.0
          */
-        onmessageerror: (message: unknown) => void;
+        onmessageerror: (message: MessageEvent) => void;
         constructor(name: string);
         /**
          * Closes the `BroadcastChannel` connection.
@@ -598,6 +660,35 @@ declare module "worker_threads" {
          */
         postMessage(message: unknown): void;
     }
+    interface Lock {
+        readonly mode: LockMode;
+        readonly name: string;
+    }
+    interface LockGrantedCallback<T> {
+        (lock: Lock | null): T;
+    }
+    interface LockInfo {
+        clientId: string;
+        mode: LockMode;
+        name: string;
+    }
+    interface LockManager {
+        query(): Promise<LockManagerSnapshot>;
+        request<T>(name: string, callback: LockGrantedCallback<T>): Promise<Awaited<T>>;
+        request<T>(name: string, options: LockOptions, callback: LockGrantedCallback<T>): Promise<Awaited<T>>;
+    }
+    interface LockManagerSnapshot {
+        held: LockInfo[];
+        pending: LockInfo[];
+    }
+    type LockMode = "exclusive" | "shared";
+    interface LockOptions {
+        ifAvailable?: boolean;
+        mode?: LockMode;
+        signal?: AbortSignal;
+        steal?: boolean;
+    }
+    var locks: LockManager;
     /**
      * Mark an object as not transferable. If `object` occurs in the transfer list of
      * a `port.postMessage()` call, it is ignored.

package/node_modules/@types/node/zlib.d.ts

@@ -92,6 +92,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/zlib.js)
  */
 declare module "zlib" {
+    import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";
     interface ZlibOptions {
         /**
@@ -180,6 +181,12 @@ declare module "zlib" {
          * If `true`, returns an object with `buffer` and `engine`.
          */
         info?: boolean | undefined;
+        /**
+         * Optional dictionary used to improve compression efficiency when compressing or decompressing data that
+         * shares common patterns with the dictionary.
+         * @since v24.6.0
+         */
+        dictionary?: NodeJS.ArrayBufferView | undefined;
     }
     interface Zlib {
         readonly bytesWritten: number;
@@ -221,7 +228,7 @@ declare module "zlib" {
      * @returns A 32-bit unsigned integer containing the checksum.
      * @since v22.2.0
      */
-    function crc32(data: string | Buffer | NodeJS.ArrayBufferView, value?: number): number;
+    function crc32(data: string | NodeJS.ArrayBufferView, value?: number): number;
     /**
      * Creates and returns a new `BrotliCompress` object.
      * @since v11.7.0, v10.16.0
@@ -285,124 +292,124 @@ declare module "zlib" {
      */
     function createZstdDecompress(options?: ZstdOptions): ZstdDecompress;
     type InputType = string | ArrayBuffer | NodeJS.ArrayBufferView;
-    type CompressCallback = (error: Error | null, result: Buffer) => void;
+    type CompressCallback = (error: Error | null, result: NonSharedBuffer) => void;
     /**
      * @since v11.7.0, v10.16.0
      */
     function brotliCompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
     function brotliCompress(buf: InputType, callback: CompressCallback): void;
     namespace brotliCompress {
-        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `BrotliCompress`.
      * @since v11.7.0, v10.16.0
      */
-    function brotliCompressSync(buf: InputType, options?: BrotliOptions): Buffer;
+    function brotliCompressSync(buf: InputType, options?: BrotliOptions): NonSharedBuffer;
     /**
      * @since v11.7.0, v10.16.0
      */
     function brotliDecompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
     function brotliDecompress(buf: InputType, callback: CompressCallback): void;
     namespace brotliDecompress {
-        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `BrotliDecompress`.
      * @since v11.7.0, v10.16.0
      */
-    function brotliDecompressSync(buf: InputType, options?: BrotliOptions): Buffer;
+    function brotliDecompressSync(buf: InputType, options?: BrotliOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function deflate(buf: InputType, callback: CompressCallback): void;
     function deflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace deflate {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `Deflate`.
      * @since v0.11.12
      */
-    function deflateSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function deflateSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function deflateRaw(buf: InputType, callback: CompressCallback): void;
     function deflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace deflateRaw {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `DeflateRaw`.
      * @since v0.11.12
      */
-    function deflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function deflateRawSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function gzip(buf: InputType, callback: CompressCallback): void;
     function gzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace gzip {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `Gzip`.
      * @since v0.11.12
      */
-    function gzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function gzipSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function gunzip(buf: InputType, callback: CompressCallback): void;
     function gunzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace gunzip {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `Gunzip`.
      * @since v0.11.12
      */
-    function gunzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function gunzipSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function inflate(buf: InputType, callback: CompressCallback): void;
     function inflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace inflate {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `Inflate`.
      * @since v0.11.12
      */
-    function inflateSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function inflateSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function inflateRaw(buf: InputType, callback: CompressCallback): void;
     function inflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace inflateRaw {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `InflateRaw`.
      * @since v0.11.12
      */
-    function inflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function inflateRawSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v0.6.0
      */
     function unzip(buf: InputType, callback: CompressCallback): void;
     function unzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
     namespace unzip {
-        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `Unzip`.
      * @since v0.11.12
      */
-    function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function unzipSync(buf: InputType, options?: ZlibOptions): NonSharedBuffer;
     /**
      * @since v22.15.0
      * @experimental
@@ -410,14 +417,14 @@ declare module "zlib" {
     function zstdCompress(buf: InputType, callback: CompressCallback): void;
     function zstdCompress(buf: InputType, options: ZstdOptions, callback: CompressCallback): void;
     namespace zstdCompress {
-        function __promisify__(buffer: InputType, options?: ZstdOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZstdOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Compress a chunk of data with `ZstdCompress`.
      * @since v22.15.0
      * @experimental
      */
-    function zstdCompressSync(buf: InputType, options?: ZstdOptions): Buffer;
+    function zstdCompressSync(buf: InputType, options?: ZstdOptions): NonSharedBuffer;
     /**
      * @since v22.15.0
      * @experimental
@@ -425,14 +432,14 @@ declare module "zlib" {
     function zstdDecompress(buf: InputType, callback: CompressCallback): void;
     function zstdDecompress(buf: InputType, options: ZstdOptions, callback: CompressCallback): void;
     namespace zstdDecompress {
-        function __promisify__(buffer: InputType, options?: ZstdOptions): Promise<Buffer>;
+        function __promisify__(buffer: InputType, options?: ZstdOptions): Promise<NonSharedBuffer>;
     }
     /**
      * Decompress a chunk of data with `ZstdDecompress`.
      * @since v22.15.0
      * @experimental
      */
-    function zstdDecompressSync(buf: InputType, options?: ZstdOptions): Buffer;
+    function zstdDecompressSync(buf: InputType, options?: ZstdOptions): NonSharedBuffer;
     namespace constants {
         const BROTLI_DECODE: number;
         const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number;