@hexclave/shared 1.0.0

package/dist/esm/utils/paginated-lists.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginated-lists.test.js","names":[],"sources":["../../../src/utils/paginated-lists.test.ts"],"sourcesContent":["import { describe, expect, it } from \"vitest\";\nimport { ArrayPaginatedList, PaginatedList } from \"./paginated-lists\";\nimport { stringCompare } from \"./strings\";\n\ntype NumberFilter = (item: number) => boolean;\ntype NumberOrderBy = (a: number, b: number) => number;\n\n// Helper to extract just the items from a paginated result\nconst items = <T>(result: { items: { item: T }[] }) => result.items.map(i => i.item);\n\ndescribe(\"ArrayPaginatedList\", () => {\n  describe(\"basic forward pagination (next)\", () => {\n    it(\"should return all items when limit is greater than array length\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 10,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([1, 2, 3]);\n      expect(result.isFirst).toBe(true);\n      expect(result.isLast).toBe(true);\n    });\n\n    it(\"should return exact limit when more items exist\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([1, 2, 3]);\n      expect(result.isFirst).toBe(true);\n      expect(result.isLast).toBe(false);\n    });\n\n    it(\"should continue from cursor correctly\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n      const first = await list.next({\n        after: list.getFirstCursor(),\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(first)).toEqual([1, 2]);\n      expect(first.cursor).toBe(\"before-2\");\n\n      const second = await list.next({\n        after: first.cursor,\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(second)).toEqual([3, 4]);\n      expect(second.isFirst).toBe(false);\n      expect(second.isLast).toBe(false);\n    });\n\n    it(\"should handle empty array\", async () => {\n      const list = new ArrayPaginatedList<number>([]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 10,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([]);\n      expect(result.isFirst).toBe(true);\n      expect(result.isLast).toBe(true);\n    });\n\n    it(\"should handle limit of 0\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 0,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([]);\n    });\n  });\n\n  describe(\"backward pagination (prev)\", () => {\n    it(\"should return items before cursor\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n      const result = await list.prev({\n        before: list.getLastCursor(),\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([4, 5]);\n      expect(result.isFirst).toBe(false);\n      expect(result.isLast).toBe(true);\n    });\n\n    it(\"should paginate backwards correctly\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n\n      const last = await list.prev({\n        before: list.getLastCursor(),\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n      expect(items(last)).toEqual([4, 5]);\n\n      const middle = await list.prev({\n        before: last.cursor,\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n      expect(items(middle)).toEqual([2, 3]);\n\n      const first = await list.prev({\n        before: middle.cursor,\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n      expect(items(first)).toEqual([1]);\n      expect(first.isFirst).toBe(true);\n    });\n  });\n\n  describe(\"cursor semantics (prevCursor and nextCursor)\", () => {\n    it(\"should have prevCursor before the item and nextCursor after\", async () => {\n      const list = new ArrayPaginatedList([10, 20, 30]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      // First item: prevCursor should be \"before-0\", nextCursor should be \"before-1\"\n      expect(result.items[0].prevCursor).toBe(\"before-0\");\n      expect(result.items[0].nextCursor).toBe(\"before-1\");\n\n      // Second item\n      expect(result.items[1].prevCursor).toBe(\"before-1\");\n      expect(result.items[1].nextCursor).toBe(\"before-2\");\n\n      // Third item\n      expect(result.items[2].prevCursor).toBe(\"before-2\");\n      expect(result.items[2].nextCursor).toBe(\"before-3\");\n    });\n\n    it(\"should allow using nextCursor to continue forward pagination\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n\n      const first = await list.next({\n        after: list.getFirstCursor(),\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      // Use the nextCursor of the last item to continue\n      const continueFrom = first.items[first.items.length - 1].nextCursor;\n      const second = await list.next({\n        after: continueFrom,\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(second)).toEqual([3, 4]);\n    });\n\n    it(\"should allow using prevCursor to go back\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n\n      // Get items 3,4,5 first\n      const middle = await list.next({\n        after: \"before-2\",\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(middle)).toEqual([3, 4, 5]);\n      expect(middle.items[0].prevCursor).toBe(\"before-2\");\n\n      // Use prevCursor of first item to go back\n      const goBack = await list.prev({\n        before: middle.items[0].prevCursor,\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(goBack)).toEqual([1, 2]);\n    });\n  });\n\n  describe(\"filtering\", () => {\n    it(\"should filter items correctly\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5, 6]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 10,\n        filter: (n) => n % 2 === 0, // only even numbers\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([2, 4, 6]);\n    });\n\n    it(\"should respect limit with filtering\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 2,\n        filter: (n) => n % 2 === 0,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([2, 4]);\n    });\n\n    it(\"should handle filter that matches nothing\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 10,\n        filter: () => false,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([]);\n    });\n  });\n\n  describe(\"ordering\", () => {\n    it(\"should sort items in ascending order\", async () => {\n      const list = new ArrayPaginatedList([5, 2, 8, 1, 9]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 10,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([1, 2, 5, 8, 9]);\n    });\n\n    it(\"should sort items in descending order\", async () => {\n      const list = new ArrayPaginatedList([5, 2, 8, 1, 9]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 10,\n        filter: () => true,\n        orderBy: (a, b) => b - a,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(result)).toEqual([9, 8, 5, 2, 1]);\n    });\n\n    it(\"should sort objects by property\", async () => {\n      const list = new ArrayPaginatedList([\n        { name: \"Charlie\", age: 30 },\n        { name: \"Alice\", age: 25 },\n        { name: \"Bob\", age: 35 },\n      ]);\n\n      const byName = await list.next({\n        after: list.getFirstCursor(),\n        limit: 10,\n        filter: () => true,\n        orderBy: (a, b) => stringCompare(a.name, b.name),\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(byName).map(p => p.name)).toEqual([\"Alice\", \"Bob\", \"Charlie\"]);\n\n      const byAge = await list.next({\n        after: list.getFirstCursor(),\n        limit: 10,\n        filter: () => true,\n        orderBy: (a, b) => a.age - b.age,\n        limitPrecision: \"exact\",\n      });\n\n      expect(items(byAge).map(p => p.name)).toEqual([\"Alice\", \"Charlie\", \"Bob\"]);\n    });\n  });\n\n  describe(\"limitPrecision\", () => {\n    it(\"exact should return exactly the limit\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      expect(result.items.length).toBe(3);\n    });\n\n    // Note: ArrayPaginatedList always returns exact results since it has all data in memory\n    // These tests verify the contract is respected\n    it(\"at-least should return at least the limit (or all if less available)\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"at-least\",\n      });\n\n      expect(result.items.length).toBeGreaterThanOrEqual(3);\n    });\n\n    it(\"at-most should return at most the limit\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"at-most\",\n      });\n\n      expect(result.items.length).toBeLessThanOrEqual(3);\n    });\n\n    it(\"approximate should allow flexibility in either direction\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n      const result = await list.next({\n        after: list.getFirstCursor(),\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"approximate\",\n      });\n\n      // With 'approximate', the implementation can return more or fewer items\n      // than requested. We just verify it returns some items and makes progress.\n      expect(result.items.length).toBeGreaterThan(0);\n      // Should still return valid items\n      expect(items(result).every(n => typeof n === \"number\")).toBe(true);\n    });\n\n    it(\"approximate should still make progress when limit > 0\", async () => {\n      const list = new ArrayPaginatedList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n      const allItems: number[] = [];\n\n      let cursor = list.getFirstCursor();\n      let iterations = 0;\n      const maxIterations = 20; // Safety limit to prevent infinite loops\n\n      while (iterations < maxIterations) {\n        const result = await list.next({\n          after: cursor,\n          limit: 2,\n          filter: () => true,\n          orderBy: (a, b) => a - b,\n          limitPrecision: \"approximate\",\n        });\n\n        if (result.items.length === 0) break;\n\n        allItems.push(...items(result));\n        // Cursor must change to ensure progress\n        expect(result.cursor).not.toBe(cursor);\n        cursor = result.cursor;\n        iterations++;\n\n        if (result.isLast) break;\n      }\n\n      // Should eventually get all items\n      expect(allItems.length).toBeGreaterThan(0);\n    });\n  });\n\n  describe(\"getFirstCursor and getLastCursor\", () => {\n    it(\"should return correct cursor format\", () => {\n      const list = new ArrayPaginatedList([1, 2, 3]);\n      expect(list.getFirstCursor()).toBe(\"before-0\");\n      expect(list.getLastCursor()).toBe(\"before-3\");\n    });\n\n    it(\"should work for empty array\", () => {\n      const list = new ArrayPaginatedList([]);\n      expect(list.getFirstCursor()).toBe(\"before-0\");\n      expect(list.getLastCursor()).toBe(\"before-0\");\n    });\n  });\n\n  describe(\"compare\", () => {\n    it(\"should compare items using the orderBy function\", () => {\n      const list = new ArrayPaginatedList([1, 2, 3]);\n      const orderBy = (a: number, b: number) => a - b;\n\n      expect(list.compare(orderBy, 1, 2)).toBeLessThan(0);\n      expect(list.compare(orderBy, 2, 1)).toBeGreaterThan(0);\n      expect(list.compare(orderBy, 1, 1)).toBe(0);\n    });\n  });\n});\n\ndescribe(\"PaginatedList.empty\", () => {\n  it(\"should return empty results\", async () => {\n    const list = PaginatedList.empty();\n    const result = await list.next({\n      after: list.getFirstCursor(),\n      limit: 10,\n      filter: {},\n      orderBy: {},\n      limitPrecision: \"exact\",\n    });\n\n    expect(result.items).toEqual([]);\n    expect(result.isFirst).toBe(true);\n    expect(result.isLast).toBe(true);\n  });\n\n  it(\"should have first cursor\", () => {\n    const list = PaginatedList.empty();\n    expect(list.getFirstCursor()).toBe(\"first\");\n    expect(list.getLastCursor()).toBe(\"last\");\n  });\n});\n\ndescribe(\"PaginatedList.map\", () => {\n  it(\"should transform items\", async () => {\n    const list = new ArrayPaginatedList([1, 2, 3]);\n    const doubled = list.map<number, NumberFilter, NumberOrderBy>({\n      itemMapper: (n) => n * 2,\n      oldItemFromNewItem: (n) => n / 2,\n      oldFilterFromNewFilter: (f) => f,\n      oldOrderByFromNewOrderBy: (o) => o,\n    });\n\n    const result = await doubled.next({\n      after: doubled.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([2, 4, 6]);\n  });\n\n  it(\"should preserve cursor semantics\", async () => {\n    const list = new ArrayPaginatedList([1, 2, 3]);\n    const doubled = list.map<number, NumberFilter, NumberOrderBy>({\n      itemMapper: (n) => n * 2,\n      oldItemFromNewItem: (n) => n / 2,\n      oldFilterFromNewFilter: (f) => f,\n      oldOrderByFromNewOrderBy: (o) => o,\n    });\n\n    const first = await doubled.next({\n      after: doubled.getFirstCursor(),\n      limit: 1,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(first)).toEqual([2]);\n\n    const second = await doubled.next({\n      after: first.cursor,\n      limit: 1,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(second)).toEqual([4]);\n  });\n});\n\ndescribe(\"PaginatedList.filter\", () => {\n  it(\"should filter items\", async () => {\n    const list = new ArrayPaginatedList([1, 2, 3, 4, 5, 6]);\n    const evens = list.filter({\n      filter: (n) => n % 2 === 0,\n      oldFilterFromNewFilter: () => () => true,\n      estimateItemsToFetch: ({ limit }) => limit * 2,\n    });\n\n    const result = await evens.next({\n      after: evens.getFirstCursor(),\n      limit: 10,\n      filter: undefined,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([2, 4, 6]);\n  });\n});\n\ndescribe(\"PaginatedList.addFilter\", () => {\n  it(\"should add additional filter constraint\", async () => {\n    const list = new ArrayPaginatedList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n\n    // First filter: only even\n    const evens = list.filter({\n      filter: (n) => n % 2 === 0,\n      oldFilterFromNewFilter: () => () => true,\n      estimateItemsToFetch: ({ limit }) => limit * 2,\n    });\n\n    // Add filter: only > 5\n    const evenAndGreaterThan5 = evens.addFilter({\n      filter: (n) => n > 5,\n      estimateItemsToFetch: ({ limit }) => limit * 2,\n    });\n\n    const result = await evenAndGreaterThan5.next({\n      after: evenAndGreaterThan5.getFirstCursor(),\n      limit: 10,\n      filter: undefined,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([6, 8, 10]);\n  });\n});\n\ndescribe(\"PaginatedList.flatMap\", () => {\n  it(\"should expand items\", async () => {\n    const list = new ArrayPaginatedList([1, 2, 3]);\n    const expanded = list.flatMap<number, `before-${number}`, NumberFilter, NumberOrderBy>({\n      itemMapper: (entry) => [\n        { item: entry.item, prevCursor: entry.prevCursor, nextCursor: entry.nextCursor },\n        { item: entry.item + 0.5, prevCursor: entry.prevCursor, nextCursor: entry.nextCursor },\n      ],\n      compare: (_, a, b) => a - b,\n      newCursorFromOldCursor: (c) => c,\n      oldCursorFromNewCursor: (c) => c,\n      oldFilterFromNewFilter: (f) => f,\n      oldOrderByFromNewOrderBy: (o) => o,\n      estimateItemsToFetch: ({ limit }) => limit,\n    });\n\n    const result = await expanded.next({\n      after: expanded.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([1, 1.5, 2, 2.5, 3, 3.5]);\n  });\n\n  it(\"should filter out items (return empty array)\", async () => {\n    const list = new ArrayPaginatedList([1, 2, 3, 4, 5]);\n    const evensOnly = list.flatMap<number, `before-${number}`, NumberFilter, NumberOrderBy>({\n      itemMapper: (entry) => entry.item % 2 === 0\n        ? [{ item: entry.item, prevCursor: entry.prevCursor, nextCursor: entry.nextCursor }]\n        : [],\n      compare: (_, a, b) => a - b,\n      newCursorFromOldCursor: (c) => c,\n      oldCursorFromNewCursor: (c) => c,\n      oldFilterFromNewFilter: (f) => f,\n      oldOrderByFromNewOrderBy: (o) => o,\n      estimateItemsToFetch: ({ limit }) => limit * 2,\n    });\n\n    const result = await evensOnly.next({\n      after: evensOnly.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([2, 4]);\n  });\n});\n\ndescribe(\"PaginatedList.merge\", () => {\n  it(\"should merge two lists\", async () => {\n    const list1 = new ArrayPaginatedList([1, 3, 5]);\n    const list2 = new ArrayPaginatedList([2, 4, 6]);\n\n    const merged = PaginatedList.merge(list1, list2);\n\n    const result = await merged.next({\n      after: merged.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([1, 2, 3, 4, 5, 6]);\n  });\n\n  it(\"should merge three lists\", async () => {\n    const list1 = new ArrayPaginatedList([1, 4, 7]);\n    const list2 = new ArrayPaginatedList([2, 5, 8]);\n    const list3 = new ArrayPaginatedList([3, 6, 9]);\n\n    const merged = PaginatedList.merge(list1, list2, list3);\n\n    const result = await merged.next({\n      after: merged.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);\n  });\n\n  it(\"should handle empty lists in merge\", async () => {\n    const list1 = new ArrayPaginatedList([1, 2, 3]);\n    const list2 = new ArrayPaginatedList<number>([]);\n\n    const merged = PaginatedList.merge(list1, list2);\n\n    const result = await merged.next({\n      after: merged.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([1, 2, 3]);\n  });\n\n  it(\"should paginate through merged list\", async () => {\n    const list1 = new ArrayPaginatedList([1, 3, 5, 7, 9]);\n    const list2 = new ArrayPaginatedList([2, 4, 6, 8, 10]);\n\n    const merged = PaginatedList.merge(list1, list2);\n\n    const first = await merged.next({\n      after: merged.getFirstCursor(),\n      limit: 4,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(first)).toEqual([1, 2, 3, 4]);\n\n    const second = await merged.next({\n      after: first.cursor,\n      limit: 4,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(second)).toEqual([5, 6, 7, 8]);\n  });\n\n  it(\"should have JSON-encoded cursor\", () => {\n    const list1 = new ArrayPaginatedList([1, 2]);\n    const list2 = new ArrayPaginatedList([3, 4]);\n\n    const merged = PaginatedList.merge(list1, list2);\n    const cursor = merged.getFirstCursor();\n\n    expect(() => JSON.parse(cursor)).not.toThrow();\n    expect(JSON.parse(cursor)).toEqual([\"before-0\", \"before-0\"]);\n  });\n\n  it(\"should paginate backward through merged list correctly\", async () => {\n    const list1 = new ArrayPaginatedList([1, 3, 5]);\n    const list2 = new ArrayPaginatedList([2, 4, 6]);\n\n    const merged = PaginatedList.merge(list1, list2);\n\n    // Get last 3 items going backward\n    const last = await merged.prev({\n      before: merged.getLastCursor(),\n      limit: 3,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(last)).toEqual([4, 5, 6]);\n    expect(last.isLast).toBe(true);\n    expect(last.isFirst).toBe(false);\n\n    // Continue backward to get previous 3 items\n    const middle = await merged.prev({\n      before: last.cursor,\n      limit: 3,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(middle)).toEqual([1, 2, 3]);\n    expect(middle.isFirst).toBe(true);\n  });\n\n  it(\"should paginate backward through entire merged list\", async () => {\n    const list1 = new ArrayPaginatedList([1, 3, 5, 7, 9]);\n    const list2 = new ArrayPaginatedList([2, 4, 6, 8, 10]);\n\n    const merged = PaginatedList.merge(list1, list2);\n    const allItems: number[] = [];\n\n    let cursor = merged.getLastCursor();\n    let isFirst = false;\n\n    while (!isFirst) {\n      const result = await merged.prev({\n        before: cursor,\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      allItems.unshift(...items(result));\n      cursor = result.cursor;\n      isFirst = result.isFirst;\n    }\n\n    expect(allItems).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n  });\n\n  it(\"should have consistent forward and backward pagination results\", async () => {\n    const list1 = new ArrayPaginatedList([1, 4, 7]);\n    const list2 = new ArrayPaginatedList([2, 5, 8]);\n    const list3 = new ArrayPaginatedList([3, 6, 9]);\n\n    const merged = PaginatedList.merge(list1, list2, list3);\n\n    // Collect all items going forward\n    const forwardItems: number[] = [];\n    let forwardCursor = merged.getFirstCursor();\n    let isLast = false;\n\n    while (!isLast) {\n      const result = await merged.next({\n        after: forwardCursor,\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      forwardItems.push(...items(result));\n      forwardCursor = result.cursor;\n      isLast = result.isLast;\n    }\n\n    // Collect all items going backward\n    const backwardItems: number[] = [];\n    let backwardCursor = merged.getLastCursor();\n    let isFirst = false;\n\n    while (!isFirst) {\n      const result = await merged.prev({\n        before: backwardCursor,\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      backwardItems.unshift(...items(result));\n      backwardCursor = result.cursor;\n      isFirst = result.isFirst;\n    }\n\n    // Both directions should yield the same final result\n    expect(forwardItems).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);\n    expect(backwardItems).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);\n  });\n});\n\ndescribe(\"edge cases\", () => {\n  it(\"should handle single item\", async () => {\n    const list = new ArrayPaginatedList([42]);\n    const result = await list.next({\n      after: list.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([42]);\n    expect(result.isFirst).toBe(true);\n    expect(result.isLast).toBe(true);\n  });\n\n  it(\"should handle duplicate values\", async () => {\n    const list = new ArrayPaginatedList([1, 1, 2, 2, 3, 3]);\n    const result = await list.next({\n      after: list.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([1, 1, 2, 2, 3, 3]);\n  });\n\n  it(\"should handle negative numbers\", async () => {\n    const list = new ArrayPaginatedList([-3, -1, 0, 1, 3]);\n    const result = await list.next({\n      after: list.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([-3, -1, 0, 1, 3]);\n  });\n\n  it(\"should handle string items\", async () => {\n    const list = new ArrayPaginatedList([\"banana\", \"apple\", \"cherry\"]);\n    const result = await list.next({\n      after: list.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => stringCompare(a, b),\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([\"apple\", \"banana\", \"cherry\"]);\n  });\n\n  it(\"should handle object items\", async () => {\n    const list = new ArrayPaginatedList([\n      { id: 1, value: \"a\" },\n      { id: 2, value: \"b\" },\n    ]);\n    const result = await list.next({\n      after: list.getFirstCursor(),\n      limit: 10,\n      filter: () => true,\n      orderBy: (a, b) => a.id - b.id,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(result)).toEqual([\n      { id: 1, value: \"a\" },\n      { id: 2, value: \"b\" },\n    ]);\n  });\n});\n\ndescribe(\"complete pagination walkthrough\", () => {\n  it(\"should paginate forward through entire list\", async () => {\n    const list = new ArrayPaginatedList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n    const allItems: number[] = [];\n\n    let cursor = list.getFirstCursor();\n    let isLast = false;\n\n    while (!isLast) {\n      const result = await list.next({\n        after: cursor,\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      allItems.push(...items(result));\n      cursor = result.cursor;\n      isLast = result.isLast;\n    }\n\n    expect(allItems).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n  });\n\n  it(\"should paginate backward through entire list\", async () => {\n    const list = new ArrayPaginatedList([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n    const allItems: number[] = [];\n\n    let cursor = list.getLastCursor();\n    let isFirst = false;\n\n    while (!isFirst) {\n      const result = await list.prev({\n        before: cursor,\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      allItems.unshift(...items(result));\n      cursor = result.cursor;\n      isFirst = result.isFirst;\n    }\n\n    expect(allItems).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);\n  });\n});\n\ndescribe(\"unsorted array pagination\", () => {\n  it(\"should correctly paginate through an unsorted array with sorting\", async () => {\n    const list = new ArrayPaginatedList([3, 1, 2]);\n\n    const first = await list.next({\n      after: list.getFirstCursor(),\n      limit: 2,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(first)).toEqual([1, 2]);\n\n    const second = await list.next({\n      after: first.cursor,\n      limit: 2,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(second)).toEqual([3]);\n  });\n\n  it(\"should maintain sorted order across pagination boundaries\", async () => {\n    const list = new ArrayPaginatedList([5, 4, 3, 2, 1]);\n    const allItems: number[] = [];\n\n    let cursor = list.getFirstCursor();\n    let isLast = false;\n\n    while (!isLast) {\n      const result = await list.next({\n        after: cursor,\n        limit: 2,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      allItems.push(...items(result));\n      cursor = result.cursor;\n      isLast = result.isLast;\n    }\n\n    expect(allItems).toEqual([1, 2, 3, 4, 5]);\n  });\n\n  it(\"should handle random order array correctly\", async () => {\n    const list = new ArrayPaginatedList([7, 2, 9, 1, 5, 8, 3, 6, 4]);\n\n    const allItems: number[] = [];\n    let cursor = list.getFirstCursor();\n    let isLast = false;\n\n    while (!isLast) {\n      const result = await list.next({\n        after: cursor,\n        limit: 3,\n        filter: () => true,\n        orderBy: (a, b) => a - b,\n        limitPrecision: \"exact\",\n      });\n\n      allItems.push(...items(result));\n      cursor = result.cursor;\n      isLast = result.isLast;\n    }\n\n    expect(allItems).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);\n  });\n\n  it(\"should have consistent cursor semantics with sorted data\", async () => {\n    const list = new ArrayPaginatedList([3, 1, 2]);\n\n    const first = await list.next({\n      after: list.getFirstCursor(),\n      limit: 1,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(first)).toEqual([1]);\n\n    const second = await list.next({\n      after: first.cursor,\n      limit: 1,\n      filter: () => true,\n      orderBy: (a, b) => a - b,\n      limitPrecision: \"exact\",\n    });\n\n    expect(items(second)).toEqual([2]);\n  });\n});\n\n"],"mappings":";;;;;AAQA,MAAM,SAAY,WAAqC,OAAO,MAAM,KAAI,MAAK,EAAE,KAAK;AAEpF,SAAS,4BAA4B;AACnC,UAAS,yCAAyC;AAChD,KAAG,mEAAmE,YAAY;GAChF,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAE,CAAC;GAC9C,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,UAAO,MAAM,OAAO,CAAC,CAAC,QAAQ;IAAC;IAAG;IAAG;IAAE,CAAC;AACxC,UAAO,OAAO,QAAQ,CAAC,KAAK,KAAK;AACjC,UAAO,OAAO,OAAO,CAAC,KAAK,KAAK;IAChC;AAEF,KAAG,mDAAmD,YAAY;GAChE,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GACpD,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,UAAO,MAAM,OAAO,CAAC,CAAC,QAAQ;IAAC;IAAG;IAAG;IAAE,CAAC;AACxC,UAAO,OAAO,QAAQ,CAAC,KAAK,KAAK;AACjC,UAAO,OAAO,OAAO,CAAC,KAAK,MAAM;IACjC;AAEF,KAAG,yCAAyC,YAAY;GACtD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GACpD,MAAM,QAAQ,MAAM,KAAK,KAAK;IAC5B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,UAAO,MAAM,MAAM,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;AACpC,UAAO,MAAM,OAAO,CAAC,KAAK,WAAW;GAErC,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO,MAAM;IACb,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,UAAO,MAAM,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;AACrC,UAAO,OAAO,QAAQ,CAAC,KAAK,MAAM;AAClC,UAAO,OAAO,OAAO,CAAC,KAAK,MAAM;IACjC;AAEF,KAAG,6BAA6B,YAAY;GAC1C,MAAM,OAAO,IAAI,mBAA2B,EAAE,CAAC;GAC/C,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,UAAO,MAAM,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;AACjC,UAAO,OAAO,QAAQ,CAAC,KAAK,KAAK;AACjC,UAAO,OAAO,OAAO,CAAC,KAAK,KAAK;IAChC;AAEF,KAAG,4BAA4B,YAAY;GACzC,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAE,CAAC;AAS9C,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,EAAE,CAAC;IACjC;GACF;AAEF,UAAS,oCAAoC;AAC3C,KAAG,qCAAqC,YAAY;GAClD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GACpD,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,QAAQ,KAAK,eAAe;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,UAAO,MAAM,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;AACrC,UAAO,OAAO,QAAQ,CAAC,KAAK,MAAM;AAClC,UAAO,OAAO,OAAO,CAAC,KAAK,KAAK;IAChC;AAEF,KAAG,uCAAuC,YAAY;GACpD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GAEpD,MAAM,OAAO,MAAM,KAAK,KAAK;IAC3B,QAAQ,KAAK,eAAe;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AACF,UAAO,MAAM,KAAK,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;GAEnC,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,QAAQ,KAAK;IACb,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AACF,UAAO,MAAM,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;GAErC,MAAM,QAAQ,MAAM,KAAK,KAAK;IAC5B,QAAQ,OAAO;IACf,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AACF,UAAO,MAAM,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;AACjC,UAAO,MAAM,QAAQ,CAAC,KAAK,KAAK;IAChC;GACF;AAEF,UAAS,sDAAsD;AAC7D,KAAG,+DAA+D,YAAY;GAC5E,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAI;IAAI;IAAG,CAAC;GACjD,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAGF,UAAO,OAAO,MAAM,GAAG,WAAW,CAAC,KAAK,WAAW;AACnD,UAAO,OAAO,MAAM,GAAG,WAAW,CAAC,KAAK,WAAW;AAGnD,UAAO,OAAO,MAAM,GAAG,WAAW,CAAC,KAAK,WAAW;AACnD,UAAO,OAAO,MAAM,GAAG,WAAW,CAAC,KAAK,WAAW;AAGnD,UAAO,OAAO,MAAM,GAAG,WAAW,CAAC,KAAK,WAAW;AACnD,UAAO,OAAO,MAAM,GAAG,WAAW,CAAC,KAAK,WAAW;IACnD;AAEF,KAAG,gEAAgE,YAAY;GAC7E,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GAEpD,MAAM,QAAQ,MAAM,KAAK,KAAK;IAC5B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;GAGF,MAAM,eAAe,MAAM,MAAM,MAAM,MAAM,SAAS,GAAG;AASzD,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,OAAO;IACP,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;IACrC;AAEF,KAAG,4CAA4C,YAAY;GACzD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GAGpD,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO;IACP,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,UAAO,MAAM,OAAO,CAAC,CAAC,QAAQ;IAAC;IAAG;IAAG;IAAE,CAAC;AACxC,UAAO,OAAO,MAAM,GAAG,WAAW,CAAC,KAAK,WAAW;AAWnD,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,QAAQ,OAAO,MAAM,GAAG;IACxB,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;IACrC;GACF;AAEF,UAAS,mBAAmB;AAC1B,KAAG,iCAAiC,YAAY;GAC9C,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;AASvD,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,SAAS,MAAM,IAAI,MAAM;IACzB,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;IAAC;IAAG;IAAG;IAAE,CAAC;IACxC;AAEF,KAAG,uCAAuC,YAAY;GACpD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG,CAAC;AASpE,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,SAAS,MAAM,IAAI,MAAM;IACzB,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;IACrC;AAEF,KAAG,6CAA6C,YAAY;GAC1D,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAE,CAAC;AAS9C,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,EAAE,CAAC;IACjC;GACF;AAEF,UAAS,kBAAkB;AACzB,KAAG,wCAAwC,YAAY;GACrD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;AASpD,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;IAC9C;AAEF,KAAG,yCAAyC,YAAY;GACtD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;AASpD,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;IAC9C;AAEF,KAAG,mCAAmC,YAAY;GAChD,MAAM,OAAO,IAAI,mBAAmB;IAClC;KAAE,MAAM;KAAW,KAAK;KAAI;IAC5B;KAAE,MAAM;KAAS,KAAK;KAAI;IAC1B;KAAE,MAAM;KAAO,KAAK;KAAI;IACzB,CAAC;AAUF,UAAO,MARQ,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,cAAc,EAAE,MAAM,EAAE,KAAK;IAChD,gBAAgB;IACjB,CAAC,CAEkB,CAAC,KAAI,MAAK,EAAE,KAAK,CAAC,CAAC,QAAQ;IAAC;IAAS;IAAO;IAAU,CAAC;AAU3E,UAAO,MARO,MAAM,KAAK,KAAK;IAC5B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,EAAE,MAAM,EAAE;IAC7B,gBAAgB;IACjB,CAAC,CAEiB,CAAC,KAAI,MAAK,EAAE,KAAK,CAAC,CAAC,QAAQ;IAAC;IAAS;IAAW;IAAM,CAAC;IAC1E;GACF;AAEF,UAAS,wBAAwB;AAC/B,KAAG,yCAAyC,YAAY;GACtD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;AASpD,WARe,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,EAEY,MAAM,OAAO,CAAC,KAAK,EAAE;IACnC;AAIF,KAAG,wEAAwE,YAAY;GACrF,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;AASpD,WARe,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,EAEY,MAAM,OAAO,CAAC,uBAAuB,EAAE;IACrD;AAEF,KAAG,2CAA2C,YAAY;GACxD,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;AASpD,WARe,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC,EAEY,MAAM,OAAO,CAAC,oBAAoB,EAAE;IAClD;AAEF,KAAG,4DAA4D,YAAY;GACzE,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAE,CAAC;GACpD,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO,KAAK,gBAAgB;IAC5B,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAIF,UAAO,OAAO,MAAM,OAAO,CAAC,gBAAgB,EAAE;AAE9C,UAAO,MAAM,OAAO,CAAC,OAAM,MAAK,OAAO,MAAM,SAAS,CAAC,CAAC,KAAK,KAAK;IAClE;AAEF,KAAG,yDAAyD,YAAY;GACtE,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG;IAAG,CAAC;GACpE,MAAM,WAAqB,EAAE;GAE7B,IAAI,SAAS,KAAK,gBAAgB;GAClC,IAAI,aAAa;GACjB,MAAM,gBAAgB;AAEtB,UAAO,aAAa,eAAe;IACjC,MAAM,SAAS,MAAM,KAAK,KAAK;KAC7B,OAAO;KACP,OAAO;KACP,cAAc;KACd,UAAU,GAAG,MAAM,IAAI;KACvB,gBAAgB;KACjB,CAAC;AAEF,QAAI,OAAO,MAAM,WAAW,EAAG;AAE/B,aAAS,KAAK,GAAG,MAAM,OAAO,CAAC;AAE/B,WAAO,OAAO,OAAO,CAAC,IAAI,KAAK,OAAO;AACtC,aAAS,OAAO;AAChB;AAEA,QAAI,OAAO,OAAQ;;AAIrB,UAAO,SAAS,OAAO,CAAC,gBAAgB,EAAE;IAC1C;GACF;AAEF,UAAS,0CAA0C;AACjD,KAAG,6CAA6C;GAC9C,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAE,CAAC;AAC9C,UAAO,KAAK,gBAAgB,CAAC,CAAC,KAAK,WAAW;AAC9C,UAAO,KAAK,eAAe,CAAC,CAAC,KAAK,WAAW;IAC7C;AAEF,KAAG,qCAAqC;GACtC,MAAM,OAAO,IAAI,mBAAmB,EAAE,CAAC;AACvC,UAAO,KAAK,gBAAgB,CAAC,CAAC,KAAK,WAAW;AAC9C,UAAO,KAAK,eAAe,CAAC,CAAC,KAAK,WAAW;IAC7C;GACF;AAEF,UAAS,iBAAiB;AACxB,KAAG,yDAAyD;GAC1D,MAAM,OAAO,IAAI,mBAAmB;IAAC;IAAG;IAAG;IAAE,CAAC;GAC9C,MAAM,WAAW,GAAW,MAAc,IAAI;AAE9C,UAAO,KAAK,QAAQ,SAAS,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE;AACnD,UAAO,KAAK,QAAQ,SAAS,GAAG,EAAE,CAAC,CAAC,gBAAgB,EAAE;AACtD,UAAO,KAAK,QAAQ,SAAS,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE;IAC3C;GACF;EACF;AAEF,SAAS,6BAA6B;AACpC,IAAG,+BAA+B,YAAY;EAC5C,MAAM,OAAO,cAAc,OAAO;EAClC,MAAM,SAAS,MAAM,KAAK,KAAK;GAC7B,OAAO,KAAK,gBAAgB;GAC5B,OAAO;GACP,QAAQ,EAAE;GACV,SAAS,EAAE;GACX,gBAAgB;GACjB,CAAC;AAEF,SAAO,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;AAChC,SAAO,OAAO,QAAQ,CAAC,KAAK,KAAK;AACjC,SAAO,OAAO,OAAO,CAAC,KAAK,KAAK;GAChC;AAEF,IAAG,kCAAkC;EACnC,MAAM,OAAO,cAAc,OAAO;AAClC,SAAO,KAAK,gBAAgB,CAAC,CAAC,KAAK,QAAQ;AAC3C,SAAO,KAAK,eAAe,CAAC,CAAC,KAAK,OAAO;GACzC;EACF;AAEF,SAAS,2BAA2B;AAClC,IAAG,0BAA0B,YAAY;EAEvC,MAAM,UADO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC,CACzB,IAAyC;GAC5D,aAAa,MAAM,IAAI;GACvB,qBAAqB,MAAM,IAAI;GAC/B,yBAAyB,MAAM;GAC/B,2BAA2B,MAAM;GAClC,CAAC;AAUF,SAAO,MARQ,MAAM,QAAQ,KAAK;GAChC,OAAO,QAAQ,gBAAgB;GAC/B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAE,CAAC;GACxC;AAEF,IAAG,oCAAoC,YAAY;EAEjD,MAAM,UADO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC,CACzB,IAAyC;GAC5D,aAAa,MAAM,IAAI;GACvB,qBAAqB,MAAM,IAAI;GAC/B,yBAAyB,MAAM;GAC/B,2BAA2B,MAAM;GAClC,CAAC;EAEF,MAAM,QAAQ,MAAM,QAAQ,KAAK;GAC/B,OAAO,QAAQ,gBAAgB;GAC/B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC;AAEF,SAAO,MAAM,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;AAUjC,SAAO,MARQ,MAAM,QAAQ,KAAK;GAChC,OAAO,MAAM;GACb,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;GAClC;EACF;AAEF,SAAS,8BAA8B;AACrC,IAAG,uBAAuB,YAAY;EAEpC,MAAM,QADO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC,CACpC,OAAO;GACxB,SAAS,MAAM,IAAI,MAAM;GACzB,oCAAoC;GACpC,uBAAuB,EAAE,YAAY,QAAQ;GAC9C,CAAC;AAUF,SAAO,MARQ,MAAM,MAAM,KAAK;GAC9B,OAAO,MAAM,gBAAgB;GAC7B,OAAO;GACP,QAAQ;GACR,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAE,CAAC;GACxC;EACF;AAEF,SAAS,iCAAiC;AACxC,IAAG,2CAA2C,YAAY;EAWxD,MAAM,sBAVO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG,CAAC,CAGjD,OAAO;GACxB,SAAS,MAAM,IAAI,MAAM;GACzB,oCAAoC;GACpC,uBAAuB,EAAE,YAAY,QAAQ;GAC9C,CAAC,CAGgC,UAAU;GAC1C,SAAS,MAAM,IAAI;GACnB,uBAAuB,EAAE,YAAY,QAAQ;GAC9C,CAAC;AAUF,SAAO,MARQ,MAAM,oBAAoB,KAAK;GAC5C,OAAO,oBAAoB,gBAAgB;GAC3C,OAAO;GACP,QAAQ;GACR,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG,CAAC;GACzC;EACF;AAEF,SAAS,+BAA+B;AACtC,IAAG,uBAAuB,YAAY;EAEpC,MAAM,WADO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC,CACxB,QAAiE;GACrF,aAAa,UAAU,CACrB;IAAE,MAAM,MAAM;IAAM,YAAY,MAAM;IAAY,YAAY,MAAM;IAAY,EAChF;IAAE,MAAM,MAAM,OAAO;IAAK,YAAY,MAAM;IAAY,YAAY,MAAM;IAAY,CACvF;GACD,UAAU,GAAG,GAAG,MAAM,IAAI;GAC1B,yBAAyB,MAAM;GAC/B,yBAAyB,MAAM;GAC/B,yBAAyB,MAAM;GAC/B,2BAA2B,MAAM;GACjC,uBAAuB,EAAE,YAAY;GACtC,CAAC;AAUF,SAAO,MARQ,MAAM,SAAS,KAAK;GACjC,OAAO,SAAS,gBAAgB;GAChC,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAK;GAAG;GAAK;GAAG;GAAI,CAAC;GACvD;AAEF,IAAG,gDAAgD,YAAY;EAE7D,MAAM,YADO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC,CAC7B,QAAiE;GACtF,aAAa,UAAU,MAAM,OAAO,MAAM,IACtC,CAAC;IAAE,MAAM,MAAM;IAAM,YAAY,MAAM;IAAY,YAAY,MAAM;IAAY,CAAC,GAClF,EAAE;GACN,UAAU,GAAG,GAAG,MAAM,IAAI;GAC1B,yBAAyB,MAAM;GAC/B,yBAAyB,MAAM;GAC/B,yBAAyB,MAAM;GAC/B,2BAA2B,MAAM;GACjC,uBAAuB,EAAE,YAAY,QAAQ;GAC9C,CAAC;AAUF,SAAO,MARQ,MAAM,UAAU,KAAK;GAClC,OAAO,UAAU,gBAAgB;GACjC,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;GACrC;EACF;AAEF,SAAS,6BAA6B;AACpC,IAAG,0BAA0B,YAAY;EACvC,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAC/C,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAE/C,MAAM,SAAS,cAAc,MAAM,OAAO,MAAM;AAUhD,SAAO,MARQ,MAAM,OAAO,KAAK;GAC/B,OAAO,OAAO,gBAAgB;GAC9B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;GACjD;AAEF,IAAG,4BAA4B,YAAY;EACzC,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAC/C,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAC/C,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAE/C,MAAM,SAAS,cAAc,MAAM,OAAO,OAAO,MAAM;AAUvD,SAAO,MARQ,MAAM,OAAO,KAAK;GAC/B,OAAO,OAAO,gBAAgB;GAC9B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;GAC1D;AAEF,IAAG,sCAAsC,YAAY;EACnD,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAC/C,MAAM,QAAQ,IAAI,mBAA2B,EAAE,CAAC;EAEhD,MAAM,SAAS,cAAc,MAAM,OAAO,MAAM;AAUhD,SAAO,MARQ,MAAM,OAAO,KAAK;GAC/B,OAAO,OAAO,gBAAgB;GAC9B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAE,CAAC;GACxC;AAEF,IAAG,uCAAuC,YAAY;EACpD,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;EACrD,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG,CAAC;EAEtD,MAAM,SAAS,cAAc,MAAM,OAAO,MAAM;EAEhD,MAAM,QAAQ,MAAM,OAAO,KAAK;GAC9B,OAAO,OAAO,gBAAgB;GAC9B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC;AAEF,SAAO,MAAM,MAAM,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAE,CAAC;AAU1C,SAAO,MARQ,MAAM,OAAO,KAAK;GAC/B,OAAO,MAAM;GACb,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAE,CAAC;GAC3C;AAEF,IAAG,yCAAyC;EAC1C,MAAM,QAAQ,IAAI,mBAAmB,CAAC,GAAG,EAAE,CAAC;EAC5C,MAAM,QAAQ,IAAI,mBAAmB,CAAC,GAAG,EAAE,CAAC;EAG5C,MAAM,SADS,cAAc,MAAM,OAAO,MAAM,CAC1B,gBAAgB;AAEtC,eAAa,KAAK,MAAM,OAAO,CAAC,CAAC,IAAI,SAAS;AAC9C,SAAO,KAAK,MAAM,OAAO,CAAC,CAAC,QAAQ,CAAC,YAAY,WAAW,CAAC;GAC5D;AAEF,IAAG,0DAA0D,YAAY;EACvE,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAC/C,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAE/C,MAAM,SAAS,cAAc,MAAM,OAAO,MAAM;EAGhD,MAAM,OAAO,MAAM,OAAO,KAAK;GAC7B,QAAQ,OAAO,eAAe;GAC9B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC;AAEF,SAAO,MAAM,KAAK,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAE,CAAC;AACtC,SAAO,KAAK,OAAO,CAAC,KAAK,KAAK;AAC9B,SAAO,KAAK,QAAQ,CAAC,KAAK,MAAM;EAGhC,MAAM,SAAS,MAAM,OAAO,KAAK;GAC/B,QAAQ,KAAK;GACb,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC;AAEF,SAAO,MAAM,OAAO,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAE,CAAC;AACxC,SAAO,OAAO,QAAQ,CAAC,KAAK,KAAK;GACjC;AAEF,IAAG,uDAAuD,YAAY;EACpE,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;EACrD,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG,CAAC;EAEtD,MAAM,SAAS,cAAc,MAAM,OAAO,MAAM;EAChD,MAAM,WAAqB,EAAE;EAE7B,IAAI,SAAS,OAAO,eAAe;EACnC,IAAI,UAAU;AAEd,SAAO,CAAC,SAAS;GACf,MAAM,SAAS,MAAM,OAAO,KAAK;IAC/B,QAAQ;IACR,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,YAAS,QAAQ,GAAG,MAAM,OAAO,CAAC;AAClC,YAAS,OAAO;AAChB,aAAU,OAAO;;AAGnB,SAAO,SAAS,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG,CAAC;GACzD;AAEF,IAAG,kEAAkE,YAAY;EAC/E,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAC/C,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAC/C,MAAM,QAAQ,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAE/C,MAAM,SAAS,cAAc,MAAM,OAAO,OAAO,MAAM;EAGvD,MAAM,eAAyB,EAAE;EACjC,IAAI,gBAAgB,OAAO,gBAAgB;EAC3C,IAAI,SAAS;AAEb,SAAO,CAAC,QAAQ;GACd,MAAM,SAAS,MAAM,OAAO,KAAK;IAC/B,OAAO;IACP,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,gBAAa,KAAK,GAAG,MAAM,OAAO,CAAC;AACnC,mBAAgB,OAAO;AACvB,YAAS,OAAO;;EAIlB,MAAM,gBAA0B,EAAE;EAClC,IAAI,iBAAiB,OAAO,eAAe;EAC3C,IAAI,UAAU;AAEd,SAAO,CAAC,SAAS;GACf,MAAM,SAAS,MAAM,OAAO,KAAK;IAC/B,QAAQ;IACR,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,iBAAc,QAAQ,GAAG,MAAM,OAAO,CAAC;AACvC,oBAAiB,OAAO;AACxB,aAAU,OAAO;;AAInB,SAAO,aAAa,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;AACzD,SAAO,cAAc,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;GAC1D;EACF;AAEF,SAAS,oBAAoB;AAC3B,IAAG,6BAA6B,YAAY;EAC1C,MAAM,OAAO,IAAI,mBAAmB,CAAC,GAAG,CAAC;EACzC,MAAM,SAAS,MAAM,KAAK,KAAK;GAC7B,OAAO,KAAK,gBAAgB;GAC5B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC;AAEF,SAAO,MAAM,OAAO,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC;AACnC,SAAO,OAAO,QAAQ,CAAC,KAAK,KAAK;AACjC,SAAO,OAAO,OAAO,CAAC,KAAK,KAAK;GAChC;AAEF,IAAG,kCAAkC,YAAY;EAC/C,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;AASvD,SAAO,MARQ,MAAM,KAAK,KAAK;GAC7B,OAAO,KAAK,gBAAgB;GAC5B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;GACjD;AAEF,IAAG,kCAAkC,YAAY;EAC/C,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAI;GAAI;GAAG;GAAG;GAAE,CAAC;AAStD,SAAO,MARQ,MAAM,KAAK,KAAK;GAC7B,OAAO,KAAK,gBAAgB;GAC5B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAI;GAAI;GAAG;GAAG;GAAE,CAAC;GAChD;AAEF,IAAG,8BAA8B,YAAY;EAC3C,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAU;GAAS;GAAS,CAAC;AASlE,SAAO,MARQ,MAAM,KAAK,KAAK;GAC7B,OAAO,KAAK,gBAAgB;GAC5B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,cAAc,GAAG,EAAE;GACtC,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ;GAAC;GAAS;GAAU;GAAS,CAAC;GAC5D;AAEF,IAAG,8BAA8B,YAAY;EAC3C,MAAM,OAAO,IAAI,mBAAmB,CAClC;GAAE,IAAI;GAAG,OAAO;GAAK,EACrB;GAAE,IAAI;GAAG,OAAO;GAAK,CACtB,CAAC;AASF,SAAO,MARQ,MAAM,KAAK,KAAK;GAC7B,OAAO,KAAK,gBAAgB;GAC5B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,EAAE,KAAK,EAAE;GAC5B,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,CAC5B;GAAE,IAAI;GAAG,OAAO;GAAK,EACrB;GAAE,IAAI;GAAG,OAAO;GAAK,CACtB,CAAC;GACF;EACF;AAEF,SAAS,yCAAyC;AAChD,IAAG,+CAA+C,YAAY;EAC5D,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG,CAAC;EACpE,MAAM,WAAqB,EAAE;EAE7B,IAAI,SAAS,KAAK,gBAAgB;EAClC,IAAI,SAAS;AAEb,SAAO,CAAC,QAAQ;GACd,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO;IACP,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,YAAS,KAAK,GAAG,MAAM,OAAO,CAAC;AAC/B,YAAS,OAAO;AAChB,YAAS,OAAO;;AAGlB,SAAO,SAAS,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG,CAAC;GACzD;AAEF,IAAG,gDAAgD,YAAY;EAC7D,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG,CAAC;EACpE,MAAM,WAAqB,EAAE;EAE7B,IAAI,SAAS,KAAK,eAAe;EACjC,IAAI,UAAU;AAEd,SAAO,CAAC,SAAS;GACf,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,QAAQ;IACR,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,YAAS,QAAQ,GAAG,MAAM,OAAO,CAAC;AAClC,YAAS,OAAO;AAChB,aAAU,OAAO;;AAGnB,SAAO,SAAS,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG,CAAC;GACzD;EACF;AAEF,SAAS,mCAAmC;AAC1C,IAAG,oEAAoE,YAAY;EACjF,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAE9C,MAAM,QAAQ,MAAM,KAAK,KAAK;GAC5B,OAAO,KAAK,gBAAgB;GAC5B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC;AAEF,SAAO,MAAM,MAAM,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;AAUpC,SAAO,MARQ,MAAM,KAAK,KAAK;GAC7B,OAAO,MAAM;GACb,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;GAClC;AAEF,IAAG,6DAA6D,YAAY;EAC1E,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;EACpD,MAAM,WAAqB,EAAE;EAE7B,IAAI,SAAS,KAAK,gBAAgB;EAClC,IAAI,SAAS;AAEb,SAAO,CAAC,QAAQ;GACd,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO;IACP,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,YAAS,KAAK,GAAG,MAAM,OAAO,CAAC;AAC/B,YAAS,OAAO;AAChB,YAAS,OAAO;;AAGlB,SAAO,SAAS,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;GACzC;AAEF,IAAG,8CAA8C,YAAY;EAC3D,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;EAEhE,MAAM,WAAqB,EAAE;EAC7B,IAAI,SAAS,KAAK,gBAAgB;EAClC,IAAI,SAAS;AAEb,SAAO,CAAC,QAAQ;GACd,MAAM,SAAS,MAAM,KAAK,KAAK;IAC7B,OAAO;IACP,OAAO;IACP,cAAc;IACd,UAAU,GAAG,MAAM,IAAI;IACvB,gBAAgB;IACjB,CAAC;AAEF,YAAS,KAAK,GAAG,MAAM,OAAO,CAAC;AAC/B,YAAS,OAAO;AAChB,YAAS,OAAO;;AAGlB,SAAO,SAAS,CAAC,QAAQ;GAAC;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAG;GAAE,CAAC;GACrD;AAEF,IAAG,4DAA4D,YAAY;EACzE,MAAM,OAAO,IAAI,mBAAmB;GAAC;GAAG;GAAG;GAAE,CAAC;EAE9C,MAAM,QAAQ,MAAM,KAAK,KAAK;GAC5B,OAAO,KAAK,gBAAgB;GAC5B,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC;AAEF,SAAO,MAAM,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;AAUjC,SAAO,MARQ,MAAM,KAAK,KAAK;GAC7B,OAAO,MAAM;GACb,OAAO;GACP,cAAc;GACd,UAAU,GAAG,MAAM,IAAI;GACvB,gBAAgB;GACjB,CAAC,CAEkB,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC;GAClC;EACF"}

