vitest-pool-assemblyscript 0.3.1 → 0.4.0

package/README.md

@@ -141,7 +141,7 @@ npx vitest run
 - Suite and test definition using `describe()` and `test()` in AssemblyScript
 - Inline test option configuration for common vitest options: `timeout`, `retry`, `skip`, `only`, `fails`
 - Assertion matching API based on vitest/jest `expect()` API
-  - `.not`, `toBe`, `toBeCloseTo`, `toEqual` (with caveats*), `toStrictEqual`, `toHaveLength`, `toThrowError`, `toBeTruthy`, `toBeFalsy`, `toBeNull`, `toBeNullable`, `toBeNaN`
+  - `.not`, `toBe`, `toBeCloseTo`, `toEqual` (with caveats*), `toStrictEqual`, `toBeGreaterThan`, `toBeGreaterThanOrEqual`, `toBeLessThan`, `toBeLessThanOrEqual`, `toHaveLength`, `toThrowError`, `toBeTruthy`, `toBeFalsy`, `toBeNull`, `toBeNullable`, `toBeNaN`
   - See [Matchers API](docs/matchers-api.md) for details and differences from JavaScript
 - Highlighted diffs for assertion and runtime failures, which point to source code
 - Source-mapped WASM error stack traces (accurate AssemblyScript source `function file:line:column`)
@@ -293,7 +293,7 @@ These are known limitations which are currently being worked on.
 - Maybe: Per-file compilation setting override
 
 **Epic: Expand expect matcher API**
-- Planned: `toBeDefined`, `toBeUndefined`, `toBeGreaterThan`, `toBeGreaterThanOrEqual`, `toBeLessThan`, `toBeLessThanOrEqual`, `toContain`, `toContainEqual`
+- Planned: `toBeDefined`, `toBeUndefined`, `toContain`, `toContainEqual`
 - Likely: `toBeOneOf`, `toBeTypeOf`, `toBeInstanceOf`, `toHaveProperty`, `toMatch`
 
 **Epic: Spy and Mock**

package/assembly/compare.ts

@@ -219,6 +219,133 @@ export function equals<T, U>(actual: T, expected: U): bool {
   );
 }
 
