@mokly/mokly 0.8.0

package/dist/browser/frame_navigation.js

@@ -0,0 +1,84 @@
+// src/client/frame_navigation.ts
+import { logicalMarker, parseLogicalMarker } from "../navigation/logical.js";
+import { parseBrowsingTarget } from "../navigation/target.js";
+var attachedFrames = /* @__PURE__ */ new WeakSet();
+var attachedDocuments = /* @__PURE__ */ new WeakSet();
+function classifyFrameActivation(candidate) {
+  const destination = parseLogicalMarker(candidate.marker);
+  if (!destination || logicalMarker(destination) !== candidate.marker) {
+    return void 0;
+  }
+  if (candidate.download || candidate.altKey) return void 0;
+  if (candidate.eventType === "click" && candidate.button !== 0)
+    return void 0;
+  if (candidate.eventType === "auxclick" && candidate.button !== 1) {
+    return void 0;
+  }
+  const target = parseBrowsingTarget(candidate.target);
+  if (target.kind === "invalid") return void 0;
+  const href = `/id/${encodeURIComponent(destination.id)}${destination.fragment ? `?fragment=${encodeURIComponent(destination.fragment)}` : ""}`;
+  if (target.kind === "top" || target.kind === "parent") {
+    return { href, kind: "navigate" };
+  }
+  if (target.kind === "blank") return { href, kind: "open", target: "_blank" };
+  if (target.kind === "named") {
+    return { href, kind: "open", target: target.name };
+  }
+  const modified = candidate.metaKey || candidate.ctrlKey || candidate.shiftKey;
+  return modified || candidate.eventType === "auxclick" ? { href, kind: "open", target: "_blank" } : { href, kind: "navigate" };
+}
+function attachFrameNavigation(doc, actions) {
+  for (const frame of doc.querySelectorAll(
+    "iframe.mbk-frag"
+  )) {
+    if (!attachedFrames.has(frame)) {
+      attachedFrames.add(frame);
+      frame.addEventListener("load", () => attachDocument(frame, actions));
+    }
+    attachDocument(frame, actions);
+  }
+}
+function attachDocument(frame, actions) {
+  let doc;
+  try {
+    doc = frame.contentDocument;
+  } catch {
+    return;
+  }
+  if (!doc || attachedDocuments.has(doc)) return;
+  attachedDocuments.add(doc);
+  const activate = (event) => {
+    const view = doc.defaultView;
+    if (!view || !(event instanceof view.MouseEvent)) return;
+    const source = event.target;
+    if (!(source instanceof view.Element) || source.ownerDocument !== doc)
+      return;
+    const link = source.closest("[data-mokly-link]");
+    if (!link || link.ownerDocument !== doc || !isNativeLink(link)) return;
+    const action = classifyFrameActivation({
+      altKey: event.altKey,
+      button: event.button,
+      ctrlKey: event.ctrlKey,
+      download: link.hasAttribute("download"),
+      eventType: event.type === "auxclick" ? "auxclick" : "click",
+      marker: link.getAttribute("data-mokly-link") ?? "",
+      metaKey: event.metaKey,
+      shiftKey: event.shiftKey,
+      target: link.getAttribute("data-mokly-target")
+    });
+    if (!action) return;
+    event.preventDefault();
+    if (action.kind === "navigate") actions.navigate(action.href);
+    else actions.open(action.href, action.target);
+  };
+  doc.addEventListener("click", activate);
+  doc.addEventListener("auxclick", activate);
+}
+function isNativeLink(element) {
+  const namespace = element.namespaceURI;
+  return namespace === "http://www.w3.org/1999/xhtml" && (element.localName === "a" || element.localName === "area") || namespace === "http://www.w3.org/2000/svg" && element.localName === "a";
+}
+export {
+  attachFrameNavigation,
+  classifyFrameActivation
+};

package/dist/browser/inspector_panels.js

