X-Git-Url: https://git.ladys.computer/Pisces/blobdiff_plain/5255537dba0f1fceaf0bc50c93ae5c4e6a2af66b..e1cb83c479df2a3e4a5e918867a135ff9dde8121:/string.test.js diff --git a/string.test.js b/string.test.js index e98a040..147e109 100644 --- 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 . +// SPDX-FileCopyrightText: 2022, 2023, 2025 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 . + */ import { assert, @@ -20,6 +23,7 @@ import { import { asciiLowercase, asciiUppercase, + canonicalNumericIndexString, characters, codepoints, codeUnits, @@ -28,11 +32,13 @@ import { getCodeUnit, getFirstSubstringIndex, getLastSubstringIndex, + isArrayIndexString, + isIntegerIndexString, join, Matcher, rawString, scalarValues, - splitOnASCIIWhitespace, + splitOnAsciiWhitespace, splitOnCommas, stringCatenate, stringEndsWith, @@ -52,8 +58,8 @@ import { stringSplit, stringStartsWith, stringValue, - stripAndCollapseASCIIWhitespace, - stripLeadingAndTrailingASCIIWhitespace, + stripAndCollapseAsciiWhitespace, + stripLeadingAndTrailingAsciiWhitespace, substring, toScalarValueString, toString, @@ -72,7 +78,11 @@ describe("Matcher", () => { 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(/(?:)/)); }); @@ -107,6 +117,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); @@ -116,7 +132,7 @@ describe("Matcher", () => { assertStrictEquals(new Matcher(/(?:)/u).dotAll, false); }); - describe(".length", () => { + describe("[[GetOwnProperty]].get.length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -128,7 +144,7 @@ describe("Matcher", () => { }); }); - describe(".name", () => { + describe("[[GetOwnProperty]].get.name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -191,6 +207,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); @@ -213,7 +234,7 @@ describe("Matcher", () => { assertStrictEquals(new Matcher(/(?:)/u).global, false); }); - describe(".length", () => { + describe("[[GetOwnProperty]].get.length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -225,7 +246,7 @@ describe("Matcher", () => { }); }); - describe(".name", () => { + describe("[[GetOwnProperty]].get.name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -247,7 +268,7 @@ describe("Matcher", () => { assertStrictEquals(new Matcher(/(?:)/u).hasIndices, false); }); - describe(".length", () => { + describe("[[GetOwnProperty]].get.length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -259,7 +280,7 @@ describe("Matcher", () => { }); }); - describe(".name", () => { + describe("[[GetOwnProperty]].get.name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -281,7 +302,7 @@ describe("Matcher", () => { assertStrictEquals(new Matcher(/(?:)/u).ignoreCase, false); }); - describe(".length", () => { + describe("[[GetOwnProperty]].get.length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -293,7 +314,7 @@ describe("Matcher", () => { }); }); - describe(".name", () => { + describe("[[GetOwnProperty]].get.name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -315,7 +336,7 @@ describe("Matcher", () => { assertStrictEquals(new Matcher(/(?:)/u).multiline, false); }); - describe(".length", () => { + describe("[[GetOwnProperty]].get.length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -327,7 +348,7 @@ describe("Matcher", () => { }); }); - describe(".name", () => { + describe("[[GetOwnProperty]].get.name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -346,7 +367,7 @@ describe("Matcher", () => { assertStrictEquals(new Matcher(/.*/su).source, ".*"); }); - describe(".length", () => { + describe("[[GetOwnProperty]].get.length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -358,7 +379,7 @@ describe("Matcher", () => { }); }); - describe(".name", () => { + describe("[[GetOwnProperty]].get.name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -380,7 +401,7 @@ describe("Matcher", () => { assertStrictEquals(new Matcher(/(?:)/u).sticky, false); }); - describe(".length", () => { + describe("[[GetOwnProperty]].get.length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -392,7 +413,7 @@ describe("Matcher", () => { }); }); - describe(".name", () => { + describe("[[GetOwnProperty]].get.name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -409,6 +430,26 @@ describe("Matcher", () => { 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", () => { @@ -416,7 +457,7 @@ describe("Matcher", () => { assertStrictEquals(new Matcher(/(?:)/u).unicode, true); }); - describe(".length", () => { + describe("[[GetOwnProperty]].get.length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -428,7 +469,7 @@ describe("Matcher", () => { }); }); - describe(".name", () => { + describe("[[GetOwnProperty]].get.name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( Object.getOwnPropertyDescriptor( @@ -441,6 +482,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); @@ -482,6 +553,11 @@ describe("Matcher", () => { false, ); }); + + it("[[Construct]] throws an error", () => { + const matcher = new Matcher(""); + assertThrows(() => new matcher("")); + }); }); describe("~lastIndex", () => { @@ -559,6 +635,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( @@ -879,6 +1008,131 @@ describe("getLastSubstringIndex", () => { }); }); +describe("isArrayIndexString", () => { + it("[[Call]] returns false for nonstrings", () => { + assertStrictEquals(isArrayIndexString(1), false); + }); + + it("[[Call]] returns false for noncanonical strings", () => { + assertStrictEquals(isArrayIndexString(""), false); + assertStrictEquals(isArrayIndexString("01"), false); + assertStrictEquals(isArrayIndexString("9007199254740993"), false); + }); + + 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( + 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", () => { + assertThrows(() => new isArrayIndexString("0")); + }); + + describe(".length", () => { + it("[[Get]] returns the correct length", () => { + assertStrictEquals(isArrayIndexString.length, 1); + }); + }); + + describe(".name", () => { + it("[[Get]] returns the correct name", () => { + assertStrictEquals( + isArrayIndexString.name, + "isArrayIndexString", + ); + }); + }); +}); + +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", () => { + assertThrows(() => new isIntegerIndexString("0")); + }); + + describe(".length", () => { + it("[[Get]] returns the correct length", () => { + assertStrictEquals(isIntegerIndexString.length, 1); + }); + }); + + describe(".name", () => { + it("[[Get]] returns the correct name", () => { + assertStrictEquals( + isIntegerIndexString.name, + "isIntegerIndexString", + ); + }); + }); +}); + describe("join", () => { it("[[Call]] joins the provided iterator with the provided separartor", () => { assertStrictEquals(join([1, 2, 3, 4].values(), "☂"), "1☂2☂3☂4"); @@ -986,67 +1240,67 @@ describe("scalarValues", () => { }); }); -describe("splitOnASCIIWhitespace", () => { +describe("splitOnAsciiWhitespace", () => { it("[[Call]] splits on sequences of spaces", () => { assertEquals( - splitOnASCIIWhitespace("🅰️ 🅱️ 🆎 🅾️"), + splitOnAsciiWhitespace("🅰️ 🅱️ 🆎 🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); 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( - splitOnASCIIWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"), + splitOnAsciiWhitespace("🅰️\r\r\r🅱️\r🆎\r\r🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); 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( - splitOnASCIIWhitespace("🅰️\f\f\f🅱️\f🆎\f\f🅾️"), + splitOnAsciiWhitespace("🅰️\f\f\f🅱️\f🆎\f\f🅾️"), ["🅰️", "🅱️", "🆎", "🅾️"], ); }); 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", () => { - assertEquals(splitOnASCIIWhitespace(""), [""]); + assertEquals(splitOnAsciiWhitespace(""), [""]); }); 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( - 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( - splitOnASCIIWhitespace( + splitOnAsciiWhitespace( "\f\r\n\r\n \n\t🅰️\f \t\n🅱️\r🆎\n\f🅾️\n\f", ), ["🅰️", "🅱️", "🆎", "🅾️"], @@ -1054,20 +1308,20 @@ describe("splitOnASCIIWhitespace", () => { }); it("[[Construct]] throws an error", () => { - assertThrows(() => new splitOnASCIIWhitespace("")); + assertThrows(() => new splitOnAsciiWhitespace("")); }); 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( - splitOnASCIIWhitespace.name, - "splitOnASCIIWhitespace", + splitOnAsciiWhitespace.name, + "splitOnAsciiWhitespace", ); }); }); @@ -1521,8 +1775,8 @@ describe("stringReplace", () => { "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", ); @@ -1556,8 +1810,8 @@ describe("stringReplaceAll", () => { "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", ); @@ -1753,17 +2007,17 @@ describe("stringStartsWith", () => { }); }); -describe("stripAndCollapseASCIIWhitespace", () => { +describe("stripAndCollapseAsciiWhitespace", () => { 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( - stripAndCollapseASCIIWhitespace( + stripAndCollapseAsciiWhitespace( "\f\r\n\r\n \n\t\f 🅰️\f \t\n🅱️\r\n\r🆎\n\f🅾️\n\f", ), "🅰️ 🅱️ 🆎 🅾️", @@ -1772,42 +2026,42 @@ describe("stripAndCollapseASCIIWhitespace", () => { 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( - 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", () => { - assertThrows(() => new stripAndCollapseASCIIWhitespace("")); + assertThrows(() => new stripAndCollapseAsciiWhitespace("")); }); 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( - stripAndCollapseASCIIWhitespace.name, - "stripAndCollapseASCIIWhitespace", + stripAndCollapseAsciiWhitespace.name, + "stripAndCollapseAsciiWhitespace", ); }); }); }); -describe("stripLeadingAndTrailingASCIIWhitespace", () => { +describe("stripLeadingAndTrailingAsciiWhitespace", () => { it("[[Call]] trims leading and trailing whitespace", () => { assertStrictEquals( - stripLeadingAndTrailingASCIIWhitespace( + stripLeadingAndTrailingAsciiWhitespace( "\f\r\n\r\n \n\t\f 🅰️🅱️🆎🅾️\n\f", ), "🅰️🅱️🆎🅾️", @@ -1816,14 +2070,14 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => { 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( - stripLeadingAndTrailingASCIIWhitespace( + stripLeadingAndTrailingAsciiWhitespace( "\v\u202F\u205Fx\0\b\xa0", ), "\v\u202F\u205Fx\0\b\xa0", @@ -1832,19 +2086,19 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => { it("[[Call]] does not adjust inner whitespace", () => { assertEquals( - stripLeadingAndTrailingASCIIWhitespace("a b"), + stripLeadingAndTrailingAsciiWhitespace("a b"), "a b", ); }); it("[[Construct]] throws an error", () => { - assertThrows(() => new stripLeadingAndTrailingASCIIWhitespace("")); + assertThrows(() => new stripLeadingAndTrailingAsciiWhitespace("")); }); describe(".length", () => { it("[[Get]] returns the correct length", () => { assertStrictEquals( - stripLeadingAndTrailingASCIIWhitespace.length, + stripLeadingAndTrailingAsciiWhitespace.length, 1, ); }); @@ -1853,8 +2107,8 @@ describe("stripLeadingAndTrailingASCIIWhitespace", () => { describe(".name", () => { it("[[Get]] returns the correct name", () => { assertStrictEquals( - stripLeadingAndTrailingASCIIWhitespace.name, - "stripLeadingAndTrailingASCIIWhitespace", + stripLeadingAndTrailingAsciiWhitespace.name, + "stripLeadingAndTrailingAsciiWhitespace", ); }); });