@swagger-api/apidom-json-path 1.0.0-alpha.8 → 1.0.0-beta.0

package/dist/apidom-json-path.browser.js

@@ -19,9 +19,17 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _JsonPathError__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(854);
+/* harmony import */ var _JsonPathError_ts__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(854);
 
-class EvaluationJsonPathError extends _JsonPathError__WEBPACK_IMPORTED_MODULE_0__["default"] {
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+class EvaluationJsonPathError extends _JsonPathError_ts__WEBPACK_IMPORTED_MODULE_0__["default"] {
   path;
   element;
   constructor(message, structuredOptions) {
@@ -44,8 +52,12 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2449);
+/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4641);
 
+
+/**
+ * @public
+ */
 class JsonPathError extends _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__["default"] {}
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (JsonPathError);
 
@@ -59,9 +71,17 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _JsonPathError__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(854);
+/* harmony import */ var _JsonPathError_ts__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(854);
+
+
+/**
+ * @public
+ */
 
-class MultiEvaluationJsonPathError extends _JsonPathError__WEBPACK_IMPORTED_MODULE_0__["default"] {
+/**
+ * @public
+ */
+class MultiEvaluationJsonPathError extends _JsonPathError_ts__WEBPACK_IMPORTED_MODULE_0__["default"] {
   paths;
   element;
   constructor(message, structuredOptions) {
@@ -85,16 +105,26 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
 /* harmony import */ var jsonpath_plus__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3357);
-/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1514);
-/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4831);
-/* harmony import */ var _swagger_api_apidom_json_pointer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1581);
-/* harmony import */ var _errors_MultiEvaluationJsonPathError__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(427);
+/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1776);
+/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6941);
+/* harmony import */ var _swagger_api_apidom_json_pointer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7453);
+/* harmony import */ var _errors_MultiEvaluationJsonPathError_ts__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(427);
+
 
 
 
 
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
 /**
  * Evaluates multiple JSONPaths on ApiDOM element.
+ * @public
  */
 const evaluateMulti = (paths, element) => {
   try {
@@ -119,7 +149,7 @@ const evaluateMulti = (paths, element) => {
     }
     return results;
   } catch (error) {
-    throw new _errors_MultiEvaluationJsonPathError__WEBPACK_IMPORTED_MODULE_3__["default"](`JSON Path evaluation failed while multi-evaluating "${String(paths)}".`, {
+    throw new _errors_MultiEvaluationJsonPathError_ts__WEBPACK_IMPORTED_MODULE_3__["default"](`JSON Path evaluation failed while multi-evaluating "${String(paths)}".`, {
       paths,
       element: (0,_swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_4__.cloneDeep)(element),
       cause: error
@@ -139,16 +169,22 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
 /* harmony import */ var jsonpath_plus__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3357);
-/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1514);
-/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4831);
-/* harmony import */ var _swagger_api_apidom_json_pointer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1581);
-/* harmony import */ var _errors_EvaluationJsonPathError__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3424);
+/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1776);
+/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6941);
+/* harmony import */ var _swagger_api_apidom_json_pointer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7453);
+/* harmony import */ var _errors_EvaluationJsonPathError_ts__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3424);
+
+
 
 
 