@@ -0,0 +1,342 @@
+// src/components/data.ts
+var DataBudget = class {
+  constructor(depthLimit = 64) {
+    this.depthLimit = depthLimit;
+  }
+  depthLimit;
+  nodes = 0;
+  visit(depth, at) {
+    if (depth > this.depthLimit || ++this.nodes > 1e4)
+      invalidData(at, "validation limit exceeded");
+  }
+};
+var ComponentValidationError = class extends Error {
+  constructor(path, detail) {
+    super(`[mokly/components] ${path}: ${detail}`);
+    this.path = path;
+    this.detail = detail;
+    this.name = "ComponentValidationError";
+  }
+  path;
+  detail;
+};
+function invalidData(at, message) {
+  throw new ComponentValidationError(at, message);
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function plainKeys(value, at) {
+  if (!record(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+    invalidData(at, "expected a plain object");
+  const keys = [];
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string") invalidData(at, "symbol keys are unsupported");
+    if (["__proto__", "constructor", "prototype"].includes(key))
+      invalidData(`${at}.${key}`, "reserved property name");
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor.enumerable || !("value" in descriptor))
+      invalidData(
+        `${at}.${key}`,
+        "only enumerable data properties are supported"
+      );
+    keys.push(key);
+  }
+  return keys.sort();
+}
+function denseArray(value, at) {
+  if (!Array.isArray(value)) invalidData(at, "expected an array");
+  if (Reflect.ownKeys(value).length !== value.length + 1)
+    invalidData(at, "expected a dense array without extra properties");
+  for (let i = 0; i < value.length; i++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+    if (!descriptor || !descriptor.enumerable || !("value" in descriptor))
+      invalidData(`${at}[${i}]`, "expected an array data element");
+  }
+}
+
+// src/components/codec.ts
+function decodeProps(value) {
+  const budget = new DataBudget();
+  budget.visit(0, "$props");
+  return Object.fromEntries(
+    plainKeys(value, "$props").map((key) => [
+      key,
+      decode(
+        value[key],
+        `$props.${key}`,
+        budget,
+        1
+      )
+    ])
+  );
+}
+function decode(value, at, budget, depth) {
+  budget.visit(depth, at);
+  denseArray(value, at);
+  const [kind, payload] = value;
+  if (kind === "null" && value.length === 1) return null;
+  if (value.length !== 2) invalidData(at, "invalid wire tuple length");
+  if (kind === "string" && typeof payload === "string") return payload;
+  if (kind === "boolean" && typeof payload === "boolean") return payload;
+  if (kind === "number" && typeof payload === "string") {
+    const number = Number(payload);
+    if (Number.isFinite(number) && (Object.is(number, -0) ? "-0" : String(number)) === payload)
+      return number;
+    invalidData(at, "noncanonical number");
+  }
+  if (kind === "array") {
+    denseArray(payload, at);
+    return payload.map(
+      (item, i) => decode(item, `${at}[${i}]`, budget, depth + 1)
+    );
+  }
+  if (kind === "object") {
+    denseArray(payload, at);
+    const object = {};
+    let previous;
+    for (const pair of payload) {
+      denseArray(pair, at);
+      if (pair.length !== 2 || typeof pair[0] !== "string")
+        invalidData(at, "invalid object entry");
+      const key = pair[0];
+      if (previous !== void 0 && previous >= key)
+        invalidData(at, "object keys must be unique and sorted");
+      plainKeys({ [key]: null }, at);
+      object[key] = decode(pair[1], `${at}.${key}`, budget, depth + 1);
+      previous = key;
+    }
+    return object;
+  }
+  return invalidData(at, "unknown or malformed wire value");
+}
+
+// src/components/views.ts
+function orderedInstances(usage) {
+  if (!usage) return [];
+  const positions = /* @__PURE__ */ new Map();
+  for (const range of usage.ranges)
+    if (range.target.kind === "instance" && !positions.has(range.target.instanceKey))
+      positions.set(range.target.instanceKey, positions.size);
+  return [...usage.instances].sort(
+    (a, b) => positions.get(a.key) - positions.get(b.key)
+  );
+}
+
+// src/client/inspector_panels.ts
+import { propText } from "./prop_display.js";
+function element(doc, tag, text) {
+  const item = doc.createElement(tag);
+  if (text !== void 0) item.textContent = text;
+  return item;
+}
+function usageHref(link) {
+  const query = new URLSearchParams({
+    viewport: link.viewport,
+    scheme: link.colorScheme,
+    instance: link.instanceKey
+  });
+  if (link.variantId) query.set("variant", link.variantId);
+  if (link.removed && link.comparisonEligible) query.set("comparison", "side");
+  return `/view/${link.route.split("/").map(encodeURIComponent).join("/")}?${query}`;
+}
+function renderUsage(panel, data) {
+  const doc = panel.ownerDocument;
+  panel.replaceChildren();
+  if (data.usageComplete === false) {
+    const status = element(
+      doc,
+      "p",
+      "Usage is unavailable until the catalogue has been checked."
+    );
+    status.dataset["usageSection"] = "status";
+    panel.append(status);
+    return;
+  }
+  for (const [key, title, links] of [
+    ["used-by", "Used by", data.usedBy],
+    ["affected", "Affected screens and components", data.affected]
+  ]) {
+    if (title !== "Used by" && links.length === 0) continue;
+    const section = element(doc, "section");
+    section.dataset["usageSection"] = key;
+    section.append(element(doc, "h3", title));
+    if (!links.length) {
+      section.append(element(doc, "p", "No recorded consumers."));
+      panel.append(section);
+      continue;
+    }
+    const list = element(doc, "ul");
+    list.className = "mbk-usage-list";
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of links) {
+      const key2 = `${item.route}|${item.variantId ?? ""}|${item.removed}|${item.comparisonEligible}`;
+      groups.set(key2, [...groups.get(key2) ?? [], item]);
+    }
+    for (const values of groups.values()) {
+      const first = values[0];
+      const row = element(doc, "li");
+      row.dataset["usageLink"] = JSON.stringify([
+        first.route,
+        first.variantId ?? "",
+        first.removed
+      ]);
+      const link = element(
+        doc,
+        "a",
+        `${first.title}${first.variantId ? ` \xB7 ${first.variantId}` : ""}${first.removed ? " \xB7 Removed" : ""}`
+      );
+      link.href = usageHref(first);
+      row.append(
+        link,
+        element(
+          doc,
+          "small",
+          `${values.some((value) => value.direct) ? "Direct use" : "Nested use"} \xB7 ${new Set(values.map((value) => value.instanceKey)).size} instances \xB7 ${new Set(values.map((value) => `${value.viewport}/${value.colorScheme}`)).size} views`
+        )
+      );
+      list.append(row);
+    }
+    section.append(list);
+    panel.append(section);
+  }
+}
+function renderInstances(panel, data, selection, select, expanded, focusNested) {
+  const doc = panel.ownerDocument;
+  panel.replaceChildren();
+  const usage = selection.usage;
+  if (!usage) {
+    panel.append(
+      element(doc, "p", "Component inspection is unavailable for this view.")
+    );
+    return;
+  }
+  if (!usage.instances.length) {
+    panel.append(
+      element(doc, "p", "No registered components are used in this view.")
+    );
+    return;
+  }
+  panel.append(
+    element(
+      doc,
+      "p",
+      `${usage.instances.length} instances \xB7 ${new Set(usage.instances.map((instance) => instance.componentId)).size} components`
+    )
+  );
+  const build = (owner) => {
+    const list = element(doc, "ul");
+    list.className = "mbk-instance-tree";
+    for (const instance of orderedInstances(usage).filter(
+      (item) => owner ? item.owner.kind === "instance" && item.owner.instanceKey === owner : item.owner.kind === "entry"
+    )) {
+      const component = data.components.find(
+        (item) => item.id === instance.componentId
+      );
+      const row = element(doc, "li");
+      const button = element(
+        doc,
+        "button",
+        `${component?.title ?? instance.componentId} \xB7 ${instance.id}`
+      );
+      button.type = "button";
+      button.className = "mbk-instance-select";
+      button.dataset["instanceKey"] = instance.key;
+      button.setAttribute(
+        "aria-pressed",
+        String(selection.instance?.key === instance.key)
+      );
+      button.addEventListener("click", () => select(instance.key));
+      row.append(button);
+      const children = build(instance.key);
+      if (children.childElementCount) {
+        const details = element(doc, "details");
+        details.open = expanded.has(instance.key);
+        details.append(
+          element(
+            doc,
+            "summary",
+            `${children.childElementCount} nested instances`
+          ),
+          children
+        );
+        row.append(details);
+        details.addEventListener("toggle", () => {
+          if (!details.isConnected || details.open === expanded.has(instance.key))
+            return;
+          if (details.open) expanded.add(instance.key);
+          else expanded.delete(instance.key);
+          const child = usage.instances.find(
+            (item) => item.owner.kind === "instance" && item.owner.instanceKey === instance.key
+          );
+          focusNested(details.open && child ? child.key : instance.key);
+        });
+      }
+      list.append(row);
+    }
+    return list;
+  };
+  panel.append(build());
+}
+function renderProps(panel, data, selection) {
+  const doc = panel.ownerDocument;
+  panel.replaceChildren();
+  const props = selection.instance?.props ?? selection.props;
+  if (!props) {
+    panel.append(
+      element(
+        doc,
+        "p",
+        "Select a component instance to see its supplied props."
+      )
+    );
+    return;
+  }
+  if (selection.instance) {
+    const component = data.components.find(
+      (item) => item.id === selection.instance.componentId
+    );
+    panel.append(
+      element(
+        doc,
+        "h3",
+        `${component?.title ?? selection.instance.componentId} \xB7 ${selection.instance.id}`
+      )
+    );
+    if (component) {
+      const link = element(doc, "a", "Open component");
+      link.href = `/view/${component.route.split("/").map(encodeURIComponent).join("/")}`;
+      panel.append(link);
+    }
+  }
+  const values = decodeProps(props);
+  const table = element(doc, "table");
+  table.className = "mbk-props-table";
+  table.setAttribute("aria-label", "Supplied props");
+  for (const [name, value] of Object.entries(values)) {
+    const row = element(doc, "tr");
+    const header = element(doc, "th", name);
+    header.scope = "row";
+    const cell = element(doc, "td");
+    cell.append(element(doc, "pre", propText(value)));
+    row.append(header, cell);
+    table.append(row);
+  }
+  panel.append(
+    table.childElementCount ? table : element(doc, "p", "No data props supplied.")
+  );
+  const slots = selection.instance ? selection.usage?.slots.filter((slot) => slot.instanceKey === selection.instance.key).map(
+    (slot) => `${slot.name} \xB7 ${slot.owner.kind === "entry" ? "Supplied by this page" : "Supplied by a parent component"}`
+  ) : selection.slots;
+  if (slots?.length) {
+    panel.append(element(doc, "h3", "Slots"));
+    for (const slot of slots) panel.append(element(doc, "p", slot));
+  }
+}
+export {
+  element,
+  renderInstances,
+  renderProps,
+  renderUsage,
+  usageHref
+};

