@mulanjs/mulanjs 1.0.1-dev.20260220121828 → 1.0.1-dev.20260220131258

package/dist/mulan.js

@@ -1,11 +1,3 @@
-/*
- * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
- * This devtool is neither made for production nor for readable output files.
- * It uses "eval()" calls to create a separate source file in the browser devtools.
- * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
- * or disable the default devtool with "devtool: false".
- * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
- */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
 		module.exports = factory();
@@ -18,218 +10,2071 @@
 })(this, () => {
 return /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
-/******/ 	var __webpack_modules__ = ({
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ src)
+});
+
+// UNUSED EXPORTS: Component, MuBlochSphereElement, MuComponent, MuInfinity, MuRouter, MuStore, Router, Security, Signal, activeControls, defineComponent, effect, getCurrentInstance, hydrate, muBurst, muControl, muEffect, muEntangle, muGate, muGeom, muMeasure, muMemo, muParallel, muPulse, muQubit, muRegister, muSearch, muState, muSurge, muSwitch, muTeleport, muVault, onMuDestroy, onMuIdle, onMuInit, onMuMount, onMuResume, onMuShake, onMuVoice, persistent, reactive, ref, render, renderToString, sanitize, setCurrentInstance, useMutation, useQuery
+
+// NAMESPACE OBJECT: ./src/core/hooks.ts
+var hooks_namespaceObject = {};
+__webpack_require__.r(hooks_namespaceObject);
+__webpack_require__.d(hooks_namespaceObject, {
+  getCurrentInstance: () => (getCurrentInstance),
+  muEffect: () => (muEffect),
+  muGeom: () => (muGeom),
+  muMemo: () => (muMemo),
+  muPulse: () => (muPulse),
+  muState: () => (muState),
+  muVault: () => (muVault),
+  onMuDestroy: () => (onMuDestroy),
+  onMuIdle: () => (onMuIdle),
+  onMuInit: () => (onMuInit),
+  onMuMount: () => (onMuMount),
+  onMuResume: () => (onMuResume),
+  onMuShake: () => (onMuShake),
+  onMuVoice: () => (onMuVoice),
+  setCurrentInstance: () => (setCurrentInstance)
+});
+
+// NAMESPACE OBJECT: ./src/core/query.ts
+var query_namespaceObject = {};
+__webpack_require__.r(query_namespaceObject);
+__webpack_require__.d(query_namespaceObject, {
+  useMutation: () => (useMutation),
+  useQuery: () => (useQuery)
+});
+
+// NAMESPACE OBJECT: ./src/core/quantum.ts
+var quantum_namespaceObject = {};
+__webpack_require__.r(quantum_namespaceObject);
+__webpack_require__.d(quantum_namespaceObject, {
+  activeControls: () => (activeControls),
+  muControl: () => (muControl),
+  muEntangle: () => (muEntangle),
+  muGate: () => (muGate),
+  muMeasure: () => (muMeasure),
+  muParallel: () => (muParallel),
+  muQubit: () => (muQubit),
+  muRegister: () => (muRegister),
+  muSearch: () => (muSearch),
+  muSwitch: () => (muSwitch),
+  muTeleport: () => (muTeleport)
+});
+
+// NAMESPACE OBJECT: ./src/components/infinity-list.ts
+var infinity_list_namespaceObject = {};
+__webpack_require__.r(infinity_list_namespaceObject);
+__webpack_require__.d(infinity_list_namespaceObject, {
+  MuInfinity: () => (MuInfinity)
+});
+
+// NAMESPACE OBJECT: ./src/core/surge.ts
+var surge_namespaceObject = {};
+__webpack_require__.r(surge_namespaceObject);
+__webpack_require__.d(surge_namespaceObject, {
+  muBurst: () => (muBurst),
+  muSurge: () => (muSurge)
+});
+
+;// ./src/core/reactive.ts
+// MulanJS 2.0: Signal-Powered Reactivity Engine
+// "Compatible Surface, World-Class Engine"
+let activeEffect = null;
+const targetMap = new WeakMap();
+// --- Signal Core (The Engine) ---
+class Signal {
+    constructor(initialValue) {
+        this._subscribers = new Set();
+        this._value = initialValue;
+    }
+    get value() {
+        if (activeEffect) {
+            this._subscribers.add(activeEffect);
+        }
+        return this._value;
+    }
+    set value(newValue) {
+        if (newValue !== this._value) {
+            this._value = newValue;
+            this.notify();
+        }
+    }
+    notify() {
+        this._subscribers.forEach(fn => fn());
+    }
+}
+// --- Compatibility Layer (The Surface) ---
+function effect(fn) {
+    let stopped = false;
+    const run = () => {
+        if (stopped)
+            return;
+        const prev = activeEffect;
+        activeEffect = run;
+        try {
+            fn();
+        }
+        finally {
+            activeEffect = prev;
+        }
+    };
+    run();
+    return () => {
+        stopped = true;
+    };
+}
+function track(target, key) {
+    if (activeEffect) {
+        let depsMap = targetMap.get(target);
+        if (!depsMap) {
+            targetMap.set(target, (depsMap = new Map()));
+        }
+        let dep = depsMap.get(key);
+        if (!dep) {
+            depsMap.set(key, (dep = new Set()));
+        }
+        dep.add(activeEffect);
+    }
+}
+function trigger(target, key) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap)
+        return;
+    const dep = depsMap.get(key);
+    if (dep) {
+        dep.forEach((fn) => fn());
+    }
+}
+/**
+ * Creates a reactive proxy object (Vue-compatible).
+ * Now optimized to respect Mulan Cycle.
+ */
+function reactive(target) {
+    return new Proxy(target, {
+        get(obj, prop, receiver) {
+            // IRON FORTRESS: Prototype Pollution Protection (Read)
+            if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {
+                return undefined;
+            }
+            track(obj, prop);
+            const val = Reflect.get(obj, prop, receiver);
+            if (val !== null && typeof val === 'object') {
+                return reactive(val);
+            }
+            return val;
+        },
+        set(obj, prop, value, receiver) {
+            // IRON FORTRESS: Prototype Pollution Protection
+            if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {
+                console.warn(`[Iron Fortress] Blocked attempt to modify dangerous property: ${String(prop)}`);
+                return false;
+            }
+            const result = Reflect.set(obj, prop, value, receiver);
+            trigger(obj, prop);
+            return result;
+        },
+    });
+}
+/**
+ * Creates a standalone reactive reference.
+ * Backed by the Mulan Signal Engine.
+ */
+function ref(value) {
+    return new Signal(value);
+}
+
+;// ./src/core/renderer.ts
+function render(template, container) {
+    // Focus Preservation (The "Mulan Glance" Technique)
+    let focusedId = null;
+    let selectionStart = null;
+    let selectionEnd = null;
+    let preservedValue = null;
+    if (document.activeElement && container.contains(document.activeElement)) {
+        const el = document.activeElement;
+        if (el.hasAttribute('data-mu-id')) {
+            focusedId = el.getAttribute('data-mu-id');
+            if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+                selectionStart = el.selectionStart;
+                selectionEnd = el.selectionEnd;
+                preservedValue = el.value;
+            }
+        }
+    }
+    // [Anima] 1. Pre-Update: Snapshot positions of animated elements
+    const animationSnapshots = new Map();
+    // Only query if we might have animations to save perf
+    if (template.includes('mu-animate')) {
+        const animatedEls = container.querySelectorAll('[mu-animate]');
+        animatedEls.forEach(el => {
+            const key = el.getAttribute('mu-key') || el.id;
+            if (key) {
+                animationSnapshots.set(key, el.getBoundingClientRect());
+            }
+        });
+    }
+    container.innerHTML = template;
+    // Restore Focus and Value
+    if (focusedId) {
+        const el = container.querySelector(`[data-mu-id="${focusedId}"]`);
+        if (el) {
+            // Restore value first to ensure cursor positioning works correctly
+            if (preservedValue !== null && (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {
+                el.value = preservedValue;
+            }
+            el.focus();
+            if ((el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) && selectionStart !== null) {
+                try {
+                    el.setSelectionRange(selectionStart, selectionEnd);
+                }
+                catch (e) {
+                    // input types that don't support selection (e.g. number/email) might throw
+                }
+            }
+        }
+    }
+    // [Anima] 2. Post-Update: FLIP (First, Last, Invert, Play)
+    if (animationSnapshots.size > 0) {
+        const newAnimatedEls = container.querySelectorAll('[mu-animate]');
+        newAnimatedEls.forEach(el => {
+            const key = el.getAttribute('mu-key') || el.id;
+            if (key && animationSnapshots.has(key)) {
+                const oldRect = animationSnapshots.get(key);
+                const newRect = el.getBoundingClientRect();
+                const dx = oldRect.left - newRect.left;
+                const dy = oldRect.top - newRect.top;
+                // Only animate if moved
+                if (dx !== 0 || dy !== 0) {
+                    const htmlEl = el;
+                    // INVERT: Move it back to where it was instantly
+                    htmlEl.style.transform = `translate(${dx}px, ${dy}px)`;
+                    htmlEl.style.transition = 'none';
+                    // PLAY: Animate to zero (new position)
+                    requestAnimationFrame(() => {
+                        // Force reflow
+                        // void htmlEl.offsetWidth; 
+                        htmlEl.style.transition = 'transform 500ms cubic-bezier(0.25, 0.8, 0.25, 1)';
+                        htmlEl.style.transform = '';
+                    });
+                }
+            }
+        });
+    }
+}
+function hydrate(template, container) {
+    // In a string-based framework, hydration is often just "take over".
+    // For now, we'll verify if the server content matches (simple check)
+    // and then assume control. In a more advanced version, we'd attach listeners without re-rendering.
+    if (container.innerHTML.trim() !== template.trim()) {
+        console.warn('Hydration Mismatch: Server rendered content differs from Client.');
+        container.innerHTML = template; // Fallback to full render
+    }
+    else {
+        // console.log('Hydration Successful.');
+    }
+    // Future: Attach event listeners here if we had a mechanism for it.
+}
+function renderToString(template) {
+    // SSR Function: returns the HTML string for the server to send.
+    // Can include additional sanitization or metadata injection here.
+    return template;
+}
+function sanitize(str) {
+    // Check if we are in a browser environment
+    if (typeof document !== 'undefined') {
+        const temp = document.createElement('div');
+        temp.textContent = str;
+        return temp.innerHTML;
+    }
+    // Simple SSR fallback sanitizer (rudimentary)
+    return str.replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+}
+
+;// ./src/core/vault.ts
+
+
+/**
+ * Mulan Vault: The World's First Native Persistent State Primitive.
+ */
+function persistent(key, initialValue, options = {}) {
+    const storage = options.storage || window.localStorage;
+    // 1. Load from Storage
+    const stored = storage.getItem(key);
+    let startVal = initialValue;
+    if (stored) {
+        try {
+            startVal = JSON.parse(stored);
+        }
+        catch (e) {
+            console.warn(`[Mulan Vault] Corrupt persistent data for key "${key}", resetting.`);
+        }
+    }
+    // 2. Create Reactive State (Follow muState pattern for consistency)
+    const isObject = typeof startVal === 'object' && startVal !== null;
+    const state = isObject ? reactive(startVal) : reactive({ value: startVal });
+    // 3. Auto-Save on Change
+    muEffect(() => {
+        try {
+            const payload = isObject ? state : state.value;
+            const toSave = JSON.stringify(payload);
+            // Non-obfuscated persistence to satisfy security audits
+            storage.setItem(key, toSave);
+        }
+        catch (e) {
+            console.error(`[Mulan Vault] Failed to save key "${key}"`);
+        }
+    });
+    // 4. Sync across Tabs
+    const sync = (e) => {
+        if (e.key === key && e.newValue) {
+            try {
+                const newVal = JSON.parse(e.newValue);
+                if (isObject) {
+                    Object.assign(state, newVal);
+                }
+                else {
+                    state.value = newVal;
+                }
+            }
+            catch (e) { }
+        }
+    };
+    window.addEventListener('storage', sync);
+    // Explicit cleanup if provided by the environment (e.g. Mulan Hooks)
+    if (options.onCleanup) {
+        options.onCleanup(() => {
+            window.removeEventListener('storage', sync);
+        });
+    }
+    return state;
+}
+
+;// ./src/core/hooks.ts
+
+
+// Global context to track the current component instance
+let currentInstance = null;
+function setCurrentInstance(instance) {
+    currentInstance = instance;
+}
+function getCurrentInstance() {
+    return currentInstance;
+}
+// --- Mulan Unique Reactivity Hooks ---
+function muState(initialValue) {
+    if (typeof initialValue === 'object' && initialValue !== null) {
+        return reactive(initialValue);
+    }
+    // Core reactive state container for primitives
+    return reactive({ value: initialValue });
+}
+function muMemo(computeFn) {
+    const signal = reactive({ value: undefined });
+    const stop = effect(() => {
+        signal.value = computeFn();
+    });
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._effects)
+            instance._effects = [];
+        instance._effects.push(stop);
+    }
+    return signal;
+}
+function muEffect(fn) {
+    const stop = effect(fn);
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._effects)
+            instance._effects = [];
+        instance._effects.push(stop);
+    }
+}
+// --- The "Mulan Cycle" (Lifecycle) ---
+function onMuInit(fn) {
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._hooks)
+            instance._hooks = {};
+        if (!instance._hooks.onMuInit)
+            instance._hooks.onMuInit = [];
+        instance._hooks.onMuInit.push(fn);
+    }
+    else {
+        console.warn('onMuInit called outside of component setup context.');
+    }
+}
+function onMuMount(fn) {
+    // New hook for when component is actually in DOM (simulated for now via update)
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._hooks)
+            instance._hooks = {};
+        if (!instance._hooks.onMuMount)
+            instance._hooks.onMuMount = [];
+        instance._hooks.onMuMount.push(fn);
+    }
+}
+function onMuDestroy(fn) {
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._hooks)
+            instance._hooks = {};
+        if (!instance._hooks.onMuDestroy)
+            instance._hooks.onMuDestroy = [];
+        instance._hooks.onMuDestroy.push(fn);
+    }
+}
+/**
+ * onMuIdle - The "Environment Life" Hook.
+ * Executes heavy logic ONLY when the browser is taking a nap (idle).
+ */
+function onMuIdle(fn) {
+    const instance = getCurrentInstance();
+    // Polyfill for Safari/Old Browsers
+    const requestIdleCallback = window.requestIdleCallback || function (cb) {
+        return setTimeout(() => {
+            cb({
+                didTimeout: false,
+                timeRemaining: function () { return 50; }
+            });
+        }, 1);
+    };
+    const cancelIdleCallback = window.cancelIdleCallback || function (id) {
+        clearTimeout(id);
+    };
+    const idleId = requestIdleCallback(() => {
+        fn();
+    });
+    // Auto-cleanup if component dies before idle time
+    if (instance) {
+        onMuDestroy(() => {
+            cancelIdleCallback(idleId);
+        });
+    }
+}
+/**
+ * onMuResume - The "Tab Life" Hook.
+ * Executes when the user switches BACK to this tab.
+ * Perfect for refreshing data or resuming animations to save battery.
+ */
+function onMuResume(fn) {
+    const handler = () => {
+        if (document.visibilityState === 'visible') {
+            fn();
+        }
+    };
+    document.addEventListener('visibilitychange', handler);
+    onMuDestroy(() => document.removeEventListener('visibilitychange', handler));
+}
+/**
+ * onMuShake - The "Physical Life" Hook.
+ * Executes when the device is shaken.
+ * Usage: Undo, Refresh, or "Rage Quit" easter eggs.
+ */
+function onMuShake(fn) {
+    // Threshold for shake detection
+    const threshold = 15;
+    let lastX = 0, lastY = 0, lastZ = 0;
+    let lastTime = 0;
+    const handler = (e) => {
+        const current = e.accelerationIncludingGravity;
+        if (!current)
+            return;
+        const time = Date.now();
+        if ((time - lastTime) > 100) {
+            const diffTime = time - lastTime;
+            lastTime = time;
+            const x = current.x || 0;
+            const y = current.y || 0;
+            const z = current.z || 0;
+            const speed = Math.abs(x + y + z - lastX - lastY - lastZ) / diffTime * 10000;
+            if (speed > threshold) {
+                fn();
+            }
+            lastX = x;
+            lastY = y;
+            lastZ = z;
+        }
+    };
+    if (window.DeviceMotionEvent) {
+        window.addEventListener('devicemotion', handler);
+        onMuDestroy(() => window.removeEventListener('devicemotion', handler));
+    }
+    else {
+        console.warn("[MulanJS] Device Motion not supported on this device.");
+    }
+}
+/**
+ * onMuVoice - The "Sound Life" Hook.
+ * Executes when a specific word is spoken.
+ * @param command The word to listen for (e.g., "save", "next")
+ * @param fn The action to take
+ */
+function onMuVoice(command, fn) {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (!SpeechRecognition) {
+        console.warn("[MulanJS] Voice Control (Web Speech API) not supported in this browser.");
+        return;
+    }
+    const recognition = new SpeechRecognition();
+    recognition.continuous = true;
+    recognition.lang = 'en-US';
+    recognition.interimResults = false;
+    recognition.onresult = (event) => {
+        const last = event.results.length - 1;
+        const spoken = event.results[last][0].transcript.trim().toLowerCase();
+        console.log(`[Mulan Voice] Heard: "${spoken}"`);
+        if (spoken.includes(command.toLowerCase())) {
+            fn();
+        }
+    };
+    recognition.start();
+    // Auto-restart if it stops (Continuous listening)
+    recognition.onend = () => {
+        // Simple check to see if we should still be listening
+        // In a real app we might want more control
+        // recognition.start(); 
+    };
+    onMuDestroy(() => {
+        recognition.stop();
+    });
+}
+// --- "Outside The Box" Hooks (Mulan Exclusives) ---
+/**
+ * muGeom - Tracks window or element dimensions reactively.
+ */
+function muGeom() {
+    const dims = muState({ width: window.innerWidth, height: window.innerHeight });
+    const handler = () => {
+        dims.width = window.innerWidth;
+        dims.height = window.innerHeight;
+    };
+    window.addEventListener('resize', handler);
+    // Auto-cleanup
+    onMuDestroy(() => {
+        window.removeEventListener('resize', handler);
+    });
+    return dims;
+}
+/**
+ * muPulse - Reactive network status.
+ */
+function muPulse() {
+    const status = muState({ online: navigator.onLine });
+    const setOnline = () => status.online = true;
+    const setOffline = () => status.online = false;
+    window.addEventListener('online', setOnline);
+    window.addEventListener('offline', setOffline);
+    onMuDestroy(() => {
+        window.removeEventListener('online', setOnline);
+        window.removeEventListener('offline', setOffline);
+    });
+    return status;
+}
+/**
+ * muVault - Secure reactive LocalStorage wrapper.
+ * Powered by the Iron Fortress persistent primitive.
+ */
+function muVault(key, initial, options = {}) {
+    return persistent(key, initial, Object.assign(Object.assign({}, options), { onCleanup: (fn) => onMuDestroy(fn) }));
+}
 
