bitz-react-admin-ui 2.4.0 → 2.4.2

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/isSafeInteger.mjs

@@ -0,0 +1,8 @@
+import e from "./isInteger.mjs";
+var t = 9007199254740991;
+function f(r) {
+  return e(r) && r >= -t && r <= t;
+}
+export {
+  f as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/isString.mjs

@@ -0,0 +1,10 @@
+import t from "./_baseGetTag.mjs";
+import i from "./isArray.mjs";
+import o from "./isObjectLike.mjs";
+var n = "[object String]";
+function g(r) {
+  return typeof r == "string" || !i(r) && o(r) && t(r) == n;
+}
+export {
+  g as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/isUndefined.mjs

@@ -0,0 +1,6 @@
+function n(e) {
+  return e === void 0;
+}
+export {
+  n as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/isWeakMap.mjs

@@ -0,0 +1,9 @@
+import e from "./_getTag.mjs";
+import t from "./isObjectLike.mjs";
+var r = "[object WeakMap]";
+function p(a) {
+  return t(a) && e(a) == r;
+}
+export {
+  p as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/isWeakSet.mjs

@@ -0,0 +1,9 @@
+import t from "./_baseGetTag.mjs";
+import a from "./isObjectLike.mjs";
+var r = "[object WeakSet]";
+function f(e) {
+  return a(e) && t(e) == r;
+}
+export {
+  f as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/iteratee.mjs

@@ -0,0 +1,9 @@
+import t from "./_baseClone.mjs";
+import r from "./_baseIteratee.mjs";
+var o = 1;
+function f(e) {
+  return r(typeof e == "function" ? e : t(e, o));
+}
+export {
+  f as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/join.mjs

@@ -0,0 +1,7 @@
+var n = Array.prototype, t = n.join;
+function a(o, r) {
+  return o == null ? "" : t.call(o, r);
+}
+export {
+  a as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/kebabCase.mjs

@@ -0,0 +1,8 @@
+import r from "./_createCompounder.mjs";
+var t = r(function(e, a, o) {
+  return e + (o ? "-" : "") + a.toLowerCase();
+});
+const s = t;
+export {
+  s as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/keyBy.mjs

@@ -0,0 +1,9 @@
+import t from "./_baseAssignValue.mjs";
+import a from "./_createAggregator.mjs";
+var s = a(function(e, r, o) {
+  t(e, o, r);
+});
+const i = s;
+export {
+  i as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/lang.default.mjs

@@ -0,0 +1,117 @@
+import r from "./castArray.mjs";
+import o from "./clone.mjs";
+import m from "./cloneDeep.mjs";
+import i from "./cloneDeepWith.mjs";
+import t from "./cloneWith.mjs";
+import f from "./conformsTo.mjs";
+import p from "./eq.mjs";
+import e from "./gt.mjs";
+import s from "./gte.mjs";
+import a from "./isArguments.mjs";
+import n from "./isArray.mjs";
+import l from "./isArrayBuffer.mjs";
+import c from "./isArrayLike.mjs";
+import g from "./isArrayLikeObject.mjs";
+import u from "./isBoolean.mjs";
+import y from "./isBuffer.mjs";
+import b from "./isDate.mjs";
+import h from "./isElement.mjs";
+import A from "./isEmpty.mjs";
+import N from "./isEqual.mjs";
+import S from "./isEqualWith.mjs";
+import E from "./isError.mjs";
+import W from "./isFinite.mjs";
+import j from "./isFunction.mjs";
+import k from "./isInteger.mjs";
+import L from "./isLength.mjs";
+import O from "./isMap.mjs";
+import d from "./isMatch.mjs";
+import I from "./isMatchWith.mjs";
+import M from "./isNaN.mjs";
+import q from "./isNative.mjs";
+import B from "./isNil.mjs";
+import D from "./isNull.mjs";
+import F from "./isNumber.mjs";
+import x from "./isObject.mjs";
+import P from "./isObjectLike.mjs";
+import T from "./isPlainObject.mjs";
+import v from "./isRegExp.mjs";
+import R from "./isSafeInteger.mjs";
+import U from "./isSet.mjs";
+import w from "./isString.mjs";
+import z from "./isSymbol.mjs";
+import C from "./isTypedArray.mjs";
+import G from "./isUndefined.mjs";
+import H from "./isWeakMap.mjs";
+import J from "./isWeakSet.mjs";
+import K from "./lt.mjs";
+import Q from "./lte.mjs";
+import V from "./toArray.mjs";
+import X from "./toFinite.mjs";
+import Y from "./toInteger.mjs";
+import Z from "./toLength.mjs";
+import _ from "./toNumber.mjs";
+import $ from "./toPlainObject.mjs";
+import rr from "./toSafeInteger.mjs";
+import or from "./toString.mjs";
+const to = {
+  castArray: r,
+  clone: o,
+  cloneDeep: m,
+  cloneDeepWith: i,
+  cloneWith: t,
+  conformsTo: f,
+  eq: p,
+  gt: e,
+  gte: s,
+  isArguments: a,
+  isArray: n,
+  isArrayBuffer: l,
+  isArrayLike: c,
+  isArrayLikeObject: g,
+  isBoolean: u,
+  isBuffer: y,
+  isDate: b,
+  isElement: h,
+  isEmpty: A,
+  isEqual: N,
+  isEqualWith: S,
+  isError: E,
+  isFinite: W,
+  isFunction: j,
+  isInteger: k,
+  isLength: L,
+  isMap: O,
+  isMatch: d,
+  isMatchWith: I,
+  isNaN: M,
+  isNative: q,
+  isNil: B,
+  isNull: D,
+  isNumber: F,
+  isObject: x,
+  isObjectLike: P,
+  isPlainObject: T,
+  isRegExp: v,
+  isSafeInteger: R,
+  isSet: U,
+  isString: w,
+  isSymbol: z,
+  isTypedArray: C,
+  isUndefined: G,
+  isWeakMap: H,
+  isWeakSet: J,
+  lt: K,
+  lte: Q,
+  toArray: V,
+  toFinite: X,
+  toInteger: Y,
+  toLength: Z,
+  toNumber: _,
+  toPlainObject: $,
+  toSafeInteger: rr,
+  toString: or
+};
+export {
+  to as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/lastIndexOf.mjs

@@ -0,0 +1,15 @@
+import f from "./_baseFindIndex.mjs";
+import o from "./_baseIsNaN.mjs";
+import m from "./_strictLastIndexOf.mjs";
+import a from "./toInteger.mjs";
+var d = Math.max, s = Math.min;
+function l(n, i, r) {
+  var e = n == null ? 0 : n.length;
+  if (!e)
+    return -1;
+  var t = e;
+  return r !== void 0 && (t = a(r), t = t < 0 ? d(e + t, 0) : s(t, e - 1)), i === i ? m(n, i, t) : f(n, o, t, !0);
+}
+export {
+  l as default
+};

package/dist/node_modules/.store/lodash-es@4.17.21/node_modules/lodash-es/lodash.default.mjs

@@ -0,0 +1,487 @@
+import u from "./_LazyWrapper.mjs";
+import H from "./_LodashWrapper.mjs";
+import M from "./_Symbol.mjs";
+import _ from "./_arrayEach.mjs";
+import Y from "./_arrayPush.mjs";
+import x from "./_baseForOwn.mjs";
+import Z from "./_baseFunctions.mjs";
+import J from "./_baseInvoke.mjs";
+import q from "./_baseIteratee.mjs";
+import X from "./_baseRest.mjs";
+import Q from "./_createHybrid.mjs";
+import D from "./identity.mjs";
+import W from "./isArray.mjs";
+import C from "./isObject.mjs";
+import T from "./keys.mjs";
+import tt from "./last.mjs";
+import et from "./_lazyClone.mjs";
+import rt from "./_lazyReverse.mjs";
+import it from "./_lazyValue.mjs";
+import nt from "./mixin.mjs";
+import U from "./negate.mjs";
+import b from "./_realNames.mjs";
+import K from "./thru.mjs";
+import k from "./toInteger.mjs";
+import t from "./wrapperLodash.mjs";
+import c from "./function.default.mjs";
+import a from "./object.default.mjs";
+import p from "./util.default.mjs";
+import r from "./lang.default.mjs";
+import g from "./seq.default.mjs";
+import e from "./array.default.mjs";
+import l from "./collection.default.mjs";
+import s from "./string.default.mjs";
+import h from "./math.default.mjs";
+import O from "./number.default.mjs";
+import at from "./date.default.mjs";
+/**
+ * @license
+ * Lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="es" -o ./`
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+var ot = "4.17.21", st = 2, pt = 1, lt = 3, N = 4294967295, ft = Array.prototype, ut = Object.prototype, $ = ut.hasOwnProperty, P = M ? M.iterator : void 0, ct = Math.max, F = Math.min, w = function(i) {
+  return function(o, n, f) {
+    if (f == null) {
+      var y = C(n), d = y && T(n), m = d && d.length && Z(n, d);
+      (m ? m.length : y) || (f = n, n = o, o = this);
+    }
+    return i(o, n, f);
+  };
+}(nt);
+t.after = c.after;
+t.ary = c.ary;
+t.assign = a.assign;
+t.assignIn = a.assignIn;
+t.assignInWith = a.assignInWith;
+t.assignWith = a.assignWith;
+t.at = a.at;
+t.before = c.before;
+t.bind = c.bind;
+t.bindAll = p.bindAll;
+t.bindKey = c.bindKey;
+t.castArray = r.castArray;
+t.chain = g.chain;
+t.chunk = e.chunk;
+t.compact = e.compact;
+t.concat = e.concat;
+t.cond = p.cond;
+t.conforms = p.conforms;
+t.constant = p.constant;
+t.countBy = l.countBy;
+t.create = a.create;
+t.curry = c.curry;
+t.curryRight = c.curryRight;
+t.debounce = c.debounce;
+t.defaults = a.defaults;
+t.defaultsDeep = a.defaultsDeep;
+t.defer = c.defer;
+t.delay = c.delay;
+t.difference = e.difference;
+t.differenceBy = e.differenceBy;
+t.differenceWith = e.differenceWith;
+t.drop = e.drop;
+t.dropRight = e.dropRight;
+t.dropRightWhile = e.dropRightWhile;
+t.dropWhile = e.dropWhile;
+t.fill = e.fill;
+t.filter = l.filter;
+t.flatMap = l.flatMap;
+t.flatMapDeep = l.flatMapDeep;
+t.flatMapDepth = l.flatMapDepth;
+t.flatten = e.flatten;
+t.flattenDeep = e.flattenDeep;
+t.flattenDepth = e.flattenDepth;
+t.flip = c.flip;
+t.flow = p.flow;
+t.flowRight = p.flowRight;
+t.fromPairs = e.fromPairs;
+t.functions = a.functions;
+t.functionsIn = a.functionsIn;
+t.groupBy = l.groupBy;
+t.initial = e.initial;
+t.intersection = e.intersection;
+t.intersectionBy = e.intersectionBy;
+t.intersectionWith = e.intersectionWith;
+t.invert = a.invert;
+t.invertBy = a.invertBy;
+t.invokeMap = l.invokeMap;
+t.iteratee = p.iteratee;
+t.keyBy = l.keyBy;
+t.keys = T;
+t.keysIn = a.keysIn;
+t.map = l.map;
+t.mapKeys = a.mapKeys;
+t.mapValues = a.mapValues;
+t.matches = p.matches;
+t.matchesProperty = p.matchesProperty;
+t.memoize = c.memoize;
+t.merge = a.merge;
+t.mergeWith = a.mergeWith;
+t.method = p.method;
+t.methodOf = p.methodOf;
+t.mixin = w;
+t.negate = U;
+t.nthArg = p.nthArg;
+t.omit = a.omit;
+t.omitBy = a.omitBy;
+t.once = c.once;
+t.orderBy = l.orderBy;
+t.over = p.over;
+t.overArgs = c.overArgs;
+t.overEvery = p.overEvery;
+t.overSome = p.overSome;
+t.partial = c.partial;
+t.partialRight = c.partialRight;
+t.partition = l.partition;
+t.pick = a.pick;
+t.pickBy = a.pickBy;
+t.property = p.property;
+t.propertyOf = p.propertyOf;
+t.pull = e.pull;
+t.pullAll = e.pullAll;
+t.pullAllBy = e.pullAllBy;
+t.pullAllWith = e.pullAllWith;
+t.pullAt = e.pullAt;
+t.range = p.range;
+t.rangeRight = p.rangeRight;
+t.rearg = c.rearg;
+t.reject = l.reject;
+t.remove = e.remove;
+t.rest = c.rest;
+t.reverse = e.reverse;
+t.sampleSize = l.sampleSize;
+t.set = a.set;
+t.setWith = a.setWith;
+t.shuffle = l.shuffle;
+t.slice = e.slice;
+t.sortBy = l.sortBy;
+t.sortedUniq = e.sortedUniq;
+t.sortedUniqBy = e.sortedUniqBy;
+t.split = s.split;
+t.spread = c.spread;
+t.tail = e.tail;
+t.take = e.take;
+t.takeRight = e.takeRight;
+t.takeRightWhile = e.takeRightWhile;
+t.takeWhile = e.takeWhile;
+t.tap = g.tap;
+t.throttle = c.throttle;
+t.thru = K;
+t.toArray = r.toArray;
+t.toPairs = a.toPairs;
+t.toPairsIn = a.toPairsIn;
+t.toPath = p.toPath;
+t.toPlainObject = r.toPlainObject;
+t.transform = a.transform;
+t.unary = c.unary;
+t.union = e.union;
+t.unionBy = e.unionBy;
+t.unionWith = e.unionWith;
+t.uniq = e.uniq;
+t.uniqBy = e.uniqBy;
+t.uniqWith = e.uniqWith;
+t.unset = a.unset;
+t.unzip = e.unzip;
+t.unzipWith = e.unzipWith;
+t.update = a.update;
+t.updateWith = a.updateWith;
+t.values = a.values;
+t.valuesIn = a.valuesIn;
+t.without = e.without;
+t.words = s.words;
+t.wrap = c.wrap;
+t.xor = e.xor;
+t.xorBy = e.xorBy;
+t.xorWith = e.xorWith;
+t.zip = e.zip;
+t.zipObject = e.zipObject;
+t.zipObjectDeep = e.zipObjectDeep;
+t.zipWith = e.zipWith;
+t.entries = a.toPairs;
+t.entriesIn = a.toPairsIn;
+t.extend = a.assignIn;
+t.extendWith = a.assignInWith;
+w(t, t);
+t.add = h.add;
+t.attempt = p.attempt;
+t.camelCase = s.camelCase;
+t.capitalize = s.capitalize;
+t.ceil = h.ceil;
+t.clamp = O.clamp;
+t.clone = r.clone;
+t.cloneDeep = r.cloneDeep;
+t.cloneDeepWith = r.cloneDeepWith;
+t.cloneWith = r.cloneWith;
+t.conformsTo = r.conformsTo;
+t.deburr = s.deburr;
+t.defaultTo = p.defaultTo;
+t.divide = h.divide;
+t.endsWith = s.endsWith;
+t.eq = r.eq;
+t.escape = s.escape;
+t.escapeRegExp = s.escapeRegExp;
+t.every = l.every;
+t.find = l.find;
+t.findIndex = e.findIndex;
+t.findKey = a.findKey;
+t.findLast = l.findLast;
+t.findLastIndex = e.findLastIndex;
+t.findLastKey = a.findLastKey;
+t.floor = h.floor;
+t.forEach = l.forEach;
+t.forEachRight = l.forEachRight;
+t.forIn = a.forIn;
+t.forInRight = a.forInRight;
+t.forOwn = a.forOwn;
+t.forOwnRight = a.forOwnRight;
+t.get = a.get;
+t.gt = r.gt;
+t.gte = r.gte;
+t.has = a.has;
+t.hasIn = a.hasIn;
+t.head = e.head;
+t.identity = D;
+t.includes = l.includes;
+t.indexOf = e.indexOf;
+t.inRange = O.inRange;
+t.invoke = a.invoke;
+t.isArguments = r.isArguments;
+t.isArray = W;
+t.isArrayBuffer = r.isArrayBuffer;
+t.isArrayLike = r.isArrayLike;
+t.isArrayLikeObject = r.isArrayLikeObject;
+t.isBoolean = r.isBoolean;
+t.isBuffer = r.isBuffer;
+t.isDate = r.isDate;
+t.isElement = r.isElement;
+t.isEmpty = r.isEmpty;
+t.isEqual = r.isEqual;
+t.isEqualWith = r.isEqualWith;
+t.isError = r.isError;
+t.isFinite = r.isFinite;
+t.isFunction = r.isFunction;
+t.isInteger = r.isInteger;
+t.isLength = r.isLength;
+t.isMap = r.isMap;
+t.isMatch = r.isMatch;
+t.isMatchWith = r.isMatchWith;
+t.isNaN = r.isNaN;
+t.isNative = r.isNative;
+t.isNil = r.isNil;
+t.isNull = r.isNull;
+t.isNumber = r.isNumber;
+t.isObject = C;
+t.isObjectLike = r.isObjectLike;
+t.isPlainObject = r.isPlainObject;
+t.isRegExp = r.isRegExp;
+t.isSafeInteger = r.isSafeInteger;
+t.isSet = r.isSet;
+t.isString = r.isString;
+t.isSymbol = r.isSymbol;
+t.isTypedArray = r.isTypedArray;
+t.isUndefined = r.isUndefined;
+t.isWeakMap = r.isWeakMap;
+t.isWeakSet = r.isWeakSet;
+t.join = e.join;
+t.kebabCase = s.kebabCase;
+t.last = tt;
+t.lastIndexOf = e.lastIndexOf;
+t.lowerCase = s.lowerCase;
+t.lowerFirst = s.lowerFirst;
+t.lt = r.lt;
+t.lte = r.lte;
+t.max = h.max;
+t.maxBy = h.maxBy;
+t.mean = h.mean;
+t.meanBy = h.meanBy;
+t.min = h.min;
+t.minBy = h.minBy;
+t.stubArray = p.stubArray;
+t.stubFalse = p.stubFalse;
+t.stubObject = p.stubObject;
+t.stubString = p.stubString;
+t.stubTrue = p.stubTrue;
+t.multiply = h.multiply;
+t.nth = e.nth;
+t.noop = p.noop;
+t.now = at.now;
+t.pad = s.pad;
+t.padEnd = s.padEnd;
+t.padStart = s.padStart;
+t.parseInt = s.parseInt;
+t.random = O.random;
+t.reduce = l.reduce;
+t.reduceRight = l.reduceRight;
+t.repeat = s.repeat;
+t.replace = s.replace;
+t.result = a.result;
+t.round = h.round;
+t.sample = l.sample;
+t.size = l.size;
+t.snakeCase = s.snakeCase;
+t.some = l.some;
+t.sortedIndex = e.sortedIndex;
+t.sortedIndexBy = e.sortedIndexBy;
+t.sortedIndexOf = e.sortedIndexOf;
+t.sortedLastIndex = e.sortedLastIndex;
+t.sortedLastIndexBy = e.sortedLastIndexBy;
+t.sortedLastIndexOf = e.sortedLastIndexOf;
+t.startCase = s.startCase;
+t.startsWith = s.startsWith;
+t.subtract = h.subtract;
+t.sum = h.sum;
+t.sumBy = h.sumBy;
+t.template = s.template;
+t.times = p.times;
+t.toFinite = r.toFinite;
+t.toInteger = k;
+t.toLength = r.toLength;
+t.toLower = s.toLower;
+t.toNumber = r.toNumber;
+t.toSafeInteger = r.toSafeInteger;
+t.toString = r.toString;
+t.toUpper = s.toUpper;
+t.trim = s.trim;
+t.trimEnd = s.trimEnd;
+t.trimStart = s.trimStart;
+t.truncate = s.truncate;
+t.unescape = s.unescape;
+t.uniqueId = p.uniqueId;
+t.upperCase = s.upperCase;
+t.upperFirst = s.upperFirst;
+t.each = l.forEach;
+t.eachRight = l.forEachRight;
+t.first = e.head;
+w(t, function() {
+  var i = {};
+  return x(t, function(o, n) {
+    $.call(t.prototype, n) || (i[n] = o);
+  }), i;
+}(), { chain: !1 });
+t.VERSION = ot;
+(t.templateSettings = s.templateSettings).imports._ = t;
+_(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(i) {
+  t[i].placeholder = t;
+});
+_(["drop", "take"], function(i, o) {
+  u.prototype[i] = function(n) {
+    n = n === void 0 ? 1 : ct(k(n), 0);
+    var f = this.__filtered__ && !o ? new u(this) : this.clone();
+    return f.__filtered__ ? f.__takeCount__ = F(n, f.__takeCount__) : f.__views__.push({
+      size: F(n, N),
+      type: i + (f.__dir__ < 0 ? "Right" : "")
+    }), f;
+  }, u.prototype[i + "Right"] = function(n) {
+    return this.reverse()[i](n).reverse();
+  };
+});
+_(["filter", "map", "takeWhile"], function(i, o) {
+  var n = o + 1, f = n == pt || n == lt;
+  u.prototype[i] = function(y) {
+    var d = this.clone();
+    return d.__iteratees__.push({
+      iteratee: q(y),
+      type: n
+    }), d.__filtered__ = d.__filtered__ || f, d;
+  };
+});
+_(["head", "last"], function(i, o) {
+  var n = "take" + (o ? "Right" : "");
+  u.prototype[i] = function() {
+    return this[n](1).value()[0];
+  };
+});
+_(["initial", "tail"], function(i, o) {
+  var n = "drop" + (o ? "" : "Right");
+  u.prototype[i] = function() {
+    return this.__filtered__ ? new u(this) : this[n](1);
+  };
+});
+u.prototype.compact = function() {
+  return this.filter(D);
+};
+u.prototype.find = function(i) {
+  return this.filter(i).head();
+};
+u.prototype.findLast = function(i) {
+  return this.reverse().find(i);
+};
+u.prototype.invokeMap = X(function(i, o) {
+  return typeof i == "function" ? new u(this) : this.map(function(n) {
+    return J(n, i, o);
+  });
+});
+u.prototype.reject = function(i) {
+  return this.filter(U(q(i)));
+};
+u.prototype.slice = function(i, o) {
+  i = k(i);
+  var n = this;
+  return n.__filtered__ && (i > 0 || o < 0) ? new u(n) : (i < 0 ? n = n.takeRight(-i) : i && (n = n.drop(i)), o !== void 0 && (o = k(o), n = o < 0 ? n.dropRight(-o) : n.take(o - i)), n);
+};
+u.prototype.takeRightWhile = function(i) {
+  return this.reverse().takeWhile(i).reverse();
+};
+u.prototype.toArray = function() {
+  return this.take(N);
+};
+x(u.prototype, function(i, o) {
+  var n = /^(?:filter|find|map|reject)|While$/.test(o), f = /^(?:head|last)$/.test(o), y = t[f ? "take" + (o == "last" ? "Right" : "") : o], d = f || /^find/.test(o);
+  y && (t.prototype[o] = function() {
+    var m = this.__wrapped__, I = f ? [1] : arguments, R = m instanceof u, L = I[0], B = R || W(m), E = function(G) {
+      var j = y.apply(t, Y([G], I));
+      return f && A ? j[0] : j;
+    };
+    B && n && typeof L == "function" && L.length != 1 && (R = B = !1);
+    var A = this.__chain__, V = !!this.__actions__.length, S = d && !A, z = R && !V;
+    if (!d && B) {
+      m = z ? m : new u(this);
+      var v = i.apply(m, I);
+      return v.__actions__.push({ func: K, args: [E], thisArg: void 0 }), new H(v, A);
+    }
+    return S && z ? i.apply(this, I) : (v = this.thru(E), S ? f ? v.value()[0] : v.value() : v);
+  });
+});
+_(["pop", "push", "shift", "sort", "splice", "unshift"], function(i) {
+  var o = ft[i], n = /^(?:push|sort|unshift)$/.test(i) ? "tap" : "thru", f = /^(?:pop|shift)$/.test(i);
+  t.prototype[i] = function() {
+    var y = arguments;
+    if (f && !this.__chain__) {
+      var d = this.value();
+      return o.apply(W(d) ? d : [], y);
+    }
+    return this[n](function(m) {
+      return o.apply(W(m) ? m : [], y);
+    });
+  };
+});
+x(u.prototype, function(i, o) {
+  var n = t[o];
+  if (n) {
+    var f = n.name + "";
+    $.call(b, f) || (b[f] = []), b[f].push({ name: o, func: n });
+  }
+});
+b[Q(void 0, st).name] = [{
+  name: "wrapper",
+  func: void 0
+}];
+u.prototype.clone = et;
+u.prototype.reverse = rt;
+u.prototype.value = it;
+t.prototype.at = g.at;
+t.prototype.chain = g.wrapperChain;
+t.prototype.commit = g.commit;
+t.prototype.next = g.next;
+t.prototype.plant = g.plant;
+t.prototype.reverse = g.reverse;
+t.prototype.toJSON = t.prototype.valueOf = t.prototype.value = g.value;
+t.prototype.first = t.prototype.head;
+P && (t.prototype[P] = g.toIterator);
+export {
+  t as default
+};