sibujs 1.0.0-beta.1

package/dist/performance.cjs

@@ -0,0 +1,927 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// performance.ts
+var performance_exports = {};
+__export(performance_exports, {
+  DOMPool: () => DOMPool,
+  Features: () => Features,
+  Priority: () => Priority,
+  block: () => block,
+  cloneTemplate: () => cloneTemplate,
+  conditional: () => conditional,
+  createChunkRegistry: () => createChunkRegistry,
+  deferredValue: () => deferredValue,
+  denormalize: () => denormalize,
+  devOnly: () => devOnly,
+  domPool: () => domPool,
+  flushScheduler: () => flushScheduler,
+  hoistable: () => hoistable,
+  lazyChunk: () => lazyChunk,
+  noSideEffect: () => noSideEffect,
+  normalize: () => normalize,
+  normalizedStore: () => normalizedStore,
+  pendingTasks: () => pendingTasks,
+  precompile: () => precompile,
+  prefetch: () => prefetch,
+  preloadImage: () => preloadImage,
+  preloadModule: () => preloadModule,
+  preloadModules: () => preloadModules,
+  preloadResource: () => preloadResource,
+  processInChunks: () => processInChunks,
+  pure: () => pure,
+  resetIdCounter: () => resetIdCounter,
+  scheduleUpdate: () => scheduleUpdate,
+  setIdPrefix: () => setIdPrefix,
+  startTransition: () => startTransition,
+  staticTemplate: () => staticTemplate,
+  transitionState: () => transitionState,
+  uniqueId: () => uniqueId,
+  yieldToMain: () => yieldToMain
+});
+module.exports = __toCommonJS(performance_exports);
+
+// src/performance/scheduler.ts
+var Priority = {
+  IMMEDIATE: 0,
+  USER_BLOCKING: 1,
+  NORMAL: 2,
+  LOW: 3,
+  IDLE: 4
+};
+var taskIdCounter = 0;
+var taskQueue = [];
+var isProcessing = false;
+var frameId = null;
+function insertTask(task) {
+  let i = taskQueue.length;
+  while (i > 0 && taskQueue[i - 1].priority > task.priority) {
+    i--;
+  }
+  taskQueue.splice(i, 0, task);
+}
+function processQueue() {
+  if (isProcessing || taskQueue.length === 0) return;
+  isProcessing = true;
+  const startTime = performance.now();
+  const timeSlice = 5;
+  while (taskQueue.length > 0) {
+    const task = taskQueue[0];
+    if (task.cancelled) {
+      taskQueue.shift();
+      continue;
+    }
+    if (task.priority > Priority.IMMEDIATE && performance.now() - startTime > timeSlice) {
+      break;
+    }
+    taskQueue.shift();
+    try {
+      task.callback();
+    } catch (e) {
+      console.error("[Scheduler] Task error:", e);
+    }
+  }
+  isProcessing = false;
+  if (taskQueue.length > 0) {
+    scheduleFrame();
+  }
+}
+function scheduleFrame() {
+  if (frameId !== null) return;
+  const nextTask = taskQueue.find((t) => !t.cancelled);
+  if (!nextTask) return;
+  if (nextTask.priority <= Priority.USER_BLOCKING) {
+    queueMicrotask(() => {
+      frameId = null;
+      processQueue();
+    });
+    frameId = -1;
+  } else if (nextTask.priority === Priority.IDLE) {
+    if (typeof requestIdleCallback !== "undefined") {
+      frameId = requestIdleCallback(() => {
+        frameId = null;
+        processQueue();
+      });
+    } else {
+      frameId = setTimeout(() => {
+        frameId = null;
+        processQueue();
+      }, 50);
+    }
+  } else {
+    frameId = requestAnimationFrame(() => {
+      frameId = null;
+      processQueue();
+    });
+  }
+}
+function scheduleUpdate(priority, callback) {
+  const task = {
+    id: taskIdCounter++,
+    priority,
+    callback,
+    cancelled: false
+  };
+  if (priority === Priority.IMMEDIATE) {
+    try {
+      callback();
+    } catch (e) {
+      console.error("[Scheduler] Immediate task error:", e);
+    }
+    return () => {
+    };
+  }
+  insertTask(task);
+  scheduleFrame();
+  return () => {
+    task.cancelled = true;
+  };
+}
+function flushScheduler() {
+  while (taskQueue.length > 0) {
+    const task = taskQueue.shift();
+    if (!task) break;
+    if (!task.cancelled) {
+      task.callback();
+    }
+  }
+  isProcessing = false;
+  frameId = null;
+}
+function pendingTasks() {
+  return taskQueue.filter((t) => !t.cancelled).length;
+}
+function yieldToMain() {
+  if (typeof globalThis !== "undefined" && "scheduler" in globalThis && typeof globalThis.scheduler?.yield === "function") {
+    return globalThis.scheduler.yield();
+  }
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+async function processInChunks(items, processor, chunkSize = 50) {
+  for (let i = 0; i < items.length; i++) {
+    processor(items[i], i);
+    if (i > 0 && i % chunkSize === 0) {
+      await yieldToMain();
+    }
+  }
+}
+
+// src/reactivity/track.ts
+var subscriberStack = [];
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+var suspendDepth = 0;
+var trackingSuspended = false;
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    subscriberStack.push(null);
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    subscriberStack.pop();
+    currentSubscriber = subscriberStack[subscriberStack.length - 1] || null;
+    trackingSuspended = false;
+  }
+}
+function recordDependency(signal2) {
+  if (!currentSubscriber) return;
+  let deps = currentSubscriber._deps;
+  if (!deps) {
+    deps = /* @__PURE__ */ new Set();
+    currentSubscriber._deps = deps;
+  }
+  if (!deps.has(signal2)) {
+    deps.add(signal2);
+    let subs = signal2[SUBS];
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      signalSubscribers.set(signal2, subs);
+      signal2[SUBS] = subs;
+    }
+    subs.add(currentSubscriber);
+    if (subs.size === 1) {
+      signal2.__f = currentSubscriber;
+    } else if (signal2.__f !== void 0) {
+      signal2.__f = void 0;
+    }
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  let sig = sub._sig;
+  let suspended = false;
+  if (sig && sig._g) {
+    const sDeps = sub._deps;
+    if (sDeps && sDeps.size === 1) {
+      suspendTracking();
+      suspended = true;
+      const s = sig;
+      s._d = false;
+      s._v = s._g();
+    }
+  }
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        if (suspended && nSig._g) {
+          const fDeps = first._deps;
+          if (fDeps && fDeps.size === 1) {
+            nSig._d = false;
+            nSig._v = nSig._g();
+          }
+        }
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s of subs) {
+      if (s._c) {
+        s();
+        const nSig = s._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s);
+        }
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    sig = nextSig;
+  }
+  if (suspended) resumeTracking();
+}
+function notifySubscribers(signal2) {
+  const first = signal2.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        first();
+      }
+      let i = 0;
+      while (i < pendingQueue.length) {
+        pendingQueue[i]();
+        i++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal2[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub of subs) {
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub of subs) {
+      pendingQueue[directCount++] = sub;
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (pendingQueue[i2]._c) {
+        propagateDirty(pendingQueue[i2]);
+      }
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (!pendingQueue[i2]._c) {
+        if (!pendingSet.has(pendingQueue[i2])) {
+          pendingQueue[i2]();
+        }
+      }
+    }
+    let i = directCount;
+    while (i < pendingQueue.length) {
+      pendingQueue[i]();
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+
+// src/core/signals/signal.ts
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = options?.name;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (Object.is(newValue, state.value)) return;
+    const oldValue = state.value;
+    state.value = newValue;
+    const hook2 = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook2) hook2.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  return [get, set];
+}
+
+// src/performance/concurrent.ts
+function startTransition(callback) {
+  scheduleUpdate(Priority.NORMAL, callback);
+}
+function deferredValue(getter) {
+  const [deferred, setDeferred] = signal(getter());
+  const sync = () => {
+    const current = getter();
+    setDeferred(current);
+  };
+  scheduleUpdate(Priority.LOW, sync);
+  return () => {
+    scheduleUpdate(Priority.LOW, sync);
+    return deferred();
+  };
+}
+function transitionState() {
+  const [isPending, setIsPending] = signal(false);
+  function transition(callback) {
+    setIsPending(true);
+    scheduleUpdate(Priority.NORMAL, () => {
+      callback();
+      scheduleUpdate(Priority.NORMAL, () => {
+        setIsPending(false);
+      });
+    });
+  }
+  return [isPending, transition];
+}
+var idCounter = 0;
+var idPrefix = "sibu";
+function resetIdCounter() {
+  idCounter = 0;
+}
+function setIdPrefix(prefix) {
+  idPrefix = prefix;
+}
+function uniqueId(suffix) {
+  const id = `${idPrefix}-${idCounter++}`;
+  return suffix ? `${id}-${suffix}` : id;
+}
+
+// src/performance/domRecycler.ts
+var DOMPool = class {
+  constructor(maxSize = 50) {
+    this.pools = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  /**
+   * Get a recycled element or create a new one.
+   */
+  acquire(tag) {
+    const pool = this.pools.get(tag);
+    if (pool && pool.length > 0) {
+      const el = pool.pop();
+      return el;
+    }
+    return document.createElement(tag);
+  }
+  /**
+   * Return an element to the pool for reuse.
+   * Clears attributes, children, and event listeners.
+   */
+  release(element) {
+    const tag = element.tagName.toLowerCase();
+    let pool = this.pools.get(tag);
+    if (!pool) {
+      pool = [];
+      this.pools.set(tag, pool);
+    }
+    if (pool.length >= this.maxSize) return;
+    element.innerHTML = "";
+    element.className = "";
+    element.removeAttribute("style");
+    element.removeAttribute("id");
+    const attrs = Array.from(element.attributes);
+    for (const attr of attrs) {
+      element.removeAttribute(attr.name);
+    }
+    const clean = element.cloneNode(false);
+    pool.push(clean);
+  }
+  /**
+   * Clear all pools.
+   */
+  clear() {
+    this.pools.clear();
+  }
+  /**
+   * Get pool statistics.
+   */
+  stats() {
+    const result = {};
+    for (const [tag, pool] of this.pools) {
+      result[tag] = pool.length;
+    }
+    return result;
+  }
+};
+var domPool = new DOMPool();
+var preloadedResources = /* @__PURE__ */ new Set();
+function preloadResource(url, type = "fetch") {
+  if (preloadedResources.has(url)) return;
+  preloadedResources.add(url);
+  const link = document.createElement("link");
+  link.rel = "preload";
+  link.href = url;
+  switch (type) {
+    case "script":
+      link.setAttribute("as", "script");
+      break;
+    case "style":
+      link.setAttribute("as", "style");
+      break;
+    case "image":
+      link.setAttribute("as", "image");
+      break;
+    default:
+      link.setAttribute("as", "fetch");
+      link.setAttribute("crossorigin", "anonymous");
+  }
+  document.head.appendChild(link);
+}
+function prefetch(url) {
+  if (preloadedResources.has(url)) return;
+  preloadedResources.add(url);
+  const link = document.createElement("link");
+  link.rel = "prefetch";
+  link.href = url;
+  document.head.appendChild(link);
+}
+function preloadImage(src) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = reject;
+    img.src = src;
+  });
+}
+
+// src/performance/bundleOptimize.ts
+function pure(fn) {
+  return fn();
+}
+function conditional(condition, loader) {
+  if (condition) return loader();
+  return void 0;
+}
+var Features = {
+  SSR: typeof window === "undefined",
+  DEV: typeof process !== "undefined" && process.env?.NODE_ENV !== "production",
+  BROWSER: typeof window !== "undefined"
+};
+function devOnly(fn) {
+  if (typeof process !== "undefined" && process.env?.NODE_ENV !== "production") {
+    fn();
+  }
+}
+function noSideEffect(fn) {
+  return fn;
+}
+
+// src/performance/compiled.ts
+function staticTemplate(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html.trim();
+  return template.content.firstElementChild;
+}
+function cloneTemplate(template) {
+  return template.content.cloneNode(true);
+}
+function precompile(templateHtml, hydrate) {
+  const tpl = document.createElement("template");
+  tpl.innerHTML = templateHtml.trim();
+  return (props) => {
+    const el = tpl.content.firstElementChild?.cloneNode(true);
+    hydrate(el, props);
+    return el;
+  };
+}
+function hoistable(value) {
+  return value;
+}
+function block(factory) {
+  return factory();
+}
+
+// src/performance/normalize.ts
+function normalizedStore(schema) {
+  const idKey = schema.idKey || "id";
+  const [getState, setState] = signal({
+    ids: [],
+    entities: {}
+  });
+  function add(entity) {
+    const id = String(entity[idKey]);
+    setState((prev) => {
+      const ids = prev.ids.includes(id) ? prev.ids : [...prev.ids, id];
+      return {
+        ids,
+        entities: { ...prev.entities, [id]: entity }
+      };
+    });
+  }
+  function addMany(entities) {
+    setState((prev) => {
+      const nextIds = [...prev.ids];
+      const nextEntities = { ...prev.entities };
+      for (const entity of entities) {
+        const id = String(entity[idKey]);
+        if (!nextIds.includes(id)) {
+          nextIds.push(id);
+        }
+        nextEntities[id] = entity;
+      }
+      return { ids: nextIds, entities: nextEntities };
+    });
+  }
+  function get(id) {
+    const state = getState();
+    return state.entities[id];
+  }
+  function getAll() {
+    const state = getState();
+    return state.ids.map((id) => state.entities[id]);
+  }
+  function update(id, partial) {
+    setState((prev) => {
+      const existing = prev.entities[id];
+      if (!existing) return prev;
+      return {
+        ids: prev.ids,
+        entities: {
+          ...prev.entities,
+          [id]: { ...existing, ...partial }
+        }
+      };
+    });
+  }
+  function remove(id) {
+    setState((prev) => {
+      if (!prev.entities[id]) return prev;
+      const { [id]: _, ...remainingEntities } = prev.entities;
+      return {
+        ids: prev.ids.filter((existingId) => existingId !== id),
+        entities: remainingEntities
+      };
+    });
+  }
+  function select(predicate) {
+    const state = getState();
+    return state.ids.map((id) => state.entities[id]).filter(predicate);
+  }
+  return { add, addMany, get, getAll, update, remove, select, getState };
+}
+function normalize(data, schema) {
+  const entities = {};
+  const idKey = schema.idKey || "id";
+  function ensureTable(name) {
+    if (!entities[name]) {
+      entities[name] = {};
+    }
+    return entities[name];
+  }
+  function normalizeEntity(entity, entitySchema) {
+    const entityIdKey = entitySchema.idKey || "id";
+    const id = String(entity[entityIdKey]);
+    const table = ensureTable(entitySchema.name);
+    const flat = { ...entity };
+    if (entitySchema.relations) {
+      for (const [field, relationType] of Object.entries(entitySchema.relations)) {
+        const value = entity[field];
+        if (value == null) continue;
+        const relSchema = { name: relationType, idKey };
+        if (Array.isArray(value)) {
+          flat[field] = value.map((item) => normalizeEntity(item, relSchema));
+        } else if (typeof value === "object") {
+          flat[field] = normalizeEntity(value, relSchema);
+        }
+      }
+    }
+    table[id] = flat;
+    return id;
+  }
+  if (Array.isArray(data)) {
+    const result2 = data.map((item) => normalizeEntity(item, schema));
+    return { result: result2, entities };
+  }
+  const result = normalizeEntity(data, schema);
+  return { result, entities };
+}
+function denormalize(id, entities, schema) {
+  const table = entities[schema.name];
+  if (!table) return void 0;
+  const entity = table[id];
+  if (!entity) return void 0;
+  const idKey = schema.idKey || "id";
+  const result = { ...entity };
+  if (schema.relations) {
+    for (const [field, relationType] of Object.entries(schema.relations)) {
+      const value = entity[field];
+      if (value == null) continue;
+      const relSchema = { name: relationType, idKey };
+      if (Array.isArray(value)) {
+        result[field] = value.map((relId) => denormalize(relId, entities, relSchema));
+      } else if (typeof value === "string") {
+        result[field] = denormalize(value, entities, relSchema);
+      }
+    }
+  }
+  return result;
+}
+
+// src/performance/chunkLoader.ts
+function createChunkRegistry(config = {}) {
+  const {
+    maxCacheSize = 50,
+    cacheTTL = 0,
+    retries = 2,
+    retryDelay = 1e3,
+    timeout = 1e4,
+    onLoadStart,
+    onLoadEnd,
+    onLoadError
+  } = config;
+  const cache = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const preloaded = /* @__PURE__ */ new Set();
+  function evict() {
+    if (cache.size < maxCacheSize) return;
+    let oldest = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of cache) {
+      if (entry.timestamp < oldestTime) {
+        oldestTime = entry.timestamp;
+        oldest = key;
+      }
+    }
+    if (oldest) cache.delete(oldest);
+  }
+  function isValid(entry) {
+    if (cacheTTL === 0) return true;
+    return Date.now() - entry.timestamp < cacheTTL;
+  }
+  async function loadWithRetry(id, loader, attempt = 0) {
+    try {
+      const result = await (timeout > 0 ? Promise.race([
+        loader(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Chunk '${id}' loading timed out after ${timeout}ms`)), timeout)
+        )
+      ]) : loader());
+      return result;
+    } catch (err) {
+      if (attempt < retries) {
+        await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
+        return loadWithRetry(id, loader, attempt + 1);
+      }
+      throw err;
+    }
+  }
+  return {
+    /**
+     * Load a chunk by ID. Uses cache if available, otherwise loads via the provided loader.
+     */
+    async load(id, loader) {
+      const cached = cache.get(id);
+      if (cached && isValid(cached)) {
+        cached.accessCount++;
+        return cached.value;
+      }
+      const pendingLoad = pending.get(id);
+      if (pendingLoad) return pendingLoad;
+      onLoadStart?.(id);
+      const loadPromise = loadWithRetry(id, loader).then((value) => {
+        evict();
+        cache.set(id, { value, timestamp: Date.now(), accessCount: 1 });
+        pending.delete(id);
+        onLoadEnd?.(id);
+        return value;
+      }).catch((err) => {
+        pending.delete(id);
+        const error = err instanceof Error ? err : new Error(String(err));
+        onLoadError?.(id, error);
+        throw error;
+      });
+      pending.set(id, loadPromise);
+      return loadPromise;
+    },
+    /**
+     * Preload a chunk without blocking. Silently caches for later use.
+     */
+    preload(id, loader) {
+      if (cache.has(id) || pending.has(id) || preloaded.has(id)) return;
+      preloaded.add(id);
+      this.load(id, loader).catch(() => {
+      });
+    },
+    /**
+     * Preload multiple chunks in parallel.
+     */
+    preloadAll(entries) {
+      for (const entry of entries) {
+        this.preload(entry.id, entry.loader);
+      }
+    },
+    /**
+     * Check if a chunk is cached and valid.
+     */
+    has(id) {
+      const entry = cache.get(id);
+      return !!entry && isValid(entry);
+    },
+    /**
+     * Get a cached chunk synchronously. Returns undefined if not cached.
+     */
+    get(id) {
+      const entry = cache.get(id);
+      if (entry && isValid(entry)) {
+        entry.accessCount++;
+        return entry.value;
+      }
+      return void 0;
+    },
+    /**
+     * Invalidate a cached chunk.
+     */
+    invalidate(id) {
+      cache.delete(id);
+    },
+    /**
+     * Clear all cached chunks.
+     */
+    clear() {
+      cache.clear();
+      preloaded.clear();
+    },
+    /**
+     * Get cache statistics.
+     */
+    stats() {
+      return {
+        size: cache.size,
+        maxSize: maxCacheSize,
+        pending: pending.size,
+        preloaded: preloaded.size
+      };
+    }
+  };
+}
+function lazyChunk(id, loader, registry, fallback) {
+  return () => {
+    const cached = registry.get(id);
+    if (cached) return cached();
+    const container = document.createElement("div");
+    container.setAttribute("data-chunk", id);
+    if (fallback) {
+      container.appendChild(fallback());
+    }
+    registry.load(id, async () => {
+      const mod = await loader();
+      return typeof mod === "function" ? mod : mod.default;
+    }).then((component) => {
+      container.innerHTML = "";
+      container.appendChild(component());
+    }).catch((err) => {
+      container.innerHTML = "";
+      const errorEl = document.createElement("div");
+      errorEl.textContent = `Failed to load chunk '${id}': ${err.message}`;
+      container.appendChild(errorEl);
+    });
+    return container;
+  };
+}
+function preloadModule(url) {
+  if (typeof document === "undefined") return;
+  const existing = document.querySelector(`link[href="${url}"][rel="modulepreload"]`);
+  if (existing) return;
+  const link = document.createElement("link");
+  link.rel = "modulepreload";
+  link.href = url;
+  document.head.appendChild(link);
+}
+function preloadModules(urls) {
+  urls.forEach(preloadModule);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DOMPool,
+  Features,
+  Priority,
+  block,
+  cloneTemplate,
+  conditional,
+  createChunkRegistry,
+  deferredValue,
+  denormalize,
+  devOnly,
+  domPool,
+  flushScheduler,
+  hoistable,
+  lazyChunk,
+  noSideEffect,
+  normalize,
+  normalizedStore,
+  pendingTasks,
+  precompile,
+  prefetch,
+  preloadImage,
+  preloadModule,
+  preloadModules,
+  preloadResource,
+  processInChunks,
+  pure,
+  resetIdCounter,
+  scheduleUpdate,
+  setIdPrefix,
+  startTransition,
+  staticTemplate,
+  transitionState,
+  uniqueId,
+  yieldToMain
+});