claude-flow-novice 1.5.16 → 1.5.17

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/core/immerClass.js

@@ -0,0 +1,172 @@
+import { isDraftable, processResult, DRAFT_STATE, isDraft, isMap, isSet, createProxyProxy, getPlugin, die, hasProxies, enterScope, revokeScope, leaveScope, usePatchesInScope, getCurrentScope, NOTHING, freeze, current } from "../internal";
+export class Immer {
+    useProxies_ = hasProxies;
+    autoFreeze_ = true;
+    constructor(config){
+        if (typeof config?.useProxies === "boolean") this.setUseProxies(config.useProxies);
+        if (typeof config?.autoFreeze === "boolean") this.setAutoFreeze(config.autoFreeze);
+    }
+    /**
+	 * 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
+	 */ produce = (base, recipe, patchListener)=>{
+        // curried invocation
+        if (typeof base === "function" && typeof recipe !== "function") {
+            const defaultBase = recipe;
+            recipe = base;
+            const self = this;
+            return function curriedProduce(base = defaultBase, ...args) {
+                return self.produce(base, (draft)=>recipe.call(this, draft, ...args)) // prettier-ignore
+                ;
+            };
+        }
+        if (typeof recipe !== "function") die(6);
+        if (patchListener !== undefined && typeof patchListener !== "function") die(7);
+        let result;
+        // Only plain objects, arrays, and "immerable classes" are drafted.
+        if (isDraftable(base)) {
+            const scope = enterScope(this);
+            const proxy = createProxy(this, base, undefined);
+            let hasError = true;
+            try {
+                result = recipe(proxy);
+                hasError = false;
+            } finally{
+                // finally instead of catch + rethrow better preserves original stack
+                if (hasError) revokeScope(scope);
+                else leaveScope(scope);
+            }
+            if (typeof Promise !== "undefined" && result instanceof Promise) {
+                return result.then((result)=>{
+                    usePatchesInScope(scope, patchListener);
+                    return processResult(result, scope);
+                }, (error)=>{
+                    revokeScope(scope);
+                    throw error;
+                });
+            }
+            usePatchesInScope(scope, patchListener);
+            return processResult(result, scope);
+        } else if (!base || typeof base !== "object") {
+            result = recipe(base);
+            if (result === undefined) result = base;
+            if (result === NOTHING) result = undefined;
+            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(21, base);
+    };
+    produceWithPatches = (base, recipe)=>{
+        // curried invocation
+        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;
+        });
+        if (typeof Promise !== "undefined" && result instanceof Promise) {
+            return result.then((nextState)=>[
+                    nextState,
+                    patches,
+                    inversePatches
+                ]);
+        }
+        return [
+            result,
+            patches,
+            inversePatches
+        ];
+    };
+    createDraft(base) {
+        if (!isDraftable(base)) die(8);
+        if (isDraft(base)) base = current(base);
+        const scope = enterScope(this);
+        const proxy = createProxy(this, base, undefined);
+        proxy[DRAFT_STATE].isManual_ = true;
+        leaveScope(scope);
+        return proxy;
+    }
+    finishDraft(draft, patchListener) {
+        const state = draft && draft[DRAFT_STATE];
+        if (__DEV__) {
+            if (!state || !state.isManual_) die(9);
+            if (state.finalized_) die(10);
+        }
+        const { scope_: scope } = state;
+        usePatchesInScope(scope, patchListener);
+        return processResult(undefined, 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 use the ES2015 `Proxy` class when creating drafts, which is
+	 * always faster than using ES5 proxies.
+	 *
+	 * By default, feature detection is used, so calling this is rarely necessary.
+	 */ setUseProxies(value) {
+        if (value && !hasProxies) {
+            die(20);
+        }
+        this.useProxies_ = value;
+    }
+    applyPatches(base, patches) {
+        // If a patch replaces the entire state, take that replacement as base
+        // before applying 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 there was a patch that replaced the entire state, start from the
+        // patch after that.
+        if (i > -1) {
+            patches = patches.slice(i + 1);
+        }
+        const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+        if (isDraft(base)) {
+            // N.B: never hits if some patch a replacement, patches are never drafts
+            return applyPatchesImpl(base, patches);
+        }
+        // Otherwise, produce a copy of the base state.
+        return this.produce(base, (draft)=>applyPatchesImpl(draft, patches));
+    }
+}
+export function createProxy(immer, value, parent) {
+    // precondition: createProxy should be guarded by isDraftable, so we know we can safely draft
+    const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : immer.useProxies_ ? createProxyProxy(value, parent) : getPlugin("ES5").createES5Proxy_(value, parent);
+    const scope = parent ? parent.scope_ : getCurrentScope();
+    scope.drafts_.push(draft);
+    return draft;
+}
+
+//# sourceMappingURL=immerClass.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/core/immerClass.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../src/web/frontend/node_modules/immer/src/core/immerClass.ts"],"names":["isDraftable","processResult","DRAFT_STATE","isDraft","isMap","isSet","createProxyProxy","getPlugin","die","hasProxies","enterScope","revokeScope","leaveScope","usePatchesInScope","getCurrentScope","NOTHING","freeze","current","Immer","useProxies_","autoFreeze_","config","useProxies","setUseProxies","autoFreeze","setAutoFreeze","produce","base","recipe","patchListener","defaultBase","self","curriedProduce","args","draft","call","undefined","result","scope","proxy","createProxy","hasError","Promise","then","error","p","ip","generateReplacementPatches_","produceWithPatches","state","patches","inversePatches","nextState","createDraft","isManual_","finishDraft","__DEV__","finalized_","scope_","value","applyPatches","i","length","patch","path","op","slice","applyPatchesImpl","applyPatches_","immer","parent","proxyMap_","proxySet_","createES5Proxy_","drafts_","push"],"mappings":"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"}

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/core/proxy.js

@@ -0,0 +1,200 @@
+import { each, has, is, isDraftable, shallowCopy, latest, getCurrentScope, DRAFT_STATE, die, createProxy, ProxyType } from "../internal";
+/**
+ * Returns a new draft of the `base` object.
+ *
+ * The second argument is the parent draft-state (used internally).
+ */ export function createProxyProxy(base, parent) {
+    const isArray = Array.isArray(base);
+    const state = {
+        type_: isArray ? ProxyType.ProxyArray : ProxyType.ProxyObject,
+        // 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,
+        // The base copy with any updated values.
+        copy_: null,
+        // Called by the `produce` function.
+        revoke_: null,
+        isManual_: false
+    };
+    // the traps must target something, a bit like the 'real' base.
+    // but also, we need to be able to determine from the target what the relevant state is
+    // (to avoid creating traps per instance to capture the state in closure,
+    // and to avoid creating weird hidden properties as well)
+    // So the trick is to use 'state' as the actual 'target'! (and make sure we intercept everything)
+    // Note that in the case of an array, we put the state in an array to have better Reflect defaults ootb
+    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;
+}
+/**
+ * Object drafts
+ */ export const objectTraps = {
+    get (state, prop) {
+        if (prop === DRAFT_STATE) return state;
+        const source = latest(state);
+        if (!has(source, prop)) {
+            // non-existing or non-own property...
+            return readPropFromProto(state, source, prop);
+        }
+        const value = source[prop];
+        if (state.finalized_ || !isDraftable(value)) {
+            return value;
+        }
+        // Check for existing draft in modified state.
+        // Assigned values are never drafted. This catches any drafts we created, too.
+        if (value === peek(state.base_, prop)) {
+            prepareCopy(state);
+            return state.copy_[prop] = createProxy(state.scope_.immer_, value, state);
+        }
+        return value;
+    },
+    has (state, prop) {
+        return prop in latest(state);
+    },
+    ownKeys (state) {
+        return Reflect.ownKeys(latest(state));
+    },
+    set (state, prop/* strictly not, but helps TS */ , value) {
+        const desc = getDescriptorFromProto(latest(state), prop);
+        if (desc?.set) {
+            // special case: if this write is captured by a setter, we have
+            // to trigger it with the correct context
+            desc.set.call(state.draft_, value);
+            return true;
+        }
+        if (!state.modified_) {
+            // the last check is because we need to be able to distinguish setting a non-existing to undefined (which is a change)
+            // from setting an existing property with value undefined to undefined (which is not a change)
+            const current = peek(latest(state), prop);
+            // special case, if we assigning the original value to a draft, we can ignore the assignment
+            const currentState = current?.[DRAFT_STATE];
+            if (currentState && currentState.base_ === value) {
+                state.copy_[prop] = value;
+                state.assigned_[prop] = false;
+                return true;
+            }
+            if (is(value, current) && (value !== undefined || has(state.base_, prop))) return true;
+            prepareCopy(state);
+            markChanged(state);
+        }
+        if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
+        (value !== undefined || prop in state.copy_) || // special case: NaN
+        Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true;
+        // @ts-ignore
+        state.copy_[prop] = value;
+        state.assigned_[prop] = true;
+        return true;
+    },
+    deleteProperty (state, prop) {
+        // The `undefined` check is a fast path for pre-existing keys.
+        if (peek(state.base_, prop) !== undefined || prop in state.base_) {
+            state.assigned_[prop] = false;
+            prepareCopy(state);
+            markChanged(state);
+        } else {
+            // if an originally not assigned property was deleted
+            delete state.assigned_[prop];
+        }
+        // @ts-ignore
+        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_ !== ProxyType.ProxyArray || prop !== "length",
+            enumerable: desc.enumerable,
+            value: owner[prop]
+        };
+    },
+    defineProperty () {
+        die(11);
+    },
+    getPrototypeOf (state) {
+        return Object.getPrototypeOf(state.base_);
+    },
+    setPrototypeOf () {
+        die(12);
+    }
+};
+/**
+ * Array drafts
+ */ const arrayTraps = {};
+each(objectTraps, (key, fn)=>{
+    // @ts-ignore
+    arrayTraps[key] = function() {
+        arguments[0] = arguments[0][0];
+        return fn.apply(this, arguments);
+    };
+});
+arrayTraps.deleteProperty = function(state, prop) {
+    if (__DEV__ && isNaN(parseInt(prop))) die(13);
+    // @ts-ignore
+    return arrayTraps.set.call(this, state, prop, undefined);
+};
+arrayTraps.set = function(state, prop, value) {
+    if (__DEV__ && prop !== "length" && isNaN(parseInt(prop))) die(14);
+    return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+// Access a property without creating an Immer draft.
+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 : // prototype, we should invoke it with the draft as context!
+    desc.get?.call(state.draft_) : undefined;
+}
+function getDescriptorFromProto(source, prop) {
+    // 'in' checks proto!
+    if (!(prop in source)) return undefined;
+    let proto = Object.getPrototypeOf(source);
+    while(proto){
+        const desc = Object.getOwnPropertyDescriptor(proto, prop);
+        if (desc) return desc;
+        proto = Object.getPrototypeOf(proto);
+    }
+    return undefined;
+}
+export function markChanged(state) {
+    if (!state.modified_) {
+        state.modified_ = true;
+        if (state.parent_) {
+            markChanged(state.parent_);
+        }
+    }
+}
+export function prepareCopy(state) {
+    if (!state.copy_) {
+        state.copy_ = shallowCopy(state.base_);
+    }
+}
+
+//# sourceMappingURL=proxy.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/core/proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../src/web/frontend/node_modules/immer/src/core/proxy.ts"],"names":["each","has","is","isDraftable","shallowCopy","latest","getCurrentScope","DRAFT_STATE","die","createProxy","ProxyType","createProxyProxy","base","parent","isArray","Array","state","type_","ProxyArray","ProxyObject","scope_","modified_","finalized_","assigned_","parent_","base_","draft_","copy_","revoke_","isManual_","target","traps","objectTraps","arrayTraps","revoke","proxy","Proxy","revocable","get","prop","source","readPropFromProto","value","peek","prepareCopy","immer_","ownKeys","Reflect","set","desc","getDescriptorFromProto","call","current","currentState","undefined","markChanged","Number","isNaN","deleteProperty","getOwnPropertyDescriptor","owner","writable","configurable","enumerable","defineProperty","getPrototypeOf","Object","setPrototypeOf","key","fn","arguments","apply","__DEV__","parseInt","draft","proto"],"mappings":"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"}

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/core/scope.js