+export enum InequalityOperation {
+  LessThan,
+  LessThanOrEqual,
+  GreaterThan,
+  GreaterThanOrEqual,
+}
+
+/**
+ * Applies an inequality operation to two values of the same promoted type.
+ * Handles <, <=, >, >= for any type that supports these operators (numbers, strings).
+ */
+function applyInequalityOp<T>(a: T, b: T, op: InequalityOperation): bool {
+  if (op == InequalityOperation.LessThan) return a < b;
+  if (op == InequalityOperation.LessThanOrEqual) return a <= b;
+  if (op == InequalityOperation.GreaterThan) return a > b;
+  return a >= b; // GreaterThanOrEqual
+}
+
+/**
+ * Generic inequality comparison. Promotes both values to a common type and applies
+ * the requested inequality operation.
+ *
+ * Strings are compared lexicographically. Booleans are treated as integers (true=1, false=0).
+ * Non-string references are not comparable and throw an error.
+ *
+ * Cross-sign integer comparisons are supported (more permissive than AS's own operators)
+ * via signed-negative early return + u64 promotion. Float/integer combinations where the
+ * float's mantissa cannot losslessly represent the integer type's range are rejected,
+ * matching AS compiler behavior. See docs/matcher-research.md for details.
+ */
+export function compareInequality<T, U>(actual: T, compareTo: U, expectedOperation: InequalityOperation): bool {
+  // --- Strings: lexicographic comparison ---
+  if (isString<T>() && isString<U>()) {
+    // Guard against null before casting, mirroring identical()'s pattern
+    const actualIsNull = isNullable<T>() && actual == null;
+    const compareToIsNull = isNullable<U>() && compareTo == null;
+    if (actualIsNull || compareToIsNull) {
+      throw new Error(
+        "Cannot compare null string with inequality operators: the result is undefined."
+        + " Use toBeNull() to check for null values."
+      );
+    }
+    return applyInequalityOp(<string>actual, <string>compareTo, expectedOperation);
+  }
+
+  // --- Reject non-string references (objects, arrays, etc.) ---
+  if (isReference<T>() || isReference<U>()) {
+    throw new Error(
+      "Inequality comparison is not supported for " + nameof<T>() + " and " + nameof<U>()
+      + ". Only numeric types and strings can be compared with inequality matchers."
+    );
+  }
+
+  // --- Float/integer precision-loss rejection ---
+  // Reject combinations where the float's mantissa cannot losslessly represent
+  // the integer type's full range (sizeof(integer) >= sizeof(float)).
+  // This mirrors AS's own operator rejection (e.g. f32 > i32, f64 > i64).
+  if (isFloat<T>() && isInteger<U>()) {
+    if (sizeof<U>() >= sizeof<T>()) {
+      throw new Error(
+        "Cannot compare " + nameof<T>() + " with " + nameof<U>()
+        + ": float precision is insufficient for the integer type's range."
+        + " Cast both values to f64 before comparing, e.g. expect(f64(a)).toBeGreaterThan(f64(b))."
+        + " Note: large integer values may lose precision when cast to f64, which could cause false positives."
+      );
+    }
+  } else if (isInteger<T>() && isFloat<U>()) {
+    if (sizeof<T>() >= sizeof<U>()) {
+      throw new Error(
+        "Cannot compare " + nameof<T>() + " with " + nameof<U>()
+        + ": float precision is insufficient for the integer type's range."
+        + " Cast both values to f64 before comparing, e.g. expect(f64(a)).toBeGreaterThan(f64(b))."
+        + " Note: large integer values may lose precision when cast to f64, which could cause false positives."
+      );
+    }
+  }
+
+  // --- Numeric comparisons ---
+  // Booleans flow through here naturally (isInteger<bool>() is true in AS).
+
+  if (isInteger<T>() && isInteger<U>()) {
+    // Both signed → promote to i64
+    if (isSigned<T>() && isSigned<U>()) {
+      return applyInequalityOp(i64(actual), i64(compareTo), expectedOperation);
+    }
+
+    // Both unsigned → promote to u64
+    if (!isSigned<T>() && !isSigned<U>()) {
+      return applyInequalityOp(u64(actual), u64(compareTo), expectedOperation);
+    }
+
+    // Mixed sign — more permissive than AS, which rejects these at compile time.
+    // If the signed value is negative, the result is deterministic: signed < unsigned.
+    if (isSigned<T>() && !isSigned<U>()) {
+      if (i64(actual) < 0) {
+        // actual (signed negative) is always less than compareTo (unsigned)
+        return expectedOperation == InequalityOperation.LessThan
+            || expectedOperation == InequalityOperation.LessThanOrEqual;
+      }
+      return applyInequalityOp(u64(actual), u64(compareTo), expectedOperation);
+    } else {
+      // !isSigned<T>() && isSigned<U>()
+      if (i64(compareTo) < 0) {
+        // compareTo (signed negative) is always less than actual (unsigned)
+        return expectedOperation == InequalityOperation.GreaterThan
+            || expectedOperation == InequalityOperation.GreaterThanOrEqual;
+      }
+      return applyInequalityOp(u64(actual), u64(compareTo), expectedOperation);
+    }
+  }
+
+  // Both floats → promote to f64
+  if (isFloat<T>() && isFloat<U>()) {
+    return applyInequalityOp(f64(actual), f64(compareTo), expectedOperation);
+  }
+
+  // Supported float/integer combo (passed precision-loss check above) → promote to f64
+  if ( (isFloat<T>() && isInteger<U>()) || (isInteger<T>() && isFloat<U>()) ) {
+    return applyInequalityOp(f64(actual), f64(compareTo), expectedOperation);
+  }
+
+  // Unsupported type combination (e.g. vectors)
+  throw new Error(
+    "Inequality comparison is not supported for " + nameof<T>() + " and " + nameof<U>() + "."
+  );
+}
+
 export function truthyOrFalsey<T>(actual: T, expected: bool): bool {
   return actual ? expected == true : expected == false;
 }

