@effectionx/worker 0.2.0 → 0.3.0

package/esm/worker-main.d.ts

@@ -0,0 +1,84 @@
+import type { ValueSignal } from "@effectionx/signals";
+import { type Operation, type Task } from "effection";
+import type { WorkerMainOptions } from "./types.js";
+/**
+ * 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>;
+type New = {
+    type: "new";
+};
+type Running = {
+    type: "running";
+    task: Task<void>;
+};
+type Complete = {
+    type: "complete";
+    value: unknown;
+};
+type Errored = {
+    type: "error";
+    error: Error;
+};
+type Interrupted = {
+    type: "interrupted";
+    error: Error;
+};
+type WorkerState = New | Running | Complete | Errored | Interrupted;
+interface WorkerStateSignal extends ValueSignal<WorkerState> {
+    state: WorkerState["type"];
+    start(task: Task<void>): Running | Complete;
+    complete(value: unknown): Complete;
+    crash(error: Error): Errored;
+    interrupt(): Interrupted;
+}
+export declare function createWorkerStatesSignal(): Operation<WorkerStateSignal>;
+export {};
+//# sourceMappingURL=worker-main.d.ts.map

package/esm/worker-main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-main.d.ts","sourceRoot":"","sources":["../src/worker-main.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAOL,KAAK,SAAS,EAGd,KAAK,IAAI,EACV,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAiB,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,CAqEf;AAED,KAAK,GAAG,GAAG;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAC3B,KAAK,OAAO,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC;AACrD,KAAK,QAAQ,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AACrD,KAAK,OAAO,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAC/C,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC;AAEzD,KAAK,WAAW,GAAG,GAAG,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC;AAEpE,UAAU,iBAAkB,SAAQ,WAAW,CAAC,WAAW,CAAC;IAC1D,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,OAAO,GAAG,QAAQ,CAAC;IAC5C,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC;IACnC,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC;IAC7B,SAAS,IAAI,WAAW,CAAC;CAC1B;AAED,wBAAgB,wBAAwB,IAAI,SAAS,CAAC,iBAAiB,CAAC,CAkEvE"}

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 "./deps/jsr.io/@std/assert/1.0.14/mod.js";
-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.2.0",
+  "version": "0.3.0",
   "author": "engineering@frontside.com",
   "repository": {
     "type": "git",
@@ -24,7 +24,8 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "effection": "4.0.0-beta.2"
+    "@effectionx/signals": "0.3.0",
+    "effection": "^3 || ^4.0.0-0"
   },
   "_generatedBy": "dnt@dev"
 }

package/{esm/deps/jsr.io/@std/assert/1.0.14 → script/deps/jsr.io/@std/assert/1.0.16}/almost_equals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"almost_equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/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"}
+{"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.14 → 1.0.16}/array_includes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array_includes.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/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"}
+{"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.14 → 1.0.16}/array_includes.js

@@ -4,7 +4,7 @@ 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.10/format.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

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/assert.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAI5D"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/assert.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,CAI5D"}

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/assertion_error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/equal.ts"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAgHrD"}

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/equal.js

@@ -70,8 +70,7 @@ function getKeysDeep(obj) {
     return keys;
 }
 // deno-lint-ignore no-explicit-any
-const Temporal = dntShim.dntGlobalThis.Temporal ??
-    new Proxy({}, { get: () => { } });
+const Temporal = dntShim.dntGlobalThis.Temporal ?? Object.create(null);
 /** A non-exhaustive list of prototypes that can be accurately fast-path compared with `String(instance)` */
 const stringComparablePrototypes = new Set([
     Intl.Locale,
@@ -141,6 +140,10 @@ function equal(a, b) {
             if (a instanceof TypedArray) {
                 return compareTypedArrays(a, b);
             }
+            if (a instanceof ArrayBuffer ||
+                (globalThis.SharedArrayBuffer && a instanceof SharedArrayBuffer)) {
+                return compareTypedArrays(new Uint8Array(a), new Uint8Array(b));
+            }
             if (a instanceof WeakMap) {
                 throw new TypeError("Cannot compare WeakMap instances");
             }

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/equals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/equals.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAkBb"}
+{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/equals.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QAmBb"}

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/equals.js

@@ -4,10 +4,10 @@ exports.assertEquals = assertEquals;
 // Copyright 2018-2025 the Deno authors. MIT license.
 // This module is browser compatible.
 const equal_js_1 = require("./equal.js");
-const build_message_js_1 = require("../../internal/1.0.10/build_message.js");
-const diff_js_1 = require("../../internal/1.0.10/diff.js");
-const diff_str_js_1 = require("../../internal/1.0.10/diff_str.js");
-const format_js_1 = require("../../internal/1.0.10/format.js");
+const build_message_js_1 = require("../../internal/1.0.12/build_message.js");
+const diff_js_1 = require("../../internal/1.0.12/diff.js");
+const diff_str_js_1 = require("../../internal/1.0.12/diff_str.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` and `expected` are equal, deeply. If not
@@ -55,7 +55,8 @@ function assertEquals(actual, expected, msg) {
     const diffResult = stringDiff
         ? (0, diff_str_js_1.diffStr)(actual, expected)
         : (0, diff_js_1.diff)(actualString.split("\n"), expectedString.split("\n"));
-    const diffMsg = (0, build_message_js_1.buildMessage)(diffResult, { stringDiff }).join("\n");
+    const diffMsg = (0, build_message_js_1.buildMessage)(diffResult, { stringDiff }, arguments[3])
+        .join("\n");
     message = `${message}\n${diffMsg}`;
     throw new assertion_error_js_1.AssertionError(message);
 }

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/exists.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/exists.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC,CAOlC"}
+{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/exists.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,MAAM,EAAE,CAAC,EACT,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC,CAOlC"}

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/fail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/fail.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAGxC"}
+{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/fail.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAGxC"}

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/false.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"false.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/false.ts"],"names":[],"mappings":"AAIA,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAI1E"}
+{"version":3,"file":"false.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/false.ts"],"names":[],"mappings":"AAIA,uDAAuD;AACvD,MAAM,MAAM,KAAK,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;AAE3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,SAAK,GAAG,OAAO,CAAC,IAAI,IAAI,KAAK,CAI1E"}

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/greater.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"greater.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/greater.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,QAMpE"}
+{"version":3,"file":"greater.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/greater.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,QAMpE"}

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/greater.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertGreater = assertGreater;
 // Copyright 2018-2025 the Deno authors. MIT license.
 // This module is browser compatible.
-const format_js_1 = require("../../internal/1.0.10/format.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` is greater than `expected`.

package/script/deps/jsr.io/@std/assert/{1.0.14 → 1.0.16}/greater_or_equal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"greater_or_equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/greater_or_equal.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QASb"}
+{"version":3,"file":"greater_or_equal.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.16/greater_or_equal.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,EACX,GAAG,CAAC,EAAE,MAAM,QASb"}