Add denseProxy, various collection.js improvements

[Pisces] / collection.test.js

diff --git a/collection.test.js b/collection.test.js
index b490572c575e017727d55c00371ffb9aef99d37d..079ef4b82545abc564665069d2d03a86b3e76faa 100644 (file)
--- a/collection.test.js
+++ b/collection.test.js
@@ -1,11 +1,14 @@
-// ♓🌟 Piscēs ∷ collection.test.js
-// ====================================================================
-//
-// Copyright © 2022 Lady [@ Lady’s Computer].
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at <https://mozilla.org/MPL/2.0/>.
+// SPDX-FileCopyrightText: 2022, 2023, 2025 Lady <https://www.ladys.computer/about/#lady>
+// SPDX-License-Identifier: MPL-2.0
+/**
+ * ⁌ ♓🧩 Piscēs ∷ collection.js
+ *
+ * Copyright © 2022–2023, 2025 Lady [@ Ladys Computer].
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at <https://mozilla.org/MPL/2.0/>.
+ */

 
 import {
   assertEquals,
 
 import {
   assertEquals,


@@ -18,82 +21,1028 @@ import {
   spy,
 } from "./dev-deps.js";
 import {
   spy,
 } from "./dev-deps.js";
 import {

-  canonicalNumericIndexString,
-  findIndexedEntry,
-  isArrayIndexString,
+  array,
+  concatSpreadableCatenate,
+  copyWithin,
+  denseProxy,
+  fill,
+  filter,
+  findFirstIndex,
+  findFirstIndexedEntry,
+  findFirstItem,
+  findLastIndex,
+  findLastIndexedEntry,
+  findLastItem,
+  flatmap,
+  flatten as _flatten /* TK */,
+  getFirstIndex as _getFirstIndex /* TK */,
+  getItem as _getItem /* TK */,
+  getLastIndex as _getLastIndex /* TK */,
+  hasEvery as _hasEvery /* TK */,
+  hasSome as _hasSome /* TK */,
+  includes as _includes /* TK */,
+  indexedEntries as _indexedEntries /* TK */,
+  indices as _indices /* TK */,
+  isArray as _isArray /* TK */,

   isCollection,
   isCollection,

-  isConcatSpreadable,
-  isIntegerIndexString,
-  lengthOfArrayLike,
-  toIndex,
-  toLength,
+  isDenseProxy,
+  items as _items /* TK */,
+  map as _map /* TK */,
+  pop as _pop /* TK */,
+  push as _push /* TK */,
+  reduce as _reduce /* TK */,
+  reverse as _reverse /* TK */,
+  shift as _shift /* TK */,
+  slice as _slice /* TK */,
+  sort as _sort /* TK */,
+  splice as _splice /* TK */,
+  toArray,
+  toDenseArray,
+  unshift as _unshift /* TK */,

 } from "./collection.js";
 
 } from "./collection.js";
 

-describe("canonicalNumericIndexString", () => {
-  it("[[Call]] returns undefined for nonstrings", () => {
-    assertStrictEquals(canonicalNumericIndexString(1), void {});
+describe("array", () => {
+  it("[[Call]] returns an array of the provided values", () => {
+    assertEquals(array("etaoin", [], true), ["etaoin", [], true]);

   });
 
   });
 

-  it("[[Call]] returns undefined for noncanonical strings", () => {
-    assertStrictEquals(canonicalNumericIndexString(""), void {});
-    assertStrictEquals(canonicalNumericIndexString("01"), void {});
+  it("[[Call]] returns an empty array with no arguments", () => {
+    assertEquals(array(), []);
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new array());
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(array.length, 0);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(array.name, "array");
+    });
+  });
+});
+
+describe("concatSpreadableCatenate", () => {
+  it("[[Call]] catenates concat spreadable values", () => {
+    assertEquals(
+      concatSpreadableCatenate([1, 2], [2, [3]], {
+        length: 1,
+        [Symbol.isConcatSpreadable]: true,
+      }),
+      [1, 2, 2, [3], ,],
+    );
+  });
+
+  it("[[Call]] does not catenate other values", () => {
+    assertEquals(concatSpreadableCatenate({}, "etaoin"), [
+      {},
+      "etaoin",
+    ]);
+  });
+
+  it("[[Call]] allows a nullish first argument", () => {
+    assertEquals(concatSpreadableCatenate(null), [null]);
+    assertEquals(concatSpreadableCatenate(undefined), [undefined]);
+  });
+
+  it("[[Call]] returns an empty array with no arguments", () => {
+    assertEquals(concatSpreadableCatenate(), []);
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new concatSpreadableCatenate());
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(concatSpreadableCatenate.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(
+        concatSpreadableCatenate.name,
+        "concatSpreadableCatenate",
+      );
+    });
+  });
+});
+
+describe("copyWithin", () => {
+  it("[[Call]] copies within", () => {
+    assertEquals(
+      copyWithin(["a", "b", "c", , "e"], 0, 3, 4),
+      [, "b", "c", , "e"],
+    );
+    assertEquals(
+      copyWithin(["a", "b", "c", , "e"], 1, 3),
+      ["a", , "e", , "e"],
+    );
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new copyWithin([], 0, 0));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(copyWithin.length, 3);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(copyWithin.name, "copyWithin");
+    });
+  });
+});
+
+describe("denseProxy", () => {
+  const makeUnderlying = () =>
+    Object.create({ 2: "inherited" }, {
+      // 0 is not present
+      1: { value: "static", configurable: true, writable: true },
+      // 2 is not an own property, but is present on the prototype
+      3: { configurable: true, get: () => "dynamic" },
+      length: { value: "4", configurable: true, writable: true },
+    });
+
+  it("[[Call]] returns an object which inherits from the provided object", () => {
+    const underlying = makeUnderlying();
+    const proxy = denseProxy(underlying);
+    assertStrictEquals(
+      Object.getPrototypeOf(proxy),
+      underlying,
+    );
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new denseProxy([]));
+  });
+
+  it("[[OwnPropertyKeys]] lists integer indices, then the length, then other keys", () => {
+    const underlying = makeUnderlying();
+    const proxy = denseProxy(underlying);
+    const sym = Symbol();
+    proxy[sym] = "shrdlu";
+    proxy["1.2.3"] = "etaion";
+    assertEquals(
+      Reflect.ownKeys(proxy),
+      ["0", "1", "2", "3", "length", "1.2.3", sym],
+    );
+  });
+
+  it("[[PreventExtensions]] fails if the underlying object is extensible", () => {
+    const underlying = makeUnderlying();
+    const proxy = denseProxy(underlying);
+    assertStrictEquals(
+      Reflect.preventExtensions(proxy),
+      false,
+    );
+  });
+
+  it("[[PreventExtensions]] fails if the underlying object has a nonconstant length", () => {
+    const underlying = makeUnderlying();
+    const proxy = denseProxy(underlying);
+    Object.defineProperty(underlying, "length", { get: () => 4 });
+    Object.freeze(underlying);

     assertStrictEquals(
     assertStrictEquals(

-      canonicalNumericIndexString("9007199254740993"),
-      void {},
+      Reflect.preventExtensions(proxy),
+      false,
+    );
+  });
+
+  it("[[PreventExtensions]] succeeds if the underlying object is non·extensible and has a constant length", () => {
+    const underlying = makeUnderlying();
+    const proxy = denseProxy(underlying);
+    Object.defineProperty(underlying, "length", {
+      configurable: false,
+      writable: false,
+    });
+    Object.preventExtensions(underlying);
+    assertStrictEquals(
+      Reflect.preventExtensions(proxy),
+      true,
+    );
+  });
+
+  it("[[SetPrototypeOf]] fails to change the prototype", () => {
+    const underlying = makeUnderlying();
+    const proxy = denseProxy(underlying);
+    assertStrictEquals(
+      Reflect.setPrototypeOf(proxy, {}),
+      false,
+    );
+  });
+
+  it("[[SetPrototypeOf]] succeeds keeping the prototype the same", () => {
+    const underlying = makeUnderlying();
+    const proxy = denseProxy(underlying);
+    assertStrictEquals(
+      Reflect.setPrototypeOf(proxy, underlying),
+      true,
+    );
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(denseProxy.length, 1);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(denseProxy.name, "denseProxy");
+    });
+  });
+
+  describe("~[]", () => {
+    it("[[DefineProperty]] allows changes when the property is not an index property or length", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      const newValue = Symbol();
+      proxy.etaoin = newValue;
+      assertStrictEquals(
+        proxy.etaoin,
+        newValue,
+      );
+    });
+
+    it("[[DefineProperty]] allows changing nothing when the property is not an own property", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "0",
+          {
+            configurable: true,
+            enumerable: true,
+            writable: false,
+            value: undefined,
+          },
+        ),
+        true,
+      );
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "2",
+          {
+            configurable: true,
+            enumerable: true,
+            writable: false,
+            value: undefined,
+          },
+        ),
+        true,
+      );
+      /* test nonconfigurable versions too */
+      Object.freeze(underlying);
+      Object.defineProperty(proxy, "0", { configurable: false });
+      Object.defineProperty(proxy, "2", { configurable: false });
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "0",
+          Object.getOwnPropertyDescriptor(proxy, "0"),
+        ),
+        true,
+      );
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "2",
+          Object.getOwnPropertyDescriptor(proxy, "2"),
+        ),
+        true,
+      );
+    });
+
+    it("[[DefineProperty]] allows changing nothing when the property is a data index property", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "1",
+          {
+            configurable: true,
+            enumerable: true,
+            writable: false,
+            value: underlying[1],
+          },
+        ),
+        true,
+      );
+      /* test nonconfigurable versions too */
+      Object.freeze(underlying);
+      Object.defineProperty(proxy, "1", { configurable: false });
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "1",
+          Object.getOwnPropertyDescriptor(proxy, "1"),
+        ),
+        true,
+      );
+    });
+
+    it("[[DefineProperty]] allows changing nothing when the property is an accessor index property", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "3",
+          {
+            configurable: true,
+            enumerable: true,
+            writable: false,
+            value: underlying[3],
+          },
+        ),
+        true,
+      );
+      /* test nonconfigurable versions too */
+      Object.freeze(underlying);
+      Object.defineProperty(proxy, "1", { configurable: false });
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "1",
+          Object.getOwnPropertyDescriptor(proxy, "1"),
+        ),
+        true,
+      );
+    });
+
+    it("[[DefineProperty]] does not allow a change in enumerablility on index properties", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.defineProperty(proxy, i, { enumerable: false }),
+          false,
+        );
+      }
+    });
+
+    it("[[DefineProperty]] does not allow a change in value on index properties", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.defineProperty(proxy, i, { value: "new value" })
+            && (() => {
+              throw i;
+            })(),
+          false,
+        );
+      }
+    });
+
+    it("[[DefineProperty]] does not allow a change in getter on index properties", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.defineProperty(proxy, i, {
+            get: () => underlying[i],
+          }) && (() => {
+            throw i;
+          })(),
+          false,
+        );
+      }
+    });
+
+    it("[[DefineProperty]] does not allow a change in setter on index properties", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.defineProperty(proxy, i, { set: () => undefined }),
+          false,
+        );
+      }
+    });
+
+    it("[[DefineProperty]] does not allow a change in configurability on index properties if the property in the underlying object may change", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      Object.defineProperty(underlying, "length", {
+        configurable: false,
+        writable: false,
+      });
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.defineProperty(proxy, i, { configurable: false }),
+          false,
+        );
+      }
+    });
+
+    it("[[DefineProperty]] does not allow a change in configurability on index properties if the length of the underlying object may change", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      Object.seal(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.defineProperty(proxy, i, { configurable: false }),
+          false,
+        );
+      }
+    });
+
+    it("[[DefineProperty]] allows a change in configurability on index properties when it is safe to do so", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      Object.defineProperty(underlying, "length", {
+        configurable: false,
+        writable: false,
+      });
+      Object.defineProperty(underlying, "1", {
+        configurable: false,
+        writable: false,
+      });
+      Object.defineProperty(underlying, "3", { configurable: false });
+      Object.preventExtensions(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.defineProperty(proxy, i, { configurable: false }),
+          true,
+        );
+      }
+    });
+
+    it("[[Delete]] is allowed when the property is not an index property or length", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      proxy.a = "etaoin";
+      assertStrictEquals(
+        Reflect.deleteProperty(proxy, "a"),
+        true,
+      );
+      assertStrictEquals(
+        Reflect.has(proxy, "a"),
+        false,
+      );
+    });
+
+    it("[[Delete]] is forbidden for index properties less than the length", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.deleteProperty(proxy, i),
+          false,
+        );
+      }
+    });
+
+    it("[[Delete]] is allowed for index properties greater than or equal to the length", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.deleteProperty(proxy, "4"),
+        true,
+      );
+      assertStrictEquals(
+        Reflect.deleteProperty(proxy, "5"),
+        true,
+      );
+    });
+
+    it("[[GetOwnProperty]] gives the value of an index property as a data property by default", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertEquals(
+        Object.getOwnPropertyDescriptor(proxy, 1),
+        {
+          configurable: true,
+          enumerable: true,
+          value: underlying[1],
+          writable: false,
+        },
+      );
+      assertEquals(
+        Object.getOwnPropertyDescriptor(proxy, 3),
+        {
+          configurable: true,
+          enumerable: true,
+          value: underlying[3],
+          writable: false,
+        },
+      );
+      /* test nonconfigurable data properties too */
+      Object.freeze(underlying);
+      Object.defineProperty(proxy, "1", { configurable: false });
+      assertEquals(
+        Object.getOwnPropertyDescriptor(proxy, 1),
+        {
+          configurable: false,
+          enumerable: true,
+          value: underlying[1],
+          writable: false,
+        },
+      );
+    });
+
+    it("[[GetOwnProperty]] gives a value of undefined if the underlying object does not have an index property as an own property", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertEquals(
+        Object.getOwnPropertyDescriptor(proxy, 0),
+        {
+          configurable: true,
+          enumerable: true,
+          value: undefined,
+          writable: false,
+        },
+      );
+      assertEquals(
+        Object.getOwnPropertyDescriptor(proxy, 2),
+        {
+          configurable: true,
+          enumerable: true,
+          value: undefined,
+          writable: false,
+        },
+      );
+    });
+
+    it("[[GetOwnProperty]] gives a value of undefined for index properties less than the length", () => {
+      const underlying = makeUnderlying();
+      underlying.length = 0;
+      const proxy = denseProxy(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Object.getOwnPropertyDescriptor(proxy, i),
+          undefined,
+        );
+      }
+    });
+
+    it("[[GetOwnProperty]] gives a getter when the underlying object has a getter and an index property is not configurable", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      Object.freeze(underlying);
+      Object.defineProperty(proxy, "3", { configurable: false });
+      const descriptor = Object.getOwnPropertyDescriptor(proxy, 3);
+      assertEquals(
+        descriptor,
+        {
+          configurable: false,
+          enumerable: true,
+          get: descriptor.get,
+          set: undefined,
+        },
+      );
+    });
+
+    describe("[[GetOwnProperty]].get.length", () => {
+      it("[[Get]] returns the correct length", () => {
+        const underlying = makeUnderlying();
+        const proxy = denseProxy(underlying);
+        Object.freeze(underlying);
+        Object.defineProperty(proxy, "3", { configurable: false });
+        assertStrictEquals(
+          Object.getOwnPropertyDescriptor(
+            proxy,
+            "3",
+          ).get.length,
+          0,
+        );
+      });
+    });
+
+    describe("[[GetOwnProperty]].get.name", () => {
+      it("[[Get]] returns the correct name", () => {
+        const underlying = makeUnderlying();
+        const proxy = denseProxy(underlying);
+        Object.freeze(underlying);
+        Object.defineProperty(proxy, "3", { configurable: false });
+        assertStrictEquals(
+          Object.getOwnPropertyDescriptor(
+            proxy,
+            "3",
+          ).get.name,
+          "get 3",
+        );
+      });
+    });
+
+    it("[[HasProperty]] works when the property is not an index property or length", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      proxy.a = "etaoin";
+      Object.getPrototypeOf(underlying).b = "shrdlu";
+      assertStrictEquals(
+        Reflect.has(proxy, "a"),
+        true,
+      );
+      assertStrictEquals(
+        Reflect.has(proxy, "b"),
+        true,
+      );
+      assertStrictEquals(
+        Reflect.has(proxy, "z"),
+        false,
+      );
+    });
+
+    it("[[HasProperty]] works for index properties less than the length", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.has(proxy, i),
+          true,
+        );
+      }
+      delete underlying.length;
+      for (let i = 0; i < 4; ++i) {
+        assertStrictEquals(
+          Reflect.has(proxy, i),
+          Reflect.has(underlying, i),
+        );
+      }
+    });
+
+    it("[[HasProperty]] works for index properties greater than or equal to the length", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.has(proxy, "4"),
+        false,
+      );
+      assertStrictEquals(
+        Reflect.has(proxy, "5"),
+        false,
+      );
+      underlying[4] = "inherited now";
+      assertStrictEquals(
+        Reflect.has(proxy, "4"),
+        true,
+      );
+    });
+  });
+
+  describe("~length", () => {
+    it("[[DefineProperty]] allows changing nothing", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "length",
+          {
+            configurable: true,
+            enumerable: false,
+            writable: false,
+            value: underlying.length >>> 0,
+          },
+        ),
+        true,
+      );
+      /* test nonconfigurable versions too */
+      Object.freeze(underlying);
+      Object.defineProperty(proxy, "length", { configurable: false });
+      assertStrictEquals(
+        Reflect.defineProperty(
+          proxy,
+          "length",
+          Object.getOwnPropertyDescriptor(proxy, "length"),
+        ),
+        true,
+      );
+    });
+
+    it("[[DefineProperty]] does not allow a change in enumerablility", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(proxy, "length", { enumerable: true }),
+        false,
+      );
+    });
+
+    it("[[DefineProperty]] does not allow a change in value", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(proxy, "length", { value: 0 }),
+        false,
+      );
+    });
+
+    it("[[DefineProperty]] does not allow a change in getter", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(proxy, "length", {
+          get: () => underlying.length >>> 0,
+        }),
+        false,
+      );
+    });
+
+    it("[[DefineProperty]] does not allow a change in setter", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(proxy, "length", { set: () => {} }),
+        false,
+      );
+    });
+
+    it("[[DefineProperty]] does not allow a change in configurability if the length of the underlying object may change", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.defineProperty(proxy, "length", {
+          configurable: false,
+        }),
+        false,
+      );
+      Object.defineProperty(underlying, "length", {
+        configurable: false,
+        get: () => 0,
+      });
+      assertStrictEquals(
+        Reflect.defineProperty(proxy, "length", {
+          configurable: false,
+        }),
+        false,
+      );
+    });
+
+    it("[[DefineProperty]] allows a change in configurability when it is safe to do so", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      Object.defineProperty(underlying, "length", {
+        configurable: false,
+        writable: false,
+      });
+      assertStrictEquals(
+        Reflect.defineProperty(proxy, "length", {
+          configurable: false,
+        }),
+        true,
+      );
+    });
+
+    it("[[Delete]] is forbidden", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.deleteProperty(
+          proxy,
+          "length",
+        ),
+        false,
+      );
+    });
+
+    it("[[GetOwnProperty]] gives the value as a data property", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertEquals(
+        Object.getOwnPropertyDescriptor(proxy, "length"),
+        {
+          configurable: true,
+          enumerable: false,
+          value: underlying.length >>> 0,
+          writable: false,
+        },
+      );
+      /* test nonconfigurable data properties too */
+      Object.freeze(underlying);
+      Object.defineProperty(proxy, "length", { configurable: false });
+      assertEquals(
+        Object.getOwnPropertyDescriptor(proxy, "length"),
+        {
+          configurable: false,
+          enumerable: false,
+          value: underlying.length >>> 0,
+          writable: false,
+        },
+      );
+    });
+
+    it("[[GetOwnProperty]] gives 0 if the underlying object does not have the property as an own property", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      delete underlying.length;
+      Object.getPrototypeOf(underlying).length = 3;
+      assertEquals(
+        Object.getOwnPropertyDescriptor(proxy, "length"),
+        {
+          configurable: true,
+          enumerable: false,
+          value: 0,
+          writable: false,
+        },
+      );
+    });
+
+    it("[[HasProperty]] is always true", () => {
+      const underlying = makeUnderlying();
+      const proxy = denseProxy(underlying);
+      assertStrictEquals(
+        Reflect.has(proxy, "length"),
+        true,
+      );
+      delete underlying.length;
+      assertStrictEquals(
+        Reflect.has(proxy, "length"),
+        true,
+      );
+    });
+  });
+});
+
+describe("fill", () => {
+  it("[[Call]] fills", () => {
+    assertEquals(
+      fill({ 1: "failure", length: 3 }, "success"),
+      { 0: "success", 1: "success", 2: "success", length: 3 },
+    );
+  });
+
+  it("[[Call]] can fill a range", () => {
+    assertEquals(
+      fill({ 1: "failure", length: 4 }, "success", 1, 3),
+      { 1: "success", 2: "success", length: 4 },
+    );
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new fill([], null));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(fill.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(fill.name, "fill");
+    });
+  });
+});
+
+describe("filter", () => {
+  it("[[Call]] filters", () => {
+    assertEquals(
+      filter(["failure", "success", ,], function ($) {
+        return !$ || $ == this;
+      }, "success"),
+      ["success"],

     );
   });
 
     );
   });
 

