@effectionx/worker 0.1.2 → 0.2.0

package/esm/deps/jsr.io/@std/assert/1.0.14/string_includes.js

@@ -0,0 +1,26 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertStringIncludes } from "@std/assert";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
+ *
+ * @param actual The actual string to check for inclusion.
+ * @param expected The expected string to check for inclusion.
+ * @param msg The optional message to display if the assertion fails.
+ */
+export function assertStringIncludes(actual, expected, msg) {
+    if (actual.includes(expected))
+        return;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    msg = `Expected actual: "${actual}" to contain: "${expected}"${msgSuffix}`;
+    throw new AssertionError(msg);
+}

package/esm/deps/jsr.io/@std/assert/1.0.14/throws.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws.
+ *
+ * To assert that an asynchronous function rejects, use
+ * {@linkcode assertRejects}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
+ * assertThrows(() => console.log("hello world!")); // Throws
+ * ```
+ *
+ * @param fn The function to execute.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The error that was thrown.
+ */
+export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
+/**
+ * Executes a function, expecting it to throw. If it does not, then it
+ * throws. An error class and a string that should be included in the
+ * error message can also be asserted.
+ *
+ * To assert that an asynchronous function rejects, use
+ * {@linkcode assertRejects}.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertThrows(() => { throw new TypeError("hello world!"); }, TypeError); // Doesn't throw
+ * assertThrows(() => { throw new TypeError("hello world!"); }, RangeError); // Throws
+ * ```
+ *
+ * @typeParam E The error class to assert.
+ * @param fn The function to execute.
+ * @param ErrorClass The error class to assert.
+ * @param msgIncludes The string that should be included in the error message.
+ * @param msg The optional message to display if the assertion fails.
+ * @returns The error that was thrown.
+ */
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: abstract new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;
+//# sourceMappingURL=throws.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.14/throws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throws.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/throws.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,OAAO,EACjB,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC;AACX;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EAClD,EAAE,EAAE,MAAM,OAAO,EAEjB,UAAU,EAAE,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAC9C,WAAW,CAAC,EAAE,MAAM,EACpB,GAAG,CAAC,EAAE,MAAM,GACX,CAAC,CAAC"}

package/esm/deps/jsr.io/@std/assert/1.0.14/throws.js

@@ -0,0 +1,44 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { assertIsError } from "./is_error.js";
+import { AssertionError } from "./assertion_error.js";
+export function assertThrows(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
+    // deno-lint-ignore no-explicit-any
+    let ErrorClass;
+    let msgIncludes;
+    let err;
+    if (typeof errorClassOrMsg !== "string") {
+        if (errorClassOrMsg === undefined ||
+            errorClassOrMsg?.prototype instanceof Error ||
+            errorClassOrMsg?.prototype === Error.prototype) {
+            ErrorClass = errorClassOrMsg;
+            msgIncludes = msgIncludesOrMsg;
+        }
+        else {
+            msg = msgIncludesOrMsg;
+        }
+    }
+    else {
+        msg = errorClassOrMsg;
+    }
+    let doesThrow = false;
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    try {
+        fn();
+    }
+    catch (error) {
+        if (ErrorClass) {
+            if (error instanceof Error === false) {
+                throw new AssertionError(`A non-Error object was thrown${msgSuffix}`);
+            }
+            assertIsError(error, ErrorClass, msgIncludes, msg);
+        }
+        err = error;
+        doesThrow = true;
+    }
+    if (!doesThrow) {
+        msg = `Expected function to throw${msgSuffix}`;
+        throw new AssertionError(msg);
+    }
+    return err;
+}

