Add denseProxy, various collection.js improvements

[Pisces] / string.test.js

diff --git a/string.test.js b/string.test.js
index e98a040bdd1f080697f8c094c41498b4678a3075..e567060f81bac2fcf1efa427e5798c49e3a3098b 100644 (file)
--- a/string.test.js
+++ b/string.test.js
@@ -1,11 +1,14 @@
-// ♓🌟 Piscēs ∷ string.test.js
-// ====================================================================
-//
-// Copyright © 2022–2023 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 ∷ string.test.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 {
   assert,
 
 import {
   assert,


@@ -32,7 +35,7 @@ import {
   Matcher,
   rawString,
   scalarValues,
   Matcher,
   rawString,
   scalarValues,

-  splitOnASCIIWhitespace,
+  splitOnAsciiWhitespace,

   splitOnCommas,
   stringCatenate,
   stringEndsWith,
   splitOnCommas,
   stringCatenate,
   stringEndsWith,


@@ -52,8 +55,8 @@ import {
   stringSplit,
   stringStartsWith,
   stringValue,
   stringSplit,
   stringStartsWith,
   stringValue,

-  stripAndCollapseASCIIWhitespace,
-  stripLeadingAndTrailingASCIIWhitespace,
+  stripAndCollapseAsciiWhitespace,
+  stripLeadingAndTrailingAsciiWhitespace,

   substring,
   toScalarValueString,
   toString,
   substring,
   toScalarValueString,
   toString,


@@ -72,7 +75,11 @@ describe("Matcher", () => {
     assert(new Matcher(/(?:)/u));
   });
 
     assert(new Matcher(/(?:)/u));
   });
 

-  it("[[Construct]] throws with a non·unicode regular expression first argument", () => {
+  it("[[Construct]] accepts a unicode sets regular expression first argument", () => {
+    assert(new Matcher(/(?:)/v));
+  });
+
+  it("[[Construct]] throws with a non·unicode·aware regular expression first argument", () => {

     assertThrows(() => new Matcher(/(?:)/));
   });
 
     assertThrows(() => new Matcher(/(?:)/));
   });
 


@@ -107,6 +114,12 @@ describe("Matcher", () => {
     });
   });
 
     });
   });
 

