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

package/node_modules/@types/node/timers/promises.d.ts

@@ -11,7 +11,7 @@
  * } from 'node:timers/promises';
  * ```
  * @since v15.0.0
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/timers/promises.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/timers/promises.js)
  */
 declare module "timers/promises" {
     import { TimerOptions } from "node:timers";

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

@@ -6,7 +6,7 @@
  * The timer functions within Node.js implement a similar API as the timers API
  * provided by Web Browsers but use a different internal implementation that is
  * built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/timers.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/timers.js)
  */
 declare module "timers" {
     import { Abortable } from "node:events";
@@ -60,7 +60,6 @@ declare module "timers" {
                 /**
                  * Cancels the immediate. This is similar to calling `clearImmediate()`.
                  * @since v20.5.0, v18.18.0
-                 * @experimental
                  */
                 [Symbol.dispose](): void;
                 _onImmediate(...args: any[]): void;
@@ -141,7 +140,6 @@ declare module "timers" {
                 /**
                  * Cancels the timeout.
                  * @since v20.5.0, v18.18.0
-                 * @experimental
                  */
                 [Symbol.dispose](): void;
                 _onTimeout(...args: any[]): void;

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

@@ -6,7 +6,7 @@
  * ```js
  * import tls from 'node:tls';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/tls.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/tls.js)
  */
 declare module "tls" {
     import { X509Certificate } from "node:crypto";
@@ -797,13 +797,6 @@ declare module "tls" {
         prependOnceListener(event: "secureConnection", listener: (tlsSocket: TLSSocket) => void): this;
         prependOnceListener(event: "keylog", listener: (line: Buffer, tlsSocket: TLSSocket) => void): this;
     }
-    /**
-     * @deprecated since v0.11.3 Use `tls.TLSSocket` instead.
-     */
-    interface SecurePair {
-        encrypted: TLSSocket;
-        cleartext: TLSSocket;
-    }
     type SecureVersion = "TLSv1.3" | "TLSv1.2" | "TLSv1.1" | "TLSv1";
     interface SecureContextOptions {
         /**
@@ -1102,45 +1095,6 @@ declare module "tls" {
         secureConnectListener?: () => void,
     ): TLSSocket;
     function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () => void): TLSSocket;
-    /**
-     * Creates a new secure pair object with two streams, one of which reads and writes
-     * the encrypted data and the other of which reads and writes the cleartext data.
-     * Generally, the encrypted stream is piped to/from an incoming encrypted data
-     * stream and the cleartext one is used as a replacement for the initial encrypted
-     * stream.
-     *
-     * `tls.createSecurePair()` returns a `tls.SecurePair` object with `cleartext` and `encrypted` stream properties.
-     *
-     * Using `cleartext` has the same API as {@link TLSSocket}.
-     *
-     * The `tls.createSecurePair()` method is now deprecated in favor of`tls.TLSSocket()`. For example, the code:
-     *
-     * ```js
-     * pair = tls.createSecurePair(// ... );
-     * pair.encrypted.pipe(socket);
-     * socket.pipe(pair.encrypted);
-     * ```
-     *
-     * can be replaced by:
-     *
-     * ```js
-     * secureSocket = tls.TLSSocket(socket, options);
-     * ```
-     *
-     * where `secureSocket` has the same API as `pair.cleartext`.
-     * @since v0.3.2
-     * @deprecated Since v0.11.3 - Use {@link TLSSocket} instead.
-     * @param context A secure context object as returned by `tls.createSecureContext()`
-     * @param isServer `true` to specify that this TLS connection should be opened as a server.
-     * @param requestCert `true` to specify whether a server should request a certificate from a connecting client. Only applies when `isServer` is `true`.
-     * @param rejectUnauthorized If not `false` a server automatically reject clients with invalid certificates. Only applies when `isServer` is `true`.
-     */
-    function createSecurePair(
-        context?: SecureContext,
-        isServer?: boolean,
-        requestCert?: boolean,
-        rejectUnauthorized?: boolean,
-    ): SecurePair;
     /**
      * `{@link createServer}` sets the default value of the `honorCipherOrder` option
      * to `true`, other APIs that create secure contexts leave it unset.
@@ -1197,7 +1151,7 @@ declare module "tls" {
      * the `ciphers` option of `{@link createSecureContext}`.
      *
      * Not all supported ciphers are enabled by default. See
-     * [Modifying the default TLS cipher suite](https://nodejs.org/docs/latest-v22.x/api/tls.html#modifying-the-default-tls-cipher-suite).
+     * [Modifying the default TLS cipher suite](https://nodejs.org/docs/latest-v24.x/api/tls.html#modifying-the-default-tls-cipher-suite).
      *
      * Cipher names that start with `'tls_'` are for TLSv1.3, all the others are for
      * TLSv1.2 and below.

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

@@ -9,8 +9,8 @@
  * The available categories are:
  *
  * * `node`: An empty placeholder.
- * * `node.async_hooks`: Enables capture of detailed [`async_hooks`](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html) trace data.
- * The [`async_hooks`](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html) events have a unique `asyncId` and a special `triggerId` `triggerAsyncId` property.
+ * * `node.async_hooks`: Enables capture of detailed [`async_hooks`](https://nodejs.org/docs/latest-v24.x/api/async_hooks.html) trace data.
+ * The [`async_hooks`](https://nodejs.org/docs/latest-v24.x/api/async_hooks.html) events have a unique `asyncId` and a special `triggerId` `triggerAsyncId` property.
  * * `node.bootstrap`: Enables capture of Node.js bootstrap milestones.
  * * `node.console`: Enables capture of `console.time()` and `console.count()` output.
  * * `node.threadpoolwork.sync`: Enables capture of trace data for threadpool synchronous operations, such as `blob`, `zlib`, `crypto` and `node_api`.
@@ -22,7 +22,7 @@
  * * `node.fs_dir.sync`: Enables capture of trace data for file system sync directory methods.
  * * `node.fs.async`: Enables capture of trace data for file system async methods.
  * * `node.fs_dir.async`: Enables capture of trace data for file system async directory methods.
- * * `node.perf`: Enables capture of [Performance API](https://nodejs.org/docs/latest-v22.x/api/perf_hooks.html) measurements.
+ * * `node.perf`: Enables capture of [Performance API](https://nodejs.org/docs/latest-v24.x/api/perf_hooks.html) measurements.
  *    * `node.perf.usertiming`: Enables capture of only Performance API User Timing
  *    measures and marks.
  *    * `node.perf.timerify`: Enables capture of only Performance API timerify
@@ -30,7 +30,7 @@
  * * `node.promises.rejections`: Enables capture of trace data tracking the number
  * of unhandled Promise rejections and handled-after-rejections.
  * * `node.vm.script`: Enables capture of trace data for the `node:vm` module's `runInNewContext()`, `runInContext()`, and `runInThisContext()` methods.
- * * `v8`: The [V8](https://nodejs.org/docs/latest-v22.x/api/v8.html) events are GC, compiling, and execution related.
+ * * `v8`: The [V8](https://nodejs.org/docs/latest-v24.x/api/v8.html) events are GC, compiling, and execution related.
  * * `node.http`: Enables capture of trace data for http request / response.
  *
  * By default the `node`, `node.async_hooks`, and `v8` categories are enabled.
@@ -88,9 +88,9 @@
  * However the trace-event timestamps are expressed in microseconds,
  * unlike `process.hrtime()` which returns nanoseconds.
  *
- * The features from this module are not available in [`Worker`](https://nodejs.org/docs/latest-v22.x/api/worker_threads.html#class-worker) threads.
+ * The features from this module are not available in [`Worker`](https://nodejs.org/docs/latest-v24.x/api/worker_threads.html#class-worker) threads.
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/trace_events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/trace_events.js)
  */
 declare module "trace_events" {
     /**

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

@@ -0,0 +1,71 @@
+// 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/node_modules/@types/node/ts5.6/globals.typedarray.d.ts

@@ -12,6 +12,7 @@ declare global {
             | Int32Array
             | BigUint64Array
             | BigInt64Array
+            | Float16Array
             | Float32Array
             | Float64Array;
         type ArrayBufferView = TypedArray | DataView;

package/node_modules/@types/node/ts5.6/index.d.ts

@@ -22,20 +22,30 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support Node.js and TypeScript 4.9 through 5.6.
+// NOTE: These definitions support Node.js and TypeScript 5.2 through 5.6.
 
-// Reference required TypeScript libs:
+// Reference required TypeScript libraries:
 /// <reference lib="es2020" />
+/// <reference lib="esnext.disposable" />
 
-// TypeScript backwards-compatibility definitions:
-/// <reference path="../compatibility/index.d.ts" />
+// TypeScript library polyfills required for TypeScript <=5.6:
+/// <reference path="./compatibility/float16array.d.ts" />
 
-// Definitions specific to TypeScript 4.9 through 5.6:
+// Iterator definitions required for compatibility with TypeScript <5.6:
+/// <reference path="../compatibility/iterators.d.ts" />
+
+// Definitions for Node.js modules specific to TypeScript <=5.6:
 /// <reference path="./globals.typedarray.d.ts" />
 /// <reference path="./buffer.buffer.d.ts" />
 
 // Definitions for Node.js modules that are not specific to any version of TypeScript:
 /// <reference path="../globals.d.ts" />
+/// <reference path="../web-globals/abortcontroller.d.ts" />
+/// <reference path="../web-globals/domexception.d.ts" />
+/// <reference path="../web-globals/events.d.ts" />
+/// <reference path="../web-globals/fetch.d.ts" />
+/// <reference path="../web-globals/navigator.d.ts" />
+/// <reference path="../web-globals/storage.d.ts" />
 /// <reference path="../assert.d.ts" />
 /// <reference path="../assert/strict.d.ts" />
 /// <reference path="../async_hooks.d.ts" />
@@ -51,7 +61,6 @@
 /// <reference path="../dns/promises.d.ts" />
 /// <reference path="../dns/promises.d.ts" />
 /// <reference path="../domain.d.ts" />
-/// <reference path="../dom-events.d.ts" />
 /// <reference path="../events.d.ts" />
 /// <reference path="../fs.d.ts" />
 /// <reference path="../fs/promises.d.ts" />

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

@@ -0,0 +1,72 @@
+// 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;
+}

package/node_modules/@types/node/ts5.7/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * License for programmatically and manually incorporated
+ * documentation aka. `JSDoc` from https://github.com/nodejs/node/tree/master/doc
+ *
+ * Copyright Node.js contributors. All rights reserved.
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+// NOTE: These definitions support Node.js and TypeScript 5.7.
+
+// Reference required TypeScript libraries:
+/// <reference lib="es2020" />
+/// <reference lib="esnext.disposable" />
+
+// TypeScript library polyfills required for TypeScript 5.7:
+/// <reference path="./compatibility/float16array.d.ts" />
+
+// Iterator definitions required for compatibility with TypeScript <5.6:
+/// <reference path="../compatibility/iterators.d.ts" />
+
+// Definitions for Node.js modules specific to TypeScript 5.7+:
+/// <reference path="../globals.typedarray.d.ts" />
+/// <reference path="../buffer.buffer.d.ts" />
+
+// Definitions for Node.js modules that are not specific to any version of TypeScript:
+/// <reference path="../globals.d.ts" />
+/// <reference path="../web-globals/abortcontroller.d.ts" />
+/// <reference path="../web-globals/domexception.d.ts" />
+/// <reference path="../web-globals/events.d.ts" />
+/// <reference path="../web-globals/fetch.d.ts" />
+/// <reference path="../web-globals/navigator.d.ts" />
+/// <reference path="../web-globals/storage.d.ts" />
+/// <reference path="../assert.d.ts" />
+/// <reference path="../assert/strict.d.ts" />
+/// <reference path="../async_hooks.d.ts" />
+/// <reference path="../buffer.d.ts" />
+/// <reference path="../child_process.d.ts" />
+/// <reference path="../cluster.d.ts" />
+/// <reference path="../console.d.ts" />
+/// <reference path="../constants.d.ts" />
+/// <reference path="../crypto.d.ts" />
+/// <reference path="../dgram.d.ts" />
+/// <reference path="../diagnostics_channel.d.ts" />
+/// <reference path="../dns.d.ts" />
+/// <reference path="../dns/promises.d.ts" />
+/// <reference path="../dns/promises.d.ts" />
+/// <reference path="../domain.d.ts" />
+/// <reference path="../events.d.ts" />
+/// <reference path="../fs.d.ts" />
+/// <reference path="../fs/promises.d.ts" />
+/// <reference path="../http.d.ts" />
+/// <reference path="../http2.d.ts" />
+/// <reference path="../https.d.ts" />
+/// <reference path="../inspector.d.ts" />
+/// <reference path="../module.d.ts" />
+/// <reference path="../net.d.ts" />
+/// <reference path="../os.d.ts" />
+/// <reference path="../path.d.ts" />
+/// <reference path="../perf_hooks.d.ts" />
+/// <reference path="../process.d.ts" />
+/// <reference path="../punycode.d.ts" />
+/// <reference path="../querystring.d.ts" />
+/// <reference path="../readline.d.ts" />
+/// <reference path="../readline/promises.d.ts" />
+/// <reference path="../repl.d.ts" />
+/// <reference path="../sea.d.ts" />
+/// <reference path="../sqlite.d.ts" />
+/// <reference path="../stream.d.ts" />
+/// <reference path="../stream/promises.d.ts" />
+/// <reference path="../stream/consumers.d.ts" />
+/// <reference path="../stream/web.d.ts" />
+/// <reference path="../string_decoder.d.ts" />
+/// <reference path="../test.d.ts" />
+/// <reference path="../timers.d.ts" />
+/// <reference path="../timers/promises.d.ts" />
+/// <reference path="../tls.d.ts" />
+/// <reference path="../trace_events.d.ts" />
+/// <reference path="../tty.d.ts" />
+/// <reference path="../url.d.ts" />
+/// <reference path="../util.d.ts" />
+/// <reference path="../v8.d.ts" />
+/// <reference path="../vm.d.ts" />
+/// <reference path="../wasi.d.ts" />
+/// <reference path="../worker_threads.d.ts" />
+/// <reference path="../zlib.d.ts" />

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

@@ -21,7 +21,7 @@
  *
  * In most cases, there should be little to no reason for an application to
  * manually create instances of the `tty.ReadStream` and `tty.WriteStream` classes.
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/tty.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/tty.js)
  */
 declare module "tty" {
     import * as net from "node:net";

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

@@ -5,7 +5,7 @@
  * ```js
  * import url from 'node:url';
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/url.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/url.js)
  */
 declare module "url" {
     import { Blob as NodeBlob } from "node:buffer";
@@ -315,6 +315,17 @@ declare module "url" {
      * @return The fully-resolved platform-specific Node.js file path.
      */
     function fileURLToPath(url: string | URL, options?: FileUrlToPathOptions): string;
+    /**
+     * Like `url.fileURLToPath(...)` except that instead of returning a string
+     * representation of the path, a `Buffer` is returned. This conversion is
+     * helpful when the input URL contains percent-encoded segments that are
+     * not valid UTF-8 / Unicode sequences.
+     * @since v24.3.0
+     * @param url The file URL string or URL object to convert to a path.
+     * @returns The fully-resolved platform-specific Node.js file path
+     * as a `Buffer`.
+     */
+    function fileURLToPathBuffer(url: string | URL, options?: FileUrlToPathOptions): Buffer;
     /**
      * This function ensures that `path` is resolved absolutely, and that the URL
      * control characters are correctly encoded when converting into a File URL.
@@ -420,14 +431,12 @@ declare module "url" {
          * Threads, `Blob` objects registered within one Worker will not be available
          * to other workers or the main thread.
          * @since v16.7.0
-         * @experimental
          */
         static createObjectURL(blob: NodeBlob): string;
         /**
          * Removes the stored `Blob` identified by the given ID. Attempting to revoke a
          * ID that isn't registered will silently fail.
          * @since v16.7.0
-         * @experimental
          * @param id A `'blob:nodedata:...` URL string returned by a prior call to `URL.createObjectURL()`.
          */
         static revokeObjectURL(id: string): void;
@@ -757,6 +766,54 @@ declare module "url" {
          */
         toJSON(): string;
     }
+    interface URLPatternComponentResult {
+        input: string;
+        groups: Record<string, string | undefined>;
+    }
+    interface URLPatternInit {
+        protocol?: string;
+        username?: string;
+        password?: string;
+        hostname?: string;
+        port?: string;
+        pathname?: string;
+        search?: string;
+        hash?: string;
+        baseURL?: string;
+    }
+    interface URLPatternOptions {
+        ignoreCase?: boolean;
+    }
+    interface URLPatternResult {
+        inputs: (string | URLPatternInit)[];
+        protocol: URLPatternComponentResult;
+        username: URLPatternComponentResult;
+        password: URLPatternComponentResult;
+        hostname: URLPatternComponentResult;
+        port: URLPatternComponentResult;
+        pathname: URLPatternComponentResult;
+        search: URLPatternComponentResult;
+        hash: URLPatternComponentResult;
+    }
+    /**
+     * @since v23.8.0
+     * @experimental
+     */
+    class URLPattern {
+        constructor(input: string | URLPatternInit, baseURL: string, options?: URLPatternOptions);
+        constructor(input?: string | URLPatternInit, options?: URLPatternOptions);
+        exec(input?: string | URLPatternInit, baseURL?: string): URLPatternResult | null;
+        readonly hasRegExpGroups: boolean;
+        readonly hash: string;
+        readonly hostname: string;
+        readonly password: string;
+        readonly pathname: string;
+        readonly port: string;
+        readonly protocol: string;
+        readonly search: string;
+        test(input?: string | URLPatternInit, baseURL?: string): boolean;
+        readonly username: string;
+    }
     interface URLSearchParamsIterator<T> extends NodeJS.Iterator<T, NodeJS.BuiltinIteratorReturn, unknown> {
         [Symbol.iterator](): URLSearchParamsIterator<T>;
     }
@@ -828,7 +885,7 @@ declare module "url" {
          * Returns an ES6 `Iterator` over each of the name-value pairs in the query.
          * Each item of the iterator is a JavaScript `Array`. The first item of the `Array` is the `name`, the second item of the `Array` is the `value`.
          *
-         * Alias for `urlSearchParams[@@iterator]()`.
+         * Alias for `urlSearchParams[Symbol.iterator]()`.
          */
         entries(): URLSearchParamsIterator<[string, string]>;
         /**
@@ -937,34 +994,30 @@ declare module "url" {
         values(): URLSearchParamsIterator<string>;
         [Symbol.iterator](): URLSearchParamsIterator<[string, string]>;
     }
-    import { URL as _URL, URLSearchParams as _URLSearchParams } from "url";
+    import {
+        URL as _URL,
+        URLPattern as _URLPattern,
+        URLPatternInit as _URLPatternInit,
+        URLPatternResult as _URLPatternResult,
+        URLSearchParams as _URLSearchParams,
+    } from "url";
     global {
-        interface URLSearchParams extends _URLSearchParams {}
         interface URL extends _URL {}
-        interface Global {
-            URL: typeof _URL;
-            URLSearchParams: typeof _URLSearchParams;
-        }
-        /**
-         * `URL` class is a global reference for `import { URL } from 'url'`
-         * https://nodejs.org/api/url.html#the-whatwg-url-api
-         * @since v10.0.0
-         */
         var URL: typeof globalThis extends {
             onmessage: any;
             URL: infer T;
         } ? T
             : typeof _URL;
-        /**
-         * `URLSearchParams` class is a global reference for `import { URLSearchParams } from 'node:url'`
-         * https://nodejs.org/api/url.html#class-urlsearchparams
-         * @since v10.0.0
-         */
+        interface URLSearchParams extends _URLSearchParams {}
         var URLSearchParams: typeof globalThis extends {
             onmessage: any;
             URLSearchParams: infer T;
         } ? T
             : typeof _URLSearchParams;
+        interface URLPatternInit extends _URLPatternInit {}
+        interface URLPatternResult extends _URLPatternResult {}
+        interface URLPattern extends _URLPattern {}
+        var URLPattern: typeof _URLPattern;
     }
 }
 declare module "node:url" {