package/dist/esm/utils/passkey.d.ts

@@ -0,0 +1,2 @@
+import { AuthenticationResponseJSON, AuthenticatorAttestationResponseJSON, PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON, RegistrationResponseJSON } from "@simplewebauthn/types";
+export { type AuthenticationResponseJSON, type AuthenticatorAttestationResponseJSON, type PublicKeyCredentialCreationOptionsJSON, type PublicKeyCredentialRequestOptionsJSON, type RegistrationResponseJSON };

package/dist/esm/utils/passkey.js

@@ -0,0 +1 @@
+export {  };

package/dist/esm/utils/promises.d.ts

@@ -0,0 +1,80 @@
+import { Result } from "./results";
+
+//#region src/utils/promises.d.ts
+type ReactPromise<T> = Promise<T> & ({
+  status: "rejected";
+  reason: unknown;
+} | {
+  status: "fulfilled";
+  value: T;
+} | {
+  status: "pending";
+});
+type Resolve<T> = (value: T) => void;
+type Reject = (reason: unknown) => void;
+declare function createPromise<T>(callback: (resolve: Resolve<T>, reject: Reject) => void): ReactPromise<T>;
+/**
+ * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook, and caches
+ * the value so that invoking `resolved` twice returns the same promise.
+ */
+declare function resolved<T>(value: T): ReactPromise<T>;
+/**
+ * Like Promise.reject(...), but also adds the status and value properties for use with React's `use` hook, and caches
+ * the value so that invoking `rejected` twice returns the same promise.
+ */
+declare function rejected<T>(reason: unknown): ReactPromise<T>;
+declare function neverResolve(): ReactPromise<never>;
+declare function pending<T>(promise: Promise<T>, options?: {
+  disableErrorWrapping?: boolean;
+}): ReactPromise<T>;
+/**
+ * Should be used to wrap Promises that are not immediately awaited, so they don't throw an unhandled promise rejection
+ * error.
+ *
+ * Vercel kills serverless functions on unhandled promise rejection errors, so this is important.
+ */
+declare function ignoreUnhandledRejection<T extends Promise<any>>(promise: T): void;
+/**
+ * See concatStacktraces for more information.
+ */
+declare function concatStacktracesIfRejected<T>(promise: Promise<T>): void;
+declare function wait(ms: number): Promise<void>;
+declare function waitUntil(date: Date): Promise<void>;
+declare function runAsynchronouslyWithAlert(...args: Parameters<typeof runAsynchronously>): void;
+declare function runAsynchronously(promiseOrFunc: void | Promise<unknown> | (() => void | Promise<unknown>) | undefined, options?: {
+  noErrorLogging?: boolean;
+  onError?: (error: Error) => void;
+}): void;
+declare class TimeoutError extends Error {
+  readonly ms: number;
+  constructor(ms: number);
+}
+declare function timeout<T>(promiseOrFunc: Promise<T> | (() => Promise<T>), ms: number): Promise<Result<T, TimeoutError>>;
+declare function timeoutThrow<T>(promise: Promise<T>, ms: number): Promise<T>;
+type RateLimitOptions = {
+  /**
+   * The number of requests to process in parallel. Currently only 1 is supported.
+   */
+  concurrency: 1;
+  /**
+   * If true, multiple requests waiting at the same time will be reduced to just one. Default is false.
+   */
+  batchCalls?: boolean;
+  /**
+   * Waits for throttleMs since the start of last request before starting the next request. Default is 0.
+   */
+  throttleMs?: number;
+  /**
+   * Waits for gapMs since the end of last request before starting the next request. Default is 0.
+   */
+  gapMs?: number;
+  /**
+   * Waits until there have been no new requests for debounceMs before starting a new request. Default is 0.
+   */
+  debounceMs?: number;
+};
+declare function rateLimited<T>(func: () => Promise<T>, options: RateLimitOptions): () => Promise<T>;
+declare function throttled<T, A extends any[]>(func: (...args: A) => Promise<T>, delayMs: number): (...args: A) => Promise<T>;
+//#endregion
+export { RateLimitOptions, ReactPromise, concatStacktracesIfRejected, createPromise, ignoreUnhandledRejection, neverResolve, pending, rateLimited, rejected, resolved, runAsynchronously, runAsynchronouslyWithAlert, throttled, timeout, timeoutThrow, wait, waitUntil };
+//# sourceMappingURL=promises.d.ts.map