+  describe("::constructor", () => {
+    it("[[Get]] returns the same constructor", () => {
+      assertStrictEquals(new Matcher(/(?:)/su).constructor, Matcher);
+    });
+  });
+

   describe("::dotAll", () => {
     it("[[Get]] returns true when the dotAll flag is present", () => {
       assertStrictEquals(new Matcher(/(?:)/su).dotAll, true);
   describe("::dotAll", () => {
     it("[[Get]] returns true when the dotAll flag is present", () => {
       assertStrictEquals(new Matcher(/(?:)/su).dotAll, true);


@@ -116,7 +129,7 @@ describe("Matcher", () => {
       assertStrictEquals(new Matcher(/(?:)/u).dotAll, false);
     });
 
       assertStrictEquals(new Matcher(/(?:)/u).dotAll, false);
     });
 

-    describe(".length", () => {
+    describe("[[GetOwnProperty]].get.length", () => {

       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -128,7 +141,7 @@ describe("Matcher", () => {
       });
     });
 
       });
     });
 

-    describe(".name", () => {
+    describe("[[GetOwnProperty]].get.name", () => {

       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -191,6 +204,11 @@ describe("Matcher", () => {
       );
     });
 
       );
     });
 

+    it("[[Construct]] throws an error", () => {
+      const matcher = new Matcher("");
+      assertThrows(() => new matcher.exec());
+    });
+

     describe(".length", () => {
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(Matcher.prototype.exec.length, 1);
     describe(".length", () => {
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(Matcher.prototype.exec.length, 1);


@@ -213,7 +231,7 @@ describe("Matcher", () => {
       assertStrictEquals(new Matcher(/(?:)/u).global, false);
     });
 
       assertStrictEquals(new Matcher(/(?:)/u).global, false);
     });
 

-    describe(".length", () => {
+    describe("[[GetOwnProperty]].get.length", () => {

       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -225,7 +243,7 @@ describe("Matcher", () => {
       });
     });
 
       });
     });
 

-    describe(".name", () => {
+    describe("[[GetOwnProperty]].get.name", () => {

       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -247,7 +265,7 @@ describe("Matcher", () => {
       assertStrictEquals(new Matcher(/(?:)/u).hasIndices, false);
     });
 
       assertStrictEquals(new Matcher(/(?:)/u).hasIndices, false);
     });
 

-    describe(".length", () => {
+    describe("[[GetOwnProperty]].get.length", () => {

       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -259,7 +277,7 @@ describe("Matcher", () => {
       });
     });
 
       });
     });
 

-    describe(".name", () => {
+    describe("[[GetOwnProperty]].get.name", () => {

       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -281,7 +299,7 @@ describe("Matcher", () => {
       assertStrictEquals(new Matcher(/(?:)/u).ignoreCase, false);
     });
 
       assertStrictEquals(new Matcher(/(?:)/u).ignoreCase, false);
     });
 

-    describe(".length", () => {
+    describe("[[GetOwnProperty]].get.length", () => {

       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -293,7 +311,7 @@ describe("Matcher", () => {
       });
     });
 
       });
     });
 

-    describe(".name", () => {
+    describe("[[GetOwnProperty]].get.name", () => {

       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -315,7 +333,7 @@ describe("Matcher", () => {
       assertStrictEquals(new Matcher(/(?:)/u).multiline, false);
     });
 
       assertStrictEquals(new Matcher(/(?:)/u).multiline, false);
     });
 

-    describe(".length", () => {
+    describe("[[GetOwnProperty]].get.length", () => {

       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -327,7 +345,7 @@ describe("Matcher", () => {
       });
     });
 
       });
     });
 

-    describe(".name", () => {
+    describe("[[GetOwnProperty]].get.name", () => {

       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -346,7 +364,7 @@ describe("Matcher", () => {
       assertStrictEquals(new Matcher(/.*/su).source, ".*");
     });
 
       assertStrictEquals(new Matcher(/.*/su).source, ".*");
     });
 

-    describe(".length", () => {
+    describe("[[GetOwnProperty]].get.length", () => {

       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -358,7 +376,7 @@ describe("Matcher", () => {
       });
     });
 
       });
     });
 

-    describe(".name", () => {
+    describe("[[GetOwnProperty]].get.name", () => {

       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -380,7 +398,7 @@ describe("Matcher", () => {
       assertStrictEquals(new Matcher(/(?:)/u).sticky, false);
     });
 
       assertStrictEquals(new Matcher(/(?:)/u).sticky, false);
     });
 

-    describe(".length", () => {
+    describe("[[GetOwnProperty]].get.length", () => {

       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -392,7 +410,7 @@ describe("Matcher", () => {
       });
     });
 
       });
     });
 

-    describe(".name", () => {
+    describe("[[GetOwnProperty]].get.name", () => {

       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -409,6 +427,26 @@ describe("Matcher", () => {
     it("[[Call]] returns the string source", () => {
       assertStrictEquals(new Matcher(/(?:)/u).toString(), "/(?:)/u");
     });
     it("[[Call]] returns the string source", () => {
       assertStrictEquals(new Matcher(/(?:)/u).toString(), "/(?:)/u");
     });

+
+    it("[[Construct]] throws an error", () => {
+      const matcher = new Matcher("");
+      assertThrows(() => new matcher.toString());
+    });
+
+    describe(".length", () => {
+      it("[[Get]] returns the correct length", () => {
+        assertStrictEquals(Matcher.prototype.toString.length, 0);
+      });
+    });
+
+    describe(".name", () => {
+      it("[[Get]] returns the correct name", () => {
+        assertStrictEquals(
+          Matcher.prototype.toString.name,
+          "toString",
+        );
+      });
+    });

   });
 
   describe("::unicode", () => {
   });
 
   describe("::unicode", () => {


@@ -416,7 +454,7 @@ describe("Matcher", () => {
       assertStrictEquals(new Matcher(/(?:)/u).unicode, true);
     });
 
       assertStrictEquals(new Matcher(/(?:)/u).unicode, true);
     });
 

-    describe(".length", () => {
+    describe("[[GetOwnProperty]].get.length", () => {

       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct length", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -428,7 +466,7 @@ describe("Matcher", () => {
       });
     });
 
       });
     });
 

-    describe(".name", () => {
+    describe("[[GetOwnProperty]].get.name", () => {

       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(
       it("[[Get]] returns the correct name", () => {
         assertStrictEquals(
           Object.getOwnPropertyDescriptor(


@@ -441,6 +479,36 @@ describe("Matcher", () => {
     });
   });
 
     });
   });
 

+  describe("::unicodeSets", () => {
+    it("[[Get]] returns true when the unicode sets flag is present", () => {
+      assertStrictEquals(new Matcher(/(?:)/v).unicodeSets, true);
+    });
+
+    describe("[[GetOwnProperty]].get.length", () => {
+      it("[[Get]] returns the correct length", () => {
+        assertStrictEquals(
+          Object.getOwnPropertyDescriptor(
+            Matcher.prototype,
+            "unicodeSets",
+          ).get.length,
+          0,
+        );
+      });
+    });
+
+    describe("[[GetOwnProperty]].get.name", () => {
+      it("[[Get]] returns the correct name", () => {
+        assertStrictEquals(
+          Object.getOwnPropertyDescriptor(
+            Matcher.prototype,
+            "unicodeSets",
+          ).get.name,
+          "get unicodeSets",
+        );
+      });
+    });
+  });
+

   describe("~", () => {
     it("[[Call]] returns true for a complete match", () => {
       assertStrictEquals(new Matcher("")(""), true);
   describe("~", () => {
     it("[[Call]] returns true for a complete match", () => {
       assertStrictEquals(new Matcher("")(""), true);


@@ -482,6 +550,11 @@ describe("Matcher", () => {
         false,
       );
     });
         false,
       );
     });

+
+    it("[[Construct]] throws an error", () => {
+      const matcher = new Matcher("");
+      assertThrows(() => new matcher(""));
+    });

   });
 
   describe("~lastIndex", () => {
   });
 
   describe("~lastIndex", () => {


@@ -986,67 +1059,67 @@ describe("scalarValues", () => {
   });
 });
 
   });
 });
 

-describe("splitOnASCIIWhitespace", () => {
+describe("splitOnAsciiWhitespace", () => {

   it("[[Call]] splits on sequences of spaces", () => {
     assertEquals(
   it("[[Call]] splits on sequences of spaces", () => {
     assertEquals(

-      splitOnASCIIWhitespace("🅰️   🅱️ 🆎  🅾️"),
+      splitOnAsciiWhitespace("🅰️   🅱️ 🆎  🅾️"),

       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of tabs", () => {
     assertEquals(
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of tabs", () => {
     assertEquals(

-      splitOnASCIIWhitespace("🅰️\t\t\t🅱️\t🆎\t\t🅾️"),
+      splitOnAsciiWhitespace("🅰️\t\t\t🅱️\t🆎\t\t🅾️"),

       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of carriage returns", () => {
     assertEquals(
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of carriage returns", () => {
     assertEquals(

-      splitOnASCIIWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"),
+      splitOnAsciiWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"),

       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of newlines", () => {
     assertEquals(
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of newlines", () => {
     assertEquals(

-      splitOnASCIIWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"),
+      splitOnAsciiWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"),

       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of form feeds", () => {
     assertEquals(
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on sequences of form feeds", () => {
     assertEquals(

-      splitOnASCIIWhitespace("🅰️\f\f\f🅱️\f🆎\f\f🅾️"),
+      splitOnAsciiWhitespace("🅰️\f\f\f🅱️\f🆎\f\f🅾️"),

       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on mixed whitespace", () => {
     assertEquals(
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] splits on mixed whitespace", () => {
     assertEquals(

-      splitOnASCIIWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"),
+      splitOnAsciiWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"),

       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] returns an array of just the empty string for the empty string", () => {
       ["🅰️", "🅱️", "🆎", "🅾️"],
     );
   });
 
   it("[[Call]] returns an array of just the empty string for the empty string", () => {

-    assertEquals(splitOnASCIIWhitespace(""), [""]);
+    assertEquals(splitOnAsciiWhitespace(""), [""]);

   });
 
   it("[[Call]] returns a single token if there are no spaces", () => {
   });
 
   it("[[Call]] returns a single token if there are no spaces", () => {

-    assertEquals(splitOnASCIIWhitespace("abcd"), ["abcd"]);
+    assertEquals(splitOnAsciiWhitespace("abcd"), ["abcd"]);

   });
 
   it("[[Call]] does not split on other kinds of whitespace", () => {
     assertEquals(
   });
 
   it("[[Call]] does not split on other kinds of whitespace", () => {
     assertEquals(

-      splitOnASCIIWhitespace("a\u202F\u205F\xa0\v\0\bb"),
+      splitOnAsciiWhitespace("a\u202F\u205F\xa0\v\0\bb"),

       ["a\u202F\u205F\xa0\v\0\bb"],
     );
   });
 
   it("[[Call]] trims leading and trailing whitespace", () => {
     assertEquals(
       ["a\u202F\u205F\xa0\v\0\bb"],
     );
   });
 
   it("[[Call]] trims leading and trailing whitespace", () => {
     assertEquals(

-      splitOnASCIIWhitespace(
+      splitOnAsciiWhitespace(

         "\f\r\n\r\n \n\t🅰️\f \t\n🅱️\r🆎\n\f🅾️\n\f",
       ),
       ["🅰️", "🅱️", "🆎", "🅾️"],
         "\f\r\n\r\n \n\t🅰️\f \t\n🅱️\r🆎\n\f🅾️\n\f",
       ),
       ["🅰️", "🅱️", "🆎", "🅾️"],


@@ -1054,20 +1127,20 @@ describe("splitOnASCIIWhitespace", () => {
   });
 
   it("[[Construct]] throws an error", () => {
   });
 
   it("[[Construct]] throws an error", () => {

-    assertThrows(() => new splitOnASCIIWhitespace(""));
+    assertThrows(() => new splitOnAsciiWhitespace(""));

   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {
   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {

-      assertStrictEquals(splitOnASCIIWhitespace.length, 1);
+      assertStrictEquals(splitOnAsciiWhitespace.length, 1);

     });
   });
 
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(
     });
   });
 
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(

-        splitOnASCIIWhitespace.name,
-        "splitOnASCIIWhitespace",
+        splitOnAsciiWhitespace.name,
+        "splitOnAsciiWhitespace",

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


@@ -1521,8 +1594,8 @@ describe("stringReplace", () => {
         "very success full",
         /([sc]+)[ue]?/g,
         (...$s) =>
         "very success full",
         /([sc]+)[ue]?/g,
         (...$s) =>

-          `${$s[0].length}`.repeat($s[1].length) +
-          $s[0].substring($s[1].length),
+          `${$s[0].length}`.repeat($s[1].length)
+          + $s[0].substring($s[1].length),

       ),
       "very 2u33e22 full",
     );
       ),
       "very 2u33e22 full",
     );


@@ -1556,8 +1629,8 @@ describe("stringReplaceAll", () => {
         "very success full",
         /([sc]+)[ue]?/g,
         (...$s) =>
         "very success full",
         /([sc]+)[ue]?/g,
         (...$s) =>

-          `${$s[0].length}`.repeat($s[1].length) +
-          $s[0].substring($s[1].length),
+          `${$s[0].length}`.repeat($s[1].length)
+          + $s[0].substring($s[1].length),

       ),
       "very 2u33e22 full",
     );
       ),
       "very 2u33e22 full",
     );


@@ -1753,17 +1826,17 @@ describe("stringStartsWith", () => {
   });
 });
 
   });
 });
 

-describe("stripAndCollapseASCIIWhitespace", () => {
+describe("stripAndCollapseAsciiWhitespace", () => {

   it("[[Call]] collapses mixed inner whitespace", () => {
     assertEquals(
   it("[[Call]] collapses mixed inner whitespace", () => {
     assertEquals(

-      stripAndCollapseASCIIWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"),
+      stripAndCollapseAsciiWhitespace("🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️"),

       "🅰️ 🅱️ 🆎 🅾️",
     );
   });
 
   it("[[Call]] trims leading and trailing whitespace", () => {
     assertStrictEquals(
       "🅰️ 🅱️ 🆎 🅾️",
     );
   });
 
   it("[[Call]] trims leading and trailing whitespace", () => {
     assertStrictEquals(

-      stripAndCollapseASCIIWhitespace(
+      stripAndCollapseAsciiWhitespace(

         "\f\r\n\r\n \n\t\f 🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️\n\f",
       ),
       "🅰️ 🅱️ 🆎 🅾️",
         "\f\r\n\r\n \n\t\f 🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️\n\f",
       ),
       "🅰️ 🅱️ 🆎 🅾️",


@@ -1772,42 +1845,42 @@ describe("stripAndCollapseASCIIWhitespace", () => {
 
   it("[[Call]] returns the empty string for strings of whitespace", () => {
     assertStrictEquals(
 
   it("[[Call]] returns the empty string for strings of whitespace", () => {
     assertStrictEquals(

-      stripAndCollapseASCIIWhitespace("\f\r\n\r\n \n\t\f \n\f"),
+      stripAndCollapseAsciiWhitespace("\f\r\n\r\n \n\t\f \n\f"),

       "",
     );
   });
 
   it("[[Call]] does not collapse other kinds of whitespace", () => {
     assertEquals(
       "",
     );
   });
 
   it("[[Call]] does not collapse other kinds of whitespace", () => {
     assertEquals(

-      stripAndCollapseASCIIWhitespace("a\u202F\u205F\xa0\v\0\bb"),
+      stripAndCollapseAsciiWhitespace("a\u202F\u205F\xa0\v\0\bb"),

       "a\u202F\u205F\xa0\v\0\bb",
     );
   });
 
   it("[[Construct]] throws an error", () => {
       "a\u202F\u205F\xa0\v\0\bb",
     );
   });
 
   it("[[Construct]] throws an error", () => {

-    assertThrows(() => new stripAndCollapseASCIIWhitespace(""));
+    assertThrows(() => new stripAndCollapseAsciiWhitespace(""));

   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {
   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {

-      assertStrictEquals(stripAndCollapseASCIIWhitespace.length, 1);
+      assertStrictEquals(stripAndCollapseAsciiWhitespace.length, 1);

     });
   });
 
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(
     });
   });
 
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(

-        stripAndCollapseASCIIWhitespace.name,
-        "stripAndCollapseASCIIWhitespace",
+        stripAndCollapseAsciiWhitespace.name,
+        "stripAndCollapseAsciiWhitespace",

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

-describe("stripLeadingAndTrailingASCIIWhitespace", () => {
+describe("stripLeadingAndTrailingAsciiWhitespace", () => {

   it("[[Call]] trims leading and trailing whitespace", () => {
     assertStrictEquals(
   it("[[Call]] trims leading and trailing whitespace", () => {
     assertStrictEquals(

-      stripLeadingAndTrailingASCIIWhitespace(
+      stripLeadingAndTrailingAsciiWhitespace(

         "\f\r\n\r\n \n\t\f 🅰️🅱️🆎🅾️\n\f",
       ),
       "🅰️🅱️🆎🅾️",
         "\f\r\n\r\n \n\t\f 🅰️🅱️🆎🅾️\n\f",
       ),
       "🅰️🅱️🆎🅾️",


@@ -1816,14 +1889,14 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => {
 
   it("[[Call]] returns the empty string for strings of whitespace", () => {
     assertStrictEquals(
 
   it("[[Call]] returns the empty string for strings of whitespace", () => {
     assertStrictEquals(

-      stripLeadingAndTrailingASCIIWhitespace("\f\r\n\r\n \n\t\f \n\f"),
+      stripLeadingAndTrailingAsciiWhitespace("\f\r\n\r\n \n\t\f \n\f"),

       "",
     );
   });
 
   it("[[Call]] does not trim other kinds of whitespace", () => {
     assertEquals(
       "",
     );
   });
 
   it("[[Call]] does not trim other kinds of whitespace", () => {
     assertEquals(

-      stripLeadingAndTrailingASCIIWhitespace(
+      stripLeadingAndTrailingAsciiWhitespace(

         "\v\u202F\u205Fx\0\b\xa0",
       ),
       "\v\u202F\u205Fx\0\b\xa0",
         "\v\u202F\u205Fx\0\b\xa0",
       ),
       "\v\u202F\u205Fx\0\b\xa0",


@@ -1832,19 +1905,19 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => {
 
   it("[[Call]] does not adjust inner whitespace", () => {
     assertEquals(
 
   it("[[Call]] does not adjust inner whitespace", () => {
     assertEquals(

-      stripLeadingAndTrailingASCIIWhitespace("a   b"),
+      stripLeadingAndTrailingAsciiWhitespace("a   b"),

       "a   b",
     );
   });
 
   it("[[Construct]] throws an error", () => {
       "a   b",
     );
   });
 
   it("[[Construct]] throws an error", () => {

-    assertThrows(() => new stripLeadingAndTrailingASCIIWhitespace(""));
+    assertThrows(() => new stripLeadingAndTrailingAsciiWhitespace(""));

   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {
       assertStrictEquals(
   });
 
   describe(".length", () => {
     it("[[Get]] returns the correct length", () => {
       assertStrictEquals(

-        stripLeadingAndTrailingASCIIWhitespace.length,
+        stripLeadingAndTrailingAsciiWhitespace.length,

         1,
       );
     });
         1,
       );
     });


@@ -1853,8 +1926,8 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => {
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(
   describe(".name", () => {
     it("[[Get]] returns the correct name", () => {
       assertStrictEquals(

-        stripLeadingAndTrailingASCIIWhitespace.name,
-        "stripLeadingAndTrailingASCIIWhitespace",
+        stripLeadingAndTrailingAsciiWhitespace.name,
+        "stripLeadingAndTrailingAsciiWhitespace",

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