+/**
+ * @public
+ */
 
 /**
  * Evaluates single JSONPath on ApiDOM element.
+ * @public
  */
 const evaluate = (path, element) => {
   try {
@@ -160,7 +196,7 @@ const evaluate = (path, element) => {
     });
     return pointers.map(pointer => (0,_swagger_api_apidom_json_pointer__WEBPACK_IMPORTED_MODULE_2__["default"])(pointer, element));
   } catch (error) {
-    throw new _errors_EvaluationJsonPathError__WEBPACK_IMPORTED_MODULE_3__["default"](`JSON Path evaluation failed while evaluating "${String(path)}".`, {
+    throw new _errors_EvaluationJsonPathError_ts__WEBPACK_IMPORTED_MODULE_3__["default"](`JSON Path evaluation failed while evaluating "${String(path)}".`, {
       path,
       element: (0,_swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_4__.cloneDeep)(element),
       cause: error
@@ -6018,6 +6054,7 @@ var createMethod = function (IS_INCLUDES) {
   return function ($this, el, fromIndex) {
     var O = toIndexedObject($this);
     var length = lengthOfArrayLike(O);
+    if (length === 0) return !IS_INCLUDES && -1;
     var index = toAbsoluteIndex(fromIndex, length);
     var value;
     // Array#includes uses SameValueZero equality algorithm
@@ -6213,16 +6250,16 @@ module.exports = function (target, key, value, options) {
 
 "use strict";
 
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 
 // eslint-disable-next-line es/no-object-defineproperty -- safe
 var defineProperty = Object.defineProperty;
 
 module.exports = function (key, value) {
   try {
-    defineProperty(global, key, { value: value, configurable: true, writable: true });
+    defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
   } catch (error) {
-    global[key] = value;
+    globalThis[key] = value;
   } return value;
 };
 
@@ -6250,10 +6287,10 @@ module.exports = !fails(function () {
 
 "use strict";
 
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 var isObject = __webpack_require__(262);
 
-var document = global.document;
+var document = globalThis.document;
 // typeof document.createElement is 'object' in old IE
 var EXISTS = isObject(document) && isObject(document.createElement);
 
@@ -6308,26 +6345,50 @@ module.exports = {
 
 /***/ }),
 
-/***/ 7868:
+/***/ 9683:
 /***/ ((module) => {
 
 "use strict";
 
-module.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';
+// IE8- don't enum bug keys
+module.exports = [
+  'constructor',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'toLocaleString',
+  'toString',
+  'valueOf'
+];
+
+
+/***/ }),
+
+/***/ 3531:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+var globalThis = __webpack_require__(8900);
+
+var navigator = globalThis.navigator;
+var userAgent = navigator && navigator.userAgent;
+
+module.exports = userAgent ? String(userAgent) : '';
 
 
 /***/ }),
 
-/***/ 4432:
+/***/ 5547:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
 
-var global = __webpack_require__(1063);
-var userAgent = __webpack_require__(7868);
+var globalThis = __webpack_require__(8900);
+var userAgent = __webpack_require__(3531);
 
-var process = global.process;
-var Deno = global.Deno;
+var process = globalThis.process;
+var Deno = globalThis.Deno;
 var versions = process && process.versions || Deno && Deno.version;
 var v8 = versions && versions.v8;
 var match, version;
@@ -6352,25 +6413,6 @@ if (!version && userAgent) {
 module.exports = version;
 
 
-/***/ }),
-
-/***/ 9683:
-/***/ ((module) => {
-
-"use strict";
-
-// IE8- don't enum bug keys
-module.exports = [
-  'constructor',
-  'hasOwnProperty',
-  'isPrototypeOf',
-  'propertyIsEnumerable',
-  'toLocaleString',
-  'toString',
-  'valueOf'
-];
-
-
 /***/ }),
 
 /***/ 3885:
@@ -6384,7 +6426,7 @@ var $Error = Error;
 var replace = uncurryThis(''.replace);
 
 var TEST = (function (arg) { return String(new $Error(arg).stack); })('zxcasd');
-// eslint-disable-next-line redos/no-vulnerable -- safe
+// eslint-disable-next-line redos/no-vulnerable, sonarjs/slow-regex -- safe
 var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
 var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
 
@@ -6443,7 +6485,7 @@ module.exports = !fails(function () {
 
 "use strict";
 
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 var apply = __webpack_require__(7013);
 var uncurryThis = __webpack_require__(9344);
 var isCallable = __webpack_require__(2769);
@@ -6453,6 +6495,8 @@ var path = __webpack_require__(8099);
 var bind = __webpack_require__(4572);
 var createNonEnumerableProperty = __webpack_require__(3999);
 var hasOwn = __webpack_require__(701);
+// add debugging info
+__webpack_require__(3753);
 
 var wrapConstructor = function (NativeConstructor) {
   var Wrapper = function (a, b, c) {
@@ -6489,7 +6533,7 @@ module.exports = function (options, source) {
   var STATIC = options.stat;
   var PROTO = options.proto;
 
-  var nativeSource = GLOBAL ? global : STATIC ? global[TARGET] : global[TARGET] && global[TARGET].prototype;
+  var nativeSource = GLOBAL ? globalThis : STATIC ? globalThis[TARGET] : globalThis[TARGET] && globalThis[TARGET].prototype;
 
   var target = GLOBAL ? path : path[TARGET] || createNonEnumerableProperty(path, TARGET, {})[TARGET];
   var targetPrototype = target.prototype;
@@ -6515,7 +6559,7 @@ module.exports = function (options, source) {
     if (!FORCED && !PROTO && typeof targetProperty == typeof sourceProperty) continue;
 
     // bind methods to global for calling from export context
-    if (options.bind && USE_NATIVE) resultProperty = bind(sourceProperty, global);
+    if (options.bind && USE_NATIVE) resultProperty = bind(sourceProperty, globalThis);
     // wrap global constructors for prevent changes in this version
     else if (options.wrap && USE_NATIVE) resultProperty = wrapConstructor(sourceProperty);
     // make static versions for prototype methods
@@ -6726,7 +6770,7 @@ module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
 "use strict";
 
 var path = __webpack_require__(8099);
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 var isCallable = __webpack_require__(2769);
 
 var aFunction = function (variable) {
@@ -6734,8 +6778,8 @@ var aFunction = function (variable) {
 };
 
 module.exports = function (namespace, method) {
-  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])
-    : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];
+  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(globalThis[namespace])
+    : path[namespace] && path[namespace][method] || globalThis[namespace] && globalThis[namespace][method];
 };
 
 
@@ -6803,7 +6847,7 @@ module.exports = function (V, P) {
 
 /***/ }),
 
-/***/ 1063:
+/***/ 8900:
 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {
 
 "use strict";
@@ -6965,7 +7009,7 @@ module.exports = function (O, options) {
 "use strict";
 
 var NATIVE_WEAK_MAP = __webpack_require__(1314);
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 var isObject = __webpack_require__(262);
 var createNonEnumerableProperty = __webpack_require__(3999);
 var hasOwn = __webpack_require__(701);
@@ -6974,8 +7018,8 @@ var sharedKey = __webpack_require__(4275);
 var hiddenKeys = __webpack_require__(5241);
 
 var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
-var TypeError = global.TypeError;
-var WeakMap = global.WeakMap;
+var TypeError = globalThis.TypeError;
+var WeakMap = globalThis.WeakMap;
 var set, get, has;
 
 var enforce = function (it) {
@@ -7572,7 +7616,8 @@ var NullProtoObjectViaActiveX = function (activeXDocument) {
   activeXDocument.write(scriptTag(''));
   activeXDocument.close();
   var temp = activeXDocument.parentWindow.Object;
-  activeXDocument = null; // avoid memory leak
+  // eslint-disable-next-line no-useless-assignment -- avoid memory leak
+  activeXDocument = null;
   return temp;
 };
 
@@ -7894,7 +7939,8 @@ exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
 
 /* eslint-disable no-proto -- safe */
 var uncurryThisAccessor = __webpack_require__(3574);
-var anObject = __webpack_require__(7235);
+var isObject = __webpack_require__(262);
+var requireObjectCoercible = __webpack_require__(5426);
 var aPossiblePrototype = __webpack_require__(1966);
 
 // `Object.setPrototypeOf` method
@@ -7911,8 +7957,9 @@ module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
     CORRECT_SETTER = test instanceof Array;
   } catch (error) { /* empty */ }
   return function setPrototypeOf(O, proto) {
-    anObject(O);
+    requireObjectCoercible(O);
     aPossiblePrototype(proto);
+    if (!isObject(O)) return O;
     if (CORRECT_SETTER) setter(O, proto);
     else O.__proto__ = proto;
     return O;
@@ -8084,13 +8131,20 @@ module.exports = function (key) {
 
 "use strict";
 
-var global = __webpack_require__(1063);
+var IS_PURE = __webpack_require__(4871);
+var globalThis = __webpack_require__(8900);
 var defineGlobalProperty = __webpack_require__(7525);
 
 var SHARED = '__core-js_shared__';
-var store = global[SHARED] || defineGlobalProperty(SHARED, {});
+var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
 
-module.exports = store;
+(store.versions || (store.versions = [])).push({
+  version: '3.39.0',
+  mode: IS_PURE ? 'pure' : 'global',
+  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
+  license: 'https://github.com/zloirock/core-js/blob/v3.39.0/LICENSE',
+  source: 'https://github.com/zloirock/core-js'
+});
 
 
 /***/ }),
@@ -8100,18 +8154,11 @@ module.exports = store;
 
 "use strict";
 
-var IS_PURE = __webpack_require__(4871);
 var store = __webpack_require__(3753);
 
-(module.exports = function (key, value) {
-  return store[key] || (store[key] = value !== undefined ? value : {});
-})('versions', []).push({
-  version: '3.35.1',
-  mode: IS_PURE ? 'pure' : 'global',
-  copyright: '© 2014-2024 Denis Pushkarev (zloirock.ru)',
-  license: 'https://github.com/zloirock/core-js/blob/v3.35.1/LICENSE',
-  source: 'https://github.com/zloirock/core-js'
-});
+module.exports = function (key, value) {
+  return store[key] || (store[key] = value || {});
+};
 
 
 /***/ }),
@@ -8167,11 +8214,11 @@ module.exports = {
 "use strict";
 
 /* eslint-disable es/no-symbol -- required for testing */
-var V8_VERSION = __webpack_require__(4432);
+var V8_VERSION = __webpack_require__(5547);
 var fails = __webpack_require__(1203);
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 
-var $String = global.String;
+var $String = globalThis.String;
 
 // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
 module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
@@ -8410,9 +8457,9 @@ module.exports = function (key) {
 /* eslint-disable es/no-symbol -- required for testing */
 var NATIVE_SYMBOL = __webpack_require__(4603);
 
-module.exports = NATIVE_SYMBOL
-  && !Symbol.sham
-  && typeof Symbol.iterator == 'symbol';
+module.exports = NATIVE_SYMBOL &&
+  !Symbol.sham &&
+  typeof Symbol.iterator == 'symbol';
 
 
 /***/ }),
@@ -8443,10 +8490,10 @@ module.exports = DESCRIPTORS && fails(function () {
 
 "use strict";
 
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 var isCallable = __webpack_require__(2769);
 
-var WeakMap = global.WeakMap;
+var WeakMap = globalThis.WeakMap;
 
 module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
 
@@ -8458,14 +8505,14 @@ module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
 
 "use strict";
 
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 var shared = __webpack_require__(8141);
 var hasOwn = __webpack_require__(701);
 var uid = __webpack_require__(1268);
 var NATIVE_SYMBOL = __webpack_require__(4603);
 var USE_SYMBOL_AS_UID = __webpack_require__(7460);
 
-var Symbol = global.Symbol;
+var Symbol = globalThis.Symbol;
 var WellKnownSymbolsStore = shared('wks');
 var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
 
@@ -8697,7 +8744,7 @@ module.exports = defineIterator(Array, 'Array', function (iterated, kind) {
   var target = state.target;
   var index = state.index++;
   if (!target || index >= target.length) {
-    state.target = undefined;
+    state.target = null;
     return createIterResultObject(undefined, true);
   }
   switch (state.kind) {
@@ -8731,12 +8778,12 @@ if (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {
 
 /* eslint-disable no-unused-vars -- required for functions `.length` */
 var $ = __webpack_require__(9098);
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 var apply = __webpack_require__(7013);
 var wrapErrorConstructorWithCause = __webpack_require__(6453);
 
 var WEB_ASSEMBLY = 'WebAssembly';
-var WebAssembly = global[WEB_ASSEMBLY];
+var WebAssembly = globalThis[WEB_ASSEMBLY];
 
 // eslint-disable-next-line es/no-error-cause -- feature detection
 var FORCED = new Error('e', { cause: 7 }).cause !== 7;
@@ -8847,12 +8894,12 @@ __webpack_require__(5695);
 
 __webpack_require__(9828);
 var DOMIterables = __webpack_require__(1100);
-var global = __webpack_require__(1063);
+var globalThis = __webpack_require__(8900);
 var setToStringTag = __webpack_require__(1811);
 var Iterators = __webpack_require__(6625);
 
 for (var COLLECTION_NAME in DOMIterables) {
-  setToStringTag(global[COLLECTION_NAME], COLLECTION_NAME);
+  setToStringTag(globalThis[COLLECTION_NAME], COLLECTION_NAME);
   Iterators[COLLECTION_NAME] = Iterators.Array;
 }
 
@@ -8883,272 +8930,1382 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   JSONPath: () => (/* binding */ JSONPath)
 /* harmony export */ });
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, _typeof(obj);
-}
-
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
+/**
+ * @implements {IHooks}
+ */
+class Hooks {
+  /**
+   * @callback HookCallback
+   * @this {*|Jsep} this
+   * @param {Jsep} env
+   * @returns: void
+   */
+  /**
+   * Adds the given callback to the list of callbacks for the given hook.
+   *
+   * The callback will be invoked when the hook it is registered for is run.
+   *
+   * One callback function can be registered to multiple hooks and the same hook multiple times.
+   *
+   * @param {string|object} name The name of the hook, or an object of callbacks keyed by name
+   * @param {HookCallback|boolean} callback The callback function which is given environment variables.
+   * @param {?boolean} [first=false] Will add the hook to the top of the list (defaults to the bottom)
+   * @public
+   */
+  add(name, callback, first) {
+    if (typeof arguments[0] != 'string') {
+      // Multiple hook callbacks, keyed by name
+      for (let name in arguments[0]) {
+        this.add(name, arguments[0][name], arguments[1]);
+      }
+    } else {
+      (Array.isArray(name) ? name : [name]).forEach(function (name) {
+        this[name] = this[name] || [];
+        if (callback) {
+          this[name][first ? 'unshift' : 'push'](callback);
+        }
+      }, this);
+    }
   }
-}
 
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
+  /**
+   * Runs a hook invoking all registered callbacks with the given environment variables.
+   *
+   * Callbacks will be invoked synchronously and in the order in which they were registered.
+   *
+   * @param {string} name The name of the hook.
+   * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+   * @public
+   */
+  run(name, env) {
+    this[name] = this[name] || [];
+    this[name].forEach(function (callback) {
+      callback.call(env && env.context ? env.context : env, env);
+    });
   }
 }
 
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  Object.defineProperty(Constructor, "prototype", {
-    writable: false
-  });
-  return Constructor;
-}
-
-function _inherits(subClass, superClass) {
-  if (typeof superClass !== "function" && superClass !== null) {
-    throw new TypeError("Super expression must either be null or a function");
+/**
+ * @implements {IPlugins}
+ */
+class Plugins {
+  constructor(jsep) {
+    this.jsep = jsep;
+    this.registered = {};
   }
 
-  subClass.prototype = Object.create(superClass && superClass.prototype, {
-    constructor: {
-      value: subClass,
-      writable: true,
-      configurable: true
+  /**
+   * @callback PluginSetup
+   * @this {Jsep} jsep
+   * @returns: void
+   */
+  /**
+   * Adds the given plugin(s) to the registry
+   *
+   * @param {object} plugins
+   * @param {string} plugins.name The name of the plugin
+   * @param {PluginSetup} plugins.init The init function
+   * @public
+   */
+  register() {
+    for (var _len = arguments.length, plugins = new Array(_len), _key = 0; _key < _len; _key++) {
+      plugins[_key] = arguments[_key];
     }
-  });
-  Object.defineProperty(subClass, "prototype", {
-    writable: false
-  });
-  if (superClass) _setPrototypeOf(subClass, superClass);
-}
-
-function _getPrototypeOf(o) {
-  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
-    return o.__proto__ || Object.getPrototypeOf(o);
-  };
-  return _getPrototypeOf(o);
-}
-
-function _setPrototypeOf(o, p) {
-  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-    o.__proto__ = p;
-    return o;
-  };
-  return _setPrototypeOf(o, p);
+    plugins.forEach(plugin => {
+      if (typeof plugin !== 'object' || !plugin.name || !plugin.init) {
+        throw new Error('Invalid JSEP plugin format');
+      }
+      if (this.registered[plugin.name]) {
+        // already registered. Ignore.
+        return;
+      }
+      plugin.init(this.jsep);
+      this.registered[plugin.name] = plugin;
+    });
+  }
 }
 
-function _isNativeReflectConstruct() {
-  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-  if (Reflect.construct.sham) return false;
-  if (typeof Proxy === "function") return true;
+//     JavaScript Expression Parser (JSEP) 1.4.0
 
-  try {
-    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-    return true;
-  } catch (e) {
-    return false;
+class Jsep {
+  /**
+   * @returns {string}
+   */
+  static get version() {
+    // To be filled in by the template
+    return '1.4.0';
   }
-}
 
-function _construct(Parent, args, Class) {
-  if (_isNativeReflectConstruct()) {
-    _construct = Reflect.construct.bind();
-  } else {
-    _construct = function _construct(Parent, args, Class) {
-      var a = [null];
-      a.push.apply(a, args);
-      var Constructor = Function.bind.apply(Parent, a);
-      var instance = new Constructor();
-      if (Class) _setPrototypeOf(instance, Class.prototype);
-      return instance;
-    };
+  /**
+   * @returns {string}
+   */
+  static toString() {
+    return 'JavaScript Expression Parser (JSEP) v' + Jsep.version;
+  }
+  // ==================== CONFIG ================================
+  /**
+   * @method addUnaryOp
+   * @param {string} op_name The name of the unary op to add
+   * @returns {Jsep}
+   */
+  static addUnaryOp(op_name) {
+    Jsep.max_unop_len = Math.max(op_name.length, Jsep.max_unop_len);
+    Jsep.unary_ops[op_name] = 1;
+    return Jsep;
   }
 
-  return _construct.apply(null, arguments);
-}
-
-function _isNativeFunction(fn) {
-  return Function.toString.call(fn).indexOf("[native code]") !== -1;
-}
-
-function _wrapNativeSuper(Class) {
-  var _cache = typeof Map === "function" ? new Map() : undefined;
-
-  _wrapNativeSuper = function _wrapNativeSuper(Class) {
-    if (Class === null || !_isNativeFunction(Class)) return Class;
-
-    if (typeof Class !== "function") {
-      throw new TypeError("Super expression must either be null or a function");
+  /**
+   * @method jsep.addBinaryOp
+   * @param {string} op_name The name of the binary op to add
+   * @param {number} precedence The precedence of the binary op (can be a float). Higher number = higher precedence
+   * @param {boolean} [isRightAssociative=false] whether operator is right-associative
+   * @returns {Jsep}
+   */
+  static addBinaryOp(op_name, precedence, isRightAssociative) {
+    Jsep.max_binop_len = Math.max(op_name.length, Jsep.max_binop_len);
+    Jsep.binary_ops[op_name] = precedence;
+    if (isRightAssociative) {
+      Jsep.right_associative.add(op_name);
+    } else {
+      Jsep.right_associative.delete(op_name);
     }
+    return Jsep;
+  }
 
-    if (typeof _cache !== "undefined") {
-      if (_cache.has(Class)) return _cache.get(Class);
+  /**
+   * @method addIdentifierChar
+   * @param {string} char The additional character to treat as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static addIdentifierChar(char) {
+    Jsep.additional_identifier_chars.add(char);
+    return Jsep;
+  }
 
-      _cache.set(Class, Wrapper);
-    }
+  /**
+   * @method addLiteral
+   * @param {string} literal_name The name of the literal to add
+   * @param {*} literal_value The value of the literal
+   * @returns {Jsep}
+   */
+  static addLiteral(literal_name, literal_value) {
+    Jsep.literals[literal_name] = literal_value;
+    return Jsep;
+  }
 
-    function Wrapper() {
-      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+  /**
+   * @method removeUnaryOp
+   * @param {string} op_name The name of the unary op to remove
+   * @returns {Jsep}
+   */
+  static removeUnaryOp(op_name) {
+    delete Jsep.unary_ops[op_name];
+    if (op_name.length === Jsep.max_unop_len) {
+      Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
     }
-
-    Wrapper.prototype = Object.create(Class.prototype, {
-      constructor: {
-        value: Wrapper,
-        enumerable: false,
-        writable: true,
-        configurable: true
-      }
-    });
-    return _setPrototypeOf(Wrapper, Class);
-  };
-
-  return _wrapNativeSuper(Class);
-}
-
-function _assertThisInitialized(self) {
-  if (self === void 0) {
-    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return Jsep;
   }
 
-  return self;
-}
-
-function _possibleConstructorReturn(self, call) {
-  if (call && (typeof call === "object" || typeof call === "function")) {
-    return call;
-  } else if (call !== void 0) {
-    throw new TypeError("Derived constructors may only return object or undefined");
+  /**
+   * @method removeAllUnaryOps
+   * @returns {Jsep}
+   */
+  static removeAllUnaryOps() {
+    Jsep.unary_ops = {};
+    Jsep.max_unop_len = 0;
+    return Jsep;
   }
 
-  return _assertThisInitialized(self);
-}
-
-function _createSuper(Derived) {
-  var hasNativeReflectConstruct = _isNativeReflectConstruct();
-
-  return function _createSuperInternal() {
-    var Super = _getPrototypeOf(Derived),
-        result;
-
-    if (hasNativeReflectConstruct) {
-      var NewTarget = _getPrototypeOf(this).constructor;
+  /**
+   * @method removeIdentifierChar
+   * @param {string} char The additional character to stop treating as a valid part of an identifier
+   * @returns {Jsep}
+   */
+  static removeIdentifierChar(char) {
+    Jsep.additional_identifier_chars.delete(char);
+    return Jsep;
+  }
 
-      result = Reflect.construct(Super, arguments, NewTarget);
-    } else {
-      result = Super.apply(this, arguments);
+  /**
+   * @method removeBinaryOp
+   * @param {string} op_name The name of the binary op to remove
+   * @returns {Jsep}
+   */
+  static removeBinaryOp(op_name) {
+    delete Jsep.binary_ops[op_name];
+    if (op_name.length === Jsep.max_binop_len) {
+      Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
     }
+    Jsep.right_associative.delete(op_name);
+    return Jsep;
+  }
 
-    return _possibleConstructorReturn(this, result);
-  };
-}
+  /**
+   * @method removeAllBinaryOps
+   * @returns {Jsep}
+   */
+  static removeAllBinaryOps() {
+    Jsep.binary_ops = {};
+    Jsep.max_binop_len = 0;
+    return Jsep;
+  }
 
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
+  /**
+   * @method removeLiteral
+   * @param {string} literal_name The name of the literal to remove
+   * @returns {Jsep}
+   */
+  static removeLiteral(literal_name) {
+    delete Jsep.literals[literal_name];
+    return Jsep;
+  }
 
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
+  /**
+   * @method removeAllLiterals
+   * @returns {Jsep}
+   */
+  static removeAllLiterals() {
+    Jsep.literals = {};
+    return Jsep;
+  }
+  // ==================== END CONFIG ============================
 
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
+  /**
+   * @returns {string}
+   */
+  get char() {
+    return this.expr.charAt(this.index);
+  }
 
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
+  /**
+   * @returns {number}
+   */
+  get code() {
+    return this.expr.charCodeAt(this.index);
+  }
+  /**
+   * @param {string} expr a string with the passed in express
+   * @returns Jsep
+   */
+  constructor(expr) {
+    // `index` stores the character number we are currently at
+    // All of the gobbles below will modify `index` as we move along
+    this.expr = expr;
+    this.index = 0;
+  }
 
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
+  /**
+   * static top-level parser
+   * @returns {jsep.Expression}
+   */
+  static parse(expr) {
+    return new Jsep(expr).parse();
+  }
 
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  /**
+   * Get the longest key length of any object
+   * @param {object} obj
+   * @returns {number}
+   */
+  static getMaxKeyLen(obj) {
+    return Math.max(0, ...Object.keys(obj).map(k => k.length));
+  }
 
-  return arr2;
-}
+  /**
+   * `ch` is a character code in the next three functions
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isDecimalDigit(ch) {
+    return ch >= 48 && ch <= 57; // 0...9
+  }
 
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
+  /**
+   * Returns the precedence of a binary operator or `0` if it isn't a binary operator. Can be float.
+   * @param {string} op_val
+   * @returns {number}
+   */
+  static binaryPrecedence(op_val) {
+    return Jsep.binary_ops[op_val] || 0;
+  }
 
-function _createForOfIteratorHelper(o, allowArrayLike) {
-  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  /**
+   * Looks for start of identifier
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierStart(ch) {
+    return ch >= 65 && ch <= 90 ||
+    // A...Z
+    ch >= 97 && ch <= 122 ||
+    // a...z
+    ch >= 128 && !Jsep.binary_ops[String.fromCharCode(ch)] ||
+    // any non-ASCII that is not an operator
+    Jsep.additional_identifier_chars.has(String.fromCharCode(ch)); // additional characters
+  }
 
-  if (!it) {
-    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
-      if (it) o = it;
-      var i = 0;
+  /**
+   * @param {number} ch
+   * @returns {boolean}
+   */
+  static isIdentifierPart(ch) {
+    return Jsep.isIdentifierStart(ch) || Jsep.isDecimalDigit(ch);
+  }
 
-      var F = function () {};
+  /**
+   * throw error at index of the expression
+   * @param {string} message
+   * @throws
+   */
+  throwError(message) {
+    const error = new Error(message + ' at character ' + this.index);
+    error.index = this.index;
+    error.description = message;
+    throw error;
+  }
 
-      return {
-        s: F,
-        n: function () {
-          if (i >= o.length) return {
-            done: true
-          };
-          return {
-            done: false,
-            value: o[i++]
-          };
-        },
-        e: function (e) {
-          throw e;
-        },
-        f: F
+  /**
+   * Run a given hook
+   * @param {string} name
+   * @param {jsep.Expression|false} [node]
+   * @returns {?jsep.Expression}
+   */
+  runHook(name, node) {
+    if (Jsep.hooks[name]) {
+      const env = {
+        context: this,
+        node
       };
+      Jsep.hooks.run(name, env);
+      return env.node;
     }
+    return node;
+  }
 
-    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  /**
+   * Runs a given hook until one returns a node
+   * @param {string} name
+   * @returns {?jsep.Expression}
+   */
+  searchHook(name) {
+    if (Jsep.hooks[name]) {
+      const env = {
+        context: this
+      };
+      Jsep.hooks[name].find(function (callback) {
+        callback.call(env.context, env);
+        return env.node;
+      });
+      return env.node;
+    }
   }
 
-  var normalCompletion = true,
-      didErr = false,
-      err;
-  return {
-    s: function () {
-      it = it.call(o);
-    },
-    n: function () {
-      var step = it.next();
-      normalCompletion = step.done;
-      return step;
-    },
-    e: function (e) {
-      didErr = true;
-      err = e;
-    },
-    f: function () {
-      try {
-        if (!normalCompletion && it.return != null) it.return();
-      } finally {
-        if (didErr) throw err;
-      }
+  /**
+   * Push `index` up to the next non-space character
+   */
+  gobbleSpaces() {
+    let ch = this.code;
+    // Whitespace
+    while (ch === Jsep.SPACE_CODE || ch === Jsep.TAB_CODE || ch === Jsep.LF_CODE || ch === Jsep.CR_CODE) {
+      ch = this.expr.charCodeAt(++this.index);
     }
-  };
-}
+    this.runHook('gobble-spaces');
+  }
+
+  /**
+   * Top-level method to parse all expressions and returns compound or single node
+   * @returns {jsep.Expression}
+   */
+  parse() {
+    this.runHook('before-all');
+    const nodes = this.gobbleExpressions();
+
+    // If there's only one expression just try returning the expression
+    const node = nodes.length === 1 ? nodes[0] : {
+      type: Jsep.COMPOUND,
+      body: nodes
+    };
+    return this.runHook('after-all', node);
+  }
+
+  /**
+   * top-level parser (but can be reused within as well)
+   * @param {number} [untilICode]
+   * @returns {jsep.Expression[]}
+   */
+  gobbleExpressions(untilICode) {
+    let nodes = [],
+      ch_i,
+      node;
+    while (this.index < this.expr.length) {
+      ch_i = this.code;
+
+      // Expressions can be separated by semicolons, commas, or just inferred without any
+      // separators
+      if (ch_i === Jsep.SEMCOL_CODE || ch_i === Jsep.COMMA_CODE) {
+        this.index++; // ignore separators
+      } else {
+        // Try to gobble each expression individually
+        if (node = this.gobbleExpression()) {
+          nodes.push(node);
+          // If we weren't able to find a binary expression and are out of room, then
+          // the expression passed in probably has too much
+        } else if (this.index < this.expr.length) {
+          if (ch_i === untilICode) {
+            break;
+          }
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+      }
+    }
+    return nodes;
+  }
+
+  /**
+   * The main parsing function.
+   * @returns {?jsep.Expression}
+   */
+  gobbleExpression() {
+    const node = this.searchHook('gobble-expression') || this.gobbleBinaryExpression();
+    this.gobbleSpaces();
+    return this.runHook('after-expression', node);
+  }
+
+  /**
+   * Search for the operation portion of the string (e.g. `+`, `===`)
+   * Start by taking the longest possible binary operations (3 characters: `===`, `!==`, `>>>`)
+   * and move down from 3 to 2 to 1 character until a matching binary operation is found
+   * then, return that binary operation
+   * @returns {string|boolean}
+   */
+  gobbleBinaryOp() {
+    this.gobbleSpaces();
+    let to_check = this.expr.substr(this.index, Jsep.max_binop_len);
+    let tc_len = to_check.length;
+    while (tc_len > 0) {
+      // Don't accept a binary op when it is an identifier.
+      // Binary ops that start with a identifier-valid character must be followed
+      // by a non identifier-part valid character
+      if (Jsep.binary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+        this.index += tc_len;
+        return to_check;
+      }
+      to_check = to_check.substr(0, --tc_len);
+    }
+    return false;
+  }
+
+  /**
+   * This function is responsible for gobbling an individual expression,
+   * e.g. `1`, `1+2`, `a+(b*2)-Math.sqrt(2)`
+   * @returns {?jsep.BinaryExpression}
+   */
+  gobbleBinaryExpression() {
+    let node, biop, prec, stack, biop_info, left, right, i, cur_biop;
+
+    // First, try to get the leftmost thing
+    // Then, check to see if there's a binary operator operating on that leftmost thing
+    // Don't gobbleBinaryOp without a left-hand-side
+    left = this.gobbleToken();
+    if (!left) {
+      return left;
+    }
+    biop = this.gobbleBinaryOp();
+
+    // If there wasn't a binary operator, just return the leftmost node
+    if (!biop) {
+      return left;
+    }
+
+    // Otherwise, we need to start a stack to properly place the binary operations in their
+    // precedence structure
+    biop_info = {
+      value: biop,
+      prec: Jsep.binaryPrecedence(biop),
+      right_a: Jsep.right_associative.has(biop)
+    };
+    right = this.gobbleToken();
+    if (!right) {
+      this.throwError("Expected expression after " + biop);
+    }
+    stack = [left, biop_info, right];
+
+    // Properly deal with precedence using [recursive descent](http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm)
+    while (biop = this.gobbleBinaryOp()) {
+      prec = Jsep.binaryPrecedence(biop);
+      if (prec === 0) {
+        this.index -= biop.length;
+        break;
+      }
+      biop_info = {
+        value: biop,
+        prec,
+        right_a: Jsep.right_associative.has(biop)
+      };
+      cur_biop = biop;
+
+      // Reduce: make a binary expression from the three topmost entries.
+      const comparePrev = prev => biop_info.right_a && prev.right_a ? prec > prev.prec : prec <= prev.prec;
+      while (stack.length > 2 && comparePrev(stack[stack.length - 2])) {
+        right = stack.pop();
+        biop = stack.pop().value;
+        left = stack.pop();
+        node = {
+          type: Jsep.BINARY_EXP,
+          operator: biop,
+          left,
+          right
+        };
+        stack.push(node);
+      }
+      node = this.gobbleToken();
+      if (!node) {
+        this.throwError("Expected expression after " + cur_biop);
+      }
+      stack.push(biop_info, node);
+    }
+    i = stack.length - 1;
+    node = stack[i];
+    while (i > 1) {
+      node = {
+        type: Jsep.BINARY_EXP,
+        operator: stack[i - 1].value,
+        left: stack[i - 2],
+        right: node
+      };
+      i -= 2;
+    }
+    return node;
+  }
+
+  /**
+   * An individual part of a binary expression:
+   * e.g. `foo.bar(baz)`, `1`, `"abc"`, `(a % 2)` (because it's in parenthesis)
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleToken() {
+    let ch, to_check, tc_len, node;
+    this.gobbleSpaces();
+    node = this.searchHook('gobble-token');
+    if (node) {
+      return this.runHook('after-token', node);
+    }
+    ch = this.code;
+    if (Jsep.isDecimalDigit(ch) || ch === Jsep.PERIOD_CODE) {
+      // Char code 46 is a dot `.` which can start off a numeric literal
+      return this.gobbleNumericLiteral();
+    }
+    if (ch === Jsep.SQUOTE_CODE || ch === Jsep.DQUOTE_CODE) {
+      // Single or double quotes
+      node = this.gobbleStringLiteral();
+    } else if (ch === Jsep.OBRACK_CODE) {
+      node = this.gobbleArray();
+    } else {
+      to_check = this.expr.substr(this.index, Jsep.max_unop_len);
+      tc_len = to_check.length;
+      while (tc_len > 0) {
+        // Don't accept an unary op when it is an identifier.
+        // Unary ops that start with a identifier-valid character must be followed
+        // by a non identifier-part valid character
+        if (Jsep.unary_ops.hasOwnProperty(to_check) && (!Jsep.isIdentifierStart(this.code) || this.index + to_check.length < this.expr.length && !Jsep.isIdentifierPart(this.expr.charCodeAt(this.index + to_check.length)))) {
+          this.index += tc_len;
+          const argument = this.gobbleToken();
+          if (!argument) {
+            this.throwError('missing unaryOp argument');
+          }
+          return this.runHook('after-token', {
+            type: Jsep.UNARY_EXP,
+            operator: to_check,
+            argument,
+            prefix: true
+          });
+        }
+        to_check = to_check.substr(0, --tc_len);
+      }
+      if (Jsep.isIdentifierStart(ch)) {
+        node = this.gobbleIdentifier();
+        if (Jsep.literals.hasOwnProperty(node.name)) {
+          node = {
+            type: Jsep.LITERAL,
+            value: Jsep.literals[node.name],
+            raw: node.name
+          };
+        } else if (node.name === Jsep.this_str) {
+          node = {
+            type: Jsep.THIS_EXP
+          };
+        }
+      } else if (ch === Jsep.OPAREN_CODE) {
+        // open parenthesis
+        node = this.gobbleGroup();
+      }
+    }
+    if (!node) {
+      return this.runHook('after-token', false);
+    }
+    node = this.gobbleTokenProperty(node);
+    return this.runHook('after-token', node);
+  }
+
+  /**
+   * Gobble properties of of identifiers/strings/arrays/groups.
+   * e.g. `foo`, `bar.baz`, `foo['bar'].baz`
+   * It also gobbles function calls:
+   * e.g. `Math.acos(obj.angle)`
+   * @param {jsep.Expression} node
+   * @returns {jsep.Expression}
+   */
+  gobbleTokenProperty(node) {
+    this.gobbleSpaces();
+    let ch = this.code;
+    while (ch === Jsep.PERIOD_CODE || ch === Jsep.OBRACK_CODE || ch === Jsep.OPAREN_CODE || ch === Jsep.QUMARK_CODE) {
+      let optional;
+      if (ch === Jsep.QUMARK_CODE) {
+        if (this.expr.charCodeAt(this.index + 1) !== Jsep.PERIOD_CODE) {
+          break;
+        }
+        optional = true;
+        this.index += 2;
+        this.gobbleSpaces();
+        ch = this.code;
+      }
+      this.index++;
+      if (ch === Jsep.OBRACK_CODE) {
+        node = {
+          type: Jsep.MEMBER_EXP,
+          computed: true,
+          object: node,
+          property: this.gobbleExpression()
+        };
+        if (!node.property) {
+          this.throwError('Unexpected "' + this.char + '"');
+        }
+        this.gobbleSpaces();
+        ch = this.code;
+        if (ch !== Jsep.CBRACK_CODE) {
+          this.throwError('Unclosed [');
+        }
+        this.index++;
+      } else if (ch === Jsep.OPAREN_CODE) {
+        // A function call is being made; gobble all the arguments
+        node = {
+          type: Jsep.CALL_EXP,
+          'arguments': this.gobbleArguments(Jsep.CPAREN_CODE),
+          callee: node
+        };
+      } else if (ch === Jsep.PERIOD_CODE || optional) {
+        if (optional) {
+          this.index--;
+        }
+        this.gobbleSpaces();
+        node = {
+          type: Jsep.MEMBER_EXP,
+          computed: false,
+          object: node,
+          property: this.gobbleIdentifier()
+        };
+      }
+      if (optional) {
+        node.optional = true;
+      } // else leave undefined for compatibility with esprima
+
+      this.gobbleSpaces();
+      ch = this.code;
+    }
+    return node;
+  }
+
+  /**
+   * Parse simple numeric literals: `12`, `3.4`, `.5`. Do this by using a string to
+   * keep track of everything in the numeric literal and then calling `parseFloat` on that string
+   * @returns {jsep.Literal}
+   */
+  gobbleNumericLiteral() {
+    let number = '',
+      ch,
+      chCode;
+    while (Jsep.isDecimalDigit(this.code)) {
+      number += this.expr.charAt(this.index++);
+    }
+    if (this.code === Jsep.PERIOD_CODE) {
+      // can start with a decimal marker
+      number += this.expr.charAt(this.index++);
+      while (Jsep.isDecimalDigit(this.code)) {
+        number += this.expr.charAt(this.index++);
+      }
+    }
+    ch = this.char;
+    if (ch === 'e' || ch === 'E') {
+      // exponent marker
+      number += this.expr.charAt(this.index++);
+      ch = this.char;
+      if (ch === '+' || ch === '-') {
+        // exponent sign
+        number += this.expr.charAt(this.index++);
+      }
+      while (Jsep.isDecimalDigit(this.code)) {
+        // exponent itself
+        number += this.expr.charAt(this.index++);
+      }
+      if (!Jsep.isDecimalDigit(this.expr.charCodeAt(this.index - 1))) {
+        this.throwError('Expected exponent (' + number + this.char + ')');
+      }
+    }
+    chCode = this.code;
+
+    // Check to make sure this isn't a variable name that start with a number (123abc)
+    if (Jsep.isIdentifierStart(chCode)) {
+      this.throwError('Variable names cannot start with a number (' + number + this.char + ')');
+    } else if (chCode === Jsep.PERIOD_CODE || number.length === 1 && number.charCodeAt(0) === Jsep.PERIOD_CODE) {
+      this.throwError('Unexpected period');
+    }
+    return {
+      type: Jsep.LITERAL,
+      value: parseFloat(number),
+      raw: number
+    };
+  }
+
+  /**
+   * Parses a string literal, staring with single or double quotes with basic support for escape codes
+   * e.g. `"hello world"`, `'this is\nJSEP'`
+   * @returns {jsep.Literal}
+   */
+  gobbleStringLiteral() {
+    let str = '';
+    const startIndex = this.index;
+    const quote = this.expr.charAt(this.index++);
+    let closed = false;
+    while (this.index < this.expr.length) {
+      let ch = this.expr.charAt(this.index++);
+      if (ch === quote) {
+        closed = true;
+        break;
+      } else if (ch === '\\') {
+        // Check for all of the common escape codes
+        ch = this.expr.charAt(this.index++);
+        switch (ch) {
+          case 'n':
+            str += '\n';
+            break;
+          case 'r':
+            str += '\r';
+            break;
+          case 't':
+            str += '\t';
+            break;
+          case 'b':
+            str += '\b';
+            break;
+          case 'f':
+            str += '\f';
+            break;
+          case 'v':
+            str += '\x0B';
+            break;
+          default:
+            str += ch;
+        }
+      } else {
+        str += ch;
+      }
+    }
+    if (!closed) {
+      this.throwError('Unclosed quote after "' + str + '"');
+    }
+    return {
+      type: Jsep.LITERAL,
+      value: str,
+      raw: this.expr.substring(startIndex, this.index)
+    };
+  }
+
+  /**
+   * Gobbles only identifiers
+   * e.g.: `foo`, `_value`, `$x1`
+   * Also, this function checks if that identifier is a literal:
+   * (e.g. `true`, `false`, `null`) or `this`
+   * @returns {jsep.Identifier}
+   */
+  gobbleIdentifier() {
+    let ch = this.code,
+      start = this.index;
+    if (Jsep.isIdentifierStart(ch)) {
+      this.index++;
+    } else {
+      this.throwError('Unexpected ' + this.char);
+    }
+    while (this.index < this.expr.length) {
+      ch = this.code;
+      if (Jsep.isIdentifierPart(ch)) {
+        this.index++;
+      } else {
+        break;
+      }
+    }
+    return {
+      type: Jsep.IDENTIFIER,
+      name: this.expr.slice(start, this.index)
+    };
+  }
+
+  /**
+   * Gobbles a list of arguments within the context of a function call
+   * or array literal. This function also assumes that the opening character
+   * `(` or `[` has already been gobbled, and gobbles expressions and commas
+   * until the terminator character `)` or `]` is encountered.
+   * e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`
+   * @param {number} termination
+   * @returns {jsep.Expression[]}
+   */
+  gobbleArguments(termination) {
+    const args = [];
+    let closed = false;
+    let separator_count = 0;
+    while (this.index < this.expr.length) {
+      this.gobbleSpaces();
+      let ch_i = this.code;
+      if (ch_i === termination) {
+        // done parsing
+        closed = true;
+        this.index++;
+        if (termination === Jsep.CPAREN_CODE && separator_count && separator_count >= args.length) {
+          this.throwError('Unexpected token ' + String.fromCharCode(termination));
+        }
+        break;
+      } else if (ch_i === Jsep.COMMA_CODE) {
+        // between expressions
+        this.index++;
+        separator_count++;
+        if (separator_count !== args.length) {
+          // missing argument
+          if (termination === Jsep.CPAREN_CODE) {
+            this.throwError('Unexpected token ,');
+          } else if (termination === Jsep.CBRACK_CODE) {
+            for (let arg = args.length; arg < separator_count; arg++) {
+              args.push(null);
+            }
+          }
+        }
+      } else if (args.length !== separator_count && separator_count !== 0) {
+        // NOTE: `&& separator_count !== 0` allows for either all commas, or all spaces as arguments
+        this.throwError('Expected comma');
+      } else {
+        const node = this.gobbleExpression();
+        if (!node || node.type === Jsep.COMPOUND) {
+          this.throwError('Expected comma');
+        }
+        args.push(node);
+      }
+    }
+    if (!closed) {
+      this.throwError('Expected ' + String.fromCharCode(termination));
+    }
+    return args;
+  }
+
+  /**
+   * Responsible for parsing a group of things within parentheses `()`
+   * that have no identifier in front (so not a function call)
+   * This function assumes that it needs to gobble the opening parenthesis
+   * and then tries to gobble everything within that parenthesis, assuming
+   * that the next thing it should see is the close parenthesis. If not,
+   * then the expression probably doesn't have a `)`
+   * @returns {boolean|jsep.Expression}
+   */
+  gobbleGroup() {
+    this.index++;
+    let nodes = this.gobbleExpressions(Jsep.CPAREN_CODE);
+    if (this.code === Jsep.CPAREN_CODE) {
+      this.index++;
+      if (nodes.length === 1) {
+        return nodes[0];
+      } else if (!nodes.length) {
+        return false;
+      } else {
+        return {
+          type: Jsep.SEQUENCE_EXP,
+          expressions: nodes
+        };
+      }
+    } else {
+      this.throwError('Unclosed (');
+    }
+  }
+
+  /**
+   * Responsible for parsing Array literals `[1, 2, 3]`
+   * This function assumes that it needs to gobble the opening bracket
+   * and then tries to gobble the expressions as arguments.
+   * @returns {jsep.ArrayExpression}
+   */
+  gobbleArray() {
+    this.index++;
+    return {
+      type: Jsep.ARRAY_EXP,
+      elements: this.gobbleArguments(Jsep.CBRACK_CODE)
+    };
+  }
+}
+
+// Static fields:
+const hooks = new Hooks();
+Object.assign(Jsep, {
+  hooks,
+  plugins: new Plugins(Jsep),
+  // Node Types
+  // ----------
+  // This is the full set of types that any JSEP node can be.
+  // Store them here to save space when minified
+  COMPOUND: 'Compound',
+  SEQUENCE_EXP: 'SequenceExpression',
+  IDENTIFIER: 'Identifier',
+  MEMBER_EXP: 'MemberExpression',
+  LITERAL: 'Literal',
+  THIS_EXP: 'ThisExpression',
+  CALL_EXP: 'CallExpression',
+  UNARY_EXP: 'UnaryExpression',
+  BINARY_EXP: 'BinaryExpression',
+  ARRAY_EXP: 'ArrayExpression',
+  TAB_CODE: 9,
+  LF_CODE: 10,
+  CR_CODE: 13,
+  SPACE_CODE: 32,
+  PERIOD_CODE: 46,
+  // '.'
+  COMMA_CODE: 44,
+  // ','
+  SQUOTE_CODE: 39,
+  // single quote
+  DQUOTE_CODE: 34,
+  // double quotes
+  OPAREN_CODE: 40,
+  // (
+  CPAREN_CODE: 41,
+  // )
+  OBRACK_CODE: 91,
+  // [
+  CBRACK_CODE: 93,
+  // ]
+  QUMARK_CODE: 63,
+  // ?
+  SEMCOL_CODE: 59,
+  // ;
+  COLON_CODE: 58,
+  // :
+
+  // Operations
+  // ----------
+  // Use a quickly-accessible map to store all of the unary operators
+  // Values are set to `1` (it really doesn't matter)
+  unary_ops: {
+    '-': 1,
+    '!': 1,
+    '~': 1,
+    '+': 1
+  },
+  // Also use a map for the binary operations but set their values to their
+  // binary precedence for quick reference (higher number = higher precedence)
+  // see [Order of operations](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence)
+  binary_ops: {
+    '||': 1,
+    '??': 1,
+    '&&': 2,
+    '|': 3,
+    '^': 4,
+    '&': 5,
+    '==': 6,
+    '!=': 6,
+    '===': 6,
+    '!==': 6,
+    '<': 7,
+    '>': 7,
+    '<=': 7,
+    '>=': 7,
+    '<<': 8,
+    '>>': 8,
+    '>>>': 8,
+    '+': 9,
+    '-': 9,
+    '*': 10,
+    '/': 10,
+    '%': 10,
+    '**': 11
+  },
+  // sets specific binary_ops as right-associative
+  right_associative: new Set(['**']),
+  // Additional valid identifier chars, apart from a-z, A-Z and 0-9 (except on the starting char)
+  additional_identifier_chars: new Set(['$', '_']),
+  // Literals
+  // ----------
+  // Store the values to return for the various literals we may encounter
+  literals: {
+    'true': true,
+    'false': false,
+    'null': null
+  },
+  // Except for `this`, which is special. This could be changed to something like `'self'` as well
+  this_str: 'this'
+});
+Jsep.max_unop_len = Jsep.getMaxKeyLen(Jsep.unary_ops);
+Jsep.max_binop_len = Jsep.getMaxKeyLen(Jsep.binary_ops);
+
+// Backward Compatibility:
+const jsep = expr => new Jsep(expr).parse();
+const stdClassProps = Object.getOwnPropertyNames(class Test {});
+Object.getOwnPropertyNames(Jsep).filter(prop => !stdClassProps.includes(prop) && jsep[prop] === undefined).forEach(m => {
+  jsep[m] = Jsep[m];
+});
+jsep.Jsep = Jsep; // allows for const { Jsep } = require('jsep');
+
+const CONDITIONAL_EXP = 'ConditionalExpression';
+var ternary = {
+  name: 'ternary',
+  init(jsep) {
+    // Ternary expression: test ? consequent : alternate
+    jsep.hooks.add('after-expression', function gobbleTernary(env) {
+      if (env.node && this.code === jsep.QUMARK_CODE) {
+        this.index++;
+        const test = env.node;
+        const consequent = this.gobbleExpression();
+        if (!consequent) {
+          this.throwError('Expected expression');
+        }
+        this.gobbleSpaces();
+        if (this.code === jsep.COLON_CODE) {
+          this.index++;
+          const alternate = this.gobbleExpression();
+          if (!alternate) {
+            this.throwError('Expected expression');
+          }
+          env.node = {
+            type: CONDITIONAL_EXP,
+            test,
+            consequent,
+            alternate
+          };
+
+          // check for operators of higher priority than ternary (i.e. assignment)
+          // jsep sets || at 1, and assignment at 0.9, and conditional should be between them
+          if (test.operator && jsep.binary_ops[test.operator] <= 0.9) {
+            let newTest = test;
+            while (newTest.right.operator && jsep.binary_ops[newTest.right.operator] <= 0.9) {
+              newTest = newTest.right;
+            }
+            env.node.test = newTest.right;
+            newTest.right = env.node;
+            env.node = test;
+          }
+        } else {
+          this.throwError('Expected :');
+        }
+      }
+    });
+  }
+};
+
+// Add default plugins:
+
+jsep.plugins.register(ternary);
+
+const FSLASH_CODE = 47; // '/'
+const BSLASH_CODE = 92; // '\\'
+
+var index = {
+  name: 'regex',
+  init(jsep) {
+    // Regex literal: /abc123/ig
+    jsep.hooks.add('gobble-token', function gobbleRegexLiteral(env) {
+      if (this.code === FSLASH_CODE) {
+        const patternIndex = ++this.index;
+        let inCharSet = false;
+        while (this.index < this.expr.length) {
+          if (this.code === FSLASH_CODE && !inCharSet) {
+            const pattern = this.expr.slice(patternIndex, this.index);
+            let flags = '';
+            while (++this.index < this.expr.length) {
+              const code = this.code;
+              if (code >= 97 && code <= 122 // a...z
+              || code >= 65 && code <= 90 // A...Z
+              || code >= 48 && code <= 57) {
+                // 0-9
+                flags += this.char;
+              } else {
+                break;
+              }
+            }
+            let value;
+            try {
+              value = new RegExp(pattern, flags);
+            } catch (e) {
+              this.throwError(e.message);
+            }
+            env.node = {
+              type: jsep.LITERAL,
+              value,
+              raw: this.expr.slice(patternIndex - 1, this.index)
+            };
+
+            // allow . [] and () after regex: /regex/.test(a)
+            env.node = this.gobbleTokenProperty(env.node);
+            return env.node;
+          }
+          if (this.code === jsep.OBRACK_CODE) {
+            inCharSet = true;
+          } else if (inCharSet && this.code === jsep.CBRACK_CODE) {
+            inCharSet = false;
+          }
+          this.index += this.code === BSLASH_CODE ? 2 : 1;
+        }
+        this.throwError('Unclosed Regex');
+      }
+    });
+  }
+};
+
+const PLUS_CODE = 43; // +
+const MINUS_CODE = 45; // -
+
+const plugin = {
+  name: 'assignment',
+  assignmentOperators: new Set(['=', '*=', '**=', '/=', '%=', '+=', '-=', '<<=', '>>=', '>>>=', '&=', '^=', '|=', '||=', '&&=', '??=']),
+  updateOperators: [PLUS_CODE, MINUS_CODE],
+  assignmentPrecedence: 0.9,
+  init(jsep) {
+    const updateNodeTypes = [jsep.IDENTIFIER, jsep.MEMBER_EXP];
+    plugin.assignmentOperators.forEach(op => jsep.addBinaryOp(op, plugin.assignmentPrecedence, true));
+    jsep.hooks.add('gobble-token', function gobbleUpdatePrefix(env) {
+      const code = this.code;
+      if (plugin.updateOperators.some(c => c === code && c === this.expr.charCodeAt(this.index + 1))) {
+        this.index += 2;
+        env.node = {
+          type: 'UpdateExpression',
+          operator: code === PLUS_CODE ? '++' : '--',
+          argument: this.gobbleTokenProperty(this.gobbleIdentifier()),
+          prefix: true
+        };
+        if (!env.node.argument || !updateNodeTypes.includes(env.node.argument.type)) {
+          this.throwError(`Unexpected ${env.node.operator}`);
+        }
+      }
+    });
+    jsep.hooks.add('after-token', function gobbleUpdatePostfix(env) {
+      if (env.node) {
+        const code = this.code;
+        if (plugin.updateOperators.some(c => c === code && c === this.expr.charCodeAt(this.index + 1))) {
+          if (!updateNodeTypes.includes(env.node.type)) {
+            this.throwError(`Unexpected ${env.node.operator}`);
+          }
+          this.index += 2;
+          env.node = {
+            type: 'UpdateExpression',
+            operator: code === PLUS_CODE ? '++' : '--',
+            argument: env.node,
+            prefix: false
+          };
+        }
+      }
+    });
+    jsep.hooks.add('after-expression', function gobbleAssignment(env) {
+      if (env.node) {
+        // Note: Binaries can be chained in a single expression to respect
+        // operator precedence (i.e. a = b = 1 + 2 + 3)
+        // Update all binary assignment nodes in the tree
+        updateBinariesToAssignments(env.node);
+      }
+    });
+    function updateBinariesToAssignments(node) {
+      if (plugin.assignmentOperators.has(node.operator)) {
+        node.type = 'AssignmentExpression';
+        updateBinariesToAssignments(node.left);
+        updateBinariesToAssignments(node.right);
+      } else if (!node.operator) {
+        Object.values(node).forEach(val => {
+          if (val && typeof val === 'object') {
+            updateBinariesToAssignments(val);
+          }
+        });
+      }
+    }
+  }
+};
+
+/* eslint-disable no-bitwise -- Convenient */
+
+// register plugins
+jsep.plugins.register(index, plugin);
+jsep.addUnaryOp('typeof');
+jsep.addLiteral('null', null);
+jsep.addLiteral('undefined', undefined);
+const BLOCKED_PROTO_PROPERTIES = new Set(['constructor', '__proto__', '__defineGetter__', '__defineSetter__']);
+const SafeEval = {
+  /**
+   * @param {jsep.Expression} ast
+   * @param {Record<string, any>} subs
+   */
+  evalAst(ast, subs) {
+    switch (ast.type) {
+      case 'BinaryExpression':
+      case 'LogicalExpression':
+        return SafeEval.evalBinaryExpression(ast, subs);
+      case 'Compound':
+        return SafeEval.evalCompound(ast, subs);
+      case 'ConditionalExpression':
+        return SafeEval.evalConditionalExpression(ast, subs);
+      case 'Identifier':
+        return SafeEval.evalIdentifier(ast, subs);
+      case 'Literal':
+        return SafeEval.evalLiteral(ast, subs);
+      case 'MemberExpression':
+        return SafeEval.evalMemberExpression(ast, subs);
+      case 'UnaryExpression':
+        return SafeEval.evalUnaryExpression(ast, subs);
+      case 'ArrayExpression':
+        return SafeEval.evalArrayExpression(ast, subs);
+      case 'CallExpression':
+        return SafeEval.evalCallExpression(ast, subs);
+      case 'AssignmentExpression':
+        return SafeEval.evalAssignmentExpression(ast, subs);
+      default:
+        throw SyntaxError('Unexpected expression', ast);
+    }
+  },
+  evalBinaryExpression(ast, subs) {
+    const result = {
+      '||': (a, b) => a || b(),
+      '&&': (a, b) => a && b(),
+      '|': (a, b) => a | b(),
+      '^': (a, b) => a ^ b(),
+      '&': (a, b) => a & b(),
+      // eslint-disable-next-line eqeqeq -- API
+      '==': (a, b) => a == b(),
+      // eslint-disable-next-line eqeqeq -- API
+      '!=': (a, b) => a != b(),
+      '===': (a, b) => a === b(),
+      '!==': (a, b) => a !== b(),
+      '<': (a, b) => a < b(),
+      '>': (a, b) => a > b(),
+      '<=': (a, b) => a <= b(),
+      '>=': (a, b) => a >= b(),
+      '<<': (a, b) => a << b(),
+      '>>': (a, b) => a >> b(),
+      '>>>': (a, b) => a >>> b(),
+      '+': (a, b) => a + b(),
+      '-': (a, b) => a - b(),
+      '*': (a, b) => a * b(),
+      '/': (a, b) => a / b(),
+      '%': (a, b) => a % b()
+    }[ast.operator](SafeEval.evalAst(ast.left, subs), () => SafeEval.evalAst(ast.right, subs));
+    return result;
+  },
+  evalCompound(ast, subs) {
+    let last;
+    for (let i = 0; i < ast.body.length; i++) {
+      if (ast.body[i].type === 'Identifier' && ['var', 'let', 'const'].includes(ast.body[i].name) && ast.body[i + 1] && ast.body[i + 1].type === 'AssignmentExpression') {
+        // var x=2; is detected as
+        // [{Identifier var}, {AssignmentExpression x=2}]
+        // eslint-disable-next-line @stylistic/max-len -- Long
+        // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient
+        i += 1;
+      }
+      const expr = ast.body[i];
+      last = SafeEval.evalAst(expr, subs);
+    }
+    return last;
+  },
+  evalConditionalExpression(ast, subs) {
+    if (SafeEval.evalAst(ast.test, subs)) {
+      return SafeEval.evalAst(ast.consequent, subs);
+    }
+    return SafeEval.evalAst(ast.alternate, subs);
+  },
+  evalIdentifier(ast, subs) {
+    if (Object.hasOwn(subs, ast.name)) {
+      return subs[ast.name];
+    }
+    throw ReferenceError(`${ast.name} is not defined`);
+  },
+  evalLiteral(ast) {
+    return ast.value;
+  },
+  evalMemberExpression(ast, subs) {
+    const prop = ast.computed ? SafeEval.evalAst(ast.property) // `object[property]`
+    : ast.property.name; // `object.property` property is Identifier
+    const obj = SafeEval.evalAst(ast.object, subs);
+    if (obj === undefined || obj === null) {
+      throw TypeError(`Cannot read properties of ${obj} (reading '${prop}')`);
+    }
+    if (!Object.hasOwn(obj, prop) && BLOCKED_PROTO_PROPERTIES.has(prop)) {
+      throw TypeError(`Cannot read properties of ${obj} (reading '${prop}')`);
+    }
+    const result = obj[prop];
+    if (typeof result === 'function') {
+      return result.bind(obj); // arrow functions aren't affected by bind.
+    }
+    return result;
+  },
+  evalUnaryExpression(ast, subs) {
+    const result = {
+      '-': a => -SafeEval.evalAst(a, subs),
+      '!': a => !SafeEval.evalAst(a, subs),
+      '~': a => ~SafeEval.evalAst(a, subs),
+      // eslint-disable-next-line no-implicit-coercion -- API
+      '+': a => +SafeEval.evalAst(a, subs),
+      typeof: a => typeof SafeEval.evalAst(a, subs)
+    }[ast.operator](ast.argument);
+    return result;
+  },
+  evalArrayExpression(ast, subs) {
+    return ast.elements.map(el => SafeEval.evalAst(el, subs));
+  },
+  evalCallExpression(ast, subs) {
+    const args = ast.arguments.map(arg => SafeEval.evalAst(arg, subs));
+    const func = SafeEval.evalAst(ast.callee, subs);
+    // if (func === Function) {
+    //     throw new Error('Function constructor is disabled');
+    // }
+    return func(...args);
+  },
+  evalAssignmentExpression(ast, subs) {
+    if (ast.left.type !== 'Identifier') {
+      throw SyntaxError('Invalid left-hand side in assignment');
+    }
+    const id = ast.left.name;
+    const value = SafeEval.evalAst(ast.right, subs);
+    subs[id] = value;
+    return subs[id];
+  }
+};
 
-var hasOwnProp = Object.prototype.hasOwnProperty;
 /**
- * @typedef {null|boolean|number|string|PlainObject|GenericArray} JSONObject
+ * A replacement for NodeJS' VM.Script which is also {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP | Content Security Policy} friendly.
+ */
+class SafeScript {
+  /**
+   * @param {string} expr Expression to evaluate
+   */
+  constructor(expr) {
+    this.code = expr;
+    this.ast = jsep(this.code);
+  }
+
+  /**
+   * @param {object} context Object whose items will be added
+   *   to evaluation
+   * @returns {EvaluatedResult} Result of evaluated code
+   */
+  runInNewContext(context) {
+    // `Object.create(null)` creates a prototypeless object
+    const keyMap = Object.assign(Object.create(null), context);
+    return SafeEval.evalAst(this.ast, keyMap);
+  }
+}
+
+/* eslint-disable camelcase -- Convenient for escaping */
+
+
+/**
+ * @typedef {null|boolean|number|string|object|GenericArray} JSONObject
  */
 
 /**
@@ -9165,7 +10322,6 @@ var hasOwnProp = Object.prototype.hasOwnProperty;
  * @param {AnyItem} item Array item to add (to end)
  * @returns {GenericArray} Copy of the original array
  */
-
 function push(arr, item) {
   arr = arr.slice();
   arr.push(item);
@@ -9177,52 +10333,39 @@ function push(arr, item) {
  * @param {GenericArray} arr Array to copy and into which to unshift
  * @returns {GenericArray} Copy of the original array
  */
-
-
 function unshift(item, arr) {
   arr = arr.slice();
   arr.unshift(item);
   return arr;
 }
+
 /**
  * Caught when JSONPath is used without `new` but rethrown if with `new`
  * @extends Error
  */
-
-
-var NewError = /*#__PURE__*/function (_Error) {
-  _inherits(NewError, _Error);
-
-  var _super = _createSuper(NewError);
-
+class NewError extends Error {
   /**
    * @param {AnyResult} value The evaluated scalar value
    */
-  function NewError(value) {
-    var _this;
-
-    _classCallCheck(this, NewError);
-
-    _this = _super.call(this, 'JSONPath should not be called with "new" (it prevents return ' + 'of (unwrapped) scalar values)');
-    _this.avoidNew = true;
-    _this.value = value;
-    _this.name = 'NewError';
-    return _this;
+  constructor(value) {
+    super('JSONPath should not be called with "new" (it prevents return ' + 'of (unwrapped) scalar values)');
+    this.avoidNew = true;
+    this.value = value;
+    this.name = 'NewError';
   }
+}
 
-  return _createClass(NewError);
-}( /*#__PURE__*/_wrapNativeSuper(Error));
 /**
-* @typedef {PlainObject} ReturnObject
+* @typedef {object} ReturnObject
 * @property {string} path
 * @property {JSONObject} value
-* @property {PlainObject|GenericArray} parent
+* @property {object|GenericArray} parent
 * @property {string} parentProperty
 */
 
 /**
 * @callback JSONPathCallback
-* @param {string|PlainObject} preferredOutput
+* @param {string|object} preferredOutput
 * @param {"value"|"property"} type
 * @param {ReturnObject} fullRetObj
 * @returns {void}
@@ -9232,23 +10375,42 @@ var NewError = /*#__PURE__*/function (_Error) {
 * @callback OtherTypeCallback
 * @param {JSONObject} val
 * @param {string} path
-* @param {PlainObject|GenericArray} parent
+* @param {object|GenericArray} parent
 * @param {string} parentPropName
 * @returns {boolean}
 */
 
-/* eslint-disable max-len -- Can make multiline type after https://github.com/syavorsky/comment-parser/issues/109 */
+/**
+ * @typedef {any} ContextItem
+ */
+
+/**
+ * @typedef {any} EvaluatedResult
+ */
+
+/**
+* @callback EvalCallback
+* @param {string} code
+* @param {ContextItem} context
+* @returns {EvaluatedResult}
+*/
 
 /**
- * @typedef {PlainObject} JSONPathOptions
+ * @typedef {typeof SafeScript} EvalClass
+ */
+
+/**
+ * @typedef {object} JSONPathOptions
  * @property {JSON} json
  * @property {string|string[]} path
- * @property {"value"|"path"|"pointer"|"parent"|"parentProperty"|"all"} [resultType="value"]
+ * @property {"value"|"path"|"pointer"|"parent"|"parentProperty"|
+ *   "all"} [resultType="value"]
  * @property {boolean} [flatten=false]
  * @property {boolean} [wrap=true]
- * @property {PlainObject} [sandbox={}]
- * @property {boolean} [preventEval=false]
- * @property {PlainObject|GenericArray|null} [parent=null]
+ * @property {object} [sandbox={}]
+ * @property {EvalCallback|EvalClass|'safe'|'native'|
+ *   boolean} [eval = 'safe']
+ * @property {object|GenericArray|null} [parent=null]
  * @property {string|null} [parentProperty=null]
  * @property {JSONPathCallback} [callback]
  * @property {OtherTypeCallback} [otherTypeCallback] Defaults to
@@ -9256,8 +10418,6 @@ var NewError = /*#__PURE__*/function (_Error) {
  * @property {boolean} [autostart=true]
  */
 
-/* eslint-enable max-len -- Can make multiline type after https://github.com/syavorsky/comment-parser/issues/109 */
-
 /**
  * @param {string|JSONPathOptions} opts If a string, will be treated as `expr`
  * @param {string} [expr] JSON path to evaluate
@@ -9273,10 +10433,8 @@ var NewError = /*#__PURE__*/function (_Error) {
  * @returns {JSONPath}
  * @class
  */
-
-
 function JSONPath(opts, expr, obj, callback, otherTypeCallback) {
-  // eslint-disable-next-line no-restricted-syntax
+  // eslint-disable-next-line no-restricted-syntax -- Allow for pseudo-class
   if (!(this instanceof JSONPath)) {
     try {
       return new JSONPath(opts, expr, obj, callback, otherTypeCallback);
@@ -9284,11 +10442,9 @@ function JSONPath(opts, expr, obj, callback, otherTypeCallback) {
       if (!e.avoidNew) {
         throw e;
       }
-
       return e.value;
     }
   }
-
   if (typeof opts === 'string') {
     otherTypeCallback = callback;
     callback = obj;
@@ -9296,249 +10452,215 @@ function JSONPath(opts, expr, obj, callback, otherTypeCallback) {
     expr = opts;
     opts = null;
   }
-
-  var optObj = opts && _typeof(opts) === 'object';
+  const optObj = opts && typeof opts === 'object';
   opts = opts || {};
   this.json = opts.json || obj;
   this.path = opts.path || expr;
   this.resultType = opts.resultType || 'value';
   this.flatten = opts.flatten || false;
-  this.wrap = hasOwnProp.call(opts, 'wrap') ? opts.wrap : true;
+  this.wrap = Object.hasOwn(opts, 'wrap') ? opts.wrap : true;
   this.sandbox = opts.sandbox || {};
-  this.preventEval = opts.preventEval || false;
+  this.eval = opts.eval === undefined ? 'safe' : opts.eval;
+  this.ignoreEvalErrors = typeof opts.ignoreEvalErrors === 'undefined' ? false : opts.ignoreEvalErrors;
   this.parent = opts.parent || null;
   this.parentProperty = opts.parentProperty || null;
   this.callback = opts.callback || callback || null;
-
   this.otherTypeCallback = opts.otherTypeCallback || otherTypeCallback || function () {
     throw new TypeError('You must supply an otherTypeCallback callback option ' + 'with the @other() operator.');
   };
-
   if (opts.autostart !== false) {
-    var args = {
+    const args = {
       path: optObj ? opts.path : expr
     };
-
     if (!optObj) {
       args.json = obj;
     } else if ('json' in opts) {
       args.json = opts.json;
     }
-
-    var ret = this.evaluate(args);
-
-    if (!ret || _typeof(ret) !== 'object') {
+    const ret = this.evaluate(args);
+    if (!ret || typeof ret !== 'object') {
       throw new NewError(ret);
     }
-
     return ret;
   }
-} // PUBLIC METHODS
-
+}
 
+// PUBLIC METHODS
 JSONPath.prototype.evaluate = function (expr, json, callback, otherTypeCallback) {
-  var _this2 = this;
-
-  var currParent = this.parent,
-      currParentProperty = this.parentProperty;
-  var flatten = this.flatten,
-      wrap = this.wrap;
+  let currParent = this.parent,
+    currParentProperty = this.parentProperty;
+  let {
+    flatten,
+    wrap
+  } = this;
   this.currResultType = this.resultType;
-  this.currPreventEval = this.preventEval;
+  this.currEval = this.eval;
   this.currSandbox = this.sandbox;
   callback = callback || this.callback;
   this.currOtherTypeCallback = otherTypeCallback || this.otherTypeCallback;
   json = json || this.json;
   expr = expr || this.path;
-
-  if (expr && _typeof(expr) === 'object' && !Array.isArray(expr)) {
+  if (expr && typeof expr === 'object' && !Array.isArray(expr)) {
     if (!expr.path && expr.path !== '') {
       throw new TypeError('You must supply a "path" property when providing an object ' + 'argument to JSONPath.evaluate().');
     }
-
-    if (!hasOwnProp.call(expr, 'json')) {
+    if (!Object.hasOwn(expr, 'json')) {
       throw new TypeError('You must supply a "json" property when providing an object ' + 'argument to JSONPath.evaluate().');
     }
-
-    var _expr = expr;
-    json = _expr.json;
-    flatten = hasOwnProp.call(expr, 'flatten') ? expr.flatten : flatten;
-    this.currResultType = hasOwnProp.call(expr, 'resultType') ? expr.resultType : this.currResultType;
-    this.currSandbox = hasOwnProp.call(expr, 'sandbox') ? expr.sandbox : this.currSandbox;
-    wrap = hasOwnProp.call(expr, 'wrap') ? expr.wrap : wrap;
-    this.currPreventEval = hasOwnProp.call(expr, 'preventEval') ? expr.preventEval : this.currPreventEval;
-    callback = hasOwnProp.call(expr, 'callback') ? expr.callback : callback;
-    this.currOtherTypeCallback = hasOwnProp.call(expr, 'otherTypeCallback') ? expr.otherTypeCallback : this.currOtherTypeCallback;
-    currParent = hasOwnProp.call(expr, 'parent') ? expr.parent : currParent;
-    currParentProperty = hasOwnProp.call(expr, 'parentProperty') ? expr.parentProperty : currParentProperty;
+    ({
+      json
+    } = expr);
+    flatten = Object.hasOwn(expr, 'flatten') ? expr.flatten : flatten;
+    this.currResultType = Object.hasOwn(expr, 'resultType') ? expr.resultType : this.currResultType;
+    this.currSandbox = Object.hasOwn(expr, 'sandbox') ? expr.sandbox : this.currSandbox;
+    wrap = Object.hasOwn(expr, 'wrap') ? expr.wrap : wrap;
+    this.currEval = Object.hasOwn(expr, 'eval') ? expr.eval : this.currEval;
+    callback = Object.hasOwn(expr, 'callback') ? expr.callback : callback;
+    this.currOtherTypeCallback = Object.hasOwn(expr, 'otherTypeCallback') ? expr.otherTypeCallback : this.currOtherTypeCallback;
+    currParent = Object.hasOwn(expr, 'parent') ? expr.parent : currParent;
+    currParentProperty = Object.hasOwn(expr, 'parentProperty') ? expr.parentProperty : currParentProperty;
     expr = expr.path;
   }
-
   currParent = currParent || null;
   currParentProperty = currParentProperty || null;
-
   if (Array.isArray(expr)) {
     expr = JSONPath.toPathString(expr);
   }
-
   if (!expr && expr !== '' || !json) {
     return undefined;
   }
-
-  var exprList = JSONPath.toPathArray(expr);
-
+  const exprList = JSONPath.toPathArray(expr);
   if (exprList[0] === '$' && exprList.length > 1) {
     exprList.shift();
   }
-
   this._hasParentSelector = null;
-
-  var result = this._trace(exprList, json, ['$'], currParent, currParentProperty, callback).filter(function (ea) {
+  const result = this._trace(exprList, json, ['$'], currParent, currParentProperty, callback).filter(function (ea) {
     return ea && !ea.isParentSelector;
   });
-
   if (!result.length) {
     return wrap ? [] : undefined;
   }
-
   if (!wrap && result.length === 1 && !result[0].hasArrExpr) {
     return this._getPreferredOutput(result[0]);
   }
-
-  return result.reduce(function (rslt, ea) {
-    var valOrPath = _this2._getPreferredOutput(ea);
-
+  return result.reduce((rslt, ea) => {
+    const valOrPath = this._getPreferredOutput(ea);
     if (flatten && Array.isArray(valOrPath)) {
       rslt = rslt.concat(valOrPath);
     } else {
       rslt.push(valOrPath);
     }
-
     return rslt;
   }, []);
-}; // PRIVATE METHODS
+};
 
+// PRIVATE METHODS
 
 JSONPath.prototype._getPreferredOutput = function (ea) {
-  var resultType = this.currResultType;
-
+  const resultType = this.currResultType;
   switch (resultType) {
     case 'all':
       {
-        var path = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
+        const path = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);
         ea.pointer = JSONPath.toPointer(path);
         ea.path = typeof ea.path === 'string' ? ea.path : JSONPath.toPathString(ea.path);
         return ea;
       }
-
     case 'value':
     case 'parent':
     case 'parentProperty':
       return ea[resultType];
-
     case 'path':
       return JSONPath.toPathString(ea[resultType]);
-
     case 'pointer':
       return JSONPath.toPointer(ea.path);
-
     default:
       throw new TypeError('Unknown result type');
   }
 };
-
 JSONPath.prototype._handleCallback = function (fullRetObj, callback, type) {
   if (callback) {
-    var preferredOutput = this._getPreferredOutput(fullRetObj);
-
-    fullRetObj.path = typeof fullRetObj.path === 'string' ? fullRetObj.path : JSONPath.toPathString(fullRetObj.path); // eslint-disable-next-line n/callback-return
-
+    const preferredOutput = this._getPreferredOutput(fullRetObj);
+    fullRetObj.path = typeof fullRetObj.path === 'string' ? fullRetObj.path : JSONPath.toPathString(fullRetObj.path);
+    // eslint-disable-next-line n/callback-return -- No need to return
     callback(preferredOutput, type, fullRetObj);
   }
 };
+
 /**
  *
  * @param {string} expr
  * @param {JSONObject} val
  * @param {string} path
- * @param {PlainObject|GenericArray} parent
+ * @param {object|GenericArray} parent
  * @param {string} parentPropName
  * @param {JSONPathCallback} callback
  * @param {boolean} hasArrExpr
  * @param {boolean} literalPriority
  * @returns {ReturnObject|ReturnObject[]}
  */
-
-
 JSONPath.prototype._trace = function (expr, val, path, parent, parentPropName, callback, hasArrExpr, literalPriority) {
-  var _this3 = this;
-
   // No expr to follow? return path and value as the result of
   //  this trace branch
-  var retObj;
-
+  let retObj;
   if (!expr.length) {
     retObj = {
-      path: path,
+      path,
       value: val,
-      parent: parent,
+      parent,
       parentProperty: parentPropName,
-      hasArrExpr: hasArrExpr
+      hasArrExpr
     };
-
     this._handleCallback(retObj, callback, 'value');
-
     return retObj;
   }
+  const loc = expr[0],
+    x = expr.slice(1);
 
-  var loc = expr[0],
-      x = expr.slice(1); // We need to gather the return value of recursive trace calls in order to
+  // We need to gather the return value of recursive trace calls in order to
   // do the parent sel computation.
-
-  var ret = [];
+  const ret = [];
   /**
    *
    * @param {ReturnObject|ReturnObject[]} elems
    * @returns {void}
    */
-
   function addRet(elems) {
     if (Array.isArray(elems)) {
       // This was causing excessive stack size in Node (with or
       //  without Babel) against our performance test:
       //  `ret.push(...elems);`
-      elems.forEach(function (t) {
+      elems.forEach(t => {
         ret.push(t);
       });
     } else {
       ret.push(elems);
     }
   }
-
-  if ((typeof loc !== 'string' || literalPriority) && val && hasOwnProp.call(val, loc)) {
+  if ((typeof loc !== 'string' || literalPriority) && val && Object.hasOwn(val, loc)) {
     // simple case--directly follow property
-    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr)); // eslint-disable-next-line unicorn/prefer-switch -- Part of larger `if`
+    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr));
+    // eslint-disable-next-line unicorn/prefer-switch -- Part of larger `if`
   } else if (loc === '*') {
     // all child properties
-    this._walk(val, function (m) {
-      addRet(_this3._trace(x, val[m], push(path, m), val, m, callback, true, true));
+    this._walk(val, m => {
+      addRet(this._trace(x, val[m], push(path, m), val, m, callback, true, true));
     });
   } else if (loc === '..') {
     // all descendent parent properties
     // Check remaining expression with val's immediate children
     addRet(this._trace(x, val, path, parent, parentPropName, callback, hasArrExpr));
-
-    this._walk(val, function (m) {
+    this._walk(val, m => {
       // We don't join m and x here because we only want parents,
       //   not scalar values
-      if (_typeof(val[m]) === 'object') {
+      if (typeof val[m] === 'object') {
         // Keep going with recursive descent on val's
         //   object children
-        addRet(_this3._trace(expr.slice(), val[m], push(path, m), val, m, callback, true));
+        addRet(this._trace(expr.slice(), val[m], push(path, m), val, m, callback, true));
       }
-    }); // The parent sel computation is handled in the frame above using the
+    });
+    // The parent sel computation is handled in the frame above using the
     // ancestor object of val
-
   } else if (loc === '^') {
     // This is not a final endpoint, so we do not invoke the callback here
     this._hasParentSelector = true;
@@ -9552,172 +10674,146 @@ JSONPath.prototype._trace = function (expr, val, path, parent, parentPropName, c
     retObj = {
       path: push(path, loc),
       value: parentPropName,
-      parent: parent,
+      parent,
       parentProperty: null
     };
-
     this._handleCallback(retObj, callback, 'property');
-
     return retObj;
   } else if (loc === '$') {
     // root only
     addRet(this._trace(x, val, path, null, null, callback, hasArrExpr));
-  } else if (/^(\x2D?[0-9]*):(\x2D?[0-9]*):?([0-9]*)$/.test(loc)) {
+  } else if (/^(-?\d*):(-?\d*):?(\d*)$/u.test(loc)) {
     // [start:end:step]  Python slice syntax
     addRet(this._slice(loc, x, val, path, parent, parentPropName, callback));
   } else if (loc.indexOf('?(') === 0) {
     // [?(expr)] (filtering)
-    if (this.currPreventEval) {
+    if (this.currEval === false) {
       throw new Error('Eval [?(expr)] prevented in JSONPath expression.');
     }
-
-    var safeLoc = loc.replace(/^\?\(((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?)\)$/, '$1');
-
-    this._walk(val, function (m) {
-      if (_this3._eval(safeLoc, val[m], m, path, parent, parentPropName)) {
-        addRet(_this3._trace(x, val[m], push(path, m), val, m, callback, true));
-      }
-    });
+    const safeLoc = loc.replace(/^\?\((.*?)\)$/u, '$1');
+    // check for a nested filter expression
+    const nested = /@.?([^?]*)[['](\??\(.*?\))(?!.\)\])[\]']/gu.exec(safeLoc);
+    if (nested) {
+      // find if there are matches in the nested expression
+      // add them to the result set if there is at least one match
+      this._walk(val, m => {
+        const npath = [nested[2]];
+        const nvalue = nested[1] ? val[m][nested[1]] : val[m];
+        const filterResults = this._trace(npath, nvalue, path, parent, parentPropName, callback, true);
+        if (filterResults.length > 0) {
+          addRet(this._trace(x, val[m], push(path, m), val, m, callback, true));
+        }
+      });
+    } else {
+      this._walk(val, m => {
+        if (this._eval(safeLoc, val[m], m, path, parent, parentPropName)) {
+          addRet(this._trace(x, val[m], push(path, m), val, m, callback, true));
+        }
+      });
+    }
   } else if (loc[0] === '(') {
     // [(expr)] (dynamic property/index)
-    if (this.currPreventEval) {
+    if (this.currEval === false) {
       throw new Error('Eval [(expr)] prevented in JSONPath expression.');
-    } // As this will resolve to a property name (but we don't know it
+    }
+    // As this will resolve to a property name (but we don't know it
     //  yet), property and parent information is relative to the
     //  parent of the property to which this expression will resolve
-
-
-    addRet(this._trace(unshift(this._eval(loc, val, path[path.length - 1], path.slice(0, -1), parent, parentPropName), x), val, path, parent, parentPropName, callback, hasArrExpr));
+    addRet(this._trace(unshift(this._eval(loc, val, path.at(-1), path.slice(0, -1), parent, parentPropName), x), val, path, parent, parentPropName, callback, hasArrExpr));
   } else if (loc[0] === '@') {
     // value type: @boolean(), etc.
-    var addType = false;
-    var valueType = loc.slice(1, -2);
-
+    let addType = false;
+    const valueType = loc.slice(1, -2);
     switch (valueType) {
       case 'scalar':
-        if (!val || !['object', 'function'].includes(_typeof(val))) {
+        if (!val || !['object', 'function'].includes(typeof val)) {
           addType = true;
         }
-
         break;
-
       case 'boolean':
       case 'string':
       case 'undefined':
       case 'function':
-        // eslint-disable-next-line valid-typeof
-        if (_typeof(val) === valueType) {
+        if (typeof val === valueType) {
           addType = true;
         }
-
         break;
-
       case 'integer':
         if (Number.isFinite(val) && !(val % 1)) {
           addType = true;
         }
-
         break;
-
       case 'number':
         if (Number.isFinite(val)) {
           addType = true;
         }
-
         break;
-
       case 'nonFinite':
         if (typeof val === 'number' && !Number.isFinite(val)) {
           addType = true;
         }
-
         break;
-
       case 'object':
-        // eslint-disable-next-line valid-typeof
-        if (val && _typeof(val) === valueType) {
+        if (val && typeof val === valueType) {
           addType = true;
         }
-
         break;
-
       case 'array':
         if (Array.isArray(val)) {
           addType = true;
         }
-
         break;
-
       case 'other':
         addType = this.currOtherTypeCallback(val, path, parent, parentPropName);
         break;
-
       case 'null':
         if (val === null) {
           addType = true;
         }
-
         break;
-
       /* c8 ignore next 2 */
-
       default:
         throw new TypeError('Unknown value type ' + valueType);
     }
-
     if (addType) {
       retObj = {
-        path: path,
+        path,
         value: val,
-        parent: parent,
+        parent,
         parentProperty: parentPropName
       };
-
       this._handleCallback(retObj, callback, 'value');
-
       return retObj;
-    } // `-escaped property
-
-  } else if (loc[0] === '`' && val && hasOwnProp.call(val, loc.slice(1))) {
-    var locProp = loc.slice(1);
+    }
+    // `-escaped property
+  } else if (loc[0] === '`' && val && Object.hasOwn(val, loc.slice(1))) {
+    const locProp = loc.slice(1);
     addRet(this._trace(x, val[locProp], push(path, locProp), val, locProp, callback, hasArrExpr, true));
   } else if (loc.includes(',')) {
     // [name1,name2,...]
-    var parts = loc.split(',');
-
-    var _iterator = _createForOfIteratorHelper(parts),
-        _step;
-
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var part = _step.value;
-        addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback, true));
-      } // simple case--directly follow property
-
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+    const parts = loc.split(',');
+    for (const part of parts) {
+      addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback, true));
     }
-  } else if (!literalPriority && val && hasOwnProp.call(val, loc)) {
+    // simple case--directly follow property
+  } else if (!literalPriority && val && Object.hasOwn(val, loc)) {
     addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr, true));
-  } // We check the resulting values for parent selections. For parent
+  }
+
+  // We check the resulting values for parent selections. For parent
   // selections we discard the value object and continue the trace with the
   // current val object
-
-
   if (this._hasParentSelector) {
-    for (var t = 0; t < ret.length; t++) {
-      var rett = ret[t];
-
+    for (let t = 0; t < ret.length; t++) {
+      const rett = ret[t];
       if (rett && rett.isParentSelector) {
-        var tmp = this._trace(rett.expr, val, rett.path, parent, parentPropName, callback, hasArrExpr);
-
+        const tmp = this._trace(rett.expr, val, rett.path, parent, parentPropName, callback, hasArrExpr);
         if (Array.isArray(tmp)) {
           ret[t] = tmp[0];
-          var tl = tmp.length;
-
-          for (var tt = 1; tt < tl; tt++) {
+          const tl = tmp.length;
+          for (let tt = 1; tt < tl; tt++) {
+            // eslint-disable-next-line @stylistic/max-len -- Long
+            // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient
             t++;
             ret.splice(t, 0, tmp[tt]);
           }
@@ -9727,164 +10823,173 @@ JSONPath.prototype._trace = function (expr, val, path, parent, parentPropName, c
       }
     }
   }
-
   return ret;
 };
-
 JSONPath.prototype._walk = function (val, f) {
   if (Array.isArray(val)) {
-    var n = val.length;
-
-    for (var i = 0; i < n; i++) {
+    const n = val.length;
+    for (let i = 0; i < n; i++) {
       f(i);
     }
-  } else if (val && _typeof(val) === 'object') {
-    Object.keys(val).forEach(function (m) {
+  } else if (val && typeof val === 'object') {
+    Object.keys(val).forEach(m => {
       f(m);
     });
   }
 };
-
 JSONPath.prototype._slice = function (loc, expr, val, path, parent, parentPropName, callback) {
   if (!Array.isArray(val)) {
     return undefined;
   }
-
-  var len = val.length,
-      parts = loc.split(':'),
-      step = parts[2] && Number.parseInt(parts[2]) || 1;
-  var start = parts[0] && Number.parseInt(parts[0]) || 0,
-      end = parts[1] && Number.parseInt(parts[1]) || len;
+  const len = val.length,
+    parts = loc.split(':'),
+    step = parts[2] && Number.parseInt(parts[2]) || 1;
+  let start = parts[0] && Number.parseInt(parts[0]) || 0,
+    end = parts[1] && Number.parseInt(parts[1]) || len;
   start = start < 0 ? Math.max(0, start + len) : Math.min(len, start);
   end = end < 0 ? Math.max(0, end + len) : Math.min(len, end);
-  var ret = [];
-
-  for (var i = start; i < end; i += step) {
-    var tmp = this._trace(unshift(i, expr), val, path, parent, parentPropName, callback, true); // Should only be possible to be an array here since first part of
+  const ret = [];
+  for (let i = start; i < end; i += step) {
+    const tmp = this._trace(unshift(i, expr), val, path, parent, parentPropName, callback, true);
+    // Should only be possible to be an array here since first part of
     //   ``unshift(i, expr)` passed in above would not be empty, nor `~`,
     //     nor begin with `@` (as could return objects)
     // This was causing excessive stack size in Node (with or
     //  without Babel) against our performance test: `ret.push(...tmp);`
-
-
-    tmp.forEach(function (t) {
+    tmp.forEach(t => {
       ret.push(t);
     });
   }
-
   return ret;
 };
-
 JSONPath.prototype._eval = function (code, _v, _vname, path, parent, parentPropName) {
   this.currSandbox._$_parentProperty = parentPropName;
   this.currSandbox._$_parent = parent;
   this.currSandbox._$_property = _vname;
   this.currSandbox._$_root = this.json;
   this.currSandbox._$_v = _v;
-  var containsPath = code.includes('@path');
-
+  const containsPath = code.includes('@path');
   if (containsPath) {
     this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));
   }
-
-  var scriptCacheKey = 'script:' + code;
-
+  const scriptCacheKey = this.currEval + 'Script:' + code;
   if (!JSONPath.cache[scriptCacheKey]) {
-    var script = code.replace(/@parentProperty/g, '_$_parentProperty').replace(/@parent/g, '_$_parent').replace(/@property/g, '_$_property').replace(/@root/g, '_$_root').replace(/@([\t-\r \)\.\[\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF])/g, '_$_v$1');
-
+    let script = code.replaceAll('@parentProperty', '_$_parentProperty').replaceAll('@parent', '_$_parent').replaceAll('@property', '_$_property').replaceAll('@root', '_$_root').replaceAll(/@([.\s)[])/gu, '_$_v$1');
     if (containsPath) {
-      script = script.replace(/@path/g, '_$_path');
+      script = script.replaceAll('@path', '_$_path');
+    }
+    if (this.currEval === 'safe' || this.currEval === true || this.currEval === undefined) {
+      JSONPath.cache[scriptCacheKey] = new this.safeVm.Script(script);
+    } else if (this.currEval === 'native') {
+      JSONPath.cache[scriptCacheKey] = new this.vm.Script(script);
+    } else if (typeof this.currEval === 'function' && this.currEval.prototype && Object.hasOwn(this.currEval.prototype, 'runInNewContext')) {
+      const CurrEval = this.currEval;
+      JSONPath.cache[scriptCacheKey] = new CurrEval(script);
+    } else if (typeof this.currEval === 'function') {
+      JSONPath.cache[scriptCacheKey] = {
+        runInNewContext: context => this.currEval(script, context)
+      };
+    } else {
+      throw new TypeError(`Unknown "eval" property "${this.currEval}"`);
     }
-
-    JSONPath.cache[scriptCacheKey] = new this.vm.Script(script);
   }
-
   try {
     return JSONPath.cache[scriptCacheKey].runInNewContext(this.currSandbox);
   } catch (e) {
+    if (this.ignoreEvalErrors) {
+      return false;
+    }
     throw new Error('jsonPath: ' + e.message + ': ' + code);
   }
-}; // PUBLIC CLASS PROPERTIES AND METHODS
-// Could store the cache object itself
+};
 
+// PUBLIC CLASS PROPERTIES AND METHODS
 
+// Could store the cache object itself
 JSONPath.cache = {};
+
 /**
  * @param {string[]} pathArr Array to convert
  * @returns {string} The path string
  */
-
 JSONPath.toPathString = function (pathArr) {
-  var x = pathArr,
-      n = x.length;
-  var p = '$';
-
-  for (var i = 1; i < n; i++) {
-    if (!/^(~|\^|@(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?\(\))$/.test(x[i])) {
-      p += /^[\*0-9]+$/.test(x[i]) ? '[' + x[i] + ']' : "['" + x[i] + "']";
+  const x = pathArr,
+    n = x.length;
+  let p = '$';
+  for (let i = 1; i < n; i++) {
+    if (!/^(~|\^|@.*?\(\))$/u.test(x[i])) {
+      p += /^[0-9*]+$/u.test(x[i]) ? '[' + x[i] + ']' : "['" + x[i] + "']";
     }
   }
-
   return p;
 };
+
 /**
  * @param {string} pointer JSON Path
  * @returns {string} JSON Pointer
  */
-
-
 JSONPath.toPointer = function (pointer) {
-  var x = pointer,
-      n = x.length;
-  var p = '';
-
-  for (var i = 1; i < n; i++) {
-    if (!/^(~|\^|@(?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?\(\))$/.test(x[i])) {
-      p += '/' + x[i].toString().replace(/~/g, '~0').replace(/\//g, '~1');
+  const x = pointer,
+    n = x.length;
+  let p = '';
+  for (let i = 1; i < n; i++) {
+    if (!/^(~|\^|@.*?\(\))$/u.test(x[i])) {
+      p += '/' + x[i].toString().replaceAll('~', '~0').replaceAll('/', '~1');
     }
   }
-
   return p;
 };
+
 /**
  * @param {string} expr Expression to convert
  * @returns {string[]}
  */
-
-
 JSONPath.toPathArray = function (expr) {
-  var cache = JSONPath.cache;
-
+  const {
+    cache
+  } = JSONPath;
   if (cache[expr]) {
     return cache[expr].concat();
   }
-
-  var subx = [];
-  var normalized = expr // Properties
-  .replace(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\(\)/g, ';$&;') // Parenthetical evaluations (filtering and otherwise), directly
+  const subx = [];
+  const normalized = expr
+  // Properties
+  .replaceAll(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\(\)/gu, ';$&;')
+  // Parenthetical evaluations (filtering and otherwise), directly
   //   within brackets or single quotes
-  .replace(/['\[](\??\((?:[\0-\t\x0B\f\x0E-\u2027\u202A-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*?\))['\]]/g, function ($0, $1) {
+  .replaceAll(/[['](\??\(.*?\))[\]'](?!.\])/gu, function ($0, $1) {
     return '[#' + (subx.push($1) - 1) + ']';
-  }) // Escape periods and tildes within properties
-  .replace(/\[["']((?:(?!['\]])[\s\S])*)["']\]/g, function ($0, prop) {
-    return "['" + prop.replace(/\./g, '%@%').replace(/~/g, '%%@@%%') + "']";
-  }) // Properties operator
-  .replace(/~/g, ';~;') // Split by property boundaries
-  .replace(/["']?\.["']?(?!(?:(?!\[)[\s\S])*\])|\[["']?/g, ';') // Reinsert periods within properties
-  .replace(/%@%/g, '.') // Reinsert tildes within properties
-  .replace(/%%@@%%/g, '~') // Parent
-  .replace(/(?:;)?(\^+)(?:;)?/g, function ($0, ups) {
+  })
+  // Escape periods and tildes within properties
+  .replaceAll(/\[['"]([^'\]]*)['"]\]/gu, function ($0, prop) {
+    return "['" + prop.replaceAll('.', '%@%').replaceAll('~', '%%@@%%') + "']";
+  })
+  // Properties operator
+  .replaceAll('~', ';~;')
+  // Split by property boundaries
+  .replaceAll(/['"]?\.['"]?(?![^[]*\])|\[['"]?/gu, ';')
+  // Reinsert periods within properties
+  .replaceAll('%@%', '.')
+  // Reinsert tildes within properties
+  .replaceAll('%%@@%%', '~')
+  // Parent
+  .replaceAll(/(?:;)?(\^+)(?:;)?/gu, function ($0, ups) {
     return ';' + ups.split('').join(';') + ';';
-  }) // Descendents
-  .replace(/;;;|;;/g, ';..;') // Remove trailing
-  .replace(/;$|'?\]|'$/g, '');
-  var exprList = normalized.split(';').map(function (exp) {
-    var match = exp.match(/#([0-9]+)/);
+  })
+  // Descendents
+  .replaceAll(/;;;|;;/gu, ';..;')
+  // Remove trailing
+  .replaceAll(/;$|'?\]|'$/gu, '');
+  const exprList = normalized.split(';').map(function (exp) {
+    const match = exp.match(/#(\d+)/u);
     return !match || !match[1] ? exp : subx[match[1]];
   });
   cache[expr] = exprList;
   return cache[expr].concat();
 };
+JSONPath.prototype.safeVm = {
+  Script: SafeScript
+};
 
 /**
  * @typedef {any} ContextItem
@@ -9908,83 +11013,73 @@ JSONPath.toPathArray = function (expr) {
  *     will move item if evaluates to `true`
  * @returns {void}
  */
-
-var moveToAnotherArray = function moveToAnotherArray(source, target, conditionCb) {
-  var il = source.length;
-
-  for (var i = 0; i < il; i++) {
-    var item = source[i];
-
+const moveToAnotherArray = function (source, target, conditionCb) {
+  const il = source.length;
+  for (let i = 0; i < il; i++) {
+    const item = source[i];
     if (conditionCb(item)) {
+      // eslint-disable-next-line @stylistic/max-len -- Long
+      // eslint-disable-next-line sonarjs/updated-loop-counter -- Convenient
       target.push(source.splice(i--, 1)[0]);
     }
   }
 };
+
 /**
  * In-browser replacement for NodeJS' VM.Script.
  */
-
-
-var Script = /*#__PURE__*/function () {
+class Script {
   /**
    * @param {string} expr Expression to evaluate
    */
-  function Script(expr) {
-    _classCallCheck(this, Script);
-
+  constructor(expr) {
     this.code = expr;
   }
+
   /**
-   * @param {PlainObject} context Object whose items will be added
+   * @param {object} context Object whose items will be added
    *   to evaluation
    * @returns {EvaluatedResult} Result of evaluated code
    */
+  runInNewContext(context) {
+    let expr = this.code;
+    const keys = Object.keys(context);
+    const funcs = [];
+    moveToAnotherArray(keys, funcs, key => {
+      return typeof context[key] === 'function';
+    });
+    const values = keys.map(vr => {
+      return context[vr];
+    });
+    const funcString = funcs.reduce((s, func) => {
+      let fString = context[func].toString();
+      if (!/function/u.test(fString)) {
+        fString = 'function ' + fString;
+      }
+      return 'var ' + func + '=' + fString + ';' + s;
+    }, '');
+    expr = funcString + expr;
 
-
-  _createClass(Script, [{
-    key: "runInNewContext",
-    value: function runInNewContext(context) {
-      var expr = this.code;
-      var keys = Object.keys(context);
-      var funcs = [];
-      moveToAnotherArray(keys, funcs, function (key) {
-        return typeof context[key] === 'function';
-      });
-      var values = keys.map(function (vr, i) {
-        return context[vr];
-      });
-      var funcString = funcs.reduce(function (s, func) {
-        var fString = context[func].toString();
-
-        if (!/function/.test(fString)) {
-          fString = 'function ' + fString;
-        }
-
-        return 'var ' + func + '=' + fString + ';' + s;
-      }, '');
-      expr = funcString + expr; // Mitigate http://perfectionkills.com/global-eval-what-are-the-options/#new_function
-
-      if (!/(["'])use strict\1/.test(expr) && !keys.includes('arguments')) {
-        expr = 'var arguments = undefined;' + expr;
-      } // Remove last semi so `return` will be inserted before
-      //  the previous one instead, allowing for the return
-      //  of a bare ending expression
-
-
-      expr = expr.replace(/;[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*$/, ''); // Insert `return`
-
-      var lastStatementEnd = expr.lastIndexOf(';');
-      var code = lastStatementEnd > -1 ? expr.slice(0, lastStatementEnd + 1) + ' return ' + expr.slice(lastStatementEnd + 1) : ' return ' + expr; // eslint-disable-next-line no-new-func
-
-      return _construct(Function, keys.concat([code])).apply(void 0, _toConsumableArray(values));
+    // Mitigate http://perfectionkills.com/global-eval-what-are-the-options/#new_function
+    if (!/(['"])use strict\1/u.test(expr) && !keys.includes('arguments')) {
+      expr = 'var arguments = undefined;' + expr;
     }
-  }]);
 
-  return Script;
-}();
+    // Remove last semi so `return` will be inserted before
+    //  the previous one instead, allowing for the return
+    //  of a bare ending expression
+    expr = expr.replace(/;\s*$/u, '');
+
+    // Insert `return`
+    const lastStatementEnd = expr.lastIndexOf(';');
+    const code = lastStatementEnd !== -1 ? expr.slice(0, lastStatementEnd + 1) + ' return ' + expr.slice(lastStatementEnd + 1) : ' return ' + expr;
 
+    // eslint-disable-next-line no-new-func -- User's choice
+    return new Function(...keys, code)(...values);
+  }
+}
 JSONPath.prototype.vm = {
-  Script: Script
+  Script
 };
 
 
@@ -14025,7 +15120,7 @@ var type = /*#__PURE__*/(0,_internal_curry1_js__WEBPACK_IMPORTED_MODULE_0__["def
 
 /***/ }),
 
-/***/ 7951:
+/***/ 331:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14039,7 +15134,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   mergeAll: () => (/* binding */ mergeAll),
 /* harmony export */   visit: () => (/* binding */ visit)
 /* harmony export */ });
-/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2449);
+/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4641);
 
 
 /**
@@ -14048,8 +15143,11 @@ __webpack_require__.r(__webpack_exports__);
  * SPDX-License-Identifier: MIT
  */
 
-// getVisitFn :: (Visitor, String, Boolean) -> Function
+/**
+ * @public
+ */
 const getVisitFn = (visitor, type, isLeaving) => {
+  // @ts-ignore
   const typeVisitor = visitor[type];
   if (typeVisitor != null) {
     if (!isLeaving && typeof typeVisitor === 'function') {
@@ -14068,6 +15166,7 @@ const getVisitFn = (visitor, type, isLeaving) => {
         // { enter() {}, leave() {} }
         return specificVisitor;
       }
+      // @ts-ignore
       const specificTypeVisitor = specificVisitor[type];
       if (typeof specificTypeVisitor === 'function') {
         // { enter: { Type() {} }, leave: { Type() {} } }
@@ -14077,15 +15176,25 @@ const getVisitFn = (visitor, type, isLeaving) => {
   }
   return null;
 };
+
+/**
+ * @public
+ */
 const BREAK = {};
 
-// getNodeType :: Node -> String
+/**
+ * @public
+ */
 const getNodeType = node => node === null || node === void 0 ? void 0 : node.type;
 
-// isNode :: Node -> Boolean
+/**
+ * @public
+ */
 const isNode = node => typeof getNodeType(node) === 'string';
 
-// cloneNode :: a -> a
+/**
+ * @public
+ */
 const cloneNode = node => Object.create(Object.getPrototypeOf(node), Object.getOwnPropertyDescriptors(node));
 
 /**
@@ -14094,8 +15203,16 @@ const cloneNode = node => Object.create(Object.getPrototypeOf(node), Object.getO
  *
  * If a prior visitor edits a node, no following visitors will see that node.
  * `exposeEdits=true` can be used to expose the edited node from the previous visitors.
+ * @public
+ */
+
+/**
+ * @public
  */
 
+/**
+ * @public
+ */
 const mergeAll = (visitors, {
   visitFnGetter = getVisitFn,
   nodeTypeGetter = getNodeType,
@@ -14277,9 +15394,11 @@ mergeAll[Symbol.for('nodejs.util.promisify.custom')] = mergeAllAsync;
  * a new version of the AST with the changes applied will be returned from the
  * visit function.
  *
+ * @example
+ * ```
  *     const editedAST = visit(ast, {
  *       enter(node, key, parent, path, ancestors) {
- *         // @return
+ *         // return
  *         //   undefined: no action
  *         //   false: skip visiting this node
  *         //   BREAK: stop visiting altogether
@@ -14287,7 +15406,7 @@ mergeAll[Symbol.for('nodejs.util.promisify.custom')] = mergeAllAsync;
  *         //   any value: replace this node with the returned value
  *       },
  *       leave(node, key, parent, path, ancestors) {
- *         // @return
+ *         // return
  *         //   undefined: no action
  *         //   false: no action
  *         //   BREAK: stop visiting altogether
@@ -14295,23 +15414,23 @@ mergeAll[Symbol.for('nodejs.util.promisify.custom')] = mergeAllAsync;
  *         //   any value: replace this node with the returned value
  *       }
  *     });
- *
+ *```
  * Alternatively to providing enter() and leave() functions, a visitor can
  * instead provide functions named the same as the kinds of AST nodes, or
  * enter/leave visitors at a named key, leading to four permutations of
  * visitor API:
  *
  * 1) Named visitors triggered when entering a node a specific kind.
- *
+ * ```
  *     visit(ast, {
  *       Kind(node) {
  *         // enter the "Kind" node
  *       }
  *     })
- *
+ * ```
  * 2) Named visitors that trigger upon entering and leaving a node of
  *    a specific kind.
- *
+ * ```
  *     visit(ast, {
  *       Kind: {
  *         enter(node) {
@@ -14322,9 +15441,9 @@ mergeAll[Symbol.for('nodejs.util.promisify.custom')] = mergeAllAsync;
  *         }
  *       }
  *     })
- *
+ * ```
  * 3) Generic visitors that trigger upon entering and leaving any node.
- *
+ * ```
  *     visit(ast, {
  *       enter(node) {
  *         // enter any node
@@ -14333,9 +15452,9 @@ mergeAll[Symbol.for('nodejs.util.promisify.custom')] = mergeAllAsync;
  *         // leave any node
  *       }
  *     })
- *
+ * ```
  * 4) Parallel visitors for entering and leaving nodes of a specific kind.
- *
+ * ```
  *     visit(ast, {
  *       enter: {
  *         Kind(node) {
@@ -14348,9 +15467,12 @@ mergeAll[Symbol.for('nodejs.util.promisify.custom')] = mergeAllAsync;
  *         }
  *       }
  *     })
+ * ```
+ *  sig `visit :: (Node, Visitor, Options)`
  *
- *  @sig visit :: (Node, Visitor, Options)
- *  @sig      Options = { keyMap: Object, state: Object }
+ *  sig `Options = { keyMap: Object, state: Object }`
+ *
+ *  @public
  */
 const visit = (
 // @ts-ignore
@@ -14690,7 +15812,7 @@ visitor, {
 
 /***/ }),
 
-/***/ 1244:
+/***/ 3757:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14698,8 +15820,16 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2449);
+/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4641);
+
+
+/**
+ * @public
+ */
 
+/**
+ * @public
+ */
 class CloneError extends _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__["default"] {
   value;
   constructor(message, structuredOptions) {
@@ -14713,7 +15843,7 @@ class CloneError extends _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__[
 
 /***/ }),
 
-/***/ 426:
+/***/ 9112:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14721,14 +15851,17 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _CloneError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1244);
+/* harmony import */ var _CloneError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3757);
 
+/**
+ * @public
+ */
 class DeepCloneError extends _CloneError_mjs__WEBPACK_IMPORTED_MODULE_0__["default"] {}
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (DeepCloneError);
 
 /***/ }),
 
-/***/ 8774:
+/***/ 6500:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14736,14 +15869,17 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _CloneError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1244);
+/* harmony import */ var _CloneError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3757);
 
+/**
+ * @public
+ */
 class ShallowCloneError extends _CloneError_mjs__WEBPACK_IMPORTED_MODULE_0__["default"] {}
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ShallowCloneError);
 
 /***/ }),
 
-/***/ 4831:
+/***/ 6941:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14753,13 +15889,22 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   cloneShallow: () => (/* binding */ cloneShallow)
 /* harmony export */ });
 /* harmony import */ var minim__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8326);
-/* harmony import */ var _predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(60);
-/* harmony import */ var _errors_DeepCloneError_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(426);
-/* harmony import */ var _errors_ShallowCloneError_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(8774);
+/* harmony import */ var _predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(726);
+/* harmony import */ var _errors_DeepCloneError_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9112);
+/* harmony import */ var _errors_ShallowCloneError_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6500);
 
 
 
 
+/**
+ * @public
+ */
+/**
+ * @public
+ */
+/**
+ * @public
+ */
 const cloneDeep = (value, options = {}) => {
   const {
     visited = new WeakMap()
@@ -14870,6 +16015,9 @@ const cloneShallowElement = element => {
 };
 /* eslint-enable */
 
+/**
+ * @public
+ */
 const cloneShallow = value => {
   if (value instanceof minim__WEBPACK_IMPORTED_MODULE_0__.KeyValuePair) {
     return cloneShallowKeyValuePair(value);
@@ -14897,7 +16045,7 @@ cloneShallow.safe = value => {
 
 /***/ }),
 
-/***/ 1460:
+/***/ 4102:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14907,6 +16055,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var minim__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8326);
 
+
+/**
+ * @public
+ */
 class Annotation extends minim__WEBPACK_IMPORTED_MODULE_0__.StringElement {
   // classes: warning | error
 
@@ -14925,7 +16077,7 @@ class Annotation extends minim__WEBPACK_IMPORTED_MODULE_0__.StringElement {
 
 /***/ }),
 
-/***/ 5534:
+/***/ 68:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14935,6 +16087,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var minim__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8326);
 
+
+/**
+ * @public
+ */
 class Comment extends minim__WEBPACK_IMPORTED_MODULE_0__.StringElement {
   constructor(content, meta, attributes) {
     super(content, meta, attributes);
@@ -14945,7 +16101,7 @@ class Comment extends minim__WEBPACK_IMPORTED_MODULE_0__.StringElement {
 
 /***/ }),
 
-/***/ 6439:
+/***/ 8737:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14957,6 +16113,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3031);
 
 
+
+/**
+ * @public
+ */
 class ParseResult extends minim__WEBPACK_IMPORTED_MODULE_0__.ArrayElement {
   constructor(content, meta, attributes) {
     super(content, meta, attributes);
@@ -15004,7 +16164,7 @@ class ParseResult extends minim__WEBPACK_IMPORTED_MODULE_0__.ArrayElement {
 
 /***/ }),
 
-/***/ 2738:
+/***/ 1364:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15014,6 +16174,18 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var minim__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8326);
 
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
 class SourceMap extends minim__WEBPACK_IMPORTED_MODULE_0__.ArrayElement {
   constructor(content, meta, attributes) {
     super(content, meta, attributes);
@@ -15040,33 +16212,89 @@ class SourceMap extends minim__WEBPACK_IMPORTED_MODULE_0__.ArrayElement {
 
 /***/ }),
 
-/***/ 1787:
+/***/ 145:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
-/* harmony export */   isElementType: () => (/* binding */ isElementType)
+/* harmony export */   hasBasicElementProps: () => (/* binding */ hasBasicElementProps),
+/* harmony export */   hasClass: () => (/* binding */ hasClass),
+/* harmony export */   hasMethod: () => (/* binding */ hasMethod),
+/* harmony export */   isElementType: () => (/* binding */ isElementType),
+/* harmony export */   primitiveEq: () => (/* binding */ primitiveEq)
 /* harmony export */ });
 /* harmony import */ var minim__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8326);
 
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
 const hasMethod = (name, element) => {
   return typeof element === 'object' && element !== null && name in element && typeof element[name] === 'function';
 };
+
+/**
+ * @public
+ */
 const hasBasicElementProps = element => typeof element === 'object' && element != null && '_storedElement' in element && typeof element._storedElement === 'string' &&
 // eslint-disable-line no-underscore-dangle
 '_content' in element;
+
+/**
+ * @public
+ */
 const primitiveEq = (val, element) => {
   if (typeof element === 'object' && element !== null && 'primitive' in element) {
     return typeof element.primitive === 'function' && element.primitive() === val;
   }
   return false;
 };
+
+/**
+ * @public
+ */
 const hasClass = (cls, element) => {
   return typeof element === 'object' && element !== null && 'classes' in element && (Array.isArray(element.classes) || element.classes instanceof minim__WEBPACK_IMPORTED_MODULE_0__.ArrayElement) && element.classes.includes(cls);
 };
+
+/**
+ * @public
+ */
 const isElementType = (name, element) => typeof element === 'object' && element !== null && 'element' in element && element.element === name;
+
+/**
+ * @public
+ */
 const createPredicate = predicateCreator => {
   return predicateCreator({
     hasMethod,
@@ -15080,7 +16308,7 @@ const createPredicate = predicateCreator => {
 
 /***/ }),
 
-/***/ 60:
+/***/ 726:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15108,11 +16336,11 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var minim__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8326);
 /* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(5380);
 /* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(3699);
-/* harmony import */ var _elements_Annotation_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1460);
-/* harmony import */ var _elements_Comment_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5534);
-/* harmony import */ var _elements_ParseResult_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6439);
-/* harmony import */ var _elements_SourceMap_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2738);
-/* harmony import */ var _helpers_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1787);
+/* harmony import */ var _elements_Annotation_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4102);
+/* harmony import */ var _elements_Comment_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(68);
+/* harmony import */ var _elements_ParseResult_mjs__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(8737);
+/* harmony import */ var _elements_SourceMap_mjs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(1364);
+/* harmony import */ var _helpers_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(145);
 
 
 
@@ -15121,36 +16349,59 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+/**
+ * @public
+ */
 const isElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   primitiveEq
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.Element || hasBasicElementProps(element) && primitiveEq(undefined, element);
 });
+
+/**
+ * @public
+ */
 const isStringElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   primitiveEq
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.StringElement || hasBasicElementProps(element) && primitiveEq('string', element);
 });
+
+/**
+ * @public
+ */
 const isNumberElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   primitiveEq
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.NumberElement || hasBasicElementProps(element) && primitiveEq('number', element);
 });
+
+/**
+ * @public
+ */
 const isNullElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   primitiveEq
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.NullElement || hasBasicElementProps(element) && primitiveEq('null', element);
 });
+
+/**
+ * @public
+ */
 const isBooleanElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   primitiveEq
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.BooleanElement || hasBasicElementProps(element) && primitiveEq('boolean', element);
 });
+
+/**
+ * @public
+ */
 const isObjectElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   primitiveEq,
@@ -15158,6 +16409,10 @@ const isObjectElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.ObjectElement || hasBasicElementProps(element) && primitiveEq('object', element) && hasMethod('keys', element) && hasMethod('values', element) && hasMethod('items', element);
 });
+
+/**
+ * @public
+ */
 const isArrayElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   primitiveEq,
@@ -15165,6 +16420,10 @@ const isArrayElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.ArrayElement && !(element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.ObjectElement) || hasBasicElementProps(element) && primitiveEq('array', element) && hasMethod('push', element) && hasMethod('unshift', element) && hasMethod('map', element) && hasMethod('reduce', element);
 });
+
+/**
+ * @public
+ */
 const isMemberElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   isElementType,
@@ -15172,6 +16431,10 @@ const isMemberElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.MemberElement || hasBasicElementProps(element) && isElementType('member', element) && primitiveEq(undefined, element);
 });
+
+/**
+ * @public
+ */
 const isLinkElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   isElementType,
@@ -15179,6 +16442,10 @@ const isLinkElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])((
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.LinkElement || hasBasicElementProps(element) && isElementType('link', element) && primitiveEq(undefined, element);
 });
+
+/**
+ * @public
+ */
 const isRefElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   isElementType,
@@ -15186,6 +16453,10 @@ const isRefElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
 }) => {
   return element => element instanceof minim__WEBPACK_IMPORTED_MODULE_0__.RefElement || hasBasicElementProps(element) && isElementType('ref', element) && primitiveEq(undefined, element);
 });
+
+/**
+ * @public
+ */
 const isAnnotationElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   isElementType,
@@ -15193,6 +16464,10 @@ const isAnnotationElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["defaul
 }) => {
   return element => element instanceof _elements_Annotation_mjs__WEBPACK_IMPORTED_MODULE_2__["default"] || hasBasicElementProps(element) && isElementType('annotation', element) && primitiveEq('array', element);
 });
+
+/**
+ * @public
+ */
 const isCommentElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   isElementType,
@@ -15200,6 +16475,10 @@ const isCommentElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"]
 }) => {
   return element => element instanceof _elements_Comment_mjs__WEBPACK_IMPORTED_MODULE_3__["default"] || hasBasicElementProps(element) && isElementType('comment', element) && primitiveEq('string', element);
 });
+
+/**
+ * @public
+ */
 const isParseResultElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   isElementType,
@@ -15207,6 +16486,10 @@ const isParseResultElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["defau
 }) => {
   return element => element instanceof _elements_ParseResult_mjs__WEBPACK_IMPORTED_MODULE_4__["default"] || hasBasicElementProps(element) && isElementType('parseResult', element) && primitiveEq('array', element);
 });
+
+/**
+ * @public
+ */
 const isSourceMapElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default"])(({
   hasBasicElementProps,
   isElementType,
@@ -15214,12 +16497,28 @@ const isSourceMapElement = (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__["default
 }) => {
   return element => element instanceof _elements_SourceMap_mjs__WEBPACK_IMPORTED_MODULE_5__["default"] || hasBasicElementProps(element) && isElementType('sourceMap', element) && primitiveEq('array', element);
 });
+
+/**
+ * @public
+ */
+
+/**
+ * @public
+ */
 const isPrimitiveElement = element => {
   return (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__.isElementType)('object', element) || (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__.isElementType)('array', element) || (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__.isElementType)('boolean', element) || (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__.isElementType)('number', element) || (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__.isElementType)('string', element) || (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__.isElementType)('null', element) || (0,_helpers_mjs__WEBPACK_IMPORTED_MODULE_1__.isElementType)('member', element);
 };
+
+/**
+ * @public
+ */
 const hasElementSourceMap = element => {
   return isSourceMapElement(element.meta.get('sourceMap'));
 };
+
+/**
+ * @public
+ */
 const includesSymbols = (symbols, element) => {
   if (symbols.length === 0) {
     return true;
@@ -15230,6 +16529,10 @@ const includesSymbols = (symbols, element) => {
   }
   return (0,ramda__WEBPACK_IMPORTED_MODULE_6__["default"])((0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_7__["default"])(elementSymbols.toValue()), symbols);
 };
+
+/**
+ * @public
+ */
 const includesClasses = (classes, element) => {
   if (classes.length === 0) {
     return true;
@@ -15239,7 +16542,7 @@ const includesClasses = (classes, element) => {
 
 /***/ }),
 
-/***/ 5330:
+/***/ 2136:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15267,7 +16570,7 @@ class EphemeralArray {
 
 /***/ }),
 
-/***/ 1234:
+/***/ 2324:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15294,7 +16597,7 @@ class EphemeralObject {
 
 /***/ }),
 
-/***/ 1514:
+/***/ 1776:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15302,10 +16605,10 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _visitor_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9872);
-/* harmony import */ var _ast_ephemeral_array_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5330);
-/* harmony import */ var _ast_ephemeral_object_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1234);
-/* harmony import */ var _predicates_index_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(60);
+/* harmony import */ var _visitor_mjs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(162);
+/* harmony import */ var _ast_ephemeral_array_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2136);
+/* harmony import */ var _ast_ephemeral_object_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2324);
+/* harmony import */ var _predicates_index_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(726);
 
 
 
@@ -15375,6 +16678,9 @@ class Visitor {
     return '';
   }
 }
+/**
+ * @public
+ */
 const serializer = element => {
   if (!(0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_2__.isElement)(element)) return element;
 
@@ -15388,7 +16694,7 @@ const serializer = element => {
 
 /***/ }),
 
-/***/ 9872:
+/***/ 162:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15397,7 +16703,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   visit: () => (/* binding */ visit)
 /* harmony export */ });
 /* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3679);
-/* harmony import */ var _traversal_visitor_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5956);
+/* harmony import */ var _traversal_visitor_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7258);
 
 
 const nodeTypeGetter = node => {
@@ -15450,7 +16756,7 @@ visit[Symbol.for('nodejs.util.promisify.custom')] = async (root, {
 
 /***/ }),
 
-/***/ 5956:
+/***/ 7258:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15468,9 +16774,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(7567);
 /* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(8833);
 /* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(5102);
-/* harmony import */ var _swagger_api_apidom_ast__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7951);
-/* harmony import */ var _predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(60);
-/* harmony import */ var _clone_index_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4831);
+/* harmony import */ var _swagger_api_apidom_ast__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(331);
+/* harmony import */ var _predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(726);
+/* harmony import */ var _clone_index_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6941);
 
 
 