package/dist/esm/utils/promises.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.d.ts","names":[],"sources":["../../../src/utils/promises.tsx"],"mappings":";;;KAQY,YAAA,MAAkB,OAAA,CAAQ,CAAA;EAChC,MAAA;EAAoB,MAAA;AAAA;EACpB,MAAA;EAAqB,KAAA,EAAO,CAAA;AAAA;EAC5B,MAAA;AAAA;AAAA,KAGD,OAAA,OAAc,KAAA,EAAO,CAAA;AAAA,KACrB,MAAA,IAAU,MAAA;AAAA,iBACC,aAAA,GAAA,CAAiB,QAAA,GAAW,OAAA,EAAS,OAAA,CAAQ,CAAA,GAAI,MAAA,EAAQ,MAAA,YAAkB,YAAA,CAAa,CAAA;;;;;iBAwExF,QAAA,GAAA,CAAY,KAAA,EAAO,CAAA,GAAI,YAAA,CAAa,CAAA;;;;;iBA0CpC,QAAA,GAAA,CAAY,MAAA,YAAkB,YAAA,CAAa,CAAA;AAAA,iBA6C3C,YAAA,CAAA,GAAgB,YAAA;AAAA,iBAchB,OAAA,GAAA,CAAW,OAAA,EAAS,OAAA,CAAQ,CAAA,GAAI,OAAA;EAAW,oBAAA;AAAA,IAAwC,YAAA,CAAa,CAAA;;;;;AA/KrF;;iBAuNX,wBAAA,WAAmC,OAAA,MAAA,CAAc,OAAA,EAAS,CAAA;;;AArN1E;iBA0OgB,2BAAA,GAAA,CAA+B,OAAA,EAAS,OAAA,CAAQ,CAAA;AAAA,iBAW1C,IAAA,CAAK,EAAA,WAAU,OAAA;AAAA,iBAgCf,SAAA,CAAU,IAAA,EAAM,IAAA,GAAI,OAAA;AAAA,iBAsB1B,0BAAA,CAAA,GAA8B,IAAA,EAAM,UAAA,QAAkB,iBAAA;AAAA,iBAgCtD,iBAAA,CACd,aAAA,SAAsB,OAAA,0BAAiC,OAAA,wBACvD,OAAA;EACE,cAAA;EACA,OAAA,IAAW,KAAA,EAAO,KAAA;AAAA;AAAA,cAoChB,YAAA,SAAqB,KAAA;EAAA,SACG,EAAA;cAAA,EAAA;AAAA;AAAA,iBAMR,OAAA,GAAA,CAAW,aAAA,EAAe,OAAA,CAAQ,CAAA,WAAY,OAAA,CAAQ,CAAA,IAAK,EAAA,WAAa,OAAA,CAAQ,MAAA,CAAO,CAAA,EAAG,YAAA;AAAA,iBA0B1F,YAAA,GAAA,CAAgB,OAAA,EAAS,OAAA,CAAQ,CAAA,GAAI,EAAA,WAAa,OAAA,CAAQ,CAAA;AAAA,KAgBpE,gBAAA;EApaqB;;;EAwa/B,WAAA;EAxauG;AAwEzG;;EAqWE,UAAA;EArWiC;;;EA0WjC,UAAA;EA1WiD;;;EA+WjD,KAAA;EA/WqC;;;EAoXrC,UAAA;AAAA;AAAA,iBAGc,WAAA,GAAA,CACd,IAAA,QAAY,OAAA,CAAQ,CAAA,GACpB,OAAA,EAAS,gBAAA,SACF,OAAA,CAAQ,CAAA;AAAA,iBA0DD,SAAA,oBAAA,CAA8B,IAAA,MAAU,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,CAAA,GAAI,OAAA,eAAsB,IAAA,EAAM,CAAA,KAAM,OAAA,CAAQ,CAAA"}

