689 lines
19 KiB
JavaScript
689 lines
19 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 09166d9658efb080.e1742a6c63.js
|
|
* Module id: 466679
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
var t,
|
|
n = Symbol.for("immer-nothing"),
|
|
o = Symbol.for("immer-draftable"),
|
|
i = Symbol.for("immer-state");
|
|
function r(e) {
|
|
throw Error(
|
|
`[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`,
|
|
);
|
|
}
|
|
var a = Object.getPrototypeOf;
|
|
function s(e) {
|
|
return !!e && !!e[i];
|
|
}
|
|
function l(e) {
|
|
return (
|
|
!!e &&
|
|
(c(e) ||
|
|
Array.isArray(e) ||
|
|
!!e[o] ||
|
|
!!e.constructor?.[o] ||
|
|
m(e) ||
|
|
y(e))
|
|
);
|
|
}
|
|
var d = Object.prototype.constructor.toString(),
|
|
u = new WeakMap();
|
|
function c(e) {
|
|
if (!e || "object" != typeof e) return !1;
|
|
let t = Object.getPrototypeOf(e);
|
|
if (null === t || t === Object.prototype) return !0;
|
|
let n = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
|
|
if (n === Object) return !0;
|
|
if ("function" != typeof n) return !1;
|
|
let o = u.get(n);
|
|
return (
|
|
void 0 === o && ((o = Function.toString.call(n)), u.set(n, o)), o === d
|
|
);
|
|
}
|
|
function p(e, t, n = !0) {
|
|
0 === h(e)
|
|
? (n ? Reflect.ownKeys(e) : Object.keys(e)).forEach((n) => {
|
|
t(n, e[n], e);
|
|
})
|
|
: e.forEach((n, o) => t(o, n, e));
|
|
}
|
|
function h(e) {
|
|
let t = e[i];
|
|
return t ? t.type_ : Array.isArray(e) ? 1 : m(e) ? 2 : 3 * !!y(e);
|
|
}
|
|
function g(e, t) {
|
|
return 2 === h(e) ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
|
|
}
|
|
function f(e, t, n) {
|
|
let o = h(e);
|
|
2 === o ? e.set(t, n) : 3 === o ? e.add(n) : (e[t] = n);
|
|
}
|
|
function m(e) {
|
|
return e instanceof Map;
|
|
}
|
|
function y(e) {
|
|
return e instanceof Set;
|
|
}
|
|
function v(e) {
|
|
return e.copy_ || e.base_;
|
|
}
|
|
function w(e, t) {
|
|
if (m(e)) return new Map(e);
|
|
if (y(e)) return new Set(e);
|
|
if (Array.isArray(e)) return Array.prototype.slice.call(e);
|
|
let n = c(e);
|
|
if (!0 !== t && ("class_only" !== t || n)) {
|
|
let t = a(e);
|
|
return null !== t && n ? { ...e } : Object.assign(Object.create(t), e);
|
|
}
|
|
{
|
|
let t = Object.getOwnPropertyDescriptors(e);
|
|
delete t[i];
|
|
let n = Reflect.ownKeys(t);
|
|
for (let o = 0; o < n.length; o++) {
|
|
let i = n[o],
|
|
r = t[i];
|
|
!1 === r.writable && ((r.writable = !0), (r.configurable = !0)),
|
|
(r.get || r.set) &&
|
|
(t[i] = {
|
|
configurable: !0,
|
|
writable: !0,
|
|
enumerable: r.enumerable,
|
|
value: e[i],
|
|
});
|
|
}
|
|
return Object.create(a(e), t);
|
|
}
|
|
}
|
|
function x(e, t = !1) {
|
|
return (
|
|
b(e) ||
|
|
s(e) ||
|
|
!l(e) ||
|
|
(h(e) > 1 &&
|
|
Object.defineProperties(e, { set: S, add: S, clear: S, delete: S }),
|
|
Object.freeze(e),
|
|
t && Object.values(e).forEach((e) => x(e, !0))),
|
|
e
|
|
);
|
|
}
|
|
var S = {
|
|
value: function () {
|
|
r(2);
|
|
},
|
|
};
|
|
function b(e) {
|
|
return null === e || "object" != typeof e || Object.isFrozen(e);
|
|
}
|
|
var I = {};
|
|
function _(e) {
|
|
let t = I[e];
|
|
return t || r(0, e), t;
|
|
}
|
|
function E(e, t) {
|
|
t &&
|
|
(_("Patches"),
|
|
(e.patches_ = []),
|
|
(e.inversePatches_ = []),
|
|
(e.patchListener_ = t));
|
|
}
|
|
function M(e) {
|
|
C(e), e.drafts_.forEach(P), (e.drafts_ = null);
|
|
}
|
|
function C(e) {
|
|
e === t && (t = e.parent_);
|
|
}
|
|
function N(e) {
|
|
return (t = {
|
|
drafts_: [],
|
|
parent_: t,
|
|
immer_: e,
|
|
canAutoFreeze_: !0,
|
|
unfinalizedDrafts_: 0,
|
|
});
|
|
}
|
|
function P(e) {
|
|
let t = e[i];
|
|
0 === t.type_ || 1 === t.type_ ? t.revoke_() : (t.revoked_ = !0);
|
|
}
|
|
function k(e, t) {
|
|
t.unfinalizedDrafts_ = t.drafts_.length;
|
|
let o = t.drafts_[0];
|
|
return (
|
|
void 0 !== e && e !== o
|
|
? (o[i].modified_ && (M(t), r(4)),
|
|
l(e) && ((e = T(t, e)), t.parent_ || A(t, e)),
|
|
t.patches_ &&
|
|
_("Patches").generateReplacementPatches_(
|
|
o[i].base_,
|
|
e,
|
|
t.patches_,
|
|
t.inversePatches_,
|
|
))
|
|
: (e = T(t, o, [])),
|
|
M(t),
|
|
t.patches_ && t.patchListener_(t.patches_, t.inversePatches_),
|
|
e !== n ? e : void 0
|
|
);
|
|
}
|
|
function T(e, t, n) {
|
|
if (b(t)) return t;
|
|
let o = e.immer_.shouldUseStrictIteration(),
|
|
r = t[i];
|
|
if (!r) return p(t, (o, i) => O(e, r, t, o, i, n), o), t;
|
|
if (r.scope_ !== e) return t;
|
|
if (!r.modified_) return A(e, r.base_, !0), r.base_;
|
|
if (!r.finalized_) {
|
|
(r.finalized_ = !0), r.scope_.unfinalizedDrafts_--;
|
|
let t = r.copy_,
|
|
i = t,
|
|
a = !1;
|
|
3 === r.type_ && ((i = new Set(t)), t.clear(), (a = !0)),
|
|
p(i, (o, i) => O(e, r, t, o, i, n, a), o),
|
|
A(e, t, !1),
|
|
n &&
|
|
e.patches_ &&
|
|
_("Patches").generatePatches_(r, n, e.patches_, e.inversePatches_);
|
|
}
|
|
return r.copy_;
|
|
}
|
|
function O(e, t, n, o, i, r, a) {
|
|
if (null == i || ("object" != typeof i && !a)) return;
|
|
let d = b(i);
|
|
if (!d || a) {
|
|
if (s(i)) {
|
|
let a = T(
|
|
e,
|
|
i,
|
|
r && t && 3 !== t.type_ && !g(t.assigned_, o)
|
|
? r.concat(o)
|
|
: void 0,
|
|
);
|
|
if ((f(n, o, a), !s(a))) return;
|
|
e.canAutoFreeze_ = !1;
|
|
} else a && n.add(i);
|
|
if (l(i) && !d) {
|
|
if (
|
|
(!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1) ||
|
|
(t && t.base_ && t.base_[o] === i && d)
|
|
)
|
|
return;
|
|
T(e, i),
|
|
(!t || !t.scope_.parent_) &&
|
|
"symbol" != typeof o &&
|
|
(m(n)
|
|
? n.has(o)
|
|
: Object.prototype.propertyIsEnumerable.call(n, o)) &&
|
|
A(e, i);
|
|
}
|
|
}
|
|
}
|
|
function A(e, t, n = !1) {
|
|
!e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && x(t, n);
|
|
}
|
|
var D = {
|
|
get(e, t) {
|
|
if (t === i) return e;
|
|
let n = v(e);
|
|
if (!g(n, t)) {
|
|
var o;
|
|
let i;
|
|
return (
|
|
(o = e),
|
|
(i = R(n, t))
|
|
? "value" in i
|
|
? i.value
|
|
: i.get?.call(o.draft_)
|
|
: void 0
|
|
);
|
|
}
|
|
let r = n[t];
|
|
return e.finalized_ || !l(r)
|
|
? r
|
|
: r === j(e.base_, t)
|
|
? (F(e), (e.copy_[t] = $(r, e)))
|
|
: r;
|
|
},
|
|
has: (e, t) => t in v(e),
|
|
ownKeys: (e) => Reflect.ownKeys(v(e)),
|
|
set(e, t, n) {
|
|
let o = R(v(e), t);
|
|
if (o?.set) return o.set.call(e.draft_, n), !0;
|
|
if (!e.modified_) {
|
|
let o = j(v(e), t),
|
|
r = o?.[i];
|
|
if (r && r.base_ === n)
|
|
return (e.copy_[t] = n), (e.assigned_[t] = !1), !0;
|
|
if (
|
|
(n === o ? 0 !== n || 1 / n == 1 / o : n != n && o != o) &&
|
|
(void 0 !== n || g(e.base_, t))
|
|
)
|
|
return !0;
|
|
F(e), z(e);
|
|
}
|
|
return (
|
|
!!(
|
|
(e.copy_[t] === n && (void 0 !== n || t in e.copy_)) ||
|
|
(Number.isNaN(n) && Number.isNaN(e.copy_[t]))
|
|
) || ((e.copy_[t] = n), (e.assigned_[t] = !0), !0)
|
|
);
|
|
},
|
|
deleteProperty: (e, t) => (
|
|
void 0 !== j(e.base_, t) || t in e.base_
|
|
? ((e.assigned_[t] = !1), F(e), z(e))
|
|
: delete e.assigned_[t],
|
|
e.copy_ && delete e.copy_[t],
|
|
!0
|
|
),
|
|
getOwnPropertyDescriptor(e, t) {
|
|
let n = v(e),
|
|
o = Reflect.getOwnPropertyDescriptor(n, t);
|
|
return o
|
|
? {
|
|
writable: !0,
|
|
configurable: 1 !== e.type_ || "length" !== t,
|
|
enumerable: o.enumerable,
|
|
value: n[t],
|
|
}
|
|
: o;
|
|
},
|
|
defineProperty() {
|
|
r(11);
|
|
},
|
|
getPrototypeOf: (e) => a(e.base_),
|
|
setPrototypeOf() {
|
|
r(12);
|
|
},
|
|
},
|
|
L = {};
|
|
function j(e, t) {
|
|
let n = e[i];
|
|
return (n ? v(n) : e)[t];
|
|
}
|
|
function R(e, t) {
|
|
if (!(t in e)) return;
|
|
let n = a(e);
|
|
for (; n; ) {
|
|
let e = Object.getOwnPropertyDescriptor(n, t);
|
|
if (e) return e;
|
|
n = a(n);
|
|
}
|
|
}
|
|
function z(e) {
|
|
!e.modified_ && ((e.modified_ = !0), e.parent_ && z(e.parent_));
|
|
}
|
|
function F(e) {
|
|
e.copy_ || (e.copy_ = w(e.base_, e.scope_.immer_.useStrictShallowCopy_));
|
|
}
|
|
function $(e, n) {
|
|
let o = m(e)
|
|
? _("MapSet").proxyMap_(e, n)
|
|
: y(e)
|
|
? _("MapSet").proxySet_(e, n)
|
|
: (function (e, n) {
|
|
let o = Array.isArray(e),
|
|
i = {
|
|
type_: +!!o,
|
|
scope_: n ? n.scope_ : t,
|
|
modified_: !1,
|
|
finalized_: !1,
|
|
assigned_: {},
|
|
parent_: n,
|
|
base_: e,
|
|
draft_: null,
|
|
copy_: null,
|
|
revoke_: null,
|
|
isManual_: !1,
|
|
},
|
|
r = i,
|
|
a = D;
|
|
o && ((r = [i]), (a = L));
|
|
let { revoke: s, proxy: l } = Proxy.revocable(r, a);
|
|
return (i.draft_ = l), (i.revoke_ = s), l;
|
|
})(e, n);
|
|
return (n ? n.scope_ : t).drafts_.push(o), o;
|
|
}
|
|
function B() {
|
|
class e extends Map {
|
|
constructor(e, n) {
|
|
super(),
|
|
(this[i] = {
|
|
type_: 2,
|
|
parent_: n,
|
|
scope_: n ? n.scope_ : t,
|
|
modified_: !1,
|
|
finalized_: !1,
|
|
copy_: void 0,
|
|
assigned_: void 0,
|
|
base_: e,
|
|
draft_: this,
|
|
isManual_: !1,
|
|
revoked_: !1,
|
|
});
|
|
}
|
|
get size() {
|
|
return v(this[i]).size;
|
|
}
|
|
has(e) {
|
|
return v(this[i]).has(e);
|
|
}
|
|
set(e, t) {
|
|
let o = this[i];
|
|
return (
|
|
s(o),
|
|
(v(o).has(e) && v(o).get(e) === t) ||
|
|
(n(o),
|
|
z(o),
|
|
o.assigned_.set(e, !0),
|
|
o.copy_.set(e, t),
|
|
o.assigned_.set(e, !0)),
|
|
this
|
|
);
|
|
}
|
|
delete(e) {
|
|
if (!this.has(e)) return !1;
|
|
let t = this[i];
|
|
return (
|
|
s(t),
|
|
n(t),
|
|
z(t),
|
|
t.base_.has(e) ? t.assigned_.set(e, !1) : t.assigned_.delete(e),
|
|
t.copy_.delete(e),
|
|
!0
|
|
);
|
|
}
|
|
clear() {
|
|
let e = this[i];
|
|
s(e),
|
|
v(e).size &&
|
|
(n(e),
|
|
z(e),
|
|
(e.assigned_ = new Map()),
|
|
p(e.base_, (t) => {
|
|
e.assigned_.set(t, !1);
|
|
}),
|
|
e.copy_.clear());
|
|
}
|
|
forEach(e, t) {
|
|
v(this[i]).forEach((n, o, i) => {
|
|
e.call(t, this.get(o), o, this);
|
|
});
|
|
}
|
|
get(e) {
|
|
let t = this[i];
|
|
s(t);
|
|
let o = v(t).get(e);
|
|
if (t.finalized_ || !l(o) || o !== t.base_.get(e)) return o;
|
|
let r = $(o, t);
|
|
return n(t), t.copy_.set(e, r), r;
|
|
}
|
|
keys() {
|
|
return v(this[i]).keys();
|
|
}
|
|
values() {
|
|
let e = this.keys();
|
|
return {
|
|
[Symbol.iterator]: () => this.values(),
|
|
next: () => {
|
|
let t = e.next();
|
|
return t.done ? t : { done: !1, value: this.get(t.value) };
|
|
},
|
|
};
|
|
}
|
|
entries() {
|
|
let e = this.keys();
|
|
return {
|
|
[Symbol.iterator]: () => this.entries(),
|
|
next: () => {
|
|
let t = e.next();
|
|
if (t.done) return t;
|
|
let n = this.get(t.value);
|
|
return { done: !1, value: [t.value, n] };
|
|
},
|
|
};
|
|
}
|
|
[Symbol.iterator]() {
|
|
return this.entries();
|
|
}
|
|
}
|
|
function n(e) {
|
|
e.copy_ || ((e.assigned_ = new Map()), (e.copy_ = new Map(e.base_)));
|
|
}
|
|
class o extends Set {
|
|
constructor(e, n) {
|
|
super(),
|
|
(this[i] = {
|
|
type_: 3,
|
|
parent_: n,
|
|
scope_: n ? n.scope_ : t,
|
|
modified_: !1,
|
|
finalized_: !1,
|
|
copy_: void 0,
|
|
base_: e,
|
|
draft_: this,
|
|
drafts_: new Map(),
|
|
revoked_: !1,
|
|
isManual_: !1,
|
|
});
|
|
}
|
|
get size() {
|
|
return v(this[i]).size;
|
|
}
|
|
has(e) {
|
|
let t = this[i];
|
|
return (s(t), t.copy_)
|
|
? !!(
|
|
t.copy_.has(e) ||
|
|
(t.drafts_.has(e) && t.copy_.has(t.drafts_.get(e)))
|
|
)
|
|
: t.base_.has(e);
|
|
}
|
|
add(e) {
|
|
let t = this[i];
|
|
return s(t), this.has(e) || (a(t), z(t), t.copy_.add(e)), this;
|
|
}
|
|
delete(e) {
|
|
if (!this.has(e)) return !1;
|
|
let t = this[i];
|
|
return (
|
|
s(t),
|
|
a(t),
|
|
z(t),
|
|
t.copy_.delete(e) ||
|
|
(!!t.drafts_.has(e) && t.copy_.delete(t.drafts_.get(e)))
|
|
);
|
|
}
|
|
clear() {
|
|
let e = this[i];
|
|
s(e), v(e).size && (a(e), z(e), e.copy_.clear());
|
|
}
|
|
values() {
|
|
let e = this[i];
|
|
return s(e), a(e), e.copy_.values();
|
|
}
|
|
entries() {
|
|
let e = this[i];
|
|
return s(e), a(e), e.copy_.entries();
|
|
}
|
|
keys() {
|
|
return this.values();
|
|
}
|
|
[Symbol.iterator]() {
|
|
return this.values();
|
|
}
|
|
forEach(e, t) {
|
|
let n = this.values(),
|
|
o = n.next();
|
|
for (; !o.done; ) e.call(t, o.value, o.value, this), (o = n.next());
|
|
}
|
|
}
|
|
function a(e) {
|
|
e.copy_ ||
|
|
((e.copy_ = new Set()),
|
|
e.base_.forEach((t) => {
|
|
if (l(t)) {
|
|
let n = $(t, e);
|
|
e.drafts_.set(t, n), e.copy_.add(n);
|
|
} else e.copy_.add(t);
|
|
}));
|
|
}
|
|
function s(e) {
|
|
e.revoked_ && r(3, JSON.stringify(v(e)));
|
|
}
|
|
I.MapSet ||
|
|
(I.MapSet = {
|
|
proxyMap_: function (t, n) {
|
|
return new e(t, n);
|
|
},
|
|
proxySet_: function (e, t) {
|
|
return new o(e, t);
|
|
},
|
|
});
|
|
}
|
|
p(D, (e, t) => {
|
|
L[e] = function () {
|
|
return (arguments[0] = arguments[0][0]), t.apply(this, arguments);
|
|
};
|
|
}),
|
|
(L.deleteProperty = function (e, t) {
|
|
return L.set.call(this, e, t, void 0);
|
|
}),
|
|
(L.set = function (e, t, n) {
|
|
return D.set.call(this, e[0], t, n, e[0]);
|
|
});
|
|
var H = new (class {
|
|
constructor(e) {
|
|
(this.autoFreeze_ = !0),
|
|
(this.useStrictShallowCopy_ = !1),
|
|
(this.useStrictIteration_ = !0),
|
|
(this.produce = (e, t, o) => {
|
|
let i;
|
|
if ("function" == typeof e && "function" != typeof t) {
|
|
let n = t;
|
|
t = e;
|
|
let o = this;
|
|
return function (e = n, ...i) {
|
|
return o.produce(e, (e) => t.call(this, e, ...i));
|
|
};
|
|
}
|
|
if (
|
|
("function" != typeof t && r(6),
|
|
void 0 !== o && "function" != typeof o && r(7),
|
|
l(e))
|
|
) {
|
|
let n = N(this),
|
|
r = $(e, void 0),
|
|
a = !0;
|
|
try {
|
|
(i = t(r)), (a = !1);
|
|
} finally {
|
|
a ? M(n) : C(n);
|
|
}
|
|
return E(n, o), k(i, n);
|
|
}
|
|
if (e && "object" == typeof e) r(1, e);
|
|
else {
|
|
if (
|
|
(void 0 === (i = t(e)) && (i = e),
|
|
i === n && (i = void 0),
|
|
this.autoFreeze_ && x(i, !0),
|
|
o)
|
|
) {
|
|
let t = [],
|
|
n = [];
|
|
_("Patches").generateReplacementPatches_(e, i, t, n), o(t, n);
|
|
}
|
|
return i;
|
|
}
|
|
}),
|
|
(this.produceWithPatches = (e, t) => {
|
|
let n, o;
|
|
return "function" == typeof e
|
|
? (t, ...n) => this.produceWithPatches(t, (t) => e(t, ...n))
|
|
: [
|
|
this.produce(e, t, (e, t) => {
|
|
(n = e), (o = t);
|
|
}),
|
|
n,
|
|
o,
|
|
];
|
|
}),
|
|
"boolean" == typeof e?.autoFreeze && this.setAutoFreeze(e.autoFreeze),
|
|
"boolean" == typeof e?.useStrictShallowCopy &&
|
|
this.setUseStrictShallowCopy(e.useStrictShallowCopy),
|
|
"boolean" == typeof e?.useStrictIteration &&
|
|
this.setUseStrictIteration(e.useStrictIteration);
|
|
}
|
|
createDraft(e) {
|
|
var t;
|
|
l(e) || r(8),
|
|
s(e) &&
|
|
(s((t = e)) || r(10, t),
|
|
(e = (function e(t) {
|
|
let n;
|
|
if (!l(t) || b(t)) return t;
|
|
let o = t[i],
|
|
r = !0;
|
|
if (o) {
|
|
if (!o.modified_) return o.base_;
|
|
(o.finalized_ = !0),
|
|
(n = w(t, o.scope_.immer_.useStrictShallowCopy_)),
|
|
(r = o.scope_.immer_.shouldUseStrictIteration());
|
|
} else n = w(t, !0);
|
|
return (
|
|
p(
|
|
n,
|
|
(t, o) => {
|
|
f(n, t, e(o));
|
|
},
|
|
r,
|
|
),
|
|
o && (o.finalized_ = !1),
|
|
n
|
|
);
|
|
})(t)));
|
|
let n = N(this),
|
|
o = $(e, void 0);
|
|
return (o[i].isManual_ = !0), C(n), o;
|
|
}
|
|
finishDraft(e, t) {
|
|
let n = e && e[i];
|
|
(n && n.isManual_) || r(9);
|
|
let { scope_: o } = n;
|
|
return E(o, t), k(void 0, o);
|
|
}
|
|
setAutoFreeze(e) {
|
|
this.autoFreeze_ = e;
|
|
}
|
|
setUseStrictShallowCopy(e) {
|
|
this.useStrictShallowCopy_ = e;
|
|
}
|
|
setUseStrictIteration(e) {
|
|
this.useStrictIteration_ = e;
|
|
}
|
|
shouldUseStrictIteration() {
|
|
return this.useStrictIteration_;
|
|
}
|
|
applyPatches(e, t) {
|
|
let n;
|
|
for (n = t.length - 1; n >= 0; n--) {
|
|
let o = t[n];
|
|
if (0 === o.path.length && "replace" === o.op) {
|
|
e = o.value;
|
|
break;
|
|
}
|
|
}
|
|
n > -1 && (t = t.slice(n + 1));
|
|
let o = _("Patches").applyPatches_;
|
|
return s(e) ? o(e, t) : this.produce(e, (e) => o(e, t));
|
|
}
|
|
})().produce;
|
|
e.s(["enableMapSet", () => B, "isDraft", () => s, "produce", () => H]);
|
|
};
|
|
|
|
export default moduleFactory;
|