@@ -0,0 +1,47 @@
+import { DRAFT_STATE, ProxyType, getPlugin } from "../internal";
+import { die } from "../utils/errors";
+let currentScope;
+export function getCurrentScope() {
+    if (__DEV__ && !currentScope) die(0);
+    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
+    };
+}
+export function usePatchesInScope(scope, patchListener) {
+    if (patchListener) {
+        getPlugin("Patches"); // assert we have the plugin
+        scope.patches_ = [];
+        scope.inversePatches_ = [];
+        scope.patchListener_ = patchListener;
+    }
+}
+export function revokeScope(scope) {
+    leaveScope(scope);
+    scope.drafts_.forEach(revokeDraft);
+    // @ts-ignore
+    scope.drafts_ = null;
+}
+export function leaveScope(scope) {
+    if (scope === currentScope) {
+        currentScope = scope.parent_;
+    }
+}
+export function enterScope(immer) {
+    return currentScope = createScope(currentScope, immer);
+}
+function revokeDraft(draft) {
+    const state = draft[DRAFT_STATE];
+    if (state.type_ === ProxyType.ProxyObject || state.type_ === ProxyType.ProxyArray) state.revoke_();
+    else state.revoked_ = true;
+}
+
+//# sourceMappingURL=scope.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/core/scope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../src/web/frontend/node_modules/immer/src/core/scope.ts"],"names":["DRAFT_STATE","ProxyType","getPlugin","die","currentScope","getCurrentScope","__DEV__","createScope","parent_","immer_","drafts_","canAutoFreeze_","unfinalizedDrafts_","usePatchesInScope","scope","patchListener","patches_","inversePatches_","patchListener_","revokeScope","leaveScope","forEach","revokeDraft","enterScope","immer","draft","state","type_","ProxyObject","ProxyArray","revoke_","revoked_"],"mappings":"AAAA,SAKCA,WAAW,EAEXC,SAAS,EACTC,SAAS,QACH,cAAa;AACpB,SAAQC,GAAG,QAAO,kBAAiB;AAenC,IAAIC;AAEJ,OAAO,SAASC;IACf,IAAIC,WAAW,CAACF,cAAcD,IAAI;IAClC,OAAOC;AACR;AAEA,SAASG,YACRC,OAA+B,EAC/BC,MAAa;IAEb,OAAO;QACNC,SAAS,EAAE;QACXF;QACAC;QACA,sEAAsE;QACtE,uEAAuE;QACvEE,gBAAgB;QAChBC,oBAAoB;IACrB;AACD;AAEA,OAAO,SAASC,kBACfC,KAAiB,EACjBC,aAA6B;IAE7B,IAAIA,eAAe;QAClBb,UAAU,YAAW,4BAA4B;QACjDY,MAAME,QAAQ,GAAG,EAAE;QACnBF,MAAMG,eAAe,GAAG,EAAE;QAC1BH,MAAMI,cAAc,GAAGH;IACxB;AACD;AAEA,OAAO,SAASI,YAAYL,KAAiB;IAC5CM,WAAWN;IACXA,MAAMJ,OAAO,CAACW,OAAO,CAACC;IACtB,aAAa;IACbR,MAAMJ,OAAO,GAAG;AACjB;AAEA,OAAO,SAASU,WAAWN,KAAiB;IAC3C,IAAIA,UAAUV,cAAc;QAC3BA,eAAeU,MAAMN,OAAO;IAC7B;AACD;AAEA,OAAO,SAASe,WAAWC,KAAY;IACtC,OAAQpB,eAAeG,YAAYH,cAAcoB;AAClD;AAEA,SAASF,YAAYG,KAAc;IAClC,MAAMC,QAAoBD,KAAK,CAACzB,YAAY;IAC5C,IACC0B,MAAMC,KAAK,KAAK1B,UAAU2B,WAAW,IACrCF,MAAMC,KAAK,KAAK1B,UAAU4B,UAAU,EAEpCH,MAAMI,OAAO;SACTJ,MAAMK,QAAQ,GAAG;AACvB"}

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/immer.js