-  it('[[Call]] returns -0 for "-0"', () => {
-    assertStrictEquals(canonicalNumericIndexString("-0"), -0);
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new filter([], () => {}));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(filter.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(filter.name, "filter");
+    });
+  });
+});
+
+describe("findFirstIndex", () => {
+  it("[[Call]] returns undefined if no matching entry exists", () => {
+    assertStrictEquals(findFirstIndex([], () => true), undefined);
+    assertStrictEquals(findFirstIndex([1], () => false), undefined);
+  });
+
+  it("[[Call]] returns an index for the first match", () => {
+    assertStrictEquals(
+      findFirstIndex([, true, false], ($) => $ ?? true),
+      1,
+    );
+    assertStrictEquals(
+      findFirstIndex(
+        ["failure", "success", "success"],
+        ($) => $ == "success",
+      ),
+      1,
+    );

   });
 
   });
 

-  it("[[Call]] returns the corresponding number for canonical strings", () => {
-    assertStrictEquals(canonicalNumericIndexString("0"), 0);
-    assertStrictEquals(canonicalNumericIndexString("-0.25"), -0.25);
+  it("[[Call]] works on arraylike objects", () => {

     assertStrictEquals(
     assertStrictEquals(

-      canonicalNumericIndexString("9007199254740992"),
-      9007199254740992,
+      findFirstIndex({ 1: "success", length: 2 }, ($) => $),
+      1,

     );
     );

-    assertStrictEquals(canonicalNumericIndexString("NaN"), 0 / 0);
-    assertStrictEquals(canonicalNumericIndexString("Infinity"), 1 / 0);

     assertStrictEquals(
     assertStrictEquals(

-      canonicalNumericIndexString("-Infinity"),
-      -1 / 0,
+      findFirstIndex({ 1: "failure", length: 1 }, ($) => $),
+      undefined,

     );
   });
     );
   });