-/***/ "./src/components/bloch-sphere.ts"
-/*!****************************************!*\
-  !*** ./src/components/bloch-sphere.ts ***!
-  \****************************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+;// ./src/core/component.ts
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   MuBlochSphereElement: () => (/* binding */ MuBlochSphereElement)\n/* harmony export */ });\n/* harmony import */ var _core_reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/reactive */ \"./src/core/reactive.ts\");\n\nclass MuBlochSphereElement extends HTMLElement {\n    static get observedAttributes() {\n        return ['size'];\n    }\n    constructor() {\n        super();\n        this._arrow = null;\n        this._container = null;\n        this._disposeEffect = null;\n        this.attachShadow({ mode: 'open' });\n    }\n    connectedCallback() {\n        this.render();\n    }\n    disconnectedCallback() {\n        if (this._disposeEffect) {\n            this._disposeEffect();\n            this._disposeEffect = null;\n        }\n    }\n    // Property setter for 'qubit' (passed as .qubit=\"${q}\" in Mulan)\n    set qubit(val) {\n        this._qubit = val;\n        this.initReactivity();\n    }\n    get qubit() {\n        return this._qubit;\n    }\n    attributeChangedCallback(name, oldValue, newValue) {\n        if (name === 'size' && this._container) {\n            this._container.style.width = newValue + 'px';\n            this._container.style.height = newValue + 'px';\n        }\n    }\n    initReactivity() {\n        if (this._disposeEffect)\n            this._disposeEffect();\n        if (!this._qubit)\n            return;\n        // MulanJS Effect: Run whenever the qubit state changes\n        this._disposeEffect = (0,_core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {\n            const state = this._qubit.value; // Access reactive proxy\n            if (!state || !state.amplitudes)\n                return;\n            // Assume Single Qubit for Visualizer (Index 0 if passed a register)\n            // If passed a register, we visualize the first qubit's logical projection (partial trace simplified)\n            // Or assume input IS a specific qubit projection?\n            // For simplified demo, we assume the register is size 1 OR we visualize Q0 of the register.\n            const amps = state.amplitudes;\n            // Support 1-qubit visualization from N-qubit register requires partial trace.\n            // For now, let's assume the user passes a 1-qubit register OR we visualize index 0.\n            // |psi> = a|0> + b|1>\n            // a = amps[0] (re, im)\n            // b = amps[1] (re, im)\n            // Dealing with multi-qubit registers (naive projection for visualization):\n            // We sum up probabilities for 0xxxx vs 1xxxx to get Z-axis.\n            // This is \"marginal probability\".\n            let p0 = 0;\n            let p1 = 0;\n            // Calculate Probabilities\n            for (let i = 0; i < amps.length; i++) {\n                const mag = amps[i].re * amps[i].re + amps[i].im * amps[i].im;\n                if ((i & 1) === 0)\n                    p0 += mag;\n                else\n                    p1 += mag;\n            }\n            // Theta from Z-projection\n            // P0 = cos^2(theta/2) -> theta = 2 * acos(sqrt(P0))\n            const theta = 2 * Math.acos(Math.min(1, Math.sqrt(p0)));\n            // Phi?\n            // Phase is relative phase between |0> and |1>.\n            // We can look at the phase of the '1' component relative to '0'.\n            // Simple approach: Look at amps[1] phase vs amps[0] phase.\n            // But with entanglement, pure state phase is tricky.\n            // Let's implement full density matrix if needed, but for now:\n            // naive: atan2(amps[1].im, amps[1].re) - atan2(amps[0].im, amps[0].re)\n            // We use the first pair (0 and 1) as proxy if multiple.\n            const a0 = amps[0];\n            const a1 = amps[1]; // Valid for N>=1\n            const phase0 = Math.atan2(a0.im, a0.re);\n            const phase1 = Math.atan2(a1.im, a1.re);\n            let phi = phase1 - phase0;\n            // Update Arrow\n            this.updateArrow(theta, phi);\n        });\n    }\n    updateArrow(theta, phi) {\n        if (!this._arrow)\n            return;\n        // Convert Quantum Coords (Theta, Phi) to CSS Transforms\n        // Theta 0 = Top (|0>)\n        // Theta PI = Bottom (|1>)\n        // Theta PI/2 = Equator\n        // CSS Rotate sequence:\n        // 1. Start pointing UP (Y or Z axis in CSS?)\n        // Let's say Arrow starts pointing UP (Y-).\n        // Rotate Z by Phi (Azimuth)\n        // Rotate X by Theta (Polar) - No, that's not standard Euler.\n        // Standard Physics:\n        // Z is Up (in Bloch), but CSS 3D Y is usually 'Down' or 'Up'.\n        // Let's Map:\n        // Bloch Z+ (|0>) -> CSS Y- (Top)\n        // Bloch Z- (|1>) -> CSS Y+ (Bottom)\n        // Bloch X+ (|+>) -> CSS Z+ (Front)\n        // Transform:\n        // rotateY(phi) ? No, phi rotates around Z-axis (Vertical).\n        // theta rotates from Z-axis down.\n        // CSS:\n        // rotateY(phi) -> Rotates around Vertical axis.\n        // rotateZ(theta) -> Rotates \"down\" from up?\n        // Let's simplify:\n        // transform: rotateY(${phi}rad) rotateZ(${theta}rad)\n        // Note: CSS rotations order matters.\n        const degTheta = theta * (180 / Math.PI);\n        const degPhi = phi * (180 / Math.PI);\n        // Adjustment for visual alignment\n        this._arrow.style.transform = `rotateY(${degPhi}deg) rotateZ(${degTheta}deg)`;\n        // Color based on state\n        const isSuperposition = Math.abs(theta - Math.PI / 2) < 0.1;\n        this._arrow.style.backgroundColor = isSuperposition ? '#00ffff' : '#ff00ff';\n    }\n    render() {\n        if (!this.shadowRoot)\n            return;\n        const size = this.getAttribute('size') || '200';\n        this.shadowRoot.innerHTML = `\r\n            <style>\r\n                :host {\r\n                    display: inline-block;\r\n                    perspective: 1000px;\r\n                }\r\n                .sphere-container {\r\n                    width: ${size}px;\r\n                    height: ${size}px;\r\n                    position: relative;\r\n                    transform-style: preserve-3d;\r\n                    margin: 0 auto;\r\n                }\r\n                .sphere {\r\n                    width: 100%;\r\n                    height: 100%;\r\n                    border-radius: 50%;\r\n                    border: 1px solid rgba(255, 255, 255, 0.2);\r\n                    position: absolute;\r\n                    background: radial-gradient(circle at 30% 30%, rgba(255, 255, 255, 0.1), rgba(0, 0, 0, 0.8));\r\n                    box-shadow: inset 0 0 20px rgba(255, 255, 255, 0.05);\r\n                    transform: rotateX(15deg) rotateY(15deg); /* Initial tilt for view */\r\n                }\r\n                /* Equator Ring */\r\n                .equator {\r\n                    position: absolute;\r\n                    top: 50%;\r\n                    left: 0;\r\n                    width: 100%;\r\n                    height: 100%;\r\n                    border: 1px dashed rgba(255, 255, 255, 0.3);\r\n                    border-radius: 50%;\r\n                    transform: rotateX(90deg);\r\n                    pointer-events: none;\r\n                }\r\n                /* Axis Lines */\r\n                .axis {\r\n                    position: absolute;\r\n                    background: rgba(255, 255, 255, 0.1);\r\n                }\r\n                .z-axis { width: 2px; height: 100%; left: 50%; top: 0; }\r\n                \r\n                /* The Quantum Arrow */\r\n                .arrow-container {\r\n                    position: absolute;\r\n                    top: 50%;\r\n                    left: 50%;\r\n                    width: 0;\r\n                    height: 0;\r\n                    transform-style: preserve-3d;\r\n                    transform: rotateX(15deg) rotateY(15deg); /* Match sphere tilt */\r\n                }\r\n                \r\n                .arrow-pivot {\r\n                    position: absolute;\r\n                    top: 0;\r\n                    left: 0;\r\n                    width: 4px;\r\n                    height: 50%; /* Length of radius */\r\n                    /* Pivot logic: we want to rotate around the center point */\r\n                    /* CSS Default transform-origin is 50% 50% */\r\n                    /* We construct the arrow such that it points UP from center */\r\n                }\r\n                \r\n                .arrow-rod {\r\n                    width: 4px;\r\n                    height: ${parseInt(size) / 2 - 10}px;\r\n                    background: #ff00ff;\r\n                    position: absolute;\r\n                    bottom: 0;\r\n                    left: -2px;\r\n                    transform-origin: bottom center;\r\n                    transition: transform 0.5s cubic-bezier(0.175, 0.885, 0.32, 1.275), background-color 0.3s;\r\n                    border-radius: 2px;\r\n                    box-shadow: 0 0 10px currentColor;\r\n                }\r\n                \r\n                .arrow-head {\r\n                    width: 0; \r\n                    height: 0; \r\n                    border-left: 6px solid transparent;\r\n                    border-right: 6px solid transparent;\r\n                    border-bottom: 12px solid #ff00ff;\r\n                    position: absolute;\r\n                    top: -10px;\r\n                    left: -6px;\r\n                }\r\n                \r\n                .label {\r\n                    position: absolute;\r\n                    color: #aaa;\r\n                    font-family: monospace;\r\n                    font-size: 10px;\r\n                }\r\n                .label-0 { top: 5px; left: 50%; transform: translateX(-50%); }\r\n                .label-1 { bottom: 5px; left: 50%; transform: translateX(-50%); }\r\n            </style>\r\n            \r\n            <div class=\"sphere-container\">\r\n                <div class=\"sphere\">\r\n                    <div class=\"equator\"></div>\r\n                    <div class=\"axis z-axis\"></div>\r\n                    <div class=\"label label-0\">|0></div>\r\n                    <div class=\"label label-1\">|1></div>\r\n                </div>\r\n                \r\n                <div class=\"arrow-container\">\r\n                    <!-- The rod is the actual rotating element -->\r\n                    <div class=\"arrow-rod\">\r\n                        <div class=\"arrow-head\"></div>\r\n                    </div>\r\n                </div>\r\n            </div>\r\n        `;\n        this._container = this.shadowRoot.querySelector('.sphere-container');\n        this._arrow = this.shadowRoot.querySelector('.arrow-rod');\n        // Re-init reactivity if qubit was set before render\n        if (this._qubit)\n            this.initReactivity();\n    }\n}\n// Register the custom element\nif (typeof customElements !== 'undefined') {\n    customElements.define('mu-bloch-sphere', MuBlochSphereElement);\n}\n\n\n//# sourceURL=webpack://Mulan/./src/components/bloch-sphere.ts?\n}");
 
-/***/ },
 
