omegon 0.8.4 → 0.9.1

package/node_modules/@types/node/assert/strict.d.ts

@@ -40,11 +40,11 @@
  * To deactivate the colors, use the `NO_COLOR` or `NODE_DISABLE_COLORS`
  * environment variables. This will also deactivate the colors in the REPL. For
  * more on color support in terminal environments, read the tty
- * [`getColorDepth()`](https://nodejs.org/docs/latest-v25.x/api/tty.html#writestreamgetcolordepthenv) documentation.
+ * [`getColorDepth()`](https://nodejs.org/docs/latest-v22.x/api/tty.html#writestreamgetcolordepthenv) documentation.
  * @since v15.0.0
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/assert/strict.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/assert/strict.js)
  */
-declare module "node:assert/strict" {
+declare module "assert/strict" {
     import {
         Assert,
         AssertionError,
@@ -52,6 +52,9 @@ declare module "node:assert/strict" {
         AssertOptions,
         AssertPredicate,
         AssertStrict,
+        CallTracker,
+        CallTrackerCall,
+        CallTrackerReportInformation,
         deepStrictEqual,
         doesNotMatch,
         doesNotReject,
@@ -76,6 +79,9 @@ declare module "node:assert/strict" {
             AssertOptions,
             AssertPredicate,
             AssertStrict,
+            CallTracker,
+            CallTrackerCall,
+            CallTrackerReportInformation,
             deepStrictEqual,
             deepStrictEqual as deepEqual,
             doesNotMatch,
@@ -99,7 +105,7 @@ declare module "node:assert/strict" {
     }
     export = strict;
 }
-declare module "assert/strict" {
-    import strict = require("node:assert/strict");
+declare module "node:assert/strict" {
+    import strict = require("assert/strict");
     export = strict;
 }

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

@@ -1,10 +1,10 @@
 /**
  * The `node:assert` module provides a set of assertion functions for verifying
  * invariants.
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/assert.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/assert.js)
  */
-declare module "node:assert" {
-    import strict = require("node:assert/strict");
+declare module "assert" {
+    import strict = require("assert/strict");
     /**
      * An alias of {@link assert.ok}.
      * @since v0.5.9
@@ -44,13 +44,6 @@ declare module "node:assert" {
              * @default true
              */
             strict?: boolean | undefined;
-            /**
-             * If set to `true`, skips prototype and constructor
-             * comparison in deep equality checks.
-             * @since v24.9.0
-             * @default false
-             */
-            skipPrototype?: boolean | undefined;
         }
         interface Assert extends Pick<typeof assert, AssertMethodNames> {
             readonly [kOptions]: AssertOptions & { strict: false };
@@ -60,7 +53,7 @@ declare module "node:assert" {
         }
         /**
          * The `Assert` class allows creating independent assertion instances with custom options.
-         * @since v24.6.0
+         * @since v22.19.0
          */
         var Assert: {
             /**
@@ -74,8 +67,7 @@ declare module "node:assert" {
              * ```
              *
              * **Important**: When destructuring assertion methods from an `Assert` instance,
-             * the methods lose their connection to the instance's configuration options (such
-             * as `diff`, `strict`, and `skipPrototype` settings).
+             * the methods lose their connection to the instance's configuration options (such as `diff` and `strict` settings).
              * The destructured methods will fall back to default behavior instead.
              *
              * ```js
@@ -89,41 +81,14 @@ declare module "node:assert" {
              * strictEqual({ a: 1 }, { b: { c: 1 } });
              * ```
              *
-             * The `skipPrototype` option affects all deep equality methods:
-             *
-             * ```js
-             * class Foo {
-             *   constructor(a) {
-             *     this.a = a;
-             *   }
-             * }
-             *
-             * class Bar {
-             *   constructor(a) {
-             *     this.a = a;
-             *   }
-             * }
-             *
-             * const foo = new Foo(1);
-             * const bar = new Bar(1);
-             *
-             * // Default behavior - fails due to different constructors
-             * const assert1 = new Assert();
-             * assert1.deepStrictEqual(foo, bar); // AssertionError
-             *
-             * // Skip prototype comparison - passes if properties are equal
-             * const assert2 = new Assert({ skipPrototype: true });
-             * assert2.deepStrictEqual(foo, bar); // OK
-             * ```
-             *
              * When destructured, methods lose access to the instance's `this` context and revert to default assertion behavior
              * (diff: 'simple', non-strict mode).
              * To maintain custom options when using destructured methods, avoid
              * destructuring and call methods directly on the instance.
-             * @since v24.6.0
+             * @since v22.19.0
              */
             new(
-                options?: AssertOptions & { strict?: true | undefined },
+                options?: AssertOptions & { strict?: true },
             ): AssertStrict;
             new(
                 options: AssertOptions,
@@ -182,6 +147,152 @@ declare module "node:assert" {
              */
             operator: string;
         }
+        /**
+         * This feature is deprecated and will be removed in a future version.
+         * Please consider using alternatives such as the `mock` helper function.
+         * @since v14.2.0, v12.19.0
+         * @deprecated Deprecated
+         */
+        class CallTracker {
+            /**
+             * The wrapper function is expected to be called exactly `exact` times. If the
+             * function has not been called exactly `exact` times when `tracker.verify()` is called, then `tracker.verify()` will throw an
+             * error.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * // Creates call tracker.
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             *
+             * // Returns a function that wraps func() that must be called exact times
+             * // before tracker.verify().
+             * const callsfunc = tracker.calls(func);
+             * ```
+             * @since v14.2.0, v12.19.0
+             * @param [fn='A no-op function']
+             * @param [exact=1]
+             * @return A function that wraps `fn`.
+             */
+            calls(exact?: number): () => void;
+            calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
+            /**
+             * Example:
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             * const callsfunc = tracker.calls(func);
+             * callsfunc(1, 2, 3);
+             *
+             * assert.deepStrictEqual(tracker.getCalls(callsfunc),
+             *                        [{ thisArg: undefined, arguments: [1, 2, 3] }]);
+             * ```
+             * @since v18.8.0, v16.18.0
+             * @return An array with all the calls to a tracked function.
+             */
+            getCalls(fn: Function): CallTrackerCall[];
+            /**
+             * The arrays contains information about the expected and actual number of calls of
+             * the functions that have not been called the expected number of times.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * // Creates call tracker.
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             *
+             * // Returns a function that wraps func() that must be called exact times
+             * // before tracker.verify().
+             * const callsfunc = tracker.calls(func, 2);
+             *
+             * // Returns an array containing information on callsfunc()
+             * console.log(tracker.report());
+             * // [
+             * //  {
+             * //    message: 'Expected the func function to be executed 2 time(s) but was
+             * //    executed 0 time(s).',
+             * //    actual: 0,
+             * //    expected: 2,
+             * //    operator: 'func',
+             * //    stack: stack trace
+             * //  }
+             * // ]
+             * ```
+             * @since v14.2.0, v12.19.0
+             * @return An array of objects containing information about the wrapper functions returned by {@link tracker.calls()}.
+             */
+            report(): CallTrackerReportInformation[];
+            /**
+             * Reset calls of the call tracker. If a tracked function is passed as an argument, the calls will be reset for it.
+             * If no arguments are passed, all tracked functions will be reset.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             * const callsfunc = tracker.calls(func);
+             *
+             * callsfunc();
+             * // Tracker was called once
+             * assert.strictEqual(tracker.getCalls(callsfunc).length, 1);
+             *
+             * tracker.reset(callsfunc);
+             * assert.strictEqual(tracker.getCalls(callsfunc).length, 0);
+             * ```
+             * @since v18.8.0, v16.18.0
+             * @param fn a tracked function to reset.
+             */
+            reset(fn?: Function): void;
+            /**
+             * Iterates through the list of functions passed to {@link tracker.calls()} and will throw an error for functions that
+             * have not been called the expected number of times.
+             *
+             * ```js
+             * import assert from 'node:assert';
+             *
+             * // Creates call tracker.
+             * const tracker = new assert.CallTracker();
+             *
+             * function func() {}
+             *
+             * // Returns a function that wraps func() that must be called exact times
+             * // before tracker.verify().
+             * const callsfunc = tracker.calls(func, 2);
+             *
+             * callsfunc();
+             *
+             * // Will throw an error since callsfunc() was only called once.
+             * tracker.verify();
+             * ```
+             * @since v14.2.0, v12.19.0
+             */
+            verify(): void;
+        }
+        interface CallTrackerCall {
+            thisArg: object;
+            arguments: unknown[];
+        }
+        interface CallTrackerReportInformation {
+            message: string;
+            /** The actual number of times the function was called. */
+            actual: number;
+            /** The number of times the function was expected to be called. */
+            expected: number;
+            /** The name of the function that is wrapped. */
+            operator: string;
+            /** A stack trace of the function. */
+            stack: object;
+        }
         type AssertPredicate = RegExp | (new() => object) | ((thrown: unknown) => boolean) | object | Error;
         /**
          * Throws an `AssertionError` with the provided error message or a default
@@ -200,10 +311,22 @@ declare module "node:assert" {
          * assert.fail(new TypeError('need array'));
          * // TypeError: need array
          * ```
+         *
+         * Using `assert.fail()` with more than two arguments is possible but deprecated.
+         * See below for further details.
          * @since v0.1.21
          * @param [message='Failed']
          */
         function fail(message?: string | Error): never;
+        /** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
+        function fail(
+            actual: unknown,
+            expected: unknown,
+            message?: string | Error,
+            operator?: string,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+            stackStartFn?: Function,
+        ): never;
         /**
          * Tests if `value` is truthy. It is equivalent to `assert.equal(!!value, true, message)`.
          *
@@ -253,10 +376,10 @@ declare module "node:assert" {
          * import assert from 'node:assert/strict';
          *
          * // Using `assert()` works the same:
-         * assert(2 + 2 > 5);;
+         * assert(0);
          * // AssertionError: The expression evaluated to a falsy value:
          * //
-         * //   assert(2 + 2 > 5)
+         * //   assert(0)
          * ```
          * @since v0.1.21
          */
@@ -771,7 +894,7 @@ declare module "node:assert" {
          * check that the promise is rejected.
          *
          * If `asyncFn` is a function and it throws an error synchronously, `assert.rejects()` will return a rejected `Promise` with that error. If the
-         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v25.x/api/errors.html#err_invalid_return_value)
+         * function does not return a promise, `assert.rejects()` will return a rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v22.x/api/errors.html#err_invalid_return_value)
          * error. In both cases the error handler is skipped.
          *
          * Besides the async nature to await the completion behaves identically to {@link throws}.
@@ -841,7 +964,7 @@ declare module "node:assert" {
          *
          * If `asyncFn` is a function and it throws an error synchronously, `assert.doesNotReject()` will return a rejected `Promise` with that error. If
          * the function does not return a promise, `assert.doesNotReject()` will return a
-         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v25.x/api/errors.html#err_invalid_return_value) error. In both cases
+         * rejected `Promise` with an [ERR_INVALID_RETURN_VALUE](https://nodejs.org/docs/latest-v22.x/api/errors.html#err_invalid_return_value) error. In both cases
          * the error handler is skipped.
          *
          * Using `assert.doesNotReject()` is actually not useful because there is little
@@ -904,7 +1027,7 @@ declare module "node:assert" {
          * If the values do not match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an [Error](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
         function match(value: string, regExp: RegExp, message?: string | Error): void;
@@ -927,7 +1050,7 @@ declare module "node:assert" {
          * If the values do match, or if the `string` argument is of another type than `string`, an `{@link AssertionError}` is thrown with a `message` property set equal
          * to the value of the `message` parameter. If the `message` parameter is
          * undefined, a default error message is assigned. If the `message` parameter is an
-         * instance of an [Error](https://nodejs.org/docs/latest-v25.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
+         * instance of an [Error](https://nodejs.org/docs/latest-v22.x/api/errors.html#class-error) then it will be thrown instead of the `{@link AssertionError}`.
          * @since v13.6.0, v12.16.0
          */
         function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
@@ -949,7 +1072,7 @@ declare module "node:assert" {
     }
     export = assert;
 }
-declare module "assert" {
-    import assert = require("node:assert");
+declare module "node:assert" {
+    import assert = require("assert");
     export = assert;
 }

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

@@ -2,8 +2,8 @@
  * We strongly discourage the use of the `async_hooks` API.
  * Other APIs that can cover most of its use cases include:
  *
- * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v25.x/api/async_context.html#class-asynclocalstorage) tracks async context
- * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v25.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
+ * * [`AsyncLocalStorage`](https://nodejs.org/docs/latest-v22.x/api/async_context.html#class-asynclocalstorage) tracks async context
+ * * [`process.getActiveResourcesInfo()`](https://nodejs.org/docs/latest-v22.x/api/process.html#processgetactiveresourcesinfo) tracks active resources
  *
  * The `node:async_hooks` module provides an API to track asynchronous resources.
  * It can be accessed using:
@@ -12,9 +12,9 @@
  * import async_hooks from 'node:async_hooks';
  * ```
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/async_hooks.js)
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/async_hooks.js)
  */
-declare module "node:async_hooks" {
+declare module "async_hooks" {
     /**
      * ```js
      * import { executionAsyncId } from 'node:async_hooks';
@@ -44,7 +44,7 @@ declare module "node:async_hooks" {
      * ```
      *
      * Promise contexts may not get precise `executionAsyncIds` by default.
-     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promise-execution-tracking).
+     * See the section on [promise execution tracking](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html#promise-execution-tracking).
      * @since v8.1.0
      * @return The `asyncId` of the current execution context. Useful to track when something calls.
      */
@@ -117,7 +117,7 @@ declare module "node:async_hooks" {
      * ```
      *
      * Promise contexts may not get valid `triggerAsyncId`s by default. See
-     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v25.x/api/async_hooks.html#promise-execution-tracking).
+     * the section on [promise execution tracking](https://nodejs.org/docs/latest-v22.x/api/async_hooks.html#promise-execution-tracking).
      * @return The ID of the resource responsible for calling the callback that is currently being executed.
      */
     function triggerAsyncId(): number;
@@ -320,16 +320,6 @@ declare module "node:async_hooks" {
          */
         triggerAsyncId(): number;
     }
-    interface AsyncLocalStorageOptions {
-        /**
-         * The default value to be used when no store is provided.
-         */
-        defaultValue?: any;
-        /**
-         * A name for the `AsyncLocalStorage` value.
-         */
-        name?: string | undefined;
-    }
     /**
      * This class creates stores that stay coherent through asynchronous operations.
      *
@@ -379,11 +369,6 @@ declare module "node:async_hooks" {
      * @since v13.10.0, v12.17.0
      */
     class AsyncLocalStorage<T> {
-        /**
-         * Creates a new instance of `AsyncLocalStorage`. Store is only provided within a
-         * `run()` call or after an `enterWith()` call.
-         */
-        constructor(options?: AsyncLocalStorageOptions);
         /**
          * Binds the given function to the current execution context.
          * @since v19.8.0
@@ -445,11 +430,6 @@ declare module "node:async_hooks" {
          * @since v13.10.0, v12.17.0
          */
         getStore(): T | undefined;
-        /**
-         * The name of the `AsyncLocalStorage` instance if provided.
-         * @since v24.0.0
-         */
-        readonly name: string;
         /**
          * Runs a function synchronously within a context and returns its
          * return value. The store is not accessible outside of the callback function.
@@ -618,6 +598,6 @@ declare module "node:async_hooks" {
         const VERIFYREQUEST: number;
     }
 }
-declare module "async_hooks" {
-    export * from "node:async_hooks";
+declare module "node:async_hooks" {
+    export * from "async_hooks";
 }

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

@@ -1,4 +1,4 @@
-declare module "node:buffer" {
+declare module "buffer" {
     type ImplicitArrayBuffer<T extends WithImplicitCoercion<ArrayBufferLike>> = T extends
         { valueOf(): infer V extends ArrayBufferLike } ? V : T;
     global {
@@ -463,4 +463,10 @@ declare module "node:buffer" {
          */
         type AllowSharedBuffer = Buffer<ArrayBufferLike>;
     }
+    /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+    var SlowBuffer: {
+        /** @deprecated Use `Buffer.allocUnsafeSlow()` instead. */
+        new(size: number): Buffer<ArrayBuffer>;
+        prototype: Buffer;
+    };
 }