+
+  it("[[Call]] only gets the value once", () => {
+    const get1 = spy(() => true);
+    findFirstIndex({
+      get 1() {
+        return get1();
+      },
+      length: 2,
+    }, ($) => $);
+    assertSpyCalls(get1, 1);
+  });
+
+  it("[[Call]] passes the value, index, and this value to the callback", () => {
+    const arr = [, "failure", "success", "success"];
+    const callback = spy(($) => $ === "success");
+    const thisArg = {};
+    findFirstIndex(arr, callback, thisArg);
+    assertSpyCalls(callback, 2);
+    assertSpyCall(callback, 0, {
+      args: ["failure", 1, arr],
+      self: thisArg,
+    });
+    assertSpyCall(callback, 1, {
+      args: ["success", 2, arr],
+      self: thisArg,
+    });
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new findFirstIndex([], () => {}));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(findFirstIndex.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(findFirstIndex.name, "findFirstIndex");
+    });
+  });

 });
 
 });
 

-describe("findIndexedEntry", () => {
+describe("findFirstIndexedEntry", () => {

   it("[[Call]] returns undefined if no matching entry exists", () => {
   it("[[Call]] returns undefined if no matching entry exists", () => {

-    assertStrictEquals(findIndexedEntry([], () => true), void {});
-    assertStrictEquals(findIndexedEntry([1], () => false), void {});
+    assertStrictEquals(
+      findFirstIndexedEntry([], () => true),
+      undefined,
+    );
+    assertStrictEquals(
+      findFirstIndexedEntry([1], () => false),
+      undefined,
+    );

   });
 
   it("[[Call]] returns an entry for the first match", () => {
     assertEquals(
   });
 
   it("[[Call]] returns an entry for the first match", () => {
     assertEquals(

-      findIndexedEntry([, true, false], ($) => $ ?? true),
-      [0, void {}],
+      findFirstIndexedEntry([, true, false], ($) => $ ?? true),
+      [1, true],

     );
     assertEquals(
     );
     assertEquals(

-      findIndexedEntry(["failure", "success"], ($) => $ == "success"),
+      findFirstIndexedEntry(
+        ["failure", "success", "success"],
+        ($) => $ == "success",
+      ),

       [1, "success"],
     );
   });
 
   it("[[Call]] works on arraylike objects", () => {
     assertEquals(
       [1, "success"],
     );
   });
 
   it("[[Call]] works on arraylike objects", () => {
     assertEquals(

-      findIndexedEntry({ 1: "success", length: 2 }, ($) => $),
+      findFirstIndexedEntry({ 1: "success", length: 2 }, ($) => $),

       [1, "success"],
     );
     assertEquals(
       [1, "success"],
     );
     assertEquals(

-      findIndexedEntry({ 1: "failure", length: 1 }, ($) => $),
-      void {},
+      findFirstIndexedEntry({ 1: "failure", length: 1 }, ($) => $),
+      undefined,

     );
   });
 
   it("[[Call]] only gets the value once", () => {
     const get1 = spy(() => true);
     );
   });
 
   it("[[Call]] only gets the value once", () => {
     const get1 = spy(() => true);

-    findIndexedEntry({
+    findFirstIndexedEntry({

       get 1() {
         return get1();
       },
       get 1() {
         return get1();
       },


@@ -103,63 +1052,372 @@ describe("findIndexedEntry", () => {
   });
 
   it("[[Call]] passes the value, index, and this value to the callback", () => {
   });
 
   it("[[Call]] passes the value, index, and this value to the callback", () => {

-    const arr = ["failure", "success", "success"];
+    const arr = [, "failure", "success", "success"];

     const callback = spy(($) => $ === "success");
     const thisArg = {};
     const callback = spy(($) => $ === "success");
     const thisArg = {};

-    findIndexedEntry(arr, callback, thisArg);
+    findFirstIndexedEntry(arr, callback, thisArg);

     assertSpyCalls(callback, 2);
     assertSpyCall(callback, 0, {
     assertSpyCalls(callback, 2);
     assertSpyCall(callback, 0, {

-      args: ["failure", 0, arr],
+      args: ["failure", 1, arr],

       self: thisArg,
     });
     assertSpyCall(callback, 1, {
       self: thisArg,
     });
     assertSpyCall(callback, 1, {

-      args: ["success", 1, arr],
+      args: ["success", 2, arr],
+      self: thisArg,
+    });
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new findFirstIndexedEntry([], () => {}));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(findFirstIndexedEntry.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(
+        findFirstIndexedEntry.name,
+        "findFirstIndexedEntry",
+      );
+    });
+  });
+});
+
+describe("findFirstItem", () => {
+  it("[[Call]] returns undefined if no matching item exists", () => {
+    assertStrictEquals(findFirstItem([], () => true), undefined);
+    assertStrictEquals(findFirstItem([1], () => false), undefined);
+  });
+
+  it("[[Call]] returns the first match", () => {
+    assertStrictEquals(
+      findFirstItem([, true, false], ($) => $ ?? true),
+      true,
+    );
+    assertStrictEquals(
+      findFirstItem(
+        ["failure", "success", "success"],
+        ($) => $ == "success",
+      ),
+      "success",
+    );
+  });
+
+  it("[[Call]] works on arraylike objects", () => {
+    assertStrictEquals(
+      findFirstItem({ 1: "success", length: 2 }, ($) => $),
+      "success",
+    );
+    assertStrictEquals(
+      findFirstItem({ 1: "failure", length: 1 }, ($) => $),
+      undefined,
+    );
+  });
+
+  it("[[Call]] only gets the value once", () => {
+    const get1 = spy(() => true);
+    findFirstItem({
+      get 1() {
+        return get1();
+      },
+      length: 2,
+    }, ($) => $);
+    assertSpyCalls(get1, 1);
+  });
+
+  it("[[Call]] passes the value, index, and this value to the callback", () => {
+    const arr = [, "failure", "success", "success"];
+    const callback = spy(($) => $ === "success");
+    const thisArg = {};
+    findFirstItem(arr, callback, thisArg);
+    assertSpyCalls(callback, 2);
+    assertSpyCall(callback, 0, {
+      args: ["failure", 1, arr],
+      self: thisArg,
+    });
+    assertSpyCall(callback, 1, {
+      args: ["success", 2, arr],

       self: thisArg,
     });
   });
       self: thisArg,
     });
   });

+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new findFirstItem([], () => {}));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(findFirstItem.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(findFirstItem.name, "findFirstItem");
+    });
+  });

 });
 
 });
 