-/***/ "./src/components/infinity-list.ts"
-/*!*****************************************!*\
-  !*** ./src/components/infinity-list.ts ***!
-  \*****************************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+// Or a simple component that returns an object of state/methods used by template? 
+// For Mulan 2.0, let's say functional component returns a template string render function explicitly.
+class MuComponent {
+    constructor(container) {
+        this._hooks = {};
+        this._effects = [];
+        this._isDestroyed = false;
+        this._propsQueue = [];
+        this._eventQueue = [];
+        this.container = container;
+        this.state = {};
+        this.$uid = 'mu_' + Math.random().toString(36).substr(2, 9);
+        // MULAN INSIGHT: Global Registry for Debugging
+        if (typeof window !== 'undefined') {
+            const global = window;
+            global.__MULAN_INSIGHT__ = global.__MULAN_INSIGHT__ || { components: new Map() };
+            global.__MULAN_INSIGHT__.components.set(this.$uid, this);
+        }
+        // Setup context for hooks
+        setCurrentInstance(this);
+        this.setup();
+        setCurrentInstance(null);
+    }
+    // Optional setup method for class components wanting to use hooks
+    setup() { }
+    onMount() {
+        var _a, _c;
+        // Mulan Cycle: Init
+        (_a = this._hooks.onMuInit) === null || _a === void 0 ? void 0 : _a.forEach(fn => fn());
+        // Mulan Cycle: Mount (Simulated immediately after init for now in this version)
+        (_c = this._hooks.onMuMount) === null || _c === void 0 ? void 0 : _c.forEach(fn => fn());
+    }
+    onUpdate() { }
+    onDestroy() {
+        var _a, _c;
+        if (this._isDestroyed)
+            return;
+        this._isDestroyed = true;
+        console.log(`[Mulan Cycle] Destroying component ${this.$uid} (${this.constructor.name})`);
+        // MULAN INSIGHT: Cleanup
+        if (typeof window !== 'undefined') {
+            const global = window;
+            (_a = global.__MULAN_INSIGHT__) === null || _a === void 0 ? void 0 : _a.components.delete(this.$uid);
+        }
+        // Mulan Cycle: Stop all effects to prevent leaks
+        console.log(`[Mulan Cycle] Stopping ${this._effects.length} effects for ${this.$uid}`);
+        this._effects.forEach(stop => stop());
+        this._effects = [];
+        // Mulan Cycle: Destroy hooks
+        (_c = this._hooks.onMuDestroy) === null || _c === void 0 ? void 0 : _c.forEach(fn => fn());
+    }
+    // Helper for compiler to register property bindings
+    _b(id, prop, value) {
+        this._propsQueue.push([id, prop, value]);
+        return "";
+    }
+    // Helper for compiler to register event bindings
+    _e(id, type, handler) {
+        this._eventQueue.push([id, type, handler]);
+        return "";
+    }
+    mount() {
+        console.log(`[Mulan Cycle] Mounting component ${this.$uid}`);
+        const stop = effect(() => {
+            console.log(`[Mulan Reactivity] Triggering update for ${this.$uid}`);
+            this.update();
+        });
+        this._effects.push(stop);
+        this.onMount();
+    }
+    update() {
+        if (this._isDestroyed) {
+            console.warn(`[Mulan Warning] Update called on destroyed component ${this.$uid}. Blocking render.`);
+            return;
+        }
+        // Clear queues before render
+        this._propsQueue = [];
+        this._eventQueue = [];
+        const template = this.template();
+        // Render HTML
+        render(template, this.container);
+        // Flush Side Effects
+        this.flushProps();
+        this.flushEvents();
+        this.onUpdate();
+    }
+    flushProps() {
+        for (const [id, prop, value] of this._propsQueue) {
+            const el = this.container.querySelector(`[data-mu-id="${id}"]`);
+            if (el) {
+                // @ts-ignore
+                el[prop] = value;
+            }
+        }
+        this._propsQueue = [];
+    }
+    flushEvents() {
+        for (const [id, type, handler] of this._eventQueue) {
+            const el = this.container.querySelector(`[data-mu-id="${id}"]`);
+            if (el) {
+                // Bind handler to this component instance to ensure 'this' works in methods
+                el.addEventListener(type, handler.bind(this));
+            }
+        }
+        this._eventQueue = [];
+    }
+}
+// Helper to create functional components wrapped in the class system
+// Helper to create functional components wrapped in the class system
+// Supports both () => render and { setup() } signatures
+function defineComponent(optionsOrSetup) {
+    return class UniversalComponent extends MuComponent {
+        constructor(container) {
+            super(container);
+            // setup() is called by super constructor
+        }
+        setup() {
+            let setupResult;
+            if (typeof optionsOrSetup === 'function') {
+                // It's a setup function returning render fn
+                setupResult = optionsOrSetup.call(this);
+            }
+            else if (typeof optionsOrSetup === 'object' && optionsOrSetup.setup) {
+                // It's an options object with setup()
+                setupResult = optionsOrSetup.setup.call(this);
+            }
+            // Handle result
+            if (typeof setupResult === 'function') {
+                // It's a render function
+                this.template = setupResult;
+            }
+            else if (setupResult && typeof setupResult === 'object') {
+                // It's bindings
+                Object.assign(this, setupResult);
+                // We assume template is assigned to prototype by compiler
+            }
+        }
+        template() {
+            return '';
+        }
+    };
+}
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   MuInfinity: () => (/* binding */ MuInfinity)\n/* harmony export */ });\nclass MuInfinity extends HTMLElement {\n    constructor() {\n        super();\n        this._items = [];\n        this._itemHeight = 50; // Default height\n        this._template = '';\n        this.attachShadow({ mode: 'open' });\n        // Structure:\n        // :host { overflow-y: auto; display: block; height: 100%; }\n        //   .spacer { height: totalHeight; position: relative; }\n        //     .content { position: absolute; top: padding; width: 100%; }\n        this.shadowRoot.innerHTML = `\r\n            <style>\r\n                :host {\r\n                    display: block;\r\n                    overflow-y: auto;\r\n                    height: 100%;\r\n                    position: relative;\r\n                }\r\n                .spacer {\r\n                    position: relative;\r\n                    width: 100%;\r\n                }\r\n                .content {\r\n                    position: absolute;\r\n                    top: 0;\r\n                    left: 0;\r\n                    width: 100%;\r\n                }\r\n            </style>\r\n            <div class=\"spacer\">\r\n                <div class=\"content\"></div>\r\n            </div>\r\n        `;\n        this.container = this.shadowRoot.host; // The host itself scrolls\n        this.spacer = this.shadowRoot.querySelector('.spacer');\n        this.content = this.shadowRoot.querySelector('.content');\n        this.onScroll = this.onScroll.bind(this);\n    }\n    static get observedAttributes() {\n        return ['item-height'];\n    }\n    attributeChangedCallback(name, oldValue, newValue) {\n        if (name === 'item-height') {\n            this._itemHeight = parseInt(newValue, 10) || 50;\n            this.renderVisible();\n        }\n    }\n    connectedCallback() {\n        // Find the template provided by the user (Support both standard and branded tags)\n        const templateTag = this.querySelector('template') || this.querySelector('mu-template');\n        if (templateTag) {\n            this._template = templateTag.innerHTML;\n        }\n        this.addEventListener('scroll', this.onScroll);\n        // Wait for next frame to get initial height if not set\n        requestAnimationFrame(() => this.renderVisible());\n    }\n    disconnectedCallback() {\n        this.removeEventListener('scroll', this.onScroll);\n    }\n    set items(value) {\n        this._items = value;\n        this.renderVisible();\n    }\n    get items() { return this._items; }\n    onScroll() {\n        requestAnimationFrame(() => this.renderVisible());\n    }\n    renderVisible() {\n        if (!this._items.length)\n            return;\n        const scrollTop = this.scrollTop;\n        const hostHeight = this.clientHeight || 400; // Default fallback if not sized\n        const totalHeight = this._items.length * this._itemHeight;\n        this.spacer.style.height = `${totalHeight}px`;\n        // Windowing Math\n        const startIndex = Math.floor(scrollTop / this._itemHeight);\n        const buffer = 5;\n        const visibleCount = Math.ceil(hostHeight / this._itemHeight);\n        const renderStart = Math.max(0, startIndex - buffer);\n        const renderEnd = Math.min(this._items.length, startIndex + visibleCount + buffer);\n        const startOffset = renderStart * this._itemHeight;\n        this.content.style.transform = `translateY(${startOffset}px)`;\n        // Render specific slice\n        const visibleItems = this._items.slice(renderStart, renderEnd);\n        // Simple string replacement template engine for the demo\n        // In a real Mulan compilation, this would be an optimized ASTR render\n        let html = '';\n        visibleItems.forEach((item, index) => {\n            const absoluteIndex = renderStart + index;\n            // Basic mustache replacement {{ item.prop }}\n            let rowHtml = this._template\n                .replace(/{{\\s*item\\s*}}/g, String(item)) // {{ item }}\n                .replace(/{{\\s*index\\s*}}/g, String(absoluteIndex)); // {{ index }}\n            // Handle object properties: {{ item.name }}\n            if (typeof item === 'object' && item !== null) {\n                rowHtml = rowHtml.replace(/{{\\s*item\\.(\\w+)\\s*}}/g, (_, prop) => {\n                    return String(item[prop] || '');\n                });\n            }\n            html += `<div style=\"height: ${this._itemHeight}px; overflow: hidden;\">${rowHtml}</div>`;\n        });\n        this.content.innerHTML = html;\n    }\n}\n// Register\nif (typeof customElements !== 'undefined' && !customElements.get('mu-infinity')) {\n    customElements.define('mu-infinity', MuInfinity);\n}\n\n\n//# sourceURL=webpack://Mulan/./src/components/infinity-list.ts?\n}");
+;// ./src/security/sanitizer.ts
+class Security {
+    /**
+     * IRON FORTRESS PROTOCOL
+     * Strictly escapes all HTML entities to prevent XSS.
+     * Use `mu-raw` attribute in templates to bypass this for trusted content.
+     */
+    static sanitize(input) {
+        // 1. Basic entity encoding
+        let secure = input
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#039;");
+        // 2. Remove dangerous events (extra layer if encoding fails)
+        const dangerousEvents = ['onload', 'onclick', 'onerror', 'onmouseover', 'onfocus'];
+        dangerousEvents.forEach(event => {
+            const regex = new RegExp(event, 'gi');
+            secure = secure.replace(regex, 'data-blocked-' + event);
+        });
+        return secure;
+    }
+    /**
+     * Generates a strict Content Security Policy header value.
+     * @param options Configuration for allowed sources
+     */
+    static generateCSP(options = {}) {
+        const scriptSrc = ["'self'", ...(options.scriptSrc || [])].join(" ");
+        const styleSrc = ["'self'", "'unsafe-inline'", ...(options.styleSrc || [])].join(" ");
+        return `default-src 'self'; script-src ${scriptSrc}; style-src ${styleSrc}; object-src 'none'; base-uri 'self';`;
+    }
+    static validateUrl(url) {
+        // Basic URL validation
+        const pattern = new RegExp('^(https?:\\/\\/)?' + // protocol
+            '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
+            '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+            '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+            '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+            '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
+        return !!pattern.test(url);
+    }
+    /**
+     * Prevents XSS by sanitizing common input fields on blur.
+     * Can be used as a utility in forms.
+     */
+    static preventXSS(inputElement) {
+        inputElement.addEventListener('blur', (e) => {
+            const target = e.target;
+            target.value = Security.sanitize(target.value);
+        });
+    }
+}
 
-/***/ },
+;// ./src/router/index.ts
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 
-/***/ "./src/core/component.ts"
-/*!*******************************!*\
-  !*** ./src/core/component.ts ***!
-  \*******************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   MuComponent: () => (/* binding */ MuComponent),\n/* harmony export */   defineComponent: () => (/* binding */ defineComponent)\n/* harmony export */ });\n/* harmony import */ var _renderer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./renderer */ \"./src/core/renderer.ts\");\n/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./hooks */ \"./src/core/hooks.ts\");\n/* harmony import */ var _reactive__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./reactive */ \"./src/core/reactive.ts\");\n\n\n\n// Or a simple component that returns an object of state/methods used by template? \n// For Mulan 2.0, let's say functional component returns a template string render function explicitly.\nclass MuComponent {\n    constructor(container) {\n        this._hooks = {};\n        this._effects = [];\n        this._isDestroyed = false;\n        this._propsQueue = [];\n        this._eventQueue = [];\n        this.container = container;\n        this.state = {};\n        this.$uid = 'mu_' + Math.random().toString(36).substr(2, 9);\n        // MULAN INSIGHT: Global Registry for Debugging\n        if (typeof window !== 'undefined') {\n            const global = window;\n            global.__MULAN_INSIGHT__ = global.__MULAN_INSIGHT__ || { components: new Map() };\n            global.__MULAN_INSIGHT__.components.set(this.$uid, this);\n        }\n        // Setup context for hooks\n        (0,_hooks__WEBPACK_IMPORTED_MODULE_1__.setCurrentInstance)(this);\n        this.setup();\n        (0,_hooks__WEBPACK_IMPORTED_MODULE_1__.setCurrentInstance)(null);\n    }\n    // Optional setup method for class components wanting to use hooks\n    setup() { }\n    onMount() {\n        var _a, _c;\n        // Mulan Cycle: Init\n        (_a = this._hooks.onMuInit) === null || _a === void 0 ? void 0 : _a.forEach(fn => fn());\n        // Mulan Cycle: Mount (Simulated immediately after init for now in this version)\n        (_c = this._hooks.onMuMount) === null || _c === void 0 ? void 0 : _c.forEach(fn => fn());\n    }\n    onUpdate() { }\n    onDestroy() {\n        var _a, _c;\n        if (this._isDestroyed)\n            return;\n        this._isDestroyed = true;\n        console.log(`[Mulan Cycle] Destroying component ${this.$uid} (${this.constructor.name})`);\n        // MULAN INSIGHT: Cleanup\n        if (typeof window !== 'undefined') {\n            const global = window;\n            (_a = global.__MULAN_INSIGHT__) === null || _a === void 0 ? void 0 : _a.components.delete(this.$uid);\n        }\n        // Mulan Cycle: Stop all effects to prevent leaks\n        console.log(`[Mulan Cycle] Stopping ${this._effects.length} effects for ${this.$uid}`);\n        this._effects.forEach(stop => stop());\n        this._effects = [];\n        // Mulan Cycle: Destroy hooks\n        (_c = this._hooks.onMuDestroy) === null || _c === void 0 ? void 0 : _c.forEach(fn => fn());\n    }\n    // Helper for compiler to register property bindings\n    _b(id, prop, value) {\n        this._propsQueue.push([id, prop, value]);\n        return \"\";\n    }\n    // Helper for compiler to register event bindings\n    _e(id, type, handler) {\n        this._eventQueue.push([id, type, handler]);\n        return \"\";\n    }\n    mount() {\n        console.log(`[Mulan Cycle] Mounting component ${this.$uid}`);\n        const stop = (0,_reactive__WEBPACK_IMPORTED_MODULE_2__.effect)(() => {\n            console.log(`[Mulan Reactivity] Triggering update for ${this.$uid}`);\n            this.update();\n        });\n        this._effects.push(stop);\n        this.onMount();\n    }\n    update() {\n        if (this._isDestroyed) {\n            console.warn(`[Mulan Warning] Update called on destroyed component ${this.$uid}. Blocking render.`);\n            return;\n        }\n        // Clear queues before render\n        this._propsQueue = [];\n        this._eventQueue = [];\n        const template = this.template();\n        // Render HTML\n        (0,_renderer__WEBPACK_IMPORTED_MODULE_0__.render)(template, this.container);\n        // Flush Side Effects\n        this.flushProps();\n        this.flushEvents();\n        this.onUpdate();\n    }\n    flushProps() {\n        for (const [id, prop, value] of this._propsQueue) {\n            const el = this.container.querySelector(`[data-mu-id=\"${id}\"]`);\n            if (el) {\n                // @ts-ignore\n                el[prop] = value;\n            }\n        }\n        this._propsQueue = [];\n    }\n    flushEvents() {\n        for (const [id, type, handler] of this._eventQueue) {\n            const el = this.container.querySelector(`[data-mu-id=\"${id}\"]`);\n            if (el) {\n                // Bind handler to this component instance to ensure 'this' works in methods\n                el.addEventListener(type, handler.bind(this));\n            }\n        }\n        this._eventQueue = [];\n    }\n}\n// Helper to create functional components wrapped in the class system\n// Helper to create functional components wrapped in the class system\n// Supports both () => render and { setup() } signatures\nfunction defineComponent(optionsOrSetup) {\n    return class UniversalComponent extends MuComponent {\n        constructor(container) {\n            super(container);\n            // setup() is called by super constructor\n        }\n        setup() {\n            let setupResult;\n            if (typeof optionsOrSetup === 'function') {\n                // It's a setup function returning render fn\n                setupResult = optionsOrSetup.call(this);\n            }\n            else if (typeof optionsOrSetup === 'object' && optionsOrSetup.setup) {\n                // It's an options object with setup()\n                setupResult = optionsOrSetup.setup.call(this);\n            }\n            // Handle result\n            if (typeof setupResult === 'function') {\n                // It's a render function\n                this.template = setupResult;\n            }\n            else if (setupResult && typeof setupResult === 'object') {\n                // It's bindings\n                Object.assign(this, setupResult);\n                // We assume template is assigned to prototype by compiler\n            }\n        }\n        template() {\n            return '';\n        }\n    };\n}\n\n\n//# sourceURL=webpack://Mulan/./src/core/component.ts?\n}");
+class MuRouter {
+    constructor(routes, rootContainer = null) {
+        this.currentPath = '';
+        this.currentComponent = null;
+        this.lastRouteId = 0;
+        this.routes = routes;
+        this.rootContainer = rootContainer;
+        this.isServer = rootContainer === null; // If no container, assume server/headless mode
+        if (!this.isServer) {
+            window.addEventListener('hashchange', this.handleRoute.bind(this));
+            this.handleRoute(); // Initial load
+        }
+    }
+    // SSR Method: Simulate a route visit on the server
+    serverLookup(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentPath = path;
+            const { route, params } = this.matchRoute(path);
+            if (route) {
+                // Run guards/resolvers here if needed
+                let componentToRender = route.component;
+                // Support Lazy Loading
+                if (typeof componentToRender === 'function' && !componentToRender.prototype) {
+                    const module = yield componentToRender();
+                    componentToRender = module.default || module;
+                }
+                if (typeof componentToRender === 'function') {
+                    // Class component SSR
+                    // We need a dummy container for the component to "render" into its own buffer
+                    // For simplicity in this string-based framework, we mock the container
+                    const mockContainer = { innerHTML: '' };
+                    const instance = new componentToRender(mockContainer);
+                    if (instance.setParams)
+                        instance.setParams(params);
+                    // Manually trigger mount logic without DOM effects if possible, or just template()
+                    // Ideally, we just want the template string.
+                    return instance.template();
+                }
+                else {
+                    return componentToRender;
+                }
+            }
+            return '<!-- 404 -->';
+        });
+    }
+    matchRoute(hash) {
+        // Simple exact match first
+        let route = this.routes.find((r) => r.path === hash);
+        if (route)
+            return { route, params: {} };
+        // Regex match for params e.g. /user/:id
+        for (const r of this.routes) {
+            const paramNames = [];
+            const regexPath = r.path.replace(/:([^/]+)/g, (_, key) => {
+                paramNames.push(key);
+                return '([^/]+)';
+            });
+            const match = new RegExp(`^${regexPath}$`).exec(hash);
+            if (match) {
+                const params = {};
+                paramNames.forEach((name, i) => {
+                    // SECURE: Automatically sanitize all route parameters
+                    params[name] = Security.sanitize(match[i + 1]);
+                });
+                return { route: r, params };
+            }
+        }
+        return { route: undefined, params: {} };
+    }
+    handleRoute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isServer)
+                return;
+            const currentRouteId = ++this.lastRouteId;
+            const hash = window.location.hash.slice(1) || '/';
+            const { route, params } = this.matchRoute(hash);
+            // Security Check: Validate URL to prevent malicious hash injection
+            if (hash !== '/' && !Security.validateUrl('http://dummy.com' + hash)) {
+                console.error("Security Alert: Malformed URL detected.");
+                return;
+            }
+            // Navigation Guard (Middleware)
+            if (route === null || route === void 0 ? void 0 : route.beforeEnter) {
+                yield new Promise((resolve) => {
+                    route.beforeEnter(hash, this.currentPath, (allow) => {
+                        if (allow)
+                            resolve();
+                        else {
+                            console.warn(`Navigation to ${hash} blocked by guard.`);
+                            // Ideally redirect or stay, here we just stop processing
+                            throw new Error('Navigation Blocked');
+                        }
+                    });
+                }).catch(() => { return; }); // Stop execution if blocked
+            }
+            this.currentPath = hash;
+            if (route) {
+                if (route.title) {
+                    document.title = route.title;
+                }
+                else if (route.meta && route.meta.title) {
+                    // Fallback to meta.title if used
+                    document.title = route.meta.title;
+                }
+                if (this.rootContainer) {
+                    // Mulan Cycle: Destroy previous component before rendering new one
+                    if (this.currentComponent) {
+                        console.log(`[Router] Navigation from ${this.currentPath} to ${hash}. Destroying previous component.`);
+                        if (this.currentComponent.onDestroy) {
+                            this.currentComponent.onDestroy();
+                        }
+                    }
+                    this.rootContainer.innerHTML = ''; // Clear previous content
+                }
+                let componentToRender = route.component;
+                // Support Lazy Loading
+                if (typeof componentToRender === 'function' && !componentToRender.prototype) {
+                    try {
+                        const module = yield componentToRender();
+                        if (currentRouteId !== this.lastRouteId) {
+                            console.log(`[Router] Navigation to ${hash} interrupted by newer navigation. Abandoning.`);
+                            return;
+                        }
+                        componentToRender = module.default || module;
+                    }
+                    catch (e) {
+                        console.error("Failed to lazy load component", e);
+                        return;
+                    }
+                }
+                if (typeof componentToRender === 'function') {
+                    // It's a class component
+                    if (this.rootContainer) {
+                        const instance = new componentToRender(this.rootContainer);
+                        this.currentComponent = instance;
+                        // Inject params if the component accepts them
+                        if (instance.setParams) {
+                            instance.setParams(params);
+                        }
+                        instance.mount();
+                    }
+                }
+                else if (typeof componentToRender === 'object' && componentToRender.template) {
+                    // Object Component (Simple SFC without script or Options API)
+                    const html = componentToRender.template();
+                    if (this.rootContainer)
+                        render(html, this.rootContainer);
+                    this.currentComponent = null;
+                }
+                else {
+                    // Simple HTML string/template
+                    if (this.rootContainer)
+                        render(componentToRender, this.rootContainer);
+                    this.currentComponent = null; // String templates don't have lifecycle instances
+                }
+            }
+            else {
+                if (this.rootContainer)
+                    render('<div style="text-align:center; padding:50px;"><h1>404</h1><p>Page Not Found</p></div>', this.rootContainer);
+            }
+        });
+    }
+    // [Chronos] Prefetch a route's component code in the background
+    prefetch(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isServer)
+                return;
+            const { route } = this.matchRoute(path);
+            if (route) {
+                let componentToRender = route.component;
+                // Check if it's a lazy-loaded function that hasn't been resolved yet
+                if (typeof componentToRender === 'function' && !componentToRender.prototype) {
+                    // If it's already a resolved module (from previous prefetch), componentToRender might be the result.
+                    // But typically in our simple implementation, route.component stays as the function until we replace it.
+                    // To avoid double-fetching, we can check if it has a specific flag or property. 
+                    // For this implementation, we'll just run it and let the browser cache the module request (standard ES Module behavior).
+                    try {
+                        // console.log(`[Chronos] Prefetching ${path}...`);
+                        yield componentToRender();
+                        // We don't need to do anything with the result here. 
+                        // The browser's module cache will handle the speedup when the user actually navigates.
+                    }
+                    catch (e) {
+                        console.warn(`[Chronos] Failed to prefetch ${path}`, e);
+                    }
+                }
+            }
+        });
+    }
+    navigate(path) {
+        if (this.isServer) {
+            this.currentPath = path;
+        }
+        else {
+            window.location.hash = path;
+        }
+    }
+}
+// --- Factory for Easy Usage ---
+const createRouter = (options) => {
+    // Expose the router instance globally for <mu-link> to access
+    const router = new MuRouter(options.routes, options.rootContainer);
+    if (typeof window !== 'undefined') {
+        window.__MULAN_ROUTER__ = router;
+    }
+    return router;
+};
+// --- Web Component: <mu-link> ---
+// Usage: <mu-link to="/about">About Us</mu-link>
+if (typeof window !== 'undefined' && !customElements.get('mu-link')) {
+    class MuLink extends HTMLElement {
+        constructor() {
+            super();
+            this.addEventListener('click', (e) => {
+                e.preventDefault();
+                const to = this.getAttribute('to');
+                if (to) {
+                    // Update Hash for SPA Navigation
+                    window.location.hash = to;
+                }
+            });
+            // [Chronos] Intelligent Pre-fetching
+            this.addEventListener('mouseenter', () => {
+                const to = this.getAttribute('to');
+                if (to) {
+                    const router = window.__MULAN_ROUTER__;
+                    if (router && typeof router.prefetch === 'function') {
+                        router.prefetch(to);
+                    }
+                }
+            });
+            // [Chronos] Also prefetch on focus for keyboard users
+            this.addEventListener('focus', () => {
+                const to = this.getAttribute('to');
+                if (to) {
+                    const router = window.__MULAN_ROUTER__;
+                    if (router && typeof router.prefetch === 'function') {
+                        router.prefetch(to);
+                    }
+                }
+            });
+        }
+        connectedCallback() {
+            this.style.cursor = 'pointer';
+            this.style.color = 'var(--primary, #9C27B0)'; // Default to brand color if available
+            this.style.textDecoration = 'none';
+        }
+        static get observedAttributes() { return ['to']; }
+    }
+    customElements.define('mu-link', MuLink);
+}
 
-/***/ },
+;// ./src/store/index.ts
 