@@ -0,0 +1,77 @@
+import { Immer } from "./internal";
+export { Draft, Immutable, Patch, PatchListener, original, current, isDraft, isDraftable, NOTHING as nothing, DRAFTABLE as immerable, freeze } from "./internal";
+const immer = new Immer();
+/**
+ * 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} producer - 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
+ */ export const produce = immer.produce;
+export default produce;
+/**
+ * Like `produce`, but `produceWithPatches` always returns a tuple
+ * [nextState, patches, inversePatches] (instead of just the next state)
+ */ export const produceWithPatches = immer.produceWithPatches.bind(immer);
+/**
+ * Pass true to automatically freeze all copies created by Immer.
+ *
+ * Always freeze by default, even in production mode
+ */ export const setAutoFreeze = immer.setAutoFreeze.bind(immer);
+/**
+ * Pass true to use the ES2015 `Proxy` class when creating drafts, which is
+ * always faster than using ES5 proxies.
+ *
+ * By default, feature detection is used, so calling this is rarely necessary.
+ */ export const setUseProxies = immer.setUseProxies.bind(immer);
+/**
+ * Apply an array of Immer patches to the first argument.
+ *
+ * This function is a producer, which means copy-on-write is in effect.
+ */ export const applyPatches = immer.applyPatches.bind(immer);
+/**
+ * Create an Immer draft from the given base state, which may be a draft itself.
+ * The draft can be modified until you finalize it with the `finishDraft` function.
+ */ export const createDraft = immer.createDraft.bind(immer);
+/**
+ * Finalize an Immer draft from a `createDraft` call, returning the base state
+ * (if no changes were made) or a modified copy. The draft must *not* be
+ * mutated afterwards.
+ *
+ * Pass a function as the 2nd argument to generate Immer patches based on the
+ * changes that were made.
+ */ export const finishDraft = immer.finishDraft.bind(immer);
+/**
+ * This function is actually a no-op, but can be used to cast an immutable type
+ * to an draft type and make TypeScript happy
+ *
+ * @param value
+ */ export function castDraft(value) {
+    return value;
+}
+/**
+ * This function is actually a no-op, but can be used to cast a mutable type
+ * to an immutable type and make TypeScript happy
+ * @param value
+ */ export function castImmutable(value) {
+    return value;
+}
+export { Immer };
+export { enableES5 } from "./plugins/es5";
+export { enablePatches } from "./plugins/patches";
+export { enableMapSet } from "./plugins/mapset";
+export { enableAllPlugins } from "./plugins/all";
+
+//# sourceMappingURL=immer.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/immer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/web/frontend/node_modules/immer/src/immer.ts"],"names":["Immer","Draft","Immutable","Patch","PatchListener","original","current","isDraft","isDraftable","NOTHING","nothing","DRAFTABLE","immerable","freeze","immer","produce","produceWithPatches","bind","setAutoFreeze","setUseProxies","applyPatches","createDraft","finishDraft","castDraft","value","castImmutable","enableES5","enablePatches","enableMapSet","enableAllPlugins"],"mappings":"AAAA,SAGCA,KAAK,QAGC,aAAY;AAEnB,SACCC,KAAK,EACLC,SAAS,EACTC,KAAK,EACLC,aAAa,EACbC,QAAQ,EACRC,OAAO,EACPC,OAAO,EACPC,WAAW,EACXC,WAAWC,OAAO,EAClBC,aAAaC,SAAS,EACtBC,MAAM,QACA,aAAY;AAEnB,MAAMC,QAAQ,IAAId;AAElB;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,MAAMe,UAAoBD,MAAMC,OAAO,CAAA;AAC9C,eAAeA,QAAO;AAEtB;;;CAGC,GACD,OAAO,MAAMC,qBAA0CF,MAAME,kBAAkB,CAACC,IAAI,CACnFH,OACA;AAED;;;;CAIC,GACD,OAAO,MAAMI,gBAAgBJ,MAAMI,aAAa,CAACD,IAAI,CAACH,OAAM;AAE5D;;;;;CAKC,GACD,OAAO,MAAMK,gBAAgBL,MAAMK,aAAa,CAACF,IAAI,CAACH,OAAM;AAE5D;;;;CAIC,GACD,OAAO,MAAMM,eAAeN,MAAMM,YAAY,CAACH,IAAI,CAACH,OAAM;AAE1D;;;CAGC,GACD,OAAO,MAAMO,cAAcP,MAAMO,WAAW,CAACJ,IAAI,CAACH,OAAM;AAExD;;;;;;;CAOC,GACD,OAAO,MAAMQ,cAAcR,MAAMQ,WAAW,CAACL,IAAI,CAACH,OAAM;AAExD;;;;;CAKC,GACD,OAAO,SAASS,UAAaC,KAAQ;IACpC,OAAOA;AACR;AAEA;;;;CAIC,GACD,OAAO,SAASC,cAAiBD,KAAQ;IACxC,OAAOA;AACR;AAEA,SAAQxB,KAAK,GAAC;AAEd,SAAQ0B,SAAS,QAAO,gBAAe;AACvC,SAAQC,aAAa,QAAO,oBAAmB;AAC/C,SAAQC,YAAY,QAAO,mBAAkB;AAC7C,SAAQC,gBAAgB,QAAO,gBAAe"}

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/internal.js