-describe("isArrayIndexString", () => {
-  it("[[Call]] returns false for nonstrings", () => {
-    assertStrictEquals(isArrayIndexString(1), false);
+describe("findLastIndex", () => {
+  it("[[Call]] returns undefined if no matching entry exists", () => {
+    assertStrictEquals(findLastIndex([], () => true), undefined);
+    assertStrictEquals(findLastIndex([1], () => false), undefined);
+  });
+
+  it("[[Call]] returns an index for the first match", () => {
+    assertStrictEquals(
+      findLastIndex([true, false, ,], ($) => $ ?? true),
+      0,
+    );
+    assertStrictEquals(
+      findLastIndex(
+        ["success", "success", "failure"],
+        ($) => $ == "success",
+      ),
+      1,
+    );
+  });
+
+  it("[[Call]] works on arraylike objects", () => {
+    assertStrictEquals(
+      findLastIndex({ 1: "success", length: 2 }, ($) => $),
+      1,
+    );
+    assertStrictEquals(
+      findLastIndex({ 1: "failure", length: 1 }, ($) => $),
+      undefined,
+    );
+  });
+
+  it("[[Call]] only gets the value once", () => {
+    const get1 = spy(() => true);
+    findLastIndex({
+      get 1() {
+        return get1();
+      },
+      length: 2,
+    }, ($) => $);
+    assertSpyCalls(get1, 1);

   });
 
   });
 

-  it("[[Call]] returns false for noncanonical strings", () => {
-    assertStrictEquals(isArrayIndexString(""), false);
-    assertStrictEquals(isArrayIndexString("01"), false);
-    assertStrictEquals(isArrayIndexString("9007199254740993"), false);
+  it("[[Call]] passes the value, index, and this value to the callback", () => {
+    const arr = ["success", "success", "failure", ,];
+    const callback = spy(($) => $ === "success");
+    const thisArg = {};
+    findLastIndex(arr, callback, thisArg);
+    assertSpyCalls(callback, 2);
+    assertSpyCall(callback, 0, {
+      args: ["failure", 2, arr],
+      self: thisArg,
+    });
+    assertSpyCall(callback, 1, {
+      args: ["success", 1, arr],
+      self: thisArg,
+    });

   });
 
   });
 

-  it("[[Call]] returns false for nonfinite numbers", () => {
-    assertStrictEquals(isArrayIndexString("NaN"), false);
-    assertStrictEquals(isArrayIndexString("Infinity"), false);
-    assertStrictEquals(isArrayIndexString("-Infinity"), false);
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new findLastIndex([], () => {}));

   });
 
   });
 

-  it("[[Call]] returns false for negative numbers", () => {
-    assertStrictEquals(isArrayIndexString("-0"), false);
-    assertStrictEquals(isArrayIndexString("-1"), false);
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(findLastIndex.length, 2);
+    });

   });
 
   });
 

