Add methods for own entries and values to object.js

[Pisces] / string.test.js

diff --git a/string.test.js b/string.test.js
index 4f257f9f96f28a8d799cb0fd447c28895e429c00..ee0e2097328535d6cbd1af583152d62ae74062b2 100644 (file)
--- a/string.test.js
+++ b/string.test.js
@@ -20,6 +20,7 @@ import {
 import {
   asciiLowercase,
   asciiUppercase,
 import {
   asciiLowercase,
   asciiUppercase,

+  canonicalNumericIndexString,

   characters,
   codepoints,
   codeUnits,
   characters,
   codepoints,
   codeUnits,


@@ -28,12 +29,13 @@ import {
   getCodeUnit,
   getFirstSubstringIndex,
   getLastSubstringIndex,
   getCodeUnit,
   getFirstSubstringIndex,
   getLastSubstringIndex,

+  isArrayIndexString,
+  isIntegerIndexString,

   join,
   Matcher,
   rawString,
   scalarValues,
   join,
   Matcher,
   rawString,
   scalarValues,

-  scalarValueString,
-  splitOnASCIIWhitespace,
+  splitOnAsciiWhitespace,

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


@@ -53,9 +55,10 @@ import {
   stringSplit,
   stringStartsWith,
   stringValue,
   stringSplit,
   stringStartsWith,
   stringValue,

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

   substring,
   substring,

+  toScalarValueString,

   toString,
 } from "./string.js";
 
   toString,
 } from "./string.js";
 


@@ -107,6 +110,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);


@@ -559,6 +568,59 @@ describe("asciiUppercase", () => {
   });
 });
 
   });
 });
 

