intently 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sean Geng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,157 @@
+# intently
+
+**Intent-aware prefetching.** Most prefetchers load every link in the viewport, or wait for a hover. intently watches where the cursor is actually *heading* — proximity and trajectory, the same prediction that powers a focus ring that warms as you approach — and prefetches (or **prerenders**, via the native Speculation Rules API) the link a beat before you click. Zero-config, ~4KB, framework-agnostic.
+
+[**intentlyjs.com**](https://intentlyjs.com) · [npm](https://www.npmjs.com/package/intently) · [GitHub](https://github.com/seangeng/intently) · [the writeup](https://seangeng.com/writing/prefetching-on-intent)
+
+```bash
+npm i intently
+```
+
+## Quick start
+
+One call binds every eligible same-origin link on the page:
+
+```js
+import { intently } from "intently";
+
+intently();
+```
+
+That's it. Move toward a link and intently prefetches its destination during the
+~200ms between intent and click, so the navigation feels instant. React:
+
+```tsx
+import { useIntently } from "intently/react";
+
+function App() {
+  useIntently();        // once, near the root
+  return <Routes />;
+}
+```
+
+## Why another prefetcher
+
+There are good ones, and intently borrows the best of each:
+
+- [**quicklink**](https://github.com/GoogleChromeLabs/quicklink) prefetches links
+  *in the viewport* when the browser is idle. Great coverage, but it can't tell
+  the one link you want from the fifty you don't.
+- [**instant.page**](https://instant.page) prefetches on *hover* (a 65ms dwell).
+  Precise, but hover is late — the decision is already made by the time you've
+  parked the cursor.
+- [**ForesightJS**](https://github.com/spaansba/ForesightJS) predicts intent from
+  mouse *trajectory* — the right signal — but you register elements yourself and
+  wire up the prefetch.
+
+intently combines them: **zero-config auto-binding** (drop it in, every `<a>` is
+covered) + **trajectory + proximity prediction** (the link you're aimed at, not
+the one you happen to be near) + a **tiered loader that uses the Speculation
+Rules API** for real prefetch *and* prerender, degrading to `<link rel=prefetch>`
+and then `fetch` where that isn't supported.
+
+The trajectory idea is old — there are
+[patents on cursor extrapolation](https://patents.google.com/patent/US8566696)
+going back years, and ForesightJS does it well today. intently's bet is that
+*prediction + the right modern loader + nothing to configure* is the combination
+worth shipping.
+
+## How it works
+
+Three things, kept small:
+
+**1. Predict.** On every `pointermove`, intently keeps a smoothed velocity. For
+each on-screen link it computes two scores — *proximity* (distance to the link's
+nearest edge, on a squared falloff) and *trajectory* (the dot product of your
+heading with the direction to the link, gated by a forward cone). The higher of
+the two is the confidence that this link is your next click. (This is the same
+math as the [input-anticipation](https://seangeng.com/writing/interfaces-that-anticipate-input)
+focus ring — here it drives a fetch instead of a glow.)
+
+**2. Tier by confidence.** Crossing `intentThreshold` (default `0.5`) prefetches.
+Sustained high confidence past `prerenderThreshold` (default `0.85`) upgrades to
+a *prerender* — the next page is fully built in a hidden tab, so the click is
+instant, not just fast. Prerender is expensive, so it stays rare and high-bar.
+
+**3. Load with the best available backend.**
+
+| Tier | Used when | Does |
+|------|-----------|------|
+| Speculation Rules API | Chromium | real `prefetch` **and** `prerender`, cross-document, browser-prioritized |
+| `<link rel="prefetch">` | most browsers | prefetch only |
+| `fetch()` low priority | last resort | warms the HTTP cache |
+
+Only in-viewport links are scored (via `IntersectionObserver`), the scoring loop
+sleeps when the pointer is still, and every URL loads once. Offscreen links cost
+nothing.
+
+## Options
+
+```js
+intently({
+  origins: [location.hostname],   // hostnames allowed; or a (url, el) => boolean
+  ignores: [/\/logout/, "?add-to-cart"], // never touch these (strings or RegExps)
+  signals: ["trajectory", "proximity", "hover", "touch"], // which to use
+  intentThreshold: 0.5,           // confidence (0–1) to prefetch
+  prerenderThreshold: 0.85,       // confidence to prerender; false to disable
+  proximityRadius: 80,            // px — how far a link "notices" the cursor
+  hoverDelay: 65,                 // ms dwell before hover counts (instant.page's number)
+  eagerOnPress: true,             // prefetch immediately on pointerdown / touchstart
+  viewportPrefetch: false,        // also idle-prefetch in-view links (quicklink-style)
+  limit: Infinity,                // cap total loads
+  respectSaveData: true,          // skip on Save-Data / 2g
+  onPredict: ({ el, url, confidence, signal }) => {}, // wire a visual affordance
+  onLoad: (url, strategy) => {},  // "prefetch" | "prerender"
+});
+```
+
+`intently()` returns a handle:
+
+```js
+const i = intently();
+i.prefetch("/pricing");   // force it
+i.prerender("/checkout"); // force it (falls back to prefetch where unsupported)
+i.loaded;                 // ReadonlySet<string> of URLs loaded this session
+i.destroy();              // remove every listener/observer
+```
+
+### Exposed prediction helpers
+
+The prediction math is exported if you want to build your own affordance (a ring
+that warms as confidence rises, say):
+
+```js
+import { distanceToRect, falloff, proximityScore, trajectoryScore } from "intently";
+```
+
+## Safety & taste
+
+- **It only guesses same-origin links** by default, and never touches anything in
+  `ignores`. Put sign-out, "add to cart", language switches, and any link with
+  side effects there — especially before enabling prerender, which *runs* the
+  page.
+- **It respects the user.** Save-Data and 2g connections turn it off. A still
+  cursor predicts nothing.
+- **It degrades.** No Speculation Rules → `<link rel=prefetch>` → `fetch`. SSR /
+  no-DOM → a no-op handle.
+- **Prefetch is a hint, not a navigation.** The real click always works whether
+  or not the guess landed.
+
+## When it helps (and when it doesn't)
+
+Biggest wins are **multi-page apps** and **hard navigations** — content sites,
+docs, e-commerce, blogs — where the next page is a real document fetch. For SPAs
+with a client router (React Router, Next.js), those frameworks already prefetch
+route data; intently still helps for outbound and non-router links, and its
+prediction layer is reusable.
+
+## Credits
+
+Trajectory prediction by way of [ForesightJS](https://github.com/spaansba/ForesightJS)
+and a long line of [cursor-extrapolation prior art](https://patents.google.com/patent/US8566696);
+zero-config ergonomics from [instant.page](https://instant.page); viewport idle
+prefetch from [quicklink](https://github.com/GoogleChromeLabs/quicklink); the
+prediction math from my own [input-anticipation](https://seangeng.com/writing/interfaces-that-anticipate-input)
+work. Built on the [Speculation Rules API](https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API).
+
+By [Sean Geng](https://seangeng.com). MIT.

package/dist/chunk-WUH3J7BB.js

@@ -0,0 +1,462 @@
+// src/predict.ts
+function distanceToRect(x, y, r) {
+  const dx = Math.max(r.left - x, 0, x - r.right);
+  const dy = Math.max(r.top - y, 0, y - r.bottom);
+  return Math.hypot(dx, dy);
+}
+function falloff(distance, radius, exponent = 2) {
+  return Math.max(0, 1 - distance / radius) ** exponent;
+}
+function proximityScore(x, y, r, radius) {
+  return falloff(distanceToRect(x, y, r), radius);
+}
+function trajectoryScore(x, y, v, r, cone = 0.6) {
+  const speed = Math.hypot(v.x, v.y);
+  if (speed < 0.04) return 0;
+  const cx = (r.left + r.right) / 2;
+  const cy = (r.top + r.bottom) / 2;
+  const dx = cx - x;
+  const dy = cy - y;
+  const d = Math.hypot(dx, dy) || 1;
+  const align = dx / d * (v.x / speed) + dy / d * (v.y / speed);
+  if (align <= cone) return 0;
+  const aligned = (align - cone) / (1 - cone);
+  const committed = Math.min(1, speed / 0.6);
+  return aligned * (0.6 + 0.4 * committed);
+}
+function updateVelocity(v, prev, x, y, t, smoothing = 0.7) {
+  if (prev) {
+    const dt = Math.max(1, t - prev.t);
+    v.x = v.x * smoothing + (x - prev.x) / dt * (1 - smoothing);
+    v.y = v.y * smoothing + (y - prev.y) / dt * (1 - smoothing);
+  }
+}
+
+// src/eligibility.ts
+function shouldRun(respectSaveData) {
+  if (typeof navigator === "undefined") return false;
+  if (!respectSaveData) return true;
+  const c = navigator.connection;
+  if (!c) return true;
+  if (c.saveData) return false;
+  if (typeof c.effectiveType === "string" && /(^|-)2g$/.test(c.effectiveType)) return false;
+  return true;
+}
+function makeEligible(opts) {
+  const here = typeof location !== "undefined" ? location : null;
+  const originOk = (url, el) => {
+    if (typeof opts.origins === "function") return opts.origins(url, el);
+    const allow = opts.origins ?? (here ? [here.hostname] : []);
+    return allow.includes(url.hostname);
+  };
+  const ignored = (url, el) => {
+    const ig = opts.ignores;
+    if (!ig) return false;
+    if (typeof ig === "function") return ig(url, el);
+    return ig.some(
+      (rule) => typeof rule === "string" ? url.href.includes(rule) : rule.test(url.href)
+    );
+  };
+  return (el) => {
+    const href = el.href;
+    if (!href) return null;
+    let url;
+    try {
+      url = new URL(href, here?.href);
+    } catch {
+      return null;
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    if (el.hasAttribute("download")) return null;
+    if (here && url.href.replace(/#.*$/, "") === here.href.replace(/#.*$/, "")) return null;
+    if (!originOk(url, el)) return null;
+    if (ignored(url, el)) return null;
+    return url.href;
+  };
+}
+
+// src/loader.ts
+var speculationRulesSupported = typeof HTMLScriptElement !== "undefined" && typeof HTMLScriptElement.supports === "function" && HTMLScriptElement.supports("speculationrules");
+var linkPrefetchSupported = (() => {
+  if (typeof document === "undefined") return false;
+  try {
+    const l = document.createElement("link");
+    return l.relList && l.relList.supports && l.relList.supports("prefetch");
+  } catch {
+    return false;
+  }
+})();
+var MAX_NODES = 50;
+var MAX_PRERENDERS = 3;
+function createLoader(limit) {
+  const loaded = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const prerenderNodes = [];
+  let count = 0;
+  function track(node) {
+    nodes.push(node);
+    while (nodes.length > MAX_NODES) nodes.shift()?.remove();
+  }
+  const tier = speculationRulesSupported ? "speculationrules" : linkPrefetchSupported ? "link" : typeof fetch === "function" ? "fetch" : "none";
+  function addSpeculationRule(url, strategy) {
+    const script = document.createElement("script");
+    script.type = "speculationrules";
+    script.textContent = JSON.stringify({
+      [strategy]: [{ source: "list", urls: [url], eagerness: "immediate" }]
+    });
+    document.head.appendChild(script);
+    if (strategy === "prerender") {
+      prerenderNodes.push({ url, node: script });
+      while (prerenderNodes.length > MAX_PRERENDERS) {
+        const old = prerenderNodes.shift();
+        if (old) {
+          old.node.remove();
+          loaded.delete(old.url);
+        }
+      }
+    } else {
+      track(script);
+    }
+  }
+  function addPrefetchLink(url) {
+    const link = document.createElement("link");
+    link.rel = "prefetch";
+    link.href = url;
+    document.head.appendChild(link);
+    track(link);
+  }
+  return {
+    tier,
+    load(url, strategy) {
+      if (tier === "none") return null;
+      const prior = loaded.get(url);
+      if (prior === "prerender" || prior === "prefetch" && strategy === "prefetch") {
+        return null;
+      }
+      if (prior === void 0 && count >= limit) return null;
+      if (prior === void 0) count++;
+      const effective = strategy === "prerender" && tier !== "speculationrules" ? "prefetch" : strategy;
+      if (tier === "speculationrules") {
+        addSpeculationRule(url, effective);
+      } else if (tier === "link") {
+        if (prior === void 0) addPrefetchLink(url);
+      } else {
+        if (prior === void 0) {
+          fetch(url, { credentials: "same-origin" }).catch(() => {
+          });
+        }
+      }
+      loaded.set(url, effective);
+      return effective;
+    },
+    destroy() {
+      for (const n of nodes) n.remove();
+      for (const p of prerenderNodes) p.node.remove();
+      nodes.length = 0;
+      prerenderNodes.length = 0;
+      loaded.clear();
+      count = 0;
+    }
+  };
+}
+
+// src/core.ts
+var DEFAULTS = {
+  intentThreshold: 0.5,
+  prerenderThreshold: 0.85,
+  proximityRadius: 80,
+  hoverDelay: 65,
+  eagerOnPress: true,
+  viewportPrefetch: false,
+  limit: Infinity,
+  respectSaveData: true
+};
+var ARM_FRAMES = 8;
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function intently(options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  const root = opts.root ?? (typeof document !== "undefined" ? document : null);
+  const loader = createLoader(opts.limit);
+  const signals = new Set(opts.signals ?? ["trajectory", "proximity", "hover", "touch"]);
+  const useTrajectory = signals.has("trajectory");
+  const useProximity = signals.has("proximity");
+  const useHover = signals.has("hover");
+  const usePress = opts.eagerOnPress;
+  const useViewport = signals.has("viewport") || opts.viewportPrefetch;
+  if (typeof window === "undefined" || !root || loader.tier === "none" || !shouldRun(opts.respectSaveData)) {
+    return { prefetch() {
+    }, prerender() {
+    }, destroy() {
+    }, loaded: /* @__PURE__ */ new Set() };
+  }
+  const eligible = makeEligible(opts);
+  const scopeEl = root instanceof Element ? root : null;
+  const candidates = /* @__PURE__ */ new Map();
+  const visible = /* @__PURE__ */ new Set();
+  const rectCache = /* @__PURE__ */ new Map();
+  const loadedView = /* @__PURE__ */ new Set();
+  let rectsDirty = false;
+  let destroyed = false;
+  const pointer = { x: 0, y: 0 };
+  const vel = { x: 0, y: 0 };
+  let prevSample = null;
+  let lastMove = 0;
+  let lastMeasure = 0;
+  let raf = 0;
+  function prerenderSafe(el, urlStr) {
+    try {
+      if (new URL(urlStr).search) return false;
+    } catch {
+      return false;
+    }
+    const rel = (el.getAttribute("rel") || "").toLowerCase();
+    if (/\b(nofollow|external)\b/.test(rel)) return false;
+    const target = el.getAttribute("target");
+    if (target && target !== "_self") return false;
+    return true;
+  }
+  function load(el, url, confidence, wantPrerender) {
+    if (destroyed) return;
+    let strategy = "prefetch";
+    if (wantPrerender && opts.prerenderThreshold !== false && confidence >= opts.prerenderThreshold && prerenderSafe(el, url)) {
+      strategy = "prerender";
+    }
+    const used = loader.load(url, strategy);
+    if (used) {
+      loadedView.add(url);
+      opts.onLoad?.(url, used);
+    }
+  }
+  function emit(el, c, confidence, signal) {
+    if (!opts.onPredict) return;
+    if (Math.abs(c.emitted - confidence) < 0.02) return;
+    c.emitted = confidence;
+    opts.onPredict({ el, url: c.url, confidence, signal });
+  }
+  function consider(el) {
+    const url = scopeEl && !scopeEl.contains(el) ? null : eligible(el);
+    const existing = candidates.get(el);
+    if (!url) {
+      if (existing) drop(el);
+      return null;
+    }
+    if (existing) {
+      existing.url = url;
+      return existing;
+    }
+    const c = { url, armedFrames: 0, emitted: -1 };
+    candidates.set(el, c);
+    io.observe(el);
+    return c;
+  }
+  function drop(el) {
+    const c = candidates.get(el);
+    if (c) {
+      if (c.emitted > 0) emit(el, c, 0, "proximity");
+      candidates.delete(el);
+      io.unobserve(el);
+      visible.delete(el);
+      rectCache.delete(el);
+    }
+  }
+  function scan() {
+    root.querySelectorAll("a[href]").forEach(consider);
+  }
+  const io = new IntersectionObserver(
+    (entries) => {
+      for (const e of entries) {
+        const el = e.target;
+        if (e.isIntersecting) {
+          visible.add(el);
+          rectCache.set(el, e.boundingClientRect);
+          if (useViewport) {
+            idle(() => {
+              const cc = candidates.get(el);
+              if (cc && !loadedView.has(cc.url)) load(el, cc.url, 0, false);
+            });
+          }
+        } else {
+          visible.delete(el);
+          rectCache.delete(el);
+          const c = candidates.get(el);
+          if (c && c.emitted > 0) emit(el, c, 0, "proximity");
+        }
+      }
+    },
+    { rootMargin: "0px" }
+  );
+  const mo = new MutationObserver((muts) => {
+    for (const m of muts) {
+      if (m.type === "attributes") {
+        if (m.target instanceof HTMLAnchorElement) consider(m.target);
+        continue;
+      }
+      m.addedNodes.forEach((n) => {
+        if (!(n instanceof Element)) return;
+        if (n.matches?.("a[href]")) consider(n);
+        n.querySelectorAll?.("a[href]").forEach(consider);
+      });
+      m.removedNodes.forEach((n) => {
+        if (!(n instanceof Element)) return;
+        if (n.matches?.("a[href]")) drop(n);
+        n.querySelectorAll?.("a[href]").forEach((el) => drop(el));
+      });
+    }
+  });
+  function refreshRects() {
+    for (const el of visible) rectCache.set(el, el.getBoundingClientRect());
+    rectsDirty = false;
+  }
+  function kick() {
+    if (!raf && !destroyed && (useProximity || useTrajectory)) raf = requestAnimationFrame(tick);
+  }
+  function tick(t) {
+    if (destroyed) {
+      raf = 0;
+      return;
+    }
+    if (document.hidden || t - lastMove > 500) {
+      raf = 0;
+      return;
+    }
+    if (rectsDirty || t - lastMeasure > 250) {
+      refreshRects();
+      lastMeasure = t;
+    }
+    if (t - lastMove > 80) {
+      vel.x = 0;
+      vel.y = 0;
+    }
+    for (const el of visible) {
+      const c = candidates.get(el);
+      if (!c || loadedView.has(c.url)) continue;
+      const r = rectCache.get(el);
+      if (!r) continue;
+      const prox = useProximity ? proximityScore(pointer.x, pointer.y, r, opts.proximityRadius) : 0;
+      const traj = useTrajectory ? trajectoryScore(pointer.x, pointer.y, vel, r) : 0;
+      const confidence = Math.max(prox, traj);
+      const signal = traj >= prox ? "trajectory" : "proximity";
+      if (confidence < 0.05) {
+        c.armedFrames = 0;
+        emit(el, c, 0, signal);
+        continue;
+      }
+      let wantPrerender = false;
+      if (opts.prerenderThreshold !== false && confidence >= opts.prerenderThreshold) {
+        c.armedFrames++;
+        if (c.armedFrames >= ARM_FRAMES) wantPrerender = true;
+      } else {
+        c.armedFrames = 0;
+      }
+      if (confidence >= opts.intentThreshold || wantPrerender) {
+        load(el, c.url, confidence, wantPrerender);
+      }
+      emit(el, c, confidence, signal);
+    }
+    raf = requestAnimationFrame(tick);
+  }
+  function onMove(e) {
+    updateVelocity(vel, prevSample, e.clientX, e.clientY, e.timeStamp);
+    prevSample = { x: e.clientX, y: e.clientY, t: e.timeStamp };
+    pointer.x = e.clientX;
+    pointer.y = e.clientY;
+    lastMove = now();
+    kick();
+  }
+  let hovered = null;
+  let hoverTimer = 0;
+  function onOver(e) {
+    const a = e.target?.closest?.("a[href]");
+    if (!a || a === hovered) return;
+    hovered = a;
+    clearTimeout(hoverTimer);
+    const c = consider(a);
+    if (!c || loadedView.has(c.url)) return;
+    hoverTimer = window.setTimeout(() => {
+      if (hovered === a) load(a, c.url, 1, true);
+    }, opts.hoverDelay);
+  }
+  function onOut(e) {
+    if (hovered && e.relatedTarget instanceof Node && hovered.contains(e.relatedTarget)) return;
+    hovered = null;
+    clearTimeout(hoverTimer);
+  }
+  function onPress(e) {
+    const a = e.target?.closest?.("a[href]");
+    if (!a) return;
+    const c = consider(a);
+    if (c && !loadedView.has(c.url)) load(a, c.url, 1, false);
+  }
+  function onScroll() {
+    rectsDirty = true;
+  }
+  function onVisibility() {
+    if (!document.hidden) {
+      lastMove = now();
+      kick();
+    }
+  }
+  function idle(fn) {
+    const ric = window.requestIdleCallback;
+    const guarded = () => {
+      if (!destroyed) fn();
+    };
+    if (ric) ric(guarded);
+    else setTimeout(guarded, 1);
+  }
+  scan();
+  mo.observe(scopeEl ?? document.documentElement, {
+    childList: true,
+    subtree: true,
+    attributes: true,
+    attributeFilter: ["href"]
+  });
+  window.addEventListener("pointermove", onMove, { passive: true });
+  if (useHover) {
+    window.addEventListener("pointerover", onOver, { passive: true });
+    window.addEventListener("pointerout", onOut, { passive: true });
+  }
+  if (usePress) {
+    window.addEventListener("pointerdown", onPress, { passive: true });
+    window.addEventListener("touchstart", onPress, { passive: true });
+  }
+  window.addEventListener("scroll", onScroll, { passive: true, capture: true });
+  window.addEventListener("resize", onScroll, { passive: true });
+  document.addEventListener("visibilitychange", onVisibility);
+  return {
+    prefetch: (url) => {
+      const used = loader.load(url, "prefetch");
+      if (used) loadedView.add(url);
+    },
+    prerender: (url) => {
+      const used = loader.load(url, "prerender");
+      if (used) loadedView.add(url);
+    },
+    destroy() {
+      destroyed = true;
+      if (raf) cancelAnimationFrame(raf);
+      clearTimeout(hoverTimer);
+      io.disconnect();
+      mo.disconnect();
+      window.removeEventListener("pointermove", onMove);
+      window.removeEventListener("pointerover", onOver);
+      window.removeEventListener("pointerout", onOut);
+      window.removeEventListener("pointerdown", onPress);
+      window.removeEventListener("touchstart", onPress);
+      window.removeEventListener("scroll", onScroll, { capture: true });
+      window.removeEventListener("resize", onScroll);
+      document.removeEventListener("visibilitychange", onVisibility);
+      loader.destroy();
+      candidates.clear();
+      visible.clear();
+      rectCache.clear();
+    },
+    loaded: loadedView
+  };
+}
+
+export { distanceToRect, falloff, intently, proximityScore, trajectoryScore, updateVelocity };
+//# sourceMappingURL=chunk-WUH3J7BB.js.map
+//# sourceMappingURL=chunk-WUH3J7BB.js.map