-  it("[[Call]] returns false for nonintegers", () => {
-    assertStrictEquals(isArrayIndexString("0.25"), false);
-    assertStrictEquals(isArrayIndexString("1.1"), false);
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(findLastIndex.name, "findLastIndex");
+    });

   });
   });

+});

 
 

-  it("[[Call]] returns false for numbers greater than or equal to -1 >>> 0", () => {
-    assertStrictEquals(isArrayIndexString(String(-1 >>> 0)), false);
+describe("findLastIndexedEntry", () => {
+  it("[[Call]] returns undefined if no matching entry exists", () => {

     assertStrictEquals(
     assertStrictEquals(

-      isArrayIndexString(String((-1 >>> 0) + 1)),
-      false,
+      findLastIndexedEntry([], () => true),
+      undefined,
+    );
+    assertStrictEquals(
+      findLastIndexedEntry([1], () => false),
+      undefined,
+    );
+  });
+
+  it("[[Call]] returns an index for the first match", () => {
+    assertEquals(
+      findLastIndexedEntry([true, false, ,], ($) => $ ?? true),
+      [0, true],
+    );
+    assertEquals(
+      findLastIndexedEntry(
+        ["success", "success", "failure"],
+        ($) => $ == "success",
+      ),
+      [1, "success"],
+    );
+  });
+
+  it("[[Call]] works on arraylike objects", () => {
+    assertEquals(
+      findLastIndexedEntry({ 1: "success", length: 2 }, ($) => $),
+      [1, "success"],
+    );
+    assertEquals(
+      findLastIndexedEntry({ 1: "failure", length: 1 }, ($) => $),
+      undefined,

     );
   });
 
     );
   });
 

-  it("[[Call]] returns true for array lengths less than -1 >>> 0", () => {
-    assertStrictEquals(isArrayIndexString("0"), true);
+  it("[[Call]] only gets the value once", () => {
+    const get1 = spy(() => true);
+    findLastIndexedEntry({
+      get 1() {
+        return get1();
+      },
+      length: 2,
+    }, ($) => $);
+    assertSpyCalls(get1, 1);
+  });
+
+  it("[[Call]] passes the value, index, and this value to the callback", () => {
+    const arr = ["success", "success", "failure", ,];
+    const callback = spy(($) => $ === "success");
+    const thisArg = {};
+    findLastIndexedEntry(arr, callback, thisArg);
+    assertSpyCalls(callback, 2);
+    assertSpyCall(callback, 0, {
+      args: ["failure", 2, arr],
+      self: thisArg,
+    });
+    assertSpyCall(callback, 1, {
+      args: ["success", 1, arr],
+      self: thisArg,
+    });
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new findLastIndexedEntry([], () => {}));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(findLastIndexedEntry.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(
+        findLastIndexedEntry.name,
+        "findLastIndexedEntry",
+      );
+    });
+  });
+});
+
+describe("findLastItem", () => {
+  it("[[Call]] returns undefined if no matching entry exists", () => {
+    assertStrictEquals(findLastItem([], () => true), undefined);
+    assertStrictEquals(findLastItem([1], () => false), undefined);
+  });
+
+  it("[[Call]] returns an index for the first match", () => {

     assertStrictEquals(
     assertStrictEquals(

-      isArrayIndexString(String((-1 >>> 0) - 1)),
+      findLastItem([true, false, ,], ($) => $ ?? true),

       true,
     );
       true,
     );

+    assertStrictEquals(
+      findLastItem(
+        ["success", "success", "failure"],
+        ($) => $ == "success",
+      ),
+      "success",
+    );
+  });
+
+  it("[[Call]] works on arraylike objects", () => {
+    assertStrictEquals(
+      findLastItem({ 1: "success", length: 2 }, ($) => $),
+      "success",
+    );
+    assertStrictEquals(
+      findLastItem({ 1: "failure", length: 1 }, ($) => $),
+      undefined,
+    );
+  });
+
+  it("[[Call]] only gets the value once", () => {
+    const get1 = spy(() => true);
+    findLastItem({
+      get 1() {
+        return get1();
+      },
+      length: 2,
+    }, ($) => $);
+    assertSpyCalls(get1, 1);
+  });
+
+  it("[[Call]] passes the value, index, and this value to the callback", () => {
+    const arr = ["success", "success", "failure", ,];
+    const callback = spy(($) => $ === "success");
+    const thisArg = {};
+    findLastItem(arr, callback, thisArg);
+    assertSpyCalls(callback, 2);
+    assertSpyCall(callback, 0, {
+      args: ["failure", 2, arr],
+      self: thisArg,
+    });
+    assertSpyCall(callback, 1, {
+      args: ["success", 1, arr],
+      self: thisArg,
+    });
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new findLastItem([], () => {}));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(findLastItem.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(findLastItem.name, "findLastItem");
+    });
+  });
+});
+
+describe("flatmap", () => {
+  it("[[Call]] flatmaps", () => {
+    assertEquals(
+      flatmap([, "a", ["b"], [["c"]]], ($) => $),
+      ["a", "b", ["c"]],
+    );
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new flatmap([], () => {}));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(flatmap.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(flatmap.name, "flatmap");
+    });

   });
 });
 
   });
 });
 


