thirdweb 5.80.1-nightly-a7b6cb3211e8b5232e77965cb8dd8ff96b369424-20241228000338 → 5.80.1-nightly-03bf859809de255d20f4ed8285a3bb75cef17252-20241230000334

package/src/utils/bigint.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { max, min, toBigInt } from "./bigint.js";
+import { max, min, replaceBigInts, toBigInt } from "./bigint.js";
 
 describe("min", () => {
   it("should return the smaller value when a is smaller than b", () => {
@@ -79,4 +79,94 @@ describe("toBigInt", () => {
       `Expected value to be an integer to convert to a bigint, got ${value} of type number`,
     );
   });
+
+  it("should convert a Uint8Array to a BigInt", () => {
+    const uint8Array = new Uint8Array([1, 2, 3, 4]);
+    const result = toBigInt(uint8Array);
+    expect(result).toBe(BigInt("0x01020304"));
+  });
+
+  it("should handle a Uint8Array with leading zeros", () => {
+    const uint8Array = new Uint8Array([0, 0, 1, 2]);
+    const result = toBigInt(uint8Array);
+    expect(result).toBe(BigInt("0x00000102"));
+  });
+
+  it("should handle a large Uint8Array", () => {
+    const uint8Array = new Uint8Array([255, 255, 255, 255]);
+    const result = toBigInt(uint8Array);
+    expect(result).toBe(BigInt("0xffffffff"));
+  });
+
+  describe("replaceBigInts", () => {
+    it("should replace a single bigint value", () => {
+      const input = BigInt(123);
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toBe("123");
+    });
+
+    it("should handle arrays containing bigints", () => {
+      const input = [BigInt(1), BigInt(2), BigInt(3)];
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual(["1", "2", "3"]);
+    });
+
+    it("should handle nested arrays with bigints", () => {
+      const input = [BigInt(1), [BigInt(2), BigInt(3)]];
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual(["1", ["2", "3"]]);
+    });
+
+    it("should handle objects containing bigints", () => {
+      const input = { a: BigInt(1), b: BigInt(2) };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual({ a: "1", b: "2" });
+    });
+
+    it("should handle nested objects with bigints", () => {
+      const input = { a: BigInt(1), b: { c: BigInt(2), d: BigInt(3) } };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual({ a: "1", b: { c: "2", d: "3" } });
+    });
+
+    it("should handle mixed arrays and objects", () => {
+      const input = {
+        a: [BigInt(1), { b: BigInt(2), c: [BigInt(3)] }],
+      };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual({ a: ["1", { b: "2", c: ["3"] }] });
+    });
+
+    it("should handle empty arrays and objects", () => {
+      expect(replaceBigInts([], (x) => x.toString())).toEqual([]);
+      expect(replaceBigInts({}, (x) => x.toString())).toEqual({});
+    });
+
+    it("should leave other types untouched", () => {
+      const input = {
+        a: "string",
+        b: 42,
+        c: null,
+        d: undefined,
+        e: true,
+        f: [1, "test"],
+      };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual(input);
+    });
+
+    it("should handle complex deeply nested structures", () => {
+      const input = {
+        a: BigInt(1),
+        b: [BigInt(2), { c: [BigInt(3), { d: BigInt(4) }] }],
+        e: { f: { g: BigInt(5) } },
+      };
+      const result = replaceBigInts(input, (x) => x.toString());
+      expect(result).toEqual({
+        a: "1",
+        b: ["2", { c: ["3", { d: "4" }] }],
+        e: { f: { g: "5" } },
+      });
+    });
+  });
 });

package/src/utils/bytecode/extractMinimalProxyImplementationAddress.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { extractMinimalProxyImplementationAddress } from "./extractMinimalProxyImplementationAddress.js";
+
+describe("extractMinimalProxyImplementationAddress", () => {
+  it("should handle bytecode without 0x prefix", () => {
+    const bytecode =
+      "363d3d373d3d3d363d73bebebebebebebebebebebebebebebebebebebebe5af43d82803e903d91602b57fd5bf3";
+    const result = extractMinimalProxyImplementationAddress(bytecode);
+    expect(result).toBe("0xbebebebebebebebebebebebebebebebebebebebe");
+  });
+
+  it("should extract address from EIP-1167 clone minimal proxy", () => {
+    const bytecode =
+      "0x363d3d373d3d3d363d73bebebebebebebebebebebebebebebebebebebebe5af43d82803e903d91602b57fd5bf3";
+    const result = extractMinimalProxyImplementationAddress(bytecode);
+    expect(result).toBe("0xbebebebebebebebebebebebebebebebebebebebe");
+  });
+
+  it("should extract address from 0xSplits minimal proxy", () => {
+    const bytecode =
+      "0x36603057343d52307f830d2d700a97af574b186c80d40429385d24241565b08a7c559ba283a964d9b1583103d5942010000000000000000000000001234567890123456789012345678901234567890";
+    const result = extractMinimalProxyImplementationAddress(bytecode);
+    expect(result).toBe("0x234567890123456789012345678901234567890");
+  });
+
+  it("should extract address from 0age's minimal proxy", () => {
+    const bytecode =
+      "0x3d3d3d3d363d3d37363d73bebebebebebebebebebebebebebebebebebebebe5af43d82803e903d91602b57fd5bf3";
+    const result = extractMinimalProxyImplementationAddress(bytecode);
+    expect(result).toBe("0xbebebebebebebebebebebebebebebebebebebebe");
+  });
+
+  it("should extract address from Vyper's minimal proxy (Uniswap v1)", () => {
+    const bytecode =
+      "0x366000600037611000600036600073bebebebebebebebebebebebebebebebebebebebe5af41558576110006000f3";
+    const result = extractMinimalProxyImplementationAddress(bytecode);
+    expect(result).toBe("0xbebebebebebebebebebebebebebebebebebebebe");
+  });
+
+  it("should extract address from alternative Vyper minimal proxy", () => {
+    const bytecode =
+      "0x36600080376020600036600073bebebebebebebebebebebebebebebebebebebebe5af41558576020600060006000f3";
+    const result = extractMinimalProxyImplementationAddress(bytecode);
+    expect(result).toBe("0xbebebebebebebebebebebebebebebebebebebebe");
+  });
+
+  it("should extract address from EIP-7511 minimal proxy with PUSH0 opcode", () => {
+    const bytecode =
+      "0x365f5f375f5f365f73bebebebebebebebebebebebebebebebebebebebe5af43d82803e903d91602b57fd5bf3";
+    const result = extractMinimalProxyImplementationAddress(bytecode);
+    expect(result).toBe("0xbebebebebebebebebebebebebebebebebebebebe");
+  });
+
+  it("should return undefined for non-matching bytecode", () => {
+    const bytecode =
+      "0x60806040526000805534801561001457600080fd5b50610150806100246000396000f3fe";
+    const result = extractMinimalProxyImplementationAddress(bytecode);
+    expect(result).toBeUndefined();
+  });
+});

package/src/utils/bytecode/resolveImplementation.ts

@@ -5,7 +5,7 @@ import { getRpcClient } from "../../rpc/rpc.js";
 import { readContract } from "../../transaction/read-contract.js";
 import { isAddress } from "../address.js";
 import type { Hex } from "../encoding/hex.js";
-import { extractMinimalProxyImplementationAddress } from "./extractMnimalProxyImplementationAddress.js";
+import { extractMinimalProxyImplementationAddress } from "./extractMinimalProxyImplementationAddress.js";
 
 // TODO: move to const exports
 const AddressZero = "0x0000000000000000000000000000000000000000";

package/src/utils/domain.test.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  DEFAULT_RPC_URL,
+  getThirdwebBaseUrl,
+  getThirdwebDomains,
+  setThirdwebDomains,
+} from "./domains.js";
+
+describe("Thirdweb Domains", () => {
+  const defaultDomains = {
+    rpc: "rpc.thirdweb.com",
+    social: "social.thirdweb.com",
+    inAppWallet: "embedded-wallet.thirdweb.com",
+    pay: "pay.thirdweb.com",
+    storage: "storage.thirdweb.com",
+    bundler: "bundler.thirdweb.com",
+    analytics: "c.thirdweb.com",
+  };
+
+  beforeEach(() => {
+    // Reset to default domains before each test
+    setThirdwebDomains({});
+  });
+
+  describe("getThirdwebDomains", () => {
+    it("should return the default domains if no overrides are set", () => {
+      expect(getThirdwebDomains()).toEqual(defaultDomains);
+    });
+  });
+
+  describe("setThirdwebDomains", () => {
+    it("should override specific domains while keeping others as default", () => {
+      setThirdwebDomains({
+        rpc: "custom.rpc.com",
+        analytics: "custom.analytics.com",
+      });
+
+      expect(getThirdwebDomains()).toEqual({
+        ...defaultDomains,
+        rpc: "custom.rpc.com",
+        analytics: "custom.analytics.com",
+      });
+    });
+
+    it("should not modify domains that are not overridden", () => {
+      setThirdwebDomains({ pay: "custom.pay.com" });
+
+      const domains = getThirdwebDomains();
+      expect(domains.pay).toBe("custom.pay.com");
+      expect(domains.rpc).toBe(defaultDomains.rpc);
+      expect(domains.analytics).toBe(defaultDomains.analytics);
+    });
+  });
+
+  describe("getThirdwebBaseUrl", () => {
+    it("should return an HTTPS URL for non-localhost domains", () => {
+      const baseUrl = getThirdwebBaseUrl("rpc");
+      expect(baseUrl).toBe(`https://${DEFAULT_RPC_URL}`);
+    });
+
+    it("should return an HTTP URL for localhost domains", () => {
+      setThirdwebDomains({ rpc: "localhost:8545" });
+      const baseUrl = getThirdwebBaseUrl("rpc");
+      expect(baseUrl).toBe("http://localhost:8545");
+    });
+
+    it("should reflect the updated domain overrides", () => {
+      setThirdwebDomains({ storage: "custom.storage.com" });
+      const baseUrl = getThirdwebBaseUrl("storage");
+      expect(baseUrl).toBe("https://custom.storage.com");
+    });
+
+    it("should throw an error if an invalid service is requested", () => {
+      // biome-ignore lint/suspicious/noExplicitAny: for test
+      expect(() => getThirdwebBaseUrl("invalid" as any)).toThrow();
+    });
+  });
+});

