@shellui/core 0.0.18 → 0.0.20

package/src/dist/WindowsLayout.08724167.js

@@ -0,0 +1,1762 @@
+// modules are defined as an array
+// [ module function, map of requires ]
+//
+// map of requires is short require name -> numeric require
+//
+// anything defined in a previous bundle is accessed via the
+// orig method which is the require for previous bundles
+
+(function (
+  modules,
+  entry,
+  mainEntry,
+  parcelRequireName,
+  externals,
+  distDir,
+  publicUrl,
+  devServer
+) {
+  /* eslint-disable no-undef */
+  var globalObject =
+    typeof globalThis !== 'undefined'
+      ? globalThis
+      : typeof self !== 'undefined'
+      ? self
+      : typeof window !== 'undefined'
+      ? window
+      : typeof global !== 'undefined'
+      ? global
+      : {};
+  /* eslint-enable no-undef */
+
+  // Save the require from previous bundle to this closure if any
+  var previousRequire =
+    typeof globalObject[parcelRequireName] === 'function' &&
+    globalObject[parcelRequireName];
+
+  var importMap = previousRequire.i || {};
+  var cache = previousRequire.cache || {};
+  // Do not use `require` to prevent Webpack from trying to bundle this call
+  var nodeRequire =
+    typeof module !== 'undefined' &&
+    typeof module.require === 'function' &&
+    module.require.bind(module);
+
+  function newRequire(name, jumped) {
+    if (!cache[name]) {
+      if (!modules[name]) {
+        if (externals[name]) {
+          return externals[name];
+        }
+        // if we cannot find the module within our internal map or
+        // cache jump to the current global require ie. the last bundle
+        // that was added to the page.
+        var currentRequire =
+          typeof globalObject[parcelRequireName] === 'function' &&
+          globalObject[parcelRequireName];
+        if (!jumped && currentRequire) {
+          return currentRequire(name, true);
+        }
+
+        // If there are other bundles on this page the require from the
+        // previous one is saved to 'previousRequire'. Repeat this as
+        // many times as there are bundles until the module is found or
+        // we exhaust the require chain.
+        if (previousRequire) {
+          return previousRequire(name, true);
+        }
+
+        // Try the node require function if it exists.
+        if (nodeRequire && typeof name === 'string') {
+          return nodeRequire(name);
+        }
+
+        var err = new Error("Cannot find module '" + name + "'");
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+      }
+
+      localRequire.resolve = resolve;
+      localRequire.cache = {};
+
+      var module = (cache[name] = new newRequire.Module(name));
+
+      modules[name][0].call(
+        module.exports,
+        localRequire,
+        module,
+        module.exports,
+        globalObject
+      );
+    }
+
+    return cache[name].exports;
+
+    function localRequire(x) {
+      var res = localRequire.resolve(x);
+      if (res === false) {
+        return {};
+      }
+      // Synthesize a module to follow re-exports.
+      if (Array.isArray(res)) {
+        var m = {__esModule: true};
+        res.forEach(function (v) {
+          var key = v[0];
+          var id = v[1];
+          var exp = v[2] || v[0];
+          var x = newRequire(id);
+          if (key === '*') {
+            Object.keys(x).forEach(function (key) {
+              if (
+                key === 'default' ||
+                key === '__esModule' ||
+                Object.prototype.hasOwnProperty.call(m, key)
+              ) {
+                return;
+              }
+
+              Object.defineProperty(m, key, {
+                enumerable: true,
+                get: function () {
+                  return x[key];
+                },
+              });
+            });
+          } else if (exp === '*') {
+            Object.defineProperty(m, key, {
+              enumerable: true,
+              value: x,
+            });
+          } else {
+            Object.defineProperty(m, key, {
+              enumerable: true,
+              get: function () {
+                if (exp === 'default') {
+                  return x.__esModule ? x.default : x;
+                }
+                return x[exp];
+              },
+            });
+          }
+        });
+        return m;
+      }
+      return newRequire(res);
+    }
+
+    function resolve(x) {
+      var id = modules[name][1][x];
+      return id != null ? id : x;
+    }
+  }
+
+  function Module(moduleName) {
+    this.id = moduleName;
+    this.bundle = newRequire;
+    this.require = nodeRequire;
+    this.exports = {};
+  }
+
+  newRequire.isParcelRequire = true;
+  newRequire.Module = Module;
+  newRequire.modules = modules;
+  newRequire.cache = cache;
+  newRequire.parent = previousRequire;
+  newRequire.distDir = distDir;
+  newRequire.publicUrl = publicUrl;
+  newRequire.devServer = devServer;
+  newRequire.i = importMap;
+  newRequire.register = function (id, exports) {
+    modules[id] = [
+      function (require, module) {
+        module.exports = exports;
+      },
+      {},
+    ];
+  };
+
+  // Only insert newRequire.load when it is actually used.
+  // The code in this file is linted against ES5, so dynamic import is not allowed.
+  // INSERT_LOAD_HERE
+
+  Object.defineProperty(newRequire, 'root', {
+    get: function () {
+      return globalObject[parcelRequireName];
+    },
+  });
+
+  globalObject[parcelRequireName] = newRequire;
+
+  for (var i = 0; i < entry.length; i++) {
+    newRequire(entry[i]);
+  }
+
+  if (mainEntry) {
+    // Expose entry point to Node, AMD or browser globals
+    // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
+    var mainExports = newRequire(mainEntry);
+
+    // CommonJS
+    if (typeof exports === 'object' && typeof module !== 'undefined') {
+      module.exports = mainExports;
+
+      // RequireJS
+    } else if (typeof define === 'function' && define.amd) {
+      define(function () {
+        return mainExports;
+      });
+    }
+  }
+})({"bpbKD":[function(require,module,exports,__globalThis) {
+var global = arguments[3];
+var HMR_HOST = "localhost";
+var HMR_PORT = null;
+var HMR_SERVER_PORT = 4000;
+var HMR_SECURE = false;
+var HMR_ENV_HASH = "439701173a9199ea";
+var HMR_USE_SSE = false;
+module.bundle.HMR_BUNDLE_ID = "254ea4fd08724167";
+"use strict";
+/* global HMR_HOST, HMR_PORT, HMR_SERVER_PORT, HMR_ENV_HASH, HMR_SECURE, HMR_USE_SSE, chrome, browser, __parcel__import__, __parcel__importScripts__, ServiceWorkerGlobalScope */ /*::
+import type {
+  HMRAsset,
+  HMRMessage,
+} from '@parcel/reporter-dev-server/src/HMRServer.js';
+interface ParcelRequire {
+  (string): mixed;
+  cache: {|[string]: ParcelModule|};
+  hotData: {|[string]: mixed|};
+  Module: any;
+  parent: ?ParcelRequire;
+  isParcelRequire: true;
+  modules: {|[string]: [Function, {|[string]: string|}]|};
+  HMR_BUNDLE_ID: string;
+  root: ParcelRequire;
+}
+interface ParcelModule {
+  hot: {|
+    data: mixed,
+    accept(cb: (Function) => void): void,
+    dispose(cb: (mixed) => void): void,
+    // accept(deps: Array<string> | string, cb: (Function) => void): void,
+    // decline(): void,
+    _acceptCallbacks: Array<(Function) => void>,
+    _disposeCallbacks: Array<(mixed) => void>,
+  |};
+}
+interface ExtensionContext {
+  runtime: {|
+    reload(): void,
+    getURL(url: string): string;
+    getManifest(): {manifest_version: number, ...};
+  |};
+}
+declare var module: {bundle: ParcelRequire, ...};
+declare var HMR_HOST: string;
+declare var HMR_PORT: string;
+declare var HMR_SERVER_PORT: string;
+declare var HMR_ENV_HASH: string;
+declare var HMR_SECURE: boolean;
+declare var HMR_USE_SSE: boolean;
+declare var chrome: ExtensionContext;
+declare var browser: ExtensionContext;
+declare var __parcel__import__: (string) => Promise<void>;
+declare var __parcel__importScripts__: (string) => Promise<void>;
+declare var globalThis: typeof self;
+declare var ServiceWorkerGlobalScope: Object;
+*/ var OVERLAY_ID = '__parcel__error__overlay__';
+var OldModule = module.bundle.Module;
+function Module(moduleName) {
+    OldModule.call(this, moduleName);
+    this.hot = {
+        data: module.bundle.hotData[moduleName],
+        _acceptCallbacks: [],
+        _disposeCallbacks: [],
+        accept: function(fn) {
+            this._acceptCallbacks.push(fn || function() {});
+        },
+        dispose: function(fn) {
+            this._disposeCallbacks.push(fn);
+        }
+    };
+    module.bundle.hotData[moduleName] = undefined;
+}
+module.bundle.Module = Module;
+module.bundle.hotData = {};
+var checkedAssets /*: {|[string]: boolean|} */ , disposedAssets /*: {|[string]: boolean|} */ , assetsToDispose /*: Array<[ParcelRequire, string]> */ , assetsToAccept /*: Array<[ParcelRequire, string]> */ , bundleNotFound = false;
+function getHostname() {
+    return HMR_HOST || (typeof location !== 'undefined' && location.protocol.indexOf('http') === 0 ? location.hostname : 'localhost');
+}
+function getPort() {
+    return HMR_PORT || (typeof location !== 'undefined' ? location.port : HMR_SERVER_PORT);
+}
+// eslint-disable-next-line no-redeclare
+let WebSocket = globalThis.WebSocket;
+if (!WebSocket && typeof module.bundle.root === 'function') try {
+    // eslint-disable-next-line no-global-assign
+    WebSocket = module.bundle.root('ws');
+} catch  {
+// ignore.
+}
+var hostname = getHostname();
+var port = getPort();
+var protocol = HMR_SECURE || typeof location !== 'undefined' && location.protocol === 'https:' && ![
+    'localhost',
+    '127.0.0.1',
+    '0.0.0.0'
+].includes(hostname) ? 'wss' : 'ws';
+// eslint-disable-next-line no-redeclare
+var parent = module.bundle.parent;
+if (!parent || !parent.isParcelRequire) {
+    // Web extension context
+    var extCtx = typeof browser === 'undefined' ? typeof chrome === 'undefined' ? null : chrome : browser;
+    // Safari doesn't support sourceURL in error stacks.
+    // eval may also be disabled via CSP, so do a quick check.
+    var supportsSourceURL = false;
+    try {
+        (0, eval)('throw new Error("test"); //# sourceURL=test.js');
+    } catch (err) {
+        supportsSourceURL = err.stack.includes('test.js');
+    }
+    var ws;
+    if (HMR_USE_SSE) ws = new EventSource('/__parcel_hmr');
+    else try {
+        // If we're running in the dev server's node runner, listen for messages on the parent port.
+        let { workerData, parentPort } = module.bundle.root('node:worker_threads') /*: any*/ ;
+        if (workerData !== null && workerData !== void 0 && workerData.__parcel) {
+            parentPort.on('message', async (message)=>{
+                try {
+                    await handleMessage(message);
+                    parentPort.postMessage('updated');
+                } catch  {
+                    parentPort.postMessage('restart');
+                }
+            });
+            // After the bundle has finished running, notify the dev server that the HMR update is complete.
+            queueMicrotask(()=>parentPort.postMessage('ready'));
+        }
+    } catch  {
+        if (typeof WebSocket !== 'undefined') try {
+            ws = new WebSocket(protocol + '://' + hostname + (port ? ':' + port : '') + '/');
+        } catch (err) {
+            // Ignore cloudflare workers error.
+            if (err.message && !err.message.includes('Disallowed operation called within global scope')) console.error(err.message);
+        }
+    }
+    if (ws) {
+        // $FlowFixMe
+        ws.onmessage = async function(event /*: {data: string, ...} */ ) {
+            var data /*: HMRMessage */  = JSON.parse(event.data);
+            await handleMessage(data);
+        };
+        if (ws instanceof WebSocket) {
+            ws.onerror = function(e) {
+                if (e.message) console.error(e.message);
+            };
+            ws.onclose = function() {
+                console.warn("[parcel] \uD83D\uDEA8 Connection to the HMR server was lost");
+            };
+        }
+    }
+}
+async function handleMessage(data /*: HMRMessage */ ) {
+    checkedAssets = {} /*: {|[string]: boolean|} */ ;
+    disposedAssets = {} /*: {|[string]: boolean|} */ ;
+    assetsToAccept = [];
+    assetsToDispose = [];
+    bundleNotFound = false;
+    if (data.type === 'reload') fullReload();
+    else if (data.type === 'update') {
+        // Remove error overlay if there is one
+        if (typeof document !== 'undefined') removeErrorOverlay();
+        let assets = data.assets;
+        // Handle HMR Update
+        let handled = assets.every((asset)=>{
+            return asset.type === 'css' || asset.type === 'js' && hmrAcceptCheck(module.bundle.root, asset.id, asset.depsByBundle);
+        });
+        // Dispatch a custom event in case a bundle was not found. This might mean
+        // an asset on the server changed and we should reload the page. This event
+        // gives the client an opportunity to refresh without losing state
+        // (e.g. via React Server Components). If e.preventDefault() is not called,
+        // we will trigger a full page reload.
+        if (handled && bundleNotFound && assets.some((a)=>a.envHash !== HMR_ENV_HASH) && typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') handled = !window.dispatchEvent(new CustomEvent('parcelhmrreload', {
+            cancelable: true
+        }));
+        if (handled) {
+            console.clear();
+            // Dispatch custom event so other runtimes (e.g React Refresh) are aware.
+            if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') window.dispatchEvent(new CustomEvent('parcelhmraccept'));
+            await hmrApplyUpdates(assets);
+            hmrDisposeQueue();
+            // Run accept callbacks. This will also re-execute other disposed assets in topological order.
+            let processedAssets = {};
+            for(let i = 0; i < assetsToAccept.length; i++){
+                let id = assetsToAccept[i][1];
+                if (!processedAssets[id]) {
+                    hmrAccept(assetsToAccept[i][0], id);
+                    processedAssets[id] = true;
+                }
+            }
+        } else fullReload();
+    }
+    if (data.type === 'error') {
+        // Log parcel errors to console
+        for (let ansiDiagnostic of data.diagnostics.ansi){
+            let stack = ansiDiagnostic.codeframe ? ansiDiagnostic.codeframe : ansiDiagnostic.stack;
+            console.error("\uD83D\uDEA8 [parcel]: " + ansiDiagnostic.message + '\n' + stack + '\n\n' + ansiDiagnostic.hints.join('\n'));
+        }
+        if (typeof document !== 'undefined') {
+            // Render the fancy html overlay
+            removeErrorOverlay();
+            var overlay = createErrorOverlay(data.diagnostics.html);
+            // $FlowFixMe
+            document.body.appendChild(overlay);
+        }
+    }
+}
+function removeErrorOverlay() {
+    var overlay = document.getElementById(OVERLAY_ID);
+    if (overlay) {
+        overlay.remove();
+        console.log("[parcel] \u2728 Error resolved");
+    }
+}
+function createErrorOverlay(diagnostics) {
+    var overlay = document.createElement('div');
+    overlay.id = OVERLAY_ID;
+    let errorHTML = '<div style="background: black; opacity: 0.85; font-size: 16px; color: white; position: fixed; height: 100%; width: 100%; top: 0px; left: 0px; padding: 30px; font-family: Menlo, Consolas, monospace; z-index: 9999;">';
+    for (let diagnostic of diagnostics){
+        let stack = diagnostic.frames.length ? diagnostic.frames.reduce((p, frame)=>{
+            return `${p}
+<a href="${protocol === 'wss' ? 'https' : 'http'}://${hostname}:${port}/__parcel_launch_editor?file=${encodeURIComponent(frame.location)}" style="text-decoration: underline; color: #888" onclick="fetch(this.href); return false">${frame.location}</a>
+${frame.code}`;
+        }, '') : diagnostic.stack;
+        errorHTML += `
+      <div>
+        <div style="font-size: 18px; font-weight: bold; margin-top: 20px;">
+          \u{1F6A8} ${diagnostic.message}
+        </div>
+        <pre>${stack}</pre>
+        <div>
+          ${diagnostic.hints.map((hint)=>"<div>\uD83D\uDCA1 " + hint + '</div>').join('')}
+        </div>
+        ${diagnostic.documentation ? `<div>\u{1F4DD} <a style="color: violet" href="${diagnostic.documentation}" target="_blank">Learn more</a></div>` : ''}
+      </div>
+    `;
+    }
+    errorHTML += '</div>';
+    overlay.innerHTML = errorHTML;
+    return overlay;
+}
+function fullReload() {
+    if (typeof location !== 'undefined' && 'reload' in location) location.reload();
+    else if (typeof extCtx !== 'undefined' && extCtx && extCtx.runtime && extCtx.runtime.reload) extCtx.runtime.reload();
+    else try {
+        let { workerData, parentPort } = module.bundle.root('node:worker_threads') /*: any*/ ;
+        if (workerData !== null && workerData !== void 0 && workerData.__parcel) parentPort.postMessage('restart');
+    } catch (err) {
+        console.error("[parcel] \u26A0\uFE0F An HMR update was not accepted. Please restart the process.");
+    }
+}
+function getParents(bundle, id) /*: Array<[ParcelRequire, string]> */ {
+    var modules = bundle.modules;
+    if (!modules) return [];
+    var parents = [];
+    var k, d, dep;
+    for(k in modules)for(d in modules[k][1]){
+        dep = modules[k][1][d];
+        if (dep === id || Array.isArray(dep) && dep[dep.length - 1] === id) parents.push([
+            bundle,
+            k
+        ]);
+    }
+    if (bundle.parent) parents = parents.concat(getParents(bundle.parent, id));
+    return parents;
+}
+function updateLink(link) {
+    var href = link.getAttribute('href');
+    if (!href) return;
+    var newLink = link.cloneNode();
+    newLink.onload = function() {
+        if (link.parentNode !== null) // $FlowFixMe
+        link.parentNode.removeChild(link);
+    };
+    newLink.setAttribute('href', // $FlowFixMe
+    href.split('?')[0] + '?' + Date.now());
+    // $FlowFixMe
+    link.parentNode.insertBefore(newLink, link.nextSibling);
+}
+var cssTimeout = null;
+function reloadCSS() {
+    if (cssTimeout || typeof document === 'undefined') return;
+    cssTimeout = setTimeout(function() {
+        var links = document.querySelectorAll('link[rel="stylesheet"]');
+        for(var i = 0; i < links.length; i++){
+            // $FlowFixMe[incompatible-type]
+            var href /*: string */  = links[i].getAttribute('href');
+            var hostname = getHostname();
+            var servedFromHMRServer = hostname === 'localhost' ? new RegExp('^(https?:\\/\\/(0.0.0.0|127.0.0.1)|localhost):' + getPort()).test(href) : href.indexOf(hostname + ':' + getPort());
+            var absolute = /^https?:\/\//i.test(href) && href.indexOf(location.origin) !== 0 && !servedFromHMRServer;
+            if (!absolute) updateLink(links[i]);
+        }
+        cssTimeout = null;
+    }, 50);
+}
+function hmrDownload(asset) {
+    if (asset.type === 'js') {
+        if (typeof document !== 'undefined') {
+            let script = document.createElement('script');
+            script.src = asset.url + '?t=' + Date.now();
+            if (asset.outputFormat === 'esmodule') script.type = 'module';
+            return new Promise((resolve, reject)=>{
+                var _document$head;
+                script.onload = ()=>resolve(script);
+                script.onerror = reject;
+                (_document$head = document.head) === null || _document$head === void 0 || _document$head.appendChild(script);
+            });
+        } else if (typeof importScripts === 'function') {
+            // Worker scripts
+            if (asset.outputFormat === 'esmodule') return import(asset.url + '?t=' + Date.now());
+            else return new Promise((resolve, reject)=>{
+                try {
+                    importScripts(asset.url + '?t=' + Date.now());
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
+            });
+        }
+    }
+}
+async function hmrApplyUpdates(assets) {
+    global.parcelHotUpdate = Object.create(null);
+    let scriptsToRemove;
+    try {
+        // If sourceURL comments aren't supported in eval, we need to load
+        // the update from the dev server over HTTP so that stack traces
+        // are correct in errors/logs. This is much slower than eval, so
+        // we only do it if needed (currently just Safari).
+        // https://bugs.webkit.org/show_bug.cgi?id=137297
+        // This path is also taken if a CSP disallows eval.
+        if (!supportsSourceURL) {
+            let promises = assets.map((asset)=>{
+                var _hmrDownload;
+                return (_hmrDownload = hmrDownload(asset)) === null || _hmrDownload === void 0 ? void 0 : _hmrDownload.catch((err)=>{
+                    // Web extension fix
+                    if (extCtx && extCtx.runtime && extCtx.runtime.getManifest().manifest_version == 3 && typeof ServiceWorkerGlobalScope != 'undefined' && global instanceof ServiceWorkerGlobalScope) {
+                        extCtx.runtime.reload();
+                        return;
+                    }
+                    throw err;
+                });
+            });
+            scriptsToRemove = await Promise.all(promises);
+        }
+        assets.forEach(function(asset) {
+            hmrApply(module.bundle.root, asset);
+        });
+    } finally{
+        delete global.parcelHotUpdate;
+        if (scriptsToRemove) scriptsToRemove.forEach((script)=>{
+            if (script) {
+                var _document$head2;
+                (_document$head2 = document.head) === null || _document$head2 === void 0 || _document$head2.removeChild(script);
+            }
+        });
+    }
+}
+function hmrApply(bundle /*: ParcelRequire */ , asset /*:  HMRAsset */ ) {
+    var modules = bundle.modules;
+    if (!modules) return;
+    if (asset.type === 'css') reloadCSS();
+    else if (asset.type === 'js') {
+        let deps = asset.depsByBundle[bundle.HMR_BUNDLE_ID];
+        if (deps) {
+            if (modules[asset.id]) {
+                // Remove dependencies that are removed and will become orphaned.
+                // This is necessary so that if the asset is added back again, the cache is gone, and we prevent a full page reload.
+                let oldDeps = modules[asset.id][1];
+                for(let dep in oldDeps)if (!deps[dep] || deps[dep] !== oldDeps[dep]) {
+                    let id = oldDeps[dep];
+                    let parents = getParents(module.bundle.root, id);
+                    if (parents.length === 1) hmrDelete(module.bundle.root, id);
+                }
+            }
+            if (supportsSourceURL) // Global eval. We would use `new Function` here but browser
+            // support for source maps is better with eval.
+            (0, eval)(asset.output);
+            // $FlowFixMe
+            let fn = global.parcelHotUpdate[asset.id];
+            modules[asset.id] = [
+                fn,
+                deps
+            ];
+        }
+        // Always traverse to the parent bundle, even if we already replaced the asset in this bundle.
+        // This is required in case modules are duplicated. We need to ensure all instances have the updated code.
+        if (bundle.parent) hmrApply(bundle.parent, asset);
+    }
+}
+function hmrDelete(bundle, id) {
+    let modules = bundle.modules;
+    if (!modules) return;
+    if (modules[id]) {
+        // Collect dependencies that will become orphaned when this module is deleted.
+        let deps = modules[id][1];
+        let orphans = [];
+        for(let dep in deps){
+            let parents = getParents(module.bundle.root, deps[dep]);
+            if (parents.length === 1) orphans.push(deps[dep]);
+        }
+        // Delete the module. This must be done before deleting dependencies in case of circular dependencies.
+        delete modules[id];
+        delete bundle.cache[id];
+        // Now delete the orphans.
+        orphans.forEach((id)=>{
+            hmrDelete(module.bundle.root, id);
+        });
+    } else if (bundle.parent) hmrDelete(bundle.parent, id);
+}
+function hmrAcceptCheck(bundle /*: ParcelRequire */ , id /*: string */ , depsByBundle /*: ?{ [string]: { [string]: string } }*/ ) {
+    checkedAssets = {};
+    if (hmrAcceptCheckOne(bundle, id, depsByBundle)) return true;
+    // Traverse parents breadth first. All possible ancestries must accept the HMR update, or we'll reload.
+    let parents = getParents(module.bundle.root, id);
+    let accepted = false;
+    while(parents.length > 0){
+        let v = parents.shift();
+        let a = hmrAcceptCheckOne(v[0], v[1], null);
+        if (a) // If this parent accepts, stop traversing upward, but still consider siblings.
+        accepted = true;
+        else if (a !== null) {
+            // Otherwise, queue the parents in the next level upward.
+            let p = getParents(module.bundle.root, v[1]);
+            if (p.length === 0) {
+                // If there are no parents, then we've reached an entry without accepting. Reload.
+                accepted = false;
+                break;
+            }
+            parents.push(...p);
+        }
+    }
+    return accepted;
+}
+function hmrAcceptCheckOne(bundle /*: ParcelRequire */ , id /*: string */ , depsByBundle /*: ?{ [string]: { [string]: string } }*/ ) {
+    var modules = bundle.modules;
+    if (!modules) return;
+    if (depsByBundle && !depsByBundle[bundle.HMR_BUNDLE_ID]) {
+        // If we reached the root bundle without finding where the asset should go,
+        // there's nothing to do. Mark as "accepted" so we don't reload the page.
+        if (!bundle.parent) {
+            bundleNotFound = true;
+            return true;
+        }
+        return hmrAcceptCheckOne(bundle.parent, id, depsByBundle);
+    }
+    if (checkedAssets[id]) return null;
+    checkedAssets[id] = true;
+    var cached = bundle.cache[id];
+    if (!cached) return true;
+    assetsToDispose.push([
+        bundle,
+        id
+    ]);
+    if (cached && cached.hot && cached.hot._acceptCallbacks.length) {
+        assetsToAccept.push([
+            bundle,
+            id
+        ]);
+        return true;
+    }
+    return false;
+}
+function hmrDisposeQueue() {
+    // Dispose all old assets.
+    for(let i = 0; i < assetsToDispose.length; i++){
+        let id = assetsToDispose[i][1];
+        if (!disposedAssets[id]) {
+            hmrDispose(assetsToDispose[i][0], id);
+            disposedAssets[id] = true;
+        }
+    }
+    assetsToDispose = [];
+}
+function hmrDispose(bundle /*: ParcelRequire */ , id /*: string */ ) {
+    var cached = bundle.cache[id];
+    bundle.hotData[id] = {};
+    if (cached && cached.hot) cached.hot.data = bundle.hotData[id];
+    if (cached && cached.hot && cached.hot._disposeCallbacks.length) cached.hot._disposeCallbacks.forEach(function(cb) {
+        cb(bundle.hotData[id]);
+    });
+    delete bundle.cache[id];
+}
+function hmrAccept(bundle /*: ParcelRequire */ , id /*: string */ ) {
+    // Execute the module.
+    bundle(id);
+    // Run the accept callbacks in the new version of the module.
+    var cached = bundle.cache[id];
+    if (cached && cached.hot && cached.hot._acceptCallbacks.length) {
+        let assetsToAlsoAccept = [];
+        cached.hot._acceptCallbacks.forEach(function(cb) {
+            let additionalAssets = cb(function() {
+                return getParents(module.bundle.root, id);
+            });
+            if (Array.isArray(additionalAssets) && additionalAssets.length) assetsToAlsoAccept.push(...additionalAssets);
+        });
+        if (assetsToAlsoAccept.length) {
+            let handled = assetsToAlsoAccept.every(function(a) {
+                return hmrAcceptCheck(a[0], a[1]);
+            });
+            if (!handled) return fullReload();
+            hmrDisposeQueue();
+        }
+    }
+}
+
+},{}],"8iGsg":[function(require,module,exports,__globalThis) {
+var $parcel$ReactRefreshHelpers$8f5d = require("@parcel/transformer-react-refresh-wrap/lib/helpers/helpers.js");
+$parcel$ReactRefreshHelpers$8f5d.init();
+var prevRefreshReg = globalThis.$RefreshReg$;
+var prevRefreshSig = globalThis.$RefreshSig$;
+$parcel$ReactRefreshHelpers$8f5d.prelude(module);
+
+try {
+var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
+parcelHelpers.defineInteropFlag(exports);
+parcelHelpers.export(exports, "WindowsLayout", ()=>WindowsLayout);
+var _jsxRuntime = require("react/jsx-runtime");
+var _react = require("react");
+var _reactI18Next = require("react-i18next");
+var _sdk = require("@shellui/sdk");
+var _utils = require("./utils");
+var _useSettings = require("../settings/hooks/useSettings");
+var _layoutProviders = require("./LayoutProviders");
+var _overlayShell = require("./OverlayShell");
+var _contentView = require("@/components/ContentView");
+var _utils1 = require("@/lib/utils");
+var _zIndex = require("@/lib/z-index");
+var _s = $RefreshSig$(), _s1 = $RefreshSig$();
+const getExternalFaviconUrl = (url)=>{
+    try {
+        const parsed = new URL(url);
+        const hostname = parsed.hostname;
+        if (!hostname) return null;
+        return `https://icons.duckduckgo.com/ip3/${hostname}.ico`;
+    } catch  {
+        return null;
+    }
+};
+/** True when the icon is a local app icon (/icons/); apply theme (dark invert) so it matches foreground. */ const isAppIcon = (src)=>src.startsWith('/icons/');
+const genId = ()=>`win-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+const MIN_WIDTH = 280;
+const MIN_HEIGHT = 200;
+const DEFAULT_WIDTH = 720;
+const DEFAULT_HEIGHT = 480;
+const TASKBAR_HEIGHT = 48;
+function getMaximizedBounds() {
+    return {
+        x: 0,
+        y: 0,
+        w: typeof window !== 'undefined' ? window.innerWidth : 800,
+        h: typeof window !== 'undefined' ? window.innerHeight - TASKBAR_HEIGHT : 600
+    };
+}
+function buildFinalUrl(baseUrl, path, pathname) {
+    const pathPrefix = `/${path}`;
+    const subPath = pathname.length > pathPrefix.length ? pathname.slice(pathPrefix.length + 1) : '';
+    if (!subPath) return baseUrl;
+    const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    return `${base}${subPath}`;
+}
+/** Single draggable/resizable window */ function AppWindow({ win, navItem, currentLanguage, isFocused, onFocus, onClose, onBoundsChange, maxZIndex, zIndex }) {
+    _s();
+    const windowLabel = (0, _utils.resolveLocalizedString)(navItem.label, currentLanguage);
+    const [bounds, setBounds] = (0, _react.useState)(win.bounds);
+    const [isMaximized, setIsMaximized] = (0, _react.useState)(false);
+    const boundsBeforeMaximizeRef = (0, _react.useRef)(bounds);
+    const containerRef = (0, _react.useRef)(null);
+    const dragRef = (0, _react.useRef)(null);
+    const resizeRef = (0, _react.useRef)(null);
+    const resizeRafRef = (0, _react.useRef)(null);
+    const pendingResizeBoundsRef = (0, _react.useRef)(null);
+    (0, _react.useEffect)(()=>{
+        setBounds(win.bounds);
+    }, [
+        win.bounds
+    ]);
+    (0, _react.useEffect)(()=>{
+        onBoundsChange(bounds);
+    }, [
+        bounds,
+        onBoundsChange
+    ]);
+    // When maximized, keep filling the viewport on window resize
+    (0, _react.useEffect)(()=>{
+        if (!isMaximized) return;
+        const onResize = ()=>setBounds(getMaximizedBounds());
+        window.addEventListener('resize', onResize);
+        return ()=>window.removeEventListener('resize', onResize);
+    }, [
+        isMaximized
+    ]);
+    const onPointerMove = (0, _react.useCallback)((e)=>{
+        if (!dragRef.current) return;
+        const d = dragRef.current;
+        const dx = e.clientX - d.startX;
+        const dy = e.clientY - d.startY;
+        d.lastDx = dx;
+        d.lastDy = dy;
+        const el = containerRef.current;
+        if (el) {
+            el.style.willChange = 'transform';
+            el.style.transform = `translate(${dx}px, ${dy}px)`;
+        }
+    }, []);
+    const onPointerUp = (0, _react.useCallback)((e)=>{
+        const el = containerRef.current;
+        if (el) {
+            el.removeEventListener('pointermove', onPointerMove);
+            el.removeEventListener('pointerup', onPointerUp);
+            el.releasePointerCapture(e.pointerId);
+        }
+        if (dragRef.current) {
+            const d = dragRef.current;
+            if (el) {
+                el.style.transform = '';
+                el.style.willChange = '';
+            }
+            const finalBounds = {
+                ...d.startBounds,
+                x: Math.max(0, d.startBounds.x + d.lastDx),
+                y: Math.max(0, d.startBounds.y + d.lastDy)
+            };
+            setBounds(finalBounds);
+            dragRef.current = null;
+        }
+    }, [
+        onPointerMove
+    ]);
+    const handleTitlePointerDown = (0, _react.useCallback)((e)=>{
+        if (e.button !== 0 || isMaximized) return;
+        // Don't start drag when clicking a button (close, maximize) so their click handlers run
+        if (e.target.closest('button')) return;
+        e.preventDefault();
+        onFocus();
+        dragRef.current = {
+            startX: e.clientX,
+            startY: e.clientY,
+            startBounds: {
+                ...bounds
+            },
+            lastDx: 0,
+            lastDy: 0
+        };
+        const el = containerRef.current;
+        if (el) {
+            el.setPointerCapture(e.pointerId);
+            el.addEventListener('pointermove', onPointerMove, {
+                passive: true
+            });
+            el.addEventListener('pointerup', onPointerUp);
+        }
+    }, [
+        bounds,
+        isMaximized,
+        onFocus,
+        onPointerMove,
+        onPointerUp
+    ]);
+    const handleMaximizeToggle = (0, _react.useCallback)(()=>{
+        if (isMaximized) {
+            setBounds(boundsBeforeMaximizeRef.current);
+            setIsMaximized(false);
+        } else {
+            boundsBeforeMaximizeRef.current = {
+                ...bounds
+            };
+            setBounds(getMaximizedBounds());
+            setIsMaximized(true);
+        }
+    }, [
+        isMaximized,
+        bounds
+    ]);
+    const onResizePointerMove = (0, _react.useCallback)((e)=>{
+        if (!resizeRef.current) return;
+        const { edge, startX, startY, startBounds } = resizeRef.current;
+        const dx = e.clientX - startX;
+        const dy = e.clientY - startY;
+        const next = {
+            ...startBounds
+        };
+        if (edge.includes('e')) next.w = Math.max(MIN_WIDTH, startBounds.w + dx);
+        if (edge.includes('w')) {
+            const newW = Math.max(MIN_WIDTH, startBounds.w - dx);
+            next.x = startBounds.x + startBounds.w - newW;
+            next.w = newW;
+        }
+        if (edge.includes('s')) next.h = Math.max(MIN_HEIGHT, startBounds.h + dy);
+        if (edge.includes('n')) {
+            const newH = Math.max(MIN_HEIGHT, startBounds.h - dy);
+            next.y = startBounds.y + startBounds.h - newH;
+            next.h = newH;
+        }
+        pendingResizeBoundsRef.current = next;
+        if (resizeRafRef.current === null) resizeRafRef.current = requestAnimationFrame(()=>{
+            const pending = pendingResizeBoundsRef.current;
+            resizeRafRef.current = null;
+            pendingResizeBoundsRef.current = null;
+            if (pending) setBounds(pending);
+        });
+    }, []);
+    const onResizePointerUp = (0, _react.useCallback)((e)=>{
+        const el = containerRef.current;
+        if (el) {
+            el.removeEventListener('pointermove', onResizePointerMove);
+            el.removeEventListener('pointerup', onResizePointerUp);
+            el.releasePointerCapture(e.pointerId);
+        }
+        resizeRef.current = null;
+    }, [
+        onResizePointerMove
+    ]);
+    const handleResizePointerDown = (0, _react.useCallback)((e, edge)=>{
+        if (e.button !== 0) return;
+        e.preventDefault();
+        e.stopPropagation();
+        onFocus();
+        resizeRef.current = {
+            edge,
+            startX: e.clientX,
+            startY: e.clientY,
+            startBounds: {
+                ...bounds
+            }
+        };
+        const el = containerRef.current;
+        if (el) {
+            el.setPointerCapture(e.pointerId);
+            el.addEventListener('pointermove', onResizePointerMove, {
+                passive: true
+            });
+            el.addEventListener('pointerup', onResizePointerUp);
+        }
+    }, [
+        bounds,
+        onFocus,
+        onResizePointerMove,
+        onResizePointerUp
+    ]);
+    const finalUrl = (0, _react.useMemo)(()=>buildFinalUrl(win.baseUrl, win.path, win.pathname), [
+        win.baseUrl,
+        win.path,
+        win.pathname
+    ]);
+    const z = isFocused ? maxZIndex : zIndex;
+    return (0, _jsxRuntime.jsxs)("div", {
+        ref: containerRef,
+        className: "absolute flex flex-col rounded-lg border border-border bg-card shadow-lg overflow-hidden",
+        style: {
+            left: bounds.x,
+            top: bounds.y,
+            width: bounds.w,
+            height: bounds.h,
+            zIndex: z
+        },
+        onClick: onFocus,
+        onMouseDown: onFocus,
+        children: [
+            (0, _jsxRuntime.jsxs)("div", {
+                className: "flex items-center gap-2 pl-2 pr-1 py-1 bg-muted/80 border-b border-border cursor-move select-none shrink-0",
+                onPointerDown: handleTitlePointerDown,
+                children: [
+                    win.icon && (0, _jsxRuntime.jsx)("img", {
+                        src: win.icon,
+                        alt: "",
+                        className: (0, _utils1.cn)('h-4 w-4 shrink-0 rounded-sm object-cover', isAppIcon(win.icon) && 'opacity-90 dark:opacity-100 dark:invert')
+                    }),
+                    (0, _jsxRuntime.jsx)("span", {
+                        className: "flex-1 text-sm font-medium truncate min-w-0",
+                        children: windowLabel
+                    }),
+                    (0, _jsxRuntime.jsx)("button", {
+                        type: "button",
+                        onClick: (e)=>{
+                            e.stopPropagation();
+                            handleMaximizeToggle();
+                        },
+                        className: "p-1 rounded cursor-pointer text-muted-foreground hover:bg-sidebar-accent/50 hover:text-sidebar-foreground transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+                        "aria-label": isMaximized ? 'Restore' : 'Maximize',
+                        children: isMaximized ? (0, _jsxRuntime.jsx)(RestoreIcon, {
+                            className: "h-4 w-4"
+                        }) : (0, _jsxRuntime.jsx)(MaximizeIcon, {
+                            className: "h-4 w-4"
+                        })
+                    }),
+                    (0, _jsxRuntime.jsx)("button", {
+                        type: "button",
+                        onClick: (e)=>{
+                            e.stopPropagation();
+                            onClose();
+                        },
+                        className: "p-1 rounded cursor-pointer text-muted-foreground hover:bg-destructive/20 hover:text-destructive transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+                        "aria-label": "Close",
+                        children: (0, _jsxRuntime.jsx)(CloseIcon, {
+                            className: "h-4 w-4"
+                        })
+                    })
+                ]
+            }),
+            (0, _jsxRuntime.jsxs)("div", {
+                className: "flex-1 min-h-0 relative bg-background",
+                children: [
+                    !isFocused && (0, _jsxRuntime.jsx)("div", {
+                        className: "absolute inset-0 z-10 cursor-pointer",
+                        onClick: onFocus,
+                        onMouseDown: (e)=>{
+                            e.stopPropagation();
+                            onFocus();
+                        },
+                        "aria-hidden": true
+                    }),
+                    (0, _jsxRuntime.jsx)((0, _contentView.ContentView), {
+                        url: finalUrl,
+                        pathPrefix: win.path,
+                        ignoreMessages: true,
+                        navItem: navItem
+                    })
+                ]
+            }),
+            !isMaximized && [
+                'n',
+                's',
+                'e',
+                'w',
+                'ne',
+                'nw',
+                'se',
+                'sw'
+            ].map((edge)=>(0, _jsxRuntime.jsx)("div", {
+                    className: (0, _utils1.cn)('absolute bg-transparent', edge.includes('n') && 'top-0 h-2 cursor-n-resize', edge.includes('s') && 'bottom-0 h-2 cursor-s-resize', edge.includes('e') && 'right-0 w-2 cursor-e-resize', edge.includes('w') && 'left-0 w-2 cursor-w-resize', edge === 'n' && 'left-2 right-2', edge === 's' && 'left-2 right-2', edge === 'e' && 'top-2 bottom-2', edge === 'w' && 'top-2 bottom-2', edge === 'ne' && 'top-0 right-0 w-2 h-2 cursor-ne-resize', edge === 'nw' && 'top-0 left-0 w-2 h-2 cursor-nw-resize', edge === 'se' && 'bottom-0 right-0 w-2 h-2 cursor-se-resize', edge === 'sw' && 'bottom-0 left-0 w-2 h-2 cursor-sw-resize'),
+                    style: edge === 'n' ? {
+                        left: 8,
+                        right: 8
+                    } : edge === 's' ? {
+                        left: 8,
+                        right: 8
+                    } : edge === 'e' ? {
+                        top: 8,
+                        bottom: 8
+                    } : edge === 'w' ? {
+                        top: 8,
+                        bottom: 8
+                    } : undefined,
+                    onPointerDown: (e)=>handleResizePointerDown(e, edge)
+                }, edge))
+        ]
+    });
+}
+_s(AppWindow, "HLpnQX9Dm1+8VkKTR+Qrce0gudU=");
+_c = AppWindow;
+function MaximizeIcon({ className }) {
+    return (0, _jsxRuntime.jsxs)("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: "24",
+        height: "24",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        className: className,
+        "aria-hidden": true,
+        children: [
+            (0, _jsxRuntime.jsx)("path", {
+                d: "M8 3H5a2 2 0 0 0-2 2v3"
+            }),
+            (0, _jsxRuntime.jsx)("path", {
+                d: "M21 8V5a2 2 0 0 0-2-2h-3"
+            }),
+            (0, _jsxRuntime.jsx)("path", {
+                d: "M3 16v3a2 2 0 0 0 2 2h3"
+            }),
+            (0, _jsxRuntime.jsx)("path", {
+                d: "M16 21h3a2 2 0 0 0 2-2v-3"
+            })
+        ]
+    });
+}
+_c1 = MaximizeIcon;
+function RestoreIcon({ className }) {
+    return (0, _jsxRuntime.jsxs)("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: "24",
+        height: "24",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        className: className,
+        "aria-hidden": true,
+        children: [
+            (0, _jsxRuntime.jsx)("rect", {
+                x: "3",
+                y: "3",
+                width: "10",
+                height: "10",
+                rx: "1"
+            }),
+            (0, _jsxRuntime.jsx)("rect", {
+                x: "11",
+                y: "11",
+                width: "10",
+                height: "10",
+                rx: "1"
+            })
+        ]
+    });
+}
+_c2 = RestoreIcon;
+function CloseIcon({ className }) {
+    return (0, _jsxRuntime.jsxs)("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: "24",
+        height: "24",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round",
+        className: className,
+        "aria-hidden": true,
+        children: [
+            (0, _jsxRuntime.jsx)("path", {
+                d: "M18 6 6 18"
+            }),
+            (0, _jsxRuntime.jsx)("path", {
+                d: "m6 6 12 12"
+            })
+        ]
+    });
+}
+_c3 = CloseIcon;
+/** Start menu icon (Windows-style) */ function StartIcon({ className }) {
+    return (0, _jsxRuntime.jsx)("svg", {
+        xmlns: "http://www.w3.org/2000/svg",
+        width: "24",
+        height: "24",
+        viewBox: "0 0 24 24",
+        fill: "currentColor",
+        className: className,
+        "aria-hidden": true,
+        children: (0, _jsxRuntime.jsx)("path", {
+            d: "M3 3h8v8H3V3zm10 0h8v8h-8V3zM3 13h8v8H3v-8zm10 0h8v8h-8v-8z"
+        })
+    });
+}
+_c4 = StartIcon;
+function getBrowserTimezone() {
+    if (typeof window !== 'undefined' && Intl.DateTimeFormat) return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return 'UTC';
+}
+function WindowsLayout({ title, appIcon: _appIcon, logo: _logo, navigation }) {
+    _s1();
+    const { i18n } = (0, _reactI18Next.useTranslation)();
+    const { settings } = (0, _useSettings.useSettings)();
+    const currentLanguage = i18n.language || 'en';
+    const timeZone = settings.region?.timezone ?? getBrowserTimezone();
+    const { startNavItems, endNavItems, navigationItems } = (0, _react.useMemo)(()=>{
+        const { start, end } = (0, _utils.splitNavigationByPosition)(navigation);
+        return {
+            startNavItems: (0, _utils.flattenNavigationItems)(start),
+            endNavItems: end,
+            navigationItems: (0, _utils.flattenNavigationItems)(navigation)
+        };
+    }, [
+        navigation
+    ]);
+    const [windows, setWindows] = (0, _react.useState)([]);
+    /** Id of the window that is on top (first plan). Clicking a window or its taskbar button sets this. */ const [frontWindowId, setFrontWindowId] = (0, _react.useState)(null);
+    const [startMenuOpen, setStartMenuOpen] = (0, _react.useState)(false);
+    const [now, setNow] = (0, _react.useState)(()=>new Date());
+    const startPanelRef = (0, _react.useRef)(null);
+    // Update date/time every second for taskbar clock
+    (0, _react.useEffect)(()=>{
+        const interval = setInterval(()=>setNow(new Date()), 1000);
+        return ()=>clearInterval(interval);
+    }, []);
+    /** Highest z-index: front window always gets this so it stays on top. */ const maxZIndex = (0, _react.useMemo)(()=>(0, _zIndex.Z_INDEX).WINDOWS_WINDOW_BASE + Math.max(windows.length, 1), [
+        windows.length
+    ]);
+    const openWindow = (0, _react.useCallback)((item)=>{
+        const label = typeof item.label === 'string' ? item.label : (0, _utils.resolveLocalizedString)(item.label, currentLanguage);
+        const faviconUrl = item.openIn === 'external' && !item.icon ? getExternalFaviconUrl(item.url) : null;
+        const icon = item.icon ?? faviconUrl ?? null;
+        const id = genId();
+        const bounds = {
+            x: 60 + windows.length * 24,
+            y: 60 + windows.length * 24,
+            w: DEFAULT_WIDTH,
+            h: DEFAULT_HEIGHT
+        };
+        setWindows((prev)=>[
+                ...prev,
+                {
+                    id,
+                    path: item.path,
+                    pathname: `/${item.path}`,
+                    baseUrl: item.url,
+                    label,
+                    icon,
+                    bounds
+                }
+            ]);
+        setFrontWindowId(id);
+        setStartMenuOpen(false);
+    }, [
+        currentLanguage,
+        windows.length
+    ]);
+    const closeWindow = (0, _react.useCallback)((id)=>{
+        setWindows((prev)=>prev.filter((w)=>w.id !== id));
+        setFrontWindowId((current)=>current === id ? null : current);
+    }, []);
+    // When front window is closed or missing, bring first window to front
+    (0, _react.useEffect)(()=>{
+        if (windows.length === 0) {
+            setFrontWindowId(null);
+            return;
+        }
+        const frontStillExists = frontWindowId !== null && windows.some((w)=>w.id === frontWindowId);
+        if (!frontStillExists) setFrontWindowId(windows[0].id);
+    }, [
+        windows,
+        frontWindowId
+    ]);
+    /** Bring the window to front (first plan). Used when clicking the window or its taskbar button. */ const focusWindow = (0, _react.useCallback)((id)=>{
+        setFrontWindowId(id);
+    }, []);
+    const updateWindowBounds = (0, _react.useCallback)((id, bounds)=>{
+        setWindows((prev)=>prev.map((w)=>w.id === id ? {
+                    ...w,
+                    bounds
+                } : w));
+    }, []);
+    // Close start menu on click outside
+    (0, _react.useEffect)(()=>{
+        if (!startMenuOpen) return;
+        const onDocClick = (e)=>{
+            if (startPanelRef.current && !startPanelRef.current.contains(e.target)) setStartMenuOpen(false);
+        };
+        document.addEventListener('mousedown', onDocClick);
+        return ()=>document.removeEventListener('mousedown', onDocClick);
+    }, [
+        startMenuOpen
+    ]);
+    const handleNavClick = (0, _react.useCallback)((item)=>{
+        if (item.openIn === 'modal') {
+            (0, _sdk.shellui).openModal(item.url);
+            setStartMenuOpen(false);
+            return;
+        }
+        if (item.openIn === 'drawer') {
+            (0, _sdk.shellui).openDrawer({
+                url: item.url,
+                position: item.drawerPosition
+            });
+            setStartMenuOpen(false);
+            return;
+        }
+        if (item.openIn === 'external') {
+            window.open(item.url, '_blank', 'noopener,noreferrer');
+            setStartMenuOpen(false);
+            return;
+        }
+        openWindow(item);
+    }, [
+        openWindow
+    ]);
+    return (0, _jsxRuntime.jsx)((0, _layoutProviders.LayoutProviders), {
+        children: (0, _jsxRuntime.jsxs)((0, _overlayShell.OverlayShell), {
+            navigationItems: navigationItems,
+            children: [
+                (0, _jsxRuntime.jsx)("div", {
+                    className: "fixed inset-0 bg-muted/30",
+                    style: {
+                        paddingBottom: TASKBAR_HEIGHT
+                    },
+                    children: windows.map((win, index)=>{
+                        const navItem = navigationItems.find((n)=>n.path === win.path);
+                        if (!navItem) return null;
+                        const isFocused = win.id === frontWindowId;
+                        const zIndex = (0, _zIndex.Z_INDEX).WINDOWS_WINDOW_BASE + index;
+                        return (0, _jsxRuntime.jsx)(AppWindow, {
+                            win: win,
+                            navItem: navItem,
+                            currentLanguage: currentLanguage,
+                            isFocused: isFocused,
+                            onFocus: ()=>focusWindow(win.id),
+                            onClose: ()=>closeWindow(win.id),
+                            onBoundsChange: (bounds)=>updateWindowBounds(win.id, bounds),
+                            maxZIndex: maxZIndex,
+                            zIndex: zIndex
+                        }, win.id);
+                    })
+                }),
+                (0, _jsxRuntime.jsxs)("div", {
+                    className: "fixed left-0 right-0 bottom-0 flex items-center gap-1 px-2 border-t border-border bg-sidebar-background",
+                    style: {
+                        height: TASKBAR_HEIGHT,
+                        zIndex: (0, _zIndex.Z_INDEX).WINDOWS_TASKBAR,
+                        paddingBottom: 'env(safe-area-inset-bottom, 0px)'
+                    },
+                    children: [
+                        (0, _jsxRuntime.jsxs)("div", {
+                            className: "relative shrink-0",
+                            ref: startPanelRef,
+                            children: [
+                                (0, _jsxRuntime.jsxs)("button", {
+                                    type: "button",
+                                    onClick: ()=>setStartMenuOpen((o)=>!o),
+                                    className: (0, _utils1.cn)('flex items-center gap-2 h-9 px-3 rounded cursor-pointer transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2', startMenuOpen ? 'bg-sidebar-accent text-sidebar-accent-foreground' : 'text-sidebar-foreground hover:bg-sidebar-accent/50 hover:text-sidebar-foreground'),
+                                    "aria-expanded": startMenuOpen,
+                                    "aria-haspopup": "true",
+                                    "aria-label": "Start",
+                                    children: [
+                                        (0, _jsxRuntime.jsx)(StartIcon, {
+                                            className: "h-5 w-5"
+                                        }),
+                                        (0, _jsxRuntime.jsx)("span", {
+                                            className: "font-semibold text-sm hidden sm:inline",
+                                            children: title || 'Start'
+                                        })
+                                    ]
+                                }),
+                                startMenuOpen && (0, _jsxRuntime.jsxs)("div", {
+                                    className: "absolute bottom-full left-0 mb-1 w-64 max-h-[70vh] overflow-y-auto rounded-lg border border-border bg-popover shadow-lg py-2 z-[10001]",
+                                    style: {
+                                        zIndex: (0, _zIndex.Z_INDEX).MODAL_CONTENT
+                                    },
+                                    children: [
+                                        (0, _jsxRuntime.jsx)("div", {
+                                            className: "px-2 pb-2 border-b border-border mb-2",
+                                            children: (0, _jsxRuntime.jsx)("span", {
+                                                className: "text-sm font-semibold text-popover-foreground",
+                                                children: title || 'Applications'
+                                            })
+                                        }),
+                                        (0, _jsxRuntime.jsx)("div", {
+                                            className: "grid gap-0.5",
+                                            children: startNavItems.filter((item)=>!item.hidden).map((item)=>{
+                                                const label = typeof item.label === 'string' ? item.label : (0, _utils.resolveLocalizedString)(item.label, currentLanguage);
+                                                const icon = item.icon ?? (item.openIn === 'external' ? getExternalFaviconUrl(item.url) : null);
+                                                return (0, _jsxRuntime.jsxs)("button", {
+                                                    type: "button",
+                                                    onClick: ()=>handleNavClick(item),
+                                                    className: "flex items-center gap-3 w-full px-3 py-2 text-left text-sm cursor-pointer text-popover-foreground hover:bg-accent hover:text-accent-foreground rounded-none transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+                                                    children: [
+                                                        icon ? (0, _jsxRuntime.jsx)("img", {
+                                                            src: icon,
+                                                            alt: "",
+                                                            className: (0, _utils1.cn)('h-5 w-5 shrink-0 rounded-sm object-cover', isAppIcon(icon) && 'opacity-90 dark:opacity-100 dark:invert')
+                                                        }) : (0, _jsxRuntime.jsx)("span", {
+                                                            className: "h-5 w-5 shrink-0 rounded-sm bg-muted"
+                                                        }),
+                                                        (0, _jsxRuntime.jsx)("span", {
+                                                            className: "truncate",
+                                                            children: label
+                                                        })
+                                                    ]
+                                                }, item.path);
+                                            })
+                                        })
+                                    ]
+                                })
+                            ]
+                        }),
+                        (0, _jsxRuntime.jsx)("div", {
+                            className: "flex-1 flex items-center gap-1 min-w-0 overflow-x-auto",
+                            children: windows.map((win)=>{
+                                const navItem = navigationItems.find((n)=>n.path === win.path);
+                                const windowLabel = navItem ? (0, _utils.resolveLocalizedString)(navItem.label, currentLanguage) : win.label;
+                                const isFocused = win.id === frontWindowId;
+                                return (0, _jsxRuntime.jsxs)("button", {
+                                    type: "button",
+                                    onClick: ()=>focusWindow(win.id),
+                                    onContextMenu: (e)=>{
+                                        e.preventDefault();
+                                        closeWindow(win.id);
+                                    },
+                                    className: (0, _utils1.cn)('flex items-center gap-2 h-8 px-2 rounded min-w-0 max-w-[140px] shrink-0 cursor-pointer transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2', isFocused ? 'bg-sidebar-accent text-sidebar-accent-foreground' : 'text-sidebar-foreground hover:bg-sidebar-accent/50 hover:text-sidebar-foreground'),
+                                    title: windowLabel,
+                                    children: [
+                                        win.icon ? (0, _jsxRuntime.jsx)("img", {
+                                            src: win.icon,
+                                            alt: "",
+                                            className: (0, _utils1.cn)('h-4 w-4 shrink-0 rounded-sm object-cover', isAppIcon(win.icon) && 'opacity-90 dark:opacity-100 dark:invert')
+                                        }) : (0, _jsxRuntime.jsx)("span", {
+                                            className: "h-4 w-4 shrink-0 rounded-sm bg-muted"
+                                        }),
+                                        (0, _jsxRuntime.jsx)("span", {
+                                            className: "text-xs truncate",
+                                            children: windowLabel
+                                        })
+                                    ]
+                                }, win.id);
+                            })
+                        }),
+                        endNavItems.length > 0 && (0, _jsxRuntime.jsx)("div", {
+                            className: "flex items-center gap-0.5 shrink-0 border-l border-sidebar-border pl-2 ml-1",
+                            children: endNavItems.map((item)=>{
+                                const label = typeof item.label === 'string' ? item.label : (0, _utils.resolveLocalizedString)(item.label, currentLanguage);
+                                const icon = item.icon ?? (item.openIn === 'external' ? getExternalFaviconUrl(item.url) : null);
+                                return (0, _jsxRuntime.jsxs)("button", {
+                                    type: "button",
+                                    onClick: ()=>handleNavClick(item),
+                                    className: "flex items-center gap-2 h-8 px-2 rounded cursor-pointer text-sidebar-foreground hover:bg-sidebar-accent/50 hover:text-sidebar-foreground transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
+                                    title: label,
+                                    children: [
+                                        icon ? (0, _jsxRuntime.jsx)("img", {
+                                            src: icon,
+                                            alt: "",
+                                            className: (0, _utils1.cn)('h-4 w-4 shrink-0 rounded-sm object-cover', isAppIcon(icon) && 'opacity-90 dark:opacity-100 dark:invert')
+                                        }) : (0, _jsxRuntime.jsx)("span", {
+                                            className: "h-4 w-4 shrink-0 rounded-sm bg-muted"
+                                        }),
+                                        (0, _jsxRuntime.jsx)("span", {
+                                            className: "text-xs truncate max-w-[100px]",
+                                            children: label
+                                        })
+                                    ]
+                                }, item.path);
+                            })
+                        }),
+                        (0, _jsxRuntime.jsxs)("div", {
+                            className: "flex flex-col items-end justify-center shrink-0 px-3 py-1 text-sidebar-foreground border-l border-sidebar-border ml-1 min-w-0",
+                            style: {
+                                paddingRight: 'max(0.75rem, env(safe-area-inset-right))'
+                            },
+                            role: "timer",
+                            "aria-live": "off",
+                            "aria-label": new Intl.DateTimeFormat(currentLanguage, {
+                                timeZone,
+                                dateStyle: 'full',
+                                timeStyle: 'medium'
+                            }).format(now),
+                            children: [
+                                (0, _jsxRuntime.jsx)("time", {
+                                    dateTime: now.toISOString(),
+                                    className: "text-xs leading-tight tabular-nums whitespace-nowrap",
+                                    children: new Intl.DateTimeFormat(currentLanguage, {
+                                        timeZone,
+                                        hour: '2-digit',
+                                        minute: '2-digit',
+                                        second: '2-digit'
+                                    }).format(now)
+                                }),
+                                (0, _jsxRuntime.jsx)("time", {
+                                    dateTime: now.toISOString(),
+                                    className: "text-[10px] leading-tight whitespace-nowrap text-sidebar-foreground/90",
+                                    children: new Intl.DateTimeFormat(currentLanguage, {
+                                        timeZone,
+                                        weekday: 'short',
+                                        day: 'numeric',
+                                        month: 'short'
+                                    }).format(now)
+                                })
+                            ]
+                        })
+                    ]
+                })
+            ]
+        })
+    });
+}
+_s1(WindowsLayout, "LZip9+xQ6LCIuveRzYGmYY2v/WY=", false, function() {
+    return [
+        (0, _reactI18Next.useTranslation),
+        (0, _useSettings.useSettings)
+    ];
+});
+_c5 = WindowsLayout;
+var _c, _c1, _c2, _c3, _c4, _c5;
+$RefreshReg$(_c, "AppWindow");
+$RefreshReg$(_c1, "MaximizeIcon");
+$RefreshReg$(_c2, "RestoreIcon");
+$RefreshReg$(_c3, "CloseIcon");
+$RefreshReg$(_c4, "StartIcon");
+$RefreshReg$(_c5, "WindowsLayout");
+
+  $parcel$ReactRefreshHelpers$8f5d.postlude(module);
+} finally {
+  globalThis.$RefreshReg$ = prevRefreshReg;
+  globalThis.$RefreshSig$ = prevRefreshSig;
+}
+},{"react/jsx-runtime":"05iiF","react":"jMk1U","react-i18next":"gKfGQ","@shellui/sdk":"dS2fb","./utils":"4dqXA","../settings/hooks/useSettings":"hj85U","./LayoutProviders":"go6VO","./OverlayShell":"2PvVD","@/components/ContentView":"iJhlx","@/lib/utils":"58RPa","@/lib/z-index":"eChN4","@parcel/transformer-js/src/esmodule-helpers.js":"jnFvT","@parcel/transformer-react-refresh-wrap/lib/helpers/helpers.js":"7h6Pi"}],"iJhlx":[function(require,module,exports,__globalThis) {
+var $parcel$ReactRefreshHelpers$9dc4 = require("@parcel/transformer-react-refresh-wrap/lib/helpers/helpers.js");
+$parcel$ReactRefreshHelpers$9dc4.init();
+var prevRefreshReg = globalThis.$RefreshReg$;
+var prevRefreshSig = globalThis.$RefreshSig$;
+$parcel$ReactRefreshHelpers$9dc4.prelude(module);
+
+try {
+var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
+parcelHelpers.defineInteropFlag(exports);
+parcelHelpers.export(exports, "ContentView", ()=>ContentView);
+var _jsxRuntime = require("react/jsx-runtime");
+var _sdk = require("@shellui/sdk");
+var _react = require("react");
+var _reactRouter = require("react-router");
+var _loadingOverlay = require("./LoadingOverlay");
+var _s = $RefreshSig$();
+const logger = (0, _sdk.getLogger)('shellcore');
+const ContentView = ({ url, pathPrefix, ignoreMessages = false, navItem })=>{
+    _s();
+    const navigate = (0, _reactRouter.useNavigate)();
+    const iframeRef = (0, _react.useRef)(null);
+    const isInternalNavigation = (0, _react.useRef)(false);
+    const [initialUrl] = (0, _react.useState)(url);
+    const [isLoading, setIsLoading] = (0, _react.useState)(true);
+    (0, _react.useEffect)(()=>{
+        if (!iframeRef.current) return;
+        const iframeId = (0, _sdk.addIframe)(iframeRef.current);
+        return ()=>{
+            (0, _sdk.removeIframe)(iframeId);
+        };
+    }, []);
+    // Sync parent URL when iframe notifies us of a change
+    (0, _react.useEffect)(()=>{
+        const cleanup = (0, _sdk.shellui).addMessageListener('SHELLUI_URL_CHANGED', (data, event)=>{
+            if (ignoreMessages) return;
+            // Ignore URL CHANGE from other than ContentView iframe
+            if (event.source !== iframeRef.current?.contentWindow) return;
+            const { pathname, search, hash } = data.payload;
+            // Remove leading slash and trailing slashes from iframe pathname
+            let cleanPathname = pathname.startsWith(navItem.url) ? pathname.slice(navItem.url.length) : pathname;
+            cleanPathname = cleanPathname.startsWith('/') ? cleanPathname.slice(1) : cleanPathname;
+            cleanPathname = cleanPathname.replace(/\/+$/, ''); // Remove trailing slashes
+            // Construct the new path without trailing slashes
+            let newShellPath = cleanPathname ? `/${pathPrefix}/${cleanPathname}${search}${hash}` : `/${pathPrefix}${search}${hash}`;
+            // Normalize: remove trailing slashes from pathname part only (preserve query/hash)
+            const urlParts = newShellPath.match(/^([^?#]*)([?#].*)?$/);
+            if (urlParts) {
+                const pathnamePart = urlParts[1].replace(/\/+$/, '') || '/';
+                const queryHashPart = urlParts[2] || '';
+                newShellPath = pathnamePart + queryHashPart;
+            }
+            // Normalize current path for comparison (remove trailing slashes from pathname)
+            const currentPathname = window.location.pathname.replace(/\/+$/, '') || '/';
+            const currentPath = currentPathname + window.location.search + window.location.hash;
+            // Normalize new path for comparison
+            const newPathParts = newShellPath.match(/^([^?#]*)([?#].*)?$/);
+            const normalizedNewPathname = newPathParts?.[1]?.replace(/\/+$/, '') || '/';
+            const normalizedNewPath = normalizedNewPathname + (newPathParts?.[2] || '');
+            if (currentPath !== normalizedNewPath) {
+                // Mark this navigation as internal so we don't try to "push" it back to the iframe
+                isInternalNavigation.current = true;
+                navigate(newShellPath, {
+                    replace: true
+                });
+                // Reset the flag after a short delay to allow the render cycle to complete
+                setTimeout(()=>{
+                    isInternalNavigation.current = false;
+                }, 100);
+            }
+        });
+        return ()=>{
+            cleanup();
+        };
+    }, [
+        pathPrefix,
+        navigate
+    ]);
+    // Hide loading overlay when iframe sends SHELLUI_INITIALIZED
+    (0, _react.useEffect)(()=>{
+        const cleanup = (0, _sdk.shellui).addMessageListener('SHELLUI_INITIALIZED', (_data, event)=>{
+            if (event.source === iframeRef.current?.contentWindow) setIsLoading(false);
+        });
+        return ()=>cleanup();
+    }, []);
+    // Fallback: hide overlay after 400ms if SHELLUI_INITIALIZED was not received
+    (0, _react.useEffect)(()=>{
+        if (!isLoading) return;
+        const timeoutId = setTimeout(()=>{
+            logger.info('ContentView: Timeout expired, hiding loading overlay');
+            setIsLoading(false);
+        }, 400);
+        return ()=>clearTimeout(timeoutId);
+    }, [
+        isLoading
+    ]);
+    // Handle external URL changes (e.g. from Sidebar)
+    (0, _react.useEffect)(()=>{
+        if (iframeRef.current && !isInternalNavigation.current) // Only update iframe src if it's actually different from its current src
+        // to avoid unnecessary reloads
+        {
+            if (iframeRef.current.src !== url) {
+                iframeRef.current.src = url;
+                setIsLoading(true);
+            }
+        }
+    }, [
+        url
+    ]);
+    // Inject script to prevent "Layout was forced" warning by deferring layout until stylesheets load
+    (0, _react.useEffect)(()=>{
+        const iframe = iframeRef.current;
+        if (!iframe) return;
+        const handleLoad = ()=>{
+            try {
+                const iframeWindow = iframe.contentWindow;
+                const iframeDoc = iframe.contentDocument || iframeWindow?.document;
+                if (!iframeDoc || !iframeWindow) return;
+                // Inject a script that waits for stylesheets before allowing layout calculations
+                const script = iframeDoc.createElement('script');
+                script.textContent = `
+          (function() {
+            // Wait for all stylesheets to load
+            function waitForStylesheets() {
+              const styleSheets = Array.from(document.styleSheets);
+              const pendingSheets = styleSheets.filter(function(sheet) {
+                try {
+                  return sheet.cssRules === null;
+                } catch (e) {
+                  return false; // Cross-origin stylesheets, assume loaded
+                }
+              });
+              
+              if (pendingSheets.length === 0) {
+                // All stylesheets loaded
+                return;
+              }
+              
+              // Check again after a short delay
+              setTimeout(waitForStylesheets, 10);
+            }
+            
+            // Start checking after DOM is ready
+            if (document.readyState === 'complete') {
+              waitForStylesheets();
+            } else {
+              window.addEventListener('load', waitForStylesheets);
+            }
+          })();
+        `;
+                iframeDoc.head.appendChild(script);
+            } catch (error) {
+                // Cross-origin or other errors - ignore (this is expected for some iframes)
+                logger.debug('Could not inject stylesheet wait script:', {
+                    error
+                });
+            }
+        };
+        // Wait for iframe to load before injecting script
+        iframe.addEventListener('load', handleLoad);
+        // Also try immediately if already loaded
+        if (iframe.contentDocument?.readyState === 'complete') handleLoad();
+        return ()=>{
+            iframe.removeEventListener('load', handleLoad);
+        };
+    }, [
+        initialUrl
+    ]);
+    // Suppress browser warnings that are expected and acceptable
+    (0, _react.useEffect)(()=>{
+        {
+            const originalWarn = console.warn;
+            console.warn = (...args)=>{
+                const message = String(args[0] ?? '');
+                // Suppress the specific sandbox warning
+                if (message.includes('allow-scripts') && message.includes('allow-same-origin') && message.includes('sandbox')) return;
+                // Suppress "Layout was forced" warning from iframe content
+                // This is a performance warning that occurs when iframe content calculates layout before stylesheets load
+                // It's harmless and common in iframe scenarios, especially with React apps
+                if (message.includes('Layout was forced') && message.includes('before the page was fully loaded')) return;
+                originalWarn.apply(console, args);
+            };
+            return ()=>{
+                console.warn = originalWarn;
+            };
+        }
+    }, []);
+    return (0, _jsxRuntime.jsxs)("div", {
+        style: {
+            width: '100%',
+            height: '100%',
+            display: 'flex',
+            position: 'relative'
+        },
+        children: [
+            (0, _jsxRuntime.jsx)("iframe", {
+                ref: iframeRef,
+                src: initialUrl,
+                style: {
+                    width: '100%',
+                    height: '100%',
+                    border: 'none',
+                    display: 'block'
+                },
+                title: "Content Frame",
+                sandbox: "allow-same-origin allow-scripts allow-forms allow-popups allow-popups-to-escape-sandbox",
+                referrerPolicy: "no-referrer-when-downgrade"
+            }),
+            isLoading && (0, _jsxRuntime.jsx)((0, _loadingOverlay.LoadingOverlay), {})
+        ]
+    });
+};
+_s(ContentView, "zBmwSNmwfZ2d1yaxlldrzHZdD2E=", false, function() {
+    return [
+        (0, _reactRouter.useNavigate)
+    ];
+});
+_c = ContentView;
+var _c;
+$RefreshReg$(_c, "ContentView");
+
+  $parcel$ReactRefreshHelpers$9dc4.postlude(module);
+} finally {
+  globalThis.$RefreshReg$ = prevRefreshReg;
+  globalThis.$RefreshSig$ = prevRefreshSig;
+}
+},{"react/jsx-runtime":"05iiF","@shellui/sdk":"dS2fb","react":"jMk1U","react-router":"kWH5w","./LoadingOverlay":"1kyE0","@parcel/transformer-js/src/esmodule-helpers.js":"jnFvT","@parcel/transformer-react-refresh-wrap/lib/helpers/helpers.js":"7h6Pi"}],"1kyE0":[function(require,module,exports,__globalThis) {
+var $parcel$ReactRefreshHelpers$681a = require("@parcel/transformer-react-refresh-wrap/lib/helpers/helpers.js");
+$parcel$ReactRefreshHelpers$681a.init();
+var prevRefreshReg = globalThis.$RefreshReg$;
+var prevRefreshSig = globalThis.$RefreshSig$;
+$parcel$ReactRefreshHelpers$681a.prelude(module);
+
+try {
+var parcelHelpers = require("@parcel/transformer-js/src/esmodule-helpers.js");
+parcelHelpers.defineInteropFlag(exports);
+parcelHelpers.export(exports, "LoadingOverlay", ()=>LoadingOverlay);
+var _jsxRuntime = require("react/jsx-runtime");
+function LoadingOverlay() {
+    return (0, _jsxRuntime.jsx)("div", {
+        className: "absolute inset-0 z-10 flex flex-col bg-background",
+        children: (0, _jsxRuntime.jsx)("div", {
+            className: "h-1 w-full overflow-hidden bg-muted/30",
+            children: (0, _jsxRuntime.jsx)("div", {
+                className: "h-full w-0 bg-muted-foreground/50",
+                style: {
+                    animation: 'loading-bar-slide 400ms linear infinite'
+                }
+            })
+        })
+    });
+}
+_c = LoadingOverlay;
+var _c;
+$RefreshReg$(_c, "LoadingOverlay");
+
+  $parcel$ReactRefreshHelpers$681a.postlude(module);
+} finally {
+  globalThis.$RefreshReg$ = prevRefreshReg;
+  globalThis.$RefreshSig$ = prevRefreshSig;
+}
+},{"react/jsx-runtime":"05iiF","@parcel/transformer-js/src/esmodule-helpers.js":"jnFvT","@parcel/transformer-react-refresh-wrap/lib/helpers/helpers.js":"7h6Pi"}]},["bpbKD"], null, "parcelRequire6cf0", {})
+
+//# sourceMappingURL=WindowsLayout.08724167.js.map