@@ -230,172 +1488,54 @@ describe("isCollection", () => {
   });
 });
 
   });
 });
 

-describe("isConcatSpreadable", () => {
-  it("[[Call]] returns false for primitives", () => {
-    assertStrictEquals(isConcatSpreadable("failure"), false);
-  });
-
-  it("[[Call]] returns false if [Symbol.isConcatSpreadable] is null or false", () => {
-    assertStrictEquals(
-      isConcatSpreadable(
-        Object.assign([], { [Symbol.isConcatSpreadable]: null }),
-      ),
-      false,
-    );
-    assertStrictEquals(
-      isConcatSpreadable(
-        Object.assign([], { [Symbol.isConcatSpreadable]: false }),
-      ),
-      false,
-    );
-  });
-
-  it("[[Call]] returns true if [Symbol.isConcatSpreadable] is undefined and the object is an array", () => {
-    assertStrictEquals(
-      isConcatSpreadable(
-        Object.assign([], { [Symbol.isConcatSpreadable]: undefined }),
-      ),
-      true,
-    );
-  });
-
-  it("[[Call]] returns true if [Symbol.isConcatSpreadable] is true", () => {
+describe("isDenseProxy", () => {
+  it("[[Call]] returns true for dense proxies", () => {
+    const underlying = [];
+    const proxy = denseProxy(underlying);

     assertStrictEquals(
     assertStrictEquals(

-      isConcatSpreadable({ [Symbol.isConcatSpreadable]: true }),
+      isDenseProxy(proxy),

       true,
     );
   });
       true,
     );
   });

-});
-
-describe("isIntegerIndexString", () => {
-  it("[[Call]] returns false for nonstrings", () => {
-    assertStrictEquals(isIntegerIndexString(1), false);
-  });

 
 

-  it("[[Call]] returns false for noncanonical strings", () => {
-    assertStrictEquals(isIntegerIndexString(""), false);
-    assertStrictEquals(isIntegerIndexString("01"), false);
+  it("[[Call]] returns false for others", () => {

     assertStrictEquals(
     assertStrictEquals(

-      isIntegerIndexString("9007199254740993"),
+      isDenseProxy([]),

       false,
     );
   });
 
       false,
     );
   });
 

-  it("[[Call]] returns false for nonfinite numbers", () => {
-    assertStrictEquals(isIntegerIndexString("NaN"), false);
-    assertStrictEquals(isIntegerIndexString("Infinity"), false);
-    assertStrictEquals(isIntegerIndexString("-Infinity"), false);
-  });
-
-  it("[[Call]] returns false for negative numbers", () => {
-    assertStrictEquals(isIntegerIndexString("-0"), false);
-    assertStrictEquals(isIntegerIndexString("-1"), false);
-  });
-
-  it("[[Call]] returns false for nonintegers", () => {
-    assertStrictEquals(isIntegerIndexString("0.25"), false);
-    assertStrictEquals(isIntegerIndexString("1.1"), false);
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new isDenseProxy([]));

   });
 
   });
 

-  it("[[Call]] returns false for numbers greater than or equal to 2 ** 53", () => {
-    assertStrictEquals(
-      isIntegerIndexString("9007199254740992"),
-      false,
-    );
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(isDenseProxy.length, 1);
+    });

   });
 
   });
 