+describe("canonicalNumericIndexString", () => {
+  it("[[Call]] returns undefined for nonstrings", () => {
+    assertStrictEquals(canonicalNumericIndexString(1), void {});
+  });
+
+  it("[[Call]] returns undefined for noncanonical strings", () => {
+    assertStrictEquals(canonicalNumericIndexString(""), void {});
+    assertStrictEquals(canonicalNumericIndexString("01"), void {});
+    assertStrictEquals(
+      canonicalNumericIndexString("9007199254740993"),
+      void {},
+    );
+  });
+
+  it('[[Call]] returns -0 for "-0"', () => {
+    assertStrictEquals(canonicalNumericIndexString("-0"), -0);
+  });
+
+  it("[[Call]] returns the corresponding number for canonical strings", () => {
+    assertStrictEquals(canonicalNumericIndexString("0"), 0);
+    assertStrictEquals(canonicalNumericIndexString("-0.25"), -0.25);
+    assertStrictEquals(
+      canonicalNumericIndexString("9007199254740992"),
+      9007199254740992,
+    );
+    assertStrictEquals(canonicalNumericIndexString("NaN"), 0 / 0);
+    assertStrictEquals(canonicalNumericIndexString("Infinity"), 1 / 0);
+    assertStrictEquals(
+      canonicalNumericIndexString("-Infinity"),
+      -1 / 0,
+    );
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new canonicalNumericIndexString(""));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(canonicalNumericIndexString.length, 1);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(
+        canonicalNumericIndexString.name,
+        "canonicalNumericIndexString",
+      );
+    });
+  });
+});
+

 describe("characters", () => {
   it("[[Call]] returns an iterable", () => {
     assertStrictEquals(
 describe("characters", () => {
   it("[[Call]] returns an iterable", () => {
     assertStrictEquals(


@@ -879,82 +941,182 @@ describe("getLastSubstringIndex", () => {
   });
 });
 
   });
 });
 

-describe("join", () => {
-  it("[[Call]] joins the provided iterator with the provided separartor", () => {
-    assertStrictEquals(join([1, 2, 3, 4].values(), "☂"), "1☂2☂3☂4");
+describe("isArrayIndexString", () => {
+  it("[[Call]] returns false for nonstrings", () => {
+    assertStrictEquals(isArrayIndexString(1), false);

   });
 
   });
 

-  it('[[Call]] uses "," if no separator is provided', () => {
-    assertStrictEquals(join([1, 2, 3, 4].values()), "1,2,3,4");
+  it("[[Call]] returns false for noncanonical strings", () => {
+    assertStrictEquals(isArrayIndexString(""), false);
+    assertStrictEquals(isArrayIndexString("01"), false);
+    assertStrictEquals(isArrayIndexString("9007199254740993"), false);

   });
 
   });
 

-  it("[[Call]] uses the empty sting for nullish values", () => {
+  it("[[Call]] returns false for nonfinite numbers", () => {
+    assertStrictEquals(isArrayIndexString("NaN"), false);
+    assertStrictEquals(isArrayIndexString("Infinity"), false);
+    assertStrictEquals(isArrayIndexString("-Infinity"), false);
+  });
+
+  it("[[Call]] returns false for negative numbers", () => {
+    assertStrictEquals(isArrayIndexString("-0"), false);
+    assertStrictEquals(isArrayIndexString("-1"), false);
+  });
+
+  it("[[Call]] returns false for nonintegers", () => {
+    assertStrictEquals(isArrayIndexString("0.25"), false);
+    assertStrictEquals(isArrayIndexString("1.1"), false);
+  });
+
+  it("[[Call]] returns false for numbers greater than or equal to -1 >>> 0", () => {
+    assertStrictEquals(isArrayIndexString(String(-1 >>> 0)), false);

     assertStrictEquals(
     assertStrictEquals(

-      join([null, , null, undefined].values(), "☂"),
-      "☂☂☂",
+      isArrayIndexString(String((-1 >>> 0) + 1)),
+      false,
+    );
+  });
+
+  it("[[Call]] returns true for array lengths less than -1 >>> 0", () => {
+    assertStrictEquals(isArrayIndexString("0"), true);
+    assertStrictEquals(
+      isArrayIndexString(String((-1 >>> 0) - 1)),
+      true,

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

-    assertThrows(() => new join([]));
+    assertThrows(() => new isArrayIndexString("0"));

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

-      assertStrictEquals(join.length, 2);
+      assertStrictEquals(isArrayIndexString.length, 1);

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

-      assertStrictEquals(join.name, "join");
+      assertStrictEquals(
+        isArrayIndexString.name,
+        "isArrayIndexString",
+      );

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

-describe("rawString", () => {
-  it("[[Call]] acts like String.raw", () => {
-    assertStrictEquals(rawString`\nraw${" string"}`, "\\nraw string");
+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);
+    assertStrictEquals(
+      isIntegerIndexString("9007199254740993"),
+      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("[[Call]] returns false for numbers greater than or equal to 2 ** 53", () => {
+    assertStrictEquals(
+      isIntegerIndexString("9007199254740992"),
+      false,
+    );
+  });
+
+  it("[[Call]] returns true for safe canonical integer strings", () => {
+    assertStrictEquals(isIntegerIndexString("0"), true);
+    assertStrictEquals(isIntegerIndexString("9007199254740991"), true);

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

-    assertThrows(() => new rawString(["string"]));
+    assertThrows(() => new isIntegerIndexString("0"));

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

-      assertStrictEquals(rawString.length, 1);
+      assertStrictEquals(isIntegerIndexString.length, 1);

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

-      assertStrictEquals(rawString.name, "rawString");
+      assertStrictEquals(
+        isIntegerIndexString.name,
+        "isIntegerIndexString",
+      );

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

-describe("scalarValueString", () => {
-  it("[[Call]] replaces invalid values", () => {
+describe("join", () => {
+  it("[[Call]] joins the provided iterator with the provided separartor", () => {
+    assertStrictEquals(join([1, 2, 3, 4].values(), "☂"), "1☂2☂3☂4");
+  });
+
+  it('[[Call]] uses "," if no separator is provided', () => {
+    assertStrictEquals(join([1, 2, 3, 4].values()), "1,2,3,4");
+  });
+
+  it("[[Call]] uses the empty sting for nullish values", () => {

     assertStrictEquals(
     assertStrictEquals(

-      scalarValueString("Ii🎙\uDFFF\uDD96\uD83C\uD800🆗☺"),
-      "Ii🎙\uFFFD\uFFFD\uFFFD\uFFFD🆗☺",
+      join([null, , null, undefined].values(), "☂"),
+      "☂☂☂",

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

-    assertThrows(() => new scalarValueString(""));
+    assertThrows(() => new join([]));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(join.length, 2);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(join.name, "join");
+    });
+  });
+});
+
+describe("rawString", () => {
+  it("[[Call]] acts like String.raw", () => {
+    assertStrictEquals(rawString`\nraw${" string"}`, "\\nraw string");
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new rawString(["string"]));

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

-      assertStrictEquals(scalarValueString.length, 1);
+      assertStrictEquals(rawString.length, 1);

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

-      assertStrictEquals(scalarValueString.name, "scalarValueString");
+      assertStrictEquals(rawString.name, "rawString");

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


@@ -1011,67 +1173,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",
       ),
       ["🅰️", "🅱️", "🆎", "🅾️"],


@@ -1079,20 +1241,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",

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


@@ -1778,17 +1940,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",
       ),
       "🅰️ 🅱️ 🆎 🅾️",


@@ -1797,42 +1959,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",
       ),
       "🅰️🅱️🆎🅾️",


@@ -1841,14 +2003,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",


@@ -1857,19 +2019,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,
       );
     });


@@ -1878,8 +2040,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",

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


@@ -1914,6 +2076,34 @@ describe("substring", () => {
   });
 });
 
   });
 });
 

+describe("toScalarValueString", () => {
+  it("[[Call]] replaces invalid values", () => {
+    assertStrictEquals(
+      toScalarValueString("Ii🎙\uDFFF\uDD96\uD83C\uD800🆗☺"),
+      "Ii🎙\uFFFD\uFFFD\uFFFD\uFFFD🆗☺",
+    );
+  });
+
+  it("[[Construct]] throws an error", () => {
+    assertThrows(() => new toScalarValueString(""));
+  });
+
+  describe(".length", () => {
+    it("[[Get]] returns the correct length", () => {
+      assertStrictEquals(toScalarValueString.length, 1);
+    });
+  });
+
+  describe(".name", () => {
+    it("[[Get]] returns the correct name", () => {
+      assertStrictEquals(
+        toScalarValueString.name,
+        "toScalarValueString",
+      );
+    });
+  });
+});
+

 describe("toString", () => {
   it("[[Call]] converts to a string", () => {
     assertStrictEquals(
 describe("toString", () => {
   it("[[Call]] converts to a string", () => {
     assertStrictEquals(