@effectionx/worker 0.1.2 → 0.3.0

package/esm/worker-main.js

@@ -0,0 +1,186 @@
+import { createSignal, each, Err, main, Ok, on, resource, spawn, } from "effection";
+/**
+ * Entrypoint used in the worker that estaliblishes communication
+ * with the main thread. It can be used to return a value,
+ * respond to messages or both.
+ *
+ * @example Returning a value
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain(function* ({ data }) {
+ *  return data;
+ * });
+ * ```
+ *
+ * @example Responding to messages
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain(function* ({ messages }) {
+ *  yield* messages.forEach(function* (message) {
+ *    return message;
+ *  });
+ * });
+ * ```
+ *
+ * @example Responding to messages and return a value
+ * ```ts
+ * import { workerMain } from "../worker.ts";
+ *
+ * await workerMain<number, number, number, number>(
+ *   function* ({ messages, data: initial }) {
+ *     let counter = initial;
+ *
+ *     yield* messages.forEach(function* (message) {
+ *       counter += message;
+ *       return counter; // returns a value after each message
+ *     });
+ *
+ *     return counter; // returns the final value
+ *   },
+ * );
+ * ```
+ *
+ * @template TSend - value main thread will send to the worker
+ * @template TRecv - value main thread will receive from the worker
+ * @template TReturn - worker operation return value
+ * @template TData - data passed from the main thread to the worker during initialization
+ * @param {(options: WorkerMainOptions<TSend, TRecv, TData>) => Operation<TReturn>} body
+ * @returns {Promise<void>}
+ */
+export async function workerMain(body) {
+    await main(function* () {
+        let sent = createSignal();
+        let worker = yield* createWorkerStatesSignal();
+        yield* spawn(function* () {
+            for (const message of yield* each(on(self, "message"))) {
+                const control = message.data;
+                switch (control.type) {
+                    case "init": {
+                        worker.start(yield* spawn(function* () {
+                            try {
+                                let value = yield* body({
+                                    data: control.data,
+                                    messages: {
+                                        *forEach(fn) {
+                                            for (let { value, response } of yield* each(sent)) {
+                                                yield* spawn(function* () {
+                                                    try {
+                                                        let result = yield* fn(value);
+                                                        response.postMessage(Ok(result));
+                                                    }
+                                                    catch (error) {
+                                                        response.postMessage(Err(error));
+                                                    }
+                                                });
+                                                yield* each.next();
+                                            }
+                                        },
+                                    },
+                                });
+                                worker.complete(value);
+                            }
+                            catch (error) {
+                                worker.crash(error);
+                            }
+                        }));
+                        break;
+                    }
+                    case "send": {
+                        let { value, response } = control;
+                        sent.send({ value, response });
+                        break;
+                    }
+                    case "close": {
+                        const current = worker.valueOf();
+                        if (current.type === "running") {
+                            yield* current.task.halt();
+                            worker.interrupt();
+                        }
+                    }
+                }
+                yield* each.next();
+            }
+        });
+        for (const state of yield* each(worker)) {
+            if (state.type === "new") {
+                postMessage({ type: "open" });
+            }
+            else if (state.type === "interrupted" || state.type === "error") {
+                postMessage({ type: "close", result: Err(state.error) });
+            }
+            else if (state.type === "complete") {
+                postMessage({ type: "close", result: Ok(state.value) });
+            }
+            yield* each.next();
+        }
+    });
+}
+export function createWorkerStatesSignal() {
+    return resource(function* (provide) {
+        let ref = {
+            current: { type: "new" },
+        };
+        const signal = createSignal();
+        const set = (value) => {
+            signal.send(ref.current = value);
+            return value;
+        };
+        const update = (updater) => set(updater(ref.current));
+        const interrupt = () => {
+            let next = {
+                type: "interrupted",
+                error: new Error(`worker terminated`),
+            };
+            set(next);
+            return next;
+        };
+        try {
+            yield* provide({
+                *[Symbol.iterator]() {
+                    let subscription = yield* signal;
+                    signal.send(ref.current);
+                    return subscription;
+                },
+                get state() {
+                    return ref.current.type;
+                },
+                set,
+                update,
+                valueOf() {
+                    return ref.current;
+                },
+                start(task) {
+                    if (ref.current.type === "complete") {
+                        return ref.current;
+                    }
+                    else {
+                        const next = { type: "running", task };
+                        set(next);
+                        return next;
+                    }
+                },
+                complete(value) {
+                    let next = { type: "complete", value };
+                    set(next);
+                    return next;
+                },
+                crash(error) {
+                    let next = { type: "error", error };
+                    set(next);
+                    return next;
+                },
+                interrupt: interrupt,
+            });
+        }
+        finally {
+            if (ref.current.type === "running") {
+                interrupt();
+            }
+        }
+    });
+}
+function postMessage(message) {
+    self.postMessage(message);
+}

