@equinor/fusion-framework-vite-plugin-spa 1.0.0 → 1.1.0

package/dist/html/bootstrap.js

@@ -4663,7 +4663,7 @@ function defaultErrorFactory() {
     return new EmptyError();
 }
 
-function finalize(callback) {
+function finalize$1(callback) {
     return operate(function (source, subscriber) {
         try {
             source.subscribe(subscriber);
@@ -9838,7 +9838,7 @@ const coerce = {
 };
 const NEVER = INVALID;
 
-var z$1 = /*#__PURE__*/Object.freeze({
+var z = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	BRAND: BRAND,
 	DIRTY: DIRTY,
@@ -10585,7 +10585,7 @@ const createSseSelector = (options) => {
             eventFilter: options?.eventFilter,
         })).pipe(
         // Stop reading if the abort signal is triggered
-        takeUntil(options?.abortSignal ? fromEvent(options.abortSignal, 'abort') : EMPTY), finalize(async () => {
+        takeUntil(options?.abortSignal ? fromEvent(options.abortSignal, 'abort') : EMPTY), finalize$1(async () => {
             // cancel just in case of a pre-mature exit
             await reader.cancel().catch(() => {
                 /** ignore cancellation errors */
@@ -10998,21 +10998,21 @@ const configureHttpClient = (name, args) => ({
 var MsalModuleVersion;
 (function (MsalModuleVersion) {
     MsalModuleVersion["V2"] = "v2";
-    MsalModuleVersion["Latest"] = "4.0.8";
+    MsalModuleVersion["Latest"] = "4.1.0";
 })(MsalModuleVersion || (MsalModuleVersion = {}));
 
-const VersionSchema = z$1.string().transform((x) => String(semver.coerce(x)));
-const AuthClientConfigSchema = z$1.object({
-    clientId: z$1.string(),
-    tenantId: z$1.string(),
-    redirectUri: z$1.string().optional(),
+const VersionSchema = z.string().transform((x) => String(semver.coerce(x)));
+const AuthClientConfigSchema = z.object({
+    clientId: z.string(),
+    tenantId: z.string(),
+    redirectUri: z.string().optional(),
 });
 // NOTE: this might need refinement to validate the provider
-const AuthClientSchema = z$1.custom();
-const AuthConfigSchema = z$1.object({
+const AuthClientSchema = z.custom();
+const AuthConfigSchema = z.object({
     client: AuthClientConfigSchema.optional(),
     provider: AuthClientSchema.optional(),
-    requiresAuth: z$1.boolean().optional(),
+    requiresAuth: z.boolean().optional(),
     version: VersionSchema,
 });
 class AuthConfigurator extends BaseConfigBuilder {
@@ -29234,27 +29234,228 @@ let ConsoleLogger$1 = class ConsoleLogger extends Logger$1 {
     };
 };
 
+var VersionMessageType;
+(function (VersionMessageType) {
+    VersionMessageType["MajorIncompatibility"] = "major-incompatibility";
+    VersionMessageType["MinorMismatch"] = "minor-mismatch";
+    VersionMessageType["PatchDifference"] = "patch-difference";
+    VersionMessageType["InvalidVersion"] = "invalid-version";
+    VersionMessageType["InvalidLatestVersion"] = "invalid-latest-version";
+    VersionMessageType["IncompatibleVersion"] = "incompatible-version";
+})(VersionMessageType || (VersionMessageType = {}));
+
+/**
+ * Creates a human-readable version message based on the version message type.
+ *
+ * This function generates descriptive error messages for different version compatibility
+ * scenarios, helping developers understand version-related issues.
+ *
+ * @param type - The type of version message to create
+ * @param requestedVersion - The version that was requested by the user
+ * @param latestVersion - The latest available version in the system
+ * @returns A formatted, human-readable version message string
+ *
+ * @example
+ * ```typescript
+ * const message = createVersionMessage(
+ *   VersionMessageType.MajorIncompatibility,
+ *   '3.0.0',
+ *   '2.1.0'
+ * );
+ * // Returns: "Requested major version 3.0.0 is greater than the latest major version 2.1.0"
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const message = createVersionMessage(
+ *   VersionMessageType.MinorMismatch,
+ *   '2.1.0',
+ *   '2.2.0'
+ * );
+ * // Returns: "Minor version mismatch, requested 2.1.0, latest 2.2.0"
+ * ```
+ */
+const createVersionMessage = (type, requestedVersion, latestVersion) => {
+    // Convert versions to strings for consistent formatting
+    const requestedVersionString = String(requestedVersion);
+    const latestVersionString = String(latestVersion);
+    switch (type) {
+        case VersionMessageType.MajorIncompatibility:
+            return `Requested major version ${requestedVersionString} is greater than the latest major version ${latestVersionString}`;
+        case VersionMessageType.InvalidVersion:
+            return `Invalid version ${requestedVersionString}`;
+        case VersionMessageType.InvalidLatestVersion:
+            return `Failed to parse latest version "${latestVersionString}" - this indicates the version.ts file was not generated correctly. Check for import errors in the build process.`;
+        case VersionMessageType.MinorMismatch:
+            return `Minor version mismatch, requested ${requestedVersionString}, latest ${latestVersionString}`;
+        case VersionMessageType.PatchDifference:
+            return `Patch version difference, requested ${requestedVersionString}, latest ${latestVersionString}`;
+        case VersionMessageType.IncompatibleVersion:
+            return `Incompatible version, requested ${requestedVersionString}, latest ${latestVersionString}`;
+        default:
+            return createVersionMessage(VersionMessageType.IncompatibleVersion, requestedVersion, latestVersion);
+    }
+};
+
+/**
+ * Creates a VersionError instance with a formatted message.
+ *
+ * This is a helper function that creates a VersionError with a human-readable
+ * message based on the error type and version information.
+ *
+ * @param type - The type of version error
+ * @param requestedVersion - The version that was requested
+ * @param latestVersion - The latest available version
+ * @param options - Additional error options including the error type
+ * @returns A new VersionError instance with formatted message
+ */
+const createVersionError = (type, requestedVersion, latestVersion, options) => {
+    return new VersionError(createVersionMessage(type, requestedVersion, latestVersion), requestedVersion, latestVersion, { ...options, type });
+};
+/**
+ * Error class for version-related issues in the MSAL module.
+ *
+ * This error is thrown when there are version compatibility problems,
+ * such as requesting an incompatible major version or providing an invalid version string.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   resolveVersion('3.0.0'); // Assuming latest is 2.x
+ * } catch (error) {
+ *   if (error instanceof VersionError) {
+ *     console.error('Version error:', error.message);
+ *     console.error('Requested:', error.requestedVersion);
+ *     console.error('Latest:', error.latestVersion);
+ *     console.error('Type:', error.type);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create a version error manually
+ * const error = VersionError.create(
+ *   VersionError.Type.MajorIncompatibility,
+ *   '3.0.0',
+ *   '2.1.0'
+ * );
+ * ```
+ */
+class VersionError extends Error {
+    /** The version that was requested by the user */
+    requestedVersion;
+    /** The latest available version in the system */
+    latestVersion;
+    /** The specific type of version error that occurred */
+    type;
+    /** The error name for instanceof checks */
+    static Name = 'VersionError';
+    /** Reference to the VersionMessageType enum for convenience */
+    static Type = VersionMessageType;
+    /** Factory method for creating VersionError instances with formatted messages */
+    static create = createVersionError;
+    /**
+     * Creates a new VersionError instance.
+     *
+     * @param message - The error message describing the version issue
+     * @param requestedVersion - The version that was requested (will be stored as string)
+     * @param latestVersion - The latest available version (will be stored as string)
+     * @param options - Additional error options including the error type
+     */
+    constructor(message, requestedVersion, latestVersion, options) {
+        super(message, options);
+        this.name = VersionError.Name;
+        // Store versions as strings
+        this.requestedVersion = String(requestedVersion);
+        this.latestVersion = String(latestVersion);
+        this.type = options?.type;
+    }
+}
+
+/**
+ * Resolves and validates a version string against the latest available MSAL version.
+ *
+ * This function performs comprehensive version checking including:
+ * - Parsing and validating the requested version
+ * - Checking major version compatibility (throws on incompatibility)
+ * - Warning on minor version mismatches (logs warning but continues)
+ * - Ignoring patch version differences for maximum compatibility
+ *
+ * @param version - The version string or SemVer object to resolve. If not provided, defaults to latest.
+ * @returns A ResolvedVersion object containing parsed versions and compatibility information
+ *
+ * @throws {VersionError} When the requested version is invalid or incompatible
+ *
+ * @example
+ * ```typescript
+ * // Resolve a specific version
+ * const result = resolveVersion('2.1.0');
+ * console.log(result.satisfiesLatest); // true if major version matches
+ *
+ * // Resolve with SemVer object
+ * const result2 = resolveVersion(new SemVer('2.0.0'));
+ *
+ * // Default to latest version
+ * const result3 = resolveVersion();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Error handling
+ * try {
+ *   const result = resolveVersion('3.0.0'); // Assuming latest is 2.x
+ * } catch (error) {
+ *   if (error instanceof VersionError) {
+ *     console.error('Version error:', error.message);
+ *   }
+ * }
+ * ```
+ */
 function resolveVersion(version) {
-    const wantedVersion = semver.coerce(version || MsalModuleVersion.Latest);
+    // Initialize warnings array to collect any version mismatches
+    const warnings = [];
+    // Parse the requested version, defaulting to latest if not provided
+    const versionString = version || MsalModuleVersion.Latest;
+    // Parse versions using coerce for backward compatibility
+    const wantedVersion = semver.coerce(versionString);
     const latestVersion = semver.coerce(MsalModuleVersion.Latest);
-    // check if version is valid semver version
+    // Validate that the requested version is a valid semver
     if (!wantedVersion) {
-        throw new Error(`Invalid version ${version} provided`);
+        throw VersionError.create(VersionError.Type.InvalidVersion, versionString, MsalModuleVersion.Latest);
     }
+    // This should never happen! Indicates version.ts was not generated correctly
+    // This is a critical build-time issue that needs immediate attention
     if (!latestVersion) {
-        throw new Error('Invalid latest version');
+        throw VersionError.create(VersionError.Type.InvalidLatestVersion, versionString, MsalModuleVersion.Latest);
+    }
+    // Major version incompatibility check - this is a hard error
+    // Users cannot request a major version that doesn't exist yet
+    if (wantedVersion.major > latestVersion.major) {
+        throw VersionError.create(VersionError.Type.MajorIncompatibility, String(wantedVersion), String(latestVersion));
     }
-    // check if version is greater than latest
-    if (semver.gt(wantedVersion, latestVersion)) {
-        throw new Error(`Requested version ${version} is greater than the latest version ${MsalModuleVersion.Latest}`);
+    // Minor version mismatch - add warning but don't throw
+    // This helps developers stay aware of version differences without breaking functionality
+    if (wantedVersion.major === latestVersion.major && wantedVersion.minor !== latestVersion.minor) {
+        const minorMismatchWarning = VersionError.create(VersionError.Type.MinorMismatch, String(wantedVersion), String(latestVersion));
+        warnings.push(minorMismatchWarning.message);
     }
+    // Find the corresponding enum version for the requested major version
+    // This is used for module configuration and feature detection
     const enumVersion = Object.values(MsalModuleVersion).find((x) => semver.coerce(x)?.major === wantedVersion.major);
+    // If no matching enum version is found, this indicates a major version
+    // that doesn't have a corresponding enum value defined
+    if (!enumVersion) {
+        throw VersionError.create(VersionError.Type.MajorIncompatibility, String(wantedVersion), String(latestVersion));
+    }
+    // Return comprehensive version resolution result
     return {
         wantedVersion,
         latestVersion,
-        enumVersion,
         isLatest: wantedVersion.compare(latestVersion) === 0,
         satisfiesLatest: wantedVersion.major === latestVersion.major,
+        enumVersion,
+        warnings: warnings.length > 0 ? warnings : undefined,
     };
 }
 
@@ -29544,10 +29745,7 @@ function v35(version, hash, value, namespace, buf, offset) {
 const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
 var native = { randomUUID };
 
-function v4(options, buf, offset) {
-    if (native.randomUUID && true && !options) {
-        return native.randomUUID();
-    }
+function _v4(options, buf, offset) {
     options = options || {};
     const rnds = options.random ?? options.rng?.() ?? rng();
     if (rnds.length < 16) {
@@ -29557,8 +29755,14 @@ function v4(options, buf, offset) {
     rnds[8] = (rnds[8] & 0x3f) | 0x80;
     return unsafeStringify(rnds);
 }
+function v4(options, buf, offset) {
+    if (native.randomUUID && true && !options) {
+        return native.randomUUID();
+    }
+    return _v4(options);
+}
 
-function f$1(s, x, y, z) {
+function f(s, x, y, z) {
     switch (s) {
         case 0:
             return (x & y) ^ (~x & z);
@@ -29612,7 +29816,7 @@ function sha1(bytes) {
         let e = H[4];
         for (let t = 0; t < 80; ++t) {
             const s = Math.floor(t / 20);
-            const T = (ROTL(a, 5) + f$1(s, b, c, d) + e + K[s] + W[t]) >>> 0;
+            const T = (ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t]) >>> 0;
             e = d;
             d = c;
             c = ROTL(b, 30) >>> 0;
@@ -29672,7 +29876,711 @@ class QueryClientError extends Error {
     }
 }
 
-function n(n){for(var r=arguments.length,t=Array(r>1?r-1:0),e=1;e<r;e++)t[e-1]=arguments[e];if("production"!==process.env.NODE_ENV){var i=Y[n],o=i?"function"==typeof i?i.apply(null,t):i:"unknown error nr: "+n;throw Error("[Immer] "+o)}throw Error("[Immer] minified error nr: "+n+(t.length?" "+t.map((function(n){return "'"+n+"'"})).join(","):"")+". Find the full error at: https://bit.ly/3cXEKWf")}function r(n){return !!n&&!!n[Q]}function t(n){var r;return !!n&&(function(n){if(!n||"object"!=typeof n)return  false;var r=Object.getPrototypeOf(n);if(null===r)return  true;var t=Object.hasOwnProperty.call(r,"constructor")&&r.constructor;return t===Object||"function"==typeof t&&Function.toString.call(t)===Z}(n)||Array.isArray(n)||!!n[L]||!!(null===(r=n.constructor)||void 0===r?void 0:r[L])||s(n)||v(n))}function i(n,r,t){ void 0===t&&(t=false),0===o(n)?(t?Object.keys:nn)(n).forEach((function(e){t&&"symbol"==typeof e||r(e,n[e],n);})):n.forEach((function(t,e){return r(e,t,n)}));}function o(n){var r=n[Q];return r?r.i>3?r.i-4:r.i:Array.isArray(n)?1:s(n)?2:v(n)?3:0}function u(n,r){return 2===o(n)?n.has(r):Object.prototype.hasOwnProperty.call(n,r)}function a(n,r){return 2===o(n)?n.get(r):n[r]}function f(n,r,t){var e=o(n);2===e?n.set(r,t):3===e?n.add(t):n[r]=t;}function c(n,r){return n===r?0!==n||1/n==1/r:n!=n&&r!=r}function s(n){return X&&n instanceof Map}function v(n){return q&&n instanceof Set}function p(n){return n.o||n.t}function l(n){if(Array.isArray(n))return Array.prototype.slice.call(n);var r=rn(n);delete r[Q];for(var t=nn(r),e=0;e<t.length;e++){var i=t[e],o=r[i];false===o.writable&&(o.writable=true,o.configurable=true),(o.get||o.set)&&(r[i]={configurable:true,writable:true,enumerable:o.enumerable,value:n[i]});}return Object.create(Object.getPrototypeOf(n),r)}function d(n,e){return void 0===e&&(e=false),y(n)||r(n)||!t(n)||(o(n)>1&&(n.set=n.add=n.clear=n.delete=h),Object.freeze(n),e&&i(n,(function(n,r){return d(r,true)}),true)),n}function h(){n(2);}function y(n){return null==n||"object"!=typeof n||Object.isFrozen(n)}function b(r){var t=tn[r];return t||n(18,r),t}function _(){return "production"===process.env.NODE_ENV||U||n(0),U}function j(n,r){r&&(b("Patches"),n.u=[],n.s=[],n.v=r);}function g(n){O(n),n.p.forEach(S),n.p=null;}function O(n){n===U&&(U=n.l);}function w(n){return U={p:[],l:U,h:n,m:true,_:0}}function S(n){var r=n[Q];0===r.i||1===r.i?r.j():r.g=true;}function P(r,e){e._=e.p.length;var i=e.p[0],o=void 0!==r&&r!==i;return e.h.O||b("ES5").S(e,r,o),o?(i[Q].P&&(g(e),n(4)),t(r)&&(r=M(e,r),e.l||x(e,r)),e.u&&b("Patches").M(i[Q].t,r,e.u,e.s)):r=M(e,i,[]),g(e),e.u&&e.v(e.u,e.s),r!==H?r:void 0}function M(n,r,t){if(y(r))return r;var e=r[Q];if(!e)return i(r,(function(i,o){return A(n,e,r,i,o,t)}),true),r;if(e.A!==n)return r;if(!e.P)return x(n,e.t,true),e.t;if(!e.I){e.I=true,e.A._--;var o=4===e.i||5===e.i?e.o=l(e.k):e.o,u=o,a=false;3===e.i&&(u=new Set(o),o.clear(),a=true),i(u,(function(r,i){return A(n,e,o,r,i,t,a)})),x(n,o,false),t&&n.u&&b("Patches").N(e,t,n.u,n.s);}return e.o}function A(e,i,o,a,c,s,v){if("production"!==process.env.NODE_ENV&&c===o&&n(5),r(c)){var p=M(e,c,s&&i&&3!==i.i&&!u(i.R,a)?s.concat(a):void 0);if(f(o,a,p),!r(p))return;e.m=false;}else v&&o.add(c);if(t(c)&&!y(c)){if(!e.h.D&&e._<1)return;M(e,c),i&&i.A.l||x(e,c);}}function x(n,r,t){ void 0===t&&(t=false),!n.l&&n.h.D&&n.m&&d(r,t);}function z(n,r){var t=n[Q];return (t?p(t):n)[r]}function I(n,r){if(r in n)for(var t=Object.getPrototypeOf(n);t;){var e=Object.getOwnPropertyDescriptor(t,r);if(e)return e;t=Object.getPrototypeOf(t);}}function k(n){n.P||(n.P=true,n.l&&k(n.l));}function E(n){n.o||(n.o=l(n.t));}function N(n,r,t){var e=s(r)?b("MapSet").F(r,t):v(r)?b("MapSet").T(r,t):n.O?function(n,r){var t=Array.isArray(n),e={i:t?1:0,A:r?r.A:_(),P:false,I:false,R:{},l:r,t:n,k:null,o:null,j:null,C:false},i=e,o=en;t&&(i=[e],o=on);var u=Proxy.revocable(i,o),a=u.revoke,f=u.proxy;return e.k=f,e.j=a,f}(r,t):b("ES5").J(r,t);return (t?t.A:_()).p.push(e),e}function R(e){return r(e)||n(22,e),function n(r){if(!t(r))return r;var e,u=r[Q],c=o(r);if(u){if(!u.P&&(u.i<4||!b("ES5").K(u)))return u.t;u.I=true,e=D(r,c),u.I=false;}else e=D(r,c);return i(e,(function(r,t){u&&a(u.t,r)===t||f(e,r,n(t));})),3===c?new Set(e):e}(e)}function D(n,r){switch(r){case 2:return new Map(n);case 3:return Array.from(n)}return l(n)}function K(n){return n}var G,U,W="undefined"!=typeof Symbol&&"symbol"==typeof Symbol("x"),X="undefined"!=typeof Map,q="undefined"!=typeof Set,B="undefined"!=typeof Proxy&&void 0!==Proxy.revocable&&"undefined"!=typeof Reflect,H=W?Symbol.for("immer-nothing"):((G={})["immer-nothing"]=true,G),L=W?Symbol.for("immer-draftable"):"__$immer_draftable",Q=W?Symbol.for("immer-state"):"__$immer_state",Y={0:"Illegal state",1:"Immer drafts cannot have computed properties",2:"This object has been frozen and should not be mutated",3:function(n){return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? "+n},4:"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",5:"Immer forbids circular references",6:"The first or second argument to `produce` must be a function",7:"The third argument to `produce` must be a function or undefined",8:"First argument to `createDraft` must be a plain object, an array, or an immerable object",9:"First argument to `finishDraft` must be a draft returned by `createDraft`",10:"The given draft is already finalized",11:"Object.defineProperty() cannot be used on an Immer draft",12:"Object.setPrototypeOf() cannot be used on an Immer draft",13:"Immer only supports deleting array indices",14:"Immer only supports setting array indices and the 'length' property",15:function(n){return "Cannot apply patch, path doesn't resolve: "+n},16:'Sets cannot have "replace" patches.',17:function(n){return "Unsupported patch operation: "+n},18:function(n){return "The plugin for '"+n+"' has not been loaded into Immer. To enable the plugin, import and call `enable"+n+"()` when initializing your application."},20:"Cannot use proxies if Proxy, Proxy.revocable or Reflect are not available",21:function(n){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 '"+n+"'"},22:function(n){return "'current' expects a draft, got: "+n},23:function(n){return "'original' expects a draft, got: "+n},24:"Patching reserved attributes like __proto__, prototype and constructor is not allowed"},Z=""+Object.prototype.constructor,nn="undefined"!=typeof Reflect&&Reflect.ownKeys?Reflect.ownKeys:void 0!==Object.getOwnPropertySymbols?function(n){return Object.getOwnPropertyNames(n).concat(Object.getOwnPropertySymbols(n))}:Object.getOwnPropertyNames,rn=Object.getOwnPropertyDescriptors||function(n){var r={};return nn(n).forEach((function(t){r[t]=Object.getOwnPropertyDescriptor(n,t);})),r},tn={},en={get:function(n,r){if(r===Q)return n;var e=p(n);if(!u(e,r))return function(n,r,t){var e,i=I(r,t);return i?"value"in i?i.value:null===(e=i.get)||void 0===e?void 0:e.call(n.k):void 0}(n,e,r);var i=e[r];return n.I||!t(i)?i:i===z(n.t,r)?(E(n),n.o[r]=N(n.A.h,i,n)):i},has:function(n,r){return r in p(n)},ownKeys:function(n){return Reflect.ownKeys(p(n))},set:function(n,r,t){var e=I(p(n),r);if(null==e?void 0:e.set)return e.set.call(n.k,t),true;if(!n.P){var i=z(p(n),r),o=null==i?void 0:i[Q];if(o&&o.t===t)return n.o[r]=t,n.R[r]=false,true;if(c(t,i)&&(void 0!==t||u(n.t,r)))return  true;E(n),k(n);}return n.o[r]===t&&(void 0!==t||r in n.o)||Number.isNaN(t)&&Number.isNaN(n.o[r])||(n.o[r]=t,n.R[r]=true),true},deleteProperty:function(n,r){return void 0!==z(n.t,r)||r in n.t?(n.R[r]=false,E(n),k(n)):delete n.R[r],n.o&&delete n.o[r],true},getOwnPropertyDescriptor:function(n,r){var t=p(n),e=Reflect.getOwnPropertyDescriptor(t,r);return e?{writable:true,configurable:1!==n.i||"length"!==r,enumerable:e.enumerable,value:t[r]}:e},defineProperty:function(){n(11);},getPrototypeOf:function(n){return Object.getPrototypeOf(n.t)},setPrototypeOf:function(){n(12);}},on={};i(en,(function(n,r){on[n]=function(){return arguments[0]=arguments[0][0],r.apply(this,arguments)};})),on.deleteProperty=function(r,t){return "production"!==process.env.NODE_ENV&&isNaN(parseInt(t))&&n(13),on.set.call(this,r,t,void 0)},on.set=function(r,t,e){return "production"!==process.env.NODE_ENV&&"length"!==t&&isNaN(parseInt(t))&&n(14),en.set.call(this,r[0],t,e,r[0])};var un=function(){function e(r){var e=this;this.O=B,this.D=true,this.produce=function(r,i,o){if("function"==typeof r&&"function"!=typeof i){var u=i;i=r;var a=e;return function(n){var r=this;void 0===n&&(n=u);for(var t=arguments.length,e=Array(t>1?t-1:0),o=1;o<t;o++)e[o-1]=arguments[o];return a.produce(n,(function(n){var t;return (t=i).call.apply(t,[r,n].concat(e))}))}}var f;if("function"!=typeof i&&n(6),void 0!==o&&"function"!=typeof o&&n(7),t(r)){var c=w(e),s=N(e,r,void 0),v=true;try{f=i(s),v=!1;}finally{v?g(c):O(c);}return "undefined"!=typeof Promise&&f instanceof Promise?f.then((function(n){return j(c,o),P(n,c)}),(function(n){throw g(c),n})):(j(c,o),P(f,c))}if(!r||"object"!=typeof r){if(void 0===(f=i(r))&&(f=r),f===H&&(f=void 0),e.D&&d(f,true),o){var p=[],l=[];b("Patches").M(r,f,p,l),o(p,l);}return f}n(21,r);},this.produceWithPatches=function(n,r){if("function"==typeof n)return function(r){for(var t=arguments.length,i=Array(t>1?t-1:0),o=1;o<t;o++)i[o-1]=arguments[o];return e.produceWithPatches(r,(function(r){return n.apply(void 0,[r].concat(i))}))};var t,i,o=e.produce(n,r,(function(n,r){t=n,i=r;}));return "undefined"!=typeof Promise&&o instanceof Promise?o.then((function(n){return [n,t,i]})):[o,t,i]},"boolean"==typeof(null==r?void 0:r.useProxies)&&this.setUseProxies(r.useProxies),"boolean"==typeof(null==r?void 0:r.autoFreeze)&&this.setAutoFreeze(r.autoFreeze);}var i=e.prototype;return i.createDraft=function(e){t(e)||n(8),r(e)&&(e=R(e));var i=w(this),o=N(this,e,void 0);return o[Q].C=true,O(i),o},i.finishDraft=function(r,t){var e=r&&r[Q];"production"!==process.env.NODE_ENV&&(e&&e.C||n(9),e.I&&n(10));var i=e.A;return j(i,t),P(void 0,i)},i.setAutoFreeze=function(n){this.D=n;},i.setUseProxies=function(r){r&&!B&&n(20),this.O=r;},i.applyPatches=function(n,t){var e;for(e=t.length-1;e>=0;e--){var i=t[e];if(0===i.path.length&&"replace"===i.op){n=i.value;break}}e>-1&&(t=t.slice(e+1));var o=b("Patches").$;return r(n)?o(n,t):this.produce(n,(function(n){return o(n,t)}))},e}(),an=new un,fn=an.produce;an.produceWithPatches.bind(an);an.setAutoFreeze.bind(an);an.setUseProxies.bind(an);an.applyPatches.bind(an);an.createDraft.bind(an);an.finishDraft.bind(an);
+// src/utils/env.ts
+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 = 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
+] : [];
+function die(error, ...args) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = errors[error];
+    const msg = typeof e === "function" ? e.apply(null, args) : e;
+    throw new Error(`[Immer] ${msg}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+
+// src/utils/common.ts
+var getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+  return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+  if (!value)
+    return false;
+  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+}
+var objectCtorString = Object.prototype.constructor.toString();
+function isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const 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 */) {
+    Reflect.ownKeys(obj).forEach((key) => {
+      iter(key, obj[key], obj);
+    });
+  } else {
+    obj.forEach((entry, index) => iter(index, entry, obj));
+  }
+}
+function getArchtype(thing) {
+  const 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 */) {
+    thing.add(value);
+  } else
+    thing[propOrOldValue] = value;
+}
+function is(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function isMap(target) {
+  return target instanceof Map;
+}
+function isSet(target) {
+  return target instanceof Set;
+}
+function latest(state) {
+  return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+  if (isMap(base)) {
+    return new Map(base);
+  }
+  if (isSet(base)) {
+    return new Set(base);
+  }
+  if (Array.isArray(base))
+    return Array.prototype.slice.call(base);
+  const isPlain = isPlainObject(base);
+  if (strict === true || strict === "class_only" && !isPlain) {
+    const 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];
+      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]
+        };
+    }
+    return Object.create(getPrototypeOf(base), descriptors);
+  } else {
+    const proto = getPrototypeOf(base);
+    if (proto !== null && isPlain) {
+      return { ...base };
+    }
+    const obj = Object.create(proto);
+    return Object.assign(obj, base);
+  }
+}
+function freeze(obj, deep = false) {
+  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
+    return obj;
+  if (getArchtype(obj) > 1) {
+    Object.defineProperties(obj, {
+      set: { value: dontMutateFrozenCollections },
+      add: { value: dontMutateFrozenCollections },
+      clear: { value: dontMutateFrozenCollections },
+      delete: { value: dontMutateFrozenCollections }
+    });
+  }
+  Object.freeze(obj);
+  if (deep)
+    Object.values(obj).forEach((value) => freeze(value, true));
+  return obj;
+}
+function dontMutateFrozenCollections() {
+  die(2);
+}
+function isFrozen(obj) {
+  return Object.isFrozen(obj);
+}
+
+// src/utils/plugins.ts
+var plugins = {};
+function getPlugin(pluginKey) {
+  const plugin = plugins[pluginKey];
+  if (!plugin) {
+    die(0, pluginKey);
+  }
+  return plugin;
+}
+
+// src/core/scope.ts
+var currentScope;
+function getCurrentScope() {
+  return currentScope;
+}
+function createScope(parent_, immer_) {
+  return {
+    drafts_: [],
+    parent_,
+    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,
+    unfinalizedDrafts_: 0
+  };
+}
+function usePatchesInScope(scope, patchListener) {
+  if (patchListener) {
+    getPlugin("Patches");
+    scope.patches_ = [];
+    scope.inversePatches_ = [];
+    scope.patchListener_ = patchListener;
+  }
+}
+function revokeScope(scope) {
+  leaveScope(scope);
+  scope.drafts_.forEach(revokeDraft);
+  scope.drafts_ = null;
+}
+function leaveScope(scope) {
+  if (scope === currentScope) {
+    currentScope = scope.parent_;
+  }
+}
+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;
+}
+
+// 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;
+  if (isReplaced) {
+    if (baseDraft[DRAFT_STATE].modified_) {
+      revokeScope(scope);
+      die(4);
+    }
+    if (isDraftable(result)) {
+      result = finalize(scope, result);
+      if (!scope.parent_)
+        maybeFreeze(scope, result);
+    }
+    if (scope.patches_) {
+      getPlugin("Patches").generateReplacementPatches_(
+        baseDraft[DRAFT_STATE].base_,
+        result,
+        scope.patches_,
+        scope.inversePatches_
+      );
+    }
+  } else {
+    result = finalize(scope, baseDraft, []);
+  }
+  revokeScope(scope);
+  if (scope.patches_) {
+    scope.patchListener_(scope.patches_, scope.inversePatches_);
+  }
+  return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value, path) {
+  if (isFrozen(value))
+    return value;
+  const state = value[DRAFT_STATE];
+  if (!state) {
+    each(
+      value,
+      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)
+    );
+    return value;
+  }
+  if (state.scope_ !== rootScope)
+    return value;
+  if (!state.modified_) {
+    maybeFreeze(rootScope, state.base_, true);
+    return state.base_;
+  }
+  if (!state.finalized_) {
+    state.finalized_ = true;
+    state.scope_.unfinalizedDrafts_--;
+    const result = state.copy_;
+    let resultEach = result;
+    let 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)
+    );
+    maybeFreeze(rootScope, result, false);
+    if (path && rootScope.patches_) {
+      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 (isDraft(childValue)) {
+    const 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);
+    set(targetObject, prop, res);
+    if (isDraft(res)) {
+      rootScope.canAutoFreeze_ = false;
+    } else
+      return;
+  } else if (targetIsSet) {
+    targetObject.add(childValue);
+  }
+  if (isDraftable(childValue) && !isFrozen(childValue)) {
+    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+      return;
+    }
+    finalize(rootScope, childValue);
+    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop)))
+      maybeFreeze(rootScope, childValue);
+  }
+}
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+
+// src/core/proxy.ts
+function createProxyProxy(base, parent) {
+  const isArray = Array.isArray(base);
+  const 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.
+    modified_: false,
+    // Used during finalization.
+    finalized_: false,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: parent,
+    // The base state.
+    base_: base,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: false
+  };
+  let target = state;
+  let traps = objectTraps;
+  if (isArray) {
+    target = [state];
+    traps = arrayTraps;
+  }
+  const { revoke, proxy } = Proxy.revocable(target, traps);
+  state.draft_ = proxy;
+  state.revoke_ = revoke;
+  return proxy;
+}
+var objectTraps = {
+  get(state, prop) {
+    if (prop === DRAFT_STATE)
+      return state;
+    const source = latest(state);
+    if (!has(source, prop)) {
+      return readPropFromProto(state, source, prop);
+    }
+    const value = source[prop];
+    if (state.finalized_ || !isDraftable(value)) {
+      return value;
+    }
+    if (value === peek(state.base_, prop)) {
+      prepareCopy(state);
+      return state.copy_[prop] = createProxy(value, state);
+    }
+    return value;
+  },
+  has(state, prop) {
+    return prop in latest(state);
+  },
+  ownKeys(state) {
+    return Reflect.ownKeys(latest(state));
+  },
+  set(state, prop, value) {
+    const desc = getDescriptorFromProto(latest(state), prop);
+    if (desc?.set) {
+      desc.set.call(state.draft_, value);
+      return true;
+    }
+    if (!state.modified_) {
+      const current2 = peek(latest(state), prop);
+      const currentState = 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;
+      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;
+    state.copy_[prop] = value;
+    state.assigned_[prop] = true;
+    return true;
+  },
+  deleteProperty(state, prop) {
+    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+      state.assigned_[prop] = false;
+      prepareCopy(state);
+      markChanged(state);
+    } else {
+      delete state.assigned_[prop];
+    }
+    if (state.copy_) {
+      delete state.copy_[prop];
+    }
+    return true;
+  },
+  // 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;
+    return {
+      writable: true,
+      configurable: state.type_ !== 1 /* Array */ || prop !== "length",
+      enumerable: desc.enumerable,
+      value: owner[prop]
+    };
+  },
+  defineProperty() {
+    die(11);
+  },
+  getPrototypeOf(state) {
+    return getPrototypeOf(state.base_);
+  },
+  setPrototypeOf() {
+    die(12);
+  }
+};
+var arrayTraps = {};
+each(objectTraps, (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);
+  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);
+  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;
+  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;
+}
+function getDescriptorFromProto(source, prop) {
+  if (!(prop in source))
+    return void 0;
+  let proto = getPrototypeOf(source);
+  while (proto) {
+    const desc = Object.getOwnPropertyDescriptor(proto, prop);
+    if (desc)
+      return desc;
+    proto = getPrototypeOf(proto);
+  }
+  return void 0;
+}
+function markChanged(state) {
+  if (!state.modified_) {
+    state.modified_ = true;
+    if (state.parent_) {
+      markChanged(state.parent_);
+    }
+  }
+}
+function prepareCopy(state) {
+  if (!state.copy_) {
+    state.copy_ = shallowCopy(
+      state.base_,
+      state.scope_.immer_.useStrictShallowCopy_
+    );
+  }
+}
+
+// src/core/immerClass.ts
+var Immer2 = class {
+  constructor(config) {
+    this.autoFreeze_ = true;
+    this.useStrictShallowCopy_ = false;
+    /**
+     * The `produce` function takes a value and a "recipe function" (whose
+     * return value often depends on the base state). The recipe function is
+     * free to mutate its first argument however it wants. All mutations are
+     * only ever applied to a __copy__ of the base state.
+     *
+     * Pass only a function to create a "curried producer" which relieves you
+     * from passing the recipe function every time.
+     *
+     * Only plain objects and arrays are made mutable. All other objects are
+     * considered uncopyable.
+     *
+     * Note: This function is __bound__ to its `Immer` instance.
+     *
+     * @param {any} base - the initial state
+     * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
+     * @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) => {
+      if (typeof base === "function" && typeof recipe !== "function") {
+        const defaultBase = recipe;
+        recipe = base;
+        const self = this;
+        return function curriedProduce(base2 = defaultBase, ...args) {
+          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+        };
+      }
+      if (typeof recipe !== "function")
+        die(6);
+      if (patchListener !== void 0 && typeof patchListener !== "function")
+        die(7);
+      let result;
+      if (isDraftable(base)) {
+        const scope = enterScope(this);
+        const proxy = createProxy(base, void 0);
+        let hasError = true;
+        try {
+          result = recipe(proxy);
+          hasError = false;
+        } finally {
+          if (hasError)
+            revokeScope(scope);
+          else
+            leaveScope(scope);
+        }
+        usePatchesInScope(scope, patchListener);
+        return processResult(result, scope);
+      } 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 (patchListener) {
+          const p = [];
+          const ip = [];
+          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+          patchListener(p, ip);
+        }
+        return result;
+      } else
+        die(1, base);
+    };
+    this.produceWithPatches = (base, recipe) => {
+      if (typeof base === "function") {
+        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+      }
+      let patches, inversePatches;
+      const result = this.produce(base, recipe, (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 (i > -1) {
+      patches = patches.slice(i + 1);
+    }
+    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+    if (isDraft(base)) {
+      return applyPatchesImpl(base, patches);
+    }
+    return this.produce(
+      base,
+      (draft) => applyPatchesImpl(draft, patches)
+    );
+  }
+};
+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();
+  scope.drafts_.push(draft);
+  return draft;
+}
+
+// src/core/current.ts
+function current(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 (state) {
+    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) => {
+    set(copy, key, currentImpl(childValue));
+  });
+  if (state) {
+    state.finalized_ = false;
+  }
+  return copy;
+}
+
+// src/immer.ts
+var immer = new Immer2();
+var produce = immer.produce;
+function castDraft(value) {
+  return value;
+}
 
 const filterAction = (...types) => filter((x) => types.includes(x.type));
 
@@ -29874,7 +30782,7 @@ function createAsyncAction(type, request, success, failure) {
 
 function freezeDraftable(val) {
     // biome-ignore lint/suspicious/noEmptyBlockStatements: This is a valid use case for an empty block statement
-    return t(val) ? fn(val, () => { }) : val;
+    return isDraftable(val) ? produce(val, () => { }) : val;
 }
 function isStateFunction(x) {
     return typeof x === 'function';
@@ -29900,7 +30808,7 @@ function createReducer$2(initialState, mapOrBuilderCallback) {
         }
         return caseReducers.reduce((previousState, caseReducer) => {
             if (caseReducer) {
-                if (r(previousState)) {
+                if (isDraft(previousState)) {
                     // If it's already a draft, we must already be inside a `createNextState` call,
                     // likely because this is being wrapped in `createReducer`, `createSlice`, or nested
                     // inside an existing draft. It's safe to just pass the draft to the mutator.
@@ -29911,7 +30819,7 @@ function createReducer$2(initialState, mapOrBuilderCallback) {
                     }
                     return result;
                 }
-                else if (!t(previousState)) {
+                else if (!isDraftable(previousState)) {
                     // If state is not draftable (ex: a primitive, such as 0), we want to directly
                     // return the caseReducer func and not wrap it with produce.
                     const result = caseReducer(previousState, action);
@@ -29929,7 +30837,7 @@ function createReducer$2(initialState, mapOrBuilderCallback) {
                     // createNextState() produces an Immutable<Draft<S>> rather
                     // than an Immutable<S>, and TypeScript cannot find out how to reconcile
                     // these two types.
-                    return fn(previousState, (draft) => {
+                    return produce(previousState, (draft) => {
                         return caseReducer(draft, action);
                     });
                 }
@@ -30195,7 +31103,7 @@ const createReducer$1 = (initial = {}) => createReducer$2(initial, (builder) =>
         // It updates the state by setting a new `QueryClientRequest` object for the key specified by `action.meta.transaction`.
         // The new `QueryClientRequest` object is created by merging `action.payload` and `action.meta`, and initializing
         // `execution` as an empty array, `errors` as an empty array, and `status` as 'idle'.
-        state[action.meta.transaction] = K({
+        state[action.meta.transaction] = castDraft({
             ...action.payload,
             ...action.meta,
             execution: [],
@@ -30818,7 +31726,7 @@ const resolveDefaultLogLevel = () => {
 const defaultLogLevel = resolveDefaultLogLevel();
 
 // Generated by genversion.
-const version = '1.1.5';
+const version = '1.1.7';
 
 /**
  * Defines an abstract base class for a logger implementation that provides common logging functionality.
@@ -31411,7 +32319,7 @@ function createReducer (actions, initial = {}) {
     return createReducer$2(initial, (builder) => builder
         .addCase(actions.set, (state, action) => {
         const { key, record } = action.payload;
-        state[key] = K(record);
+        state[key] = castDraft(record);
     })
         // Handles the 'set' action to update or add a cache record.
         .addCase(actions.insert, (state, action) => {
@@ -31422,7 +32330,7 @@ function createReducer (actions, initial = {}) {
             record.updated = Date.now();
             record.updates ??= 0;
             record.updates++;
-            record.value = K(entry.value);
+            record.value = castDraft(entry.value);
             record.transaction = entry.transaction;
             // reset the mutated timestamp
             record.mutated = undefined;
@@ -31430,7 +32338,7 @@ function createReducer (actions, initial = {}) {
         else {
             // If the record does not exist, create a new one with the current timestamp.
             const created = Date.now();
-            state[key] = K({
+            state[key] = castDraft({
                 ...entry,
                 created,
                 updated: created, // Set `updated` to the creation time.
@@ -31458,7 +32366,7 @@ function createReducer (actions, initial = {}) {
         const record = state[key];
         if (record) {
             // Update the record with the new value and metadata.
-            record.value = K(value);
+            record.value = castDraft(value);
             record.updated = updated;
             record.mutated = Date.now();
             record.updates ??= 0;
@@ -31702,7 +32610,7 @@ class QueryTask extends Subject {
                 complete: result.completed,
                 value: result.value,
             };
-        }), finalize(() => {
+        }), finalize$1(() => {
             logger?.debug(`QueryTask complete`, {
                 uuid: this.uuid,
                 key: this.key,
@@ -32303,15 +33211,15 @@ class Query {
 /**
  * Represents a service from the service discovery API.
  */
-const ApiService = z$1
+const ApiService = z
     .object({
-    key: z$1.string().describe('The key used to identify the service'),
-    uri: z$1.string().describe('The URI of the service'),
-    id: z$1.string().optional().describe('The ID of the service'),
-    environment: z$1.string().optional().describe('The environment of the service'),
-    name: z$1.string().optional().describe('The name of the service'),
-    scopes: z$1.array(z$1.string()).optional().default([]).describe('Endpoint authentication scopes'),
-    tags: z$1.array(z$1.string()).optional().describe('Tags for the service'),
+    key: z.string().describe('The key used to identify the service'),
+    uri: z.string().describe('The URI of the service'),
+    id: z.string().optional().describe('The ID of the service'),
+    environment: z.string().optional().describe('The environment of the service'),
+    name: z.string().optional().describe('The name of the service'),
+    scopes: z.array(z.string()).optional().default([]).describe('Endpoint authentication scopes'),
+    tags: z.array(z.string()).optional().describe('Tags for the service'),
 })
     .describe('A service from the service discovery API')
     .transform((value) => ({
@@ -32331,7 +33239,7 @@ const ApiService = z$1
  * @constant
  * @description A list of services from the service discovery API.
  */
-const ApiServices = z$1
+const ApiServices = z
     .array(ApiService)
     .describe('A list of services from the service discovery API');