-/***/ "./src/core/hooks.ts"
-/*!***************************!*\
-  !*** ./src/core/hooks.ts ***!
-  \***************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+class MuStore {
+    constructor(initialState, options) {
+        this.subscribers = [];
+        // Load from local storage if persist is true
+        let loadedState = initialState;
+        if (options === null || options === void 0 ? void 0 : options.persist) {
+            const key = options.key || 'mulan-store';
+            try {
+                const stored = localStorage.getItem(key);
+                if (stored) {
+                    loadedState = Object.assign(Object.assign({}, initialState), JSON.parse(stored));
+                }
+            }
+            catch (e) {
+                console.error("Failed to load state", e);
+            }
+            // Auto-save effect
+            effect(() => {
+                localStorage.setItem(key, JSON.stringify(this.state));
+            });
+        }
+        this.state = reactive(loadedState);
+    }
+    // Subscribe to changes
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        effect(() => {
+            fn(this.state);
+        });
+    }
+    // Action dispatcher pattern
+    dispatch(action) {
+        const result = action(this.state);
+        if (result instanceof Promise) {
+            result.then(() => {
+                // Optional: Notify subscribers of async completion if needed manually?
+                // But reactive() handles updates automatically.
+            });
+        }
+    }
+}
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   getCurrentInstance: () => (/* binding */ getCurrentInstance),\n/* harmony export */   muEffect: () => (/* binding */ muEffect),\n/* harmony export */   muGeom: () => (/* binding */ muGeom),\n/* harmony export */   muMemo: () => (/* binding */ muMemo),\n/* harmony export */   muPulse: () => (/* binding */ muPulse),\n/* harmony export */   muState: () => (/* binding */ muState),\n/* harmony export */   muVault: () => (/* binding */ muVault),\n/* harmony export */   onMuDestroy: () => (/* binding */ onMuDestroy),\n/* harmony export */   onMuIdle: () => (/* binding */ onMuIdle),\n/* harmony export */   onMuInit: () => (/* binding */ onMuInit),\n/* harmony export */   onMuMount: () => (/* binding */ onMuMount),\n/* harmony export */   onMuResume: () => (/* binding */ onMuResume),\n/* harmony export */   onMuShake: () => (/* binding */ onMuShake),\n/* harmony export */   onMuVoice: () => (/* binding */ onMuVoice),\n/* harmony export */   setCurrentInstance: () => (/* binding */ setCurrentInstance)\n/* harmony export */ });\n/* harmony import */ var _reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./reactive */ \"./src/core/reactive.ts\");\n/* harmony import */ var _vault__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./vault */ \"./src/core/vault.ts\");\n\n\n// Global context to track the current component instance\nlet currentInstance = null;\nfunction setCurrentInstance(instance) {\n    currentInstance = instance;\n}\nfunction getCurrentInstance() {\n    return currentInstance;\n}\n// --- Mulan Unique Reactivity Hooks ---\nfunction muState(initialValue) {\n    if (typeof initialValue === 'object' && initialValue !== null) {\n        return (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)(initialValue);\n    }\n    // Core reactive state container for primitives\n    return (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)({ value: initialValue });\n}\nfunction muMemo(computeFn) {\n    const signal = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)({ value: undefined });\n    const stop = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {\n        signal.value = computeFn();\n    });\n    const instance = getCurrentInstance();\n    if (instance) {\n        if (!instance._effects)\n            instance._effects = [];\n        instance._effects.push(stop);\n    }\n    return signal;\n}\nfunction muEffect(fn) {\n    const stop = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(fn);\n    const instance = getCurrentInstance();\n    if (instance) {\n        if (!instance._effects)\n            instance._effects = [];\n        instance._effects.push(stop);\n    }\n}\n// --- The \"Mulan Cycle\" (Lifecycle) ---\nfunction onMuInit(fn) {\n    const instance = getCurrentInstance();\n    if (instance) {\n        if (!instance._hooks)\n            instance._hooks = {};\n        if (!instance._hooks.onMuInit)\n            instance._hooks.onMuInit = [];\n        instance._hooks.onMuInit.push(fn);\n    }\n    else {\n        console.warn('onMuInit called outside of component setup context.');\n    }\n}\nfunction onMuMount(fn) {\n    // New hook for when component is actually in DOM (simulated for now via update)\n    const instance = getCurrentInstance();\n    if (instance) {\n        if (!instance._hooks)\n            instance._hooks = {};\n        if (!instance._hooks.onMuMount)\n            instance._hooks.onMuMount = [];\n        instance._hooks.onMuMount.push(fn);\n    }\n}\nfunction onMuDestroy(fn) {\n    const instance = getCurrentInstance();\n    if (instance) {\n        if (!instance._hooks)\n            instance._hooks = {};\n        if (!instance._hooks.onMuDestroy)\n            instance._hooks.onMuDestroy = [];\n        instance._hooks.onMuDestroy.push(fn);\n    }\n}\n/**\n * onMuIdle - The \"Environment Life\" Hook.\n * Executes heavy logic ONLY when the browser is taking a nap (idle).\n */\nfunction onMuIdle(fn) {\n    const instance = getCurrentInstance();\n    // Polyfill for Safari/Old Browsers\n    const requestIdleCallback = window.requestIdleCallback || function (cb) {\n        return setTimeout(() => {\n            cb({\n                didTimeout: false,\n                timeRemaining: function () { return 50; }\n            });\n        }, 1);\n    };\n    const cancelIdleCallback = window.cancelIdleCallback || function (id) {\n        clearTimeout(id);\n    };\n    const idleId = requestIdleCallback(() => {\n        fn();\n    });\n    // Auto-cleanup if component dies before idle time\n    if (instance) {\n        onMuDestroy(() => {\n            cancelIdleCallback(idleId);\n        });\n    }\n}\n/**\n * onMuResume - The \"Tab Life\" Hook.\n * Executes when the user switches BACK to this tab.\n * Perfect for refreshing data or resuming animations to save battery.\n */\nfunction onMuResume(fn) {\n    const handler = () => {\n        if (document.visibilityState === 'visible') {\n            fn();\n        }\n    };\n    document.addEventListener('visibilitychange', handler);\n    onMuDestroy(() => document.removeEventListener('visibilitychange', handler));\n}\n/**\n * onMuShake - The \"Physical Life\" Hook.\n * Executes when the device is shaken.\n * Usage: Undo, Refresh, or \"Rage Quit\" easter eggs.\n */\nfunction onMuShake(fn) {\n    // Threshold for shake detection\n    const threshold = 15;\n    let lastX = 0, lastY = 0, lastZ = 0;\n    let lastTime = 0;\n    const handler = (e) => {\n        const current = e.accelerationIncludingGravity;\n        if (!current)\n            return;\n        const time = Date.now();\n        if ((time - lastTime) > 100) {\n            const diffTime = time - lastTime;\n            lastTime = time;\n            const x = current.x || 0;\n            const y = current.y || 0;\n            const z = current.z || 0;\n            const speed = Math.abs(x + y + z - lastX - lastY - lastZ) / diffTime * 10000;\n            if (speed > threshold) {\n                fn();\n            }\n            lastX = x;\n            lastY = y;\n            lastZ = z;\n        }\n    };\n    if (window.DeviceMotionEvent) {\n        window.addEventListener('devicemotion', handler);\n        onMuDestroy(() => window.removeEventListener('devicemotion', handler));\n    }\n    else {\n        console.warn(\"[MulanJS] Device Motion not supported on this device.\");\n    }\n}\n/**\n * onMuVoice - The \"Sound Life\" Hook.\n * Executes when a specific word is spoken.\n * @param command The word to listen for (e.g., \"save\", \"next\")\n * @param fn The action to take\n */\nfunction onMuVoice(command, fn) {\n    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;\n    if (!SpeechRecognition) {\n        console.warn(\"[MulanJS] Voice Control (Web Speech API) not supported in this browser.\");\n        return;\n    }\n    const recognition = new SpeechRecognition();\n    recognition.continuous = true;\n    recognition.lang = 'en-US';\n    recognition.interimResults = false;\n    recognition.onresult = (event) => {\n        const last = event.results.length - 1;\n        const spoken = event.results[last][0].transcript.trim().toLowerCase();\n        console.log(`[Mulan Voice] Heard: \"${spoken}\"`);\n        if (spoken.includes(command.toLowerCase())) {\n            fn();\n        }\n    };\n    recognition.start();\n    // Auto-restart if it stops (Continuous listening)\n    recognition.onend = () => {\n        // Simple check to see if we should still be listening\n        // In a real app we might want more control\n        // recognition.start(); \n    };\n    onMuDestroy(() => {\n        recognition.stop();\n    });\n}\n// --- \"Outside The Box\" Hooks (Mulan Exclusives) ---\n/**\n * muGeom - Tracks window or element dimensions reactively.\n */\nfunction muGeom() {\n    const dims = muState({ width: window.innerWidth, height: window.innerHeight });\n    const handler = () => {\n        dims.width = window.innerWidth;\n        dims.height = window.innerHeight;\n    };\n    window.addEventListener('resize', handler);\n    // Auto-cleanup\n    onMuDestroy(() => {\n        window.removeEventListener('resize', handler);\n    });\n    return dims;\n}\n/**\n * muPulse - Reactive network status.\n */\nfunction muPulse() {\n    const status = muState({ online: navigator.onLine });\n    const setOnline = () => status.online = true;\n    const setOffline = () => status.online = false;\n    window.addEventListener('online', setOnline);\n    window.addEventListener('offline', setOffline);\n    onMuDestroy(() => {\n        window.removeEventListener('online', setOnline);\n        window.removeEventListener('offline', setOffline);\n    });\n    return status;\n}\n/**\n * muVault - Secure reactive LocalStorage wrapper.\n * Powered by the Iron Fortress persistent primitive.\n */\nfunction muVault(key, initial, options = {}) {\n    return (0,_vault__WEBPACK_IMPORTED_MODULE_1__.persistent)(key, initial, options);\n}\n\n\n//# sourceURL=webpack://Mulan/./src/core/hooks.ts?\n}");
+;// ./src/core/query.ts
+var query_awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 
-/***/ },
+function useQuery(queryFn, options = { enabled: true }) {
+    const state = reactive({
+        data: null,
+        isLoading: false,
+        error: null
+    });
+    const execute = () => query_awaiter(this, void 0, void 0, function* () {
+        state.isLoading = true;
+        state.error = null;
+        try {
+            const result = yield queryFn();
+            state.data = result;
+        }
+        catch (err) {
+            state.error = err;
+        }
+        finally {
+            state.isLoading = false;
+        }
+    });
+    if (options.enabled) {
+        // Run automatically
+        effect(() => {
+            // Basic effect wrapper to allow reactivity if queryFn relies on signals
+            execute();
+        });
+    }
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        refetch: execute
+    };
+}
+function useMutation(mutationFn) {
+    const state = reactive({
+        data: null,
+        isLoading: false,
+        error: null
+    });
+    const mutate = (args) => query_awaiter(this, void 0, void 0, function* () {
+        state.isLoading = true;
+        state.error = null;
+        try {
+            const result = yield mutationFn(args);
+            state.data = result;
+            return result;
+        }
+        catch (err) {
+            state.error = err;
+            throw err;
+        }
+        finally {
+            state.isLoading = false;
+        }
+    });
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        mutate
+    };
+}
 
