json-p3 1.3.1 → 1.3.3

package/dist/json-p3.cjs.js

@@ -1,5 +1,5 @@
 /*
- * json-p3 version 1.3.1
+ * json-p3 version 1.3.3
  * https://github.com/jg-rp/json-p3
  * 
  * MIT License
@@ -138,6 +138,18 @@ class JSONPathRecursionLimitError extends JSONPathError {
   }
 }
 
+/**
+ * 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.
  */
@@ -1082,6 +1094,1255 @@ class LRUCache extends Map {
   }
 }
 
+// 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;
@@ -1091,8 +2352,11 @@ class Match {
     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);
@@ -1105,6 +2369,18 @@ class Match {
         }
       }
     }
+    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);
@@ -1116,53 +2392,11 @@ class Match {
   }
   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("");
   }
 }
@@ -1176,8 +2410,11 @@ class Search {
     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);
@@ -1190,8 +2427,20 @@ class Search {
         }
       }
     }
+    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) {
@@ -1199,44 +2448,6 @@ class Search {
       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 {
@@ -2845,6 +4056,7 @@ class Parser {
         throw new JSONPathTypeError(`result of ${expr.name}()  must be compared`, expr.token);
       }
     }
+    this.throwForLiteral(expr);
     return keys ? new KeysFilterSelector(this.environment, tok, new LogicalExpression(tok, expr)) : new FilterSelector(this.environment, tok, new LogicalExpression(tok, expr));
   }
   parseBoolean(stream) {
@@ -2876,6 +4088,9 @@ class Parser {
     if (COMPARISON_OPERATORS.has(operator)) {
       this.throwForNonComparable(left);
       this.throwForNonComparable(right);
+    } else {
+      this.throwForLiteral(left);
+      this.throwForLiteral(right);
     }
     return new InfixExpression(tok, left, operator, right);
   }
@@ -2984,6 +4199,11 @@ class Parser {
       }
     }
   }
+  throwForLiteral(expr) {
+    if (expr instanceof FilterExpressionLiteral) {
+      throw new JSONPathSyntaxError(`filter expression literals (${expr.toString()}) must be compared`, expr.token);
+    }
+  }
 }
 
 /**
@@ -3766,7 +4986,7 @@ var index = /*#__PURE__*/Object.freeze({
   apply: apply
 });
 
-const version = "1.3.1";
+const version = "1.3.3";
 
 exports.DEFAULT_ENVIRONMENT = DEFAULT_ENVIRONMENT;
 exports.FunctionExpressionType = FunctionExpressionType;