specnav-core 0.2.0

package/dist/index.cjs

@@ -0,0 +1,843 @@
+'use strict';
+
+// src/trajectory.ts
+var DEFAULT_CONFIG = {
+  lookaheadMs: 120,
+  minVelocity: 0.2,
+  sampleRate: 50,
+  cancelOnDeviation: true
+};
+var TrajectoryEngine = class {
+  samples = [];
+  links = /* @__PURE__ */ new Map();
+  config;
+  lastPrediction = null;
+  sampleInterval = null;
+  onPrediction;
+  onCancel;
+  cooldownMap = /* @__PURE__ */ new Map();
+  updateDebounceTimer = null;
+  constructor(config = {}, callbacks) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.onPrediction = callbacks?.onPrediction;
+    this.onCancel = callbacks?.onCancel;
+  }
+  start() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("pointermove", this.handlePointerMove);
+    this.sampleInterval = window.setInterval(
+      () => this.processSamples(),
+      this.config.sampleRate
+    );
+  }
+  stop() {
+    if (typeof window === "undefined") return;
+    window.removeEventListener("pointermove", this.handlePointerMove);
+    if (this.sampleInterval) {
+      clearInterval(this.sampleInterval);
+      this.sampleInterval = null;
+    }
+    if (this.updateDebounceTimer) {
+      clearTimeout(this.updateDebounceTimer);
+      this.updateDebounceTimer = null;
+    }
+    this.samples = [];
+    this.links.clear();
+    this.cooldownMap.clear();
+    this.lastPrediction = null;
+  }
+  registerLink(href, element) {
+    const rect = element.getBoundingClientRect();
+    this.links.set(element, { href, rect, element });
+  }
+  unregisterLink(element) {
+    this.links.delete(element);
+  }
+  updateLinkPositions() {
+    if (this.updateDebounceTimer) {
+      clearTimeout(this.updateDebounceTimer);
+    }
+    this.updateDebounceTimer = window.setTimeout(() => {
+      this.links.forEach((link, element) => {
+        const rect = element.getBoundingClientRect();
+        this.links.set(element, { ...link, rect });
+      });
+      this.updateDebounceTimer = null;
+    }, 100);
+  }
+  handlePointerMove = (e) => {
+    this.samples.push({
+      x: e.clientX,
+      y: e.clientY,
+      t: e.timeStamp
+    });
+    if (this.samples.length > 10) {
+      this.samples.shift();
+    }
+  };
+  processSamples() {
+    if (this.samples.length < 4) return;
+    const velocity = this.computeVelocity();
+    const speed = Math.sqrt(velocity.vx ** 2 + velocity.vy ** 2);
+    if (speed < this.config.minVelocity) {
+      if (this.lastPrediction && this.config.cancelOnDeviation) {
+        this.onCancel?.(this.lastPrediction);
+        this.lastPrediction = null;
+      }
+      return;
+    }
+    const target = this.predictTarget(velocity);
+    if (target && target.href !== this.lastPrediction) {
+      const now = Date.now();
+      const lastTime = this.cooldownMap.get(target.href) ?? 0;
+      const cooldown = 500;
+      if (now - lastTime < cooldown) {
+        return;
+      }
+      if (this.lastPrediction && this.config.cancelOnDeviation) {
+        this.onCancel?.(this.lastPrediction);
+      }
+      this.lastPrediction = target.href;
+      this.cooldownMap.set(target.href, now);
+      this.onPrediction?.(target.href);
+    } else if (!target && this.lastPrediction && this.config.cancelOnDeviation) {
+      this.onCancel?.(this.lastPrediction);
+      this.lastPrediction = null;
+    }
+  }
+  computeVelocity() {
+    const recent = this.samples.slice(-4);
+    const dt = recent[recent.length - 1].t - recent[0].t;
+    if (dt === 0) return { vx: 0, vy: 0 };
+    const dx = recent[recent.length - 1].x - recent[0].x;
+    const dy = recent[recent.length - 1].y - recent[0].y;
+    return {
+      vx: dx / dt,
+      vy: dy / dt
+    };
+  }
+  projectRay(velocity) {
+    const origin = this.samples[this.samples.length - 1];
+    return {
+      x: origin.x + velocity.vx * this.config.lookaheadMs,
+      y: origin.y + velocity.vy * this.config.lookaheadMs
+    };
+  }
+  predictTarget(velocity) {
+    const tip = this.projectRay(velocity);
+    for (const link of this.links.values()) {
+      if (this.rectContains(link.rect, tip)) {
+        return link;
+      }
+    }
+    return null;
+  }
+  rectContains(rect, point) {
+    return point.x >= rect.left && point.x <= rect.right && point.y >= rect.top && point.y <= rect.bottom;
+  }
+};
+function createTrajectoryEngine(config, callbacks) {
+  return new TrajectoryEngine(config, callbacks);
+}
+
+// src/cache.ts
+var DEFAULT_CONFIG2 = {
+  memory: {
+    enabled: true,
+    maxPages: 10
+  },
+  serviceWorker: {
+    enabled: true,
+    ttl: 300,
+    cacheName: "specnav-v1",
+    crossTabSync: true,
+    broadcastChannel: "specnav-sync"
+  },
+  edge: {
+    enabled: true,
+    maxAge: 60,
+    staleWhileRevalidate: 300
+  },
+  exclude: []
+};
+var CacheManager = class {
+  config;
+  memoryCache = /* @__PURE__ */ new Map();
+  accessOrder = [];
+  broadcastChannel;
+  onCacheHit;
+  constructor(config = {}, callbacks) {
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.onCacheHit = callbacks?.onCacheHit;
+    if (this.config.serviceWorker.enabled && this.config.serviceWorker.crossTabSync && typeof BroadcastChannel !== "undefined") {
+      this.broadcastChannel = new BroadcastChannel(
+        this.config.serviceWorker.broadcastChannel
+      );
+      this.broadcastChannel.onmessage = this.handleBroadcast;
+    }
+  }
+  async get(href) {
+    if (this.isExcluded(href)) return null;
+    const memoryHit = this.getFromMemory(href);
+    if (memoryHit) {
+      this.onCacheHit?.(href, 1);
+      return memoryHit;
+    }
+    if (this.config.serviceWorker.enabled) {
+      const swHit = await this.getFromServiceWorker(href);
+      if (swHit) {
+        this.onCacheHit?.(href, 2);
+        this.setInMemory(href, swHit);
+        return swHit;
+      }
+    }
+    return null;
+  }
+  async set(href, html) {
+    if (this.isExcluded(href)) return;
+    const sanitizedHref = this.sanitizeHref(href);
+    if (!sanitizedHref) return;
+    if (this.containsDangerousContent(html)) {
+      console.warn(`Refusing to cache potentially dangerous content from ${sanitizedHref}`);
+      return;
+    }
+    const page = {
+      href: sanitizedHref,
+      html,
+      timestamp: Date.now(),
+      ttl: this.config.serviceWorker.ttl
+    };
+    if (this.config.memory.enabled) {
+      this.setInMemory(sanitizedHref, html);
+    }
+    if (this.config.serviceWorker.enabled) {
+      await this.setInServiceWorker(page);
+      this.broadcastSet(sanitizedHref);
+    }
+  }
+  containsDangerousContent(html) {
+    const dangerousPatterns = [
+      /on\w+\s*=\s*["'][^"']*["']/i,
+      // Inline event handlers
+      /javascript:/i
+      // javascript: URLs
+    ];
+    const scriptRegex = /<script([^>]*)>([\s\S]*?)<\/script>/gi;
+    let match;
+    while ((match = scriptRegex.exec(html)) !== null) {
+      const attrs = match[1] || "";
+      if (/src\s*=/.test(attrs)) continue;
+      if (/type\s*=\s*["']?(application\/json|application\/ld\+json|text\/template)["']?/i.test(attrs)) continue;
+      if (/id\s*=\s*["']__NEXT_DATA__["']/i.test(attrs)) continue;
+      return true;
+    }
+    return dangerousPatterns.some((pattern) => pattern.test(html));
+  }
+  sanitizeHref(href) {
+    try {
+      const url = new URL(href, window.location.origin);
+      if (url.origin !== window.location.origin) return null;
+      return url.pathname + url.search + url.hash;
+    } catch {
+      return null;
+    }
+  }
+  clear(href) {
+    if (href) {
+      this.memoryCache.delete(href);
+      this.accessOrder = this.accessOrder.filter((h) => h !== href);
+      this.clearFromServiceWorker(href);
+    } else {
+      this.memoryCache.clear();
+      this.accessOrder = [];
+      this.clearAllServiceWorker();
+    }
+  }
+  getSize() {
+    return this.memoryCache.size;
+  }
+  destroy() {
+    this.memoryCache.clear();
+    this.accessOrder = [];
+    this.broadcastChannel?.close();
+  }
+  getFromMemory(href) {
+    const page = this.memoryCache.get(href);
+    if (!page) return null;
+    this.accessOrder = this.accessOrder.filter((h) => h !== href);
+    this.accessOrder.push(href);
+    return page.html;
+  }
+  setInMemory(href, html) {
+    const maxPageSize = 5 * 1024 * 1024;
+    if (html.length > maxPageSize) {
+      console.warn(`Page ${href} exceeds max size, not caching`);
+      return;
+    }
+    this.memoryCache.set(href, {
+      href,
+      html,
+      timestamp: Date.now(),
+      ttl: this.config.serviceWorker.ttl
+    });
+    const existingIndex = this.accessOrder.indexOf(href);
+    if (existingIndex !== -1) {
+      this.accessOrder.splice(existingIndex, 1);
+    }
+    this.accessOrder.push(href);
+    if (this.memoryCache.size > this.config.memory.maxPages) {
+      const oldest = this.accessOrder.shift();
+      if (oldest) this.memoryCache.delete(oldest);
+    }
+  }
+  async getFromServiceWorker(href) {
+    if (typeof caches === "undefined") return null;
+    try {
+      const cache = await caches.open(this.config.serviceWorker.cacheName);
+      const response = await cache.match(href);
+      if (!response) return null;
+      const data = await response.json();
+      const page = data;
+      const age = Date.now() - page.timestamp;
+      if (age > page.ttl * 1e3) {
+        await cache.delete(href);
+        return null;
+      }
+      return page.html;
+    } catch {
+      return null;
+    }
+  }
+  async setInServiceWorker(page) {
+    if (typeof caches === "undefined") return;
+    try {
+      const cache = await caches.open(this.config.serviceWorker.cacheName);
+      const response = new Response(JSON.stringify(page), {
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": `max-age=${this.config.edge.maxAge}, stale-while-revalidate=${this.config.edge.staleWhileRevalidate}`
+        }
+      });
+      await cache.put(page.href, response);
+    } catch {
+    }
+  }
+  async clearFromServiceWorker(href) {
+    if (typeof caches === "undefined") return;
+    try {
+      const cache = await caches.open(this.config.serviceWorker.cacheName);
+      await cache.delete(href);
+    } catch {
+    }
+  }
+  async clearAllServiceWorker() {
+    if (typeof caches === "undefined") return;
+    try {
+      await caches.delete(this.config.serviceWorker.cacheName);
+    } catch {
+    }
+  }
+  isExcluded(href) {
+    return this.config.exclude.some((pattern) => {
+      if (typeof pattern === "string") {
+        return pattern.includes("*") ? new RegExp(pattern.replace(/\*/g, ".*")).test(href) : href === pattern;
+      }
+      return pattern.test(href);
+    });
+  }
+  broadcastSet(href) {
+    this.broadcastChannel?.postMessage({ type: "set", href });
+  }
+  handleBroadcast = (event) => {
+    if (event.data.type === "set") {
+      this.memoryCache.delete(event.data.href);
+    }
+  };
+};
+function createCacheManager(config, callbacks) {
+  return new CacheManager(config, callbacks);
+}
+
+// src/morpher.ts
+var DEFAULT_CONFIG3 = {
+  preserveScroll: true,
+  preserveFocus: true
+};
+var DOMmorpher = class {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG3, ...config };
+  }
+  morph(from, to) {
+    const ctx = this.createContext();
+    requestAnimationFrame(() => {
+      this.morphElement(from, to, ctx);
+      this.restoreContext(ctx);
+    });
+  }
+  createContext() {
+    const ctx = {
+      config: this.config,
+      focusedElement: null,
+      scrollPositions: /* @__PURE__ */ new Map()
+    };
+    if (this.config.preserveFocus) {
+      ctx.focusedElement = document.activeElement;
+    }
+    if (this.config.preserveScroll) {
+      this.captureScrollPositions(document.body, ctx.scrollPositions);
+    }
+    return ctx;
+  }
+  restoreContext(ctx) {
+    if (ctx.config.preserveFocus && ctx.focusedElement) {
+      const element = ctx.focusedElement;
+      if (element.focus && document.body.contains(element)) {
+        element.focus();
+      }
+    }
+    if (ctx.config.preserveScroll) {
+      ctx.scrollPositions.forEach((pos, element) => {
+        element.scrollTop = pos.top;
+        element.scrollLeft = pos.left;
+      });
+    }
+  }
+  captureScrollPositions(element, positions) {
+    if (element.scrollTop > 0 || element.scrollLeft > 0) {
+      positions.set(element, {
+        top: element.scrollTop,
+        left: element.scrollLeft
+      });
+    }
+    Array.from(element.children).forEach((child) => {
+      this.captureScrollPositions(child, positions);
+    });
+  }
+  morphElement(from, to, ctx) {
+    this.syncAttributes(from, to);
+    this.morphChildren(from, to, ctx);
+  }
+  syncAttributes(from, to) {
+    const fromAttrs = from.attributes;
+    const toAttrs = to.attributes;
+    for (let i = fromAttrs.length - 1; i >= 0; i--) {
+      const attr = fromAttrs[i];
+      if (!to.hasAttribute(attr.name)) {
+        from.removeAttribute(attr.name);
+      }
+    }
+    for (let i = 0; i < toAttrs.length; i++) {
+      const attr = toAttrs[i];
+      if (from.getAttribute(attr.name) !== attr.value) {
+        from.setAttribute(attr.name, attr.value);
+      }
+    }
+  }
+  morphChildren(from, to, ctx) {
+    const fromChildren = Array.from(from.childNodes);
+    const toChildren = Array.from(to.childNodes);
+    let fromIndex = 0;
+    let toIndex = 0;
+    while (toIndex < toChildren.length) {
+      const toNode = toChildren[toIndex];
+      const fromNode = fromChildren[fromIndex];
+      if (!fromNode) {
+        from.appendChild(toNode.cloneNode(true));
+        toIndex++;
+        continue;
+      }
+      if (this.nodesMatch(fromNode, toNode)) {
+        if (fromNode.nodeType === Node.TEXT_NODE) {
+          if (fromNode.nodeValue !== toNode.nodeValue) {
+            fromNode.nodeValue = toNode.nodeValue;
+          }
+        } else if (fromNode.nodeType === Node.ELEMENT_NODE) {
+          this.morphElement(fromNode, toNode, ctx);
+        }
+        fromIndex++;
+        toIndex++;
+      } else {
+        const matchIndex = this.findMatchingNode(
+          fromChildren,
+          fromIndex + 1,
+          toNode
+        );
+        if (matchIndex !== -1) {
+          for (let i = fromIndex; i < matchIndex; i++) {
+            from.removeChild(fromChildren[i]);
+          }
+          fromIndex = matchIndex;
+        } else {
+          from.insertBefore(toNode.cloneNode(true), fromNode);
+          toIndex++;
+        }
+      }
+    }
+    while (fromIndex < fromChildren.length) {
+      from.removeChild(fromChildren[fromIndex]);
+      fromIndex++;
+    }
+  }
+  nodesMatch(a, b) {
+    if (a.nodeType !== b.nodeType) return false;
+    if (a.nodeType === Node.ELEMENT_NODE) {
+      const aEl = a;
+      const bEl = b;
+      if (aEl.tagName !== bEl.tagName) return false;
+      const aId = aEl.getAttribute("id");
+      const bId = bEl.getAttribute("id");
+      if (aId && bId) return aId === bId;
+      return true;
+    }
+    return true;
+  }
+  findMatchingNode(nodes, startIndex, target) {
+    for (let i = startIndex; i < nodes.length; i++) {
+      if (this.nodesMatch(nodes[i], target)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+};
+function createMorpher(config) {
+  return new DOMmorpher(config);
+}
+function morph(from, to, config) {
+  const morpher = createMorpher(config);
+  morpher.morph(from, to);
+}
+
+// src/speculator.ts
+var SpeculativeRenderer = class {
+  speculations = /* @__PURE__ */ new Map();
+  maxSpeculations;
+  constructor(maxSpeculations = 3) {
+    this.maxSpeculations = maxSpeculations;
+  }
+  async speculate(href, html) {
+    if (this.speculations.has(href)) return;
+    if (this.speculations.size >= this.maxSpeculations) {
+      const oldest = Array.from(this.speculations.values()).sort(
+        (a, b) => a.timestamp - b.timestamp
+      )[0];
+      if (oldest) this.cancel(oldest.href);
+    }
+    const container = this.createDetachedContainer();
+    container.innerHTML = html;
+    this.speculations.set(href, {
+      href,
+      html,
+      container,
+      timestamp: Date.now()
+    });
+  }
+  get(href) {
+    const speculation = this.speculations.get(href);
+    return speculation?.container ?? null;
+  }
+  cancel(href) {
+    const speculation = this.speculations.get(href);
+    if (speculation) {
+      speculation.container.remove();
+      this.speculations.delete(href);
+    }
+  }
+  cancelAll() {
+    this.speculations.forEach((spec) => spec.container.remove());
+    this.speculations.clear();
+  }
+  has(href) {
+    return this.speculations.has(href);
+  }
+  createDetachedContainer() {
+    const container = document.createElement("div");
+    container.style.display = "none";
+    container.setAttribute("data-specnav-speculation", "true");
+    return container;
+  }
+};
+function createSpeculativeRenderer(maxSpeculations) {
+  return new SpeculativeRenderer(maxSpeculations);
+}
+
+// src/graph.ts
+var DEFAULT_CONFIG4 = {
+  enabled: true,
+  minConfidence: 0.6,
+  sessionWeight: 0.7,
+  storageKey: "specnav-graph",
+  maxNodes: 50
+};
+var NavigationGraphLearner = class {
+  config;
+  graph = {};
+  sessionGraph = {};
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG4, ...config };
+    if (this.config.enabled) {
+      this.loadGraph();
+    }
+  }
+  recordNavigation(fromHref, toHref) {
+    if (!this.config.enabled) return;
+    if (!this.sessionGraph[fromHref]) {
+      this.sessionGraph[fromHref] = {};
+    }
+    const current = this.sessionGraph[fromHref][toHref] ?? 0;
+    this.sessionGraph[fromHref][toHref] = current + 1;
+    if (!this.graph[fromHref]) {
+      this.graph[fromHref] = {};
+    }
+    const persistentCurrent = this.graph[fromHref][toHref] ?? 0;
+    this.graph[fromHref][toHref] = persistentCurrent + 1;
+    this.saveGraph();
+  }
+  getPredictions(fromHref) {
+    if (!this.config.enabled) return [];
+    const sessionEdges = this.sessionGraph[fromHref] ?? {};
+    const persistentEdges = this.graph[fromHref] ?? {};
+    const merged = {};
+    Object.entries(persistentEdges).forEach(([href, count]) => {
+      merged[href] = count * (1 - this.config.sessionWeight);
+    });
+    Object.entries(sessionEdges).forEach(([href, count]) => {
+      merged[href] = (merged[href] ?? 0) + count * this.config.sessionWeight;
+    });
+    const total = Object.values(merged).reduce((sum, val) => sum + val, 0);
+    if (total === 0) return [];
+    const predictions = Object.entries(merged).map(([href, count]) => ({
+      href,
+      confidence: count / total
+    })).filter((p) => p.confidence >= this.config.minConfidence).sort((a, b) => b.confidence - a.confidence).map((p) => p.href);
+    return predictions;
+  }
+  getGraph() {
+    return { ...this.graph };
+  }
+  clearGraph() {
+    this.graph = {};
+    this.sessionGraph = {};
+    this.saveGraph();
+  }
+  loadGraph() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const stored = localStorage.getItem(this.config.storageKey);
+      if (stored) {
+        this.graph = JSON.parse(stored);
+        this.pruneGraph();
+      }
+    } catch {
+    }
+  }
+  saveGraph() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      this.pruneGraph();
+      const serialized = JSON.stringify(this.graph);
+      if (serialized.length > 4 * 1024 * 1024) {
+        console.warn("Navigation graph too large, pruning more aggressively");
+        const reducedMaxNodes = Math.floor(this.config.maxNodes / 2);
+        const originalMaxNodes = this.config.maxNodes;
+        this.config.maxNodes = reducedMaxNodes;
+        this.pruneGraph();
+        this.config.maxNodes = originalMaxNodes;
+      }
+      localStorage.setItem(this.config.storageKey, JSON.stringify(this.graph));
+    } catch (error) {
+      if (error instanceof Error && error.name === "QuotaExceededError") {
+        console.warn("localStorage quota exceeded, clearing navigation graph");
+        this.clearGraph();
+      }
+    }
+  }
+  pruneGraph() {
+    const nodes = Object.keys(this.graph);
+    if (nodes.length <= this.config.maxNodes) return;
+    const nodeCounts = nodes.map((node) => ({
+      node,
+      count: Object.values(this.graph[node]).reduce(
+        (sum, val) => sum + val,
+        0
+      )
+    }));
+    nodeCounts.sort((a, b) => b.count - a.count);
+    const toKeep = new Set(
+      nodeCounts.slice(0, this.config.maxNodes).map((n) => n.node)
+    );
+    Object.keys(this.graph).forEach((node) => {
+      if (!toKeep.has(node)) {
+        delete this.graph[node];
+      }
+    });
+  }
+};
+function createNavigationGraphLearner(config) {
+  return new NavigationGraphLearner(config);
+}
+function getNavigationGraph(storageKey = "specnav-graph") {
+  if (typeof localStorage === "undefined") return {};
+  try {
+    const stored = localStorage.getItem(storageKey);
+    return stored ? JSON.parse(stored) : {};
+  } catch {
+    return {};
+  }
+}
+
+// src/adaptive.ts
+var DEFAULT_CONFIG5 = {
+  batteryThreshold: 0.2,
+  connectionTypes: {
+    slow: ["2g", "3g", "slow-2g"],
+    fast: ["4g"]
+  },
+  respectSaveData: true,
+  respectReducedMotion: true
+};
+var AdaptiveMode = class {
+  config;
+  battery = null;
+  connection = null;
+  initPromise;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG5, ...config };
+    this.initPromise = this.initialize();
+  }
+  async waitForInit() {
+    await this.initPromise;
+  }
+  async initialize() {
+    if (typeof navigator === "undefined") return;
+    if ("getBattery" in navigator) {
+      try {
+        this.battery = await navigator.getBattery();
+      } catch {
+      }
+    }
+    if ("connection" in navigator || "mozConnection" in navigator || "webkitConnection" in navigator) {
+      this.connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    }
+  }
+  getStrategy(baseStrategy) {
+    if (baseStrategy === "off") return "off";
+    if (baseStrategy !== "auto") return baseStrategy;
+    if (this.config.respectSaveData && this.hasSaveData()) {
+      return "off";
+    }
+    if (this.isLowBattery()) {
+      return "conservative";
+    }
+    if (this.isSlowConnection()) {
+      return "conservative";
+    }
+    return "aggressive";
+  }
+  shouldPrefetch() {
+    if (this.config.respectSaveData && this.hasSaveData()) {
+      return false;
+    }
+    if (this.isLowBattery()) {
+      return false;
+    }
+    return true;
+  }
+  shouldSpeculate() {
+    if (!this.shouldPrefetch()) {
+      return false;
+    }
+    if (this.isSlowConnection()) {
+      return false;
+    }
+    return true;
+  }
+  shouldUseTransitions() {
+    if (!this.config.respectReducedMotion) return true;
+    if (typeof window === "undefined") return true;
+    return !window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+  }
+  hasSaveData() {
+    if (typeof navigator === "undefined") return false;
+    return navigator.connection?.saveData === true || navigator.mozConnection?.saveData === true || navigator.webkitConnection?.saveData === true;
+  }
+  isLowBattery() {
+    if (!this.battery) return false;
+    return !this.battery.charging && this.battery.level < this.config.batteryThreshold;
+  }
+  isSlowConnection() {
+    if (!this.connection) return false;
+    const effectiveType = this.connection.effectiveType;
+    if (!effectiveType) return false;
+    return this.config.connectionTypes.slow.includes(effectiveType);
+  }
+  isFastConnection() {
+    if (!this.connection) return true;
+    const effectiveType = this.connection.effectiveType;
+    if (!effectiveType) return true;
+    return this.config.connectionTypes.fast.includes(effectiveType);
+  }
+  getBatteryLevel() {
+    return this.battery?.level ?? null;
+  }
+  getConnectionType() {
+    return this.connection?.effectiveType ?? null;
+  }
+};
+function createAdaptiveMode(config) {
+  return new AdaptiveMode(config);
+}
+
+// src/performance.ts
+var PerformanceMonitor = class {
+  metrics = [];
+  maxMetrics = 100;
+  recordNavigation(metrics) {
+    this.metrics.push(metrics);
+    if (this.metrics.length > this.maxMetrics) {
+      this.metrics.shift();
+    }
+  }
+  getAverageNavigationTime() {
+    if (this.metrics.length === 0) return 0;
+    const sum = this.metrics.reduce((acc, m) => acc + m.navigationTime, 0);
+    return sum / this.metrics.length;
+  }
+  getCacheHitRate() {
+    if (this.metrics.length === 0) return 0;
+    const hits = this.metrics.filter((m) => m.cacheHit).length;
+    return hits / this.metrics.length;
+  }
+  getSpeculativeHitRate() {
+    if (this.metrics.length === 0) return 0;
+    const hits = this.metrics.filter((m) => m.speculativeHit).length;
+    return hits / this.metrics.length;
+  }
+  getMetrics() {
+    return [...this.metrics];
+  }
+  clear() {
+    this.metrics = [];
+  }
+};
+var performanceMonitor = new PerformanceMonitor();
+
+exports.AdaptiveMode = AdaptiveMode;
+exports.CacheManager = CacheManager;
+exports.DOMmorpher = DOMmorpher;
+exports.NavigationGraphLearner = NavigationGraphLearner;
+exports.PerformanceMonitor = PerformanceMonitor;
+exports.SpeculativeRenderer = SpeculativeRenderer;
+exports.TrajectoryEngine = TrajectoryEngine;
+exports.createAdaptiveMode = createAdaptiveMode;
+exports.createCacheManager = createCacheManager;
+exports.createMorpher = createMorpher;
+exports.createNavigationGraphLearner = createNavigationGraphLearner;
+exports.createSpeculativeRenderer = createSpeculativeRenderer;
+exports.createTrajectoryEngine = createTrajectoryEngine;
+exports.getNavigationGraph = getNavigationGraph;
+exports.morph = morph;
+exports.performanceMonitor = performanceMonitor;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map