@@ -15478,7 +16784,9 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-// getNodeType :: Node -> String
+/**
+ * @public
+ */
 const getNodeType = element => {
   /*
    * We're translating every possible higher element type to primitive minim type here.
@@ -15490,7 +16798,9 @@ const getNodeType = element => {
   return (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isObjectElement)(element) ? 'ObjectElement' : (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isArrayElement)(element) ? 'ArrayElement' : (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isMemberElement)(element) ? 'MemberElement' : (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isStringElement)(element) ? 'StringElement' : (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isBooleanElement)(element) ? 'BooleanElement' : (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isNumberElement)(element) ? 'NumberElement' : (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isNullElement)(element) ? 'NullElement' : (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isLinkElement)(element) ? 'LinkElement' : (0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isRefElement)(element) ? 'RefElement' : undefined;
 };
 
-// cloneNode :: a -> a
+/**
+ * @public
+ */
 const cloneNode = node => {
   if ((0,_predicates_index_mjs__WEBPACK_IMPORTED_MODULE_1__.isElement)(node)) {
     return (0,_clone_index_mjs__WEBPACK_IMPORTED_MODULE_2__.cloneShallow)(node);
@@ -15500,6 +16810,10 @@ const cloneNode = node => {
 
 // isNode :: Node -> Boolean
 const isNode = (0,ramda__WEBPACK_IMPORTED_MODULE_3__["default"])(getNodeType, ramda_adjunct__WEBPACK_IMPORTED_MODULE_4__["default"]);
+
+/**
+ * @public
+ */
 const keyMapDefault = {
   ObjectElement: ['content'],
   ArrayElement: ['content'],
@@ -15538,6 +16852,10 @@ class PredicateVisitor {
     return this.returnOnFalse;
   }
 }
+
+/**
+ * @public
+ */
 const visit = (root,
 // @ts-ignore
 visitor, {
@@ -15577,7 +16895,7 @@ visitor, {
 
 /***/ }),
 
-/***/ 6173:
+/***/ 3437:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15587,6 +16905,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var _babel_runtime_corejs3_core_js_aggregate_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1212);
 
+/**
+ * @public
+ */
 class ApiDOMAggregateError extends _babel_runtime_corejs3_core_js_aggregate_error__WEBPACK_IMPORTED_MODULE_0__ {
   constructor(errors, message, options) {
     super(errors, message, options);
@@ -15619,7 +16940,7 @@ class ApiDOMAggregateError extends _babel_runtime_corejs3_core_js_aggregate_erro
 
 /***/ }),
 
-/***/ 5262:
+/***/ 6126:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15627,8 +16948,11 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _ApiDOMAggregateError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6173);
+/* harmony import */ var _ApiDOMAggregateError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3437);
 
+/**
+ * @public
+ */
 class ApiDOMError extends Error {
   static [Symbol.hasInstance](instance) {
     // we want to ApiDOMAggregateError to act as if ApiDOMError was its superclass
@@ -15665,7 +16989,7 @@ class ApiDOMError extends Error {
 
 /***/ }),
 
-/***/ 2449:
+/***/ 4641:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15673,8 +16997,11 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _ApiDOMError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5262);
+/* harmony import */ var _ApiDOMError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6126);
 
+/**
+ * @public
+ */
 class ApiDOMStructuredError extends _ApiDOMError_mjs__WEBPACK_IMPORTED_MODULE_0__["default"] {
   constructor(message, structuredOptions) {
     super(message, structuredOptions);
@@ -15691,7 +17018,7 @@ class ApiDOMStructuredError extends _ApiDOMError_mjs__WEBPACK_IMPORTED_MODULE_0_
 
 /***/ }),
 
-/***/ 4659:
+/***/ 2131:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15699,8 +17026,14 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _JsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9249);
+/* harmony import */ var _JsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9217);
 
