Temporal: Make U+2212 MINUS SIGN invalid in ISO strings

These are the test adjustments corresponding to the normative PR
https://github.com/tc39/ecma262/pull/3334 which reached consensus at the
June 2024 TC39 meeting.

harness/temporalHelpers.js

@@ -2130,7 +2130,7 @@ var TemporalHelpers = {
         "1976-11-01T00:00:00+05:00",
         "197611",
         "+00197611",
-        "1976-11-18T15:23:30.1\u221202:00",
+        "1976-11-18T15:23:30.1-02:00",
         "1976-11-18T152330.1+00:00",
         "19761118T15:23:30.1+00:00",
         "1976-11-18T15:23:30.1+0000",
@@ -2157,7 +2157,7 @@ var TemporalHelpers = {
      */
     plainYearMonthStringsValidNegativeYear() {
       return [
-        "\u2212009999-11",
+        "-009999-11",
       ];
     },
   }

test/built-ins/Temporal/Duration/from/argument-string.js

@@ -40,8 +40,6 @@ TemporalHelpers.assertDuration(Temporal.Duration.from("+P1D"),
    0, 0, 0, 1, 0, 0, 0, 0, 0, 0);
 TemporalHelpers.assertDuration(Temporal.Duration.from("-P1D"),
    0, 0, 0, -1, 0, 0, 0, 0, 0, 0);
-TemporalHelpers.assertDuration(Temporal.Duration.from("\u2212P1D"),
-   0, 0, 0, -1, 0, 0, 0, 0, 0, 0);
 TemporalHelpers.assertDuration(Temporal.Duration.from("-P1Y1M1W1DT1H1M1.123456789S"),
    -1, -1, -1, -1, -1, -1, -1, -123, -456, -789);
 TemporalHelpers.assertDuration(Temporal.Duration.from("PT100M"),

test/built-ins/Temporal/Instant/compare/argument-string-minus-sign.js

@@ -0,0 +1,28 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.compare
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+const epoch = new Temporal.Instant(0n);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.Instant.compare(arg, epoch),
+    `variant minus sign: ${arg} (first argument)`
+  );
+
+  assert.throws(
+    RangeError,
+    () => Temporal.Instant.compare(epoch, arg),
+    `variant minus sign: ${arg} (second argument)`
+  );
+});