-  it("[[Call]] returns true for safe canonical integer strings", () => {
-    assertStrictEquals(isIntegerIndexString("0"), true);
-    assertStrictEquals(isIntegerIndexString("9007199254740991"), true);
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(isDenseProxy.name, "isDenseProxy");
+    });

   });
 });
 
   });
 });
 

-describe("lengthOfArrayLike", () => {
-  it("[[Call]] returns the length", () => {
-    assertStrictEquals(
-      lengthOfArrayLike({ length: 9007199254740991 }),
-      9007199254740991,
-    );
-  });
-
-  it("[[Call]] returns a non·nan result", () => {
-    assertStrictEquals(lengthOfArrayLike({ length: NaN }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: "failure" }), 0);
-  });
-
-  it("[[Call]] returns an integral result", () => {
-    assertStrictEquals(lengthOfArrayLike({ length: 0.25 }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: 1.1 }), 1);
-  });
-
-  it("[[Call]] returns a result greater than or equal to zero", () => {
-    assertStrictEquals(lengthOfArrayLike({ length: -0 }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: -1 }), 0);
-    assertStrictEquals(lengthOfArrayLike({ length: -Infinity }), 0);
-  });
-
-  it("[[Call]] returns a result less than 2 ** 53", () => {
-    assertStrictEquals(
-      lengthOfArrayLike({ length: 9007199254740992 }),
-      9007199254740991,
-    );
-    assertStrictEquals(
-      lengthOfArrayLike({ length: Infinity }),
-      9007199254740991,
+describe("toArray", () => {
+  it("[[Call]] returns an array of the values in a provided arraylike", () => {
+    assertEquals(
+      toArray({ 1: "success", length: 3 }),
+      [, "success", ,],

     );
   });
 });
 
     );
   });
 });
 

