@aerokit/sdk 12.44.0

package/dist/esm/utils/jsonpath.mjs

@@ -0,0 +1,470 @@
+const globalEval = eval;
+const allowedResultTypes = ["value", "path", "pointer", "parent", "parentProperty", "all"];
+const { hasOwnProperty: hasOwnProp } = Object.prototype;
+const moveToAnotherArray = function(source, target, conditionCb) {
+  const il = source.length;
+  for (let i = 0; i < il; i++) {
+    const item = source[i];
+    if (conditionCb(item)) {
+      target.push(source.splice(i--, 1)[0]);
+    }
+  }
+};
+const vm = {
+  /**
+   * @param {string} expr Expression to evaluate
+   * @param {Object} context Object whose items will be added to evaluation
+   * @returns {*} Result of evaluated code
+   */
+  runInNewContext(expr, context) {
+    const keys = Object.keys(context);
+    const funcs = [];
+    moveToAnotherArray(keys, funcs, (key) => {
+      return typeof context[key] === "function";
+    });
+    const code = funcs.reduce((s, func) => {
+      let fString = context[func].toString();
+      if (!/function/.exec(fString)) {
+        fString = "function " + fString;
+      }
+      return "var " + func + "=" + fString + ";" + s;
+    }, "") + keys.reduce((s, vr) => {
+      return "var " + vr + "=" + JSON.stringify(context[vr]).replace(
+        // http://www.thespanner.co.uk/2011/07/25/the-json-specification-is-now-wrong/
+        /\u2028|\u2029/g,
+        (m) => {
+          return "\\u202" + (m === "\u2028" ? "8" : "9");
+        }
+      ) + ";" + s;
+    }, expr);
+    return globalEval(code);
+  }
+};
+function push(arr, item) {
+  arr = arr.slice();
+  arr.push(item);
+  return arr;
+}
+function unshift(item, arr) {
+  arr = arr.slice();
+  arr.unshift(item);
+  return arr;
+}
+var NewError = function(value) {
+  const error = Error.call(this, 'JSONPath should not be called with "new" (it prevents return of (unwrapped) scalar values)');
+  this.message = error.message;
+  this.stack = error.stack;
+  this.avoidNew = true;
+  this.value = value;
+  this.name = "NewError";
+};
+NewError.prototype = Object.create(Error.prototype);
+NewError.prototype.constructor = NewError;
+function JSONPath(opts, expr, obj, callback, otherTypeCallback) {
+  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 = {};
+  }
+  opts = opts || {};
+  const objArgs = hasOwnProp.call(opts, "json") && hasOwnProp.call(opts, "path");
+  this.json = opts.json || obj;
+  this.path = opts.path || expr;
+  this.resultType = opts.resultType && opts.resultType.toLowerCase() || "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 Error("You must supply an otherTypeCallback callback option with the @other() operator.");
+  };
+  if (opts.autostart !== false) {
+    const ret = this.evaluate({
+      path: objArgs ? opts.path : expr,
+      json: objArgs ? opts.json : obj
+    });
+    if (!ret || typeof ret !== "object") {
+      throw new NewError(ret);
+    }
+    return ret;
+  }
+}
+JSONPath.prototype = Object.create(Object.prototype);
+JSONPath.prototype.constructor = JSONPath;
+JSONPath.prototype.evaluate = function(expr, json, callback, otherTypeCallback) {
+  const that = this;
+  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") {
+    if (!expr.path) {
+      throw new Error('You must supply a "path" property when providing an object argument to JSONPath.evaluate().');
+    }
+    json = hasOwnProp.call(expr, "json") ? expr.json : 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;
+    expr = expr.path;
+  }
+  currParent = currParent || null;
+  currParentProperty = currParentProperty || null;
+  if (Array.isArray(expr)) {
+    expr = JSONPath.toPathString(expr);
+  }
+  if (!expr || !json || allowedResultTypes.indexOf(this.currResultType) < 0) {
+    return void 0;
+  }
+  this._obj = json;
+  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 ? [] : void 0;
+  }
+  if (result.length === 1 && !wrap && !Array.isArray(result[0].value)) {
+    return this._getPreferredOutput(result[0]);
+  }
+  return result.reduce(function(rslt, ea) {
+    const valOrPath = that._getPreferredOutput(ea);
+    if (flatten && Array.isArray(valOrPath)) {
+      rslt = rslt.concat(valOrPath);
+    } else {
+      rslt.push(valOrPath);
+    }
+    return rslt;
+  }, []);
+};
+JSONPath.prototype._getPreferredOutput = function(ea) {
+  const resultType = this.currResultType;
+  switch (resultType) {
+    default:
+      throw new TypeError("Unknown result type");
+    case "all":
+      ea.pointer = JSONPath.toPointer(ea.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);
+  }
+};
+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);
+    callback(preferredOutput, type, fullRetObj);
+  }
+};
+JSONPath.prototype._trace = function(expr, val, path, parent, parentPropName, callback, literalPriority) {
+  let retObj;
+  const that = this;
+  if (!expr.length) {
+    retObj = { path, value: val, parent, parentProperty: parentPropName };
+    this._handleCallback(retObj, callback, "value");
+    return retObj;
+  }
+  const loc = expr[0], x = expr.slice(1);
+  const ret = [];
+  function addRet(elems) {
+    if (Array.isArray(elems)) {
+      elems.forEach((t) => {
+        ret.push(t);
+      });
+    } else {
+      ret.push(elems);
+    }
+  }
+  if ((typeof loc !== "string" || literalPriority) && val && hasOwnProp.call(val, loc)) {
+    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback));
+  } else if (loc === "*") {
+    this._walk(loc, x, val, path, parent, parentPropName, callback, function(m, l, x2, v, p, par, pr, cb) {
+      addRet(that._trace(unshift(m, x2), v, p, par, pr, cb, true));
+    });
+  } else if (loc === "..") {
+    addRet(this._trace(x, val, path, parent, parentPropName, callback));
+    this._walk(loc, x, val, path, parent, parentPropName, callback, function(m, l, x2, v, p, par, pr, cb) {
+      if (typeof v[m] === "object") {
+        addRet(that._trace(unshift(l, x2), v[m], push(p, m), v, m, cb));
+      }
+    });
+  } else if (loc === "^") {
+    this._hasParentSelector = true;
+    return path.length ? {
+      path: path.slice(0, -1),
+      expr: x,
+      isParentSelector: true
+    } : [];
+  } else if (loc === "~") {
+    retObj = { path: push(path, loc), value: parentPropName, parent, parentProperty: null };
+    this._handleCallback(retObj, callback, "property");
+    return retObj;
+  } else if (loc === "$") {
+    addRet(this._trace(x, val, path, null, null, callback));
+  } else if (/^(-?\d*):(-?\d*):?(\d*)$/.test(loc)) {
+    addRet(this._slice(loc, x, val, path, parent, parentPropName, callback));
+  } else if (loc.indexOf("?(") === 0) {
+    if (this.currPreventEval) {
+      throw new Error("Eval [?(expr)] prevented in JSONPath expression.");
+    }
+    this._walk(loc, x, val, path, parent, parentPropName, callback, function(m, l, x2, v, p, par, pr, cb) {
+      if (that._eval(l.replace(/^\?\((.*?)\)$/, "$1"), v[m], m, p, par, pr)) {
+        addRet(that._trace(unshift(m, x2), v, p, par, pr, cb));
+      }
+    });
+  } else if (loc[0] === "(") {
+    if (this.currPreventEval) {
+      throw new Error("Eval [(expr)] prevented in JSONPath expression.");
+    }
+    addRet(this._trace(unshift(
+      this._eval(loc, val, path[path.length - 1], path.slice(0, -1), parent, parentPropName),
+      x
+    ), val, path, parent, parentPropName, callback));
+  } else if (loc[0] === "@") {
+    let addType = false;
+    const valueType = loc.slice(1, -2);
+    switch (valueType) {
+      default:
+        throw new TypeError("Unknown value type " + valueType);
+      case "scalar":
+        if (!val || ["object", "function"].indexOf(typeof val) < 0) {
+          addType = true;
+        }
+        break;
+      case "boolean":
+      case "string":
+      case "undefined":
+      case "function":
+        if (typeof val === valueType) {
+          addType = true;
+        }
+        break;
+      case "number":
+        if (typeof val === valueType && isFinite(val)) {
+          addType = true;
+        }
+        break;
+      case "nonFinite":
+        if (typeof val === "number" && !isFinite(val)) {
+          addType = true;
+        }
+        break;
+      case "object":
+        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 "integer":
+        if (val === Number(val) && isFinite(val) && !(val % 1)) {
+          addType = true;
+        }
+        break;
+      case "null":
+        if (val === null) {
+          addType = true;
+        }
+        break;
+    }
+    if (addType) {
+      retObj = { path, value: val, parent, parentProperty: parentPropName };
+      this._handleCallback(retObj, callback, "value");
+      return retObj;
+    }
+  } 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, true));
+  } else if (loc.indexOf(",") > -1) {
+    const parts = loc.split(",");
+    parts.forEach(function(part) {
+      addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback));
+    }.bind(this));
+  } else if (!literalPriority && val && hasOwnProp.call(val, loc)) {
+    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, true));
+  }
+  if (this._hasParentSelector) {
+    for (let t = 0; t < ret.length; t++) {
+      const rett = ret[t];
+      if (rett.isParentSelector) {
+        const tmp = that._trace(
+          rett.expr,
+          val,
+          rett.path,
+          parent,
+          parentPropName,
+          callback
+        );
+        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(loc, expr, val, path, parent, parentPropName, callback, f) {
+  if (Array.isArray(val)) {
+    const n = val.length;
+    for (let i = 0; i < n; i++) {
+      f(i, loc, expr, val, path, parent, parentPropName, callback);
+    }
+  } else if (typeof val === "object") {
+    for (var m in val) {
+      if (hasOwnProp.call(val, m)) {
+        f(m, loc, expr, val, path, parent, parentPropName, callback);
+      }
+    }
+  }
+};
+JSONPath.prototype._slice = function(loc, expr, val, path, parent, parentPropName, callback) {
+  if (!Array.isArray(val)) {
+    return void 0;
+  }
+  const len = val.length, parts = loc.split(":"), step = parts[2] && parseInt(parts[2]) || 1;
+  let start = parts[0] && parseInt(parts[0]) || 0, end = parts[1] && 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) {
+    let tmp = this._trace(unshift(i, expr), val, path, parent, parentPropName, callback);
+    if (Array.isArray(tmp)) {
+      tmp.forEach((t) => {
+        ret.push(t);
+      });
+    } else {
+      ret.push(tmp);
+    }
+  }
+  return ret;
+};
+JSONPath.prototype._eval = function(code, _v, _vname, path, parent, parentPropName) {
+  if (!this._obj || !_v) {
+    return false;
+  }
+  if (code.indexOf("@parentProperty") > -1) {
+    this.currSandbox._$_parentProperty = parentPropName;
+    code = code.replace(/@parentProperty/g, "_$_parentProperty");
+  }
+  if (code.indexOf("@parent") > -1) {
+    this.currSandbox._$_parent = parent;
+    code = code.replace(/@parent/g, "_$_parent");
+  }
+  if (code.indexOf("@property") > -1) {
+    this.currSandbox._$_property = _vname;
+    code = code.replace(/@property/g, "_$_property");
+  }
+  if (code.indexOf("@path") > -1) {
+    this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));
+    code = code.replace(/@path/g, "_$_path");
+  }
+  if (code.match(/@([.\s)[])/)) {
+    this.currSandbox._$_v = _v;
+    code = code.replace(/@([.\s)[])/g, "_$_v$1");
+  }
+  try {
+    return vm.runInNewContext(code, this.currSandbox);
+  } catch (e) {
+    console.log(e);
+    throw new Error("jsonPath: " + e.message + ": " + code);
+  }
+};
+JSONPath.cache = {};
+JSONPath.toPathString = function(pathArr) {
+  const x = pathArr, n = x.length;
+  let p = "$";
+  for (let i = 1; i < n; i++) {
+    if (!/^(~|\^|@.*?\(\))$/.test(x[i])) {
+      p += /^[0-9*]+$/.test(x[i]) ? "[" + x[i] + "]" : "['" + x[i] + "']";
+    }
+  }
+  return p;
+};
+JSONPath.toPointer = function(pointer) {
+  const x = pointer, n = x.length;
+  let p = "";
+  for (let i = 1; i < n; i++) {
+    if (!/^(~|\^|@.*?\(\))$/.test(x[i])) {
+      p += "/" + x[i].toString().replace(/~/g, "~0").replace(/\//g, "~1");
+    }
+  }
+  return p;
+};
+JSONPath.toPathArray = function(expr) {
+  const { cache } = JSONPath;
+  if (cache[expr]) {
+    return cache[expr].concat();
+  }
+  const subx = [];
+  const normalized = expr.replace(
+    /@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\(\)/g,
+    ";$&;"
+  ).replace(/[['](\??\(.*?\))[\]']/g, function($0, $1) {
+    return "[#" + (subx.push($1) - 1) + "]";
+  }).replace(/\['([^'\]]*)'\]/g, function($0, prop) {
+    return "['" + prop.replace(/\./g, "%@%").replace(/~/g, "%%@@%%") + "']";
+  }).replace(/~/g, ";~;").replace(/'?\.'?(?![^[]*\])|\['?/g, ";").replace(/%@%/g, ".").replace(/%%@@%%/g, "~").replace(/(?:;)?(\^+)(?:;)?/g, function($0, ups) {
+    return ";" + ups.split("").join(";") + ";";
+  }).replace(/;;;|;;/g, ";..;").replace(/;$|'?\]|'$/g, "");
+  const exprList = normalized.split(";").map(function(exp) {
+    const match = exp.match(/#(\d+)/);
+    return !match || !match[1] ? exp : subx[match[1]];
+  });
+  cache[expr] = exprList;
+  return cache[expr];
+};
+var jsonpath_default = JSONPath;
+export {
+  JSONPath,
+  jsonpath_default as default
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/utils/jsonpath.ts"],
  "sourcesContent": ["/*\n* Forked from source published at https://github.com/s3u with MIT\n* license as of 5/30/2019 and adapted for Dirigible\n* Contributors:\n*   s3u (https://github.com/s3u) - initial API and implementation\n*   SAP - adapted for Dirigible\n*/\nconst globalEval = eval;\nconst allowedResultTypes = ['value', 'path', 'pointer', 'parent', 'parentProperty', 'all'];\nconst {hasOwnProperty: hasOwnProp} = Object.prototype;\n\n/**\n * Copy items out of one array into another.\n * @param {Array} source Array with items to copy\n * @param {Array} target Array to which to copy\n * @param {Function} conditionCb Callback passed the current item; will move\n * item if evaluates to `true`\n * @returns {undefined}\n */\nconst moveToAnotherArray = function (source, target, conditionCb) {\n    const il = source.length;\n    for (let i = 0; i < il; i++) {\n        const item = source[i];\n        if (conditionCb(item)) {\n            target.push(source.splice(i--, 1)[0]);\n        }\n    }\n};\n\nconst vm = {\n        /**\n         * @param {string} expr Expression to evaluate\n         * @param {Object} context Object whose items will be added to evaluation\n         * @returns {*} Result of evaluated code\n         */\n        runInNewContext (expr, context) {\n            const keys = Object.keys(context);\n            const funcs = [];\n            moveToAnotherArray(keys, funcs, (key) => {\n                return typeof context[key] === 'function';\n            });\n            const code = funcs.reduce((s, func) => {\n                let fString = context[func].toString();\n                if (!(/function/).exec(fString)) {\n                    fString = 'function ' + fString;\n                }\n                return 'var ' + func + '=' + fString + ';' + s;\n            }, '') + keys.reduce((s, vr) => {\n                return 'var ' + vr + '=' + JSON.stringify(context[vr]).replace(\n                    // http://www.thespanner.co.uk/2011/07/25/the-json-specification-is-now-wrong/\n                    /\\u2028|\\u2029/g, (m) => {\n                        return '\\\\u202' + (m === '\\u2028' ? '8' : '9');\n                    }\n                ) + ';' + s;\n            }, expr);\n            return globalEval(code);\n        }\n    };\n\n/**\n * Copies array and then pushes item into it.\n * @param {Array} arr Array to copy and into which to push\n * @param {*} item Array item to add (to end)\n * @returns {Array} Copy of the original array\n */\nfunction push (arr, item) {\n    arr = arr.slice();\n    arr.push(item);\n    return arr;\n}\n/**\n * Copies array and then unshifts item into it.\n * @param {*} item Array item to add (to beginning)\n * @param {Array} arr Array to copy and into which to unshift\n * @returns {Array} Copy of the original array\n */\nfunction unshift (item, arr) {\n    arr = arr.slice();\n    arr.unshift(item);\n    return arr;\n}\n\n/**\n * Caught when JSONPath is used without `new` but rethrown if with `new`\n * @extends Error\n * @param {*} value The evaluated scalar value\n */\nvar NewError = function (value) {\n    const error = Error.call(this, 'JSONPath should not be called with \"new\" (it prevents return of (unwrapped) scalar values)');\n    this.message = error.message;\n    this.stack = error.stack;\n    this.avoidNew = true;\n    this.value = value;\n    this.name = 'NewError';\n}\nNewError.prototype = Object.create(Error.prototype);\nNewError.prototype.constructor = NewError;\n\n/**\n * @param {Object} [opts] If present, must be an object\n * @param {string} expr JSON path to evaluate\n * @param {JSON} obj JSON object to evaluate against\n * @param {Function} callback Passed 3 arguments: 1) desired payload per `resultType`,\n *     2) `\"value\"|\"property\"`, 3) Full returned object with all payloads\n * @param {Function} otherTypeCallback If `@other()` is at the end of one's query, this\n *  will be invoked with the value of the item, its path, its parent, and its parent's\n *  property name, and it should return a boolean indicating whether the supplied value\n *  belongs to the \"other\" type or not (or it may handle transformations and return `false`).\n * @returns {JSONPath}\n * @class\n */\nexport function JSONPath (opts, expr, obj, callback, otherTypeCallback): void {\n    // eslint-disable-next-line no-restricted-syntax\n    if (!(this instanceof JSONPath)) {\n        try {\n            return new JSONPath(opts, expr, obj, callback, otherTypeCallback);\n        } catch (e) {\n            if (!e.avoidNew) {\n                throw e;\n            }\n            return e.value;\n        }\n    }\n\n    if (typeof opts === 'string') {\n        otherTypeCallback = callback;\n        callback = obj;\n        obj = expr;\n        expr = opts;\n        opts = {};\n    }\n    opts = opts || {};\n    const objArgs = hasOwnProp.call(opts, 'json') && hasOwnProp.call(opts, 'path');\n    this.json = opts.json || obj;\n    this.path = opts.path || expr;\n    this.resultType = (opts.resultType && opts.resultType.toLowerCase()) || 'value';\n    this.flatten = opts.flatten || false;\n    this.wrap = hasOwnProp.call(opts, 'wrap') ? opts.wrap : true;\n    this.sandbox = opts.sandbox || {};\n    this.preventEval = opts.preventEval || false;\n    this.parent = opts.parent || null;\n    this.parentProperty = opts.parentProperty || null;\n    this.callback = opts.callback || callback || null;\n    this.otherTypeCallback = opts.otherTypeCallback || otherTypeCallback || function () {\n        throw new Error('You must supply an otherTypeCallback callback option with the @other() operator.');\n    };\n\n    if (opts.autostart !== false) {\n        const ret = this.evaluate({\n            path: (objArgs ? opts.path : expr),\n            json: (objArgs ? opts.json : obj)\n        });\n        if (!ret || typeof ret !== 'object') {\n            throw new NewError(ret);\n        }\n        return ret;\n    }\n}\nJSONPath.prototype = Object.create(Object.prototype);\nJSONPath.prototype.constructor = JSONPath;\n\n// PUBLIC METHODS\nJSONPath.prototype.evaluate = function (expr, json, callback, otherTypeCallback) {\n    const that = this;\n    let currParent = this.parent,\n        currParentProperty = this.parentProperty;\n    let {flatten, wrap} = this;\n\n    this.currResultType = this.resultType;\n    this.currPreventEval = this.preventEval;\n    this.currSandbox = this.sandbox;\n    callback = callback || this.callback;\n    this.currOtherTypeCallback = otherTypeCallback || this.otherTypeCallback;\n\n    json = json || this.json;\n    expr = expr || this.path;\n    if (expr && typeof expr === 'object') {\n        if (!expr.path) {\n            throw new Error('You must supply a \"path\" property when providing an object argument to JSONPath.evaluate().');\n        }\n        json = hasOwnProp.call(expr, 'json') ? expr.json : json;\n        flatten = hasOwnProp.call(expr, 'flatten') ? expr.flatten : flatten;\n        this.currResultType = hasOwnProp.call(expr, 'resultType') ? expr.resultType : this.currResultType;\n        this.currSandbox = hasOwnProp.call(expr, 'sandbox') ? expr.sandbox : this.currSandbox;\n        wrap = hasOwnProp.call(expr, 'wrap') ? expr.wrap : wrap;\n        this.currPreventEval = hasOwnProp.call(expr, 'preventEval') ? expr.preventEval : this.currPreventEval;\n        callback = hasOwnProp.call(expr, 'callback') ? expr.callback : callback;\n        this.currOtherTypeCallback = hasOwnProp.call(expr, 'otherTypeCallback') ? expr.otherTypeCallback : this.currOtherTypeCallback;\n        currParent = hasOwnProp.call(expr, 'parent') ? expr.parent : currParent;\n        currParentProperty = hasOwnProp.call(expr, 'parentProperty') ? expr.parentProperty : currParentProperty;\n        expr = expr.path;\n    }\n    currParent = currParent || null;\n    currParentProperty = currParentProperty || null;\n\n    if (Array.isArray(expr)) {\n        expr = JSONPath.toPathString(expr);\n    }\n    if (!expr || !json || allowedResultTypes.indexOf(this.currResultType)<0) {\n        return undefined;\n    }\n    this._obj = json;\n\n    const exprList = JSONPath.toPathArray(expr);\n    if (exprList[0] === '$' && exprList.length > 1) { exprList.shift(); }\n    this._hasParentSelector = null;\n    const result = this\n        ._trace(exprList, json, ['$'], currParent, currParentProperty, callback)\n        .filter(function (ea) { return ea && !ea.isParentSelector; });\n\n    if (!result.length) { return wrap ? [] : undefined; }\n    if (result.length === 1 && !wrap && !Array.isArray(result[0].value)) {\n        return this._getPreferredOutput(result[0]);\n    }\n    return result.reduce(function (rslt, ea) {\n        const valOrPath = that._getPreferredOutput(ea);\n        if (flatten && Array.isArray(valOrPath)) {\n            rslt = rslt.concat(valOrPath);\n        } else {\n            rslt.push(valOrPath);\n        }\n        return rslt;\n    }, []);\n};\n\n// PRIVATE METHODS\n\nJSONPath.prototype._getPreferredOutput = function (ea) {\n    const resultType = this.currResultType;\n    switch (resultType) {\n    default:\n        throw new TypeError('Unknown result type');\n    case 'all':\n        ea.pointer = JSONPath.toPointer(ea.path);\n        ea.path = typeof ea.path === 'string' ? ea.path : JSONPath.toPathString(ea.path);\n        return ea;\n    case 'value': case 'parent': case 'parentProperty':\n        return ea[resultType];\n    case 'path':\n        return JSONPath.toPathString(ea[resultType]);\n    case 'pointer':\n        return JSONPath.toPointer(ea.path);\n    }\n};\n\nJSONPath.prototype._handleCallback = function (fullRetObj, callback, type) {\n    if (callback) {\n        const preferredOutput = this._getPreferredOutput(fullRetObj);\n        fullRetObj.path = typeof fullRetObj.path === 'string'\n            ? fullRetObj.path\n            : JSONPath.toPathString(fullRetObj.path);\n        // eslint-disable-next-line callback-return\n        callback(preferredOutput, type, fullRetObj);\n    }\n};\n\nJSONPath.prototype._trace = function (\n    expr, val, path, parent, parentPropName, callback, literalPriority\n) {\n    // No expr to follow? return path and value as the result of this trace branch\n    let retObj;\n    const that = this;\n    if (!expr.length) {\n        retObj = {path: path, value: val, parent: parent, parentProperty: parentPropName};\n        this._handleCallback(retObj, callback, 'value');\n        return retObj;\n    }\n\n    const loc = expr[0], x = expr.slice(1);\n\n    // We need to gather the return value of recursive trace calls in order to\n    // do the parent sel computation.\n    const ret = [];\n    function addRet (elems) {\n        if (Array.isArray(elems)) {\n            // This was causing excessive stack size in Node (with or without Babel) against our performance test: `ret.push(...elems);`\n            elems.forEach((t) => {\n                ret.push(t);\n            });\n        } else {\n            ret.push(elems);\n        }\n    }\n\n    if ((typeof loc !== 'string' || literalPriority) && val &&\n        hasOwnProp.call(val, loc)\n    ) { // simple case--directly follow property\n        addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback));\n    } else if (loc === '*') { // all child properties\n        // eslint-disable-next-line no-shadow\n        this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, x, v, p, par, pr, cb) {\n            addRet(that._trace(unshift(m, x), v, p, par, pr, cb, true));\n        });\n    } else if (loc === '..') { // all descendent parent properties\n        addRet(this._trace(x, val, path, parent, parentPropName, callback)); // Check remaining expression with val's immediate children\n        // eslint-disable-next-line no-shadow\n        this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, x, v, p, par, pr, cb) {\n            // We don't join m and x here because we only want parents, not scalar values\n            if (typeof v[m] === 'object') { // Keep going with recursive descent on val's object children\n                addRet(that._trace(unshift(l, x), v[m], push(p, m), v, m, cb));\n            }\n        });\n    // The parent sel computation is handled in the frame above using the\n    // ancestor object of val\n    } else if (loc === '^') {\n        // This is not a final endpoint, so we do not invoke the callback here\n        this._hasParentSelector = true;\n        return path.length\n            ? {\n                path: path.slice(0, -1),\n                expr: x,\n                isParentSelector: true\n            }\n            : [];\n    } else if (loc === '~') { // property name\n        retObj = {path: push(path, loc), value: parentPropName, parent:parent, parentProperty: null};\n        this._handleCallback(retObj, callback, 'property');\n        return retObj;\n    } else if (loc === '$') { // root only\n        addRet(this._trace(x, val, path, null, null, callback));\n    } else if ((/^(-?\\d*):(-?\\d*):?(\\d*)$/).test(loc)) { // [start:end:step]  Python slice syntax\n        addRet(this._slice(loc, x, val, path, parent, parentPropName, callback));\n    } else if (loc.indexOf('?(') === 0) { // [?(expr)] (filtering)\n        if (this.currPreventEval) {\n            throw new Error('Eval [?(expr)] prevented in JSONPath expression.');\n        }\n        // eslint-disable-next-line no-shadow\n        this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, x, v, p, par, pr, cb) {\n            if (that._eval(l.replace(/^\\?\\((.*?)\\)$/, '$1'), v[m], m, p, par, pr)) {\n                addRet(that._trace(unshift(m, x), v, p, par, pr, cb));\n            }\n        });\n    } else if (loc[0] === '(') { // [(expr)] (dynamic property/index)\n        if (this.currPreventEval) {\n            throw new Error('Eval [(expr)] prevented in JSONPath expression.');\n        }\n        // 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\n        addRet(this._trace(unshift(\n            this._eval(loc, val, path[path.length - 1], path.slice(0, -1), parent, parentPropName),\n            x\n        ), val, path, parent, parentPropName, callback));\n    } else if (loc[0] === '@') { // value type: @boolean(), etc.\n        let addType = false;\n        const valueType = loc.slice(1, -2);\n        switch (valueType) {\n        default:\n            throw new TypeError('Unknown value type ' + valueType);\n        case 'scalar':\n            if (!val || (['object', 'function'].indexOf(typeof val)<0)) {\n                addType = true;\n            }\n            break;\n        case 'boolean': case 'string': case 'undefined': case 'function':\n            if (typeof val === valueType) { // eslint-disable-line valid-typeof\n                addType = true;\n            }\n            break;\n        case 'number':\n            if (typeof val === valueType && isFinite(val)) { // eslint-disable-line valid-typeof\n                addType = true;\n            }\n            break;\n        case 'nonFinite':\n            if (typeof val === 'number' && !isFinite(val)) {\n                addType = true;\n            }\n            break;\n        case 'object':\n            if (val && typeof val === valueType) { // eslint-disable-line valid-typeof\n                addType = true;\n            }\n            break;\n        case 'array':\n            if (Array.isArray(val)) {\n                addType = true;\n            }\n            break;\n        case 'other':\n            addType = this.currOtherTypeCallback(val, path, parent, parentPropName);\n            break;\n        case 'integer':\n            if (val === Number(val) && isFinite(val) && !(val % 1)) {\n                addType = true;\n            }\n            break;\n        case 'null':\n            if (val === null) {\n                addType = true;\n            }\n            break;\n        }\n        if (addType) {\n            retObj = {path: path, value: val, parent: parent, parentProperty: parentPropName};\n            this._handleCallback(retObj, callback, 'value');\n            return retObj;\n        }\n    } else if (loc[0] === '`' && val && hasOwnProp.call(val, loc.slice(1))) { // `-escaped property\n        const locProp = loc.slice(1);\n        addRet(this._trace(x, val[locProp], push(path, locProp), val, locProp, callback, true));\n    } else if (loc.indexOf(',')>-1) { // [name1,name2,...]\n        const parts = loc.split(',');\n        parts.forEach(function(part){\n            addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback));\n        }.bind(this))\n    } else if (!literalPriority && val && hasOwnProp.call(val, loc)) { // simple case--directly follow property\n        addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, true));\n    }\n\n    // We check the resulting values for parent selections. For parent\n    // selections we discard the value object and continue the trace with the\n    // current val object\n    if (this._hasParentSelector) {\n        // eslint-disable-next-line unicorn/no-for-loop\n        for (let t = 0; t < ret.length; t++) {\n            const rett = ret[t];\n            if (rett.isParentSelector) {\n                const tmp = that._trace(\n                    rett.expr, val, rett.path, parent, parentPropName, callback\n                );\n                if (Array.isArray(tmp)) {\n                    ret[t] = tmp[0];\n                    const tl = tmp.length;\n                    for (let tt = 1; tt < tl; tt++) {\n                        t++;\n                        ret.splice(t, 0, tmp[tt]);\n                    }\n                } else {\n                    ret[t] = tmp;\n                }\n            }\n        }\n    }\n\n    return ret;\n};\n\nJSONPath.prototype._walk = function (loc, expr, val, path, parent, parentPropName, callback, f) {\n    if (Array.isArray(val)) {\n        const n = val.length;\n        for (let i = 0; i < n; i++) {\n            f(i, loc, expr, val, path, parent, parentPropName, callback);\n        }\n    } else if (typeof val === 'object') {\n        for (var m in val) { // originally m declared as `const`, but this is not allowed in Rhino\n            if (hasOwnProp.call(val, m)) {\n                f(m, loc, expr, val, path, parent, parentPropName, callback);\n            }\n        }\n    }\n};\n\nJSONPath.prototype._slice = function (loc, expr, val, path, parent, parentPropName, callback) {\n    if (!Array.isArray(val)) { return undefined; }\n    const len = val.length, parts = loc.split(':'),\n        step = (parts[2] && parseInt(parts[2])) || 1;\n    let start = (parts[0] && parseInt(parts[0])) || 0,\n        end = (parts[1] && parseInt(parts[1])) || len;\n    start = (start < 0) ? Math.max(0, start + len) : Math.min(len, start);\n    end = (end < 0) ? Math.max(0, end + len) : Math.min(len, end);\n    const ret = [];\n    for (let i = start; i < end; i += step) {\n        let tmp = this._trace(unshift(i, expr), val, path, parent, parentPropName, callback);// originally declared as `const`, this doesn't work in Rhino\n        if (Array.isArray(tmp)) {\n            // This was causing excessive stack size in Node (with or without Babel) against our performance test: `ret.push(...tmp);`\n            tmp.forEach((t) => {\n                ret.push(t);\n            });\n        } else {\n            ret.push(tmp);\n        }\n    }\n    return ret;\n};\n\nJSONPath.prototype._eval = function (code, _v, _vname, path, parent, parentPropName) {\n    if (!this._obj || !_v) { return false; }\n    if (code.indexOf('@parentProperty')>-1) {\n        this.currSandbox._$_parentProperty = parentPropName;\n        code = code.replace(/@parentProperty/g, '_$_parentProperty');\n    }\n    if (code.indexOf('@parent')>-1) {\n        this.currSandbox._$_parent = parent;\n        code = code.replace(/@parent/g, '_$_parent');\n    }\n    if (code.indexOf('@property')>-1) {\n        this.currSandbox._$_property = _vname;\n        code = code.replace(/@property/g, '_$_property');\n    }\n    if (code.indexOf('@path')>-1) {\n        this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));\n        code = code.replace(/@path/g, '_$_path');\n    }\n    if (code.match(/@([.\\s)[])/)) {\n        this.currSandbox._$_v = _v;\n        code = code.replace(/@([.\\s)[])/g, '_$_v$1');\n    }\n    try {\n        return vm.runInNewContext(code, this.currSandbox);\n    } catch (e) {\n        // eslint-disable-next-line no-console\n        console.log(e);\n        throw new Error('jsonPath: ' + e.message + ': ' + code);\n    }\n};\n\n// PUBLIC CLASS PROPERTIES AND METHODS\n\n// Could store the cache object itself\nJSONPath.cache = {};\n\n/**\n * @param {string[]} pathArr Array to convert\n * @returns {string} The path string\n */\nJSONPath.toPathString = function (pathArr) {\n    const x = pathArr, n = x.length;\n    let p = '$';\n    for (let i = 1; i < n; i++) {\n        if (!(/^(~|\\^|@.*?\\(\\))$/).test(x[i])) {\n            p += (/^[0-9*]+$/).test(x[i]) ? ('[' + x[i] + ']') : (\"['\" + x[i] + \"']\");\n        }\n    }\n    return p;\n};\n\n/**\n * @param {string} pointer JSON Path\n * @returns {string} JSON Pointer\n */\nJSONPath.toPointer = function (pointer) {\n    const x = pointer, n = x.length;\n    let p = '';\n    for (let i = 1; i < n; i++) {\n        if (!(/^(~|\\^|@.*?\\(\\))$/).test(x[i])) {\n            p += '/' + x[i].toString()\n                .replace(/~/g, '~0')\n                .replace(/\\//g, '~1');\n        }\n    }\n    return p;\n};\n\n/**\n * @param {string} expr Expression to convert\n * @returns {string[]}\n */\nJSONPath.toPathArray = function (expr) {\n    const {cache} = JSONPath;\n    if (cache[expr]) { return cache[expr].concat(); }\n    const subx = [];\n    const normalized = expr\n        // Properties\n        .replace(\n            /@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\\(\\)/g,\n            ';$&;'\n        )\n        // Parenthetical evaluations (filtering and otherwise), directly\n        //   within brackets or single quotes\n        .replace(/[['](\\??\\(.*?\\))[\\]']/g, function ($0, $1) {\n            return '[#' + (subx.push($1) - 1) + ']';\n        })\n        // Escape periods and tildes within properties\n        .replace(/\\['([^'\\]]*)'\\]/g, function ($0, prop) {\n            return \"['\" + prop\n                .replace(/\\./g, '%@%')\n                .replace(/~/g, '%%@@%%') +\n                \"']\";\n        })\n        // Properties operator\n        .replace(/~/g, ';~;')\n        // Split by property boundaries\n        .replace(/'?\\.'?(?![^[]*\\])|\\['?/g, ';')\n        // Reinsert periods within properties\n        .replace(/%@%/g, '.')\n        // Reinsert tildes within properties\n        .replace(/%%@@%%/g, '~')\n        // Parent\n        .replace(/(?:;)?(\\^+)(?:;)?/g, function ($0, ups) {\n            return ';' + ups.split('').join(';') + ';';\n        })\n        // Descendents\n        .replace(/;;;|;;/g, ';..;')\n        // Remove trailing\n        .replace(/;$|'?\\]|'$/g, '');\n\n    const exprList = normalized.split(';').map(function (exp) {\n        const match = exp.match(/#(\\d+)/);\n        return !match || !match[1] ? exp : subx[match[1]];\n    });\n    cache[expr] = exprList;\n    return cache[expr];\n};\n\nexport default JSONPath;\n"],
  "mappings": "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",
  "names": ["x"]
}