test/built-ins/Temporal/Instant/from/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.from
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.Instant.from(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/Instant/from/argument-string.js

@@ -19,8 +19,8 @@ const tests = [
   ['1976-11-18T15:23:30.12345678Z', 217178610123456780n],
   ['1976-11-18T15:23:30.123456789Z', 217178610123456789n],
   ['1976-11-18T15:23:30,12Z', 217178610120000000n],
-  ['1976-11-18T15:23:30.12\u221202:00', 217185810120000000n],
-  ['\u2212009999-11-18T15:23:30.12Z', -377677326989880000000n],
+  ['1976-11-18T15:23:30.12-02:00', 217185810120000000n],
+  ['-009999-11-18T15:23:30.12Z', -377677326989880000000n],
   ['19761118T15:23:30.1+00:00', 217178610100000000n],
   ['1976-11-18T152330.1+00:00', 217178610100000000n],
   ['1976-11-18T15:23:30.1+0000', 217178610100000000n],

test/built-ins/Temporal/Instant/prototype/equals/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.equals
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.Instant(0n);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.equals(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/Instant/prototype/since/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.since
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.Instant(0n);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.since(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/Instant/prototype/until/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.instant.prototype.until
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.Instant(0n);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.until(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDate/compare/argument-string-minus-sign.js

@@ -0,0 +1,27 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.compare
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainDate.compare(arg, new Temporal.PlainDate(1976, 11, 18)),
+    `variant minus sign: ${arg} (first argument)`
+  );
+
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainDate.compare(new Temporal.PlainDate(1976, 11, 18), arg),
+    `variant minus sign: ${arg} (second argument)`
+  );
+});

test/built-ins/Temporal/PlainDate/from/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.from
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainDate.from(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDate/prototype/equals/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.equals
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDate(2000, 5, 2);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.equals(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDate/prototype/since/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.since
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDate(2000, 5, 2);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.since(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDate/prototype/toPlainDateTime/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.toplaindatetime
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDate(2000, 5, 2);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.toPlainDateTime(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDate/prototype/toZonedDateTime/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.tozoneddatetime
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDate(2000, 5, 2);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.toZonedDateTime({ plainTime: arg, timeZone: "UTC" }),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDate/prototype/until/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindate.prototype.until
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDate(2000, 5, 2);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.until(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDateTime/compare/argument-string-minus-sign.js

@@ -0,0 +1,27 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.compare
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainDateTime.compare(arg, new Temporal.PlainDateTime(1976, 11, 18)),
+    `variant minus sign: ${arg} (first argument)`
+  );
+
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainDateTime.compare(new Temporal.PlainDateTime(1976, 11, 18), arg),
+    `variant minus sign: ${arg} (second argument)`
+  );
+});

test/built-ins/Temporal/PlainDateTime/from/argument-string-minus-sign.js

@@ -1,21 +1,21 @@
-// Copyright (C) 2022 Igalia, S.L. All rights reserved.
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
 // This code is governed by the BSD license found in the LICENSE file.
 
 /*---
 esid: sec-temporal.plaindatetime.from
-description: Non-ASCII minus sign is acceptable
+description: Non-ASCII minus sign is not acceptable
 features: [Temporal]
-includes: [temporalHelpers.js]
 ---*/
 
-TemporalHelpers.assertPlainDateTime(
-  Temporal.PlainDateTime.from("1976-11-18T15:23:30.12\u221202:00"),
-  1976, 11, "M11", 18, 15, 23, 30, 120, 0, 0,
-  "variant minus sign (offset)"
-);
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
 
-TemporalHelpers.assertPlainDateTime(
-  Temporal.PlainDateTime.from("\u2212009999-11-18T15:23:30.12"),
-  -9999, 11, "M11", 18, 15, 23, 30, 120, 0, 0,
-  "variant minus sign (leading minus)"
-);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainDateTime.from(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDateTime/prototype/equals/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.equals
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.equals(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDateTime/prototype/since/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.since
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.since(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDateTime/prototype/until/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.until
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.until(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainDateTime/prototype/withPlainTime/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaindatetime.prototype.withplaintime
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainDateTime(2000, 5, 2, 12, 34, 56, 987, 654, 321);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.withPlainTime(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainMonthDay/from/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.from
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainMonthDay.from(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainMonthDay/prototype/equals/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainmonthday.prototype.equals
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainMonthDay(5, 2);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.equals(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainTime/compare/argument-string-minus-sign.js

@@ -0,0 +1,27 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.compare
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainTime.compare(arg, new Temporal.PlainTime(12, 34, 56, 987, 654, 321)),
+    `variant minus sign: ${arg} (first argument)`
+  );
+
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainTime.compare(new Temporal.PlainTime(12, 34, 56, 987, 654, 321), arg),
+    `variant minus sign: ${arg} (second argument)`
+  );
+});

test/built-ins/Temporal/PlainTime/from/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.from
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainTime.from(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainTime/from/argument-string.js

@@ -24,7 +24,7 @@ const tests = [
   ["1976-11-18T15:23:30.12345678", 15, 23, 30, 123, 456, 780],
   ["1976-11-18T15:23:30.123456789", 15, 23, 30, 123, 456, 789],
   ["1976-11-18T15:23:30,12", 15, 23, 30, 120, 0, 0],
-  ["1976-11-18T15:23:30.12\u221202:00", 15, 23, 30, 120, 0, 0],
+  ["1976-11-18T15:23:30.12-02:00", 15, 23, 30, 120, 0, 0],
   ["152330", 15, 23, 30, 0, 0, 0],
   ["152330.1", 15, 23, 30, 100, 0, 0],
   ["152330-08", 15, 23, 30, 0, 0, 0],

test/built-ins/Temporal/PlainTime/prototype/equals/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.prototype.equals
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainTime(12, 34, 56, 987, 654, 321);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.equals(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainTime/prototype/since/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.prototype.since
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainTime(12, 34, 56, 987, 654, 321);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.since(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainTime/prototype/until/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plaintime.prototype.until
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainTime(12, 34, 56, 987, 654, 321);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.until(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainYearMonth/compare/argument-string-minus-sign.js

@@ -0,0 +1,27 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.compare
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainYearMonth.compare(arg, new Temporal.PlainYearMonth(2019, 6)),
+    `variant minus sign: ${arg} (first argument)`
+  );
+
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainYearMonth.compare(new Temporal.PlainYearMonth(2019, 6), arg),
+    `variant minus sign: ${arg} (second argument)`
+  );
+});

test/built-ins/Temporal/PlainYearMonth/from/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.from
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.PlainYearMonth.from(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainYearMonth/prototype/equals/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.prototype.equals
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainYearMonth(2000, 5);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.equals(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainYearMonth/prototype/since/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.prototype.since
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainYearMonth(2000, 5);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.since(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/PlainYearMonth/prototype/until/argument-string-minus-sign.js

@@ -0,0 +1,21 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.plainyearmonth.prototype.until
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const instance = new Temporal.PlainYearMonth(2000, 5);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.until(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/TimeZone/basic.js

@@ -13,9 +13,6 @@ const valid = [
   ["+0330", "+03:30"],
   ["-0650", "-06:50"],
   ["-08", "-08:00"],
-  ["\u221201:00", "-01:00"],
-  ["\u22120650", "-06:50"],
-  ["\u221208", "-08:00"],
   ["UTC"],
 ];
 for (const [zone, id = zone] of valid) {

test/built-ins/Temporal/TimeZone/from/argument-valid.js

@@ -13,12 +13,8 @@ const valids = [
   ["+0330", "+03:30"],
   ["-0650", "-06:50"],
   ["-08", "-08:00"],
-  ["\u221201:00", "-01:00"],
-  ["\u22120650", "-06:50"],
-  ["\u221208", "-08:00"],
   ["UTC"],
   ["1994-11-05T08:15:30-05:00", "-05:00"],
-  ["1994-11-05T08:15:30\u221205:00", "-05:00"],
   ["1994-11-05T13:15:30Z", "UTC"],
 ];
 

test/built-ins/Temporal/TimeZone/prototype/equals/argument-valid.js

@@ -11,11 +11,7 @@ const validsEqual = [
   ["+0330", "+03:30"],
   ["-0650", "-06:50"],
   ["-08", "-08:00"],
-  ["\u221201:00", "-01:00"],
-  ["\u22120650", "-06:50"],
-  ["\u221208", "-08:00"],
   ["1994-11-05T08:15:30-05:00", "-05:00"],
-  ["1994-11-05T08:15:30\u221205:00", "-05:00"],
   ["1994-11-05T13:15:30Z", "UTC"]
 ];
 
@@ -30,11 +26,7 @@ const validsNotEqual = [
   ["+0330", "+03:31"],
   ["-0650", "-06:51"],
   ["-08", "-08:01"],
-  ["\u221201:00", "-01:01"],
-  ["\u22120650", "-06:51"],
-  ["\u221208", "-08:01"],
   ["1994-11-05T08:15:30-05:00", "-05:01"],
-  ["1994-11-05T08:15:30\u221205:00", "-05:01"]
 ];
 
 for (const [valid, canonical] of validsNotEqual) {

test/built-ins/Temporal/ZonedDateTime/compare/argument-string-minus-sign.js

@@ -0,0 +1,30 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.compare
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "1976-11-18T15:23:30.12-02:00[\u221202:00]",
+  "1976-11-18T15:23:30.12\u221202:00[\u221202:00]",
+  "\u2212009999-11-18T15:23:30.12[UTC]",
+];
+
+const datetime = new Temporal.ZonedDateTime(0n, "UTC");
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.ZonedDateTime.compare(arg, datetime),
+    `variant minus sign: ${arg} (first argument)`
+  );
+
+  assert.throws(
+    RangeError,
+    () => Temporal.ZonedDateTime.compare(datetime, arg),
+    `variant minus sign: ${arg} (second argument)`
+  );
+});

test/built-ins/Temporal/ZonedDateTime/from/argument-string-minus-sign.js

@@ -0,0 +1,23 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.from
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "1976-11-18T15:23:30.12-02:00[\u221202:00]",
+  "1976-11-18T15:23:30.12\u221202:00[\u221202:00]",
+  "\u2212009999-11-18T15:23:30.12[UTC]",
+];
+
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => Temporal.ZonedDateTime.from(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/ZonedDateTime/prototype/equals/argument-string-minus-sign.js

@@ -0,0 +1,24 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.equals
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "1976-11-18T15:23:30.12-02:00[\u221202:00]",
+  "1976-11-18T15:23:30.12\u221202:00[\u221202:00]",
+  "\u2212009999-11-18T15:23:30.12[UTC]",
+];
+const timeZone = "UTC";
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.equals(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/ZonedDateTime/prototype/since/argument-string-minus-sign.js

@@ -0,0 +1,24 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.since
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "1976-11-18T15:23:30.12-02:00[\u221202:00]",
+  "1976-11-18T15:23:30.12\u221202:00[\u221202:00]",
+  "\u2212009999-11-18T15:23:30.12[UTC]",
+];
+const timeZone = "UTC";
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.since(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/ZonedDateTime/prototype/until/argument-string-minus-sign.js

@@ -0,0 +1,24 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.until
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "1976-11-18T15:23:30.12-02:00[\u221202:00]",
+  "1976-11-18T15:23:30.12\u221202:00[\u221202:00]",
+  "\u2212009999-11-18T15:23:30.12[UTC]",
+];
+const timeZone = "UTC";
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.until(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/built-ins/Temporal/ZonedDateTime/prototype/withPlainTime/argument-string-minus-sign.js

@@ -0,0 +1,22 @@
+// Copyright (C) 2024 Igalia, S.L. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal.zoneddatetime.prototype.withplaintime
+description: Non-ASCII minus sign is not acceptable
+features: [Temporal]
+---*/
+
+const invalidStrings = [
+  "1976-11-18T15:23:30.12\u221202:00",
+  "\u2212009999-11-18T15:23:30.12",
+];
+const timeZone = "UTC";
+const instance = new Temporal.ZonedDateTime(0n, timeZone);
+invalidStrings.forEach((arg) => {
+  assert.throws(
+    RangeError,
+    () => instance.withPlainTime(arg),
+    `variant minus sign: ${arg}`
+  );
+});

test/intl402/Temporal/TimeZone/from/argument-valid.js

@@ -18,8 +18,6 @@ const valids = [
   ["etc/gmt", "Etc/GMT"],
   ["1994-11-05T08:15:30-05:00[America/New_York]", "America/New_York"],
   ["1994-11-05T08:15:30-05[America/New_York]", "America/New_York"],
-  ["1994-11-05T08:15:30\u221205:00[America/New_York]", "America/New_York"],
-  ["1994-11-05T08:15:30\u221205[America/New_York]", "America/New_York"],
 ];
 
 for (const [valid, canonical = valid] of valids) {

test/staging/Temporal/Regex/old/instant.js

@@ -175,21 +175,7 @@ test("1976-11-18T15:23:30,1234Z", [
   123,
   400
 ]);
-[
-  "\u221204:00",
-  "\u221204",
-  "\u22120400"
-].forEach(offset => test(`1976-11-18T15:23:30.1234${ offset }`, [
-  1976,
-  11,
-  18,
-  19,
-  23,
-  30,
-  123,
-  400
-]));
-test("\u2212009999-11-18T15:23:30.1234Z", [
+test("-009999-11-18T15:23:30.1234Z", [
   -9999,
   11,
   18,

test/staging/Temporal/Regex/old/plaindate.js

@@ -54,7 +54,7 @@ test("1976-11-18T15:23:30,1234", [
   11,
   18
 ]);
-test("\u2212009999-11-18", [
+test("-009999-11-18", [
   -9999,
   11,
   18

test/staging/Temporal/Regex/old/plainmonthday.js

@@ -49,7 +49,7 @@ function generateTest(dateTimeString, zoneString) {
 ]));
 [
   "1976-11-18T15:23:30,1234",
-  "\u2212009999-11-18",
+  "-009999-11-18",
   "19761118",
   "+199999-11-18",
   "+1999991118",

test/staging/Temporal/Regex/old/timezone.js

@@ -44,11 +44,6 @@ function generateTest(dateTimeString, zoneString, expectedName) {
 generateTest("1976-11-18T15:23", "z", "UTC");
 test("1976-11-18T15:23:30,1234Z", "UTC");
 test("1976-11-18T15:23+000000,0[UTC]", "UTC");
-[
-  "\u221204:00",
-  "\u221204",
-  "\u22120400"
-].forEach(offset => test(`1976-11-18T15:23${ offset }`, "-04:00"));
 [
   "1976-11-18T152330",
   "1976-11-18T152330.1234",
@@ -76,12 +71,8 @@ test("+00", "+00:00");
 test("-00", "+00:00");
 test("+03", "+03:00");
 test("-03", "-03:00");
-test("\u22120000", "+00:00");
-test("\u221200:00", "+00:00");
-test("\u221200", "+00:00");
-test("\u22120300", "-03:00");
-test("\u221203:00", "-03:00");
-test("\u221203", "-03:00");
+test("-0300", "-03:00");
+test("-03:00", "-03:00");
 test("1976-11-18T15:23:30.123456789Z[u-ca=iso8601]", "UTC");
 test("1976-11-18T15:23:30.123456789-04:00[u-ca=iso8601]", "-04:00");
 test("1976-11-18T15:23:30.123456789[UTC][u-ca=iso8601]", "UTC");

test/staging/Temporal/ZonedDateTime/old/string-parsing.js

@@ -21,9 +21,8 @@ assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-
 // variant decimal separator
 assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30,12-08:00[-08:00]") }`, "1976-11-18T15:23:30.12-08:00[-08:00]");
 
-// variant minus sign
-assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12\u221208:00[-08:00]") }`, "1976-11-18T15:23:30.12-08:00[-08:00]");
-assert.sameValue(`${ Temporal.ZonedDateTime.from("\u2212009999-11-18T15:23:30.12+00:00[UTC]") }`, "-009999-11-18T15:23:30.12+00:00[UTC]");
+// negative extended year
+assert.sameValue(`${ Temporal.ZonedDateTime.from("-009999-11-18T15:23:30.12+00:00[UTC]") }`, "-009999-11-18T15:23:30.12+00:00[UTC]");
 
 // mixture of basic and extended format
 [