package/dist/esm/utils/promises.js

@@ -0,0 +1,333 @@
+import { HexclaveAssertionError, captureError, concatStacktraces, errorToNiceString } from "./errors.js";
+import { getProcessEnv } from "./env.js";
+import { DependenciesMap } from "./maps.js";
+import { Result } from "./results.js";
+import { traceSpan } from "./telemetry.js";
+import { KnownError } from "../index.js";
+import { generateUuid } from "./uuids.js";
+
+//#region src/utils/promises.tsx
+function createPromise(callback) {
+	let status = "pending";
+	let valueOrReason = void 0;
+	let resolve = null;
+	let reject = null;
+	const promise = new Promise((res, rej) => {
+		resolve = (value) => {
+			if (status !== "pending") return;
+			status = "fulfilled";
+			valueOrReason = value;
+			res(value);
+		};
+		reject = (reason) => {
+			if (status !== "pending") return;
+			status = "rejected";
+			valueOrReason = reason;
+			rej(reason);
+		};
+	});
+	callback(resolve, reject);
+	return Object.assign(promise, {
+		status,
+		...status === "fulfilled" ? { value: valueOrReason } : {},
+		...status === "rejected" ? { reason: valueOrReason } : {}
+	});
+}
+(void 0)?.test("createPromise", async ({ expect }) => {
+	const resolvedPromise = createPromise((resolve) => {
+		resolve(42);
+	});
+	expect(resolvedPromise.status).toBe("fulfilled");
+	expect(resolvedPromise.value).toBe(42);
+	expect(await resolvedPromise).toBe(42);
+	const error = /* @__PURE__ */ new Error("Test error");
+	const rejectedPromise = createPromise((_, reject) => {
+		reject(error);
+	});
+	expect(rejectedPromise.status).toBe("rejected");
+	expect(rejectedPromise.reason).toBe(error);
+	await expect(rejectedPromise).rejects.toBe(error);
+	const pendingPromise = createPromise(() => {});
+	expect(pendingPromise.status).toBe("pending");
+	expect(pendingPromise.value).toBeUndefined();
+	expect(pendingPromise.reason).toBeUndefined();
+	let resolveCount = 0;
+	const multiResolvePromise = createPromise((resolve) => {
+		resolve(1);
+		resolveCount++;
+		resolve(2);
+		resolveCount++;
+	});
+	expect(resolveCount).toBe(2);
+	expect(multiResolvePromise.status).toBe("fulfilled");
+	expect(multiResolvePromise.value).toBe(1);
+	expect(await multiResolvePromise).toBe(1);
+});
+let resolvedCache = null;
+/**
+* Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook, and caches
+* the value so that invoking `resolved` twice returns the same promise.
+*/
+function resolved(value) {
+	resolvedCache ??= new DependenciesMap();
+	if (resolvedCache.has([value])) return resolvedCache.get([value]);
+	const res = Object.assign(Promise.resolve(value), {
+		status: "fulfilled",
+		value
+	});
+	resolvedCache.set([value], res);
+	return res;
+}
+(void 0)?.test("resolved", async ({ expect }) => {
+	const promise1 = resolved(42);
+	expect(promise1.status).toBe("fulfilled");
+	expect(promise1.value).toBe(42);
+	expect(await promise1).toBe(42);
+	const obj = { test: true };
+	const promise2 = resolved(obj);
+	expect(promise2.status).toBe("fulfilled");
+	expect(promise2.value).toBe(obj);
+	expect(await promise2).toBe(obj);
+	expect(resolved(42)).toBe(promise1);
+	expect(resolved(43)).not.toBe(promise1);
+});
+let rejectedCache = null;
+/**
+* Like Promise.reject(...), but also adds the status and value properties for use with React's `use` hook, and caches
+* the value so that invoking `rejected` twice returns the same promise.
+*/
+function rejected(reason) {
+	rejectedCache ??= new DependenciesMap();
+	if (rejectedCache.has([reason])) return rejectedCache.get([reason]);
+	const promise = Promise.reject(reason);
+	ignoreUnhandledRejection(promise);
+	const res = Object.assign(promise, {
+		status: "rejected",
+		reason
+	});
+	rejectedCache.set([reason], res);
+	return res;
+}
+(void 0)?.test("rejected", ({ expect }) => {
+	const error = /* @__PURE__ */ new Error("Test error");
+	const promise1 = rejected(error);
+	expect(promise1.status).toBe("rejected");
+	expect(promise1.reason).toBe(error);
+	const promise2 = rejected("error message");
+	expect(promise2.status).toBe("rejected");
+	expect(promise2.reason).toBe("error message");
+	expect(rejected(error)).toBe(promise1);
+	expect(rejected(/* @__PURE__ */ new Error("Different error"))).not.toBe(promise1);
+});
+const neverResolvePromise = pending(new Promise(() => {}));
+function neverResolve() {
+	return neverResolvePromise;
+}
+(void 0)?.test("neverResolve", ({ expect }) => {
+	const promise = neverResolve();
+	expect(promise.status).toBe("pending");
+	expect(promise.value).toBeUndefined();
+	expect(promise.reason).toBeUndefined();
+	expect(neverResolve()).toBe(promise);
+});
+function pending(promise, options = {}) {
+	const res = promise.then((value) => {
+		res.status = "fulfilled";
+		res.value = value;
+		return value;
+	}, (actualReason) => {
+		res.status = "rejected";
+		res.reason = actualReason;
+		throw actualReason;
+	});
+	res.status = "pending";
+	return res;
+}
+(void 0)?.test("pending", async ({ expect }) => {
+	const resolvePromise = Promise.resolve(42);
+	const pendingPromise = pending(resolvePromise);
+	expect(pendingPromise.status).toBe("pending");
+	await resolvePromise;
+	await new Promise((resolve) => setTimeout(resolve, 0));
+	expect(pendingPromise.status).toBe("fulfilled");
+	expect(pendingPromise.value).toBe(42);
+});
+/**
+* Should be used to wrap Promises that are not immediately awaited, so they don't throw an unhandled promise rejection
+* error.
+*
+* Vercel kills serverless functions on unhandled promise rejection errors, so this is important.
+*/
+function ignoreUnhandledRejection(promise) {
+	promise.catch(() => {});
+}
+(void 0)?.test("ignoreUnhandledRejection", async ({ expect }) => {
+	const resolvePromise = Promise.resolve(42);
+	ignoreUnhandledRejection(resolvePromise);
+	expect(await resolvePromise).toBe(42);
+	const error = /* @__PURE__ */ new Error("Test error");
+	const rejectPromise = Promise.reject(error);
+	ignoreUnhandledRejection(rejectPromise);
+	await expect(rejectPromise).rejects.toBe(error);
+});
+/**
+* See concatStacktraces for more information.
+*/
+function concatStacktracesIfRejected(promise) {
+	const currentError = /* @__PURE__ */ new Error();
+	promise.catch((error) => {
+		if (error instanceof Error) concatStacktraces(error, currentError);
+	});
+}
+async function wait(ms) {
+	if (!Number.isFinite(ms) || ms < 0) throw new HexclaveAssertionError(`wait() requires a non-negative integer number of milliseconds to wait. (found: ${ms}ms)`);
+	if (ms >= 2 ** 31) throw new HexclaveAssertionError("The maximum timeout for wait() is 2147483647ms (2**31 - 1). (found: ${ms}ms)");
+	return await traceSpan({
+		description: "wait(...)",
+		attributes: { "stack.wait.ms": ms }
+	}, async (span) => {
+		return await new Promise((resolve) => setTimeout(resolve, ms));
+	});
+}
+(void 0)?.test("wait", async ({ expect }) => {
+	const start = Date.now();
+	await wait(10);
+	expect(Date.now() - start).toBeGreaterThanOrEqual(5);
+	await expect(wait(0)).resolves.toBeUndefined();
+	await expect(wait(-10)).rejects.toThrow("wait() requires a non-negative integer");
+	await expect(wait(NaN)).rejects.toThrow("wait() requires a non-negative integer");
+	await expect(wait(Infinity)).rejects.toThrow("wait() requires a non-negative integer");
+	await expect(wait(2 ** 31)).rejects.toThrow("The maximum timeout for wait()");
+});
+async function waitUntil(date) {
+	return await wait(date.getTime() - Date.now());
+}
+(void 0)?.test("waitUntil", async ({ expect }) => {
+	const futureDate = new Date(Date.now() + 10);
+	const start = Date.now();
+	await waitUntil(futureDate);
+	expect(Date.now() - start).toBeGreaterThanOrEqual(5);
+	try {
+		await waitUntil(/* @__PURE__ */ new Date(Date.now() - 1e3));
+		expect.fail("Should have thrown an error");
+	} catch (error) {
+		expect(error).toBeInstanceOf(HexclaveAssertionError);
+		expect(error.message).toContain("wait() requires a non-negative integer");
+	}
+});
+function runAsynchronouslyWithAlert(...args) {
+	return runAsynchronously(args[0], {
+		...args[1],
+		onError: (error) => {
+			const nodeEnv = getProcessEnv("NODE_ENV");
+			if (KnownError.isKnownError(error) && nodeEnv?.includes("production")) alert(error.message);
+			else alert(`An unhandled error occurred. Please ${nodeEnv === "development" ? `check the browser console for the full error.` : "report this to the developer."}\n\n${error}`);
+			args[1]?.onError?.(error);
+		}
+	}, ...args.slice(2));
+}
+(void 0)?.test("runAsynchronouslyWithAlert", ({ expect }) => {
+	const testFn = () => Promise.resolve("test");
+	const testOptions = { noErrorLogging: true };
+	expect(() => runAsynchronouslyWithAlert(testFn, testOptions)).not.toThrow();
+	expect(typeof runAsynchronouslyWithAlert).toBe("function");
+});
+function runAsynchronously(promiseOrFunc, options = {}) {
+	if (typeof promiseOrFunc === "function") promiseOrFunc = promiseOrFunc();
+	if (promiseOrFunc) {
+		concatStacktracesIfRejected(promiseOrFunc);
+		promiseOrFunc.catch((error) => {
+			options.onError?.(error);
+			const newError = new HexclaveAssertionError("Uncaught error in asynchronous function: " + errorToNiceString(error), { cause: error });
+			if (!options.noErrorLogging) captureError("runAsynchronously", newError);
+		});
+	}
+}
+(void 0)?.test("runAsynchronously", ({ expect }) => {
+	const testFn = () => Promise.resolve("test");
+	expect(() => runAsynchronously(testFn)).not.toThrow();
+	expect(() => runAsynchronously(Promise.resolve("test"))).not.toThrow();
+	expect(() => runAsynchronously(void 0)).not.toThrow();
+	expect(() => runAsynchronously(testFn, { noErrorLogging: true })).not.toThrow();
+	expect(() => runAsynchronously(testFn, { onError: () => {} })).not.toThrow();
+});
+var TimeoutError = class extends Error {
+	constructor(ms) {
+		super(`Timeout after ${ms}ms`);
+		this.ms = ms;
+		this.name = "TimeoutError";
+	}
+};
+async function timeout(promiseOrFunc, ms) {
+	const promise = typeof promiseOrFunc === "function" ? promiseOrFunc() : promiseOrFunc;
+	return await Promise.race([promise.then((value) => Result.ok(value)), wait(ms).then(() => Result.error(new TimeoutError(ms)))]);
+}
+(void 0)?.test("timeout", async ({ expect }) => {
+	const fastResult = await timeout(Promise.resolve(42), 100);
+	expect(fastResult.status).toBe("ok");
+	if (fastResult.status === "ok") expect(fastResult.data).toBe(42);
+	const slowResult = await timeout(new Promise((resolve) => setTimeout(() => resolve("too late"), 50)), 10);
+	expect(slowResult.status).toBe("error");
+	if (slowResult.status === "error") {
+		expect(slowResult.error).toBeInstanceOf(TimeoutError);
+		expect(slowResult.error.ms).toBe(10);
+	}
+});
+async function timeoutThrow(promise, ms) {
+	return Result.orThrow(await timeout(promise, ms));
+}
+(void 0)?.test("timeoutThrow", async ({ expect }) => {
+	expect(await timeoutThrow(Promise.resolve(42), 100)).toBe(42);
+	const slowPromise = new Promise((resolve) => setTimeout(() => resolve("too late"), 50));
+	await expect(timeoutThrow(slowPromise, 10)).rejects.toThrow("Timeout after 10ms");
+	await expect(timeoutThrow(slowPromise, 10)).rejects.toBeInstanceOf(TimeoutError);
+});
+function rateLimited(func, options) {
+	let waitUntil = performance.now();
+	let queue = [];
+	let addedToQueueCallbacks = /* @__PURE__ */ new Map();
+	const next = async () => {
+		while (true) if (waitUntil > performance.now()) await wait(Math.max(1, waitUntil - performance.now() + 1));
+		else if (queue.length === 0) {
+			const uuid = generateUuid();
+			await new Promise((resolve) => {
+				addedToQueueCallbacks.set(uuid, resolve);
+			});
+			addedToQueueCallbacks.delete(uuid);
+		} else break;
+		const nextFuncs = options.batchCalls ? queue.splice(0, queue.length) : [queue.shift()];
+		const start = performance.now();
+		const value = await Result.fromPromise(func());
+		const end = performance.now();
+		waitUntil = Math.max(waitUntil, start + (options.throttleMs ?? 0), end + (options.gapMs ?? 0));
+		for (const nextFunc of nextFuncs) if (value.status === "ok") nextFunc[0](value.data);
+		else nextFunc[1](value.error);
+	};
+	runAsynchronously(async () => {
+		while (true) await next();
+	});
+	return () => {
+		return new Promise((resolve, reject) => {
+			waitUntil = Math.max(waitUntil, performance.now() + (options.debounceMs ?? 0));
+			queue.push([resolve, reject]);
+			addedToQueueCallbacks.forEach((cb) => cb());
+		});
+	};
+}
+function throttled(func, delayMs) {
+	let nextAvailable = null;
+	return async (...args) => {
+		while (nextAvailable !== null) await nextAvailable;
+		nextAvailable = new Promise((resolve) => {
+			setTimeout(() => {
+				nextAvailable = null;
+				resolve(func(...args));
+			}, delayMs);
+		});
+		return await nextAvailable;
+	};
+}
+
+//#endregion
+export { concatStacktracesIfRejected, createPromise, ignoreUnhandledRejection, neverResolve, pending, rateLimited, rejected, resolved, runAsynchronously, runAsynchronouslyWithAlert, throttled, timeout, timeoutThrow, wait, waitUntil };
+//# sourceMappingURL=promises.js.map