-describe("toIndex", () => {
-  it("[[Call]] returns an index", () => {
-    assertStrictEquals(toIndex(9007199254740991), 9007199254740991);
-  });
-
-  it("[[Call]] returns zero for a zerolike result", () => {
-    assertStrictEquals(toIndex(NaN), 0);
-    assertStrictEquals(toIndex("failure"), 0);
-    assertStrictEquals(toIndex(-0), 0);
-  });
-
-  it("[[Call]] rounds down to the nearest integer", () => {
-    assertStrictEquals(toIndex(0.25), 0);
-    assertStrictEquals(toIndex(1.1), 1);
-  });
-
-  it("[[Call]] throws when provided a negative number", () => {
-    assertThrows(() => toIndex(-1));
-    assertThrows(() => toIndex(-Infinity));
-  });
-
-  it("[[Call]] throws when provided a number greater than or equal to 2 ** 53", () => {
-    assertThrows(() => toIndex(9007199254740992));
-    assertThrows(() => toIndex(Infinity));
-  });
-});
-
-describe("toLength", () => {
-  it("[[Call]] returns a length", () => {
-    assertStrictEquals(toLength(9007199254740991), 9007199254740991);
-  });
-
-  it("[[Call]] returns a non·nan result", () => {
-    assertStrictEquals(toLength(NaN), 0);
-    assertStrictEquals(toLength("failure"), 0);
-  });
-
-  it("[[Call]] returns an integral result", () => {
-    assertStrictEquals(toLength(0.25), 0);
-    assertStrictEquals(toLength(1.1), 1);
-  });
-
-  it("[[Call]] returns a result greater than or equal to zero", () => {
-    assertStrictEquals(toLength(-0), 0);
-    assertStrictEquals(toLength(-1), 0);
-    assertStrictEquals(toLength(-Infinity), 0);
-  });
-
-  it("[[Call]] returns a result less than 2 ** 53", () => {
-    assertStrictEquals(toLength(9007199254740992), 9007199254740991);
-    assertStrictEquals(toLength(Infinity), 9007199254740991);
+describe("toDenseArray", () => {
+  it("[[Call]] returns a dense array of the values in a provided arraylike", () => {
+    assertEquals(
+      toDenseArray({ 1: "success", length: 3 }),
+      [undefined, "success", undefined],
+    );

   });
 });
   });
 });