-/***/ "./src/core/quantum.ts"
-/*!*****************************!*\
-  !*** ./src/core/quantum.ts ***!
-  \*****************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+;// ./src/core/quantum.ts
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   activeControls: () => (/* binding */ activeControls),\n/* harmony export */   muControl: () => (/* binding */ muControl),\n/* harmony export */   muEntangle: () => (/* binding */ muEntangle),\n/* harmony export */   muGate: () => (/* binding */ muGate),\n/* harmony export */   muMeasure: () => (/* binding */ muMeasure),\n/* harmony export */   muParallel: () => (/* binding */ muParallel),\n/* harmony export */   muQubit: () => (/* binding */ muQubit),\n/* harmony export */   muRegister: () => (/* binding */ muRegister),\n/* harmony export */   muSearch: () => (/* binding */ muSearch),\n/* harmony export */   muSwitch: () => (/* binding */ muSwitch),\n/* harmony export */   muTeleport: () => (/* binding */ muTeleport)\n/* harmony export */ });\n/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hooks */ \"./src/core/hooks.ts\");\n\n/**\n * Mulan Quantum (ASTR-Q+) Core\n * Advanced Simulation Engine for multi-qubit registers and entanglement.\n */\n// -- GLOBAL CONTEXT FOR QUANTUM CONTROL --\n// Defined at top to ensure visibility for muGate\nlet activeControls = [];\n/**\n * Creates a quantum register of size n.\n * State vector will have 2^n amplitudes.\n */\nfunction muRegister(n) {\n    const numStates = Math.pow(2, n);\n    const amplitudes = new Array(numStates).fill(0).map((_, i) => ({\n        re: i === 0 ? 1 : 0,\n        im: 0\n    }));\n    return (0,_hooks__WEBPACK_IMPORTED_MODULE_0__.muState)({\n        value: {\n            size: n,\n            amplitudes\n        }\n    });\n}\n/**\n * Backward compatible muQubit (Single Qubit Register)\n */\nfunction muQubit(initial = 0) {\n    const q = muRegister(1);\n    if (initial === 1) {\n        muGate(q, 'X', 0);\n    }\n    // Add compatibility properties for Phase 1 components\n    // These properties are getters that dynamically access the amplitudes array\n    Object.defineProperty(q.value, 'alpha', { get: () => q.value.amplitudes[0] });\n    Object.defineProperty(q.value, 'beta', { get: () => q.value.amplitudes[1] });\n    return q;\n}\n/**\n * Internal helper to update register state while maintaining compatibility\n */\nfunction updateState(reg, newState) {\n    if (newState.size === 1) {\n        // Re-inject compatibility getters for muQubit users\n        Object.defineProperty(newState, 'alpha', {\n            get: () => newState.amplitudes[0],\n            configurable: true,\n            enumerable: true\n        });\n        Object.defineProperty(newState, 'beta', {\n            get: () => newState.amplitudes[1],\n            configurable: true,\n            enumerable: true\n        });\n    }\n    reg.value = newState;\n}\nfunction muGate(reg, type, target = 0, control) {\n    const state = reg.value;\n    const n = state.size;\n    const amplitudes = state.amplitudes;\n    const newAmps = amplitudes.map(a => (Object.assign({}, a)));\n    // Prepare Effective Control (Explicit Arguments + Global Context)\n    const effectiveControl = [...(control === undefined ? [] : (Array.isArray(control) ? control : [control])), ...activeControls];\n    // Helper: Check if all control bits are 1\n    const checkControl = (index, ctrl) => {\n        if (ctrl === undefined || (Array.isArray(ctrl) && ctrl.length === 0))\n            return true;\n        const ctrls = Array.isArray(ctrl) ? ctrl : [ctrl];\n        return ctrls.every(c => ((index >> c) & 1) === 1);\n    };\n    // SWAP Gate (Unique case: affects 2 targets)\n    if (type === 'SWAP') {\n        const t1 = target;\n        const t2 = control; // SWAP uses control arg as second target \n        // Iterate only half to avoid double swapping\n        for (let i = 0; i < amplitudes.length; i++) {\n            // Check active controls for SWAP too\n            if (activeControls.length > 0 && !checkControl(i, activeControls))\n                continue;\n            const bit1 = (i >> t1) & 1;\n            const bit2 = (i >> t2) & 1;\n            if (bit1 !== bit2) {\n                // Determine the swap partner index\n                // If i has (0,1), partner has (1,0) at those positions\n                const partner = i ^ (1 << t1) ^ (1 << t2);\n                if (i < partner) {\n                    const temp = newAmps[i];\n                    newAmps[i] = newAmps[partner];\n                    newAmps[partner] = temp;\n                }\n            }\n        }\n        updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));\n        return;\n    }\n    // Standard Single-Qubit & Controlled Gates\n    if (type === 'H') {\n        const s = 1 / Math.sqrt(2);\n        const processed = new Set();\n        for (let i = 0; i < state.amplitudes.length; i++) {\n            if (processed.has(i))\n                continue;\n            // Check Controls first\n            if (!checkControl(i, effectiveControl))\n                continue;\n            const targetBit = (i >> target) & 1;\n            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));\n            const a = state.amplitudes[i];\n            const b = state.amplitudes[pairedIndex];\n            if (targetBit === 0) {\n                newAmps[i] = { re: s * (a.re + b.re), im: s * (a.im + b.im) };\n                newAmps[pairedIndex] = { re: s * (a.re - b.re), im: s * (a.im - b.im) };\n            }\n            else {\n                newAmps[pairedIndex] = { re: s * (b.re + a.re), im: s * (b.im + a.im) };\n                newAmps[i] = { re: s * (b.re - a.re), im: s * (b.im - a.im) };\n            }\n            processed.add(i);\n            processed.add(pairedIndex);\n        }\n    }\n    else if (type === 'X' || type === 'CNOT') {\n        // CNOT is just Controlled-X\n        for (let i = 0; i < amplitudes.length; i++) {\n            if (!checkControl(i, effectiveControl))\n                continue;\n            const targetBit = (i >> target) & 1;\n            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));\n            if (i < pairedIndex) {\n                const temp = newAmps[i];\n                newAmps[i] = newAmps[pairedIndex];\n                newAmps[pairedIndex] = temp;\n            }\n        }\n    }\n    else if (type === 'Z' || type === 'CZ') {\n        // Z and CZ are Phase Flips\n        for (let i = 0; i < amplitudes.length; i++) {\n            if (!checkControl(i, effectiveControl))\n                continue;\n            const targetBit = (i >> target) & 1;\n            // Z Gate acts on |1>\n            if (targetBit === 1) {\n                newAmps[i] = { re: -amplitudes[i].re, im: -amplitudes[i].im };\n            }\n        }\n    }\n    else if (type === 'Y') {\n        // Y: |0> -> i|1>, |1> -> -i|0>\n        for (let i = 0; i < amplitudes.length; i++) {\n            if (!checkControl(i, effectiveControl))\n                continue;\n            const targetBit = (i >> target) & 1;\n            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));\n            if (i < pairedIndex) {\n                // We process pairs (i, pairedIndex) where i has 0 at target, paired has 1\n                const a = newAmps[i]; // Coeff of |0>\n                const b = newAmps[pairedIndex]; // Coeff of |1>\n                // New |0> = -i * Old |1>\n                newAmps[i] = { re: b.im, im: -b.re };\n                // New |1> = i * Old |0>\n                newAmps[pairedIndex] = { re: -a.im, im: a.re };\n            }\n        }\n    }\n    updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));\n}\n/**\n * Mulan Search Logic (Grover's Operator)\n * Automatically constructs a multi-controlled Phase Flip (Z) for a specific target state.\n * This is the core of the \"Quantum Switch\" or \"Quantum Search\" capability.\n * @param reg Quantum Register\n * @param targetState The integer state to \"search\" and mark (e.g. 2 for |10>)\n */\nfunction muSearch(reg, targetState) {\n    const n = reg.value.size;\n    const controls = [];\n    // 1. Identify which bits are 0 and need wrapping with X gates\n    // Logic: To mark |010>, we want C-C-Z to trigger on 111.\n    // So we apply X to bits that are 0, then C-C-Z, then X again.\n    // We treat the last bit as the 'target' for the Z gate, rest as controls\n    const targetQubit = n - 1;\n    for (let i = 0; i < n; i++) {\n        const bit = (targetState >> i) & 1;\n        if (i === targetQubit) {\n            // If target bit logic requires 0, we flip it to 1 for the Z gate to work\n            if (bit === 0)\n                muGate(reg, 'X', i);\n        }\n        else {\n            controls.push(i);\n            if (bit === 0)\n                muGate(reg, 'X', i);\n        }\n    }\n    // 2. Apply Multi-Controlled Z\n    muGate(reg, 'Z', targetQubit, controls);\n    // 3. Uncompute (Restore 0s)\n    for (let i = 0; i < n; i++) {\n        const bit = (targetState >> i) & 1;\n        if (bit === 0)\n            muGate(reg, 'X', i);\n    }\n    // --- GROVER DIFFUSER (Amplification) ---\n    // This flips the probability amplitudes around the mean, boosting the target state.\n    // 1. Apply H to all\n    for (let i = 0; i < n; i++)\n        muGate(reg, 'H', i);\n    // 2. Apply X to all\n    for (let i = 0; i < n; i++)\n        muGate(reg, 'X', i);\n    // 3. Multi-Controlled Z (Reflection about |0...0>)\n    // We want to flip phase of |11...1> state after X transformation (which corresponds to |00...0> original)\n    // Target is last qubit, controls are 0 to n-2\n    const diffControls = [];\n    for (let i = 0; i < n - 1; i++)\n        diffControls.push(i);\n    muGate(reg, 'Z', n - 1, diffControls);\n    // 4. Uncompute X\n    for (let i = 0; i < n; i++)\n        muGate(reg, 'X', i);\n    // 5. Uncompute H\n    for (let i = 0; i < n; i++)\n        muGate(reg, 'H', i);\n}\nfunction muEntangle(reg, i, j) {\n    muGate(reg, 'H', i);\n    muGate(reg, 'CNOT', j, i);\n}\n/**\n * Quantum Teleportation Protocol\n * Transfers the state of `msgIdx` to `targetIdx` using `ancillaIdx` as a resource.\n * @param reg Register\n * @param msgIdx The qubit containing the state to teleport (Alice)\n * @param ancillaIdx The helper qubit (Alice's half of entanglement)\n * @param targetIdx The destination qubit (Bob)\n */\nfunction muTeleport(reg, msgIdx, ancillaIdx, targetIdx) {\n    // 1. Create Bell Pair (Entanglement) between Ancilla and Target\n    // Represents the shared link between Alice and Bob\n    muEntangle(reg, ancillaIdx, targetIdx);\n    // 2. Bell Measurement on Message + Ancilla (Alice's side)\n    muGate(reg, 'CNOT', ancillaIdx, msgIdx); // Control: msg, Target: ancilla\n    muGate(reg, 'H', msgIdx);\n    // 3. Measure Alice's qubits (This collapses them)\n    const m1 = muMeasure(reg, msgIdx); // Measures \"Z\" component\n    const m2 = muMeasure(reg, ancillaIdx); // Measures \"X\" component\n    // 4. Classical Communication & Correction (Bob's side)\n    // Apply corrections to Target based on measurements\n    if (m2 === 1)\n        muGate(reg, 'X', targetIdx);\n    if (m1 === 1)\n        muGate(reg, 'Z', targetIdx);\n}\n/**\n * Measures a specific qubit in the register, collapsing the superposition.\n * @param reg Quantum Register\n * @param target Index of qubit to measure\n * @returns 0 or 1\n */\nfunction muMeasure(reg, target = 0) {\n    const state = reg.value;\n    const amplitudes = state.amplitudes;\n    let prob0 = 0;\n    // 1. Calculate Probability of |0>\n    for (let i = 0; i < amplitudes.length; i++) {\n        if (((i >> target) & 1) === 0) {\n            const a = amplitudes[i];\n            prob0 += (a.re * a.re) + (a.im * a.im);\n        }\n    }\n    // 2. Determine Outcome\n    const result = Math.random() < prob0 ? 0 : 1;\n    const resultProb = result === 0 ? prob0 : (1 - prob0);\n    const normFactor = resultProb > 0 ? (1 / Math.sqrt(resultProb)) : 0;\n    // 3. Collapse the State (Wavefunction Collapse)\n    const newAmps = amplitudes.map((a, i) => {\n        const bit = (i >> target) & 1;\n        if (bit !== result) {\n            return { re: 0, im: 0 };\n        }\n        else {\n            return { re: a.re * normFactor, im: a.im * normFactor };\n        }\n    });\n    // We need to call updateState to ensure reactivity if specialized getters exist\n    // But since this file has updateState internal, we can just call it.\n    // However, the internal updateState function needs to be in scope. \n    // It is defined at line 60. So we are good.\n    updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));\n    return result;\n}\n/**\n * Quantum Loop: Parallel Execution\n * Applies a gate to multiple qubits \"simultaneously\" (in simulation steps).\n * Ideal for initialization (Hadamard Transform) or global operations.\n * @param reg Quantum Register\n * @param qubits Array of qubit indices\n * @param gate Gate type to apply (e.g. 'H', 'X')\n */\nfunction muParallel(reg, qubits, gate) {\n    if (gate === 'SWAP') {\n        throw new Error(\"SWAP cannot be applied in parallel (requires pairs).\");\n    }\n    // In a real quantum computer, these happen at t=0.\n    // Here, we loop, but logical time is constant.\n    qubits.forEach(q => muGate(reg, gate, q));\n}\n/**\n * Applies a block of operations controlled by specific qubits.\n * Enables \"Quantum If/Else\".\n */\nfunction muControl(reg, controlQubit, inverse, block) {\n    // 1. Setup Context\n    if (inverse) {\n        muGate(reg, 'X', controlQubit); // Flip 0 to 1 to activate\n    }\n    activeControls.push(controlQubit);\n    try {\n        block();\n    }\n    finally {\n        activeControls.pop();\n        // Uncompute (Restore 0)\n        if (inverse) {\n            muGate(reg, 'X', controlQubit);\n        }\n    }\n}\n/**\n * Quantum Switch: conditional Logic on Superposition\n * Executes different logic branches based on the state of control qubits.\n * Because the register can be in a superposition of states (e.g. |0> + |1>),\n * MULTIPLE branches can execute effectively simultaneously on different subspaces.\n *\n * @param reg Quantum Register\n * @param controlQubit The qubit controlling the switch (Single control for v1)\n * @param cases Object mapping state (0 or 1) to a function executing quantum operations\n */\nfunction muSwitch(reg, controlQubit, cases) {\n    if (cases[0]) {\n        muControl(reg, controlQubit, true, cases[0]);\n    }\n    if (cases[1]) {\n        muControl(reg, controlQubit, false, cases[1]);\n    }\n}\n\n\n//# sourceURL=webpack://Mulan/./src/core/quantum.ts?\n}");
+/**
+ * Mulan Quantum (ASTR-Q+) Core
+ * Advanced Simulation Engine for multi-qubit registers and entanglement.
+ */
+// -- GLOBAL CONTEXT FOR QUANTUM CONTROL --
+// Defined at top to ensure visibility for muGate
+let activeControls = [];
+/**
+ * Creates a quantum register of size n.
+ * State vector will have 2^n amplitudes.
+ */
+function muRegister(n) {
+    const numStates = Math.pow(2, n);
+    const amplitudes = new Array(numStates).fill(0).map((_, i) => ({
+        re: i === 0 ? 1 : 0,
+        im: 0
+    }));
+    return muState({
+        value: {
+            size: n,
+            amplitudes
+        }
+    });
+}
+/**
+ * Backward compatible muQubit (Single Qubit Register)
+ */
+function muQubit(initial = 0) {
+    const q = muRegister(1);
+    if (initial === 1) {
+        muGate(q, 'X', 0);
+    }
+    // Add compatibility properties for Phase 1 components
+    // These properties are getters that dynamically access the amplitudes array
+    Object.defineProperty(q.value, 'alpha', { get: () => q.value.amplitudes[0] });
+    Object.defineProperty(q.value, 'beta', { get: () => q.value.amplitudes[1] });
+    return q;
+}
+/**
+ * Internal helper to update register state while maintaining compatibility
+ */
+function updateState(reg, newState) {
+    if (newState.size === 1) {
+        // Re-inject compatibility getters for muQubit users
+        Object.defineProperty(newState, 'alpha', {
+            get: () => newState.amplitudes[0],
+            configurable: true,
+            enumerable: true
+        });
+        Object.defineProperty(newState, 'beta', {
+            get: () => newState.amplitudes[1],
+            configurable: true,
+            enumerable: true
+        });
+    }
+    reg.value = newState;
+}
+function muGate(reg, type, target = 0, control) {
+    const state = reg.value;
+    const n = state.size;
+    const amplitudes = state.amplitudes;
+    const newAmps = amplitudes.map(a => (Object.assign({}, a)));
+    // Prepare Effective Control (Explicit Arguments + Global Context)
+    const effectiveControl = [...(control === undefined ? [] : (Array.isArray(control) ? control : [control])), ...activeControls];
+    // Helper: Check if all control bits are 1
+    const checkControl = (index, ctrl) => {
+        if (ctrl === undefined || (Array.isArray(ctrl) && ctrl.length === 0))
+            return true;
+        const ctrls = Array.isArray(ctrl) ? ctrl : [ctrl];
+        return ctrls.every(c => ((index >> c) & 1) === 1);
+    };
+    // SWAP Gate (Unique case: affects 2 targets)
+    if (type === 'SWAP') {
+        const t1 = target;
+        const t2 = control; // SWAP uses control arg as second target 
+        // Iterate only half to avoid double swapping
+        for (let i = 0; i < amplitudes.length; i++) {
+            // Check active controls for SWAP too
+            if (activeControls.length > 0 && !checkControl(i, activeControls))
+                continue;
+            const bit1 = (i >> t1) & 1;
+            const bit2 = (i >> t2) & 1;
+            if (bit1 !== bit2) {
+                // Determine the swap partner index
+                // If i has (0,1), partner has (1,0) at those positions
+                const partner = i ^ (1 << t1) ^ (1 << t2);
+                if (i < partner) {
+                    const temp = newAmps[i];
+                    newAmps[i] = newAmps[partner];
+                    newAmps[partner] = temp;
+                }
+            }
+        }
+        updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+        return;
+    }
+    // Standard Single-Qubit & Controlled Gates
+    if (type === 'H') {
+        const s = 1 / Math.sqrt(2);
+        const processed = new Set();
+        for (let i = 0; i < state.amplitudes.length; i++) {
+            if (processed.has(i))
+                continue;
+            // Check Controls first
+            if (!checkControl(i, effectiveControl))
+                continue;
+            const targetBit = (i >> target) & 1;
+            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
+            const a = state.amplitudes[i];
+            const b = state.amplitudes[pairedIndex];
+            if (targetBit === 0) {
+                newAmps[i] = { re: s * (a.re + b.re), im: s * (a.im + b.im) };
+                newAmps[pairedIndex] = { re: s * (a.re - b.re), im: s * (a.im - b.im) };
+            }
+            else {
+                newAmps[pairedIndex] = { re: s * (b.re + a.re), im: s * (b.im + a.im) };
+                newAmps[i] = { re: s * (b.re - a.re), im: s * (b.im - a.im) };
+            }
+            processed.add(i);
+            processed.add(pairedIndex);
+        }
+    }
+    else if (type === 'X' || type === 'CNOT') {
+        // CNOT is just Controlled-X
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, effectiveControl))
+                continue;
+            const targetBit = (i >> target) & 1;
+            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
+            if (i < pairedIndex) {
+                const temp = newAmps[i];
+                newAmps[i] = newAmps[pairedIndex];
+                newAmps[pairedIndex] = temp;
+            }
+        }
+    }
+    else if (type === 'Z' || type === 'CZ') {
+        // Z and CZ are Phase Flips
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, effectiveControl))
+                continue;
+            const targetBit = (i >> target) & 1;
+            // Z Gate acts on |1>
+            if (targetBit === 1) {
+                newAmps[i] = { re: -amplitudes[i].re, im: -amplitudes[i].im };
+            }
+        }
+    }
+    else if (type === 'Y') {
+        // Y: |0> -> i|1>, |1> -> -i|0>
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, effectiveControl))
+                continue;
+            const targetBit = (i >> target) & 1;
+            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
+            if (i < pairedIndex) {
+                // We process pairs (i, pairedIndex) where i has 0 at target, paired has 1
+                const a = newAmps[i]; // Coeff of |0>
+                const b = newAmps[pairedIndex]; // Coeff of |1>
+                // New |0> = -i * Old |1>
+                newAmps[i] = { re: b.im, im: -b.re };
+                // New |1> = i * Old |0>
+                newAmps[pairedIndex] = { re: -a.im, im: a.re };
+            }
+        }
+    }
+    updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+}
+/**
+ * Mulan Search Logic (Grover's Operator)
+ * Automatically constructs a multi-controlled Phase Flip (Z) for a specific target state.
+ * This is the core of the "Quantum Switch" or "Quantum Search" capability.
+ * @param reg Quantum Register
+ * @param targetState The integer state to "search" and mark (e.g. 2 for |10>)
+ */
+function muSearch(reg, targetState) {
+    const n = reg.value.size;
+    const controls = [];
+    // 1. Identify which bits are 0 and need wrapping with X gates
+    // Logic: To mark |010>, we want C-C-Z to trigger on 111.
+    // So we apply X to bits that are 0, then C-C-Z, then X again.
+    // We treat the last bit as the 'target' for the Z gate, rest as controls
+    const targetQubit = n - 1;
+    for (let i = 0; i < n; i++) {
+        const bit = (targetState >> i) & 1;
+        if (i === targetQubit) {
+            // If target bit logic requires 0, we flip it to 1 for the Z gate to work
+            if (bit === 0)
+                muGate(reg, 'X', i);
+        }
+        else {
+            controls.push(i);
+            if (bit === 0)
+                muGate(reg, 'X', i);
+        }
+    }
+    // 2. Apply Multi-Controlled Z
+    muGate(reg, 'Z', targetQubit, controls);
+    // 3. Uncompute (Restore 0s)
+    for (let i = 0; i < n; i++) {
+        const bit = (targetState >> i) & 1;
+        if (bit === 0)
+            muGate(reg, 'X', i);
+    }
+    // --- GROVER DIFFUSER (Amplification) ---
+    // This flips the probability amplitudes around the mean, boosting the target state.
+    // 1. Apply H to all
+    for (let i = 0; i < n; i++)
+        muGate(reg, 'H', i);
+    // 2. Apply X to all
+    for (let i = 0; i < n; i++)
+        muGate(reg, 'X', i);
+    // 3. Multi-Controlled Z (Reflection about |0...0>)
+    // We want to flip phase of |11...1> state after X transformation (which corresponds to |00...0> original)
+    // Target is last qubit, controls are 0 to n-2
+    const diffControls = [];
+    for (let i = 0; i < n - 1; i++)
+        diffControls.push(i);
+    muGate(reg, 'Z', n - 1, diffControls);
+    // 4. Uncompute X
+    for (let i = 0; i < n; i++)
+        muGate(reg, 'X', i);
+    // 5. Uncompute H
+    for (let i = 0; i < n; i++)
+        muGate(reg, 'H', i);
+}
+function muEntangle(reg, i, j) {
+    muGate(reg, 'H', i);
+    muGate(reg, 'CNOT', j, i);
+}
+/**
+ * Quantum Teleportation Protocol
+ * Transfers the state of `msgIdx` to `targetIdx` using `ancillaIdx` as a resource.
+ * @param reg Register
+ * @param msgIdx The qubit containing the state to teleport (Alice)
+ * @param ancillaIdx The helper qubit (Alice's half of entanglement)
+ * @param targetIdx The destination qubit (Bob)
+ */
+function muTeleport(reg, msgIdx, ancillaIdx, targetIdx) {
+    // 1. Create Bell Pair (Entanglement) between Ancilla and Target
+    // Represents the shared link between Alice and Bob
+    muEntangle(reg, ancillaIdx, targetIdx);
+    // 2. Bell Measurement on Message + Ancilla (Alice's side)
+    muGate(reg, 'CNOT', ancillaIdx, msgIdx); // Control: msg, Target: ancilla
+    muGate(reg, 'H', msgIdx);
+    // 3. Measure Alice's qubits (This collapses them)
+    const m1 = muMeasure(reg, msgIdx); // Measures "Z" component
+    const m2 = muMeasure(reg, ancillaIdx); // Measures "X" component
+    // 4. Classical Communication & Correction (Bob's side)
+    // Apply corrections to Target based on measurements
+    if (m2 === 1)
+        muGate(reg, 'X', targetIdx);
+    if (m1 === 1)
+        muGate(reg, 'Z', targetIdx);
+}
+/**
+ * Measures a specific qubit in the register, collapsing the superposition.
+ * @param reg Quantum Register
+ * @param target Index of qubit to measure
+ * @returns 0 or 1
+ */
+function muMeasure(reg, target = 0) {
+    const state = reg.value;
+    const amplitudes = state.amplitudes;
+    let prob0 = 0;
+    // 1. Calculate Probability of |0>
+    for (let i = 0; i < amplitudes.length; i++) {
+        if (((i >> target) & 1) === 0) {
+            const a = amplitudes[i];
+            prob0 += (a.re * a.re) + (a.im * a.im);
+        }
+    }
+    // 2. Determine Outcome
+    const result = Math.random() < prob0 ? 0 : 1;
+    const resultProb = result === 0 ? prob0 : (1 - prob0);
+    const normFactor = resultProb > 0 ? (1 / Math.sqrt(resultProb)) : 0;
+    // 3. Collapse the State (Wavefunction Collapse)
+    const newAmps = amplitudes.map((a, i) => {
+        const bit = (i >> target) & 1;
+        if (bit !== result) {
+            return { re: 0, im: 0 };
+        }
+        else {
+            return { re: a.re * normFactor, im: a.im * normFactor };
+        }
+    });
+    // We need to call updateState to ensure reactivity if specialized getters exist
+    // But since this file has updateState internal, we can just call it.
+    // However, the internal updateState function needs to be in scope. 
+    // It is defined at line 60. So we are good.
+    updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+    return result;
+}
+/**
+ * Quantum Loop: Parallel Execution
+ * Applies a gate to multiple qubits "simultaneously" (in simulation steps).
+ * Ideal for initialization (Hadamard Transform) or global operations.
+ * @param reg Quantum Register
+ * @param qubits Array of qubit indices
+ * @param gate Gate type to apply (e.g. 'H', 'X')
+ */
+function muParallel(reg, qubits, gate) {
+    if (gate === 'SWAP') {
+        throw new Error("SWAP cannot be applied in parallel (requires pairs).");
+    }
+    // In a real quantum computer, these happen at t=0.
+    // Here, we loop, but logical time is constant.
+    qubits.forEach(q => muGate(reg, gate, q));
+}
+/**
+ * Applies a block of operations controlled by specific qubits.
+ * Enables "Quantum If/Else".
+ */
+function muControl(reg, controlQubit, inverse, block) {
+    // 1. Setup Context
+    if (inverse) {
+        muGate(reg, 'X', controlQubit); // Flip 0 to 1 to activate
+    }
+    activeControls.push(controlQubit);
+    try {
+        block();
+    }
+    finally {
+        activeControls.pop();
+        // Uncompute (Restore 0)
+        if (inverse) {
+            muGate(reg, 'X', controlQubit);
+        }
+    }
+}
+/**
+ * Quantum Switch: conditional Logic on Superposition
+ * Executes different logic branches based on the state of control qubits.
+ * Because the register can be in a superposition of states (e.g. |0> + |1>),
+ * MULTIPLE branches can execute effectively simultaneously on different subspaces.
+ *
+ * @param reg Quantum Register
+ * @param controlQubit The qubit controlling the switch (Single control for v1)
+ * @param cases Object mapping state (0 or 1) to a function executing quantum operations
+ */
+function muSwitch(reg, controlQubit, cases) {
+    if (cases[0]) {
+        muControl(reg, controlQubit, true, cases[0]);
+    }
+    if (cases[1]) {
+        muControl(reg, controlQubit, false, cases[1]);
+    }
+}
 
-/***/ },
+;// ./src/components/bloch-sphere.ts
 