package/dist/browser/inspector_resize.js

@@ -0,0 +1,96 @@
+// src/client/inspector_resize.ts
+function installInspectorResize(root, signal) {
+  const win = root.ownerDocument.defaultView;
+  const inspector = root.querySelector(
+    "[data-workspace-inspector]"
+  );
+  const divider = root.querySelector("[data-inspector-resize]");
+  const grab = root.querySelector("[data-inspector-size]");
+  const panes = root.querySelector(".mbk-workspace-panes");
+  let height = 260;
+  const narrow = () => win.matchMedia("(max-width: 56.25rem)").matches;
+  const bounds = () => ({
+    min: Math.min(160, panes.clientHeight - 100),
+    max: Math.max(46, panes.clientHeight - 100)
+  });
+  const clamp = () => {
+    const { min, max } = bounds();
+    height = Math.min(max, Math.max(Math.max(46, min), height));
+    inspector.style.setProperty("--inspector-height", `${height}px`);
+    divider.setAttribute("aria-valuemin", String(Math.max(46, min)));
+    divider.setAttribute("aria-valuemax", String(max));
+    divider.setAttribute("aria-valuenow", String(Math.round(height)));
+  };
+  const expand = (value) => {
+    inspector.dataset["expanded"] = String(value);
+    grab.setAttribute("aria-expanded", String(value));
+    grab.setAttribute(
+      "aria-label",
+      value ? "Make inspector compact" : "Expand inspector"
+    );
+  };
+  let drag;
+  let suppressClick = false;
+  const begin = (event) => {
+    if (event.button !== 0) return;
+    const target = event.currentTarget;
+    drag = {
+      pointer: event.pointerId,
+      y: event.clientY,
+      height: inspector.getBoundingClientRect().height,
+      moved: false
+    };
+    target.setPointerCapture(event.pointerId);
+    if (!narrow()) event.preventDefault();
+  };
+  const move = (event) => {
+    if (!drag || drag.pointer !== event.pointerId) return;
+    const delta = drag.y - event.clientY;
+    drag.moved ||= Math.abs(delta) > 5;
+    if (narrow())
+      inspector.style.height = `${Math.min(panes.clientHeight - 36, Math.max(190, drag.height + delta))}px`;
+    else {
+      height = drag.height + delta;
+      clamp();
+    }
+  };
+  const end = (event) => {
+    if (!drag || drag.pointer !== event.pointerId) return;
+    if (narrow() && drag.moved) expand(drag.y - event.clientY > 0);
+    suppressClick = drag.moved;
+    inspector.style.removeProperty("height");
+    drag = void 0;
+  };
+  for (const handle of [divider, grab]) {
+    handle.addEventListener("pointerdown", begin, { signal });
+    handle.addEventListener("pointermove", move, { signal });
+    handle.addEventListener("pointerup", end, { signal });
+    handle.addEventListener("pointercancel", end, { signal });
+  }
+  grab.addEventListener(
+    "click",
+    () => {
+      if (!suppressClick) expand(inspector.dataset["expanded"] !== "true");
+      suppressClick = false;
+    },
+    { signal }
+  );
+  divider.addEventListener(
+    "keydown",
+    (event) => {
+      if (!["ArrowUp", "ArrowDown", "Home", "End"].includes(event.key)) return;
+      event.preventDefault();
+      height = event.key === "Home" ? bounds().min : event.key === "End" ? bounds().max : height + (event.key === "ArrowUp" ? 20 : -20);
+      clamp();
+    },
+    { signal }
+  );
+  const observer = new ResizeObserver(clamp);
+  observer.observe(panes);
+  signal.addEventListener("abort", () => observer.disconnect(), { once: true });
+  clamp();
+  return clamp;
+}
+export {
+  installInspectorResize
+};