@@ -0,0 +1,13 @@
+export * from "./utils/env";
+export * from "./utils/errors";
+export * from "./types/types-external";
+export * from "./types/types-internal";
+export * from "./utils/common";
+export * from "./utils/plugins";
+export * from "./core/scope";
+export * from "./core/finalize";
+export * from "./core/proxy";
+export * from "./core/immerClass";
+export * from "./core/current";
+
+//# sourceMappingURL=internal.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../src/web/frontend/node_modules/immer/src/internal.ts"],"names":[],"mappings":"AAAA,cAAc,cAAa;AAC3B,cAAc,iBAAgB;AAC9B,cAAc,yBAAwB;AACtC,cAAc,yBAAwB;AACtC,cAAc,iBAAgB;AAC9B,cAAc,kBAAiB;AAC/B,cAAc,eAAc;AAC5B,cAAc,kBAAiB;AAC/B,cAAc,eAAc;AAC5B,cAAc,oBAAmB;AACjC,cAAc,iBAAgB"}

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/plugins/all.js

@@ -0,0 +1,10 @@
+import { enableES5 } from "./es5";
+import { enableMapSet } from "./mapset";
+import { enablePatches } from "./patches";
+export function enableAllPlugins() {
+    enableES5();
+    enableMapSet();
+    enablePatches();
+}
+
+//# sourceMappingURL=all.js.map

package/.claude-flow-novice/dist/src/web/frontend/node_modules/immer/src/plugins/all.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../src/web/frontend/node_modules/immer/src/plugins/all.ts"],"names":["enableES5","enableMapSet","enablePatches","enableAllPlugins"],"mappings":"AAAA,SAAQA,SAAS,QAAO,QAAO;AAC/B,SAAQC,YAAY,QAAO,WAAU;AACrC,SAAQC,aAAa,QAAO,YAAW;AAEvC,OAAO,SAASC;IACfH;IACAC;IACAC;AACD"}