package/esm/deps/jsr.io/@std/assert/1.0.14/unimplemented.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unimplemented } from "@std/assert";
+ *
+ * unimplemented(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export declare function unimplemented(msg?: string): never;
+//# sourceMappingURL=unimplemented.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.14/unimplemented.d.ts.map

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

package/esm/deps/jsr.io/@std/assert/1.0.14/unimplemented.js

@@ -0,0 +1,20 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unimplemented } from "@std/assert";
+ *
+ * unimplemented(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export function unimplemented(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Unimplemented${msgSuffix}`);
+}

package/esm/deps/jsr.io/@std/assert/1.0.14/unreachable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unreachable } from "@std/assert";
+ *
+ * unreachable(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export declare function unreachable(msg?: string): never;
+//# sourceMappingURL=unreachable.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.14/unreachable.d.ts.map

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

package/esm/deps/jsr.io/@std/assert/1.0.14/unreachable.js

@@ -0,0 +1,20 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { AssertionError } from "./assertion_error.js";
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { unreachable } from "@std/assert";
+ *
+ * unreachable(); // Throws
+ * ```
+ *
+ * @param msg Optional message to include in the error.
+ * @returns Never returns, always throws.
+ */
+export function unreachable(msg) {
+    const msgSuffix = msg ? `: ${msg}` : ".";
+    throw new AssertionError(`Unreachable${msgSuffix}`);
+}

package/esm/deps/jsr.io/@std/internal/1.0.10/build_message.d.ts

@@ -0,0 +1,82 @@
+import type { DiffResult, DiffType } from "./types.js";
+/**
+ * Colors the output of assertion diffs.
+ *
+ * @param diffType Difference type, either added or removed.
+ * @param background If true, colors the background instead of the text.
+ *
+ * @returns A function that colors the input string.
+ *
+ * @example Usage
+ * ```ts
+ * import { createColor } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ * import { bold, green, red, white } from "@std/fmt/colors";
+ *
+ * assertEquals(createColor("added")("foo"), green(bold("foo")));
+ * assertEquals(createColor("removed")("foo"), red(bold("foo")));
+ * assertEquals(createColor("common")("foo"), white("foo"));
+ * ```
+ */
+export declare function createColor(diffType: DiffType, 
+/**
+ * TODO(@littledivy): Remove this when we can detect true color terminals. See
+ * https://github.com/denoland/std/issues/2575.
+ */
+background?: boolean): (s: string) => string;
+/**
+ * Prefixes `+` or `-` in diff output.
+ *
+ * @param diffType Difference type, either added or removed
+ *
+ * @returns A string representing the sign.
+ *
+ * @example Usage
+ * ```ts
+ * import { createSign } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(createSign("added"), "+   ");
+ * assertEquals(createSign("removed"), "-   ");
+ * assertEquals(createSign("common"), "    ");
+ * ```
+ */
+export declare function createSign(diffType: DiffType): string;
+/** Options for {@linkcode buildMessage}. */
+export interface BuildMessageOptions {
+    /**
+     * Whether to output the diff as a single string.
+     *
+     * @default {false}
+     */
+    stringDiff?: boolean;
+}
+/**
+ * Builds a message based on the provided diff result.
+ *
+ * @param diffResult The diff result array.
+ * @param options Optional parameters for customizing the message.
+ *
+ * @returns An array of strings representing the built message.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { diffStr, buildMessage } from "@std/internal";
+ *
+ * const diffResult = diffStr("Hello, world!", "Hello, world");
+ *
+ * console.log(buildMessage(diffResult));
+ * // [
+ * //   "",
+ * //   "",
+ * //   "    [Diff] Actual / Expected",
+ * //   "",
+ * //   "",
+ * //   "-   Hello, world!",
+ * //   "+   Hello, world",
+ * //   "",
+ * // ]
+ * ```
+ */
+export declare function buildMessage(diffResult: ReadonlyArray<DiffResult<string>>, options?: BuildMessageOptions): string[];
+//# sourceMappingURL=build_message.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.10/build_message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_message.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/build_message.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ;AAClB;;;GAGG;AACH,UAAU,UAAQ,GACjB,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CASvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CASrD;AAED,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,aAAa,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAC7C,OAAO,GAAE,mBAAwB,GAChC,MAAM,EAAE,CAsBV"}

package/esm/deps/jsr.io/@std/internal/1.0.10/build_message.js

@@ -0,0 +1,110 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { bgGreen, bgRed, bold, gray, green, red, white } from "./styles.js";
+/**
+ * Colors the output of assertion diffs.
+ *
+ * @param diffType Difference type, either added or removed.
+ * @param background If true, colors the background instead of the text.
+ *
+ * @returns A function that colors the input string.
+ *
+ * @example Usage
+ * ```ts
+ * import { createColor } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ * import { bold, green, red, white } from "@std/fmt/colors";
+ *
+ * assertEquals(createColor("added")("foo"), green(bold("foo")));
+ * assertEquals(createColor("removed")("foo"), red(bold("foo")));
+ * assertEquals(createColor("common")("foo"), white("foo"));
+ * ```
+ */
+export function createColor(diffType, 
+/**
+ * TODO(@littledivy): Remove this when we can detect true color terminals. See
+ * https://github.com/denoland/std/issues/2575.
+ */
+background = false) {
+    switch (diffType) {
+        case "added":
+            return (s) => background ? bgGreen(white(s)) : green(bold(s));
+        case "removed":
+            return (s) => background ? bgRed(white(s)) : red(bold(s));
+        default:
+            return white;
+    }
+}
+/**
+ * Prefixes `+` or `-` in diff output.
+ *
+ * @param diffType Difference type, either added or removed
+ *
+ * @returns A string representing the sign.
+ *
+ * @example Usage
+ * ```ts
+ * import { createSign } from "@std/internal";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(createSign("added"), "+   ");
+ * assertEquals(createSign("removed"), "-   ");
+ * assertEquals(createSign("common"), "    ");
+ * ```
+ */
+export function createSign(diffType) {
+    switch (diffType) {
+        case "added":
+            return "+   ";
+        case "removed":
+            return "-   ";
+        default:
+            return "    ";
+    }
+}
+/**
+ * Builds a message based on the provided diff result.
+ *
+ * @param diffResult The diff result array.
+ * @param options Optional parameters for customizing the message.
+ *
+ * @returns An array of strings representing the built message.
+ *
+ * @example Usage
+ * ```ts no-assert
+ * import { diffStr, buildMessage } from "@std/internal";
+ *
+ * const diffResult = diffStr("Hello, world!", "Hello, world");
+ *
+ * console.log(buildMessage(diffResult));
+ * // [
+ * //   "",
+ * //   "",
+ * //   "    [Diff] Actual / Expected",
+ * //   "",
+ * //   "",
+ * //   "-   Hello, world!",
+ * //   "+   Hello, world",
+ * //   "",
+ * // ]
+ * ```
+ */
+export function buildMessage(diffResult, options = {}) {
+    const { stringDiff = false } = options;
+    const messages = [
+        "",
+        "",
+        `    ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${green(bold("Expected"))}`,
+        "",
+        "",
+    ];
+    const diffMessages = diffResult.map((result) => {
+        const color = createColor(result.type);
+        const line = result.details?.map((detail) => detail.type !== "common"
+            ? createColor(detail.type, true)(detail.value)
+            : detail.value).join("") ?? result.value;
+        return color(`${createSign(result.type)}${line}`);
+    });
+    messages.push(...(stringDiff ? [diffMessages.join("")] : diffMessages), "");
+    return messages;
+}

package/esm/deps/jsr.io/@std/internal/1.0.10/diff.d.ts

@@ -0,0 +1,140 @@
+import type { DiffResult, DiffType } from "./types.js";
+/** Represents the farthest point in the diff algorithm. */
+export interface FarthestPoint {
+    /** The y-coordinate of the point. */
+    y: number;
+    /** The id of the point. */
+    id: number;
+}
+/**
+ * Creates an array of common elements between two arrays.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A The first array.
+ * @param B The second array.
+ *
+ * @returns An array containing the common elements between the two arrays.
+ *
+ * @example Usage
+ * ```ts
+ * import { createCommon } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = [1, 2, 3];
+ * const b = [1, 2, 4];
+ *
+ * assertEquals(createCommon(a, b), [1, 2]);
+ * ```
+ */
+export declare function createCommon<T>(A: T[], B: T[]): T[];
+/**
+ * Asserts that the value is a {@linkcode FarthestPoint}.
+ * If not, an error is thrown.
+ *
+ * @param value The value to check.
+ *
+ * @returns A void value that returns once the assertion completes.
+ *
+ * @example Usage
+ * ```ts
+ * import { assertFp } from "@std/internal/diff";
+ * import { assertThrows } from "@std/assert";
+ *
+ * assertFp({ y: 0, id: 0 });
+ * assertThrows(() => assertFp({ id: 0 }));
+ * assertThrows(() => assertFp({ y: 0 }));
+ * assertThrows(() => assertFp(undefined));
+ * ```
+ */
+export declare function assertFp(value: unknown): asserts value is FarthestPoint;
+/**
+ * Creates an array of backtraced differences.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A The first array.
+ * @param B The second array.
+ * @param current The current {@linkcode FarthestPoint}.
+ * @param swapped Boolean indicating if the arrays are swapped.
+ * @param routes The routes array.
+ * @param diffTypesPtrOffset The offset of the diff types in the routes array.
+ *
+ * @returns An array of backtraced differences.
+ *
+ * @example Usage
+ * ```ts
+ * import { backTrace } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   backTrace([], [], { y: 0, id: 0 }, false, new Uint32Array(0), 0),
+ *   [],
+ * );
+ * ```
+ */
+export declare function backTrace<T>(A: T[], B: T[], current: FarthestPoint, swapped: boolean, routes: Uint32Array, diffTypesPtrOffset: number): Array<{
+    type: DiffType;
+    value: T;
+}>;
+/**
+ * Creates a {@linkcode FarthestPoint}.
+ *
+ * @param k The current index.
+ * @param M The length of the first array.
+ * @param routes The routes array.
+ * @param diffTypesPtrOffset The offset of the diff types in the routes array.
+ * @param ptr The current pointer.
+ * @param slide The slide {@linkcode FarthestPoint}.
+ * @param down The down {@linkcode FarthestPoint}.
+ *
+ * @returns A {@linkcode FarthestPoint}.
+ *
+ * @example Usage
+ * ```ts
+ * import { createFp } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(
+ *   createFp(
+ *     0,
+ *     0,
+ *     new Uint32Array(0),
+ *     0,
+ *     0,
+ *     { y: -1, id: 0 },
+ *     { y: 0, id: 0 },
+ *   ),
+ *   { y: -1, id: 1 },
+ * );
+ * ```
+ */
+export declare function createFp(k: number, M: number, routes: Uint32Array, diffTypesPtrOffset: number, ptr: number, slide?: FarthestPoint, down?: FarthestPoint): FarthestPoint;
+/**
+ * Renders the differences between the actual and expected values.
+ *
+ * @typeParam T The type of elements in the arrays.
+ *
+ * @param A Actual value
+ * @param B Expected value
+ *
+ * @returns An array of differences between the actual and expected values.
+ *
+ * @example Usage
+ * ```ts
+ * import { diff } from "@std/internal/diff";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = [1, 2, 3];
+ * const b = [1, 2, 4];
+ *
+ * assertEquals(diff(a, b), [
+ *   { type: "common", value: 1 },
+ *   { type: "common", value: 2 },
+ *   { type: "removed", value: 3 },
+ *   { type: "added", value: 4 },
+ * ]);
+ * ```
+ */
+export declare function diff<T>(A: T[], B: T[]): DiffResult<T>[];
+//# sourceMappingURL=diff.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.10/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/diff.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,2DAA2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B;IAC3B,EAAE,EAAE,MAAM,CAAC;CACZ;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAanD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,aAAa,CAWvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,CAAC,EAAE,EACN,CAAC,EAAE,CAAC,EAAE,EACN,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,GACzB,KAAK,CAAC;IACP,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,CAAC,CAAC;CACV,CAAC,CAgCD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,EACrB,IAAI,CAAC,EAAE,aAAa,GACnB,aAAa,CAsBf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,EAAE,CAwEvD"}