@bigbinary/neeto-audit-frontend 2.0.5 → 2.0.6

package/dist/index.js

@@ -3044,31 +3044,31 @@ function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
 
-function _iterableToArrayLimit(arr, i) {
-  var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
-  if (null != _i) {
-    var _s,
-      _e,
-      _x,
-      _r,
-      _arr = [],
-      _n = !0,
-      _d = !1;
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
     try {
-      if (_x = (_i = _i.call(arr)).next, 0 === i) {
-        if (Object(_i) !== _i) return;
-        _n = !1;
-      } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
-    } catch (err) {
-      _d = !0, _e = err;
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
     } finally {
       try {
-        if (!_n && null != _i["return"] && (_r = _i["return"](), Object(_r) !== _r)) return;
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
       } finally {
-        if (_d) throw _e;
+        if (o) throw n;
       }
     }
-    return _arr;
+    return a;
   }
 }
 
@@ -3095,111 +3095,154 @@ function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
 
-function _typeof(obj) {
+function _typeof(o) {
   "@babel/helpers - typeof";
 
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, _typeof(obj);
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
 }
 
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function ownKeys$1(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 // src/utils/env.ts
-var NOTHING = Symbol.for("immer-nothing");
-var DRAFTABLE = Symbol.for("immer-draftable");
-var DRAFT_STATE = Symbol.for("immer-state");
+var NOTHING = Symbol["for"]("immer-nothing");
+var DRAFTABLE = Symbol["for"]("immer-draftable");
+var DRAFT_STATE = Symbol["for"]("immer-state");
 
 // src/utils/errors.ts
 var errors$1 = process.env.NODE_ENV !== "production" ? [
-  // All error codes, starting by 0:
-  function(plugin) {
-    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
-  },
-  function(thing) {
-    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
-  },
-  "This object has been frozen and should not be mutated",
-  function(data) {
-    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
-  },
-  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
-  "Immer forbids circular references",
-  "The first or second argument to `produce` must be a function",
-  "The third argument to `produce` must be a function or undefined",
-  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
-  "First argument to `finishDraft` must be a draft returned by `createDraft`",
-  function(thing) {
-    return `'current' expects a draft, got: ${thing}`;
-  },
-  "Object.defineProperty() cannot be used on an Immer draft",
-  "Object.setPrototypeOf() cannot be used on an Immer draft",
-  "Immer only supports deleting array indices",
-  "Immer only supports setting array indices and the 'length' property",
-  function(thing) {
-    return `'original' expects a draft, got: ${thing}`;
-  }
-  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
-  // See Patches.ts for additional errors
+// All error codes, starting by 0:
+function (plugin) {
+  return "The plugin for '".concat(plugin, "' has not been loaded into Immer. To enable the plugin, import and call `enable").concat(plugin, "()` when initializing your application.");
+}, function (thing) {
+  return "produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '".concat(thing, "'");
+}, "This object has been frozen and should not be mutated", function (data) {
+  return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+}, "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.", "Immer forbids circular references", "The first or second argument to `produce` must be a function", "The third argument to `produce` must be a function or undefined", "First argument to `createDraft` must be a plain object, an array, or an immerable object", "First argument to `finishDraft` must be a draft returned by `createDraft`", function (thing) {
+  return "'current' expects a draft, got: ".concat(thing);
+}, "Object.defineProperty() cannot be used on an Immer draft", "Object.setPrototypeOf() cannot be used on an Immer draft", "Immer only supports deleting array indices", "Immer only supports setting array indices and the 'length' property", function (thing) {
+  return "'original' expects a draft, got: ".concat(thing);
+}
+// Note: if more errors are added, the errorOffset in Patches.ts should be increased
+// See Patches.ts for additional errors
 ] : [];
-function die(error, ...args) {
+function die(error) {
   if (process.env.NODE_ENV !== "production") {
-    const e = errors$1[error];
-    const msg = typeof e === "function" ? e.apply(null, args) : e;
-    throw new Error(`[Immer] ${msg}`);
+    var e = errors$1[error];
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key2 = 1; _key2 < _len; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    var msg = typeof e === "function" ? e.apply(null, args) : e;
+    throw new Error("[Immer] ".concat(msg));
   }
-  throw new Error(
-    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
-  );
+  throw new Error("[Immer] minified error nr: ".concat(error, ". Full error at: https://bit.ly/3cXEKWf"));
 }
 
 // src/utils/common.ts
-var getPrototypeOf$1 = Object.getPrototypeOf;
+var _getPrototypeOf = Object.getPrototypeOf;
 function isDraft(value) {
   return !!value && !!value[DRAFT_STATE];
 }
 function isDraftable(value) {
-  if (!value)
-    return false;
-  return isPlainObject$1(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+  var _value$constructor;
+  if (!value) return false;
+  return isPlainObject$1(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!((_value$constructor = value.constructor) !== null && _value$constructor !== void 0 && _value$constructor[DRAFTABLE]) || isMap(value) || isSet(value);
 }
 var objectCtorString = Object.prototype.constructor.toString();
 function isPlainObject$1(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  const proto = getPrototypeOf$1(value);
+  if (!value || _typeof(value) !== "object") return false;
+  var proto = _getPrototypeOf(value);
   if (proto === null) {
     return true;
   }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  if (Ctor === Object)
-    return true;
+  var Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object) return true;
   return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
 }
 function each(obj, iter) {
   if (getArchtype(obj) === 0 /* Object */) {
-    Object.entries(obj).forEach(([key, value]) => {
+    Object.entries(obj).forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
       iter(key, value, obj);
     });
   } else {
-    obj.forEach((entry, index) => iter(index, entry, obj));
+    obj.forEach(function (entry, index) {
+      return iter(index, entry, obj);
+    });
   }
 }
 function getArchtype(thing) {
-  const state = thing[DRAFT_STATE];
+  var state = thing[DRAFT_STATE];
   return state ? state.type_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
 }
 function has(thing, prop) {
   return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
 }
 function set(thing, propOrOldValue, value) {
-  const t = getArchtype(thing);
-  if (t === 2 /* Map */)
-    thing.set(propOrOldValue, value);
-  else if (t === 3 /* Set */) {
+  var t = getArchtype(thing);
+  if (t === 2 /* Map */) thing.set(propOrOldValue, value);else if (t === 3 /* Set */) {
     thing.add(value);
-  } else
-    thing[propOrOldValue] = value;
+  } else thing[propOrOldValue] = value;
 }
 function is(x, y) {
   if (x === y) {
@@ -3224,45 +3267,44 @@ function shallowCopy(base, strict) {
   if (isSet(base)) {
     return new Set(base);
   }
-  if (Array.isArray(base))
-    return Array.prototype.slice.call(base);
+  if (Array.isArray(base)) return Array.prototype.slice.call(base);
   if (!strict && isPlainObject$1(base)) {
-    if (!getPrototypeOf$1(base)) {
-      const obj = /* @__PURE__ */ Object.create(null);
+    if (!_getPrototypeOf(base)) {
+      var obj = /* @__PURE__ */Object.create(null);
       return Object.assign(obj, base);
     }
-    return { ...base };
+    return _objectSpread$1({}, base);
   }
-  const descriptors = Object.getOwnPropertyDescriptors(base);
+  var descriptors = Object.getOwnPropertyDescriptors(base);
   delete descriptors[DRAFT_STATE];
-  let keys = Reflect.ownKeys(descriptors);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    const desc = descriptors[key];
+  var keys = Reflect.ownKeys(descriptors);
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var desc = descriptors[key];
     if (desc.writable === false) {
       desc.writable = true;
       desc.configurable = true;
     }
-    if (desc.get || desc.set)
-      descriptors[key] = {
-        configurable: true,
-        writable: true,
-        // could live with !!desc.set as well here...
-        enumerable: desc.enumerable,
-        value: base[key]
-      };
+    if (desc.get || desc.set) descriptors[key] = {
+      configurable: true,
+      writable: true,
+      // could live with !!desc.set as well here...
+      enumerable: desc.enumerable,
+      value: base[key]
+    };
   }
-  return Object.create(getPrototypeOf$1(base), descriptors);
+  return Object.create(_getPrototypeOf(base), descriptors);
 }
-function freeze(obj, deep = false) {
-  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
-    return obj;
+function freeze(obj) {
+  var deep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj;
   if (getArchtype(obj) > 1) {
-    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
+    obj.set = obj.add = obj.clear = obj["delete"] = dontMutateFrozenCollections;
   }
   Object.freeze(obj);
-  if (deep)
-    each(obj, (_key, value) => freeze(value, true));
+  if (deep) each(obj, function (_key, value) {
+    return freeze(value, true);
+  });
   return obj;
 }
 function dontMutateFrozenCollections() {
@@ -3275,7 +3317,7 @@ function isFrozen(obj) {
 // src/utils/plugins.ts
 var plugins = {};
 function getPlugin(pluginKey) {
-  const plugin = plugins[pluginKey];
+  var plugin = plugins[pluginKey];
   if (!plugin) {
     die(0, pluginKey);
   }
@@ -3290,8 +3332,8 @@ function getCurrentScope() {
 function createScope(parent_, immer_) {
   return {
     drafts_: [],
-    parent_,
-    immer_,
+    parent_: parent_,
+    immer_: immer_,
     // Whenever the modified draft contains a draft from another scope, we
     // need to prevent auto-freezing so the unowned draft can be finalized.
     canAutoFreeze_: true,
@@ -3320,18 +3362,15 @@ function enterScope(immer2) {
   return currentScope = createScope(currentScope, immer2);
 }
 function revokeDraft(draft) {
-  const state = draft[DRAFT_STATE];
-  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)
-    state.revoke_();
-  else
-    state.revoked_ = true;
+  var state = draft[DRAFT_STATE];
+  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */) state.revoke_();else state.revoked_ = true;
 }
 
 // src/core/finalize.ts
 function processResult(result, scope) {
   scope.unfinalizedDrafts_ = scope.drafts_.length;
-  const baseDraft = scope.drafts_[0];
-  const isReplaced = result !== void 0 && result !== baseDraft;
+  var baseDraft = scope.drafts_[0];
+  var isReplaced = result !== void 0 && result !== baseDraft;
   if (isReplaced) {
     if (baseDraft[DRAFT_STATE].modified_) {
       revokeScope(scope);
@@ -3339,16 +3378,10 @@ function processResult(result, scope) {
     }
     if (isDraftable(result)) {
       result = finalize(scope, result);
-      if (!scope.parent_)
-        maybeFreeze(scope, result);
+      if (!scope.parent_) maybeFreeze(scope, result);
     }
     if (scope.patches_) {
-      getPlugin("Patches").generateReplacementPatches_(
-        baseDraft[DRAFT_STATE].base_,
-        result,
-        scope.patches_,
-        scope.inversePatches_
-      );
+      getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_);
     }
   } else {
     result = finalize(scope, baseDraft, []);
@@ -3360,17 +3393,15 @@ function processResult(result, scope) {
   return result !== NOTHING ? result : void 0;
 }
 function finalize(rootScope, value, path) {
-  if (isFrozen(value))
-    return value;
-  const state = value[DRAFT_STATE];
+  if (isFrozen(value)) return value;
+  var state = value[DRAFT_STATE];
   if (!state) {
-    each(
-      value,
-      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path));
+    each(value, function (key, childValue) {
+      return finalizeProperty(rootScope, state, value, key, childValue, path);
+    });
     return value;
   }
-  if (state.scope_ !== rootScope)
-    return value;
+  if (state.scope_ !== rootScope) return value;
   if (!state.modified_) {
     maybeFreeze(rootScope, state.base_, true);
     return state.base_;
@@ -3378,42 +3409,35 @@ function finalize(rootScope, value, path) {
   if (!state.finalized_) {
     state.finalized_ = true;
     state.scope_.unfinalizedDrafts_--;
-    const result = state.copy_;
-    let resultEach = result;
-    let isSet2 = false;
+    var result = state.copy_;
+    var resultEach = result;
+    var isSet2 = false;
     if (state.type_ === 3 /* Set */) {
       resultEach = new Set(result);
       result.clear();
       isSet2 = true;
     }
-    each(
-      resultEach,
-      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
-    );
+    each(resultEach, function (key, childValue) {
+      return finalizeProperty(rootScope, state, result, key, childValue, path, isSet2);
+    });
     maybeFreeze(rootScope, result, false);
     if (path && rootScope.patches_) {
-      getPlugin("Patches").generatePatches_(
-        state,
-        path,
-        rootScope.patches_,
-        rootScope.inversePatches_
-      );
+      getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_);
     }
   }
   return state.copy_;
 }
 function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
-  if (process.env.NODE_ENV !== "production" && childValue === targetObject)
-    die(5);
+  if (process.env.NODE_ENV !== "production" && childValue === targetObject) die(5);
   if (isDraft(childValue)) {
-    const path = rootPath && parentState && parentState.type_ !== 3 /* Set */ && // Set objects are atomic since they have no keys.
+    var path = rootPath && parentState && parentState.type_ !== 3 /* Set */ &&
+    // Set objects are atomic since they have no keys.
     !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
-    const res = finalize(rootScope, childValue, path);
+    var res = finalize(rootScope, childValue, path);
     set(targetObject, prop, res);
     if (isDraft(res)) {
       rootScope.canAutoFreeze_ = false;
-    } else
-      return;
+    } else return;
   } else if (targetIsSet) {
     targetObject.add(childValue);
   }
@@ -3422,11 +3446,11 @@ function finalizeProperty(rootScope, parentState, targetObject, prop, childValue
       return;
     }
     finalize(rootScope, childValue);
-    if (!parentState || !parentState.scope_.parent_)
-      maybeFreeze(rootScope, childValue);
+    if (!parentState || !parentState.scope_.parent_) maybeFreeze(rootScope, childValue);
   }
 }
-function maybeFreeze(scope, value, deep = false) {
+function maybeFreeze(scope, value) {
+  var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
     freeze(value, deep);
   }
@@ -3434,9 +3458,10 @@ function maybeFreeze(scope, value, deep = false) {
 
 // src/core/proxy.ts
 function createProxyProxy(base, parent) {
-  const isArray = Array.isArray(base);
-  const state = {
+  var isArray = Array.isArray(base);
+  var state = {
     type_: isArray ? 1 /* Array */ : 0 /* Object */,
+
     // Track which produce call this is associated with.
     scope_: parent ? parent.scope_ : getCurrentScope(),
     // True for both shallow and deep changes.
@@ -3458,26 +3483,27 @@ function createProxyProxy(base, parent) {
     revoke_: null,
     isManual_: false
   };
-  let target = state;
-  let traps = objectTraps;
+  var target = state;
+  var traps = objectTraps;
   if (isArray) {
     target = [state];
     traps = arrayTraps;
   }
-  const { revoke, proxy } = Proxy.revocable(target, traps);
+  var _Proxy$revocable = Proxy.revocable(target, traps),
+    revoke = _Proxy$revocable.revoke,
+    proxy = _Proxy$revocable.proxy;
   state.draft_ = proxy;
   state.revoke_ = revoke;
   return proxy;
 }
 var objectTraps = {
-  get(state, prop) {
-    if (prop === DRAFT_STATE)
-      return state;
-    const source = latest(state);
+  get: function get(state, prop) {
+    if (prop === DRAFT_STATE) return state;
+    var source = latest(state);
     if (!has(source, prop)) {
       return readPropFromProto(state, source, prop);
     }
-    const value = source[prop];
+    var value = source[prop];
     if (state.finalized_ || !isDraftable(value)) {
       return value;
     }
@@ -3487,40 +3513,40 @@ var objectTraps = {
     }
     return value;
   },
-  has(state, prop) {
+  has: function has(state, prop) {
     return prop in latest(state);
   },
-  ownKeys(state) {
+  ownKeys: function ownKeys(state) {
     return Reflect.ownKeys(latest(state));
   },
-  set(state, prop, value) {
-    const desc = getDescriptorFromProto(latest(state), prop);
-    if (desc?.set) {
+  set: function set(state, prop, value) {
+    var desc = getDescriptorFromProto(latest(state), prop);
+    if (desc !== null && desc !== void 0 && desc.set) {
       desc.set.call(state.draft_, value);
       return true;
     }
     if (!state.modified_) {
-      const current2 = peek(latest(state), prop);
-      const currentState = current2?.[DRAFT_STATE];
+      var current2 = peek(latest(state), prop);
+      var currentState = current2 === null || current2 === void 0 ? void 0 : current2[DRAFT_STATE];
       if (currentState && currentState.base_ === value) {
         state.copy_[prop] = value;
         state.assigned_[prop] = false;
         return true;
       }
-      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
-        return true;
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop))) return true;
       prepareCopy(state);
       markChanged(state);
     }
-    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
-    (value !== void 0 || prop in state.copy_) || // special case: NaN
-    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
-      return true;
+    if (state.copy_[prop] === value && (
+    // special case: handle new props with value 'undefined'
+    value !== void 0 || prop in state.copy_) ||
+    // special case: NaN
+    Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true;
     state.copy_[prop] = value;
     state.assigned_[prop] = true;
     return true;
   },
-  deleteProperty(state, prop) {
+  deleteProperty: function deleteProperty(state, prop) {
     if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
       state.assigned_[prop] = false;
       prepareCopy(state);
@@ -3535,11 +3561,10 @@ var objectTraps = {
   },
   // Note: We never coerce `desc.value` into an Immer draft, because we can't make
   // the same guarantee in ES5 mode.
-  getOwnPropertyDescriptor(state, prop) {
-    const owner = latest(state);
-    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
-    if (!desc)
-      return desc;
+  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(state, prop) {
+    var owner = latest(state);
+    var desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+    if (!desc) return desc;
     return {
       writable: true,
       configurable: state.type_ !== 1 /* Array */ || prop !== "length",
@@ -3547,55 +3572,50 @@ var objectTraps = {
       value: owner[prop]
     };
   },
-  defineProperty() {
+  defineProperty: function defineProperty() {
     die(11);
   },
-  getPrototypeOf(state) {
-    return getPrototypeOf$1(state.base_);
+  getPrototypeOf: function getPrototypeOf(state) {
+    return _getPrototypeOf(state.base_);
   },
-  setPrototypeOf() {
+  setPrototypeOf: function setPrototypeOf() {
     die(12);
   }
 };
 var arrayTraps = {};
-each(objectTraps, (key, fn) => {
-  arrayTraps[key] = function() {
+each(objectTraps, function (key, fn) {
+  arrayTraps[key] = function () {
     arguments[0] = arguments[0][0];
     return fn.apply(this, arguments);
   };
 });
-arrayTraps.deleteProperty = function(state, prop) {
-  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop)))
-    die(13);
+arrayTraps.deleteProperty = function (state, prop) {
+  if (process.env.NODE_ENV !== "production" && isNaN(parseInt(prop))) die(13);
   return arrayTraps.set.call(this, state, prop, void 0);
 };
-arrayTraps.set = function(state, prop, value) {
-  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop)))
-    die(14);
+arrayTraps.set = function (state, prop, value) {
+  if (process.env.NODE_ENV !== "production" && prop !== "length" && isNaN(parseInt(prop))) die(14);
   return objectTraps.set.call(this, state[0], prop, value, state[0]);
 };
 function peek(draft, prop) {
-  const state = draft[DRAFT_STATE];
-  const source = state ? latest(state) : draft;
+  var state = draft[DRAFT_STATE];
+  var source = state ? latest(state) : draft;
   return source[prop];
 }
 function readPropFromProto(state, source, prop) {
-  const desc = getDescriptorFromProto(source, prop);
-  return desc ? `value` in desc ? desc.value : (
-    // This is a very special case, if the prop is a getter defined by the
-    // prototype, we should invoke it with the draft as context!
-    desc.get?.call(state.draft_)
-  ) : void 0;
+  var _desc$get;
+  var desc = getDescriptorFromProto(source, prop);
+  return desc ? "value" in desc ? desc.value : // This is a very special case, if the prop is a getter defined by the
+  // prototype, we should invoke it with the draft as context!
+  (_desc$get = desc.get) === null || _desc$get === void 0 ? void 0 : _desc$get.call(state.draft_) : void 0;
 }
 function getDescriptorFromProto(source, prop) {
-  if (!(prop in source))
-    return void 0;
-  let proto = getPrototypeOf$1(source);
+  if (!(prop in source)) return void 0;
+  var proto = _getPrototypeOf(source);
   while (proto) {
-    const desc = Object.getOwnPropertyDescriptor(proto, prop);
-    if (desc)
-      return desc;
-    proto = getPrototypeOf$1(proto);
+    var desc = Object.getOwnPropertyDescriptor(proto, prop);
+    if (desc) return desc;
+    proto = _getPrototypeOf(proto);
   }
   return void 0;
 }
@@ -3609,16 +3629,15 @@ function markChanged(state) {
 }
 function prepareCopy(state) {
   if (!state.copy_) {
-    state.copy_ = shallowCopy(
-      state.base_,
-      state.scope_.immer_.useStrictShallowCopy_
-    );
+    state.copy_ = shallowCopy(state.base_, state.scope_.immer_.useStrictShallowCopy_);
   }
 }
 
 // src/core/immerClass.ts
-var Immer2 = class {
-  constructor(config) {
+var Immer2 = /*#__PURE__*/function () {
+  function Immer2(config) {
+    var _this = this;
+    _classCallCheck(this, Immer2);
     this.autoFreeze_ = true;
     this.useStrictShallowCopy_ = false;
     /**
@@ -3640,153 +3659,162 @@ var Immer2 = class {
      * @param {Function} patchListener - optional function that will be called with all the patches produced here
      * @returns {any} a new state, or the initial state if nothing was modified
      */
-    this.produce = (base, recipe, patchListener) => {
+    this.produce = function (base, recipe, patchListener) {
       if (typeof base === "function" && typeof recipe !== "function") {
-        const defaultBase = recipe;
+        var defaultBase = recipe;
         recipe = base;
-        const self = this;
-        return function curriedProduce(base2 = defaultBase, ...args) {
-          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        var self = _this;
+        return function curriedProduce() {
+          var _this2 = this;
+          var base2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultBase;
+          for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key3 = 1; _key3 < _len2; _key3++) {
+            args[_key3 - 1] = arguments[_key3];
+          }
+          return self.produce(base2, function (draft) {
+            var _recipe;
+            return (_recipe = recipe).call.apply(_recipe, [_this2, draft].concat(args));
+          });
         };
       }
-      if (typeof recipe !== "function")
-        die(6);
-      if (patchListener !== void 0 && typeof patchListener !== "function")
-        die(7);
-      let result;
+      if (typeof recipe !== "function") die(6);
+      if (patchListener !== void 0 && typeof patchListener !== "function") die(7);
+      var result;
       if (isDraftable(base)) {
-        const scope = enterScope(this);
-        const proxy = createProxy(base, void 0);
-        let hasError = true;
+        var scope = enterScope(_this);
+        var proxy = createProxy(base, void 0);
+        var hasError = true;
         try {
           result = recipe(proxy);
           hasError = false;
         } finally {
-          if (hasError)
-            revokeScope(scope);
-          else
-            leaveScope(scope);
+          if (hasError) revokeScope(scope);else leaveScope(scope);
         }
         usePatchesInScope(scope, patchListener);
         return processResult(result, scope);
-      } else if (!base || typeof base !== "object") {
+      } else if (!base || _typeof(base) !== "object") {
         result = recipe(base);
-        if (result === void 0)
-          result = base;
-        if (result === NOTHING)
-          result = void 0;
-        if (this.autoFreeze_)
-          freeze(result, true);
+        if (result === void 0) result = base;
+        if (result === NOTHING) result = void 0;
+        if (_this.autoFreeze_) freeze(result, true);
         if (patchListener) {
-          const p = [];
-          const ip = [];
+          var p = [];
+          var ip = [];
           getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
           patchListener(p, ip);
         }
         return result;
-      } else
-        die(1, base);
+      } else die(1, base);
     };
-    this.produceWithPatches = (base, recipe) => {
+    this.produceWithPatches = function (base, recipe) {
       if (typeof base === "function") {
-        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+        return function (state) {
+          for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key4 = 1; _key4 < _len3; _key4++) {
+            args[_key4 - 1] = arguments[_key4];
+          }
+          return _this.produceWithPatches(state, function (draft) {
+            return base.apply(void 0, [draft].concat(args));
+          });
+        };
       }
-      let patches, inversePatches;
-      const result = this.produce(base, recipe, (p, ip) => {
+      var patches, inversePatches;
+      var result = _this.produce(base, recipe, function (p, ip) {
         patches = p;
         inversePatches = ip;
       });
       return [result, patches, inversePatches];
     };
-    if (typeof config?.autoFreeze === "boolean")
-      this.setAutoFreeze(config.autoFreeze);
-    if (typeof config?.useStrictShallowCopy === "boolean")
-      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
-  }
-  createDraft(base) {
-    if (!isDraftable(base))
-      die(8);
-    if (isDraft(base))
-      base = current(base);
-    const scope = enterScope(this);
-    const proxy = createProxy(base, void 0);
-    proxy[DRAFT_STATE].isManual_ = true;
-    leaveScope(scope);
-    return proxy;
-  }
-  finishDraft(draft, patchListener) {
-    const state = draft && draft[DRAFT_STATE];
-    if (!state || !state.isManual_)
-      die(9);
-    const { scope_: scope } = state;
-    usePatchesInScope(scope, patchListener);
-    return processResult(void 0, scope);
-  }
-  /**
-   * Pass true to automatically freeze all copies created by Immer.
-   *
-   * By default, auto-freezing is enabled.
-   */
-  setAutoFreeze(value) {
-    this.autoFreeze_ = value;
-  }
-  /**
-   * Pass true to enable strict shallow copy.
-   *
-   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
-   */
-  setUseStrictShallowCopy(value) {
-    this.useStrictShallowCopy_ = value;
-  }
-  applyPatches(base, patches) {
-    let i;
-    for (i = patches.length - 1; i >= 0; i--) {
-      const patch = patches[i];
-      if (patch.path.length === 0 && patch.op === "replace") {
-        base = patch.value;
-        break;
-      }
+    if (typeof (config === null || config === void 0 ? void 0 : config.autoFreeze) === "boolean") this.setAutoFreeze(config.autoFreeze);
+    if (typeof (config === null || config === void 0 ? void 0 : config.useStrictShallowCopy) === "boolean") this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+  }
+  _createClass(Immer2, [{
+    key: "createDraft",
+    value: function createDraft(base) {
+      if (!isDraftable(base)) die(8);
+      if (isDraft(base)) base = current(base);
+      var scope = enterScope(this);
+      var proxy = createProxy(base, void 0);
+      proxy[DRAFT_STATE].isManual_ = true;
+      leaveScope(scope);
+      return proxy;
+    }
+  }, {
+    key: "finishDraft",
+    value: function finishDraft(draft, patchListener) {
+      var state = draft && draft[DRAFT_STATE];
+      if (!state || !state.isManual_) die(9);
+      var scope = state.scope_;
+      usePatchesInScope(scope, patchListener);
+      return processResult(void 0, scope);
     }
-    if (i > -1) {
-      patches = patches.slice(i + 1);
+    /**
+     * Pass true to automatically freeze all copies created by Immer.
+     *
+     * By default, auto-freezing is enabled.
+     */
+  }, {
+    key: "setAutoFreeze",
+    value: function setAutoFreeze(value) {
+      this.autoFreeze_ = value;
     }
-    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
-    if (isDraft(base)) {
-      return applyPatchesImpl(base, patches);
+    /**
+     * Pass true to enable strict shallow copy.
+     *
+     * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+     */
+  }, {
+    key: "setUseStrictShallowCopy",
+    value: function setUseStrictShallowCopy(value) {
+      this.useStrictShallowCopy_ = value;
+    }
+  }, {
+    key: "applyPatches",
+    value: function applyPatches(base, patches) {
+      var i;
+      for (i = patches.length - 1; i >= 0; i--) {
+        var patch = patches[i];
+        if (patch.path.length === 0 && patch.op === "replace") {
+          base = patch.value;
+          break;
+        }
+      }
+      if (i > -1) {
+        patches = patches.slice(i + 1);
+      }
+      var applyPatchesImpl = getPlugin("Patches").applyPatches_;
+      if (isDraft(base)) {
+        return applyPatchesImpl(base, patches);
+      }
+      return this.produce(base, function (draft) {
+        return applyPatchesImpl(draft, patches);
+      });
     }
-    return this.produce(
-      base,
-      (draft) => applyPatchesImpl(draft, patches)
-    );
-  }
-};
+  }]);
+  return Immer2;
+}();
 function createProxy(value, parent) {
-  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
-  const scope = parent ? parent.scope_ : getCurrentScope();
+  var draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+  var scope = parent ? parent.scope_ : getCurrentScope();
   scope.drafts_.push(draft);
   return draft;
 }
 
 // src/core/current.ts
 function current(value) {
-  if (!isDraft(value))
-    die(10, value);
+  if (!isDraft(value)) die(10, value);
   return currentImpl(value);
 }
 function currentImpl(value) {
-  if (!isDraftable(value) || isFrozen(value))
-    return value;
-  const state = value[DRAFT_STATE];
-  let copy;
+  if (!isDraftable(value) || isFrozen(value)) return value;
+  var state = value[DRAFT_STATE];
+  var copy;
   if (state) {
-    if (!state.modified_)
-      return state.base_;
+    if (!state.modified_) return state.base_;
     state.finalized_ = true;
     copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
   } else {
     copy = shallowCopy(value, true);
   }
-  each(copy, (key, childValue) => {
+  each(copy, function (key, childValue) {
     set(copy, key, currentImpl(childValue));
   });
   if (state) {
@@ -3798,17 +3826,13 @@ function currentImpl(value) {
 // src/immer.ts
 var immer = new Immer2();
 immer.produce;
-immer.produceWithPatches.bind(
-  immer
-);
+immer.produceWithPatches.bind(immer);
 immer.setAutoFreeze.bind(immer);
 immer.setUseStrictShallowCopy.bind(immer);
 immer.applyPatches.bind(immer);
 immer.createDraft.bind(immer);
 immer.finishDraft.bind(immer);
 
-/* eslint-disable @bigbinary/neeto/neetocommons-tips */
-
 /**
  * @template {Function} T
  * @param {T} func
@@ -19322,7 +19346,7 @@ const getCliOptions = () => {
 
 const getFileContent = async ({
   relativeFilePath = "",
-  debug = false,
+  debug = false
 }) => {
   const resolvedFilePath = path$2.resolve(relativeFilePath);
 
@@ -19338,7 +19362,7 @@ const createOrReplaceFile = async ({
   relativeFilePath = "",
   content = "",
   debug = false,
-  options = {},
+  options = {}
 }) => {
   const resolvedFilePath = path$2.resolve(relativeFilePath);
 
@@ -19346,7 +19370,7 @@ const createOrReplaceFile = async ({
     return await writeFile(resolvedFilePath, content, {
       encoding: "utf8",
       flag: "w",
-      ...options,
+      ...options
     });
   } catch (error) {
     debug && console.error(error);
@@ -19357,7 +19381,7 @@ const createOrReplaceFile = async ({
 const identicalFiles = async ({
   sourceFile = "",
   destinationFile = "",
-  debug = false,
+  debug = false
 }) => {
   try {
     const sourceFileContent = await readFile(sourceFile);
@@ -19375,7 +19399,7 @@ const identicalFiles = async ({
 const identicalDirectoryFiles = async ({
   sourceDirectory,
   destinationDirectory,
-  debug,
+  debug
 }) => {
   try {
     const files = await promises.readdir(sourceDirectory);
@@ -19390,14 +19414,14 @@ const identicalDirectoryFiles = async ({
         return await identicalFiles({
           sourceFile,
           destinationFile,
-          debug,
+          debug
         });
       } else {
         await mkdir(destinationFile, { recursive: true });
         const identicalFiles = await identicalDirectoryFiles({
           sourceDirectory: sourceFile,
           destinationDirectory: destinationFile,
-          debug,
+          debug
         });
 
         const results = await Promise.all(identicalFiles);
@@ -19417,7 +19441,7 @@ const createOrReplaceDirectoryFiles = async ({
   sourceDirectory,
   destinationDirectory,
   debug,
-  options,
+  options
 }) => {
   try {
     const files = await promises.readdir(sourceDirectory);
@@ -19431,14 +19455,14 @@ const createOrReplaceDirectoryFiles = async ({
       if (isFile) {
         const content = await getFileContent({
           relativeFilePath: sourcePath,
-          debug,
+          debug
         });
 
         await createOrReplaceFile({
           relativeFilePath: destinationPath,
           content,
           debug,
-          options,
+          options
         });
       } else {
         await mkdir(destinationPath, { recursive: true });
@@ -19446,7 +19470,7 @@ const createOrReplaceDirectoryFiles = async ({
           sourceDirectory: sourcePath,
           destinationDirectory: destinationPath,
           debug,
-          options,
+          options
         });
       }
     });
@@ -19499,14 +19523,14 @@ const getNanoType = async () => {
 
   return {
     type: NANO_TYPE_MAP[last$2(split$1("-", projectName))],
-    repoName: projectName,
+    repoName: projectName
   };
 };
 
 const getPackageJson = async (debug) => {
   const packageJsonContent = await getFileContent({
     relativeFilePath: PACKAGE_JSON_PATH,
-    debug,
+    debug
   });
 
   return JSON.parse(packageJsonContent);
@@ -19759,7 +19783,7 @@ const DEV_DEPENDENCIES$4 = {
   "eslint-plugin-import": "2.29.0",
   "eslint-plugin-jam3": "0.2.3",
   "eslint-plugin-json": "3.1.0",
-  "eslint-plugin-prettier": "5.0.1",
+  "eslint-plugin-prettier": "4.0.0",
   "eslint-plugin-promise": "6.1.1",
   "eslint-plugin-react": "7.33.2",
   "eslint-plugin-react-hooks": "4.6.0",
@@ -37117,7 +37141,7 @@ const updateBigbinaryPackages = async (recommendedList) => {
     while (retries < MAX_RETRIES) {
       try {
         const {
-          data: { repos },
+          data: { repos }
         } = await axios$1.get(
           "https://nanos-release-tool-staging.neetodeployapp.com/api/v1/repos"
         );
@@ -37223,7 +37247,7 @@ const recommendedPackageVersions = async (debug) => {
       (await createOrReplaceFile({
         relativeFilePath: PACKAGE_JSON_PATH,
         content: JSON.stringify(newPackageJson, null, 2),
-        debug,
+        debug
       }));
 
     const commands = getInstallationCommands(
@@ -37245,7 +37269,7 @@ const recommendedPackageVersions = async (debug) => {
     return {
       error: "The dependency packages are not using the recommended versions.",
       status: STATUSES.FAIL,
-      fix,
+      fix
     };
   }