@valbuild/react 0.148.2 → 0.148.4

package/analytics/dist/valbuild-react-analytics.browser.esm.js

@@ -0,0 +1,950 @@
+import { _ as _slicedToArray } from '../../dist/slicedToArray-8f9b0d84.browser.esm.js';
+import { _ as _toConsumableArray } from '../../dist/toConsumableArray-991f680f.browser.esm.js';
+import { _ as _createForOfIteratorHelper } from '../../dist/createForOfIteratorHelper-c0be3691.browser.esm.js';
+
+/**
+ * The analytics wire format, version 1: what the browser sends to
+ * `POST /api/val/analytics`. See `docs/plans/analytics.md`, "Wire format".
+ *
+ * Nothing in this directory may import `@valbuild/core`, `@valbuild/shared`
+ * or zod: this is code every visitor of a site downloads, and those three are
+ * most of the weight Val already puts on a page (`client-bundle-weight.md`).
+ * `imports.test.ts` keeps it so. The zod schema the server parses this with
+ * is `AnalyticsBeacon` in `@valbuild/shared/internal`, and `beacon.test.ts`
+ * checks the two agree.
+ */
+
+/** What only the first beacon of a page view carries. Its presence IS the page view. */
+
+/** Module file path → module paths (the part of a source path after `?p=`). */
+
+/**
+ * The receiver rejects a beacon above these (`AnalyticsBeacon` in
+ * `@valbuild/shared/internal` repeats them), so the sender never sends more:
+ * it cuts or drops what is longer, and splits what is larger.
+ */
+var MAX_PATHS_PER_BEACON = 200;
+var MAX_ROUTE_LENGTH = 512;
+var MAX_UTM_LENGTH = 100;
+/** A host name is at most 253 characters (RFC 1035). */
+var MAX_REF_LENGTH = 253;
+var MAX_CV_LENGTH = 128;
+var MAX_MODULE_FILE_PATH_LENGTH = 512;
+var MAX_MODULE_PATH_LENGTH = 1024;
+/**
+ * A beacon's size in bytes of JSON, below the 16 KB Val's hosting accepts --
+ * 200 long router keys are about 18 KB. `sendBeacon` itself takes 64 KB.
+ */
+var MAX_BEACON_BYTES = 12000;
+var MODULE_FILE_PATH_SEP = "?p=";
+
+/** Phone below 640 px of viewport width, tablet below 1024, desktop above. */
+function deviceOf(viewportWidth) {
+  if (viewportWidth < 640) {
+    return "phone";
+  }
+  if (viewportWidth < 1024) {
+    return "tablet";
+  }
+  return "desktop";
+}
+
+/**
+ * The referrer's host, when it is another site -- never its path or query,
+ * which can carry anything. A referrer from this site is navigation within it,
+ * not a source.
+ */
+function referrerHostOf(referrer, ownHost) {
+  if (!referrer) {
+    return undefined;
+  }
+  var host;
+  try {
+    host = new URL(referrer).host;
+  } catch (_unused) {
+    return undefined;
+  }
+  if (!host || host === ownHost) {
+    return undefined;
+  }
+  return host.slice(0, MAX_REF_LENGTH);
+}
+
+/** `utm_source`, `utm_medium` and `utm_campaign`, and no other parameter. */
+function utmOf(search) {
+  var params = new URLSearchParams(search);
+  var utm = {};
+  var _iterator = _createForOfIteratorHelper(["source", "medium", "campaign"]),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      var value = params.get("utm_".concat(key));
+      if (value) {
+        utm[key] = value.slice(0, MAX_UTM_LENGTH);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return Object.keys(utm).length > 0 ? utm : undefined;
+}
+function routeOf(pathname) {
+  return pathname.slice(0, MAX_ROUTE_LENGTH);
+}
+
+/** Splits a source path into its module file path and its module path. */
+function splitSourcePath(sourcePath) {
+  var at = sourcePath.indexOf(MODULE_FILE_PATH_SEP);
+  if (at === -1) {
+    return [sourcePath, ""];
+  }
+  return [sourcePath.slice(0, at), sourcePath.slice(at + MODULE_FILE_PATH_SEP.length)];
+}
+
+/**
+ * The beacons that carry `rendered` and `viewed`: at most
+ * `MAX_PATHS_PER_BEACON` paths and about `MAX_BEACON_BYTES` each. `view`, when
+ * given, goes in the first. Returns none when there is nothing to say.
+ *
+ * A path longer than the receiver takes is dropped rather than cut: half a
+ * path names some other content, or none.
+ */
+function buildBeacons(args) {
+  var _args$cv;
+  var counted = function counted(kind, sourcePath) {
+    var _splitSourcePath = splitSourcePath(sourcePath),
+      _splitSourcePath2 = _slicedToArray(_splitSourcePath, 2),
+      moduleFilePath = _splitSourcePath2[0],
+      modulePath = _splitSourcePath2[1];
+    if (moduleFilePath.length > MAX_MODULE_FILE_PATH_LENGTH || modulePath.length > MAX_MODULE_PATH_LENGTH) {
+      return [];
+    }
+    return [{
+      kind: kind,
+      moduleFilePath: moduleFilePath,
+      modulePath: modulePath
+    }];
+  };
+  var all = [].concat(_toConsumableArray(args.rendered.flatMap(function (path) {
+    return counted("rendered", path);
+  })), _toConsumableArray(args.viewed.flatMap(function (path) {
+    return counted("viewed", path);
+  })));
+  if (all.length === 0 && !args.view) {
+    return [];
+  }
+  var cv = (_args$cv = args.cv) === null || _args$cv === void 0 ? void 0 : _args$cv.slice(0, MAX_CV_LENGTH);
+  var empty = function empty(withView) {
+    var beacon = {
+      v: 1,
+      route: args.route,
+      rendered: {},
+      viewed: {}
+    };
+    if (cv) {
+      beacon.cv = cv;
+    }
+    if (withView && args.view) {
+      beacon.view = args.view;
+    }
+    return beacon;
+  };
+  var beacons = [];
+  var beacon = empty(true);
+  var paths = 0;
+  var bytes = byteLength(JSON.stringify(beacon));
+  // What adding a path costs: the path and a comma, and a new key when its
+  // module is not in this beacon yet. An estimate in UTF-8 bytes, close
+  // enough to keep well under the limit.
+  var costOf = function costOf(path) {
+    return byteLength(JSON.stringify(path.modulePath)) + 1 + (beacon[path.kind][path.moduleFilePath] ? 0 : byteLength(JSON.stringify(path.moduleFilePath)) + 4);
+  };
+  var _iterator2 = _createForOfIteratorHelper(all),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _beacon$path$kind, _path$moduleFilePath, _beacon$path$kind$_pa;
+      var path = _step2.value;
+      var cost = costOf(path);
+      if (paths > 0 && (paths === MAX_PATHS_PER_BEACON || bytes + cost > MAX_BEACON_BYTES)) {
+        beacons.push(beacon);
+        beacon = empty(false);
+        paths = 0;
+        bytes = byteLength(JSON.stringify(beacon));
+        cost = costOf(path);
+      }
+      ((_beacon$path$kind$_pa = (_beacon$path$kind = beacon[path.kind])[_path$moduleFilePath = path.moduleFilePath]) !== null && _beacon$path$kind$_pa !== void 0 ? _beacon$path$kind$_pa : _beacon$path$kind[_path$moduleFilePath] = []).push(path.modulePath);
+      paths += 1;
+      bytes += cost;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  beacons.push(beacon);
+  return beacons;
+}
+function byteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
+
+/**
+ * The source paths in a `data-val-path` attribute.
+ *
+ * One element can show several pieces of content, and `attrs()` and
+ * `autoTagJSX` join their paths with commas. Core's `splitJoinedSourcePaths`
+ * splits on every comma, which cuts a path whose record key holds one
+ * (`"/blog/a,b"`). This splits only on commas outside the JSON strings a
+ * module path is made of, so it agrees with core wherever core is right and
+ * keeps such a path whole. It is here rather than imported because nothing in
+ * this directory may import core -- see `beacon.ts`.
+ */
+function splitValPaths(attribute) {
+  if (!attribute) {
+    return [];
+  }
+  var paths = [];
+  var current = "";
+  var inString = false;
+  var escaped = false;
+  var _iterator = _createForOfIteratorHelper(attribute),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _char = _step.value;
+      if (inString) {
+        current += _char;
+        if (escaped) {
+          escaped = false;
+        } else if (_char === "\\") {
+          escaped = true;
+        } else if (_char === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (_char === '"') {
+        inString = true;
+        current += _char;
+        continue;
+      }
+      if (_char === ",") {
+        if (current) {
+          paths.push(current);
+        }
+        current = "";
+        continue;
+      }
+      current += _char;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (current) {
+    paths.push(current);
+  }
+  return paths;
+}
+
+var SELECTOR = "[data-val-path]";
+var ATTRIBUTE = "data-val-path";
+/** Every 5%, so an element far taller than the screen still crosses one. */
+var THRESHOLDS = Array.from({
+  length: 21
+}, function (_, i) {
+  return i / 20;
+});
+
+/**
+ * Counts which content a visitor's page shows, and sends it.
+ *
+ * - **Rendered**: an element with a `data-val-path` is in the document.
+ * - **Viewed**: one is at least half visible -- or covers at least half the
+ *   viewport, for an element taller than it -- for `viewedAfterMs` without a
+ *   break, while the page is visible.
+ *
+ * Each path counts at most once of each per page view. A page view starts with
+ * the page and with every client-side navigation to another pathname; content
+ * still on screen after one (a header, a footer) counts again for the new one,
+ * because it was rendered on it.
+ *
+ * Returns null where it does nothing: on the server, and for an automated
+ * browser (`navigator.webdriver`). The caller decides the rest -- draft mode,
+ * the Studio's canvas and an editor browsing with Val enabled all count
+ * nothing, and the provider does not start it for them.
+ *
+ * A page the browser PRERENDERS (speculation rules, the address bar's guess
+ * at where the visitor is going) is hydrated with nobody looking, and may
+ * never be looked at: nothing starts until it is shown, and nothing at all
+ * if it never is.
+ */
+function startValAnalytics() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (navigator.webdriver) {
+    return null;
+  }
+  if (!isPrerendering()) {
+    return startNow(options);
+  }
+  var tracker = null;
+  var stopped = false;
+  var onShown = function onShown() {
+    if (!stopped) {
+      tracker = startNow(options);
+    }
+  };
+  document.addEventListener("prerenderingchange", onShown, {
+    once: true
+  });
+  return {
+    flush: function flush() {
+      var _tracker;
+      return (_tracker = tracker) === null || _tracker === void 0 ? void 0 : _tracker.flush();
+    },
+    stop: function stop() {
+      var _tracker2;
+      stopped = true;
+      document.removeEventListener("prerenderingchange", onShown);
+      (_tracker2 = tracker) === null || _tracker2 === void 0 || _tracker2.stop();
+    }
+  };
+}
+
+/** `document.prerendering`, which TypeScript's DOM types do not have yet. */
+function isPrerendering() {
+  return "prerendering" in document && document.prerendering === true;
+}
+function startNow(options) {
+  var _options$endpoint, _options$firstSendAft, _options$viewedAfterM, _options$sendWhenPend, _options$minSendInter, _options$landingPath;
+  var routeFor = function routeFor(pathname) {
+    return routeOf(options.routeFor ? options.routeFor(pathname) : pathname);
+  };
+  var endpoint = (_options$endpoint = options.endpoint) !== null && _options$endpoint !== void 0 ? _options$endpoint : "/api/val/analytics";
+  var firstSendAfterMs = (_options$firstSendAft = options.firstSendAfterMs) !== null && _options$firstSendAft !== void 0 ? _options$firstSendAft : 3000;
+  var viewedAfterMs = (_options$viewedAfterM = options.viewedAfterMs) !== null && _options$viewedAfterM !== void 0 ? _options$viewedAfterM : 1000;
+  var sendWhenPending = (_options$sendWhenPend = options.sendWhenPending) !== null && _options$sendWhenPend !== void 0 ? _options$sendWhenPend : 50;
+  var minSendIntervalMs = (_options$minSendInter = options.minSendIntervalMs) !== null && _options$minSendInter !== void 0 ? _options$minSendInter : 15000;
+  var stopped = false;
+  /**
+   * Whether a beacon has been sent with `fetch`, whose answer can be read --
+   * one is, the first that is not sent while leaving, so a site with
+   * analytics off or paused (410) stops sending.
+   */
+  var asked = false;
+
+  // The page view.
+  /** The page view's pathname, which a new page view is a change of. */
+  var pathname = location.pathname;
+  var route = routeFor(pathname);
+  var view = null;
+  var viewSent = false;
+  var rendered = new Set();
+  var viewed = new Set();
+  var pendingRendered = [];
+  var pendingViewed = [];
+  var lastSentAt = 0;
+  var firstSendTimer = null;
+  var batchTimer = null;
+  var viewTimers = new Map();
+  function pageView(first, url) {
+    var pageView = {
+      device: deviceOf(innerWidth)
+    };
+    // A referrer is where the LOAD came from. A client-side navigation's
+    // `document.referrer` is still that, so it is not a source again.
+    var ref = first ? referrerHostOf(document.referrer, location.host) : undefined;
+    if (ref) {
+      pageView.ref = ref;
+    }
+    var utm = utmOf(url.search);
+    if (utm) {
+      pageView.utm = utm;
+    }
+    return pageView;
+  }
+  function send(beacon, leaving) {
+    var body = JSON.stringify(beacon);
+    if (!asked && !leaving) {
+      asked = true;
+      // `sendBeacon` cannot read the answer, so this one asks. Not while
+      // leaving, where only `sendBeacon` is sure to get out -- the next one
+      // asks instead.
+      fetch(endpoint, {
+        method: "POST",
+        body: body,
+        keepalive: true,
+        headers: {
+          "Content-Type": "text/plain;charset=UTF-8"
+        }
+      }).then(function (res) {
+        if (res.status === 410) {
+          stop(false);
+        }
+      })["catch"](function () {
+        // A lost beacon is a rounding error, not something to retry.
+      });
+      return;
+    }
+    if (typeof navigator.sendBeacon === "function") {
+      // A string body is sent as text/plain, which needs no CORS preflight.
+      if (navigator.sendBeacon(endpoint, body)) {
+        return;
+      }
+    }
+    fetch(endpoint, {
+      method: "POST",
+      body: body,
+      keepalive: true,
+      headers: {
+        "Content-Type": "text/plain;charset=UTF-8"
+      }
+    })["catch"](function () {
+      // As above.
+    });
+  }
+
+  /**
+   * `confirm`: what was carried over from the previous page and is still
+   * here is the new page's. True when a page view's first beacon is due --
+   * that is as long as a navigation's old page gets. False when the page view
+   * ends first -- leaving, or navigating on again before the new page has
+   * changed the screen -- so it is not counted at all, which is better than
+   * counted on the wrong route.
+   */
+  function flushNow(leaving) {
+    var confirm = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : !leaving;
+    if (confirm) {
+      confirmCarried();
+    }
+    if (firstSendTimer !== null) {
+      clearTimeout(firstSendTimer);
+      firstSendTimer = null;
+    }
+    if (batchTimer !== null) {
+      clearTimeout(batchTimer);
+      batchTimer = null;
+    }
+    var beacons = buildBeacons({
+      route: route,
+      cv: options.contentVersion,
+      view: !viewSent && view ? view : undefined,
+      rendered: pendingRendered.splice(0),
+      viewed: pendingViewed.splice(0)
+    });
+    if (beacons.length === 0) {
+      return;
+    }
+    viewSent = true;
+    lastSentAt = Date.now();
+    var _iterator = _createForOfIteratorHelper(beacons),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var beacon = _step.value;
+        send(beacon, leaving);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  function maybeSendSoon() {
+    if (!viewSent || batchTimer !== null) {
+      // Before the first beacon, what is waiting goes with it.
+      return;
+    }
+    if (pendingRendered.length + pendingViewed.length < sendWhenPending) {
+      return;
+    }
+    batchTimer = setTimeout(function () {
+      batchTimer = null;
+      flushNow(false);
+    }, Math.max(0, lastSentAt + minSendIntervalMs - Date.now()));
+  }
+  function countRendered(element) {
+    var _iterator2 = _createForOfIteratorHelper(splitValPaths(element.getAttribute(ATTRIBUTE))),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var path = _step2.value;
+        if (!rendered.has(path)) {
+          rendered.add(path);
+          pendingRendered.push(path);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+  function countViewed(element) {
+    var _iterator3 = _createForOfIteratorHelper(splitValPaths(element.getAttribute(ATTRIBUTE))),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var path = _step3.value;
+        if (!viewed.has(path)) {
+          viewed.add(path);
+          pendingViewed.push(path);
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    maybeSendSoon();
+  }
+  function onScreenEnough(entry) {
+    if (!entry.isIntersecting) {
+      return false;
+    }
+    return entry.intersectionRatio >= 0.5 || entry.intersectionRect.height >= 0.5 * innerHeight;
+  }
+
+  /** Elements on screen enough to be viewed, whether or not they have been. */
+  var onScreen = new Set();
+  function armViewTimer(element) {
+    if (viewTimers.has(element) || document.visibilityState !== "visible") {
+      return;
+    }
+    viewTimers.set(element, setTimeout(function () {
+      viewTimers["delete"](element);
+      if (element.isConnected) {
+        countViewed(element);
+      }
+    }, viewedAfterMs));
+  }
+  function clearViewTimer(element) {
+    var timer = viewTimers.get(element);
+    if (timer !== undefined) {
+      clearTimeout(timer);
+      viewTimers["delete"](element);
+    }
+  }
+  function clearViewTimers() {
+    var _iterator4 = _createForOfIteratorHelper(viewTimers.values()),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var timer = _step4.value;
+        clearTimeout(timer);
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    viewTimers.clear();
+  }
+  var intersections = new IntersectionObserver(function (entries) {
+    var _iterator5 = _createForOfIteratorHelper(entries),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var entry = _step5.value;
+        if (onScreenEnough(entry)) {
+          onScreen.add(entry.target);
+          armViewTimer(entry.target);
+        } else {
+          onScreen["delete"](entry.target);
+          clearViewTimer(entry.target);
+        }
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+  }, {
+    threshold: THRESHOLDS
+  });
+  var observed = new Set();
+  function forget(element) {
+    observed["delete"](element);
+    onScreen["delete"](element);
+    clearViewTimer(element);
+    intersections.unobserve(element);
+  }
+
+  /*
+   * After a client-side navigation the URL changes when it starts, and the
+   * old page stays on screen until the new one has loaded -- often longer
+   * than a scan takes to find it. So what is on the page when the URL
+   * changes is CARRIED, and not counted for the new route until the page has
+   * changed under it: some content of the new page is added, or some of the
+   * carried content is removed. What is still there then is the layout
+   * around both pages (a header, a footer), and it counts.
+   */
+  var carried = new Set();
+  function confirmCarried() {
+    if (carried.size === 0) {
+      return;
+    }
+    var kept = _toConsumableArray(carried);
+    carried.clear();
+    var _iterator6 = _createForOfIteratorHelper(kept),
+      _step6;
+    try {
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        var element = _step6.value;
+        if (element.isConnected) {
+          track(element);
+        }
+      }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
+    }
+  }
+  function track(element) {
+    if (carried.has(element)) {
+      return;
+    }
+    countRendered(element);
+    if (!observed.has(element)) {
+      observed.add(element);
+      intersections.observe(element);
+    }
+  }
+  function scanAll() {
+    document.querySelectorAll(SELECTOR).forEach(track);
+    maybeSendSoon();
+  }
+
+  /*
+   * What changed, a little later: a render that adds a hundred tagged
+   * elements is one pass, and the pass looks at what was added rather than
+   * at the whole document, so a page that changes all the time (a clock, a
+   * carousel) costs what it changes.
+   */
+  var added = new Set();
+  var removedSome = false;
+  var processQueued = false;
+  function process() {
+    processQueued = false;
+    if (stopped) {
+      return;
+    }
+    var pageChanged = false;
+    var _iterator7 = _createForOfIteratorHelper(added),
+      _step7;
+    try {
+      var _loop = function _loop() {
+        var root = _step7.value;
+        if (!root.isConnected) {
+          return 1; // continue
+        }
+        var found = root.matches(SELECTOR) ? [root] : [];
+        root.querySelectorAll(SELECTOR).forEach(function (element) {
+          found.push(element);
+        });
+        for (var _i = 0, _found = found; _i < _found.length; _i++) {
+          var _element2 = _found[_i];
+          if (!carried.has(_element2)) {
+            pageChanged = true;
+            track(_element2);
+          }
+        }
+      };
+      for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+        if (_loop()) continue;
+      }
+    } catch (err) {
+      _iterator7.e(err);
+    } finally {
+      _iterator7.f();
+    }
+    added.clear();
+    if (removedSome) {
+      removedSome = false;
+      var _iterator8 = _createForOfIteratorHelper(observed),
+        _step8;
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var element = _step8.value;
+          if (!element.isConnected) {
+            forget(element);
+          }
+        }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
+      }
+      var _iterator9 = _createForOfIteratorHelper(carried),
+        _step9;
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var _element = _step9.value;
+          if (!_element.isConnected) {
+            carried["delete"](_element);
+            pageChanged = true;
+          }
+        }
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
+      }
+    }
+    if (pageChanged) {
+      confirmCarried();
+    }
+    maybeSendSoon();
+  }
+  var mutations = new MutationObserver(function (records) {
+    var _iterator0 = _createForOfIteratorHelper(records),
+      _step0;
+    try {
+      for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+        var record = _step0.value;
+        if (record.type === "attributes") {
+          if (record.target instanceof Element) {
+            added.add(record.target);
+          }
+          continue;
+        }
+        record.addedNodes.forEach(function (node) {
+          if (node instanceof Element) {
+            added.add(node);
+          }
+        });
+        if (record.removedNodes.length > 0) {
+          removedSome = true;
+        }
+      }
+    } catch (err) {
+      _iterator0.e(err);
+    } finally {
+      _iterator0.f();
+    }
+    if (!processQueued && (added.size > 0 || removedSome)) {
+      processQueued = true;
+      setTimeout(process, 50);
+    }
+  });
+
+  /**
+   * A new page view. `carry` for a client-side navigation, whose old page is
+   * probably still on screen; see `carried`.
+   */
+  function startPageView(first, url, carry) {
+    pathname = location.pathname;
+    route = routeFor(pathname);
+    view = pageView(first, url);
+    viewSent = false;
+    rendered.clear();
+    viewed.clear();
+    clearViewTimers();
+    // Observe everything afresh, so what is already on screen reports itself
+    // to the new page view.
+    for (var _i2 = 0, _arr = _toConsumableArray(observed); _i2 < _arr.length; _i2++) {
+      var element = _arr[_i2];
+      forget(element);
+    }
+    carried.clear();
+    if (carry) {
+      document.querySelectorAll(SELECTOR).forEach(function (element) {
+        carried.add(element);
+      });
+    }
+    firstSendTimer = setTimeout(function () {
+      firstSendTimer = null;
+      flushNow(false);
+    }, firstSendAfterMs);
+    scanAll();
+  }
+  function onLocationMaybeChanged() {
+    if (stopped || location.pathname === pathname) {
+      return;
+    }
+    flushNow(false, false);
+    startPageView(false, location, true);
+  }
+
+  // Client-side navigation: the router calls `pushState`, and back and
+  // forward fire `popstate`. A change of query or hash alone is not a new
+  // page view.
+  //
+  // Applied to `history`, never to `this`: a router may call the function
+  // it took off `history` unbound (TanStack's does), and the browser's own
+  // throws "Illegal invocation" without its object.
+  var originalPushState = history.pushState;
+  var originalReplaceState = history.replaceState;
+  var pushState = function pushState() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    originalPushState.apply(history, args);
+    onLocationMaybeChanged();
+  };
+  var replaceState = function replaceState() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    originalReplaceState.apply(history, args);
+    onLocationMaybeChanged();
+  };
+  history.pushState = pushState;
+  history.replaceState = replaceState;
+  function onVisibilityChange() {
+    if (document.visibilityState === "hidden") {
+      // Time hidden is not time looked at: what was on its way to viewed
+      // starts again when the visitor is back.
+      clearViewTimers();
+      flushNow(true);
+    } else if (document.visibilityState === "visible") {
+      // The observer reports nothing new when only the tab changed, so what
+      // is on screen is armed again from what it last said.
+      var _iterator1 = _createForOfIteratorHelper(onScreen),
+        _step1;
+      try {
+        for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
+          var element = _step1.value;
+          armViewTimer(element);
+        }
+      } catch (err) {
+        _iterator1.e(err);
+      } finally {
+        _iterator1.f();
+      }
+    }
+  }
+  function onPageHide() {
+    flushNow(true);
+  }
+  function onPageShow(event) {
+    // Back from the back/forward cache: the visitor is looking again.
+    if (event.persisted) {
+      startPageView(false, location, false);
+    }
+  }
+  addEventListener("popstate", onLocationMaybeChanged);
+  addEventListener("pagehide", onPageHide);
+  addEventListener("pageshow", onPageShow);
+  document.addEventListener("visibilitychange", onVisibilityChange);
+  mutations.observe(document.body, {
+    childList: true,
+    subtree: true,
+    attributes: true,
+    attributeFilter: [ATTRIBUTE]
+  });
+
+  /*
+   * The page the visitor LANDED on, if it is not the one they are on now.
+   *
+   * This starts after hydration, from a lazily loaded chunk, and a visitor
+   * can click through to another page before it does. That first page view
+   * still happened, and it is the one with the referrer -- often the most
+   * useful thing about a visit -- so it is sent on its own, with nothing
+   * counted on it (nothing was being counted yet), and the page they are on
+   * now starts as a navigation within the site.
+   */
+  var landing = landingUrl();
+  var landedAt = (_options$landingPath = options.landingPath) !== null && _options$landingPath !== void 0 ? _options$landingPath : landing === null || landing === void 0 ? void 0 : landing.pathname;
+  // The campaign is in the URL the visitor arrived at; a redirect or the
+  // router may have dropped the query since.
+  var arrivedAt = landing && !utmOf(location.search) ? landing : location;
+  if (landedAt !== undefined && landedAt !== location.pathname) {
+    var _iterator10 = _createForOfIteratorHelper(buildBeacons({
+        route: routeFor(landedAt),
+        cv: options.contentVersion,
+        view: pageView(true, arrivedAt),
+        rendered: [],
+        viewed: []
+      })),
+      _step10;
+    try {
+      for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+        var beacon = _step10.value;
+        send(beacon, false);
+      }
+    } catch (err) {
+      _iterator10.e(err);
+    } finally {
+      _iterator10.f();
+    }
+    startPageView(false, location, false);
+  } else {
+    startPageView(true, arrivedAt, false);
+  }
+  function stop(sendFirst) {
+    if (stopped) {
+      return;
+    }
+    if (sendFirst) {
+      flushNow(false, false);
+    }
+    stopped = true;
+    if (firstSendTimer !== null) {
+      clearTimeout(firstSendTimer);
+    }
+    if (batchTimer !== null) {
+      clearTimeout(batchTimer);
+    }
+    clearViewTimers();
+    mutations.disconnect();
+    intersections.disconnect();
+    // Only put them back if nothing has wrapped them since: restoring over a
+    // later wrapper would take it off, and whatever installed it would stop
+    // seeing navigations.
+    if (history.pushState === pushState) {
+      history.pushState = originalPushState;
+    }
+    if (history.replaceState === replaceState) {
+      history.replaceState = originalReplaceState;
+    }
+    removeEventListener("popstate", onLocationMaybeChanged);
+    removeEventListener("pagehide", onPageHide);
+    removeEventListener("pageshow", onPageShow);
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+  }
+  return {
+    flush: function flush() {
+      if (!stopped) {
+        flushNow(false);
+      }
+    },
+    stop: function (_stop) {
+      function stop() {
+        return _stop.apply(this, arguments);
+      }
+      stop.toString = function () {
+        return _stop.toString();
+      };
+      return stop;
+    }(function () {
+      return stop(true);
+    })
+  };
+}
+
+/** The URL the document was loaded at, from the navigation timing entry. */
+function landingUrl() {
+  if (typeof performance === "undefined" || !performance.getEntriesByType) {
+    return null;
+  }
+  var _performance$getEntri = performance.getEntriesByType("navigation"),
+    _performance$getEntri2 = _slicedToArray(_performance$getEntri, 1),
+    entry = _performance$getEntri2[0];
+  if (!(entry !== null && entry !== void 0 && entry.name)) {
+    return null;
+  }
+  try {
+    return new URL(entry.name);
+  } catch (_unused) {
+    return null;
+  }
+}
+
+export { MAX_PATHS_PER_BEACON, MAX_ROUTE_LENGTH, MAX_UTM_LENGTH, buildBeacons, splitValPaths, startValAnalytics };