package/src/utils/encoding/hex.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { numberToHex } from "./hex.js";
+import { fromHex, numberToHex, padHex, toHex } from "./hex.js";
 
 describe("hex.ts", () => {
   it("should convert number with no padding", () => {
@@ -54,3 +54,165 @@ describe("hex.ts", () => {
     );
   });
 });
+
+describe("toHex without parameters", () => {
+  it("should convert number to hex", () => {
+    expect(toHex(1)).toBe("0x1");
+  });
+
+  it("should convert bigint to hex", () => {
+    expect(toHex(1n)).toBe("0x1");
+  });
+
+  it("should convert string to hex", () => {
+    expect(toHex("1")).toBe("0x31");
+  });
+
+  it("should convert boolean to hex", () => {
+    expect(toHex(true)).toBe("0x1");
+    expect(toHex(false)).toBe("0x0");
+  });
+
+  it("should convert uint8 array to hex", () => {
+    expect(toHex(new Uint8Array([42, 255, 0, 128, 64]))).toBe("0x2aff008040");
+  });
+});
+
+describe("toHex WITH parameters", () => {
+  it("should convert number to hex", () => {
+    expect(toHex(1, { size: 32 })).toBe(
+      "0x0000000000000000000000000000000000000000000000000000000000000001",
+    );
+  });
+
+  it("should convert bigint to hex", () => {
+    expect(toHex(1n, { size: 32 })).toBe(
+      "0x0000000000000000000000000000000000000000000000000000000000000001",
+    );
+  });
+
+  it("should convert string to hex", () => {
+    expect(toHex("1", { size: 32 })).toBe(
+      "0x3100000000000000000000000000000000000000000000000000000000000000",
+    );
+  });
+
+  it("should convert boolean to hex", () => {
+    expect(toHex(true, { size: 32 })).toBe(
+      "0x0000000000000000000000000000000000000000000000000000000000000001",
+    );
+    expect(toHex(false, { size: 32 })).toBe(
+      "0x0000000000000000000000000000000000000000000000000000000000000000",
+    );
+  });
+
+  it("should convert uint8 array to hex", () => {
+    expect(toHex(new Uint8Array([42, 255, 0, 128, 64]), { size: 32 })).toBe(
+      "0x2aff008040000000000000000000000000000000000000000000000000000000",
+    );
+  });
+});
+
+describe("fromHex without parameter", () => {
+  it("should convert hex to number", () => {
+    expect(fromHex("0x1", { to: "number" })).toBe(1);
+  });
+
+  it("should convert hex to bigint", () => {
+    expect(fromHex("0x1", { to: "bigint" })).toBe(1n);
+  });
+
+  it("should convert hex to string", () => {
+    expect(fromHex("0x31", "string")).toBe("1");
+  });
+
+  it("should convert hex to boolean:true", () => {
+    expect(fromHex("0x1", "boolean")).toBe(true);
+  });
+
+  it("should convert hex to boolean:false", () => {
+    expect(fromHex("0x0", "boolean")).toBe(false);
+  });
+
+  it("should convert hex to uint8 array", () => {
+    expect(fromHex("0x2aff008040", "bytes")).toStrictEqual(
+      new Uint8Array([42, 255, 0, 128, 64]),
+    );
+  });
+});
+
+describe("fromHex WITH parameter", () => {
+  it("should convert hex to number", () => {
+    expect(
+      fromHex(
+        "0x0000000000000000000000000000000000000000000000000000000000000001",
+        { to: "number", size: 32 },
+      ),
+    ).toBe(1);
+  });
+
+  it("should convert hex to bigint", () => {
+    expect(
+      fromHex(
+        "0x0000000000000000000000000000000000000000000000000000000000000001",
+        { to: "bigint", size: 32 },
+      ),
+    ).toBe(1n);
+  });
+
+  it("should convert hex to string", () => {
+    expect(
+      fromHex(
+        "0x3100000000000000000000000000000000000000000000000000000000000000",
+        { to: "string", size: 32 },
+      ),
+    ).toBe("1");
+  });
+
+  it("should convert hex to boolean:true", () => {
+    expect(
+      fromHex(
+        "0x0000000000000000000000000000000000000000000000000000000000000001",
+        { to: "boolean", size: 32 },
+      ),
+    ).toBe(true);
+  });
+
+  it("should convert hex to boolean:false", () => {
+    expect(
+      fromHex(
+        "0x0000000000000000000000000000000000000000000000000000000000000000",
+        { to: "boolean", size: 32 },
+      ),
+    ).toBe(false);
+  });
+
+  it("should convert hex to uint8 array", () => {
+    expect(
+      fromHex(
+        "0x2aff008040000000000000000000000000000000000000000000000000000000",
+        { to: "bytes", size: 32 },
+      ).toString(),
+    ).toStrictEqual(
+      "42,255,0,128,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0",
+    );
+  });
+});
+
+describe("padHex", () => {
+  it("should return the original value if size is undefined", () => {
+    expect(padHex("0x0", { size: null })).toBe("0x0");
+  });
+
+  it("should produce correct result if padding direction is right", () => {
+    expect(padHex("0x1", { size: 10, dir: "right" })).toBe(
+      "0x10000000000000000000",
+    );
+  });
+
+  it("should produce correct result if padding direction is Left", () => {
+    expect(padHex("0x1", { size: 10, dir: "left" })).toBe(
+      "0x00000000000000000001",
+    );
+  });
+});

package/src/utils/ens/encodeLabelToLabelhash.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { encodedLabelToLabelhash } from "./encodeLabelToLabelhash.js";
+
+describe("encodedLabelToLabelhash", () => {
+  it("should return null if the label length is not 66", () => {
+    expect(encodedLabelToLabelhash("")).toBeNull();
+    expect(encodedLabelToLabelhash("[123456]")).toBeNull();
+    expect(encodedLabelToLabelhash("[1234567890]".padEnd(67, "0"))).toBeNull();
+  });
+
+  it("should return null if the label does not start with '['", () => {
+    const input = "1234567890".padStart(66, "0");
+    expect(encodedLabelToLabelhash(input)).toBeNull();
+  });
+
+  it("should return null if the label does not end with ']' at position 65", () => {
+    const input = "[1234567890".padEnd(66, "0");
+    expect(encodedLabelToLabelhash(input)).toBeNull();
+  });
+
+  it("should return the hash if the label is valid", () => {
+    const validHash = "a".repeat(64);
+    const input = `[${validHash}]`;
+
+    const result = encodedLabelToLabelhash(input);
+    expect(result).toBe(`0x${validHash}`);
+  });
+});

package/src/utils/ens/encodeLabelhash.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import type { Hex } from "../encoding/hex.js";
+import { encodeLabelhash } from "./encodeLabelhash.js";
+
+describe("encodeLabelhash", () => {
+  it("should encode a valid hex hash correctly", () => {
+    const input = "0x1234567890abcdef";
+    const expectedOutput = "[1234567890abcdef]";
+    expect(encodeLabelhash(input)).toBe(expectedOutput);
+  });
+
+  it("should handle hashes of varying valid lengths", () => {
+    const shortHash = "0x1";
+    const longHash = `0x${"a".repeat(64)}`;
+    expect(encodeLabelhash(shortHash)).toBe("[1]");
+    expect(encodeLabelhash(longHash as Hex)).toBe(`[${"a".repeat(64)}]`);
+  });
+});

package/src/utils/ens/namehash.test.ts

@@ -0,0 +1,17 @@
+import { bytesToHex, concat } from "viem/utils";
+import { describe, expect, it } from "vitest";
+import { namehash } from "./namehash.js";
+
+describe("namehash", () => {
+  it("should return a zero-filled hash for an empty name", () => {
+    const result = namehash("");
+    expect(result).toBe(bytesToHex(new Uint8Array(32).fill(0)));
+  });
+
+  it("should correctly concatenate intermediate hashes", () => {
+    const labelBytes1 = new Uint8Array([1, 2, 3]);
+    const labelBytes2 = new Uint8Array([4, 5, 6]);
+    const concatenated = concat([labelBytes1, labelBytes2]);
+    expect(concat([labelBytes1, labelBytes2])).toEqual(concatenated);
+  });
+});

package/src/utils/nft/{parse-nft.test.ts → parseNft.test.ts}

@@ -1,9 +1,11 @@
 import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
 import {
   type NFT,
   type NFTMetadata,
   type ParseNFTOptions,
   parseNFT,
+  parseNftUri,
 } from "./parseNft.js";
 
 const base: NFTMetadata = {
@@ -11,6 +13,8 @@ const base: NFTMetadata = {
   uri: "ipfs://",
 };
 
+const client = TEST_CLIENT;
+
 describe("parseNft", () => {
   it("should parse ERC721 token", () => {
     const option: ParseNFTOptions = {
@@ -57,4 +61,39 @@ describe("parseNft", () => {
     // @ts-ignore For testing purpose
     expect(() => parseNFT(base, option)).toThrowError(/Invalid NFT type/);
   });
+
+  it("should throw an error for an invalid EIP namespace", async () => {
+    const uri = "invalid:1/erc721:0x1234567890abcdef1234567890abcdef12345678/1";
+    await expect(parseNftUri({ client, uri })).rejects.toThrow(
+      'Invalid EIP namespace, expected EIP155, got: "invalid"',
+    );
+  });
+
+  it("should throw an error for a missing chain ID", async () => {
+    const uri = "eip155:/erc721:0x1234567890abcdef1234567890abcdef12345678/1";
+    await expect(parseNftUri({ client, uri })).rejects.toThrow(
+      "Chain ID not found",
+    );
+  });
+
+  it("should throw an error for an invalid contract address", async () => {
+    const uri = "eip155:1/erc721:invalid-address/1";
+    await expect(parseNftUri({ client, uri })).rejects.toThrow(
+      "Contract address not found",
+    );
+  });
+
+  it("should throw an error for a missing token ID", async () => {
+    const uri = "eip155:1/erc721:0x1234567890abcdef1234567890abcdef12345678/";
+    await expect(parseNftUri({ client, uri })).rejects.toThrow(
+      "Token ID not found",
+    );
+  });
+
+  it("should throw an error for an invalid ERC namespace", async () => {
+    const uri = "eip155:1/invalid:0x1234567890abcdef1234567890abcdef12345678/1";
+    await expect(parseNftUri({ client, uri })).rejects.toThrow(
+      'Invalid ERC namespace, expected ERC721 or ERC1155, got: "invalid"',
+    );
+  });
 });

package/src/utils/promise/p-limit.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import { Queue, pLimit } from "./p-limit.js";
+
+describe("p-limit queue", () => {
+  it("should enqueue and dequeue items in the correct order", () => {
+    const queue = new Queue<number>();
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+
+    expect(queue.size).toBe(3);
+    expect(queue.dequeue()).toBe(1);
+    expect(queue.dequeue()).toBe(2);
+    expect(queue.dequeue()).toBe(3);
+    expect(queue.dequeue()).toBeUndefined();
+  });
+
+  it("should correctly report size", () => {
+    const queue = new Queue<number>();
+    expect(queue.size).toBe(0);
+
+    queue.enqueue(1);
+    expect(queue.size).toBe(1);
+
+    queue.dequeue();
+    expect(queue.size).toBe(0);
+  });
+
+  it("should clear the queue", () => {
+    const queue = new Queue<number>();
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.clear();
+
+    expect(queue.size).toBe(0);
+    expect(queue.dequeue()).toBeUndefined();
+  });
+
+  it("should support iteration", () => {
+    const queue = new Queue<number>();
+    queue.enqueue(1);
+    queue.enqueue(2);
+    queue.enqueue(3);
+
+    const values = [...queue];
+    expect(values).toEqual([1, 2, 3]);
+  });
+});
+
+describe("pLimit", () => {
+  it("should limit the number of concurrent executions", async () => {
+    const limit = pLimit(2);
+    const executionOrder: number[] = [];
+    const delayedTask = (id: number) =>
+      limit(async () => {
+        executionOrder.push(id);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      });
+
+    await Promise.all([
+      delayedTask(1),
+      delayedTask(2),
+      delayedTask(3),
+      delayedTask(4),
+    ]);
+
+    // Ensure tasks were executed in the correct order with concurrency of 2
+    expect(executionOrder).toEqual([1, 2, 3, 4]);
+  });
+
+  it("should handle rejected promises gracefully", async () => {
+    const limit = pLimit(1);
+
+    await expect(
+      limit(async () => {
+        throw new Error("Test error");
+      }),
+    ).rejects.toThrow("Test error");
+
+    expect(limit.activeCount).toBe(0);
+    expect(limit.pendingCount).toBe(0);
+  });
+
+  it("should handle mixed resolutions and rejections", async () => {
+    const limit = pLimit(2);
+
+    const task1 = limit(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      return 1;
+    });
+
+    const task2 = limit(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      return 2;
+    });
+
+    const task3 = limit(async () => {
+      throw new Error("Task failed");
+    }).catch(() => "Task failed");
+
+    const results = await Promise.all([task1, task2, task3]);
+
+    expect(results).toStrictEqual([1, 2, "Task failed"]);
+  });
+});

package/src/utils/promise/p-limit.ts

@@ -9,7 +9,10 @@ class Node<T> {
   }
 }
 
-class Queue<T> {
+/**
+ * @internal
+ */
+export class Queue<T> {
   private head: Node<T> | undefined;
   private tail: Node<T> | undefined;
   size: number;