-/***/ "./src/core/query.ts"
-/*!***************************!*\
-  !*** ./src/core/query.ts ***!
-  \***************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+class MuBlochSphereElement extends HTMLElement {
+    static get observedAttributes() {
+        return ['size'];
+    }
+    constructor() {
+        super();
+        this._arrow = null;
+        this._container = null;
+        this._disposeEffect = null;
+        this.attachShadow({ mode: 'open' });
+    }
+    connectedCallback() {
+        this.render();
+    }
+    disconnectedCallback() {
+        if (this._disposeEffect) {
+            this._disposeEffect();
+            this._disposeEffect = null;
+        }
+    }
+    // Property setter for 'qubit' (passed as .qubit="${q}" in Mulan)
+    set qubit(val) {
+        this._qubit = val;
+        this.initReactivity();
+    }
+    get qubit() {
+        return this._qubit;
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+        if (name === 'size' && this._container) {
+            this._container.style.width = newValue + 'px';
+            this._container.style.height = newValue + 'px';
+        }
+    }
+    initReactivity() {
+        if (this._disposeEffect)
+            this._disposeEffect();
+        if (!this._qubit)
+            return;
+        // MulanJS Effect: Run whenever the qubit state changes
+        this._disposeEffect = effect(() => {
+            const state = this._qubit.value; // Access reactive proxy
+            if (!state || !state.amplitudes)
+                return;
+            // Assume Single Qubit for Visualizer (Index 0 if passed a register)
+            // If passed a register, we visualize the first qubit's logical projection (partial trace simplified)
+            // Or assume input IS a specific qubit projection?
+            // For simplified demo, we assume the register is size 1 OR we visualize Q0 of the register.
+            const amps = state.amplitudes;
+            // Support 1-qubit visualization from N-qubit register requires partial trace.
+            // For now, let's assume the user passes a 1-qubit register OR we visualize index 0.
+            // |psi> = a|0> + b|1>
+            // a = amps[0] (re, im)
+            // b = amps[1] (re, im)
+            // Dealing with multi-qubit registers (naive projection for visualization):
+            // We sum up probabilities for 0xxxx vs 1xxxx to get Z-axis.
+            // This is "marginal probability".
+            let p0 = 0;
+            let p1 = 0;
+            // Calculate Probabilities
+            for (let i = 0; i < amps.length; i++) {
+                const mag = amps[i].re * amps[i].re + amps[i].im * amps[i].im;
+                if ((i & 1) === 0)
+                    p0 += mag;
+                else
+                    p1 += mag;
+            }
+            // Theta from Z-projection
+            // P0 = cos^2(theta/2) -> theta = 2 * acos(sqrt(P0))
+            const theta = 2 * Math.acos(Math.min(1, Math.sqrt(p0)));
+            // Phi?
+            // Phase is relative phase between |0> and |1>.
+            // We can look at the phase of the '1' component relative to '0'.
+            // Simple approach: Look at amps[1] phase vs amps[0] phase.
+            // But with entanglement, pure state phase is tricky.
+            // Let's implement full density matrix if needed, but for now:
+            // naive: atan2(amps[1].im, amps[1].re) - atan2(amps[0].im, amps[0].re)
+            // We use the first pair (0 and 1) as proxy if multiple.
+            const a0 = amps[0];
+            const a1 = amps[1]; // Valid for N>=1
+            const phase0 = Math.atan2(a0.im, a0.re);
+            const phase1 = Math.atan2(a1.im, a1.re);
+            let phi = phase1 - phase0;
+            // Update Arrow
+            this.updateArrow(theta, phi);
+        });
+    }
+    updateArrow(theta, phi) {
+        if (!this._arrow)
+            return;
+        // Convert Quantum Coords (Theta, Phi) to CSS Transforms
+        // Theta 0 = Top (|0>)
+        // Theta PI = Bottom (|1>)
+        // Theta PI/2 = Equator
+        // CSS Rotate sequence:
+        // 1. Start pointing UP (Y or Z axis in CSS?)
+        // Let's say Arrow starts pointing UP (Y-).
+        // Rotate Z by Phi (Azimuth)
+        // Rotate X by Theta (Polar) - No, that's not standard Euler.
+        // Standard Physics:
+        // Z is Up (in Bloch), but CSS 3D Y is usually 'Down' or 'Up'.
+        // Let's Map:
+        // Bloch Z+ (|0>) -> CSS Y- (Top)
+        // Bloch Z- (|1>) -> CSS Y+ (Bottom)
+        // Bloch X+ (|+>) -> CSS Z+ (Front)
+        // Transform:
+        // rotateY(phi) ? No, phi rotates around Z-axis (Vertical).
+        // theta rotates from Z-axis down.
+        // CSS:
+        // rotateY(phi) -> Rotates around Vertical axis.
+        // rotateZ(theta) -> Rotates "down" from up?
+        // Let's simplify:
+        // transform: rotateY(${phi}rad) rotateZ(${theta}rad)
+        // Note: CSS rotations order matters.
+        const degTheta = theta * (180 / Math.PI);
+        const degPhi = phi * (180 / Math.PI);
+        // Adjustment for visual alignment
+        this._arrow.style.transform = `rotateY(${degPhi}deg) rotateZ(${degTheta}deg)`;
+        // Color based on state
+        const isSuperposition = Math.abs(theta - Math.PI / 2) < 0.1;
+        this._arrow.style.backgroundColor = isSuperposition ? '#00ffff' : '#ff00ff';
+    }
+    render() {
+        if (!this.shadowRoot)
+            return;
+        const size = this.getAttribute('size') || '200';
+        this.shadowRoot.innerHTML = `
+            <style>
+                :host {
+                    display: inline-block;
+                    perspective: 1000px;
+                }
+                .sphere-container {
+                    width: ${size}px;
+                    height: ${size}px;
+                    position: relative;
+                    transform-style: preserve-3d;
+                    margin: 0 auto;
+                }
+                .sphere {
+                    width: 100%;
+                    height: 100%;
+                    border-radius: 50%;
+                    border: 1px solid rgba(255, 255, 255, 0.2);
+                    position: absolute;
+                    background: radial-gradient(circle at 30% 30%, rgba(255, 255, 255, 0.1), rgba(0, 0, 0, 0.8));
+                    box-shadow: inset 0 0 20px rgba(255, 255, 255, 0.05);
+                    transform: rotateX(15deg) rotateY(15deg); /* Initial tilt for view */
+                }
+                /* Equator Ring */
+                .equator {
+                    position: absolute;
+                    top: 50%;
+                    left: 0;
+                    width: 100%;
+                    height: 100%;
+                    border: 1px dashed rgba(255, 255, 255, 0.3);
+                    border-radius: 50%;
+                    transform: rotateX(90deg);
+                    pointer-events: none;
+                }
+                /* Axis Lines */
+                .axis {
+                    position: absolute;
+                    background: rgba(255, 255, 255, 0.1);
+                }
+                .z-axis { width: 2px; height: 100%; left: 50%; top: 0; }
+                
+                /* The Quantum Arrow */
+                .arrow-container {
+                    position: absolute;
+                    top: 50%;
+                    left: 50%;
+                    width: 0;
+                    height: 0;
+                    transform-style: preserve-3d;
+                    transform: rotateX(15deg) rotateY(15deg); /* Match sphere tilt */
+                }
+                
+                .arrow-pivot {
+                    position: absolute;
+                    top: 0;
+                    left: 0;
+                    width: 4px;
+                    height: 50%; /* Length of radius */
+                    /* Pivot logic: we want to rotate around the center point */
+                    /* CSS Default transform-origin is 50% 50% */
+                    /* We construct the arrow such that it points UP from center */
+                }
+                
+                .arrow-rod {
+                    width: 4px;
+                    height: ${parseInt(size) / 2 - 10}px;
+                    background: #ff00ff;
+                    position: absolute;
+                    bottom: 0;
+                    left: -2px;
+                    transform-origin: bottom center;
+                    transition: transform 0.5s cubic-bezier(0.175, 0.885, 0.32, 1.275), background-color 0.3s;
+                    border-radius: 2px;
+                    box-shadow: 0 0 10px currentColor;
+                }
+                
+                .arrow-head {
+                    width: 0; 
+                    height: 0; 
+                    border-left: 6px solid transparent;
+                    border-right: 6px solid transparent;
+                    border-bottom: 12px solid #ff00ff;
+                    position: absolute;
+                    top: -10px;
+                    left: -6px;
+                }
+                
+                .label {
+                    position: absolute;
+                    color: #aaa;
+                    font-family: monospace;
+                    font-size: 10px;
+                }
+                .label-0 { top: 5px; left: 50%; transform: translateX(-50%); }
+                .label-1 { bottom: 5px; left: 50%; transform: translateX(-50%); }
+            </style>
+            
+            <div class="sphere-container">
+                <div class="sphere">
+                    <div class="equator"></div>
+                    <div class="axis z-axis"></div>
+                    <div class="label label-0">|0></div>
+                    <div class="label label-1">|1></div>
+                </div>
+                
+                <div class="arrow-container">
+                    <!-- The rod is the actual rotating element -->
+                    <div class="arrow-rod">
+                        <div class="arrow-head"></div>
+                    </div>
+                </div>
+            </div>
+        `;
+        this._container = this.shadowRoot.querySelector('.sphere-container');
+        this._arrow = this.shadowRoot.querySelector('.arrow-rod');
+        // Re-init reactivity if qubit was set before render
+        if (this._qubit)
+            this.initReactivity();
+    }
+}
+// Register the custom element
+if (typeof customElements !== 'undefined') {
+    customElements.define('mu-bloch-sphere', MuBlochSphereElement);
+}
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   useMutation: () => (/* binding */ useMutation),\n/* harmony export */   useQuery: () => (/* binding */ useQuery)\n/* harmony export */ });\n/* harmony import */ var _reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./reactive */ \"./src/core/reactive.ts\");\nvar __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\n\nfunction useQuery(queryFn, options = { enabled: true }) {\n    const state = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)({\n        data: null,\n        isLoading: false,\n        error: null\n    });\n    const execute = () => __awaiter(this, void 0, void 0, function* () {\n        state.isLoading = true;\n        state.error = null;\n        try {\n            const result = yield queryFn();\n            state.data = result;\n        }\n        catch (err) {\n            state.error = err;\n        }\n        finally {\n            state.isLoading = false;\n        }\n    });\n    if (options.enabled) {\n        // Run automatically\n        (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {\n            // Basic effect wrapper to allow reactivity if queryFn relies on signals\n            execute();\n        });\n    }\n    return {\n        get data() { return state.data; },\n        get isLoading() { return state.isLoading; },\n        get error() { return state.error; },\n        refetch: execute\n    };\n}\nfunction useMutation(mutationFn) {\n    const state = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)({\n        data: null,\n        isLoading: false,\n        error: null\n    });\n    const mutate = (args) => __awaiter(this, void 0, void 0, function* () {\n        state.isLoading = true;\n        state.error = null;\n        try {\n            const result = yield mutationFn(args);\n            state.data = result;\n            return result;\n        }\n        catch (err) {\n            state.error = err;\n            throw err;\n        }\n        finally {\n            state.isLoading = false;\n        }\n    });\n    return {\n        get data() { return state.data; },\n        get isLoading() { return state.isLoading; },\n        get error() { return state.error; },\n        mutate\n    };\n}\n\n\n//# sourceURL=webpack://Mulan/./src/core/query.ts?\n}");
+;// ./src/components/infinity-list.ts
+class MuInfinity extends HTMLElement {
+    constructor() {
+        super();
+        this._items = [];
+        this._itemHeight = 50; // Default height
+        this._template = '';
+        this.attachShadow({ mode: 'open' });
+        // Structure:
+        // :host { overflow-y: auto; display: block; height: 100%; }
+        //   .spacer { height: totalHeight; position: relative; }
+        //     .content { position: absolute; top: padding; width: 100%; }
+        this.shadowRoot.innerHTML = `
+            <style>
+                :host {
+                    display: block;
+                    overflow-y: auto;
+                    height: 100%;
+                    position: relative;
+                }
+                .spacer {
+                    position: relative;
+                    width: 100%;
+                }
+                .content {
+                    position: absolute;
+                    top: 0;
+                    left: 0;
+                    width: 100%;
+                }
+            </style>
+            <div class="spacer">
+                <div class="content"></div>
+            </div>
+        `;
+        this.container = this.shadowRoot.host; // The host itself scrolls
+        this.spacer = this.shadowRoot.querySelector('.spacer');
+        this.content = this.shadowRoot.querySelector('.content');
+        this.onScroll = this.onScroll.bind(this);
+    }
+    static get observedAttributes() {
+        return ['item-height'];
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+        if (name === 'item-height') {
+            this._itemHeight = parseInt(newValue, 10) || 50;
+            this.renderVisible();
+        }
+    }
+    connectedCallback() {
+        // Find the template provided by the user (Support both standard and branded tags)
+        const templateTag = this.querySelector('template') || this.querySelector('mu-template');
+        if (templateTag) {
+            this._template = templateTag.innerHTML;
+        }
+        this.addEventListener('scroll', this.onScroll);
+        // Wait for next frame to get initial height if not set
+        requestAnimationFrame(() => this.renderVisible());
+    }
+    disconnectedCallback() {
+        this.removeEventListener('scroll', this.onScroll);
+    }
+    set items(value) {
+        this._items = value;
+        this.renderVisible();
+    }
+    get items() { return this._items; }
+    onScroll() {
+        requestAnimationFrame(() => this.renderVisible());
+    }
+    renderVisible() {
+        if (!this._items.length)
+            return;
+        const scrollTop = this.scrollTop;
+        const hostHeight = this.clientHeight || 400; // Default fallback if not sized
+        const totalHeight = this._items.length * this._itemHeight;
+        this.spacer.style.height = `${totalHeight}px`;
+        // Windowing Math
+        const startIndex = Math.floor(scrollTop / this._itemHeight);
+        const buffer = 5;
+        const visibleCount = Math.ceil(hostHeight / this._itemHeight);
+        const renderStart = Math.max(0, startIndex - buffer);
+        const renderEnd = Math.min(this._items.length, startIndex + visibleCount + buffer);
+        const startOffset = renderStart * this._itemHeight;
+        this.content.style.transform = `translateY(${startOffset}px)`;
+        // Render specific slice
+        const visibleItems = this._items.slice(renderStart, renderEnd);
+        // Simple string replacement template engine for the demo
+        // In a real Mulan compilation, this would be an optimized ASTR render
+        let html = '';
+        visibleItems.forEach((item, index) => {
+            const absoluteIndex = renderStart + index;
+            // Basic mustache replacement {{ item.prop }}
+            let rowHtml = this._template
+                .replace(/{{\s*item\s*}}/g, String(item)) // {{ item }}
+                .replace(/{{\s*index\s*}}/g, String(absoluteIndex)); // {{ index }}
+            // Handle object properties: {{ item.name }}
+            if (typeof item === 'object' && item !== null) {
+                rowHtml = rowHtml.replace(/{{\s*item\.(\w+)\s*}}/g, (_, prop) => {
+                    return String(item[prop] || '');
+                });
+            }
+            html += `<div style="height: ${this._itemHeight}px; overflow: hidden;">${rowHtml}</div>`;
+        });
+        this.content.innerHTML = html;
+    }
+}
+// Register
+if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity')) {
+    customElements.define('mu-infinity', MuInfinity);
+}
 
-/***/ },
+;// ./src/core/surge.ts
+/**
+ * muBurst - Adaptive Non-blocking Iterator
+ * Processes large arrays in batches within a frame budget (typically 8-16ms)
+ * to keep the UI responsive while executing at near-native loop speeds.
+ */
+function muBurst(array, callback, options = {}) {
+    const { chunkSize = 1000, timeout = 8, onProgress } = options;
+    return new Promise((resolve) => {
+        let index = 0;
+        const total = array.length;
+        function process() {
+            const start = performance.now();
+            // Tight loop for high-speed processing
+            while (index < total && (performance.now() - start) < timeout) {
+                // Process in smaller bursts to allow more frequent time checks if needed
+                const endBurst = Math.min(index + chunkSize, total);
+                for (; index < endBurst; index++) {
+                    callback(array[index], index);
+                }
+            }
+            if (onProgress) {
+                onProgress((index / total) * 100);
+            }
+            if (index < total) {
+                requestAnimationFrame(process);
+            }
+            else {
+                resolve();
+            }
+        }
+        process();
+    });
+}
+/**
+ * muSurge - Truly Parallel Execution
+ * Distributes work across CPU cores using Web Workers.
+ * Logic must be serializable.
+ */
+function muSurge(array, taskFn, onProgress) {
+    const n = navigator.hardwareConcurrency || 4;
+    const chunkSize = Math.ceil(array.length / n);
+    const results = new Array(array.length);
+    let completedChunks = 0;
+    let completedItems = 0;
+    // Convert function to string if it isn't already
+    const fnStr = typeof taskFn === 'function' ? taskFn.toString() : taskFn;
+    const workerPart1 = `const taskFn = ${fnStr};`;
+    const workerPart2 = `self.onmessage = function(e) {`;
+    const workerPart3 = `  const { chunk, startIndex } = e.data;`;
+    const workerPart4 = `  try { const results = chunk.map(taskFn); self.postMessage({ results, startIndex }); }`;
+    const workerPart5 = `  catch (err) { self.postMessage({ error: err.message, startIndex }); }`;
+    const workerPart6 = `};`;
+    const workerCode = [workerPart1, workerPart2, workerPart3, workerPart4, workerPart5, workerPart6].join('\n');
+    const blob = new Blob([workerCode], { type: 'application/javascript' });
+    const workerUrl = URL.createObjectURL(blob);
+    return new Promise((resolve) => {
+        if (array.length === 0)
+            return resolve([]);
+        for (let i = 0; i < n; i++) {
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, array.length);
+            if (start >= end) {
+                completedChunks++;
+                continue;
+            }
+            const chunk = array.slice(start, end);
+            const worker = new Worker(workerUrl);
+            worker.onmessage = (e) => {
+                const { results: chunkResults, startIndex } = e.data;
+                // Merge results back into main array
+                for (let j = 0; j < chunkResults.length; j++) {
+                    results[startIndex + j] = chunkResults[j];
+                }
+                completedChunks++;
+                completedItems += chunkResults.length;
+                if (onProgress)
+                    onProgress((completedItems / array.length) * 100);
+                worker.terminate();
+                if (completedChunks === n) {
+                    URL.revokeObjectURL(workerUrl);
+                    resolve(results);
+                }
+            };
+            worker.postMessage({ chunk, startIndex: start, fnStr });
+        }
+    });
+}
 
-/***/ "./src/core/reactive.ts"
-/*!******************************!*\
-  !*** ./src/core/reactive.ts ***!
-  \******************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+;// ./src/index.ts
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   Signal: () => (/* binding */ Signal),\n/* harmony export */   effect: () => (/* binding */ effect),\n/* harmony export */   reactive: () => (/* binding */ reactive),\n/* harmony export */   ref: () => (/* binding */ ref)\n/* harmony export */ });\n// MulanJS 2.0: Signal-Powered Reactivity Engine\n// \"Compatible Surface, World-Class Engine\"\nlet activeEffect = null;\nconst targetMap = new WeakMap();\n// --- Signal Core (The Engine) ---\nclass Signal {\n    constructor(initialValue) {\n        this._subscribers = new Set();\n        this._value = initialValue;\n    }\n    get value() {\n        if (activeEffect) {\n            this._subscribers.add(activeEffect);\n        }\n        return this._value;\n    }\n    set value(newValue) {\n        if (newValue !== this._value) {\n            this._value = newValue;\n            this.notify();\n        }\n    }\n    notify() {\n        this._subscribers.forEach(fn => fn());\n    }\n}\n// --- Compatibility Layer (The Surface) ---\nfunction effect(fn) {\n    let stopped = false;\n    const run = () => {\n        if (stopped)\n            return;\n        const prev = activeEffect;\n        activeEffect = run;\n        try {\n            fn();\n        }\n        finally {\n            activeEffect = prev;\n        }\n    };\n    run();\n    return () => {\n        stopped = true;\n    };\n}\nfunction track(target, key) {\n    if (activeEffect) {\n        let depsMap = targetMap.get(target);\n        if (!depsMap) {\n            targetMap.set(target, (depsMap = new Map()));\n        }\n        let dep = depsMap.get(key);\n        if (!dep) {\n            depsMap.set(key, (dep = new Set()));\n        }\n        dep.add(activeEffect);\n    }\n}\nfunction trigger(target, key) {\n    const depsMap = targetMap.get(target);\n    if (!depsMap)\n        return;\n    const dep = depsMap.get(key);\n    if (dep) {\n        dep.forEach((fn) => fn());\n    }\n}\n/**\n * Creates a reactive proxy object (Vue-compatible).\n * Now optimized to respect Mulan Cycle.\n */\nfunction reactive(target) {\n    return new Proxy(target, {\n        get(obj, prop, receiver) {\n            // IRON FORTRESS: Prototype Pollution Protection (Read)\n            if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {\n                return undefined;\n            }\n            track(obj, prop);\n            const val = Reflect.get(obj, prop, receiver);\n            if (val !== null && typeof val === 'object') {\n                return reactive(val);\n            }\n            return val;\n        },\n        set(obj, prop, value, receiver) {\n            // IRON FORTRESS: Prototype Pollution Protection\n            if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {\n                console.warn(`[Iron Fortress] Blocked attempt to modify dangerous property: ${String(prop)}`);\n                return false;\n            }\n            const result = Reflect.set(obj, prop, value, receiver);\n            trigger(obj, prop);\n            return result;\n        },\n    });\n}\n/**\n * Creates a standalone reactive reference.\n * Backed by the Mulan Signal Engine.\n */\nfunction ref(value) {\n    return new Signal(value);\n}\n\n\n//# sourceURL=webpack://Mulan/./src/core/reactive.ts?\n}");
 
-/***/ },
 
-/***/ "./src/core/renderer.ts"
-/*!******************************!*\
-  !*** ./src/core/renderer.ts ***!
-  \******************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   hydrate: () => (/* binding */ hydrate),\n/* harmony export */   render: () => (/* binding */ render),\n/* harmony export */   renderToString: () => (/* binding */ renderToString),\n/* harmony export */   sanitize: () => (/* binding */ sanitize)\n/* harmony export */ });\nfunction render(template, container) {\n    // Focus Preservation (The \"Mulan Glance\" Technique)\n    let focusedId = null;\n    let selectionStart = null;\n    let selectionEnd = null;\n    let preservedValue = null;\n    if (document.activeElement && container.contains(document.activeElement)) {\n        const el = document.activeElement;\n        if (el.hasAttribute('data-mu-id')) {\n            focusedId = el.getAttribute('data-mu-id');\n            if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {\n                selectionStart = el.selectionStart;\n                selectionEnd = el.selectionEnd;\n                preservedValue = el.value;\n            }\n        }\n    }\n    // [Anima] 1. Pre-Update: Snapshot positions of animated elements\n    const animationSnapshots = new Map();\n    // Only query if we might have animations to save perf\n    if (template.includes('mu-animate')) {\n        const animatedEls = container.querySelectorAll('[mu-animate]');\n        animatedEls.forEach(el => {\n            const key = el.getAttribute('mu-key') || el.id;\n            if (key) {\n                animationSnapshots.set(key, el.getBoundingClientRect());\n            }\n        });\n    }\n    container.innerHTML = template;\n    // Restore Focus and Value\n    if (focusedId) {\n        const el = container.querySelector(`[data-mu-id=\"${focusedId}\"]`);\n        if (el) {\n            // Restore value first to ensure cursor positioning works correctly\n            if (preservedValue !== null && (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {\n                el.value = preservedValue;\n            }\n            el.focus();\n            if ((el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) && selectionStart !== null) {\n                try {\n                    el.setSelectionRange(selectionStart, selectionEnd);\n                }\n                catch (e) {\n                    // input types that don't support selection (e.g. number/email) might throw\n                }\n            }\n        }\n    }\n    // [Anima] 2. Post-Update: FLIP (First, Last, Invert, Play)\n    if (animationSnapshots.size > 0) {\n        const newAnimatedEls = container.querySelectorAll('[mu-animate]');\n        newAnimatedEls.forEach(el => {\n            const key = el.getAttribute('mu-key') || el.id;\n            if (key && animationSnapshots.has(key)) {\n                const oldRect = animationSnapshots.get(key);\n                const newRect = el.getBoundingClientRect();\n                const dx = oldRect.left - newRect.left;\n                const dy = oldRect.top - newRect.top;\n                // Only animate if moved\n                if (dx !== 0 || dy !== 0) {\n                    const htmlEl = el;\n                    // INVERT: Move it back to where it was instantly\n                    htmlEl.style.transform = `translate(${dx}px, ${dy}px)`;\n                    htmlEl.style.transition = 'none';\n                    // PLAY: Animate to zero (new position)\n                    requestAnimationFrame(() => {\n                        // Force reflow\n                        // void htmlEl.offsetWidth; \n                        htmlEl.style.transition = 'transform 500ms cubic-bezier(0.25, 0.8, 0.25, 1)';\n                        htmlEl.style.transform = '';\n                    });\n                }\n            }\n        });\n    }\n}\nfunction hydrate(template, container) {\n    // In a string-based framework, hydration is often just \"take over\".\n    // For now, we'll verify if the server content matches (simple check)\n    // and then assume control. In a more advanced version, we'd attach listeners without re-rendering.\n    if (container.innerHTML.trim() !== template.trim()) {\n        console.warn('Hydration Mismatch: Server rendered content differs from Client.');\n        container.innerHTML = template; // Fallback to full render\n    }\n    else {\n        // console.log('Hydration Successful.');\n    }\n    // Future: Attach event listeners here if we had a mechanism for it.\n}\nfunction renderToString(template) {\n    // SSR Function: returns the HTML string for the server to send.\n    // Can include additional sanitization or metadata injection here.\n    return template;\n}\nfunction sanitize(str) {\n    // Check if we are in a browser environment\n    if (typeof document !== 'undefined') {\n        const temp = document.createElement('div');\n        temp.textContent = str;\n        return temp.innerHTML;\n    }\n    // Simple SSR fallback sanitizer (rudimentary)\n    return str.replace(/&/g, \"&amp;\")\n        .replace(/</g, \"&lt;\")\n        .replace(/>/g, \"&gt;\")\n        .replace(/\"/g, \"&quot;\")\n        .replace(/'/g, \"&#039;\");\n}\n\n\n//# sourceURL=webpack://Mulan/./src/core/renderer.ts?\n}");
 