package/dist/esm/utils/qrcode.mjs

@@ -0,0 +1,22 @@
+import { Bytes } from "@aerokit/sdk/io/bytes";
+const QRCodeFacade = Java.type("org.eclipse.dirigible.components.api.utils.QRCodeFacade");
+class QRCode {
+  /**
+   * Generates a QR code image byte array from the given text.
+   * The returned byte array represents the image data (e.g., PNG or JPEG format,
+   * depending on the native implementation's default output).
+   *
+   * @param text The string content to be encoded in the QR code.
+   * @returns A **JavaScript byte array (any[])** containing the raw QR code image data.
+   */
+  static generateQRCode(text) {
+    return Bytes.toJavaScriptBytes(QRCodeFacade.generateQRCode(text));
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = QRCode;
+}
+export {
+  QRCode
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL3V0aWxzL3FyY29kZS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0IHsgQnl0ZXMgfSBmcm9tIFwiQGFlcm9raXQvc2RrL2lvL2J5dGVzXCI7XG5jb25zdCBRUkNvZGVGYWNhZGUgPSBKYXZhLnR5cGUoXCJvcmcuZWNsaXBzZS5kaXJpZ2libGUuY29tcG9uZW50cy5hcGkudXRpbHMuUVJDb2RlRmFjYWRlXCIpO1xuXG4vKipcbiAqIFV0aWxpdHkgY2xhc3MgZm9yIGdlbmVyYXRpbmcgUVIgY29kZXMuXG4gKiBJdCB1c2VzIHRoZSB1bmRlcmx5aW5nIG5hdGl2ZSBKYXZhIFFSQ29kZUZhY2FkZSB0byBjb252ZXJ0IHRleHQgaW50b1xuICogYSBRUiBjb2RlIGltYWdlIHJlcHJlc2VudGVkIGFzIGEgcmF3IGJ5dGUgYXJyYXkuXG4gKi9cbmV4cG9ydCBjbGFzcyBRUkNvZGUge1xuXG4gICAgLyoqXG4gICAgICogR2VuZXJhdGVzIGEgUVIgY29kZSBpbWFnZSBieXRlIGFycmF5IGZyb20gdGhlIGdpdmVuIHRleHQuXG4gICAgICogVGhlIHJldHVybmVkIGJ5dGUgYXJyYXkgcmVwcmVzZW50cyB0aGUgaW1hZ2UgZGF0YSAoZS5nLiwgUE5HIG9yIEpQRUcgZm9ybWF0LFxuICAgICAqIGRlcGVuZGluZyBvbiB0aGUgbmF0aXZlIGltcGxlbWVudGF0aW9uJ3MgZGVmYXVsdCBvdXRwdXQpLlxuICAgICAqXG4gICAgICogQHBhcmFtIHRleHQgVGhlIHN0cmluZyBjb250ZW50IHRvIGJlIGVuY29kZWQgaW4gdGhlIFFSIGNvZGUuXG4gICAgICogQHJldHVybnMgQSAqKkphdmFTY3JpcHQgYnl0ZSBhcnJheSAoYW55W10pKiogY29udGFpbmluZyB0aGUgcmF3IFFSIGNvZGUgaW1hZ2UgZGF0YS5cbiAgICAgKi9cbiAgICBwdWJsaWMgc3RhdGljIGdlbmVyYXRlUVJDb2RlKHRleHQ6IHN0cmluZyk6IGFueVtdIHtcbiAgICAgICAgcmV0dXJuIEJ5dGVzLnRvSmF2YVNjcmlwdEJ5dGVzKFFSQ29kZUZhY2FkZS5nZW5lcmF0ZVFSQ29kZSh0ZXh0KSk7XG4gICAgfVxufVxuXG4vLyBAdHMtaWdub3JlXG5pZiAodHlwZW9mIG1vZHVsZSAhPT0gJ3VuZGVmaW5lZCcpIHtcbiAgICAvLyBAdHMtaWdub3JlXG4gICAgbW9kdWxlLmV4cG9ydHMgPSBRUkNvZGU7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiQUFBQSxTQUFTLGFBQWE7QUFDdEIsTUFBTSxlQUFlLEtBQUssS0FBSyx5REFBeUQ7QUFPakYsTUFBTSxPQUFPO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBVWhCLE9BQWMsZUFBZSxNQUFxQjtBQUM5QyxXQUFPLE1BQU0sa0JBQWtCLGFBQWEsZUFBZSxJQUFJLENBQUM7QUFBQSxFQUNwRTtBQUNKO0FBR0EsSUFBSSxPQUFPLFdBQVcsYUFBYTtBQUUvQixTQUFPLFVBQVU7QUFDckI7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/esm/utils/url.mjs

@@ -0,0 +1,63 @@
+const UrlFacade = Java.type("org.eclipse.dirigible.components.api.utils.UrlFacade");
+class URL {
+  /**
+   * URL-encodes the input string, typically used for encoding query parameter values.
+   *
+   * @param input The string to be encoded.
+   * @param charset The character set (e.g., 'UTF-8', 'ISO-8859-1') to use for encoding. Defaults to the system's preferred encoding if omitted.
+   * @returns The URL-encoded string.
+   */
+  static encode(input, charset) {
+    return UrlFacade.encode(input, charset);
+  }
+  /**
+   * URL-decodes the input string, typically used for decoding query parameter values.
+   *
+   * @param input The string to be decoded.
+   * @param charset The character set (e.g., 'UTF-8', 'ISO-8859-1') that was used for encoding. Defaults to the system's preferred encoding if omitted.
+   * @returns The URL-decoded string.
+   */
+  static decode(input, charset) {
+    return UrlFacade.decode(input, charset);
+  }
+  /**
+   * Escapes the input string using general URL escaping rules.
+   * This is typically equivalent to `encodeURIComponent` and is suitable for
+   * encoding query parameter *values*.
+   *
+   * @param input The string to escape.
+   * @returns The escaped string.
+   */
+  static escape(input) {
+    return UrlFacade.escape(input);
+  }
+  /**
+   * Escapes the input string specifically for use as a **URL path segment**.
+   * It typically preserves path delimiters like `/` that might otherwise be escaped
+   * in standard URL encoding.
+   *
+   * @param input The path string to escape.
+   * @returns The escaped path string.
+   */
+  static escapePath(input) {
+    return UrlFacade.escapePath(input);
+  }
+  /**
+   * Escapes the input string according to the rules for **HTML Form Data**
+   * (application/x-www-form-urlencoded). This typically replaces spaces with `+`
+   * instead of `%20`.
+   *
+   * @param input The form data string to escape.
+   * @returns The escaped form data string.
+   */
+  static escapeForm(input) {
+    return UrlFacade.escapeForm(input);
+  }
+}
+if (typeof module !== "undefined") {
+  module.exports = URL;
+}
+export {
+  URL
+};
+//# sourceMappingURL=data:application/json;base64,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