package/dist/browser/inspector_tabs.js

@@ -0,0 +1,84 @@
+// src/client/inspector_tabs.ts
+import { createBrowserDetailsPreference } from "./browse_details.js";
+import { installInspectorResize } from "./inspector_resize.js";
+function installInspectorTabs(root, signal) {
+  const doc = root.ownerDocument;
+  const win = doc.defaultView;
+  const preference = createBrowserDetailsPreference(
+    win
+  );
+  const inspector = root.querySelector(
+    "[data-workspace-inspector]"
+  );
+  const content = root.querySelector(".mbk-inspector-content");
+  const clamp = installInspectorResize(root, signal);
+  let active;
+  const button = (value) => value ? root.querySelector(`[data-inspector-tab="${value}"]`) : void 0;
+  const open = (value, persist = true) => {
+    active = value;
+    inspector.dataset["open"] = String(value !== void 0);
+    content.hidden = value === void 0;
+    for (const tab of root.querySelectorAll(
+      "[data-inspector-tab]"
+    ))
+      tab.setAttribute(
+        "aria-selected",
+        String(tab.dataset["inspectorTab"] === value)
+      );
+    for (const panel of root.querySelectorAll(
+      "[data-inspector-panel]"
+    ))
+      panel.hidden = panel.dataset["inspectorPanel"] !== value;
+    root.querySelector("[data-inspector-title]").textContent = button(value)?.getAttribute("aria-label") ?? "";
+    root.querySelector("[data-inspector-close]").hidden = !value;
+    clamp();
+    if (persist) preference.remember(value !== void 0);
+  };
+  const close = () => {
+    const previous = active;
+    open(void 0);
+    button(previous)?.focus({ preventScroll: true });
+  };
+  root.addEventListener(
+    "click",
+    (event) => {
+      const target = event.target;
+      const tab = target.closest("[data-inspector-tab]");
+      if (tab)
+        open(
+          active === tab.dataset["inspectorTab"] ? void 0 : tab.dataset["inspectorTab"]
+        );
+      if (target.closest("[data-inspector-close]")) close();
+    },
+    { signal }
+  );
+  root.addEventListener(
+    "keydown",
+    (event) => {
+      const target = event.target;
+      if (!target.matches("[data-inspector-tab]") || !["ArrowLeft", "ArrowRight", "Home", "End"].includes(event.key))
+        return;
+      event.preventDefault();
+      const tabs = [
+        ...root.querySelectorAll("[data-inspector-tab]")
+      ];
+      const next = event.key === "Home" ? 0 : event.key === "End" ? tabs.length - 1 : (tabs.indexOf(target) + (event.key === "ArrowRight" ? 1 : tabs.length - 1)) % tabs.length;
+      tabs[next]?.focus();
+    },
+    { signal }
+  );
+  doc.addEventListener(
+    "mokly:inspector-restore",
+    () => open(inspector.dataset["open"] === "true" ? "details" : void 0, false),
+    { signal }
+  );
+  return {
+    open,
+    close,
+    active: () => active,
+    preferredOpen: preference.preferredOpen
+  };
+}
+export {
+  installInspectorTabs
+};