-/***/ },
 
-/***/ "./src/core/surge.ts"
-/*!***************************!*\
-  !*** ./src/core/surge.ts ***!
-  \***************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   muBurst: () => (/* binding */ muBurst),\n/* harmony export */   muSurge: () => (/* binding */ muSurge)\n/* harmony export */ });\n/**\n * muBurst - Adaptive Non-blocking Iterator\n * Processes large arrays in batches within a frame budget (typically 8-16ms)\n * to keep the UI responsive while executing at near-native loop speeds.\n */\nfunction muBurst(array, callback, options = {}) {\n    const { chunkSize = 1000, timeout = 8, onProgress } = options;\n    return new Promise((resolve) => {\n        let index = 0;\n        const total = array.length;\n        function process() {\n            const start = performance.now();\n            // Tight loop for high-speed processing\n            while (index < total && (performance.now() - start) < timeout) {\n                // Process in smaller bursts to allow more frequent time checks if needed\n                const endBurst = Math.min(index + chunkSize, total);\n                for (; index < endBurst; index++) {\n                    callback(array[index], index);\n                }\n            }\n            if (onProgress) {\n                onProgress((index / total) * 100);\n            }\n            if (index < total) {\n                requestAnimationFrame(process);\n            }\n            else {\n                resolve();\n            }\n        }\n        process();\n    });\n}\n/**\n * muSurge - Truly Parallel Execution\n * Distributes work across CPU cores using Web Workers.\n * Logic must be serializable.\n */\nfunction muSurge(array, taskFn, onProgress) {\n    const n = navigator.hardwareConcurrency || 4;\n    const chunkSize = Math.ceil(array.length / n);\n    const results = new Array(array.length);\n    let completedChunks = 0;\n    let completedItems = 0;\n    // Convert function to string if it isn't already\n    const fnStr = typeof taskFn === 'function' ? taskFn.toString() : taskFn;\n    const workerCode = `\r\n        const taskFn = ${fnStr};\r\n        self.onmessage = function(e) {\r\n            const { chunk, startIndex } = e.data;\r\n            try {\r\n                const results = chunk.map(taskFn);\r\n                self.postMessage({ results, startIndex });\r\n            } catch (err) {\r\n                self.postMessage({ error: err.message, startIndex });\r\n            }\r\n        };\r\n    `;\n    const blob = new Blob([workerCode], { type: 'application/javascript' });\n    const workerUrl = URL.createObjectURL(blob);\n    return new Promise((resolve) => {\n        if (array.length === 0)\n            return resolve([]);\n        for (let i = 0; i < n; i++) {\n            const start = i * chunkSize;\n            const end = Math.min(start + chunkSize, array.length);\n            if (start >= end) {\n                completedChunks++;\n                continue;\n            }\n            const chunk = array.slice(start, end);\n            const worker = new Worker(workerUrl);\n            worker.onmessage = (e) => {\n                const { results: chunkResults, startIndex } = e.data;\n                // Merge results back into main array\n                for (let j = 0; j < chunkResults.length; j++) {\n                    results[startIndex + j] = chunkResults[j];\n                }\n                completedChunks++;\n                completedItems += chunkResults.length;\n                if (onProgress)\n                    onProgress((completedItems / array.length) * 100);\n                worker.terminate();\n                if (completedChunks === n) {\n                    URL.revokeObjectURL(workerUrl);\n                    resolve(results);\n                }\n            };\n            worker.postMessage({ chunk, startIndex: start, fnStr });\n        }\n    });\n}\n\n\n//# sourceURL=webpack://Mulan/./src/core/surge.ts?\n}");
 
-/***/ },
 
-/***/ "./src/core/vault.ts"
-/*!***************************!*\
-  !*** ./src/core/vault.ts ***!
-  \***************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   persistent: () => (/* binding */ persistent)\n/* harmony export */ });\n/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hooks */ \"./src/core/hooks.ts\");\n/* harmony import */ var _reactive__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./reactive */ \"./src/core/reactive.ts\");\n\n\n/**\n * Mulan Vault: The World's First Native Persistent State Primitive.\n */\nfunction persistent(key, initialValue, options = {}) {\n    const storage = options.storage || window.localStorage;\n    // 1. Load from Storage\n    const stored = storage.getItem(key);\n    let startVal = initialValue;\n    if (stored) {\n        try {\n            startVal = JSON.parse(stored);\n        }\n        catch (e) {\n            console.warn(`[Mulan Vault] Corrupt persistent data for key \"${key}\", resetting.`);\n        }\n    }\n    // 2. Create Reactive State (Follow muState pattern for consistency)\n    const isObject = typeof startVal === 'object' && startVal !== null;\n    const state = isObject ? (0,_reactive__WEBPACK_IMPORTED_MODULE_1__.reactive)(startVal) : (0,_reactive__WEBPACK_IMPORTED_MODULE_1__.reactive)({ value: startVal });\n    // 3. Auto-Save on Change\n    (0,_hooks__WEBPACK_IMPORTED_MODULE_0__.muEffect)(() => {\n        try {\n            const payload = isObject ? state : state.value;\n            const toSave = JSON.stringify(payload);\n            // Non-obfuscated persistence to satisfy security audits\n            storage.setItem(key, toSave);\n        }\n        catch (e) {\n            console.error(`[Mulan Vault] Failed to save key \"${key}\"`);\n        }\n    });\n    // 4. Sync across Tabs\n    const sync = (e) => {\n        if (e.key === key && e.newValue) {\n            try {\n                const newVal = JSON.parse(e.newValue);\n                if (isObject) {\n                    Object.assign(state, newVal);\n                }\n                else {\n                    state.value = newVal;\n                }\n            }\n            catch (e) { }\n        }\n    };\n    window.addEventListener('storage', sync);\n    // Auto-cleanup if used inside a component\n    try {\n        const { onMuDestroy } = __webpack_require__(/*! ./hooks */ \"./src/core/hooks.ts\");\n        onMuDestroy(() => {\n            window.removeEventListener('storage', sync);\n        });\n    }\n    catch (e) {\n        // muVault might be used outside component setup in some advanced cases, \n        // fallback to manual or no-cleanup if so.\n    }\n    return state;\n}\n\n\n//# sourceURL=webpack://Mulan/./src/core/vault.ts?\n}");
 
-/***/ },
 
-/***/ "./src/index.ts"
-/*!**********************!*\
-  !*** ./src/index.ts ***!
-  \**********************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   Component: () => (/* reexport safe */ _core_component__WEBPACK_IMPORTED_MODULE_1__.MuComponent),\n/* harmony export */   MuBlochSphereElement: () => (/* reexport safe */ _components_bloch_sphere__WEBPACK_IMPORTED_MODULE_11__.MuBlochSphereElement),\n/* harmony export */   MuComponent: () => (/* reexport safe */ _core_component__WEBPACK_IMPORTED_MODULE_1__.MuComponent),\n/* harmony export */   MuInfinity: () => (/* reexport safe */ _components_infinity_list__WEBPACK_IMPORTED_MODULE_12__.MuInfinity),\n/* harmony export */   MuRouter: () => (/* reexport safe */ _router_index__WEBPACK_IMPORTED_MODULE_3__.MuRouter),\n/* harmony export */   MuStore: () => (/* reexport safe */ _store_index__WEBPACK_IMPORTED_MODULE_4__.MuStore),\n/* harmony export */   Router: () => (/* reexport safe */ _router_index__WEBPACK_IMPORTED_MODULE_3__.MuRouter),\n/* harmony export */   Security: () => (/* reexport safe */ _security_sanitizer__WEBPACK_IMPORTED_MODULE_5__.Security),\n/* harmony export */   Signal: () => (/* reexport safe */ _core_reactive__WEBPACK_IMPORTED_MODULE_0__.Signal),\n/* harmony export */   activeControls: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.activeControls),\n/* harmony export */   \"default\": () => (__WEBPACK_DEFAULT_EXPORT__),\n/* harmony export */   defineComponent: () => (/* reexport safe */ _core_component__WEBPACK_IMPORTED_MODULE_1__.defineComponent),\n/* harmony export */   effect: () => (/* reexport safe */ _core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect),\n/* harmony export */   getCurrentInstance: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.getCurrentInstance),\n/* harmony export */   hydrate: () => (/* reexport safe */ _core_renderer__WEBPACK_IMPORTED_MODULE_2__.hydrate),\n/* harmony export */   muBurst: () => (/* reexport safe */ _core_surge__WEBPACK_IMPORTED_MODULE_10__.muBurst),\n/* harmony export */   muControl: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muControl),\n/* harmony export */   muEffect: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muEffect),\n/* harmony export */   muEntangle: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muEntangle),\n/* harmony export */   muGate: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muGate),\n/* harmony export */   muGeom: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muGeom),\n/* harmony export */   muMeasure: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muMeasure),\n/* harmony export */   muMemo: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muMemo),\n/* harmony export */   muParallel: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muParallel),\n/* harmony export */   muPulse: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muPulse),\n/* harmony export */   muQubit: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muQubit),\n/* harmony export */   muRegister: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muRegister),\n/* harmony export */   muSearch: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muSearch),\n/* harmony export */   muState: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muState),\n/* harmony export */   muSurge: () => (/* reexport safe */ _core_surge__WEBPACK_IMPORTED_MODULE_10__.muSurge),\n/* harmony export */   muSwitch: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muSwitch),\n/* harmony export */   muTeleport: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muTeleport),\n/* harmony export */   muVault: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muVault),\n/* harmony export */   onMuDestroy: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuDestroy),\n/* harmony export */   onMuIdle: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuIdle),\n/* harmony export */   onMuInit: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuInit),\n/* harmony export */   onMuMount: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuMount),\n/* harmony export */   onMuResume: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuResume),\n/* harmony export */   onMuShake: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuShake),\n/* harmony export */   onMuVoice: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuVoice),\n/* harmony export */   persistent: () => (/* reexport safe */ _core_vault__WEBPACK_IMPORTED_MODULE_8__.persistent),\n/* harmony export */   reactive: () => (/* reexport safe */ _core_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive),\n/* harmony export */   ref: () => (/* reexport safe */ _core_reactive__WEBPACK_IMPORTED_MODULE_0__.ref),\n/* harmony export */   render: () => (/* reexport safe */ _core_renderer__WEBPACK_IMPORTED_MODULE_2__.render),\n/* harmony export */   renderToString: () => (/* reexport safe */ _core_renderer__WEBPACK_IMPORTED_MODULE_2__.renderToString),\n/* harmony export */   sanitize: () => (/* reexport safe */ _core_renderer__WEBPACK_IMPORTED_MODULE_2__.sanitize),\n/* harmony export */   setCurrentInstance: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.setCurrentInstance),\n/* harmony export */   useMutation: () => (/* reexport safe */ _core_query__WEBPACK_IMPORTED_MODULE_7__.useMutation),\n/* harmony export */   useQuery: () => (/* reexport safe */ _core_query__WEBPACK_IMPORTED_MODULE_7__.useQuery)\n/* harmony export */ });\n/* harmony import */ var _core_reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./core/reactive */ \"./src/core/reactive.ts\");\n/* harmony import */ var _core_component__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./core/component */ \"./src/core/component.ts\");\n/* harmony import */ var _core_renderer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./core/renderer */ \"./src/core/renderer.ts\");\n/* harmony import */ var _router_index__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./router/index */ \"./src/router/index.ts\");\n/* harmony import */ var _store_index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./store/index */ \"./src/store/index.ts\");\n/* harmony import */ var _security_sanitizer__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./security/sanitizer */ \"./src/security/sanitizer.ts\");\n/* harmony import */ var _core_hooks__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./core/hooks */ \"./src/core/hooks.ts\");\n/* harmony import */ var _core_query__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./core/query */ \"./src/core/query.ts\");\n/* harmony import */ var _core_vault__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./core/vault */ \"./src/core/vault.ts\");\n/* harmony import */ var _core_quantum__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./core/quantum */ \"./src/core/quantum.ts\");\n/* harmony import */ var _core_surge__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./core/surge */ \"./src/core/surge.ts\");\n/* harmony import */ var _components_bloch_sphere__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./components/bloch-sphere */ \"./src/components/bloch-sphere.ts\");\n/* harmony import */ var _components_infinity_list__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./components/infinity-list */ \"./src/components/infinity-list.ts\");\n\n\n\n\n\n\n\n\n\n\n\n\n\n// Global Mulan Object for non-module usage\n\n\n\n\n\n\n\n\n\n\n\nconst Mulan = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ reactive: _core_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive,\n    effect: _core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect, Component: _core_component__WEBPACK_IMPORTED_MODULE_1__.MuComponent, defineComponent: _core_component__WEBPACK_IMPORTED_MODULE_1__.defineComponent, Router: _router_index__WEBPACK_IMPORTED_MODULE_3__.MuRouter, createRouter: _router_index__WEBPACK_IMPORTED_MODULE_3__.createRouter, Store: _store_index__WEBPACK_IMPORTED_MODULE_4__.MuStore, Security: _security_sanitizer__WEBPACK_IMPORTED_MODULE_5__.Security }, _core_hooks__WEBPACK_IMPORTED_MODULE_6__), _core_query__WEBPACK_IMPORTED_MODULE_7__), _core_quantum__WEBPACK_IMPORTED_MODULE_9__), _core_surge__WEBPACK_IMPORTED_MODULE_10__), _components_infinity_list__WEBPACK_IMPORTED_MODULE_12__), { render: _core_renderer__WEBPACK_IMPORTED_MODULE_2__.render, \n    // MULAN INSIGHT: Branded Logging\n    log: (msg, ...args) => {\n        console.log(`%c[MulanJS]%c ${msg}`, \"color: #ff3e00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;\", \"\", ...args);\n    }, warn: (msg, ...args) => {\n        console.warn(`%c[MulanJS]%c ${msg}`, \"color: #ffcc00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;\", \"\", ...args);\n    }, error: (msg, ...args) => {\n        console.error(`%c[MulanJS]%c ${msg}`, \"color: #ff0000; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;\", \"\", ...args);\n    } });\n// Security: Freeze the object to prevent runtime tampering\nObject.freeze(Mulan);\nObject.freeze(Mulan.Security);\n// MULAN INSIGHT: Initialize Global Registry\nif (typeof window !== 'undefined') {\n    window.__MULAN_INSIGHT__ = window.__MULAN_INSIGHT__ || { components: new Map() };\n    // MULAN INSIGHT: HMR Support\n    window.__MULAN_REFRESH__ = () => {\n        var _a;\n        const components = (_a = window.__MULAN_INSIGHT__) === null || _a === void 0 ? void 0 : _a.components;\n        if (components) {\n            components.forEach((comp) => {\n                if (comp && typeof comp.update === 'function') {\n                    // Force refresh\n                    comp.update();\n                }\n            });\n        }\n    };\n}\nif (typeof window !== 'undefined') {\n    window.Mulan = Mulan;\n}\n/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Mulan);\n\n\n//# sourceURL=webpack://Mulan/./src/index.ts?\n}");
+// Global Mulan Object for non-module usage
 
