@devtron-labs/devtron-fe-common-lib 0.0.48 → 0.0.50-beta-1

package/dist/index.js

@@ -4,6 +4,7 @@ var jsxRuntime = require('react/jsx-runtime');
 var React = require('react');
 var ReactDOM = require('react-dom');
 var reactRouterDom = require('react-router-dom');
+var vm = require('vm');
 var RJSF = require('@rjsf/core');
 var RJSFValidator = require('@rjsf/validator-ajv8');
 var utils = require('@rjsf/utils');
@@ -47,7 +48,8 @@ var ROUTES = {
     PROJECT_LIST_MIN: 'team/autocomplete',
     USER_CHECK_ROLE: 'user/check/roles',
     IMAGE_TAGGING: 'app/image-tagging',
-    CD_MATERIAL_GET: 'app/cd-pipeline'
+    CD_MATERIAL_GET: 'app/cd-pipeline',
+    DEPLOYMENT_TEMPLATE_LIST: 'app/template/list'
 };
 exports.KEY_VALUE = void 0;
 (function (KEY_VALUE) {
@@ -279,7 +281,7 @@ var extendStatics = function(d, b) {
     return extendStatics(d, b);
 };
 
-function __extends(d, b) {
+function __extends$1(d, b) {
     if (typeof b !== "function" && b !== null)
         throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
     extendStatics(d, b);
@@ -385,7 +387,7 @@ var ServerError = /** @class */ (function () {
     return ServerError;
 }());
 var ServerErrors = /** @class */ (function (_super) {
-    __extends(ServerErrors, _super);
+    __extends$1(ServerErrors, _super);
     function ServerErrors(obj) {
         var _this = _super.call(this) || this;
         _this.code = obj.code;
@@ -2173,7 +2175,7 @@ eventManager.on(2
 });
 
 var ToastBody = /** @class */ (function (_super) {
-    __extends(ToastBody, _super);
+    __extends$1(ToastBody, _super);
     function ToastBody() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -2183,7 +2185,7 @@ var ToastBody = /** @class */ (function (_super) {
     return ToastBody;
 }(React.Component));
 var ToastBody3 = /** @class */ (function (_super) {
-    __extends(ToastBody3, _super);
+    __extends$1(ToastBody3, _super);
     function ToastBody3() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -2193,7 +2195,7 @@ var ToastBody3 = /** @class */ (function (_super) {
     return ToastBody3;
 }(React.Component));
 var ToastBodyWithButton = /** @class */ (function (_super) {
-    __extends(ToastBodyWithButton, _super);
+    __extends$1(ToastBodyWithButton, _super);
     function ToastBodyWithButton() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -2242,7 +2244,7 @@ function ErrorScreenNotFound() {
 }
 
 var ErrorScreenManager = /** @class */ (function (_super) {
-    __extends(ErrorScreenManager, _super);
+    __extends$1(ErrorScreenManager, _super);
     function ErrorScreenManager() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -2273,7 +2275,7 @@ var ErrorScreenManager = /** @class */ (function (_super) {
     return ErrorScreenManager;
 }(React.Component));
 var ErrorScreenNotAuthorized = /** @class */ (function (_super) {
-    __extends(ErrorScreenNotAuthorized, _super);
+    __extends$1(ErrorScreenNotAuthorized, _super);
     function ErrorScreenNotAuthorized() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -9862,6 +9864,1506 @@ var moment$1 = {
 
 var moment = momentExports;
 
+const {
+  hasOwnProperty: hasOwnProp
+} = Object.prototype;
+/**
+ * @typedef {null|boolean|number|string|PlainObject|GenericArray} JSONObject
+ */
+
+/**
+ * @typedef {any} AnyItem
+ */
+
+/**
+ * @typedef {any} AnyResult
+ */
+
+/**
+ * Copies array and then pushes item into it.
+ * @param {GenericArray} arr Array to copy and into which to push
+ * @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);
+  return arr;
+}
+/**
+ * Copies array and then unshifts item into it.
+ * @param {AnyItem} item Array item to add (to beginning)
+ * @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
+ */
+
+
+class NewError extends Error {
+  /**
+   * @param {AnyResult} value The evaluated scalar value
+   */
+  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';
+  }
+
+}
+/**
+* @typedef {PlainObject} ReturnObject
+* @property {string} path
+* @property {JSONObject} value
+* @property {PlainObject|GenericArray} parent
+* @property {string} parentProperty
+*/
+
+/**
+* @callback JSONPathCallback
+* @param {string|PlainObject} preferredOutput
+* @param {"value"|"property"} type
+* @param {ReturnObject} fullRetObj
+* @returns {void}
+*/
+
+/**
+* @callback OtherTypeCallback
+* @param {JSONObject} val
+* @param {string} path
+* @param {PlainObject|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 {PlainObject} JSONPathOptions
+ * @property {JSON} json
+ * @property {string|string[]} path
+ * @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 {string|null} [parentProperty=null]
+ * @property {JSONPathCallback} [callback]
+ * @property {OtherTypeCallback} [otherTypeCallback] Defaults to
+ *   function which throws on encountering `@other`
+ * @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
+ * @param {JSON} [obj] JSON object to evaluate against
+ * @param {JSONPathCallback} [callback] Passed 3 arguments: 1) desired payload
+ *     per `resultType`, 2) `"value"|"property"`, 3) Full returned object with
+ *     all payloads
+ * @param {OtherTypeCallback} [otherTypeCallback] If `@other()` is at the end
+ *   of one's query, this will be invoked with the value of the item, its
+ *   path, its parent, and its parent's property name, and it should return
+ *   a boolean indicating whether the supplied value belongs to the "other"
+ *   type or not (or it may handle transformations and return `false`).
+ * @returns {JSONPath}
+ * @class
+ */
+
+
+function JSONPath(opts, expr, obj, callback, otherTypeCallback) {
+  // eslint-disable-next-line no-restricted-syntax
+  if (!(this instanceof JSONPath)) {
+    try {
+      return new JSONPath(opts, expr, obj, callback, otherTypeCallback);
+    } catch (e) {
+      if (!e.avoidNew) {
+        throw e;
+      }
+
+      return e.value;
+    }
+  }
+
+  if (typeof opts === 'string') {
+    otherTypeCallback = callback;
+    callback = obj;
+    obj = expr;
+    expr = opts;
+    opts = null;
+  }
+
+  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.sandbox = opts.sandbox || {};
+  this.preventEval = opts.preventEval || false;
+  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) {
+    const args = {
+      path: optObj ? opts.path : expr
+    };
+
+    if (!optObj) {
+      args.json = obj;
+    } else if ('json' in opts) {
+      args.json = opts.json;
+    }
+
+    const ret = this.evaluate(args);
+
+    if (!ret || typeof ret !== 'object') {
+      throw new NewError(ret);
+    }
+
+    return ret;
+  }
+} // PUBLIC METHODS
+
+
+JSONPath.prototype.evaluate = function (expr, json, callback, otherTypeCallback) {
+  let currParent = this.parent,
+      currParentProperty = this.parentProperty;
+  let {
+    flatten,
+    wrap
+  } = this;
+  this.currResultType = this.resultType;
+  this.currPreventEval = this.preventEval;
+  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.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')) {
+      throw new TypeError('You must supply a "json" property when providing an object ' + 'argument to JSONPath.evaluate().');
+    }
+
+    ({
+      json
+    } = expr);
+    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;
+    expr = expr.path;
+  }
+
+  currParent = currParent || null;
+  currParentProperty = currParentProperty || null;
+
+  if (Array.isArray(expr)) {
+    expr = JSONPath.toPathString(expr);
+  }
+
+  if (!expr && expr !== '' || !json) {
+    return undefined;
+  }
+
+  const exprList = JSONPath.toPathArray(expr);
+
+  if (exprList[0] === '$' && exprList.length > 1) {
+    exprList.shift();
+  }
+
+  this._hasParentSelector = null;
+
+  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((rslt, ea) => {
+    const valOrPath = this._getPreferredOutput(ea);
+
+    if (flatten && Array.isArray(valOrPath)) {
+      rslt = rslt.concat(valOrPath);
+    } else {
+      rslt.push(valOrPath);
+    }
+
+    return rslt;
+  }, []);
+}; // PRIVATE METHODS
+
+
+JSONPath.prototype._getPreferredOutput = function (ea) {
+  const resultType = this.currResultType;
+
+  switch (resultType) {
+    case 'all':
+      {
+        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) {
+    const preferredOutput = this._getPreferredOutput(fullRetObj);
+
+    fullRetObj.path = typeof fullRetObj.path === 'string' ? fullRetObj.path : JSONPath.toPathString(fullRetObj.path); // eslint-disable-next-line n/callback-return
+
+    callback(preferredOutput, type, fullRetObj);
+  }
+};
+/**
+ *
+ * @param {string} expr
+ * @param {JSONObject} val
+ * @param {string} path
+ * @param {PlainObject|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) {
+  // No expr to follow? return path and value as the result of
+  //  this trace branch
+  let retObj;
+
+  if (!expr.length) {
+    retObj = {
+      path,
+      value: val,
+      parent,
+      parentProperty: parentPropName,
+      hasArrExpr
+    };
+
+    this._handleCallback(retObj, callback, 'value');
+
+    return retObj;
+  }
+
+  const loc = expr[0],
+        x = expr.slice(1); // We need to gather the return value of recursive trace calls in order to
+  // do the parent sel computation.
+
+  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(t => {
+        ret.push(t);
+      });
+    } else {
+      ret.push(elems);
+    }
+  }
+
+  if ((typeof loc !== 'string' || literalPriority) && val && hasOwnProp.call(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`
+  } else if (loc === '*') {
+    // all child properties
+    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, m => {
+      // We don't join m and x here because we only want parents,
+      //   not scalar values
+      if (typeof val[m] === 'object') {
+        // Keep going with recursive descent on val's
+        //   object children
+        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
+    // ancestor object of val
+
+  } else if (loc === '^') {
+    // This is not a final endpoint, so we do not invoke the callback here
+    this._hasParentSelector = true;
+    return {
+      path: path.slice(0, -1),
+      expr: x,
+      isParentSelector: true
+    };
+  } else if (loc === '~') {
+    // property name
+    retObj = {
+      path: push(path, loc),
+      value: parentPropName,
+      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 (/^(-?\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) {
+      throw new Error('Eval [?(expr)] prevented in JSONPath expression.');
+    }
+
+    const safeLoc = loc.replace(/^\?\((.*?)\)$/u, '$1');
+
+    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) {
+      throw new Error('Eval [(expr)] prevented in JSONPath expression.');
+    } // 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));
+  } else if (loc[0] === '@') {
+    // value type: @boolean(), etc.
+    let addType = false;
+    const valueType = loc.slice(1, -2);
+
+    switch (valueType) {
+      case 'scalar':
+        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) {
+          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) {
+          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,
+        value: val,
+        parent,
+        parentProperty: parentPropName
+      };
+
+      this._handleCallback(retObj, callback, 'value');
+
+      return retObj;
+    } // `-escaped property
+
+  } else if (loc[0] === '`' && val && hasOwnProp.call(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,...]
+    const parts = loc.split(',');
+
+    for (const part of parts) {
+      addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback, true));
+    } // simple case--directly follow property
+
+  } else if (!literalPriority && val && hasOwnProp.call(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
+  // selections we discard the value object and continue the trace with the
+  // current val object
+
+
+  if (this._hasParentSelector) {
+    for (let t = 0; t < ret.length; t++) {
+      const rett = ret[t];
+
+      if (rett && rett.isParentSelector) {
+        const tmp = this._trace(rett.expr, val, rett.path, parent, parentPropName, callback, hasArrExpr);
+
+        if (Array.isArray(tmp)) {
+          ret[t] = tmp[0];
+          const tl = tmp.length;
+
+          for (let tt = 1; tt < tl; tt++) {
+            t++;
+            ret.splice(t, 0, tmp[tt]);
+          }
+        } else {
+          ret[t] = tmp;
+        }
+      }
+    }
+  }
+
+  return ret;
+};
+
+JSONPath.prototype._walk = function (val, f) {
+  if (Array.isArray(val)) {
+    const n = val.length;
+
+    for (let i = 0; i < n; i++) {
+      f(i);
+    }
+  } 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;
+  }
+
+  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);
+  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(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;
+  const containsPath = code.includes('@path');
+
+  if (containsPath) {
+    this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));
+  }
+
+  const scriptCacheKey = 'script:' + code;
+
+  if (!JSONPath.cache[scriptCacheKey]) {
+    let script = code.replace(/@parentProperty/gu, '_$_parentProperty').replace(/@parent/gu, '_$_parent').replace(/@property/gu, '_$_property').replace(/@root/gu, '_$_root').replace(/@([.\s)[])/gu, '_$_v$1');
+
+    if (containsPath) {
+      script = script.replace(/@path/gu, '_$_path');
+    }
+
+    JSONPath.cache[scriptCacheKey] = new this.vm.Script(script);
+  }
+
+  try {
+    return JSONPath.cache[scriptCacheKey].runInNewContext(this.currSandbox);
+  } catch (e) {
+    throw new Error('jsonPath: ' + e.message + ': ' + code);
+  }
+}; // 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) {
+  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) {
+  const x = pointer,
+        n = x.length;
+  let p = '';
+
+  for (let i = 1; i < n; i++) {
+    if (!/^(~|\^|@.*?\(\))$/u.test(x[i])) {
+      p += '/' + x[i].toString().replace(/~/gu, '~0').replace(/\//gu, '~1');
+    }
+  }
+
+  return p;
+};
+/**
+ * @param {string} expr Expression to convert
+ * @returns {string[]}
+ */
+
+
+JSONPath.toPathArray = function (expr) {
+  const {
+    cache
+  } = JSONPath;
+
+  if (cache[expr]) {
+    return cache[expr].concat();
+  }
+
+  const subx = [];
+  const normalized = expr // Properties
+  .replace(/@(?: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(/[['](\??\(.*?\))[\]']/gu, function ($0, $1) {
+    return '[#' + (subx.push($1) - 1) + ']';
+  }) // Escape periods and tildes within properties
+  .replace(/\[['"]([^'\]]*)['"]\]/gu, function ($0, prop) {
+    return "['" + prop.replace(/\./gu, '%@%').replace(/~/gu, '%%@@%%') + "']";
+  }) // Properties operator
+  .replace(/~/gu, ';~;') // Split by property boundaries
+  .replace(/['"]?\.['"]?(?![^[]*\])|\[['"]?/gu, ';') // Reinsert periods within properties
+  .replace(/%@%/gu, '.') // Reinsert tildes within properties
+  .replace(/%%@@%%/gu, '~') // Parent
+  .replace(/(?:;)?(\^+)(?:;)?/gu, function ($0, ups) {
+    return ';' + ups.split('').join(';') + ';';
+  }) // Descendents
+  .replace(/;;;|;;/gu, ';..;') // Remove trailing
+  .replace(/;$|'?\]|'$/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.vm = vm;
+
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2022 Joachim Wester
+ * MIT licensed
+ */
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwnProperty$b(obj, key) {
+    return _hasOwnProperty.call(obj, key);
+}
+function _objectKeys(obj) {
+    if (Array.isArray(obj)) {
+        var keys_1 = new Array(obj.length);
+        for (var k = 0; k < keys_1.length; k++) {
+            keys_1[k] = "" + k;
+        }
+        return keys_1;
+    }
+    if (Object.keys) {
+        return Object.keys(obj);
+    }
+    var keys = [];
+    for (var i in obj) {
+        if (hasOwnProperty$b(obj, i)) {
+            keys.push(i);
+        }
+    }
+    return keys;
+}
+/**
+* Deeply clone the object.
+* https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+* @param  {any} obj value to clone
+* @return {any} cloned obj
+*/
+function _deepClone(obj) {
+    switch (typeof obj) {
+        case "object":
+            return JSON.parse(JSON.stringify(obj)); //Faster than ES5 clone - http://jsperf.com/deep-cloning-of-objects/5
+        case "undefined":
+            return null; //this is how JSON.stringify behaves for array items
+        default:
+            return obj; //no need to clone primitives
+    }
+}
+//3x faster than cached /^\d+$/.test(str)
+function isInteger(str) {
+    var i = 0;
+    var len = str.length;
+    var charCode;
+    while (i < len) {
+        charCode = str.charCodeAt(i);
+        if (charCode >= 48 && charCode <= 57) {
+            i++;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+/**
+* Escapes a json pointer path
+* @param path The raw pointer
+* @return the Escaped path
+*/
+function escapePathComponent(path) {
+    if (path.indexOf('/') === -1 && path.indexOf('~') === -1)
+        return path;
+    return path.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+/**
+ * Unescapes a json pointer path
+ * @param path The escaped pointer
+ * @return The unescaped path
+ */
+function unescapePathComponent(path) {
+    return path.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+/**
+* Recursively checks whether an object has any undefined values inside.
+*/
+function hasUndefined(obj) {
+    if (obj === undefined) {
+        return true;
+    }
+    if (obj) {
+        if (Array.isArray(obj)) {
+            for (var i_1 = 0, len = obj.length; i_1 < len; i_1++) {
+                if (hasUndefined(obj[i_1])) {
+                    return true;
+                }
+            }
+        }
+        else if (typeof obj === "object") {
+            var objKeys = _objectKeys(obj);
+            var objKeysLength = objKeys.length;
+            for (var i = 0; i < objKeysLength; i++) {
+                if (hasUndefined(obj[objKeys[i]])) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function patchErrorMessageFormatter(message, args) {
+    var messageParts = [message];
+    for (var key in args) {
+        var value = typeof args[key] === 'object' ? JSON.stringify(args[key], null, 2) : args[key]; // pretty print
+        if (typeof value !== 'undefined') {
+            messageParts.push(key + ": " + value);
+        }
+    }
+    return messageParts.join('\n');
+}
+var PatchError = /** @class */ (function (_super) {
+    __extends(PatchError, _super);
+    function PatchError(message, name, index, operation, tree) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, patchErrorMessageFormatter(message, { name: name, index: index, operation: operation, tree: tree })) || this;
+        _this.name = name;
+        _this.index = index;
+        _this.operation = operation;
+        _this.tree = tree;
+        Object.setPrototypeOf(_this, _newTarget.prototype); // restore prototype chain, see https://stackoverflow.com/a/48342359
+        _this.message = patchErrorMessageFormatter(message, { name: name, index: index, operation: operation, tree: tree });
+        return _this;
+    }
+    return PatchError;
+}(Error));
+
+var JsonPatchError = PatchError;
+var deepClone = _deepClone;
+/* We use a Javascript hash to store each
+ function. Each hash entry (property) uses
+ the operation identifiers specified in rfc6902.
+ In this way, we can map each patch operation
+ to its dedicated function in efficient way.
+ */
+/* The operations applicable to an object */
+var objOps = {
+    add: function (obj, key, document) {
+        obj[key] = this.value;
+        return { newDocument: document };
+    },
+    remove: function (obj, key, document) {
+        var removed = obj[key];
+        delete obj[key];
+        return { newDocument: document, removed: removed };
+    },
+    replace: function (obj, key, document) {
+        var removed = obj[key];
+        obj[key] = this.value;
+        return { newDocument: document, removed: removed };
+    },
+    move: function (obj, key, document) {
+        /* in case move target overwrites an existing value,
+        return the removed value, this can be taxing performance-wise,
+        and is potentially unneeded */
+        var removed = getValueByPointer(document, this.path);
+        if (removed) {
+            removed = _deepClone(removed);
+        }
+        var originalValue = applyOperation(document, { op: "remove", path: this.from }).removed;
+        applyOperation(document, { op: "add", path: this.path, value: originalValue });
+        return { newDocument: document, removed: removed };
+    },
+    copy: function (obj, key, document) {
+        var valueToCopy = getValueByPointer(document, this.from);
+        // enforce copy by value so further operations don't affect source (see issue #177)
+        applyOperation(document, { op: "add", path: this.path, value: _deepClone(valueToCopy) });
+        return { newDocument: document };
+    },
+    test: function (obj, key, document) {
+        return { newDocument: document, test: _areEquals(obj[key], this.value) };
+    },
+    _get: function (obj, key, document) {
+        this.value = obj[key];
+        return { newDocument: document };
+    }
+};
+/* The operations applicable to an array. Many are the same as for the object */
+var arrOps = {
+    add: function (arr, i, document) {
+        if (isInteger(i)) {
+            arr.splice(i, 0, this.value);
+        }
+        else { // array props
+            arr[i] = this.value;
+        }
+        // this may be needed when using '-' in an array
+        return { newDocument: document, index: i };
+    },
+    remove: function (arr, i, document) {
+        var removedList = arr.splice(i, 1);
+        return { newDocument: document, removed: removedList[0] };
+    },
+    replace: function (arr, i, document) {
+        var removed = arr[i];
+        arr[i] = this.value;
+        return { newDocument: document, removed: removed };
+    },
+    move: objOps.move,
+    copy: objOps.copy,
+    test: objOps.test,
+    _get: objOps._get
+};
+/**
+ * Retrieves a value from a JSON document by a JSON pointer.
+ * Returns the value.
+ *
+ * @param document The document to get the value from
+ * @param pointer an escaped JSON pointer
+ * @return The retrieved value
+ */
+function getValueByPointer(document, pointer) {
+    if (pointer == '') {
+        return document;
+    }
+    var getOriginalDestination = { op: "_get", path: pointer };
+    applyOperation(document, getOriginalDestination);
+    return getOriginalDestination.value;
+}
+/**
+ * Apply a single JSON Patch Operation on a JSON document.
+ * Returns the {newDocument, result} of the operation.
+ * It modifies the `document` and `operation` objects - it gets the values by reference.
+ * If you would like to avoid touching your values, clone them:
+ * `jsonpatch.applyOperation(document, jsonpatch._deepClone(operation))`.
+ *
+ * @param document The document to patch
+ * @param operation The operation to apply
+ * @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
+ * @param mutateDocument Whether to mutate the original document or clone it before applying
+ * @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
+ * @return `{newDocument, result}` after the operation
+ */
+function applyOperation(document, operation, validateOperation, mutateDocument, banPrototypeModifications, index) {
+    if (validateOperation === void 0) { validateOperation = false; }
+    if (mutateDocument === void 0) { mutateDocument = true; }
+    if (banPrototypeModifications === void 0) { banPrototypeModifications = true; }
+    if (index === void 0) { index = 0; }
+    if (validateOperation) {
+        if (typeof validateOperation == 'function') {
+            validateOperation(operation, 0, document, operation.path);
+        }
+        else {
+            validator$1(operation, 0);
+        }
+    }
+    /* ROOT OPERATIONS */
+    if (operation.path === "") {
+        var returnValue = { newDocument: document };
+        if (operation.op === 'add') {
+            returnValue.newDocument = operation.value;
+            return returnValue;
+        }
+        else if (operation.op === 'replace') {
+            returnValue.newDocument = operation.value;
+            returnValue.removed = document; //document we removed
+            return returnValue;
+        }
+        else if (operation.op === 'move' || operation.op === 'copy') { // it's a move or copy to root
+            returnValue.newDocument = getValueByPointer(document, operation.from); // get the value by json-pointer in `from` field
+            if (operation.op === 'move') { // report removed item
+                returnValue.removed = document;
+            }
+            return returnValue;
+        }
+        else if (operation.op === 'test') {
+            returnValue.test = _areEquals(document, operation.value);
+            if (returnValue.test === false) {
+                throw new JsonPatchError("Test operation failed", 'TEST_OPERATION_FAILED', index, operation, document);
+            }
+            returnValue.newDocument = document;
+            return returnValue;
+        }
+        else if (operation.op === 'remove') { // a remove on root
+            returnValue.removed = document;
+            returnValue.newDocument = null;
+            return returnValue;
+        }
+        else if (operation.op === '_get') {
+            operation.value = document;
+            return returnValue;
+        }
+        else { /* bad operation */
+            if (validateOperation) {
+                throw new JsonPatchError('Operation `op` property is not one of operations defined in RFC-6902', 'OPERATION_OP_INVALID', index, operation, document);
+            }
+            else {
+                return returnValue;
+            }
+        }
+    } /* END ROOT OPERATIONS */
+    else {
+        if (!mutateDocument) {
+            document = _deepClone(document);
+        }
+        var path = operation.path || "";
+        var keys = path.split('/');
+        var obj = document;
+        var t = 1; //skip empty element - http://jsperf.com/to-shift-or-not-to-shift
+        var len = keys.length;
+        var existingPathFragment = undefined;
+        var key = void 0;
+        var validateFunction = void 0;
+        if (typeof validateOperation == 'function') {
+            validateFunction = validateOperation;
+        }
+        else {
+            validateFunction = validator$1;
+        }
+        while (true) {
+            key = keys[t];
+            if (key && key.indexOf('~') != -1) {
+                key = unescapePathComponent(key);
+            }
+            if (banPrototypeModifications &&
+                (key == '__proto__' ||
+                    (key == 'prototype' && t > 0 && keys[t - 1] == 'constructor'))) {
+                throw new TypeError('JSON-Patch: modifying `__proto__` or `constructor/prototype` prop is banned for security reasons, if this was on purpose, please set `banPrototypeModifications` flag false and pass it to this function. More info in fast-json-patch README');
+            }
+            if (validateOperation) {
+                if (existingPathFragment === undefined) {
+                    if (obj[key] === undefined) {
+                        existingPathFragment = keys.slice(0, t).join('/');
+                    }
+                    else if (t == len - 1) {
+                        existingPathFragment = operation.path;
+                    }
+                    if (existingPathFragment !== undefined) {
+                        validateFunction(operation, 0, document, existingPathFragment);
+                    }
+                }
+            }
+            t++;
+            if (Array.isArray(obj)) {
+                if (key === '-') {
+                    key = obj.length;
+                }
+                else {
+                    if (validateOperation && !isInteger(key)) {
+                        throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document);
+                    } // only parse key when it's an integer for `arr.prop` to work
+                    else if (isInteger(key)) {
+                        key = ~~key;
+                    }
+                }
+                if (t >= len) {
+                    if (validateOperation && operation.op === "add" && key > obj.length) {
+                        throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document);
+                    }
+                    var returnValue = arrOps[operation.op].call(operation, obj, key, document); // Apply patch
+                    if (returnValue.test === false) {
+                        throw new JsonPatchError("Test operation failed", 'TEST_OPERATION_FAILED', index, operation, document);
+                    }
+                    return returnValue;
+                }
+            }
+            else {
+                if (t >= len) {
+                    var returnValue = objOps[operation.op].call(operation, obj, key, document); // Apply patch
+                    if (returnValue.test === false) {
+                        throw new JsonPatchError("Test operation failed", 'TEST_OPERATION_FAILED', index, operation, document);
+                    }
+                    return returnValue;
+                }
+            }
+            obj = obj[key];
+            // If we have more keys in the path, but the next value isn't a non-null object,
+            // throw an OPERATION_PATH_UNRESOLVABLE error instead of iterating again.
+            if (validateOperation && t < len && (!obj || typeof obj !== "object")) {
+                throw new JsonPatchError('Cannot perform operation at the desired path', 'OPERATION_PATH_UNRESOLVABLE', index, operation, document);
+            }
+        }
+    }
+}
+/**
+ * Apply a full JSON Patch array on a JSON document.
+ * Returns the {newDocument, result} of the patch.
+ * It modifies the `document` object and `patch` - it gets the values by reference.
+ * If you would like to avoid touching your values, clone them:
+ * `jsonpatch.applyPatch(document, jsonpatch._deepClone(patch))`.
+ *
+ * @param document The document to patch
+ * @param patch The patch to apply
+ * @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
+ * @param mutateDocument Whether to mutate the original document or clone it before applying
+ * @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
+ * @return An array of `{newDocument, result}` after the patch
+ */
+function applyPatch(document, patch, validateOperation, mutateDocument, banPrototypeModifications) {
+    if (mutateDocument === void 0) { mutateDocument = true; }
+    if (banPrototypeModifications === void 0) { banPrototypeModifications = true; }
+    if (validateOperation) {
+        if (!Array.isArray(patch)) {
+            throw new JsonPatchError('Patch sequence must be an array', 'SEQUENCE_NOT_AN_ARRAY');
+        }
+    }
+    if (!mutateDocument) {
+        document = _deepClone(document);
+    }
+    var results = new Array(patch.length);
+    for (var i = 0, length_1 = patch.length; i < length_1; i++) {
+        // we don't need to pass mutateDocument argument because if it was true, we already deep cloned the object, we'll just pass `true`
+        results[i] = applyOperation(document, patch[i], validateOperation, true, banPrototypeModifications, i);
+        document = results[i].newDocument; // in case root was replaced
+    }
+    results.newDocument = document;
+    return results;
+}
+/**
+ * Apply a single JSON Patch Operation on a JSON document.
+ * Returns the updated document.
+ * Suitable as a reducer.
+ *
+ * @param document The document to patch
+ * @param operation The operation to apply
+ * @return The updated document
+ */
+function applyReducer(document, operation, index) {
+    var operationResult = applyOperation(document, operation);
+    if (operationResult.test === false) { // failed test
+        throw new JsonPatchError("Test operation failed", 'TEST_OPERATION_FAILED', index, operation, document);
+    }
+    return operationResult.newDocument;
+}
+/**
+ * Validates a single operation. Called from `jsonpatch.validate`. Throws `JsonPatchError` in case of an error.
+ * @param {object} operation - operation object (patch)
+ * @param {number} index - index of operation in the sequence
+ * @param {object} [document] - object where the operation is supposed to be applied
+ * @param {string} [existingPathFragment] - comes along with `document`
+ */
+function validator$1(operation, index, document, existingPathFragment) {
+    if (typeof operation !== 'object' || operation === null || Array.isArray(operation)) {
+        throw new JsonPatchError('Operation is not an object', 'OPERATION_NOT_AN_OBJECT', index, operation, document);
+    }
+    else if (!objOps[operation.op]) {
+        throw new JsonPatchError('Operation `op` property is not one of operations defined in RFC-6902', 'OPERATION_OP_INVALID', index, operation, document);
+    }
+    else if (typeof operation.path !== 'string') {
+        throw new JsonPatchError('Operation `path` property is not a string', 'OPERATION_PATH_INVALID', index, operation, document);
+    }
+    else if (operation.path.indexOf('/') !== 0 && operation.path.length > 0) {
+        // paths that aren't empty string should start with "/"
+        throw new JsonPatchError('Operation `path` property must start with "/"', 'OPERATION_PATH_INVALID', index, operation, document);
+    }
+    else if ((operation.op === 'move' || operation.op === 'copy') && typeof operation.from !== 'string') {
+        throw new JsonPatchError('Operation `from` property is not present (applicable in `move` and `copy` operations)', 'OPERATION_FROM_REQUIRED', index, operation, document);
+    }
+    else if ((operation.op === 'add' || operation.op === 'replace' || operation.op === 'test') && operation.value === undefined) {
+        throw new JsonPatchError('Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)', 'OPERATION_VALUE_REQUIRED', index, operation, document);
+    }
+    else if ((operation.op === 'add' || operation.op === 'replace' || operation.op === 'test') && hasUndefined(operation.value)) {
+        throw new JsonPatchError('Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)', 'OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED', index, operation, document);
+    }
+    else if (document) {
+        if (operation.op == "add") {
+            var pathLen = operation.path.split("/").length;
+            var existingPathLen = existingPathFragment.split("/").length;
+            if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) {
+                throw new JsonPatchError('Cannot perform an `add` operation at the desired path', 'OPERATION_PATH_CANNOT_ADD', index, operation, document);
+            }
+        }
+        else if (operation.op === 'replace' || operation.op === 'remove' || operation.op === '_get') {
+            if (operation.path !== existingPathFragment) {
+                throw new JsonPatchError('Cannot perform the operation at a path that does not exist', 'OPERATION_PATH_UNRESOLVABLE', index, operation, document);
+            }
+        }
+        else if (operation.op === 'move' || operation.op === 'copy') {
+            var existingValue = { op: "_get", path: operation.from, value: undefined };
+            var error = validate([existingValue], document);
+            if (error && error.name === 'OPERATION_PATH_UNRESOLVABLE') {
+                throw new JsonPatchError('Cannot perform the operation from a path that does not exist', 'OPERATION_FROM_UNRESOLVABLE', index, operation, document);
+            }
+        }
+    }
+}
+/**
+ * Validates a sequence of operations. If `document` parameter is provided, the sequence is additionally validated against the object document.
+ * If error is encountered, returns a JsonPatchError object
+ * @param sequence
+ * @param document
+ * @returns {JsonPatchError|undefined}
+ */
+function validate(sequence, document, externalValidator) {
+    try {
+        if (!Array.isArray(sequence)) {
+            throw new JsonPatchError('Patch sequence must be an array', 'SEQUENCE_NOT_AN_ARRAY');
+        }
+        if (document) {
+            //clone document and sequence so that we can safely try applying operations
+            applyPatch(_deepClone(document), _deepClone(sequence), externalValidator || true);
+        }
+        else {
+            externalValidator = externalValidator || validator$1;
+            for (var i = 0; i < sequence.length; i++) {
+                externalValidator(sequence[i], i, document, undefined);
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof JsonPatchError) {
+            return e;
+        }
+        else {
+            throw e;
+        }
+    }
+}
+// based on https://github.com/epoberezkin/fast-deep-equal
+// MIT License
+// Copyright (c) 2017 Evgeny Poberezkin
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+function _areEquals(a, b) {
+    if (a === b)
+        return true;
+    if (a && b && typeof a == 'object' && typeof b == 'object') {
+        var arrA = Array.isArray(a), arrB = Array.isArray(b), i, length, key;
+        if (arrA && arrB) {
+            length = a.length;
+            if (length != b.length)
+                return false;
+            for (i = length; i-- !== 0;)
+                if (!_areEquals(a[i], b[i]))
+                    return false;
+            return true;
+        }
+        if (arrA != arrB)
+            return false;
+        var keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length)
+            return false;
+        for (i = length; i-- !== 0;)
+            if (!b.hasOwnProperty(keys[i]))
+                return false;
+        for (i = length; i-- !== 0;) {
+            key = keys[i];
+            if (!_areEquals(a[key], b[key]))
+                return false;
+        }
+        return true;
+    }
+    return a !== a && b !== b;
+}
+
+var core = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  JsonPatchError: JsonPatchError,
+  _areEquals: _areEquals,
+  applyOperation: applyOperation,
+  applyPatch: applyPatch,
+  applyReducer: applyReducer,
+  deepClone: deepClone,
+  getValueByPointer: getValueByPointer,
+  validate: validate,
+  validator: validator$1
+});
+
+/*!
+ * https://github.com/Starcounter-Jack/JSON-Patch
+ * (c) 2017-2021 Joachim Wester
+ * MIT license
+ */
+var beforeDict = new WeakMap();
+var Mirror = /** @class */ (function () {
+    function Mirror(obj) {
+        this.observers = new Map();
+        this.obj = obj;
+    }
+    return Mirror;
+}());
+var ObserverInfo = /** @class */ (function () {
+    function ObserverInfo(callback, observer) {
+        this.callback = callback;
+        this.observer = observer;
+    }
+    return ObserverInfo;
+}());
+function getMirror(obj) {
+    return beforeDict.get(obj);
+}
+function getObserverFromMirror(mirror, callback) {
+    return mirror.observers.get(callback);
+}
+function removeObserverFromMirror(mirror, observer) {
+    mirror.observers.delete(observer.callback);
+}
+/**
+ * Detach an observer from an object
+ */
+function unobserve(root, observer) {
+    observer.unobserve();
+}
+/**
+ * Observes changes made to an object, which can then be retrieved using generate
+ */
+function observe(obj, callback) {
+    var patches = [];
+    var observer;
+    var mirror = getMirror(obj);
+    if (!mirror) {
+        mirror = new Mirror(obj);
+        beforeDict.set(obj, mirror);
+    }
+    else {
+        var observerInfo = getObserverFromMirror(mirror, callback);
+        observer = observerInfo && observerInfo.observer;
+    }
+    if (observer) {
+        return observer;
+    }
+    observer = {};
+    mirror.value = _deepClone(obj);
+    if (callback) {
+        observer.callback = callback;
+        observer.next = null;
+        var dirtyCheck = function () {
+            generate(observer);
+        };
+        var fastCheck = function () {
+            clearTimeout(observer.next);
+            observer.next = setTimeout(dirtyCheck);
+        };
+        if (typeof window !== 'undefined') { //not Node
+            window.addEventListener('mouseup', fastCheck);
+            window.addEventListener('keyup', fastCheck);
+            window.addEventListener('mousedown', fastCheck);
+            window.addEventListener('keydown', fastCheck);
+            window.addEventListener('change', fastCheck);
+        }
+    }
+    observer.patches = patches;
+    observer.object = obj;
+    observer.unobserve = function () {
+        generate(observer);
+        clearTimeout(observer.next);
+        removeObserverFromMirror(mirror, observer);
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('mouseup', fastCheck);
+            window.removeEventListener('keyup', fastCheck);
+            window.removeEventListener('mousedown', fastCheck);
+            window.removeEventListener('keydown', fastCheck);
+            window.removeEventListener('change', fastCheck);
+        }
+    };
+    mirror.observers.set(callback, new ObserverInfo(callback, observer));
+    return observer;
+}
+/**
+ * Generate an array of patches from an observer
+ */
+function generate(observer, invertible) {
+    if (invertible === void 0) { invertible = false; }
+    var mirror = beforeDict.get(observer.object);
+    _generate(mirror.value, observer.object, observer.patches, "", invertible);
+    if (observer.patches.length) {
+        applyPatch(mirror.value, observer.patches);
+    }
+    var temp = observer.patches;
+    if (temp.length > 0) {
+        observer.patches = [];
+        if (observer.callback) {
+            observer.callback(temp);
+        }
+    }
+    return temp;
+}
+// Dirty check if obj is different from mirror, generate patches and update mirror
+function _generate(mirror, obj, patches, path, invertible) {
+    if (obj === mirror) {
+        return;
+    }
+    if (typeof obj.toJSON === "function") {
+        obj = obj.toJSON();
+    }
+    var newKeys = _objectKeys(obj);
+    var oldKeys = _objectKeys(mirror);
+    var deleted = false;
+    //if ever "move" operation is implemented here, make sure this test runs OK: "should not generate the same patch twice (move)"
+    for (var t = oldKeys.length - 1; t >= 0; t--) {
+        var key = oldKeys[t];
+        var oldVal = mirror[key];
+        if (hasOwnProperty$b(obj, key) && !(obj[key] === undefined && oldVal !== undefined && Array.isArray(obj) === false)) {
+            var newVal = obj[key];
+            if (typeof oldVal == "object" && oldVal != null && typeof newVal == "object" && newVal != null && Array.isArray(oldVal) === Array.isArray(newVal)) {
+                _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key), invertible);
+            }
+            else {
+                if (oldVal !== newVal) {
+                    if (invertible) {
+                        patches.push({ op: "test", path: path + "/" + escapePathComponent(key), value: _deepClone(oldVal) });
+                    }
+                    patches.push({ op: "replace", path: path + "/" + escapePathComponent(key), value: _deepClone(newVal) });
+                }
+            }
+        }
+        else if (Array.isArray(mirror) === Array.isArray(obj)) {
+            if (invertible) {
+                patches.push({ op: "test", path: path + "/" + escapePathComponent(key), value: _deepClone(oldVal) });
+            }
+            patches.push({ op: "remove", path: path + "/" + escapePathComponent(key) });
+            deleted = true; // property has been deleted
+        }
+        else {
+            if (invertible) {
+                patches.push({ op: "test", path: path, value: mirror });
+            }
+            patches.push({ op: "replace", path: path, value: obj });
+        }
+    }
+    if (!deleted && newKeys.length == oldKeys.length) {
+        return;
+    }
+    for (var t = 0; t < newKeys.length; t++) {
+        var key = newKeys[t];
+        if (!hasOwnProperty$b(mirror, key) && obj[key] !== undefined) {
+            patches.push({ op: "add", path: path + "/" + escapePathComponent(key), value: _deepClone(obj[key]) });
+        }
+    }
+}
+/**
+ * Create an array of patches from the differences in two objects
+ */
+function compare(tree1, tree2, invertible) {
+    if (invertible === void 0) { invertible = false; }
+    var patches = [];
+    _generate(tree1, tree2, patches, '', invertible);
+    return patches;
+}
+
+var duplex = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  compare: compare,
+  generate: generate,
+  observe: observe,
+  unobserve: unobserve
+});
+
+Object.assign({}, core, duplex, {
+    JsonPatchError: PatchError,
+    deepClone: _deepClone,
+    escapePathComponent,
+    unescapePathComponent
+});
+
 toast.configure({
     autoClose: 3000,
     hideProgressBar: true,
@@ -10259,7 +11761,83 @@ var getUrlWithSearchParams = function (url, params) {
 /**
  * Custom exception logger function for logging errors to sentry
  */
-var logExceptionToSentry = captureException.bind(window);
+var logExceptionToSentry = captureException.bind(window);
+var customStyles = {
+    control: function (base, state) { return (__assign(__assign({}, base), { minHeight: '32px', boxShadow: 'none', border: 'none', cursor: 'pointer', background: 'transparent' })); },
+    indicatorSeparator: function (base, state) { return (__assign(__assign({}, base), { width: 0 })); },
+    valueContainer: function (base, state) { return (__assign(__assign({}, base), { padding: '0', fontSize: '13px', fontWeight: '600' })); },
+    dropdownIndicator: function (base, state) { return (__assign(__assign({}, base), { color: 'var(--N400)', padding: '0 8px', transition: 'all .2s ease', transform: state.selectProps.menuIsOpen ? 'rotate(180deg)' : 'rotate(0deg)' })); },
+};
+var getFilteredChartVersions = function (charts, selectedChartType) {
+    // Filter chart versions based on selected chart type
+    return charts
+        .filter(function (item) { return (item === null || item === void 0 ? void 0 : item.chartType) === selectedChartType.value; })
+        .map(function (item) { return ({
+        value: item === null || item === void 0 ? void 0 : item.chartVersion,
+        label: item === null || item === void 0 ? void 0 : item.chartVersion,
+        chartRefId: item.chartRefId,
+    }); });
+};
+function removeEmptyObjectKeysAndNullValues(obj) {
+    // It recursively removes empty object keys and array values that are null
+    for (var key in obj) {
+        if (Array.isArray(obj[key])) {
+            if (obj[key].length === 0)
+                continue;
+            obj[key] = obj[key].filter(function (item) { return item !== null; });
+            // Check if the array is empty
+            if (obj[key].length === 0) {
+                delete obj[key]; // Delete the key if the array is empty
+            }
+        }
+        else if (obj[key] && typeof obj[key] === 'object') {
+            if (removeEmptyObjectKeysAndNullValues(obj[key])) {
+                delete obj[key];
+            }
+        }
+        else if (obj[key] === undefined) {
+            delete obj[key];
+        }
+    }
+    return Object.keys(obj).length === 0;
+}
+function getUnlockedJSON(json, jsonPathArray) {
+    var jsonCopy = JSON.parse(JSON.stringify(json));
+    var patches = jsonPathArray.flatMap(function (jsonPath) {
+        var pathsToRemove = JSONPath({ path: jsonPath, json: jsonCopy, resultType: 'all' });
+        return pathsToRemove.map(function (result) {
+            return Array.isArray(result.parent)
+                ? { op: 'replace', path: result.pointer, value: null }
+                : { op: 'remove', path: result.pointer };
+        });
+    });
+    var newDocument = applyPatch(jsonCopy, patches).newDocument;
+    removeEmptyObjectKeysAndNullValues(newDocument);
+    return newDocument;
+}
+function getLockedJSON(json, jsonPathArray) {
+    var jsonCopy = JSON.parse(JSON.stringify(json));
+    var resultJson = {};
+    jsonPathArray.forEach(function (jsonPath) {
+        var elements = JSONPath({ path: jsonPath, json: jsonCopy, resultType: 'all' });
+        elements.forEach(function (element) {
+            var _a;
+            var pathArray = JSONPath.toPathArray(element.path);
+            var lastPath = pathArray.pop();
+            var current = resultJson;
+            for (var i = 0; i < pathArray.length; i++) {
+                var key_1 = isNaN(Number(pathArray[i])) ? pathArray[i] : parseInt(pathArray[i]);
+                if (!current[key_1]) {
+                    current[key_1] = isNaN(Number((_a = pathArray[i + 1]) !== null && _a !== void 0 ? _a : lastPath)) ? {} : [];
+                }
+                current = current[key_1];
+            }
+            var key = isNaN(Number(lastPath)) ? lastPath : parseInt(lastPath);
+            current[key] = element.value;
+        });
+    });
+    return resultJson['$'];
+}
 
 function Progressing(_a) {
     var pageLoader = _a.pageLoader, size = _a.size, theme = _a.theme, styles = _a.styles, fillColor = _a.fillColor;
@@ -10272,7 +11850,7 @@ function DetailsProgressing(_a) {
 }
 
 var VisibleModal = /** @class */ (function (_super) {
-    __extends(VisibleModal, _super);
+    __extends$1(VisibleModal, _super);
     function VisibleModal(props) {
         var _this = _super.call(this, props) || this;
         _this.modalRef = document.getElementById('visible-modal');
@@ -10403,7 +11981,7 @@ var SvgIcCross = function SvgIcCross(props) {
 var close = "data:image/svg+xml,%3Csvg%20width%3D%2224%22%20height%3D%2224%22%20viewBox%3D%220%200%2024%2024%22%20fill%3D%22none%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%3Cpath%20d%3D%22M19.2803%205.78033C19.5732%205.48744%2019.5732%205.01256%2019.2803%204.71967C18.9874%204.42678%2018.5126%204.42678%2018.2197%204.71967L19.2803%205.78033ZM4.71967%2018.2197C4.42678%2018.5126%204.42678%2018.9874%204.71967%2019.2803C5.01256%2019.5732%205.48744%2019.5732%205.78033%2019.2803L4.71967%2018.2197ZM18.2197%2019.2803C18.5126%2019.5732%2018.9874%2019.5732%2019.2803%2019.2803C19.5732%2018.9874%2019.5732%2018.5126%2019.2803%2018.2197L18.2197%2019.2803ZM5.78033%204.71967C5.48744%204.42678%205.01256%204.42678%204.71967%204.71967C4.42678%205.01256%204.42678%205.48744%204.71967%205.78033L5.78033%204.71967ZM18.2197%204.71967L11.4697%2011.4697L12.5303%2012.5303L19.2803%205.78033L18.2197%204.71967ZM11.4697%2011.4697L4.71967%2018.2197L5.78033%2019.2803L12.5303%2012.5303L11.4697%2011.4697ZM19.2803%2018.2197L12.5303%2011.4697L11.4697%2012.5303L18.2197%2019.2803L19.2803%2018.2197ZM12.5303%2011.4697L5.78033%204.71967L4.71967%205.78033L11.4697%2012.5303L12.5303%2011.4697Z%22%20fill%3D%22%23596168%22%2F%3E%3C%2Fsvg%3E";
 
 var OpaqueModal = /** @class */ (function (_super) {
-    __extends(OpaqueModal, _super);
+    __extends$1(OpaqueModal, _super);
     function OpaqueModal() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
         _this.modalRef = document.getElementById('full-screen-modal');
@@ -10427,7 +12005,7 @@ var OpaqueModal = /** @class */ (function (_super) {
 }(React.Component));
 
 var VisibleModal2 = /** @class */ (function (_super) {
-    __extends(VisibleModal2, _super);
+    __extends$1(VisibleModal2, _super);
     function VisibleModal2(props) {
         var _this = _super.call(this, props) || this;
         _this.modalRef = document.getElementById('visible-modal-2');
@@ -10538,7 +12116,7 @@ var BreadCrumb = function (_a) {
 
 var RadioGroupContext = React.createContext({ name: '', value: '', disabled: false, onChange: function (event) { } });
 var RadioGroupItem = /** @class */ (function (_super) {
-    __extends(RadioGroupItem, _super);
+    __extends$1(RadioGroupItem, _super);
     function RadioGroupItem() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -10551,7 +12129,7 @@ var RadioGroupItem = /** @class */ (function (_super) {
     return RadioGroupItem;
 }(React.Component));
 var RadioGroup$1 = /** @class */ (function (_super) {
-    __extends(RadioGroup, _super);
+    __extends$1(RadioGroup, _super);
     function RadioGroup() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -15132,7 +16710,7 @@ DeleteDialog.Description = DeleteDialogDescription;
 //TODO: may not need context
 var DialogFormContext = React.createContext({ title: '', isLoading: false, close: function (event) { }, onSave: function (event) { } });
 var DialogForm = /** @class */ (function (_super) {
-    __extends(DialogForm, _super);
+    __extends$1(DialogForm, _super);
     function DialogForm(props) {
         var _this = _super.call(this, props) || this;
         _this.escFunction = _this.escFunction.bind(_this);
@@ -15168,7 +16746,7 @@ var DialogForm = /** @class */ (function (_super) {
     return DialogForm;
 }(React.Component));
 var DialogFormSubmit = /** @class */ (function (_super) {
-    __extends(DialogFormSubmit, _super);
+    __extends$1(DialogFormSubmit, _super);
     function DialogFormSubmit() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -22935,6 +24513,9 @@ function createGitCommitUrl(url, revision) {
         }
     }
     return "NA";
+}
+function fetchChartTemplateVersions() {
+    return get("".concat(ROUTES.DEPLOYMENT_TEMPLATE_LIST, "?appId=-1&envId=-1"));
 }
 
 /*
@@ -22947,7 +24528,7 @@ Valid States of Checkbox:
 6. disabled: false, checked: true,  value: CHECKED
 */
 var Checkbox$1 = /** @class */ (function (_super) {
-    __extends(Checkbox, _super);
+    __extends$1(Checkbox, _super);
     function Checkbox() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
@@ -26649,6 +28230,53 @@ function DevtronProgressing(_a) {
     return (jsxRuntime.jsx("div", __assign({ className: parentClasses ? parentClasses : '' }, { children: jsxRuntime.jsx(SvgIcRotateDevtron, { className: classes ? classes : '' }) })));
 }
 
+// @TODO: Generalize this component to be used in CodeEditor as Chart selector toolbar
+// when the Code Editor is moved to the fe-common-lib
+var ChartVersionAndTypeSelector = function (_a) {
+    var setSelectedChartRefId = _a.setSelectedChartRefId;
+    var _b = __read(React.useState([]), 2), charts = _b[0], setCharts = _b[1];
+    var _c = __read(React.useState(null), 2), selectedChartType = _c[0], setSelectedChartType = _c[1];
+    var _d = __read(React.useState([]), 2), chartVersionOptions = _d[0], setChartVersionOptions = _d[1];
+    var _e = __read(React.useState([]), 2), chartTypeOptions = _e[0], setChartTypeOptions = _e[1];
+    var _f = __read(React.useState(null), 2), selectedChartVersion = _f[0], setSelectedChartVersion = _f[1];
+    React.useEffect(function () {
+        fetchChartTemplateVersions()
+            .then(function (res) {
+            var charts = (res === null || res === void 0 ? void 0 : res.result) || [];
+            setCharts(charts);
+            // Extract unique chart types from the data
+            var chartTypeOptions = __spreadArray([], __read(new Set(charts.map(function (item) { return item.chartType; }))), false).map(function (type) { return ({
+                value: type,
+                label: type,
+            }); });
+            setChartTypeOptions(chartTypeOptions);
+            var filteredVersions = getFilteredChartVersions(charts, chartTypeOptions[0]);
+            selectFirstChartVersion(filteredVersions);
+        })
+            .catch(function (err) {
+            showError(err);
+        });
+    }, []);
+    var selectFirstChartVersion = function (filteredVersions) {
+        var _a;
+        setChartVersionOptions(filteredVersions);
+        setSelectedChartVersion(filteredVersions[0]); // Select the first chart version by default
+        setSelectedChartRefId((_a = filteredVersions[0]) === null || _a === void 0 ? void 0 : _a.chartRefId);
+    };
+    // Function to update chart version options based on selected chart type
+    var handleChartTypeChange = function (selectedOption) {
+        setSelectedChartType(selectedOption);
+        var filteredVersions = getFilteredChartVersions(charts, selectedOption);
+        selectFirstChartVersion(filteredVersions);
+    };
+    // Function to handle the change of the selected chart version
+    var handleChartVersionChange = function (selectedOption) {
+        setSelectedChartVersion(selectedOption);
+        setSelectedChartRefId(selectedOption.chartRefId);
+    };
+    return (jsxRuntime.jsxs("div", __assign({ className: "flex" }, { children: [jsxRuntime.jsxs("div", __assign({ className: "chart-type-options flex", "data-testid": "chart-type-options" }, { children: [jsxRuntime.jsx("span", __assign({ className: "chart-type-options-label mr-4" }, { children: "Chart Type" })), jsxRuntime.jsx(ReactSelect, { value: selectedChartType !== null && selectedChartType !== void 0 ? selectedChartType : chartTypeOptions[0], options: chartTypeOptions, onChange: handleChartTypeChange, styles: customStyles })] })), jsxRuntime.jsxs("div", __assign({ className: "chart-version-options flex", "data-testid": "chart-version-options" }, { children: [jsxRuntime.jsx("span", __assign({ className: "chart-version-options-label mr-4" }, { children: "Chart Version" })), jsxRuntime.jsx(ReactSelect, { value: selectedChartVersion !== null && selectedChartVersion !== void 0 ? selectedChartVersion : chartVersionOptions[0], options: chartVersionOptions, onChange: handleChartVersionChange, styles: customStyles })] }))] })));
+};
+
 function TooltipContent(_a) {
     var tooltipContent = _a.tooltipContent;
     if (tooltipContent) {
@@ -26753,6 +28381,7 @@ exports.BreadCrumb = BreadCrumb;
 exports.BreadcrumbStore = Store;
 exports.BuildStageVariable = BuildStageVariable;
 exports.CDModalTab = CDModalTab;
+exports.ChartVersionAndTypeSelector = ChartVersionAndTypeSelector;
 exports.Checkbox = Checkbox$1;
 exports.ClearIndicator = ClearIndicator;
 exports.ClipboardButton = ClipboardButton;
@@ -26825,17 +28454,22 @@ exports.VisibleModal2 = VisibleModal2;
 exports.closeOnEscKeyPressed = closeOnEscKeyPressed;
 exports.copyToClipboard = copyToClipboard;
 exports.createGitCommitUrl = createGitCommitUrl;
+exports.customStyles = customStyles;
 exports.extractImage = extractImage;
+exports.fetchChartTemplateVersions = fetchChartTemplateVersions;
 exports.genericCDMaterialsService = genericCDMaterialsService;
 exports.get = get;
 exports.getAlphabetIcon = getAlphabetIcon;
 exports.getCookie = getCookie;
 exports.getEmptyArrayOfLength = getEmptyArrayOfLength;
+exports.getFilteredChartVersions = getFilteredChartVersions;
 exports.getInferredTypeFromValueType = getInferredTypeFromValueType;
+exports.getLockedJSON = getLockedJSON;
 exports.getLoginInfo = getLoginInfo;
 exports.getRandomColor = getRandomColor;
 exports.getRedirectionProps = getRedirectionProps;
 exports.getTeamListMin = getTeamListMin;
+exports.getUnlockedJSON = getUnlockedJSON;
 exports.getUrlWithSearchParams = getUrlWithSearchParams;
 exports.getUserRole = getUserRole;
 exports.handleAddCD = handleAddCD;