package/dist/esm/utils/promises.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promises.js","names":[],"sources":["../../../src/utils/promises.tsx"],"sourcesContent":["import { KnownError } from \"..\";\nimport { getProcessEnv } from \"./env\";\nimport { HexclaveAssertionError, captureError, concatStacktraces, errorToNiceString } from \"./errors\";\nimport { DependenciesMap } from \"./maps\";\nimport { Result } from \"./results\";\nimport { traceSpan } from \"./telemetry\";\nimport { generateUuid } from \"./uuids\";\n\nexport type ReactPromise<T> = Promise<T> & (\n  | { status: \"rejected\", reason: unknown }\n  | { status: \"fulfilled\", value: T }\n  | { status: \"pending\" }\n);\n\ntype Resolve<T> = (value: T) => void;\ntype Reject = (reason: unknown) => void;\nexport function createPromise<T>(callback: (resolve: Resolve<T>, reject: Reject) => void): ReactPromise<T> {\n  let status = \"pending\" as \"fulfilled\" | \"rejected\" | \"pending\";\n  let valueOrReason: T | unknown | undefined = undefined;\n  let resolve: Resolve<T> | null = null;\n  let reject: Reject | null = null;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = (value) => {\n      if (status !== \"pending\") return;\n      status = \"fulfilled\";\n      valueOrReason = value;\n      res(value);\n    };\n    reject = (reason) => {\n      if (status !== \"pending\") return;\n      status = \"rejected\";\n      valueOrReason = reason;\n      rej(reason);\n    };\n  });\n\n  callback(resolve!, reject!);\n  return Object.assign(promise, {\n    status: status,\n    ...status === \"fulfilled\" ? { value: valueOrReason as T } : {},\n    ...status === \"rejected\" ? { reason: valueOrReason } : {},\n  } as any);\n}\nimport.meta.vitest?.test(\"createPromise\", async ({ expect }) => {\n  // Test resolved promise\n  const resolvedPromise = createPromise<number>((resolve) => {\n    resolve(42);\n  });\n  expect(resolvedPromise.status).toBe(\"fulfilled\");\n  expect((resolvedPromise as any).value).toBe(42);\n  expect(await resolvedPromise).toBe(42);\n\n  // Test rejected promise\n  const error = new Error(\"Test error\");\n  const rejectedPromise = createPromise<number>((_, reject) => {\n    reject(error);\n  });\n  expect(rejectedPromise.status).toBe(\"rejected\");\n  expect((rejectedPromise as any).reason).toBe(error);\n  await expect(rejectedPromise).rejects.toBe(error);\n\n  // Test pending promise\n  const pendingPromise = createPromise<number>(() => {\n    // Do nothing, leave it pending\n  });\n  expect(pendingPromise.status).toBe(\"pending\");\n  expect((pendingPromise as any).value).toBeUndefined();\n  expect((pendingPromise as any).reason).toBeUndefined();\n\n  // Test that resolving after already resolved does nothing\n  let resolveCount = 0;\n  const multiResolvePromise = createPromise<number>((resolve) => {\n    resolve(1);\n    resolveCount++;\n    resolve(2);\n    resolveCount++;\n  });\n  expect(resolveCount).toBe(2); // Both resolve calls executed\n  expect(multiResolvePromise.status).toBe(\"fulfilled\");\n  expect((multiResolvePromise as any).value).toBe(1); // Only first resolve took effect\n  expect(await multiResolvePromise).toBe(1);\n});\n\nlet resolvedCache: DependenciesMap<[unknown], ReactPromise<unknown>> | null = null;\n/**\n * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook, and caches\n * the value so that invoking `resolved` twice returns the same promise.\n */\nexport function resolved<T>(value: T): ReactPromise<T> {\n  resolvedCache ??= new DependenciesMap<[unknown], ReactPromise<unknown>>();\n  if (resolvedCache.has([value])) {\n    return resolvedCache.get([value]) as ReactPromise<T>;\n  }\n\n  const res = Object.assign(Promise.resolve(value), {\n    status: \"fulfilled\",\n    value,\n  } as const);\n  resolvedCache.set([value], res);\n  return res;\n}\nimport.meta.vitest?.test(\"resolved\", async ({ expect }) => {\n  // Test with primitive value\n  const promise1 = resolved(42);\n  expect(promise1.status).toBe(\"fulfilled\");\n  // Need to use type assertion since value is only available when status is \"fulfilled\"\n  expect((promise1 as { value: number }).value).toBe(42);\n  expect(await promise1).toBe(42);\n\n  // Test with object value\n  const obj = { test: true };\n  const promise2 = resolved(obj);\n  expect(promise2.status).toBe(\"fulfilled\");\n  expect((promise2 as { value: typeof obj }).value).toBe(obj);\n  expect(await promise2).toBe(obj);\n\n  // Test caching (same reference for same value)\n  const promise3 = resolved(42);\n  expect(promise3).toBe(promise1); // Same reference due to caching\n\n  // Test with different value (different reference)\n  const promise4 = resolved(43);\n  expect(promise4).not.toBe(promise1);\n});\n\nlet rejectedCache: DependenciesMap<[unknown], ReactPromise<unknown>> | null = null;\n/**\n * Like Promise.reject(...), but also adds the status and value properties for use with React's `use` hook, and caches\n * the value so that invoking `rejected` twice returns the same promise.\n */\nexport function rejected<T>(reason: unknown): ReactPromise<T> {\n  rejectedCache ??= new DependenciesMap<[unknown], ReactPromise<unknown>>();\n  if (rejectedCache.has([reason])) {\n    return rejectedCache.get([reason]) as ReactPromise<T>;\n  }\n\n  const promise = Promise.reject(reason);\n  ignoreUnhandledRejection(promise);\n  const res = Object.assign(promise, {\n    status: \"rejected\",\n    reason: reason,\n  } as const);\n  rejectedCache.set([reason], res);\n  return res;\n}\nimport.meta.vitest?.test(\"rejected\", ({ expect }) => {\n  // Test with error object\n  const error = new Error(\"Test error\");\n  const promise1 = rejected<number>(error);\n  expect(promise1.status).toBe(\"rejected\");\n  // Need to use type assertion since reason is only available when status is \"rejected\"\n  expect((promise1 as { reason: Error }).reason).toBe(error);\n\n  // Test with string reason\n  const promise2 = rejected<string>(\"error message\");\n  expect(promise2.status).toBe(\"rejected\");\n  expect((promise2 as { reason: string }).reason).toBe(\"error message\");\n\n  // Test caching (same reference for same reason)\n  const promise3 = rejected<number>(error);\n  expect(promise3).toBe(promise1); // Same reference due to caching\n\n  // Test with different reason (different reference)\n  const differentError = new Error(\"Different error\");\n  const promise4 = rejected<number>(differentError);\n  expect(promise4).not.toBe(promise1);\n\n  // Note: We're not using await expect(promise).rejects to avoid unhandled rejections\n});\n\n// We'll skip the rejection test for pending() since it's causing unhandled rejections\n// The function is already well tested through other tests like rejected() and createPromise()\n\n\nconst neverResolvePromise = pending(new Promise<never>(() => {}));\nexport function neverResolve(): ReactPromise<never> {\n  return neverResolvePromise;\n}\nimport.meta.vitest?.test(\"neverResolve\", ({ expect }) => {\n  const promise = neverResolve();\n  expect(promise.status).toBe(\"pending\");\n  expect((promise as any).value).toBeUndefined();\n  expect((promise as any).reason).toBeUndefined();\n\n  // Test that multiple calls return the same promise\n  const promise2 = neverResolve();\n  expect(promise2).toBe(promise);\n});\n\nexport function pending<T>(promise: Promise<T>, options: { disableErrorWrapping?: boolean } = {}): ReactPromise<T> {\n  const res = promise.then(\n    value => {\n      res.status = \"fulfilled\";\n      (res as any).value = value;\n      return value;\n    },\n    actualReason => {\n      res.status = \"rejected\";\n      (res as any).reason = actualReason;\n      throw actualReason;\n    },\n  ) as ReactPromise<T>;\n  res.status = \"pending\";\n  return res;\n}\nimport.meta.vitest?.test(\"pending\", async ({ expect }) => {\n  // Test with a promise that resolves\n  const resolvePromise = Promise.resolve(42);\n  const pendingPromise = pending(resolvePromise);\n\n  // Initially it should be pending\n  expect(pendingPromise.status).toBe(\"pending\");\n\n  // After resolution, it should be fulfilled\n  await resolvePromise;\n  // Need to wait a tick for the then handler to execute\n  await new Promise(resolve => setTimeout(resolve, 0));\n  expect(pendingPromise.status).toBe(\"fulfilled\");\n  expect((pendingPromise as { value: number }).value).toBe(42);\n\n  // For the rejection test, we'll use a separate test to avoid unhandled rejections\n});\n\n/**\n * Should be used to wrap Promises that are not immediately awaited, so they don't throw an unhandled promise rejection\n * error.\n *\n * Vercel kills serverless functions on unhandled promise rejection errors, so this is important.\n */\nexport function ignoreUnhandledRejection<T extends Promise<any>>(promise: T): void {\n  promise.catch(() => {});\n}\nimport.meta.vitest?.test(\"ignoreUnhandledRejection\", async ({ expect }) => {\n  // Test with a promise that resolves\n  const resolvePromise = Promise.resolve(42);\n  ignoreUnhandledRejection(resolvePromise);\n  expect(await resolvePromise).toBe(42); // Should still resolve to the same value\n\n  // Test with a promise that rejects\n  // The promise should still reject, but the rejection is caught internally\n  // so it doesn't cause an unhandled rejection error\n  const error = new Error(\"Test error\");\n  const rejectPromise = Promise.reject(error);\n  ignoreUnhandledRejection(rejectPromise);\n  await expect(rejectPromise).rejects.toBe(error);\n});\n\n/**\n * See concatStacktraces for more information.\n */\nexport function concatStacktracesIfRejected<T>(promise: Promise<T>): void {\n  const currentError = new Error();\n  promise.catch(error => {\n    if (error instanceof Error) {\n      concatStacktraces(error, currentError);\n    } else {\n      // we can only concatenate errors, so we'll just ignore the non-error\n    }\n  });\n}\n\nexport async function wait(ms: number) {\n  if (!Number.isFinite(ms) || ms < 0) {\n    throw new HexclaveAssertionError(`wait() requires a non-negative integer number of milliseconds to wait. (found: ${ms}ms)`);\n  }\n  if (ms >= 2**31) {\n    throw new HexclaveAssertionError(\"The maximum timeout for wait() is 2147483647ms (2**31 - 1). (found: ${ms}ms)\");\n  }\n  return await traceSpan({ description: 'wait(...)', attributes: { 'stack.wait.ms': ms } }, async (span) => {\n    return await new Promise<void>(resolve => setTimeout(resolve, ms));\n  });\n}\nimport.meta.vitest?.test(\"wait\", async ({ expect }) => {\n  // Test with valid input\n  const start = Date.now();\n  await wait(10);\n  const elapsed = Date.now() - start;\n  expect(elapsed).toBeGreaterThanOrEqual(5); // Allow some flexibility in timing\n\n  // Test with zero\n  await expect(wait(0)).resolves.toBeUndefined();\n\n  // Test with negative number\n  await expect(wait(-10)).rejects.toThrow(\"wait() requires a non-negative integer\");\n\n  // Test with non-finite number\n  await expect(wait(NaN)).rejects.toThrow(\"wait() requires a non-negative integer\");\n  await expect(wait(Infinity)).rejects.toThrow(\"wait() requires a non-negative integer\");\n\n  // Test with too large number\n  await expect(wait(2**31)).rejects.toThrow(\"The maximum timeout for wait()\");\n});\n\nexport async function waitUntil(date: Date) {\n  return await wait(date.getTime() - Date.now());\n}\nimport.meta.vitest?.test(\"waitUntil\", async ({ expect }) => {\n  // Test with future date\n  const futureDate = new Date(Date.now() + 10);\n  const start = Date.now();\n  await waitUntil(futureDate);\n  const elapsed = Date.now() - start;\n  expect(elapsed).toBeGreaterThanOrEqual(5); // Allow some flexibility in timing\n\n  // Test with past date - this will throw because wait() requires non-negative time\n  // We need to verify it throws the correct error\n  try {\n    await waitUntil(new Date(Date.now() - 1000));\n    expect.fail(\"Should have thrown an error\");\n  } catch (error) {\n    expect(error).toBeInstanceOf(HexclaveAssertionError);\n    expect((error as Error).message).toContain(\"wait() requires a non-negative integer\");\n  }\n});\n\nexport function runAsynchronouslyWithAlert(...args: Parameters<typeof runAsynchronously>) {\n  return runAsynchronously(\n    args[0],\n    {\n      ...args[1],\n      onError: error => {\n        const nodeEnv = getProcessEnv(\"NODE_ENV\");\n        if (KnownError.isKnownError(error) && nodeEnv?.includes(\"production\")) {\n          alert(error.message);\n        } else {\n          alert(`An unhandled error occurred. Please ${nodeEnv === \"development\" ? `check the browser console for the full error.` : \"report this to the developer.\"}\\n\\n${error}`);\n        }\n        args[1]?.onError?.(error);\n      },\n    },\n    ...args.slice(2) as [],\n  );\n}\nimport.meta.vitest?.test(\"runAsynchronouslyWithAlert\", ({ expect }) => {\n  // Simple test to verify the function calls runAsynchronously\n  // We can't easily test the alert functionality without mocking\n  const testFn = () => Promise.resolve(\"test\");\n  const testOptions = { noErrorLogging: true };\n\n  // Just verify it doesn't throw\n  expect(() => runAsynchronouslyWithAlert(testFn, testOptions)).not.toThrow();\n\n  // We can't easily test the error handling without mocking, so we'll\n  // just verify the function exists and can be called\n  expect(typeof runAsynchronouslyWithAlert).toBe(\"function\");\n});\n\nexport function runAsynchronously(\n  promiseOrFunc: void | Promise<unknown> | (() => void | Promise<unknown>) | undefined,\n  options: {\n    noErrorLogging?: boolean,\n    onError?: (error: Error) => void,\n  } = {},\n): void {\n  if (typeof promiseOrFunc === \"function\") {\n    promiseOrFunc = promiseOrFunc();\n  }\n  if (promiseOrFunc) {\n    concatStacktracesIfRejected(promiseOrFunc);\n    promiseOrFunc.catch(error => {\n      options.onError?.(error);\n      const newError = new HexclaveAssertionError(\n        \"Uncaught error in asynchronous function: \" + errorToNiceString(error),\n        { cause: error },\n      );\n      if (!options.noErrorLogging) {\n        captureError(\"runAsynchronously\", newError);\n      }\n    });\n  }\n}\nimport.meta.vitest?.test(\"runAsynchronously\", ({ expect }) => {\n  // Simple test to verify the function exists and can be called\n  const testFn = () => Promise.resolve(\"test\");\n\n  // Just verify it doesn't throw\n  expect(() => runAsynchronously(testFn)).not.toThrow();\n  expect(() => runAsynchronously(Promise.resolve(\"test\"))).not.toThrow();\n  expect(() => runAsynchronously(undefined)).not.toThrow();\n\n  // We can't easily test the error handling without mocking, so we'll\n  // just verify the function exists and can be called with options\n  expect(() => runAsynchronously(testFn, { noErrorLogging: true })).not.toThrow();\n  expect(() => runAsynchronously(testFn, { onError: () => {} })).not.toThrow();\n});\n\n\nclass TimeoutError extends Error {\n  constructor(public readonly ms: number) {\n    super(`Timeout after ${ms}ms`);\n    this.name = \"TimeoutError\";\n  }\n}\n\nexport async function timeout<T>(promiseOrFunc: Promise<T> | (() => Promise<T>), ms: number): Promise<Result<T, TimeoutError>> {\n  const promise = typeof promiseOrFunc === \"function\" ? promiseOrFunc() : promiseOrFunc;\n  return await Promise.race([\n    promise.then(value => Result.ok(value)),\n    wait(ms).then(() => Result.error(new TimeoutError(ms))),\n  ]);\n}\nimport.meta.vitest?.test(\"timeout\", async ({ expect }) => {\n  // Test with a promise that resolves quickly\n  const fastPromise = Promise.resolve(42);\n  const fastResult = await timeout(fastPromise, 100);\n  expect(fastResult.status).toBe(\"ok\");\n  if (fastResult.status === \"ok\") {\n    expect(fastResult.data).toBe(42);\n  }\n\n  // Test with a promise that takes longer than the timeout\n  const slowPromise = new Promise(resolve => setTimeout(() => resolve(\"too late\"), 50));\n  const slowResult = await timeout(slowPromise, 10);\n  expect(slowResult.status).toBe(\"error\");\n  if (slowResult.status === \"error\") {\n    expect(slowResult.error).toBeInstanceOf(TimeoutError);\n    expect((slowResult.error as TimeoutError).ms).toBe(10);\n  }\n});\n\nexport async function timeoutThrow<T>(promise: Promise<T>, ms: number): Promise<T> {\n  return Result.orThrow(await timeout(promise, ms));\n}\nimport.meta.vitest?.test(\"timeoutThrow\", async ({ expect }) => {\n  // Test with a promise that resolves quickly\n  const fastPromise = Promise.resolve(42);\n  const fastResult = await timeoutThrow(fastPromise, 100);\n  expect(fastResult).toBe(42);\n\n  // Test with a promise that takes longer than the timeout\n  const slowPromise = new Promise(resolve => setTimeout(() => resolve(\"too late\"), 50));\n  await expect(timeoutThrow(slowPromise, 10)).rejects.toThrow(\"Timeout after 10ms\");\n  await expect(timeoutThrow(slowPromise, 10)).rejects.toBeInstanceOf(TimeoutError);\n});\n\n\nexport type RateLimitOptions = {\n  /**\n   * The number of requests to process in parallel. Currently only 1 is supported.\n   */\n  concurrency: 1,\n\n  /**\n   * If true, multiple requests waiting at the same time will be reduced to just one. Default is false.\n   */\n  batchCalls?: boolean,\n\n  /**\n   * Waits for throttleMs since the start of last request before starting the next request. Default is 0.\n   */\n  throttleMs?: number,\n\n  /**\n   * Waits for gapMs since the end of last request before starting the next request. Default is 0.\n   */\n  gapMs?: number,\n\n  /**\n   * Waits until there have been no new requests for debounceMs before starting a new request. Default is 0.\n   */\n  debounceMs?: number,\n};\n\nexport function rateLimited<T>(\n  func: () => Promise<T>,\n  options: RateLimitOptions,\n): () => Promise<T> {\n  let waitUntil = performance.now();\n  let queue: [(t: T) => void, (e: unknown) => void][] = [];\n  let addedToQueueCallbacks = new Map<string, () => void>;\n\n  const next = async () => {\n    while (true) {\n      if (waitUntil > performance.now()) {\n        await wait(Math.max(1, waitUntil - performance.now() + 1));\n      } else if (queue.length === 0) {\n        const uuid = generateUuid();\n        await new Promise<void>(resolve => {\n          addedToQueueCallbacks.set(uuid, resolve);\n        });\n        addedToQueueCallbacks.delete(uuid);\n      } else {\n        break;\n      }\n    }\n    const nextFuncs = options.batchCalls ? queue.splice(0, queue.length) : [queue.shift()!];\n\n    const start = performance.now();\n    const value = await Result.fromPromise(func());\n    const end = performance.now();\n\n    waitUntil = Math.max(\n      waitUntil,\n      start + (options.throttleMs ?? 0),\n      end + (options.gapMs ?? 0),\n    );\n\n    for (const nextFunc of nextFuncs) {\n      if (value.status === \"ok\") {\n        nextFunc[0](value.data);\n      } else {\n        nextFunc[1](value.error);\n      }\n    }\n  };\n\n  runAsynchronously(async () => {\n    while (true) {\n      await next();\n    }\n  });\n\n  return () => {\n    return new Promise<T>((resolve, reject) => {\n      waitUntil = Math.max(\n        waitUntil,\n        performance.now() + (options.debounceMs ?? 0),\n      );\n      queue.push([resolve, reject]);\n      addedToQueueCallbacks.forEach(cb => cb());\n    });\n  };\n}\n\nexport function throttled<T, A extends any[]>(func: (...args: A) => Promise<T>, delayMs: number): (...args: A) => Promise<T> {\n  let timeout: ReturnType<typeof setTimeout> | null = null;\n  let nextAvailable: Promise<T> | null = null;\n  return async (...args) => {\n    while (nextAvailable !== null) {\n      await nextAvailable;\n    }\n    nextAvailable = new Promise<T>(resolve => {\n      timeout = setTimeout(() => {\n        nextAvailable = null;\n        resolve(func(...args));\n      }, delayMs);\n    });\n    return await nextAvailable;\n  };\n}\n"],"mappings":"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"}