-/***/ },
 
-/***/ "./src/router/index.ts"
-/*!*****************************!*\
-  !*** ./src/router/index.ts ***!
-  \*****************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   MuRouter: () => (/* binding */ MuRouter),\n/* harmony export */   createRouter: () => (/* binding */ createRouter)\n/* harmony export */ });\n/* harmony import */ var _core_renderer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/renderer */ \"./src/core/renderer.ts\");\n/* harmony import */ var _security_sanitizer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../security/sanitizer */ \"./src/security/sanitizer.ts\");\nvar __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\n\n\nclass MuRouter {\n    constructor(routes, rootContainer = null) {\n        this.currentPath = '';\n        this.currentComponent = null;\n        this.lastRouteId = 0;\n        this.routes = routes;\n        this.rootContainer = rootContainer;\n        this.isServer = rootContainer === null; // If no container, assume server/headless mode\n        if (!this.isServer) {\n            window.addEventListener('hashchange', this.handleRoute.bind(this));\n            this.handleRoute(); // Initial load\n        }\n    }\n    // SSR Method: Simulate a route visit on the server\n    serverLookup(path) {\n        return __awaiter(this, void 0, void 0, function* () {\n            this.currentPath = path;\n            const { route, params } = this.matchRoute(path);\n            if (route) {\n                // Run guards/resolvers here if needed\n                let componentToRender = route.component;\n                // Support Lazy Loading\n                if (typeof componentToRender === 'function' && !componentToRender.prototype) {\n                    const module = yield componentToRender();\n                    componentToRender = module.default || module;\n                }\n                if (typeof componentToRender === 'function') {\n                    // Class component SSR\n                    // We need a dummy container for the component to \"render\" into its own buffer\n                    // For simplicity in this string-based framework, we mock the container\n                    const mockContainer = { innerHTML: '' };\n                    const instance = new componentToRender(mockContainer);\n                    if (instance.setParams)\n                        instance.setParams(params);\n                    // Manually trigger mount logic without DOM effects if possible, or just template()\n                    // Ideally, we just want the template string.\n                    return instance.template();\n                }\n                else {\n                    return componentToRender;\n                }\n            }\n            return '<!-- 404 -->';\n        });\n    }\n    matchRoute(hash) {\n        // Simple exact match first\n        let route = this.routes.find((r) => r.path === hash);\n        if (route)\n            return { route, params: {} };\n        // Regex match for params e.g. /user/:id\n        for (const r of this.routes) {\n            const paramNames = [];\n            const regexPath = r.path.replace(/:([^/]+)/g, (_, key) => {\n                paramNames.push(key);\n                return '([^/]+)';\n            });\n            const match = new RegExp(`^${regexPath}$`).exec(hash);\n            if (match) {\n                const params = {};\n                paramNames.forEach((name, i) => {\n                    // SECURE: Automatically sanitize all route parameters\n                    params[name] = _security_sanitizer__WEBPACK_IMPORTED_MODULE_1__.Security.sanitize(match[i + 1]);\n                });\n                return { route: r, params };\n            }\n        }\n        return { route: undefined, params: {} };\n    }\n    handleRoute() {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (this.isServer)\n                return;\n            const currentRouteId = ++this.lastRouteId;\n            const hash = window.location.hash.slice(1) || '/';\n            const { route, params } = this.matchRoute(hash);\n            // Security Check: Validate URL to prevent malicious hash injection\n            if (hash !== '/' && !_security_sanitizer__WEBPACK_IMPORTED_MODULE_1__.Security.validateUrl('http://dummy.com' + hash)) {\n                console.error(\"Security Alert: Malformed URL detected.\");\n                return;\n            }\n            // Navigation Guard (Middleware)\n            if (route === null || route === void 0 ? void 0 : route.beforeEnter) {\n                yield new Promise((resolve) => {\n                    route.beforeEnter(hash, this.currentPath, (allow) => {\n                        if (allow)\n                            resolve();\n                        else {\n                            console.warn(`Navigation to ${hash} blocked by guard.`);\n                            // Ideally redirect or stay, here we just stop processing\n                            throw new Error('Navigation Blocked');\n                        }\n                    });\n                }).catch(() => { return; }); // Stop execution if blocked\n            }\n            this.currentPath = hash;\n            if (route) {\n                if (route.title) {\n                    document.title = route.title;\n                }\n                else if (route.meta && route.meta.title) {\n                    // Fallback to meta.title if used\n                    document.title = route.meta.title;\n                }\n                if (this.rootContainer) {\n                    // Mulan Cycle: Destroy previous component before rendering new one\n                    if (this.currentComponent) {\n                        console.log(`[Router] Navigation from ${this.currentPath} to ${hash}. Destroying previous component.`);\n                        if (this.currentComponent.onDestroy) {\n                            this.currentComponent.onDestroy();\n                        }\n                    }\n                    this.rootContainer.innerHTML = ''; // Clear previous content\n                }\n                let componentToRender = route.component;\n                // Support Lazy Loading\n                if (typeof componentToRender === 'function' && !componentToRender.prototype) {\n                    try {\n                        const module = yield componentToRender();\n                        if (currentRouteId !== this.lastRouteId) {\n                            console.log(`[Router] Navigation to ${hash} interrupted by newer navigation. Abandoning.`);\n                            return;\n                        }\n                        componentToRender = module.default || module;\n                    }\n                    catch (e) {\n                        console.error(\"Failed to lazy load component\", e);\n                        return;\n                    }\n                }\n                if (typeof componentToRender === 'function') {\n                    // It's a class component\n                    if (this.rootContainer) {\n                        const instance = new componentToRender(this.rootContainer);\n                        this.currentComponent = instance;\n                        // Inject params if the component accepts them\n                        if (instance.setParams) {\n                            instance.setParams(params);\n                        }\n                        instance.mount();\n                    }\n                }\n                else if (typeof componentToRender === 'object' && componentToRender.template) {\n                    // Object Component (Simple SFC without script or Options API)\n                    const html = componentToRender.template();\n                    if (this.rootContainer)\n                        (0,_core_renderer__WEBPACK_IMPORTED_MODULE_0__.render)(html, this.rootContainer);\n                    this.currentComponent = null;\n                }\n                else {\n                    // Simple HTML string/template\n                    if (this.rootContainer)\n                        (0,_core_renderer__WEBPACK_IMPORTED_MODULE_0__.render)(componentToRender, this.rootContainer);\n                    this.currentComponent = null; // String templates don't have lifecycle instances\n                }\n            }\n            else {\n                if (this.rootContainer)\n                    (0,_core_renderer__WEBPACK_IMPORTED_MODULE_0__.render)('<div style=\"text-align:center; padding:50px;\"><h1>404</h1><p>Page Not Found</p></div>', this.rootContainer);\n            }\n        });\n    }\n    // [Chronos] Prefetch a route's component code in the background\n    prefetch(path) {\n        return __awaiter(this, void 0, void 0, function* () {\n            if (this.isServer)\n                return;\n            const { route } = this.matchRoute(path);\n            if (route) {\n                let componentToRender = route.component;\n                // Check if it's a lazy-loaded function that hasn't been resolved yet\n                if (typeof componentToRender === 'function' && !componentToRender.prototype) {\n                    // If it's already a resolved module (from previous prefetch), componentToRender might be the result.\n                    // But typically in our simple implementation, route.component stays as the function until we replace it.\n                    // To avoid double-fetching, we can check if it has a specific flag or property. \n                    // For this implementation, we'll just run it and let the browser cache the module request (standard ES Module behavior).\n                    try {\n                        // console.log(`[Chronos] Prefetching ${path}...`);\n                        yield componentToRender();\n                        // We don't need to do anything with the result here. \n                        // The browser's module cache will handle the speedup when the user actually navigates.\n                    }\n                    catch (e) {\n                        console.warn(`[Chronos] Failed to prefetch ${path}`, e);\n                    }\n                }\n            }\n        });\n    }\n    navigate(path) {\n        if (this.isServer) {\n            this.currentPath = path;\n        }\n        else {\n            window.location.hash = path;\n        }\n    }\n}\n// --- Factory for Easy Usage ---\nconst createRouter = (options) => {\n    // Expose the router instance globally for <mu-link> to access\n    const router = new MuRouter(options.routes, options.rootContainer);\n    if (typeof window !== 'undefined') {\n        window.__MULAN_ROUTER__ = router;\n    }\n    return router;\n};\n// --- Web Component: <mu-link> ---\n// Usage: <mu-link to=\"/about\">About Us</mu-link>\nif (typeof window !== 'undefined' && !customElements.get('mu-link')) {\n    class MuLink extends HTMLElement {\n        constructor() {\n            super();\n            this.addEventListener('click', (e) => {\n                e.preventDefault();\n                const to = this.getAttribute('to');\n                if (to) {\n                    // Update Hash for SPA Navigation\n                    window.location.hash = to;\n                }\n            });\n            // [Chronos] Intelligent Pre-fetching\n            this.addEventListener('mouseenter', () => {\n                const to = this.getAttribute('to');\n                if (to) {\n                    const router = window.__MULAN_ROUTER__;\n                    if (router && typeof router.prefetch === 'function') {\n                        router.prefetch(to);\n                    }\n                }\n            });\n            // [Chronos] Also prefetch on focus for keyboard users\n            this.addEventListener('focus', () => {\n                const to = this.getAttribute('to');\n                if (to) {\n                    const router = window.__MULAN_ROUTER__;\n                    if (router && typeof router.prefetch === 'function') {\n                        router.prefetch(to);\n                    }\n                }\n            });\n        }\n        connectedCallback() {\n            this.style.cursor = 'pointer';\n            this.style.color = 'var(--primary, #9C27B0)'; // Default to brand color if available\n            this.style.textDecoration = 'none';\n        }\n        static get observedAttributes() { return ['to']; }\n    }\n    customElements.define('mu-link', MuLink);\n}\n\n\n//# sourceURL=webpack://Mulan/./src/router/index.ts?\n}");
 
-/***/ },
 
-/***/ "./src/security/sanitizer.ts"
-/*!***********************************!*\
-  !*** ./src/security/sanitizer.ts ***!
-  \***********************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   Security: () => (/* binding */ Security)\n/* harmony export */ });\nclass Security {\n    /**\n     * IRON FORTRESS PROTOCOL\n     * Strictly escapes all HTML entities to prevent XSS.\n     * Use `mu-raw` attribute in templates to bypass this for trusted content.\n     */\n    static sanitize(input) {\n        // 1. Basic entity encoding\n        let secure = input\n            .replace(/&/g, \"&amp;\")\n            .replace(/</g, \"&lt;\")\n            .replace(/>/g, \"&gt;\")\n            .replace(/\"/g, \"&quot;\")\n            .replace(/'/g, \"&#039;\");\n        // 2. Remove dangerous events (extra layer if encoding fails)\n        const dangerousEvents = ['onload', 'onclick', 'onerror', 'onmouseover', 'onfocus'];\n        dangerousEvents.forEach(event => {\n            const regex = new RegExp(event, 'gi');\n            secure = secure.replace(regex, 'data-blocked-' + event);\n        });\n        return secure;\n    }\n    /**\n     * Generates a strict Content Security Policy header value.\n     * @param options Configuration for allowed sources\n     */\n    static generateCSP(options = {}) {\n        const scriptSrc = [\"'self'\", ...(options.scriptSrc || [])].join(\" \");\n        const styleSrc = [\"'self'\", \"'unsafe-inline'\", ...(options.styleSrc || [])].join(\" \");\n        return `default-src 'self'; script-src ${scriptSrc}; style-src ${styleSrc}; object-src 'none'; base-uri 'self';`;\n    }\n    static validateUrl(url) {\n        // Basic URL validation\n        const pattern = new RegExp('^(https?:\\\\/\\\\/)?' + // protocol\n            '((([a-z\\\\d]([a-z\\\\d-]*[a-z\\\\d])*)\\\\.)+[a-z]{2,}|' + // domain name\n            '((\\\\d{1,3}\\\\.){3}\\\\d{1,3}))' + // OR ip (v4) address\n            '(\\\\:\\\\d+)?(\\\\/[-a-z\\\\d%_.~+]*)*' + // port and path\n            '(\\\\?[;&a-z\\\\d%_.~+=-]*)?' + // query string\n            '(\\\\#[-a-z\\\\d_]*)?$', 'i'); // fragment locator\n        return !!pattern.test(url);\n    }\n    /**\n     * Prevents XSS by sanitizing common input fields on blur.\n     * Can be used as a utility in forms.\n     */\n    static preventXSS(inputElement) {\n        inputElement.addEventListener('blur', (e) => {\n            const target = e.target;\n            target.value = Security.sanitize(target.value);\n        });\n    }\n}\n\n\n//# sourceURL=webpack://Mulan/./src/security/sanitizer.ts?\n}");
 
-/***/ },
 
-/***/ "./src/store/index.ts"
-/*!****************************!*\
-  !*** ./src/store/index.ts ***!
-  \****************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-eval("{__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   MuStore: () => (/* binding */ MuStore)\n/* harmony export */ });\n/* harmony import */ var _core_reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/reactive */ \"./src/core/reactive.ts\");\n\nclass MuStore {\n    constructor(initialState, options) {\n        this.subscribers = [];\n        // Load from local storage if persist is true\n        let loadedState = initialState;\n        if (options === null || options === void 0 ? void 0 : options.persist) {\n            const key = options.key || 'mulan-store';\n            try {\n                const stored = localStorage.getItem(key);\n                if (stored) {\n                    loadedState = Object.assign(Object.assign({}, initialState), JSON.parse(stored));\n                }\n            }\n            catch (e) {\n                console.error(\"Failed to load state\", e);\n            }\n            // Auto-save effect\n            (0,_core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {\n                localStorage.setItem(key, JSON.stringify(this.state));\n            });\n        }\n        this.state = (0,_core_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)(loadedState);\n    }\n    // Subscribe to changes\n    subscribe(fn) {\n        this.subscribers.push(fn);\n        (0,_core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {\n            fn(this.state);\n        });\n    }\n    // Action dispatcher pattern\n    dispatch(action) {\n        const result = action(this.state);\n        if (result instanceof Promise) {\n            result.then(() => {\n                // Optional: Notify subscribers of async completion if needed manually?\n                // But reactive() handles updates automatically.\n            });\n        }\n    }\n}\n\n\n//# sourceURL=webpack://Mulan/./src/store/index.ts?\n}");
 
-/***/ }
 
-/******/ 	});
-/************************************************************************/
-/******/ 	// The module cache
-/******/ 	var __webpack_module_cache__ = {};
-/******/ 	
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/ 		// Check if module is in cache
-/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
-/******/ 		if (cachedModule !== undefined) {
-/******/ 			return cachedModule.exports;
-/******/ 		}
-/******/ 		// Check if module exists (development only)
-/******/ 		if (__webpack_modules__[moduleId] === undefined) {
-/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
-/******/ 			e.code = 'MODULE_NOT_FOUND';
-/******/ 			throw e;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = __webpack_module_cache__[moduleId] = {
-/******/ 			// no module.id needed
-/******/ 			// no module.loaded needed
-/******/ 			exports: {}
-/******/ 		};
-/******/ 	
-/******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-/******/ 	
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/ 	
-/************************************************************************/
-/******/ 	/* webpack/runtime/define property getters */
-/******/ 	(() => {
-/******/ 		// define getter functions for harmony exports
-/******/ 		__webpack_require__.d = (exports, definition) => {
-/******/ 			for(var key in definition) {
-/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
-/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
-/******/ 				}
-/******/ 			}
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
-/******/ 	(() => {
-/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
-/******/ 	})();
-/******/ 	
-/******/ 	/* webpack/runtime/make namespace object */
-/******/ 	(() => {
-/******/ 		// define __esModule on exports
-/******/ 		__webpack_require__.r = (exports) => {
-/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 			}
-/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 		};
-/******/ 	})();
-/******/ 	
-/************************************************************************/
-/******/ 	
-/******/ 	// startup
-/******/ 	// Load entry module and return exports
-/******/ 	// This entry module can't be inlined because the eval devtool is used.
-/******/ 	var __webpack_exports__ = __webpack_require__("./src/index.ts");
-/******/ 	__webpack_exports__ = __webpack_exports__["default"];
-/******/ 	
+const Mulan = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ reactive: reactive,
+    effect: effect, Component: MuComponent, defineComponent: defineComponent, Router: MuRouter, createRouter: createRouter, Store: MuStore, Security: Security }, hooks_namespaceObject), query_namespaceObject), quantum_namespaceObject), surge_namespaceObject), infinity_list_namespaceObject), { render: render, 
+    // MULAN INSIGHT: Branded Logging
+    log: (msg, ...args) => {
+        console.log(`%c[MulanJS]%c ${msg}`, "color: #ff3e00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
+    }, warn: (msg, ...args) => {
+        console.warn(`%c[MulanJS]%c ${msg}`, "color: #ffcc00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
+    }, error: (msg, ...args) => {
+        console.error(`%c[MulanJS]%c ${msg}`, "color: #ff0000; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
+    } });
+// Security: Freeze the object to prevent runtime tampering
+Object.freeze(Mulan);
+Object.freeze(Mulan.Security);
+// MULAN INSIGHT: Initialize Global Registry
+if (typeof window !== 'undefined') {
+    window.__MULAN_INSIGHT__ = window.__MULAN_INSIGHT__ || { components: new Map() };
+    // MULAN INSIGHT: HMR Support
+    window.__MULAN_REFRESH__ = () => {
+        var _a;
+        const components = (_a = window.__MULAN_INSIGHT__) === null || _a === void 0 ? void 0 : _a.components;
+        if (components) {
+            components.forEach((comp) => {
+                if (comp && typeof comp.update === 'function') {
+                    // Force refresh
+                    comp.update();
+                }
+            });
+        }
+    };
+}
+if (typeof window !== 'undefined') {
+    window.Mulan = Mulan;
+}
+/* harmony default export */ const src = (Mulan);
+
+__webpack_exports__ = __webpack_exports__["default"];
 /******/ 	return __webpack_exports__;
 /******/ })()
 ;
-});
+});
+//# sourceMappingURL=mulan.js.map