package/dist/browser/live_updates.js

@@ -0,0 +1,91 @@
+// src/client/live_updates.ts
+import { parseBrowseRecoveryState } from "./browse_recovery.js";
+var RECOVERY_KEY = "mokly:live-update-recovery";
+var LiveUpdateController = class {
+  constructor(stream, storage, location, captureBrowseState = () => void 0, pageVersion, refresh) {
+    this.stream = stream;
+    this.storage = storage;
+    this.location = location;
+    this.captureBrowseState = captureBrowseState;
+    this.refresh = refresh;
+    const knownPageVersion = isUpdateVersion(pageVersion) ? pageVersion : 0;
+    this.#pageVersionKnown = knownPageVersion > 0;
+    this.#lastVersion = knownPageVersion;
+  }
+  stream;
+  storage;
+  location;
+  captureBrowseState;
+  refresh;
+  #lastVersion;
+  #pageVersionKnown;
+  #pending;
+  #closed = false;
+  /** Begin receiving server update versions. */
+  start() {
+    this.stream.onReady((version) => this.receive(version, false));
+    this.stream.onUpdate((version) => this.receive(version, true));
+  }
+  /** Close the stream when the shell unmounts. */
+  close() {
+    this.#closed = true;
+    this.#pending?.abort();
+    this.stream.close();
+  }
+  /** Consume recovery exactly once; later manual refreshes see no stale state. */
+  consumeRecovery() {
+    const raw = this.storage.getItem(RECOVERY_KEY);
+    this.storage.removeItem(RECOVERY_KEY);
+    if (!raw) return void 0;
+    try {
+      const value = JSON.parse(raw);
+      if (typeof value.url !== "string" || !Number.isSafeInteger(value.version))
+        return void 0;
+      const browse = value.browse === void 0 ? void 0 : parseBrowseRecoveryState(value.browse);
+      if (value.browse !== void 0 && !browse) return void 0;
+      return {
+        ...browse ? { browse } : {},
+        url: value.url,
+        version: value.version
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  receive(version, forceReload) {
+    if (this.#closed || !isUpdateVersion(version) || version <= this.#lastVersion)
+      return;
+    const initialReady = !this.#pageVersionKnown && this.#lastVersion === 0 && !forceReload;
+    this.#lastVersion = version;
+    if (initialReady) return;
+    this.#pending?.abort();
+    if (this.refresh) {
+      const pending = new AbortController();
+      this.#pending = pending;
+      void this.refresh(version, pending.signal).then((applied) => {
+        if (pending.signal.aborted || this.#closed) return;
+        if (isUpdateVersion(applied) && applied >= version)
+          this.#lastVersion = Math.max(this.#lastVersion, applied);
+        else this.reload(version);
+      }).catch(() => {
+        if (!pending.signal.aborted && !this.#closed) this.reload(version);
+      });
+    } else this.reload(version);
+  }
+  reload(version) {
+    const browse = this.captureBrowseState();
+    const recovery = {
+      ...browse ? { browse } : {},
+      url: this.location.href,
+      version
+    };
+    this.storage.setItem(RECOVERY_KEY, JSON.stringify(recovery));
+    this.location.reload();
+  }
+};
+function isUpdateVersion(value) {
+  return Number.isSafeInteger(value) && value !== void 0 && value > 0;
+}
+export {
+  LiveUpdateController
+};