package/esm/worker.d.ts

@@ -1,18 +1,4 @@
 import { type Operation } from "effection";
-export interface WorkerResource<TSend, TRecv, TReturn> extends Operation<TReturn> {
-    send(data: TSend): Operation<TRecv>;
-}
-/**
- * Object that represents messages the main thread
- * sends to the worker. It provides function for
- * handling messages.
- *
- * @template TSend - value main thread will send to the worker
- * @template TRecv - value main thread will receive from the worker
- */
-export interface WorkerMessages<TSend, TRecv> {
-    forEach(fn: (message: TSend) => Operation<TRecv>): Operation<void>;
-}
 /**
  * Argument received by workerMain function
  *
@@ -20,67 +6,9 @@ export interface WorkerMessages<TSend, TRecv> {
  * @template TRecv - value main thread will receive from the worker
  * @template TData - data passed from the main thread to the worker during initialization
  */
-export interface WorkerMainOptions<TSend, TRecv, TData> {
-    /**
-     * Namespace that provides APIs for working with incoming messages
-     */
-    messages: WorkerMessages<TSend, TRecv>;
-    /**
-     * Initial data received by the worker from the main thread used for initialization.
-     */
-    data: TData;
+export interface WorkerResource<TSend, TRecv, TReturn> extends Operation<TReturn> {
+    send(data: TSend): Operation<TRecv>;
 }
-/**
- * Entrypoint used in the worker that estaliblishes communication
- * with the main thread. It can be used to return a value,
- * respond to messages or both.
- *
- * @example Returning a value
- * ```ts
- * import { workerMain } from "../worker.ts";
- *
- * await workerMain(function* ({ data }) {
- *  return data;
- * });
- * ```
- *
- * @example Responding to messages
- * ```ts
- * import { workerMain } from "../worker.ts";
- *
- * await workerMain(function* ({ messages }) {
- *  yield* messages.forEach(function* (message) {
- *    return message;
- *  });
- * });
- * ```
- *
- * @example Responding to messages and return a value
- * ```ts
- * import { workerMain } from "../worker.ts";
- *
- * await workerMain<number, number, number, number>(
- *   function* ({ messages, data: initial }) {
- *     let counter = initial;
- *
- *     yield* messages.forEach(function* (message) {
- *       counter += message;
- *       return counter; // returns a value after each message
- *     });
- *
- *     return counter; // returns the final value
- *   },
- * );
- * ```
- *
- * @template TSend - value main thread will send to the worker
- * @template TRecv - value main thread will receive from the worker
- * @template TReturn - worker operation return value
- * @template TData - data passed from the main thread to the worker during initialization
- * @param {(options: WorkerMainOptions<TSend, TRecv, TData>) => Operation<TReturn>} body
- * @returns {Promise<void>}
- */
-export declare function workerMain<TSend, TRecv, TReturn, TData>(body: (options: WorkerMainOptions<TSend, TRecv, TData>) => Operation<TReturn>): Promise<void>;
 /**
  * Use on the main thread to create and exeecute a well behaved web worker.
  *

package/esm/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AACA,OAAO,EAQL,KAAK,SAAS,EAMf,MAAM,WAAW,CAAC;AAEnB,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CACnD,SAAQ,SAAS,CAAC,OAAO,CAAC;IAC1B,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,KAAK;IAC1C,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,KAAK,SAAS,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;CACpE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK;IACpD;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACvC;;OAEG;IACH,IAAI,EAAE,KAAK,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAC3D,IAAI,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,SAAS,CAAC,OAAO,CAAC,GAC5E,OAAO,CAAC,IAAI,CAAC,CAsDf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EACpD,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,OAAO,CAAC,EAAE,aAAa,GAAG;IAAE,IAAI,CAAC,EAAE,KAAK,CAAA;CAAE,GACzC,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAgElD"}
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,SAAS,EAKf,MAAM,WAAW,CAAC;AAInB;;;;;;GAMG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CACnD,SAAQ,SAAS,CAAC,OAAO,CAAC;IAC1B,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EACpD,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,OAAO,CAAC,EAAE,aAAa,GAAG;IAAE,IAAI,CAAC,EAAE,KAAK,CAAA;CAAE,GACzC,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAgElD"}

package/esm/worker.js

@@ -1,110 +1,6 @@
-import { assert } from "@std/assert";
-import { createSignal, each, Err, main, Ok, on, once, resource, scoped, spawn, withResolvers, } from "effection";
-/**
- * Entrypoint used in the worker that estaliblishes communication
- * with the main thread. It can be used to return a value,
- * respond to messages or both.
- *
- * @example Returning a value
- * ```ts
- * import { workerMain } from "../worker.ts";
- *
- * await workerMain(function* ({ data }) {
- *  return data;
- * });
- * ```
- *
- * @example Responding to messages
- * ```ts
- * import { workerMain } from "../worker.ts";
- *
- * await workerMain(function* ({ messages }) {
- *  yield* messages.forEach(function* (message) {
- *    return message;
- *  });
- * });
- * ```
- *
- * @example Responding to messages and return a value
- * ```ts
- * import { workerMain } from "../worker.ts";
- *
- * await workerMain<number, number, number, number>(
- *   function* ({ messages, data: initial }) {
- *     let counter = initial;
- *
- *     yield* messages.forEach(function* (message) {
- *       counter += message;
- *       return counter; // returns a value after each message
- *     });
- *
- *     return counter; // returns the final value
- *   },
- * );
- * ```
- *
- * @template TSend - value main thread will send to the worker
- * @template TRecv - value main thread will receive from the worker
- * @template TReturn - worker operation return value
- * @template TData - data passed from the main thread to the worker during initialization
- * @param {(options: WorkerMainOptions<TSend, TRecv, TData>) => Operation<TReturn>} body
- * @returns {Promise<void>}
- */
-export async function workerMain(body) {
-    await main(function* () {
-        let sent = createSignal();
-        let controls = yield* on(self, "message");
-        let outcome = withResolvers();
-        self.postMessage({ type: "open" });
-        let result = yield* scoped(function* () {
-            yield* spawn(function* () {
-                let next = yield* controls.next();
-                while (true) {
-                    let control = next.value.data;
-                    if (control.type === "init") {
-                        yield* spawn(function* () {
-                            try {
-                                let value = yield* body({
-                                    data: control.data,
-                                    messages: {
-                                        *forEach(fn) {
-                                            for (let { value, response } of yield* each(sent)) {
-                                                yield* spawn(function* () {
-                                                    try {
-                                                        let result = yield* fn(value);
-                                                        response.postMessage(Ok(result));
-                                                    }
-                                                    catch (error) {
-                                                        response.postMessage(Err(error));
-                                                    }
-                                                });
-                                                yield* each.next();
-                                            }
-                                        },
-                                    },
-                                });
-                                outcome.resolve(Ok(value));
-                            }
-                            catch (error) {
-                                outcome.resolve(Err(error));
-                            }
-                        });
-                    }
-                    else if (control.type === "send") {
-                        let { value, response } = control;
-                        sent.send({ value, response });
-                    }
-                    else if (control.type === "close") {
-                        outcome.resolve(Err(new Error(`worker terminated`)));
-                    }
-                    next = yield* controls.next();
-                }
-            });
-            return yield* outcome.operation;
-        });
-        self.postMessage({ type: "close", result });
-    });
-}
+import { assert } from "./deps/jsr.io/@std/assert/1.0.16/mod.js";
+import { Err, Ok, on, once, resource, spawn, withResolvers, } from "effection";
+import { useMessageChannel } from "./message-channel.js";
 /**
  * Use on the main thread to create and exeecute a well behaved web worker.
  *
@@ -210,24 +106,12 @@ export function useWorker(url, options) {
         }
     });
 }
-function useMessageChannel() {
-    return resource(function* (provide) {
-        let channel = new MessageChannel();
-        try {
-            yield* provide(channel);
-        }
-        finally {
-            channel.port1.close();
-            channel.port2.close();
-        }
-    });
-}
 function settled(operation) {
     return {
         *[Symbol.iterator]() {
             try {
                 yield* operation;
-                return Ok();
+                return Ok(void 0);
             }
             catch (error) {
                 return Err(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effectionx/worker",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "author": "engineering@frontside.com",
   "repository": {
     "type": "git",
@@ -18,9 +18,14 @@
       "require": "./script/mod.js"
     }
   },
+  "scripts": {},
   "engines": {
     "node": ">= 16"
   },
   "sideEffects": false,
+  "dependencies": {
+    "@effectionx/signals": "0.3.0",
+    "effection": "^3 || ^4.0.0-0"
+  },
   "_generatedBy": "dnt@dev"
 }

package/script/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = void 0;
+const dntGlobals = {};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/deps/jsr.io/@std/assert/1.0.16/almost_equals.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers
+ * through a given tolerance. It can be used to take into account IEEE-754
+ * double-precision floating-point representation limitations. If the values
+ * are not almost equal then throw.
+ *
+ * The default tolerance is one hundred thousandth of a percent of the
+ * expected value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertAlmostEquals } from "@std/assert";
+ *
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(1e-8, 1e-9); // Throws
+ * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ *
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param tolerance The tolerance to consider the values almost equal. The
+ * default is one hundred thousandth of a percent of the expected value.
+ * @param msg The optional message to include in the error.
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+//# sourceMappingURL=almost_equals.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.16/almost_equals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"almost_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/almost_equals.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,GAAG,CAAC,EAAE,MAAM,QAmBb"}

package/script/deps/jsr.io/@std/assert/1.0.16/almost_equals.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertAlmostEquals = assertAlmostEquals;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers
+ * through a given tolerance. It can be used to take into account IEEE-754
+ * double-precision floating-point representation limitations. If the values
+ * are not almost equal then throw.
+ *
+ * The default tolerance is one hundred thousandth of a percent of the
+ * expected value.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertAlmostEquals } from "@std/assert";
+ *
+ * assertAlmostEquals(0.01, 0.02); // Throws
+ * assertAlmostEquals(1e-8, 1e-9); // Throws
+ * assertAlmostEquals(1.000000001e-8, 1.000000002e-8); // Doesn't throw
+ * assertAlmostEquals(0.01, 0.02, 0.1); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16); // Doesn't throw
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17); // Throws
+ * ```
+ *
+ * @param actual The actual value to compare.
+ * @param expected The expected value to compare.
+ * @param tolerance The tolerance to consider the values almost equal. The
+ * default is one hundred thousandth of a percent of the expected value.
+ * @param msg The optional message to include in the error.
+ */
+function assertAlmostEquals(actual, expected, tolerance, msg) {
+    if (Object.is(actual, expected)) {
+        return;
+    }
+    const delta = Math.abs(expected - actual);
+    if (tolerance === undefined) {
+        tolerance = isFinite(expected) ? Math.abs(expected * 1e-7) : 1e-7;
+    }
+    if (delta <= tolerance) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    const f = (n) => Number.isInteger(n) ? n : n.toExponential();
+    throw new assertion_error_js_1.AssertionError(`Expected actual: "${f(actual)}" to be close to "${f(expected)}": \
+delta "${f(delta)}" is greater than "${f(tolerance)}"${msgSuffix}`);
+}

package/script/deps/jsr.io/@std/assert/1.0.16/array_includes.d.ts

@@ -0,0 +1,24 @@
+/** An array-like object (`Array`, `Uint8Array`, `NodeList`, etc.) that is not a string */
+export type ArrayLikeArg<T> = ArrayLike<T> & object;
+/**
+ * Make an assertion that `actual` includes the `expected` values. If not then
+ * an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ *
+ * @typeParam T The type of the elements in the array to compare.
+ * @param actual The array-like object to check for.
+ * @param expected The array-like object to check for.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export declare function assertArrayIncludes<T>(actual: ArrayLikeArg<T>, expected: ArrayLikeArg<T>, msg?: string): void;
+//# sourceMappingURL=array_includes.d.ts.map

package/script/deps/jsr.io/@std/assert/1.0.16/array_includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_includes.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/array_includes.ts"],"names":[],"mappings":"AAMA,0FAA0F;AAC1F,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,EACzB,GAAG,CAAC,EAAE,MAAM,QAwBb"}

package/script/deps/jsr.io/@std/assert/1.0.16/array_includes.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArrayIncludes = assertArrayIncludes;
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const equal_js_1 = require("./equal.js");
+const format_js_1 = require("../../internal/1.0.12/format.js");
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion that `actual` includes the `expected` values. If not then
+ * an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the
+ * same type.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertArrayIncludes } from "@std/assert";
+ *
+ * assertArrayIncludes([1, 2], [2]); // Doesn't throw
+ * assertArrayIncludes([1, 2], [3]); // Throws
+ * ```
+ *
+ * @typeParam T The type of the elements in the array to compare.
+ * @param actual The array-like object to check for.
+ * @param expected The array-like object to check for.
+ * @param msg The optional message to display if the assertion fails.
+ */
+function assertArrayIncludes(actual, expected, msg) {
+    const missing = [];
+    for (let i = 0; i < expected.length; i++) {
+        let found = false;
+        for (let j = 0; j < actual.length; j++) {
+            if ((0, equal_js_1.equal)(expected[i], actual[j])) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            missing.push(expected[i]);
+        }
+    }
+    if (missing.length === 0) {
+        return;
+    }
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${(0, format_js_1.format)(actual)}" to include: "${(0, format_js_1.format)(expected)}"${msgSuffix}\nmissing: ${(0, format_js_1.format)(missing)}`;
+    throw new assertion_error_js_1.AssertionError(msg);
+}