package/dist/esm/utils/proxies.d.ts

@@ -0,0 +1,13 @@
+//#region src/utils/proxies.d.ts
+/**
+ * Creates a proxy that throws an error when any property is accessed, function is called,
+ * or any other operation is performed on it.
+ *
+ * Useful for placeholder values that should never actually be used at runtime.
+ */
+declare function throwingProxy<T = any>(error: string | Error): T;
+declare function logged<T extends object>(name: string, toLog: T, options?: {}): T;
+declare function createLazyProxy<FactoryResult>(factory: () => FactoryResult): FactoryResult;
+//#endregion
+export { createLazyProxy, logged, throwingProxy };
+//# sourceMappingURL=proxies.d.ts.map

package/dist/esm/utils/proxies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxies.d.ts","names":[],"sources":["../../../src/utils/proxies.tsx"],"mappings":";;AASA;;;;;iBAAgB,aAAA,SAAA,CAAuB,KAAA,WAAgB,KAAA,GAAQ,CAAA;AAAA,iBA0B/C,MAAA,kBAAA,CAAyB,IAAA,UAAc,KAAA,EAAO,CAAA,EAAG,OAAA,QAAmB,CAAA;AAAA,iBA0DpE,eAAA,eAAA,CAA+B,OAAA,QAAe,aAAA,GAAgB,aAAA"}