+/**
+ * @public
+ */
+/**
+ * @public
+ */
 class EvaluationJsonPointerError extends _JsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_0__["default"] {
   pointer;
   tokens;
@@ -15724,7 +17057,7 @@ class EvaluationJsonPointerError extends _JsonPointerError_mjs__WEBPACK_IMPORTED
 
 /***/ }),
 
-/***/ 9060:
+/***/ 2900:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15732,8 +17065,14 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _JsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9249);
+/* harmony import */ var _JsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9217);
 
+/**
+ * @public
+ */
+/**
+ * @public
+ */
 class InvalidJsonPointerError extends _JsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_0__["default"] {
   pointer;
   constructor(message, structuredOptions) {
@@ -15747,7 +17086,7 @@ class InvalidJsonPointerError extends _JsonPointerError_mjs__WEBPACK_IMPORTED_MO
 
 /***/ }),
 
-/***/ 9249:
+/***/ 9217:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15755,14 +17094,18 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2449);
+/* harmony import */ var _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4641);
 
+
+/**
+ * @public
+ */
 class JsonPointerError extends _swagger_api_apidom_error__WEBPACK_IMPORTED_MODULE_0__["default"] {}
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (JsonPointerError);
 
 /***/ }),
 
-/***/ 1581:
+/***/ 7453:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15771,14 +17114,18 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
 /* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6201);
-/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4831);
-/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(60);
-/* harmony import */ var _parse_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8969);
-/* harmony import */ var _errors_EvaluationJsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4659);
+/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6941);
+/* harmony import */ var _swagger_api_apidom_core__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(726);
+/* harmony import */ var _parse_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4409);
+/* harmony import */ var _errors_EvaluationJsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2131);
+
 
 
 
