Use strict equals in Matcher constraint tests

[Pisces] / string.js

diff --git a/string.js b/string.js
index 8c858cd66a527b56c8a0d591a75d77e1f5134b60..3dc39acade9259c7c5120c28cde20ad398225426 100644 (file)
--- a/string.js
+++ b/string.js
@@ -10,6 +10,7 @@
 import { bind, call, identity, makeCallable } from "./function.js";
 import {
   defineOwnProperties,
+  getOwnPropertyDescriptors,
   getPrototype,
   objectCreate,
   setPrototype,
@@ -65,11 +66,11 @@ export const {
      * A name for the matcher may be provided as the second argument.
      *
      * A callable constraint on acceptable inputs may be provided as a
-     * third argument. If provided, it will be called with two
+     * third argument. If provided, it will be called with three
      * arguments whenever a match appears successful: first, the string
-     * being matched, and second, the Matcher object itself. If the
-     * return value of this call is falsey, then the match will be
-     * considered a failure.
+     * being matched, second, the match result, and third, the Matcher
+     * object itself. If the return value of this call is falsey, then
+     * the match will be considered a failure.
      *
      * ☡ If the provided source regular expression uses nongreedy
      * quantifiers, it may not match the whole string even if a match
@@ -89,8 +90,9 @@ export const {
             // at a match matches the whole string and passes the
             // provided constraint (if present).
             regExp.lastIndex = 0;
-            return call(reExec, regExp, [$])?.[0] === $ &&
-              (constraint === null || constraint($, this));
+            const result = call(reExec, regExp, [$]);
+            return result?.[0] === $ &&
+              (constraint === null || constraint($, result, this));
           }
         },
       );
@@ -148,6 +150,10 @@ export const {
      *
      * Matchers only match if they can match the entire value on the
      * first attempt.
+     *
+     * ☡ The match result returned by this method will be the same as
+     * that passed to the constraint function—and may have been
+     * modified by said function prior to being returned.
      */
     exec($) {
       const regExp = this.#regExp;
@@ -157,7 +163,7 @@ export const {
       const result = call(reExec, regExp, [string]);
       if (
         result?.[0] === string &&
-        (constraint === null || constraint(string, this))
+        (constraint === null || constraint(string, result, this))
       ) {
         // The entire string was matched and the constraint, if
         // present, returned a truthy value.
@@ -208,12 +214,25 @@ export const {
       return call(getUnicode, this.#regExp, []);
     }
   };
-  const matcherPrototype = setPrototype(
-    Matcher.prototype,
-    rePrototype,
+
+  const matcherConstructor = defineOwnProperties(
+    class extends RegExp {
+      constructor(...args) {
+        return new Matcher(...args);
+      }
+    },
+    {
+      name: { value: "Matcher" },
+      length: { value: 1 },
+    },
+  );
+  const matcherPrototype = defineOwnProperties(
+    matcherConstructor.prototype,
+    getOwnPropertyDescriptors(Matcher.prototype),
+    { constructor: { value: matcherConstructor } },
   );
 
-  return { Matcher };
+  return { Matcher: matcherConstructor };
 })();
 
 export const {