package/assembly/expect.ts

@@ -1,7 +1,9 @@
 import {
   closeTo,
+  compareInequality,
   equals,
   identical,
+  InequalityOperation,
   isNull,
   nan,
   truthyOrFalsey
@@ -97,12 +99,12 @@ abstract class BaseExpectMatcher<T> {
    * objects, arrays, etc).
    *
    * Cross-type numeric comparisons are allowed where AssemblyScript's own `==` operator
-   * permits them (e.g. `f64` vs `i32`). Combinations where the float type lacks sufficient
-   * mantissa precision for the integer type's range are rejected with an error, mirroring
-   * the AS compiler's behavior (e.g. `f32` vs `i32`, `f64` vs `i64`).
+   * permits them (e.g. `f64` vs `i32`). `toBeCloseTo()` is safer for any comparison
+   * involving a float and allows all numeric types because it can still produce accurate
+   * results in precision-loss casting edge cases.
    *
-   * `toBeCloseTo()` is safer for any comparison involving a float and allows all numeric 
-   * types because it can still produce accurate results in precision loss casting edge cases.
+   * @throws When comparing float/integer types where the float's mantissa cannot losslessly
+   * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
    *
    * @example
    * expect(1 + 1).toBe(2);
@@ -132,7 +134,7 @@ abstract class BaseExpectMatcher<T> {
    * Strings are compared by value equality as with `toBe`. Non-numeric, non-string types return false.
    *
    * @param precision - Specify the number of decimal places that must match for values to be 
-   * considered close. Defaults to 2 digits, meaning effectively that values must be within 0.005 of 
+   * considered close. Defaults to 2 digits, meaning effectively that values must be within 0.005 of
    * each other.
    *
    * @example
@@ -142,7 +144,109 @@ abstract class BaseExpectMatcher<T> {
   toBeCloseTo<U>(val: U, precision: i32 = 2): void {
     this.assertComparison(closeTo(this.actual, val, precision), this.actual, val, "to be close to", true);
   }
-  
+
+  /**
+   * Checks that a value is greater than the expected value. Supports numeric types
+   * (integers, floats, booleans) and strings (lexicographic comparison).
+   *
+   * Cross-type numeric comparisons are allowed where safe, including cross-sign integers
+   * (more permissive than AS's own `>` operator). Booleans are treated as numeric
+   * (true=1, false=0).
+   *
+   * @throws When comparing float/integer types where the float's mantissa cannot losslessly
+   * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
+   * @throws When comparing nullable strings where either value is null. Use `toBeNull()`
+   * to check for null values.
+   * @throws When comparing non-string reference types (objects, arrays, etc).
+   *
+   * @example
+   * expect(10).toBeGreaterThan(5);
+   * expect(3.14).toBeGreaterThan(3);
+   * expect("banana").toBeGreaterThan("apple");
+   */
+  toBeGreaterThan<U>(val: U): void {
+    this.assertComparison(
+      compareInequality(this.actual, val, InequalityOperation.GreaterThan),
+      this.actual, val, "to be greater than", true
+    );
+  }
+
+  /**
+   * Checks that a value is greater than or equal to the expected value. Supports numeric
+   * types (integers, floats, booleans) and strings (lexicographic comparison).
+   *
+   * Cross-type numeric comparisons are allowed where safe, including cross-sign integers
+   * (more permissive than AS's own `>=` operator). Booleans are treated as numeric
+   * (true=1, false=0).
+   *
+   * @throws When comparing float/integer types where the float's mantissa cannot losslessly
+   * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
+   * @throws When comparing nullable strings where either value is null. Use `toBeNull()`
+   * to check for null values.
+   * @throws When comparing non-string reference types (objects, arrays, etc).
+   *
+   * @example
+   * expect(10).toBeGreaterThanOrEqual(10);
+   * expect(3.14).toBeGreaterThanOrEqual(3);
+   */
+  toBeGreaterThanOrEqual<U>(val: U): void {
+    this.assertComparison(
+      compareInequality(this.actual, val, InequalityOperation.GreaterThanOrEqual),
+      this.actual, val, "to be greater than or equal to", true
+    );
+  }
+
+  /**
+   * Checks that a value is less than the expected value. Supports numeric types
+   * (integers, floats, booleans) and strings (lexicographic comparison).
+   *
+   * Cross-type numeric comparisons are allowed where safe, including cross-sign integers
+   * (more permissive than AS's own `<` operator). Booleans are treated as numeric
+   * (true=1, false=0).
+   *
+   * @throws When comparing float/integer types where the float's mantissa cannot losslessly
+   * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
+   * @throws When comparing nullable strings where either value is null. Use `toBeNull()`
+   * to check for null values.
+   * @throws When comparing non-string reference types (objects, arrays, etc).
+   *
+   * @example
+   * expect(5).toBeLessThan(10);
+   * expect(3).toBeLessThan(3.14);
+   * expect("apple").toBeLessThan("banana");
+   */
+  toBeLessThan<U>(val: U): void {
+    this.assertComparison(
+      compareInequality(this.actual, val, InequalityOperation.LessThan),
+      this.actual, val, "to be less than", true
+    );
+  }
+
+  /**
+   * Checks that a value is less than or equal to the expected value. Supports numeric
+   * types (integers, floats, booleans) and strings (lexicographic comparison).
+   *
+   * Cross-type numeric comparisons are allowed where safe, including cross-sign integers
+   * (more permissive than AS's own `<=` operator). Booleans are treated as numeric
+   * (true=1, false=0).
+   *
+   * @throws When comparing float/integer types where the float's mantissa cannot losslessly
+   * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
+   * @throws When comparing nullable strings where either value is null. Use `toBeNull()`
+   * to check for null values.
+   * @throws When comparing non-string reference types (objects, arrays, etc).
+   *
+   * @example
+   * expect(5).toBeLessThanOrEqual(5);
+   * expect(3).toBeLessThanOrEqual(3.14);
+   */
+  toBeLessThanOrEqual<U>(val: U): void {
+    this.assertComparison(
+      compareInequality(this.actual, val, InequalityOperation.LessThanOrEqual),
+      this.actual, val, "to be less than or equal to", true
+    );
+  }
+
   /**
    * Checks that two values have the same value (deep equality). Currently supports
    * checking equality of Arrays, Sets, Maps, and nulls. Values inside arrays are
@@ -151,13 +255,14 @@ abstract class BaseExpectMatcher<T> {
    * `toBe()` rules.
    *
    * Like `toBe`, cross-type numeric comparisons follow AssemblyScript's own `==` operator
-   * restrictions. Combinations where the float type lacks sufficient mantissa precision
-   * for the integer type's range are rejected with an error (e.g. `f32` vs `i32`,
-   * `f64` vs `i64`). `toBeCloseTo()` is safer for any comparison involving a float and
-   * accurately handles these edge cases.
+   * restrictions. `toBeCloseTo()` is safer for any comparison involving a float and
+   * accurately handles precision-loss edge cases.
    *
    * ⚠️ IMPORTANT: Does not yet support user-defined object deep equality checking.
    *
+   * @throws When comparing float/integer types where the float's mantissa cannot losslessly
+   * represent the integer type's range (e.g. `f32` vs `i32`, `f64` vs `i64`).
+   *
    * @example
    * expect([1, 2, 3]).toEqual([1, 2, 3]);
    * expect(["one", "two", "three"]).toEqual(["one", "two", "three"]);

package/dist/config/index-v3.d.mts

@@ -1,5 +1,5 @@
-import { AssemblyScriptPoolOptions, WasmImportsFactory, WasmImportsFactoryInfo } from "../types-8KKo9Hbf.mjs";
-import "../custom-provider-options-CF5C1kXb.mjs";
+import { AssemblyScriptPoolOptions, WasmImportsFactory, WasmImportsFactoryInfo } from "../types-DasF0_PX.mjs";
+import "../custom-provider-options-CVLz0nAp.mjs";
 import { ConfigEnv, UserWorkspaceConfig, ViteUserConfig } from "vitest/config";
 
 //#region src/config/config-helpers-v3.d.ts

package/dist/config/index.d.mts

@@ -1,4 +1,4 @@
-import { AssemblyScriptPoolOptions, WasmImportsFactory, WasmImportsFactoryInfo } from "../types-8KKo9Hbf.mjs";
-import "../custom-provider-options-CF5C1kXb.mjs";
-import { createAssemblyScriptPool } from "../pool-runner-init-CEwLyNI3.mjs";
+import { AssemblyScriptPoolOptions, WasmImportsFactory, WasmImportsFactoryInfo } from "../types-DasF0_PX.mjs";
+import "../custom-provider-options-CVLz0nAp.mjs";
+import { createAssemblyScriptPool } from "../pool-runner-init-8vx-5Pb4.mjs";
 export { type AssemblyScriptPoolOptions, type WasmImportsFactory, type WasmImportsFactoryInfo, createAssemblyScriptPool };

package/dist/{custom-provider-options-CF5C1kXb.d.mts → custom-provider-options-CVLz0nAp.d.mts}

@@ -1,4 +1,4 @@
-import { HybridProviderOptions } from "./types-8KKo9Hbf.mjs";
+import { HybridProviderOptions } from "./types-DasF0_PX.mjs";
 import { CoverageV8Options } from "vitest/node";
 
 //#region src/config/custom-provider-options.d.ts
@@ -23,4 +23,4 @@ declare module "vitest/node" {
     customProviderModule: string;
   }
 }
-//# sourceMappingURL=custom-provider-options-CF5C1kXb.d.mts.map
+//# sourceMappingURL=custom-provider-options-CVLz0nAp.d.mts.map

package/dist/{custom-provider-options-CF5C1kXb.d.mts.map → custom-provider-options-CVLz0nAp.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"custom-provider-options-CF5C1kXb.d.mts","names":[],"sources":["../src/config/custom-provider-options.ts"],"mappings":";;;;;;AAE2C;;;;;;;;;;;;;YAiB/B,qBAAA,SAA8B,qBAAA,EAAuB,IAAA,CAAK,iBAAA;IAClE,QAAA;IAGD;IAAA,oBAAA;EAAA;AAAA"}
+{"version":3,"file":"custom-provider-options-CVLz0nAp.d.mts","names":[],"sources":["../src/config/custom-provider-options.ts"],"mappings":";;;;;;AAE2C;;;;;;;;;;;;;YAiB/B,qBAAA,SAA8B,qBAAA,EAAuB,IAAA,CAAK,iBAAA;IAClE,QAAA;IAGD;IAAA,oBAAA;EAAA;AAAA"}

package/dist/index-internal.d.mts

@@ -1,4 +1,4 @@
-import { AssemblyScriptCompilerOptions, AssemblyScriptCompilerResult, AssemblyScriptPoolOptions } from "./types-8KKo9Hbf.mjs";
+import { AssemblyScriptCompilerOptions, AssemblyScriptCompilerResult, AssemblyScriptPoolOptions } from "./types-DasF0_PX.mjs";
 
 //#region src/compiler/index.d.ts
 /**

package/dist/index.d.mts

@@ -1,3 +1,3 @@
-import "./types-8KKo9Hbf.mjs";
-import { createAssemblyScriptPool } from "./pool-runner-init-CEwLyNI3.mjs";
+import "./types-DasF0_PX.mjs";
+import { createAssemblyScriptPool } from "./pool-runner-init-8vx-5Pb4.mjs";
 export { createAssemblyScriptPool };

package/dist/{pool-runner-init-CEwLyNI3.d.mts → pool-runner-init-8vx-5Pb4.d.mts}

@@ -1,8 +1,8 @@
-import { AssemblyScriptPoolOptions } from "./types-8KKo9Hbf.mjs";
+import { AssemblyScriptPoolOptions } from "./types-DasF0_PX.mjs";
 import { PoolRunnerInitializer } from "vitest/node";
 
 //#region src/pool/pool-runner-init.d.ts
 declare function createAssemblyScriptPool(userPoolOptions?: AssemblyScriptPoolOptions): PoolRunnerInitializer;
 //#endregion
 export { createAssemblyScriptPool };
-//# sourceMappingURL=pool-runner-init-CEwLyNI3.d.mts.map
+//# sourceMappingURL=pool-runner-init-8vx-5Pb4.d.mts.map

package/dist/pool-runner-init-8vx-5Pb4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool-runner-init-8vx-5Pb4.d.mts","names":[],"sources":["../src/pool/pool-runner-init.ts"],"mappings":";;;;iBAUgB,wBAAA,CAAyB,eAAA,GAAkB,yBAAA,GAA4B,qBAAA"}

package/dist/pool-thread/compile-worker-thread.d.mts

@@ -1,4 +1,4 @@
-import { RunCompileAndDiscoverTask, ThreadSpec } from "../types-8KKo9Hbf.mjs";
+import { RunCompileAndDiscoverTask, ThreadSpec } from "../types-DasF0_PX.mjs";
 
 //#region src/pool-thread/compile-worker-thread.d.ts
 declare function runCompileAndDisoverSpec(data: RunCompileAndDiscoverTask): Promise<ThreadSpec>;

package/dist/pool-thread/test-worker-thread.d.mts

@@ -1,4 +1,4 @@
-import { RunTestsTask } from "../types-8KKo9Hbf.mjs";
+import { RunTestsTask } from "../types-DasF0_PX.mjs";
 
 //#region src/pool-thread/test-worker-thread.d.ts
 declare function runFileSpec(data: RunTestsTask): Promise<void>;

package/dist/pool-thread/v3-tinypool-thread.d.mts

@@ -1,4 +1,4 @@
-import { ProcessPoolRunFileTask } from "../types-8KKo9Hbf.mjs";
+import { ProcessPoolRunFileTask } from "../types-DasF0_PX.mjs";
 
 //#region src/pool-thread/v3-tinypool-thread.d.ts
 declare function runTestFile(taskData: ProcessPoolRunFileTask): Promise<void>;

package/dist/{types-8KKo9Hbf.d.mts → types-DasF0_PX.d.mts}

@@ -1,7 +1,6 @@
 import "tinyrainbow";
 import { MessagePort } from "node:worker_threads";
 import "birpc";
-import "vitest/node";
 import "@vitest/utils";
 import { SerializedConfig } from "vitest";
 import { File, Test } from "@vitest/runner/types";
@@ -225,4 +224,4 @@ interface ProcessPoolRunFileTask {
 }
 //#endregion
 export { AssemblyScriptCompilerOptions, AssemblyScriptCompilerResult, AssemblyScriptPoolOptions, HybridProviderOptions, ProcessPoolRunFileTask, RunCompileAndDiscoverTask, RunTestsTask, ThreadSpec, WasmImportsFactory, WasmImportsFactoryInfo };
-//# sourceMappingURL=types-8KKo9Hbf.d.mts.map
+//# sourceMappingURL=types-DasF0_PX.d.mts.map

package/dist/types-DasF0_PX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DasF0_PX.d.mts","names":[],"sources":["../src/types/types.ts"],"mappings":";;;;;;;;AAqHA;;;AAAA,UA3DiB,yBAAA;;EAEf,KAAA;;;;;;;;;;EAUA,WAAA;EAuDU;;;;;;;EA9CV,YAAA;EAEA,0BAAA;EACA,sBAAA;EAEA,sBAAA;EACA,kBAAA;EAEA,kBAAA;EAEA,kBAAA;AAAA;;;;UAMe,qBAAA;EACf,QAAA;EACA,oBAAA;EAyGF;;;;;;;;EA/FE,qBAAA;;;;;AAuGF;EAhGE,qBAAA;AAAA;AAAA,UAGe,sBAAA;EACf,MAAA,EAAQ,WAAA,CAAY,MAAA;EACpB,MAAA,EAAQ,WAAA,CAAY,MAAA;EACpB,KAAA;IACE,UAAA,GAAa,SAAA;EAAA;AAAA;AAAA,KAIL,kBAAA,IAAsB,UAAA,EAAY,sBAAA,KAA2B,WAAA,CAAY,OAAA;AAAA,UAqEpE,6BAAA;EACf,gBAAA;EACA,WAAA;EACA,sBAAA,GAAyB,sBAAA;EACzB,WAAA;EACA,UAAA;AAAA;AAAA,UAGe,4BAAA;EACf,MAAA,EAAQ,UAAA;EACR,SAAA;EACA,SAAA,GAAY,eAAA;EACZ,cAAA;EACA,aAAA;AAAA;AAAA,UAGe,sBAAA;;EAEf,qBAAA;EACA,yBAAA;EACA,sBAAA;EACA,sBAAA;AAAA;;;;;AAiZF;;UAxXiB,cAAA;EA4XH;EA1XZ,QAAA;EACA,IAAA;EACA,MAAA;AAAA;;;;UAoEe,mBAAA;;EAEf,gBAAA;;EAEA,qBAAA;AAAA;;;;;;;UASe,mBAAA;EAyUA;EAvUf,IAAA;;EAEA,QAAA,GAAW,cAAA;;EAEX,QAAA;;EAEA,WAAA;EAwUsB;;;;EAnUtB,mBAAA;AAAA;;;;;;;UASe,mBAAA;;EAEf,KAAA;;EAEA,iBAAA;;EAEA,QAAA,EAAU,mBAAA;;;;;EAKV,mBAAA;AAAA;;;;UAMe,iBAAA;;EAEf,SAAA;;EAEA,IAAA;;;;;EAKA,sBAAA,EAAwB,cAAA;;EAExB,mBAAA;;EAEA,WAAA,EAAa,mBAAA;;EAEb,WAAA,EAAa,mBAAA;AAAA;;;;;;;UASE,eAAA;;EAEf,gBAAA;;;;;EAKA,0BAAA,EAA4B,MAAA,SAAe,MAAA,SAAe,iBAAA;EAE1D,yBAAA;AAAA;AAAA,UA2Ne,eAAA;EACf,QAAA;EACA,MAAA,EAAQ,UAAA;EACR,SAAA;EACA,SAAA,GAAY,eAAA;AAAA;AAAA,UASG,UAAA;EACf,IAAA,EAAM,IAAA;EACN,WAAA,GAAc,eAAA;AAAA;AAAA,UAGC,yBAAA;EACf,aAAA;EACA,QAAA;EACA,IAAA,EAAM,WAAA;EACN,IAAA,EAAM,IAAA;EACN,MAAA,EAAQ,gBAAA;EACR,kBAAA;AAAA;AAAA,UAGe,YAAA;EACf,aAAA;EACA,QAAA;EACA,IAAA,EAAM,WAAA;EACN,IAAA,EAAM,IAAA;EACN,WAAA,EAAa,eAAA;EACb,MAAA,EAAQ,gBAAA;EACR,kBAAA;EACA,YAAA,GAAe,IAAA;AAAA;AAAA,UAGA,sBAAA;EACf,aAAA;EACA,IAAA,EAAM,WAAA;EACN,IAAA,EAAM,IAAA;EACN,MAAA,EAAQ,gBAAA;EACR,kBAAA;EACA,YAAA,GAAe,IAAA;EACf,mBAAA,GAAsB,eAAA;AAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vitest-pool-assemblyscript",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "AssemblyScript testing with Vitest - Simple, fast, familiar, AS-native, with full coverage output",
   "author": "Matt Ritter <matthew.d.ritter@gmail.com>",
   "license": "MIT",

package/dist/pool-runner-init-CEwLyNI3.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool-runner-init-CEwLyNI3.d.mts","names":[],"sources":["../src/pool/pool-runner-init.ts"],"mappings":";;;;iBAUgB,wBAAA,CAAyB,eAAA,GAAkB,yBAAA,GAA4B,qBAAA"}

package/dist/types-8KKo9Hbf.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-8KKo9Hbf.d.mts","names":[],"sources":["../src/types/types.ts"],"mappings":";;;;;;;;;;AAqHA;;UA3DiB,yBAAA;EA6DK;EA3DpB,KAAA;;;;;;;;;;EAUA,WAAA;EAuDF;;;;;;;EA9CE,YAAA;EAEA,0BAAA;EACA,sBAAA;EAEA,sBAAA;EACA,kBAAA;EAEA,kBAAA;EAEA,kBAAA;AAAA;;;;UAMe,qBAAA;EACf,QAAA;EACA,oBAAA;EAsGA;AAGF;;;;;;;EA/FE,qBAAA;;;;;;EAOA,qBAAA;AAAA;AAAA,UAGe,sBAAA;EACf,MAAA,EAAQ,WAAA,CAAY,MAAA;EACpB,MAAA,EAAQ,WAAA,CAAY,MAAA;EACpB,KAAA;IACE,UAAA,GAAa,SAAA;EAAA;AAAA;AAAA,KAIL,kBAAA,IAAsB,UAAA,EAAY,sBAAA,KAA2B,WAAA,CAAY,OAAA;AAAA,UAqEpE,6BAAA;EACf,gBAAA;EACA,WAAA;EACA,sBAAA,GAAyB,sBAAA;EACzB,WAAA;EACA,UAAA;AAAA;AAAA,UAGe,4BAAA;EACf,MAAA,EAAQ,UAAA;EACR,SAAA;EACA,SAAA,GAAY,eAAA;EACZ,cAAA;EACA,aAAA;AAAA;AAAA,UAGe,sBAAA;;EAEf,qBAAA;EACA,yBAAA;EACA,sBAAA;EACA,sBAAA;AAAA;;;;;;AAiZF;UAxXiB,cAAA;;EAEf,QAAA;EACA,IAAA;EACA,MAAA;AAAA;;;;UAoEe,mBAAA;;EAEf,gBAAA;;EAEA,qBAAA;AAAA;;;;;;;UASe,mBAAA;EAyUjB;EAvUE,IAAA;;EAEA,QAAA,GAAW,cAAA;;EAEX,QAAA;;EAEA,WAAA;;;;;EAKA,mBAAA;AAAA;;;;;;;UASe,mBAAA;;EAEf,KAAA;EAwTsB;EAtTtB,iBAAA;;EAEA,QAAA,EAAU,mBAAA;;;;;EAKV,mBAAA;AAAA;;;;UAMe,iBAAA;;EAEf,SAAA;;EAEA,IAAA;;;;;EAKA,sBAAA,EAAwB,cAAA;;EAExB,mBAAA;;EAEA,WAAA,EAAa,mBAAA;;EAEb,WAAA,EAAa,mBAAA;AAAA;;;;;;;UASE,eAAA;;EAEf,gBAAA;;;;;EAKA,0BAAA,EAA4B,MAAA,SAAe,MAAA,SAAe,iBAAA;EAE1D,yBAAA;AAAA;AAAA,UA2Ne,eAAA;EACf,QAAA;EACA,MAAA,EAAQ,UAAA;EACR,SAAA;EACA,SAAA,GAAY,eAAA;AAAA;AAAA,UASG,UAAA;EACf,IAAA,EAAM,IAAA;EACN,WAAA,GAAc,eAAA;AAAA;AAAA,UAGC,yBAAA;EACf,aAAA;EACA,QAAA;EACA,IAAA,EAAM,WAAA;EACN,IAAA,EAAM,IAAA;EACN,MAAA,EAAQ,gBAAA;EACR,kBAAA;AAAA;AAAA,UAGe,YAAA;EACf,aAAA;EACA,QAAA;EACA,IAAA,EAAM,WAAA;EACN,IAAA,EAAM,IAAA;EACN,WAAA,EAAa,eAAA;EACb,MAAA,EAAQ,gBAAA;EACR,kBAAA;EACA,YAAA,GAAe,IAAA;AAAA;AAAA,UAGA,sBAAA;EACf,aAAA;EACA,IAAA,EAAM,WAAA;EACN,IAAA,EAAM,IAAA;EACN,MAAA,EAAQ,gBAAA;EACR,kBAAA;EACA,YAAA,GAAe,IAAA;EACf,mBAAA,GAAsB,eAAA;AAAA"}