- // evaluates JSON Pointer against ApiDOM fragment
+/**
+ * Evaluates JSON Pointer against ApiDOM fragment.
+ * @public
+ */
 const evaluate = (pointer, element) => {
   let tokens;
   try {
@@ -15831,7 +17178,7 @@ const evaluate = (pointer, element) => {
 
 /***/ }),
 
-/***/ 8969:
+/***/ 4409:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15847,12 +17194,15 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var ramda__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(6561);
 /* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(687);
 /* harmony import */ var ramda_adjunct__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(4988);
-/* harmony import */ var _unescape_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1736);
-/* harmony import */ var _errors_InvalidJsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9060);
+/* harmony import */ var _unescape_mjs__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(7800);
+/* harmony import */ var _errors_InvalidJsonPointerError_mjs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2900);
 
 
 
- // parse :: String -> String[]
+
+/**
+ * @public
+ */
 const parse = pointer => {
   if ((0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_0__["default"])(pointer)) {
     return [];
@@ -15885,7 +17235,9 @@ const getHash = uri => {
   return '#';
 };
 
-// uriToPointer :: String -> String
+/**
+ * @public
+ */
 const uriToPointer = uri => {
   const hash = getHash(uri);
   return (0,ramda_adjunct__WEBPACK_IMPORTED_MODULE_8__["default"])('#', hash);
@@ -15894,7 +17246,7 @@ const uriToPointer = uri => {
 
 /***/ }),
 
-/***/ 1736:
+/***/ 7800:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -15920,7 +17272,9 @@ const safeDecodeURIComponent = encodedURIComponent => {
   }
 };
 
-// unescape :: String -> String
+/**
+ * @public
+ */
 const unescape = (0,ramda__WEBPACK_IMPORTED_MODULE_0__["default"])((0,ramda__WEBPACK_IMPORTED_MODULE_1__["default"])(/~1/g, '/'), (0,ramda__WEBPACK_IMPORTED_MODULE_1__["default"])(/~0/g, '~'), safeDecodeURIComponent);
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (unescape);
 
@@ -16007,20 +17361,21 @@ const unescape = (0,ramda__WEBPACK_IMPORTED_MODULE_0__["default"])((0,ramda__WEB
 /******/ 	
 /************************************************************************/
 var __webpack_exports__ = {};
-// This entry need to be wrapped in an IIFE because it need to be in strict mode.
+// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
 (() => {
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   EvaluationJsonPathError: () => (/* reexport safe */ _errors_EvaluationJsonPathError__WEBPACK_IMPORTED_MODULE_0__["default"]),
-/* harmony export */   MultiEvaluationJsonPathError: () => (/* reexport safe */ _errors_MultiEvaluationJsonPathError__WEBPACK_IMPORTED_MODULE_1__["default"]),
-/* harmony export */   evaluate: () => (/* reexport safe */ _evaluate__WEBPACK_IMPORTED_MODULE_2__["default"]),
-/* harmony export */   evaluateMulti: () => (/* reexport safe */ _evaluate_multi__WEBPACK_IMPORTED_MODULE_3__["default"])
+/* harmony export */   EvaluationJsonPathError: () => (/* reexport safe */ _errors_EvaluationJsonPathError_ts__WEBPACK_IMPORTED_MODULE_0__["default"]),
+/* harmony export */   MultiEvaluationJsonPathError: () => (/* reexport safe */ _errors_MultiEvaluationJsonPathError_ts__WEBPACK_IMPORTED_MODULE_1__["default"]),
+/* harmony export */   evaluate: () => (/* reexport safe */ _evaluate_ts__WEBPACK_IMPORTED_MODULE_2__["default"]),
+/* harmony export */   evaluateMulti: () => (/* reexport safe */ _evaluate_multi_ts__WEBPACK_IMPORTED_MODULE_3__["default"])
 /* harmony export */ });
-/* harmony import */ var _errors_EvaluationJsonPathError__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3424);
-/* harmony import */ var _errors_MultiEvaluationJsonPathError__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(427);
-/* harmony import */ var _evaluate__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1272);
-/* harmony import */ var _evaluate_multi__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6792);
+/* harmony import */ var _errors_EvaluationJsonPathError_ts__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3424);
+/* harmony import */ var _errors_MultiEvaluationJsonPathError_ts__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(427);
+/* harmony import */ var _evaluate_ts__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1272);
+/* harmony import */ var _evaluate_multi_ts__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6792);
+