json-p3 1.3.1 → 1.3.2

package/dist/json-p3.iife.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 1.3.1
+ * json-p3 version 1.3.2
  * https://github.com/jg-rp/json-p3
  * 
  * MIT License
@@ -139,6 +139,18 @@ var json_p3 = (function (exports) {
     }
   }
 
+  /**
+   * Error thrown due to invalid I-Regexp syntax.
+   */
+  class IRegexpError extends Error {
+    constructor(message) {
+      super(message);
+      this.message = message;
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = "IRegexpError";
+    }
+  }
+
   /**
    * Common types and type predicates.
    */
@@ -1083,6 +1095,1255 @@ var json_p3 = (function (exports) {
     }
   }
 
+  // See https://datatracker.ietf.org/doc/html/rfc9485#name-ecmascript-regexps
+  function mapRegexp(pattern) {
+    let escaped = false;
+    let charClass = false;
+    const parts = [];
+    for (const ch of pattern) {
+      if (escaped) {
+        parts.push(ch);
+        escaped = false;
+        continue;
+      }
+      switch (ch) {
+        case ".":
+          if (!charClass) {
+            parts.push("(?:(?![\r\n])\\P{Cs}|\\p{Cs}\\p{Cs})");
+          } else {
+            parts.push(ch);
+          }
+          break;
+        case "\\":
+          escaped = true;
+          parts.push(ch);
+          break;
+        case "[":
+          charClass = true;
+          parts.push(ch);
+          break;
+        case "]":
+          charClass = false;
+          parts.push(ch);
+          break;
+        default:
+          parts.push(ch);
+          break;
+      }
+    }
+    return parts.join("");
+  }
+
+  /*
+   * iregexp-check version 0.1.1
+   * https://github.com/jg-rp/js-iregexp
+   * 
+   * MIT License
+   * 
+   * Copyright (c) 2024 James Prior
+   * 
+   * Permission is hereby granted, free of charge, to any person obtaining a copy
+   * of this software and associated documentation files (the "Software"), to deal
+   * in the Software without restriction, including without limitation the rights
+   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   * copies of the Software, and to permit persons to whom the Software is
+   * furnished to do so, subject to the following conditions:
+   * 
+   * The above copyright notice and this permission notice shall be included in all
+   * copies or substantial portions of the Software.
+   * 
+   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   * SOFTWARE.
+   * 
+   */
+  function isNormalChar(c) {
+    return c < "\u0027" || c === "," || c === "-" || c >= "\u002F" && c <= "\u003E" ||
+    // / .. >
+    c >= "\u0040" && c <= "\u005A" ||
+    // @ .. Z
+    c >= "\u005E" && c <= "\u007A" ||
+    // ^ .. z
+    c >= "\u007E" && c <= "\uD7FF" ||
+    // skip surrogate code points
+    c >= "\uE000";
+  }
+  function isCCChar(c) {
+    return c < "\u002C" || c >= "\u002E" && c <= "\u005A" ||
+    // '.' .. Z
+    c >= "\u005E" && c <= "\uD7FF" ||
+    // skip surrogate code points
+    c >= "\uE000";
+  }
+  function peg$subclass(child, parent) {
+    function C() {
+      this.constructor = child;
+    }
+    C.prototype = parent.prototype;
+    child.prototype = new C();
+  }
+  function peg$SyntaxError(message, expected, found, location) {
+    var self = Error.call(this, message);
+    // istanbul ignore next Check is a necessary evil to support older environments
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(self, peg$SyntaxError.prototype);
+    }
+    self.expected = expected;
+    self.found = found;
+    self.location = location;
+    self.name = "SyntaxError";
+    return self;
+  }
+  peg$subclass(peg$SyntaxError, Error);
+  function peg$padEnd(str, targetLength, padString) {
+    padString = padString || " ";
+    if (str.length > targetLength) {
+      return str;
+    }
+    targetLength -= str.length;
+    padString += padString.repeat(targetLength);
+    return str + padString.slice(0, targetLength);
+  }
+  peg$SyntaxError.prototype.format = function (sources) {
+    var str = "Error: " + this.message;
+    if (this.location) {
+      var src = null;
+      var k;
+      for (k = 0; k < sources.length; k++) {
+        if (sources[k].source === this.location.source) {
+          src = sources[k].text.split(/\r\n|\n|\r/g);
+          break;
+        }
+      }
+      var s = this.location.start;
+      var offset_s = this.location.source && typeof this.location.source.offset === "function" ? this.location.source.offset(s) : s;
+      var loc = this.location.source + ":" + offset_s.line + ":" + offset_s.column;
+      if (src) {
+        var e = this.location.end;
+        var filler = peg$padEnd("", offset_s.line.toString().length, ' ');
+        var line = src[s.line - 1];
+        var last = s.line === e.line ? e.column : line.length + 1;
+        var hatLen = last - s.column || 1;
+        str += "\n --> " + loc + "\n" + filler + " |\n" + offset_s.line + " | " + line + "\n" + filler + " | " + peg$padEnd("", s.column - 1, ' ') + peg$padEnd("", hatLen, "^");
+      } else {
+        str += "\n at " + loc;
+      }
+    }
+    return str;
+  };
+  peg$SyntaxError.buildMessage = function (expected, found) {
+    var DESCRIBE_EXPECTATION_FNS = {
+      literal: function (expectation) {
+        return "\"" + literalEscape(expectation.text) + "\"";
+      },
+      class: function (expectation) {
+        var escapedParts = expectation.parts.map(function (part) {
+          return Array.isArray(part) ? classEscape(part[0]) + "-" + classEscape(part[1]) : classEscape(part);
+        });
+        return "[" + (expectation.inverted ? "^" : "") + escapedParts.join("") + "]";
+      },
+      any: function () {
+        return "any character";
+      },
+      end: function () {
+        return "end of input";
+      },
+      other: function (expectation) {
+        return expectation.description;
+      }
+    };
+    function hex(ch) {
+      return ch.charCodeAt(0).toString(16).toUpperCase();
+    }
+    function literalEscape(s) {
+      return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function (ch) {
+        return "\\x0" + hex(ch);
+      }).replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
+        return "\\x" + hex(ch);
+      });
+    }
+    function classEscape(s) {
+      return s.replace(/\\/g, "\\\\").replace(/\]/g, "\\]").replace(/\^/g, "\\^").replace(/-/g, "\\-").replace(/\0/g, "\\0").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/[\x00-\x0F]/g, function (ch) {
+        return "\\x0" + hex(ch);
+      }).replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
+        return "\\x" + hex(ch);
+      });
+    }
+    function describeExpectation(expectation) {
+      return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+    }
+    function describeExpected(expected) {
+      var descriptions = expected.map(describeExpectation);
+      var i, j;
+      descriptions.sort();
+      if (descriptions.length > 0) {
+        for (i = 1, j = 1; i < descriptions.length; i++) {
+          if (descriptions[i - 1] !== descriptions[i]) {
+            descriptions[j] = descriptions[i];
+            j++;
+          }
+        }
+        descriptions.length = j;
+      }
+      switch (descriptions.length) {
+        case 1:
+          return descriptions[0];
+        case 2:
+          return descriptions[0] + " or " + descriptions[1];
+        default:
+          return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
+      }
+    }
+    function describeFound(found) {
+      return found ? "\"" + literalEscape(found) + "\"" : "end of input";
+    }
+    return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+  };
+  function peg$parse(input, options) {
+    options = options !== undefined ? options : {};
+    var peg$FAILED = {};
+    var peg$source = options.grammarSource;
+    var peg$startRuleFunctions = {
+      start: peg$parsestart
+    };
+    var peg$startRuleFunction = peg$parsestart;
+    var peg$c0 = "|";
+    var peg$c1 = "{";
+    var peg$c2 = ",";
+    var peg$c3 = "}";
+    var peg$c4 = "(";
+    var peg$c5 = ")";
+    var peg$c6 = ".";
+    var peg$c7 = "\\";
+    var peg$c8 = "[";
+    var peg$c9 = "^";
+    var peg$c10 = "-";
+    var peg$c11 = "]";
+    var peg$c12 = "\\p{";
+    var peg$c13 = "\\P{";
+    var peg$c14 = "L";
+    var peg$c15 = "M";
+    var peg$c16 = "N";
+    var peg$c17 = "P";
+    var peg$c18 = "Z";
+    var peg$c19 = "S";
+    var peg$c20 = "C";
+    var peg$r0 = /^[*-+?]/;
+    var peg$r1 = /^[0-9]/;
+    var peg$r2 = /^[(-+\--.?[-\^nrt{-}]/;
+    var peg$r3 = /^[l-mot-u]/;
+    var peg$r4 = /^[cen]/;
+    var peg$r5 = /^[dlo]/;
+    var peg$r6 = /^[c-fios]/;
+    var peg$r7 = /^[lps]/;
+    var peg$r8 = /^[ckmo]/;
+    var peg$r9 = /^[cfn-o]/;
+    var peg$e0 = peg$literalExpectation("|", false);
+    var peg$e1 = peg$classExpectation([["*", "+"], "?"], false, false);
+    var peg$e2 = peg$literalExpectation("{", false);
+    var peg$e3 = peg$classExpectation([["0", "9"]], false, false);
+    var peg$e4 = peg$literalExpectation(",", false);
+    var peg$e5 = peg$literalExpectation("}", false);
+    var peg$e6 = peg$literalExpectation("(", false);
+    var peg$e7 = peg$literalExpectation(")", false);
+    var peg$e8 = peg$anyExpectation();
+    var peg$e9 = peg$literalExpectation(".", false);
+    var peg$e10 = peg$literalExpectation("\\", false);
+    var peg$e11 = peg$classExpectation([["(", "+"], ["-", "."], "?", ["[", "^"], "n", "r", "t", ["{", "}"]], false, false);
+    var peg$e12 = peg$literalExpectation("[", false);
+    var peg$e13 = peg$literalExpectation("^", false);
+    var peg$e14 = peg$literalExpectation("-", false);
+    var peg$e15 = peg$literalExpectation("]", false);
+    var peg$e16 = peg$literalExpectation("\\p{", false);
+    var peg$e17 = peg$literalExpectation("\\P{", false);
+    var peg$e18 = peg$literalExpectation("L", false);
+    var peg$e19 = peg$classExpectation([["l", "m"], "o", ["t", "u"]], false, false);
+    var peg$e20 = peg$literalExpectation("M", false);
+    var peg$e21 = peg$classExpectation(["c", "e", "n"], false, false);
+    var peg$e22 = peg$literalExpectation("N", false);
+    var peg$e23 = peg$classExpectation(["d", "l", "o"], false, false);
+    var peg$e24 = peg$literalExpectation("P", false);
+    var peg$e25 = peg$classExpectation([["c", "f"], "i", "o", "s"], false, false);
+    var peg$e26 = peg$literalExpectation("Z", false);
+    var peg$e27 = peg$classExpectation(["l", "p", "s"], false, false);
+    var peg$e28 = peg$literalExpectation("S", false);
+    var peg$e29 = peg$classExpectation(["c", "k", "m", "o"], false, false);
+    var peg$e30 = peg$literalExpectation("C", false);
+    var peg$e31 = peg$classExpectation(["c", "f", ["n", "o"]], false, false);
+    var peg$f0 = function (c) {
+      return isNormalChar(c);
+    };
+    var peg$f1 = function (c) {
+      return isCCChar(c);
+    };
+    var peg$currPos = options.peg$currPos | 0;
+    var peg$posDetailsCache = [{
+      line: 1,
+      column: 1
+    }];
+    var peg$maxFailPos = peg$currPos;
+    var peg$maxFailExpected = options.peg$maxFailExpected || [];
+    var peg$silentFails = options.peg$silentFails | 0;
+    var peg$result;
+    if (options.startRule) {
+      if (!(options.startRule in peg$startRuleFunctions)) {
+        throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+      }
+      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+    }
+    function peg$literalExpectation(text, ignoreCase) {
+      return {
+        type: "literal",
+        text: text,
+        ignoreCase: ignoreCase
+      };
+    }
+    function peg$classExpectation(parts, inverted, ignoreCase) {
+      return {
+        type: "class",
+        parts: parts,
+        inverted: inverted,
+        ignoreCase: ignoreCase
+      };
+    }
+    function peg$anyExpectation() {
+      return {
+        type: "any"
+      };
+    }
+    function peg$endExpectation() {
+      return {
+        type: "end"
+      };
+    }
+    function peg$computePosDetails(pos) {
+      var details = peg$posDetailsCache[pos];
+      var p;
+      if (details) {
+        return details;
+      } else {
+        if (pos >= peg$posDetailsCache.length) {
+          p = peg$posDetailsCache.length - 1;
+        } else {
+          p = pos;
+          while (!peg$posDetailsCache[--p]) {}
+        }
+        details = peg$posDetailsCache[p];
+        details = {
+          line: details.line,
+          column: details.column
+        };
+        while (p < pos) {
+          if (input.charCodeAt(p) === 10) {
+            details.line++;
+            details.column = 1;
+          } else {
+            details.column++;
+          }
+          p++;
+        }
+        peg$posDetailsCache[pos] = details;
+        return details;
+      }
+    }
+    function peg$computeLocation(startPos, endPos, offset) {
+      var startPosDetails = peg$computePosDetails(startPos);
+      var endPosDetails = peg$computePosDetails(endPos);
+      var res = {
+        source: peg$source,
+        start: {
+          offset: startPos,
+          line: startPosDetails.line,
+          column: startPosDetails.column
+        },
+        end: {
+          offset: endPos,
+          line: endPosDetails.line,
+          column: endPosDetails.column
+        }
+      };
+      return res;
+    }
+    function peg$fail(expected) {
+      if (peg$currPos < peg$maxFailPos) {
+        return;
+      }
+      if (peg$currPos > peg$maxFailPos) {
+        peg$maxFailPos = peg$currPos;
+        peg$maxFailExpected = [];
+      }
+      peg$maxFailExpected.push(expected);
+    }
+    function peg$buildStructuredError(expected, found, location) {
+      return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
+    }
+    function peg$parsestart() {
+      var s0;
+      s0 = peg$parseiregexp();
+      return s0;
+    }
+    function peg$parseiregexp() {
+      var s0, s1, s2, s3, s4, s5;
+      s0 = peg$currPos;
+      s1 = peg$parsebranch();
+      s2 = [];
+      s3 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 124) {
+        s4 = peg$c0;
+        peg$currPos++;
+      } else {
+        s4 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e0);
+        }
+      }
+      if (s4 !== peg$FAILED) {
+        s5 = peg$parsebranch();
+        s4 = [s4, s5];
+        s3 = s4;
+      } else {
+        peg$currPos = s3;
+        s3 = peg$FAILED;
+      }
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 124) {
+          s4 = peg$c0;
+          peg$currPos++;
+        } else {
+          s4 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e0);
+          }
+        }
+        if (s4 !== peg$FAILED) {
+          s5 = peg$parsebranch();
+          s4 = [s4, s5];
+          s3 = s4;
+        } else {
+          peg$currPos = s3;
+          s3 = peg$FAILED;
+        }
+      }
+      s1 = [s1, s2];
+      s0 = s1;
+      return s0;
+    }
+    function peg$parsebranch() {
+      var s0, s1;
+      s0 = [];
+      s1 = peg$parsepiece();
+      while (s1 !== peg$FAILED) {
+        s0.push(s1);
+        s1 = peg$parsepiece();
+      }
+      return s0;
+    }
+    function peg$parsepiece() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      s1 = peg$parseatom();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parsequantifier();
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsequantifier() {
+      var s0;
+      s0 = input.charAt(peg$currPos);
+      if (peg$r0.test(s0)) {
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e1);
+        }
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$parserange_quantifier();
+      }
+      return s0;
+    }
+    function peg$parserange_quantifier() {
+      var s0, s1, s2, s3, s4, s5;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 123) {
+        s1 = peg$c1;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e2);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r1.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e3);
+          }
+        }
+        if (s2 !== peg$FAILED) {
+          s3 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s4 = peg$c2;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e4);
+            }
+          }
+          if (s4 !== peg$FAILED) {
+            s5 = input.charAt(peg$currPos);
+            if (peg$r1.test(s5)) {
+              peg$currPos++;
+            } else {
+              s5 = peg$FAILED;
+              if (peg$silentFails === 0) {
+                peg$fail(peg$e3);
+              }
+            }
+            if (s5 === peg$FAILED) {
+              s5 = null;
+            }
+            s4 = [s4, s5];
+            s3 = s4;
+          } else {
+            peg$currPos = s3;
+            s3 = peg$FAILED;
+          }
+          if (s3 === peg$FAILED) {
+            s3 = null;
+          }
+          if (input.charCodeAt(peg$currPos) === 125) {
+            s4 = peg$c3;
+            peg$currPos++;
+          } else {
+            s4 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e5);
+            }
+          }
+          if (s4 !== peg$FAILED) {
+            s1 = [s1, s2, s3, s4];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parseatom() {
+      var s0, s1, s2, s3;
+      s0 = peg$parsenormal_char();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsechar_class();
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          if (input.charCodeAt(peg$currPos) === 40) {
+            s1 = peg$c4;
+            peg$currPos++;
+          } else {
+            s1 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e6);
+            }
+          }
+          if (s1 !== peg$FAILED) {
+            s2 = peg$parseiregexp();
+            if (s2 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 41) {
+                s3 = peg$c5;
+                peg$currPos++;
+              } else {
+                s3 = peg$FAILED;
+                if (peg$silentFails === 0) {
+                  peg$fail(peg$e7);
+                }
+              }
+              if (s3 !== peg$FAILED) {
+                s1 = [s1, s2, s3];
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        }
+      }
+      return s0;
+    }
+    function peg$parsenormal_char() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.length > peg$currPos) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e8);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$f0(s1);
+        if (s2) {
+          s2 = undefined;
+        } else {
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsechar_class() {
+      var s0;
+      if (input.charCodeAt(peg$currPos) === 46) {
+        s0 = peg$c6;
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e9);
+        }
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsesingle_char_esc();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parsechar_class_esc();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parsechar_class_expr();
+          }
+        }
+      }
+      return s0;
+    }
+    function peg$parsesingle_char_esc() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 92) {
+        s1 = peg$c7;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e10);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r2.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e11);
+          }
+        }
+        if (s2 !== peg$FAILED) {
+          s1 = [s1, s2];
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsechar_class_esc() {
+      var s0;
+      s0 = peg$parsecat_esc();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsecompl_esc();
+      }
+      return s0;
+    }
+    function peg$parsechar_class_expr() {
+      var s0, s1, s2, s3, s4, s5, s6;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 91) {
+        s1 = peg$c8;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e12);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 94) {
+          s2 = peg$c9;
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e13);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        if (input.charCodeAt(peg$currPos) === 45) {
+          s3 = peg$c10;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e14);
+          }
+        }
+        if (s3 === peg$FAILED) {
+          s3 = peg$parsecce1();
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = [];
+          s5 = peg$parsecce1();
+          while (s5 !== peg$FAILED) {
+            s4.push(s5);
+            s5 = peg$parsecce1();
+          }
+          if (input.charCodeAt(peg$currPos) === 45) {
+            s5 = peg$c10;
+            peg$currPos++;
+          } else {
+            s5 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e14);
+            }
+          }
+          if (s5 === peg$FAILED) {
+            s5 = null;
+          }
+          if (input.charCodeAt(peg$currPos) === 93) {
+            s6 = peg$c11;
+            peg$currPos++;
+          } else {
+            s6 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e15);
+            }
+          }
+          if (s6 !== peg$FAILED) {
+            s1 = [s1, s2, s3, s4, s5, s6];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsecce1() {
+      var s0, s1, s2, s3, s4;
+      s0 = peg$currPos;
+      s1 = peg$parsecc_char();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 45) {
+          s3 = peg$c10;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e14);
+          }
+        }
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parsecc_char();
+          if (s4 !== peg$FAILED) {
+            s3 = [s3, s4];
+            s2 = s3;
+          } else {
+            peg$currPos = s2;
+            s2 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s2;
+          s2 = peg$FAILED;
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsechar_class_esc();
+      }
+      return s0;
+    }
+    function peg$parsecc_char() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.length > peg$currPos) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e8);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$f1(s1);
+        if (s2) {
+          s2 = undefined;
+        } else {
+          s2 = peg$FAILED;
+        }
+        if (s2 !== peg$FAILED) {
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsesingle_char_esc();
+      }
+      return s0;
+    }
+    function peg$parsecat_esc() {
+      var s0, s1, s2, s3;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 3) === peg$c12) {
+        s1 = peg$c12;
+        peg$currPos += 3;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e16);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseis_category();
+        if (s2 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 125) {
+            s3 = peg$c3;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e5);
+            }
+          }
+          if (s3 !== peg$FAILED) {
+            s1 = [s1, s2, s3];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsecompl_esc() {
+      var s0, s1, s2, s3;
+      s0 = peg$currPos;
+      if (input.substr(peg$currPos, 3) === peg$c13) {
+        s1 = peg$c13;
+        peg$currPos += 3;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e17);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseis_category();
+        if (s2 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 125) {
+            s3 = peg$c3;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) {
+              peg$fail(peg$e5);
+            }
+          }
+          if (s3 !== peg$FAILED) {
+            s1 = [s1, s2, s3];
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parseis_category() {
+      var s0;
+      s0 = peg$parseletters();
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsemarks();
+        if (s0 === peg$FAILED) {
+          s0 = peg$parsenumbers();
+          if (s0 === peg$FAILED) {
+            s0 = peg$parsepunctuation();
+            if (s0 === peg$FAILED) {
+              s0 = peg$parseseparators();
+              if (s0 === peg$FAILED) {
+                s0 = peg$parsesymbols();
+                if (s0 === peg$FAILED) {
+                  s0 = peg$parseothers();
+                }
+              }
+            }
+          }
+        }
+      }
+      return s0;
+    }
+    function peg$parseletters() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 76) {
+        s1 = peg$c14;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e18);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r3.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e19);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsemarks() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 77) {
+        s1 = peg$c15;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e20);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r4.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e21);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsenumbers() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 78) {
+        s1 = peg$c16;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e22);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r5.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e23);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsepunctuation() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 80) {
+        s1 = peg$c17;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e24);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r6.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e25);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parseseparators() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 90) {
+        s1 = peg$c18;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e26);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r7.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e27);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parsesymbols() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 83) {
+        s1 = peg$c19;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e28);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r8.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e29);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    function peg$parseothers() {
+      var s0, s1, s2;
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 67) {
+        s1 = peg$c20;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) {
+          peg$fail(peg$e30);
+        }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = input.charAt(peg$currPos);
+        if (peg$r9.test(s2)) {
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+          if (peg$silentFails === 0) {
+            peg$fail(peg$e31);
+          }
+        }
+        if (s2 === peg$FAILED) {
+          s2 = null;
+        }
+        s1 = [s1, s2];
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+      return s0;
+    }
+    peg$result = peg$startRuleFunction();
+    if (options.peg$library) {
+      return /** @type {any} */{
+        peg$result,
+        peg$currPos,
+        peg$FAILED,
+        peg$maxFailExpected,
+        peg$maxFailPos
+      };
+    }
+    if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+      return peg$result;
+    } else {
+      if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+        peg$fail(peg$endExpectation());
+      }
+      throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
+    }
+  }
+  var iregexp$1 = {
+    StartRules: ["start"],
+    SyntaxError: peg$SyntaxError,
+    parse: peg$parse
+  };
+
+  const iregexp = iregexp$1;
+
+  /**
+   * Return _true_ if _pattern_ is a valid I-Regexp
+   * @param {string} pattern - Regular expression pattern to check.
+   * @returns true if _pattern_ is valid, or false otherwise.
+   */
+  function check(pattern) {
+    try {
+      iregexp.parse(pattern, {});
+    } catch (error) {
+      if (error instanceof iregexp.SyntaxError) {
+        return false;
+      }
+      throw error;
+    }
+    return true;
+  }
+  var check_1 = {
+    check
+  };
+
+  var check$1 = check_1.check;
+
   class Match {
     argTypes = [FunctionExpressionType.ValueType, FunctionExpressionType.ValueType];
     returnType = FunctionExpressionType.LogicalType;
@@ -1092,8 +2353,11 @@ var json_p3 = (function (exports) {
       this.options = options;
       this.cacheSize = options.cacheSize ?? 10;
       this.throwErrors = options.throwErrors ?? false;
+      this.iRegexpCheck = options.iRegexpCheck ?? true;
       this.#cache = new LRUCache(this.cacheSize);
     }
+
+    // eslint-disable-next-line sonarjs/cognitive-complexity
     call(s, pattern) {
       if (this.cacheSize > 0) {
         const re = this.#cache.get(pattern);
@@ -1106,6 +2370,18 @@ var json_p3 = (function (exports) {
           }
         }
       }
+      if (!isString(pattern)) {
+        if (this.throwErrors) {
+          throw new IRegexpError(`match() expected a string pattern, found ${pattern}`);
+        }
+        return false;
+      }
+      if (this.iRegexpCheck && !check$1(pattern)) {
+        if (this.throwErrors) {
+          throw new IRegexpError(`pattern ${pattern} is not a valid I-Regexp pattern`);
+        }
+        return false;
+      }
       try {
         const re = new RegExp(this.fullMatch(pattern), "u");
         if (this.cacheSize > 0) this.#cache.set(pattern, re);
@@ -1117,53 +2393,11 @@ var json_p3 = (function (exports) {
     }
     fullMatch(pattern) {
       const parts = [];
-      let nonCaptureGroup = false;
-      if (!pattern.startsWith("^") && !pattern.startsWith("^(")) {
-        nonCaptureGroup = true;
-        parts.push("^(?:");
-      }
-      parts.push(this.mapRegexp(pattern));
-      if (nonCaptureGroup && !pattern.endsWith("$") && !pattern.endsWith(")$")) {
-        parts.push(")$");
-      }
-      return parts.join("");
-    }
-
-    // See https://datatracker.ietf.org/doc/html/rfc9485#name-ecmascript-regexps
-    mapRegexp(pattern) {
-      let escaped = false;
-      let charClass = false;
-      const parts = [];
-      for (const ch of pattern) {
-        switch (ch) {
-          case ".":
-            if (!escaped && !charClass) {
-              parts.push("(?:(?![\r\n])\\P{Cs}|\\p{Cs}\\p{Cs})");
-            } else {
-              parts.push(ch);
-              escaped = false;
-            }
-            break;
-          case "\\":
-            escaped = true;
-            parts.push(ch);
-            break;
-          case "[":
-            charClass = true;
-            escaped = false;
-            parts.push(ch);
-            break;
-          case "]":
-            charClass = false;
-            escaped = false;
-            parts.push(ch);
-            break;
-          default:
-            escaped = false;
-            parts.push(ch);
-            break;
-        }
-      }
+      const explicitCaret = pattern.startsWith("^");
+      const explicitDollar = pattern.endsWith("$");
+      if (!explicitCaret && !explicitDollar) parts.push("^(?:");
+      parts.push(mapRegexp(pattern));
+      if (!explicitCaret && !explicitDollar) parts.push(")$");
       return parts.join("");
     }
   }
@@ -1177,8 +2411,11 @@ var json_p3 = (function (exports) {
       this.options = options;
       this.cacheSize = options.cacheSize ?? 10;
       this.throwErrors = options.throwErrors ?? false;
+      this.iRegexpCheck = options.iRegexpCheck ?? true;
       this.#cache = new LRUCache(this.cacheSize);
     }
+
+    // eslint-disable-next-line sonarjs/cognitive-complexity
     call(s, pattern) {
       if (this.cacheSize > 0) {
         const re = this.#cache.get(pattern);
@@ -1191,8 +2428,20 @@ var json_p3 = (function (exports) {
           }
         }
       }
+      if (!isString(pattern)) {
+        if (this.throwErrors) {
+          throw new IRegexpError(`match() expected a string pattern, found ${pattern}`);
+        }
+        return false;
+      }
+      if (this.iRegexpCheck && !check$1(pattern)) {
+        if (this.throwErrors) {
+          throw new IRegexpError(`pattern ${pattern} is not a valid I-Regexp pattern`);
+        }
+        return false;
+      }
       try {
-        const re = new RegExp(this.mapRegexp(pattern), "u");
+        const re = new RegExp(mapRegexp(pattern), "u");
         if (this.cacheSize > 0) this.#cache.set(pattern, re);
         return !!s.match(re);
       } catch (error) {
@@ -1200,44 +2449,6 @@ var json_p3 = (function (exports) {
         return false;
       }
     }
-
-    // See https://datatracker.ietf.org/doc/html/rfc9485#name-ecmascript-regexps
-    mapRegexp(pattern) {
-      let escaped = false;
-      let charClass = false;
-      const parts = [];
-      for (const ch of pattern) {
-        switch (ch) {
-          case ".":
-            if (!escaped && !charClass) {
-              parts.push("(?:(?![\r\n])\\P{Cs}|\\p{Cs}\\p{Cs})");
-            } else {
-              parts.push(ch);
-              escaped = false;
-            }
-            break;
-          case "\\":
-            escaped = true;
-            parts.push(ch);
-            break;
-          case "[":
-            charClass = true;
-            escaped = false;
-            parts.push(ch);
-            break;
-          case "]":
-            charClass = false;
-            escaped = false;
-            parts.push(ch);
-            break;
-          default:
-            escaped = false;
-            parts.push(ch);
-            break;
-        }
-      }
-      return parts.join("");
-    }
   }
 
   class Value {
@@ -3767,7 +4978,7 @@ var json_p3 = (function (exports) {
     apply: apply
   });
 
-  const version = "1.3.1";
+  const version = "1.3.2";
 
   exports.DEFAULT_ENVIRONMENT = DEFAULT_ENVIRONMENT;
   exports.FunctionExpressionType = FunctionExpressionType;