// Set EXEC_URL and API_TOKEN to your deployed Apps Script web-app values.
// NOTE: this token is served publicly with the app — use a dedicated, rotatable token.
window.CONFIG = {
  EXEC_URL: "REPLACE_WITH_APPS_SCRIPT_EXEC_URL",
  API_TOKEN: "REPLACE_WITH_API_TOKEN",
  PERSON_LABELS: { ayush: "You", simran: "Simran" }
};

import { defineConfig } from "vitest/config";
export default defineConfig({ test: { globals: true } });

describe("toolchain", () => {
  it("runs vitest", () => { expect(1 + 1).toBe(2); });
});

const { dayTypeForWeekday, WEEKDAY_DAYTYPE, nowNext } = require("../../health/js/schedule.js");

describe("dayTypeForWeekday", () => {
  it("maps weekdays per the contract", () => {
    expect(WEEKDAY_DAYTYPE).toEqual(["sunday","office","office","office","wfh","wfh","saturday"]);
    expect(dayTypeForWeekday(0)).toBe("sunday");
    expect(dayTypeForWeekday(1)).toBe("office");
    expect(dayTypeForWeekday(4)).toBe("wfh");
    expect(dayTypeForWeekday(6)).toBe("saturday");
  });
});

describe("nowNext", () => {
  const ev = (time, minutes, activity) => ({ time, minutes, activity });
  const events = [ev("06:00",360,"Walk"), ev("07:00",420,"Gym"), ev("08:15",495,"Breakfast")];

  it("finds current and next around a mid time", () => {
    const r = nowNext(events, 430); // after Gym(420), before Breakfast(495)
    expect(r.current.activity).toBe("Gym");
    expect(r.next.activity).toBe("Breakfast");
  });
  it("before the first event has no current", () => {
    const r = nowNext(events, 300);
    expect(r.current).toBeNull();
    expect(r.next.activity).toBe("Walk");
  });
  it("after the last event has no next", () => {
    const r = nowNext(events, 600);
    expect(r.current.activity).toBe("Breakfast");
    expect(r.next).toBeNull();
  });
  it("handles empty list", () => {
    expect(nowNext([], 500)).toEqual({ current: null, next: null });
  });
});

var WEEKDAY_DAYTYPE = ["sunday", "office", "office", "office", "wfh", "wfh", "saturday"];

function dayTypeForWeekday(weekday) {
  return WEEKDAY_DAYTYPE[weekday];
}

function nowNext(events, nowMinutes) {
  var current = null, next = null;
  var sorted = (events || []).slice().sort(function (a, b) { return a.minutes - b.minutes; });
  for (var i = 0; i < sorted.length; i++) {
    if (sorted[i].minutes <= nowMinutes) current = sorted[i];
    else { next = sorted[i]; break; }
  }
  return { current: current, next: next };
}

if (typeof module !== "undefined" && module.exports) {
  module.exports = { WEEKDAY_DAYTYPE, dayTypeForWeekday, nowNext };
}

const { proteinTotal, calorieTotal, PROTEIN_TARGET } = require("../../health/js/schedule.js");

describe("macro totals", () => {
  const events = [
    { protein: 34, calories: 740 },
    { protein: null, calories: 225 },
    { protein: 47, calories: null }
  ];
  it("sums protein treating null as 0", () => {
    expect(proteinTotal(events)).toBe(81);
  });
  it("sums calories treating null as 0", () => {
    expect(calorieTotal(events)).toBe(965);
  });
  it("exposes protein targets", () => {
    expect(PROTEIN_TARGET).toEqual({ ayush: 150, simran: 120 });
  });
  it("handles empty", () => {
    expect(proteinTotal([])).toBe(0);
    expect(calorieTotal([])).toBe(0);
  });
});

var PROTEIN_TARGET = { ayush: 150, simran: 120 };

function proteinTotal(events) {
  return (events || []).reduce(function (s, e) { return s + (e.protein || 0); }, 0);
}

function calorieTotal(events) {
  return (events || []).reduce(function (s, e) { return s + (e.calories || 0); }, 0);
}

  module.exports = { WEEKDAY_DAYTYPE, dayTypeForWeekday, nowNext, PROTEIN_TARGET, proteinTotal, calorieTotal };

const { OFFICE_DAY_COUNT, mealPrepRollup, extractIngredients, groceryList } = require("../../health/js/mealprep.js");

describe("mealPrepRollup", () => {
  const events = [
    { kind: "wake", activity: "Wake Up", details: "water" },
    { kind: "meal", activity: "Lunch at Office", details: "Basmati rice 200g + Chickpeas curry (~740 cal)" },
    { kind: "workout", activity: "Gym", details: "Lower A" },
    { kind: "meal", activity: "Dinner", details: "Tofu + Sweet Potato" }
  ];
  it("keeps only meals and stamps the weekly count", () => {
    expect(mealPrepRollup(events, 3)).toEqual([
      { activity: "Lunch at Office", details: "Basmati rice 200g + Chickpeas curry (~740 cal)", count: 3 },
      { activity: "Dinner", details: "Tofu + Sweet Potato", count: 3 }
    ]);
  });
  it("exposes the office day count", () => { expect(OFFICE_DAY_COUNT).toBe(3); });
});

describe("extractIngredients", () => {
  it("splits on + and , drops parentheticals and quantities", () => {
    expect(extractIngredients("Basmati rice 200g + Chickpeas/Tofu curry + salad (~740 cal, 34g protein)"))
      .toEqual(["Basmati rice", "Chickpeas/Tofu curry", "salad"]);
  });
  it("returns [] for blank", () => { expect(extractIngredients("")).toEqual([]); });
});

describe("groceryList", () => {
  it("dedupes ingredients across both people's office meals", () => {
    const schedule = {
      office: {
        ayush: [{ kind: "meal", details: "Basmati rice 200g + Chickpeas curry" }],
        simran: [{ kind: "meal", details: "Dal + brown rice" }, { kind: "walk", details: "x" }]
      },
      wfh: { ayush: [], simran: [] }, saturday: { ayush: [], simran: [] }, sunday: { ayush: [], simran: [] }
    };
    expect(groceryList(schedule)).toEqual(["Basmati rice", "Chickpeas curry", "Dal", "brown rice"]);
  });
});

var OFFICE_DAY_COUNT = 3;

function mealPrepRollup(events, dayCount) {
  return (events || [])
    .filter(function (e) { return e.kind === "meal"; })
    .map(function (e) { return { activity: e.activity, details: e.details, count: dayCount }; });
}

function extractIngredients(details) {
  var s = String(details || "").replace(/\([^)]*\)/g, " "); // drop parentheticals
  return s.split(/[+,]/)
    .map(function (part) {
      return part
        .replace(/\b\d+(\.\d+)?\s*(g|kg|ml|l|tsp|tbsp)\b/gi, " ") // drop "200g", "1 tsp"
        .replace(/\s+/g, " ")
        .trim();
    })
    .filter(function (x) { return x.length > 0; });
}

function groceryList(schedule) {
  var out = [];
  var seen = {};
  ["ayush", "simran"].forEach(function (person) {
    var meals = ((schedule.office && schedule.office[person]) || [])
      .filter(function (e) { return e.kind === "meal"; });
    meals.forEach(function (m) {
      extractIngredients(m.details).forEach(function (ing) {
        var key = ing.toLowerCase();
        if (!seen[key]) { seen[key] = true; out.push(ing); }
      });
    });
  });
  return out;
}

if (typeof module !== "undefined" && module.exports) {
  module.exports = { OFFICE_DAY_COUNT, mealPrepRollup, extractIngredients, groceryList };
}

// jsdom-free: provide minimal globals the module uses.
const store = {};
global.localStorage = {
  getItem: k => (k in store ? store[k] : null),
  setItem: (k, v) => { store[k] = String(v); },
  removeItem: k => { delete store[k]; }
};
global.CONFIG = { EXEC_URL: "https://exec.test/x", API_TOKEN: "tok" };

const { cacheGet, cacheSet, fetchSchedule, postCheckoff } = require("../../health/js/api.js");

beforeEach(() => { for (const k in store) delete store[k]; });

describe("cache", () => {
  it("round-trips JSON", () => {
    cacheSet("k", { a: 1 });
    expect(cacheGet("k")).toEqual({ a: 1 });
  });
  it("returns null for missing/corrupt", () => {
    expect(cacheGet("nope")).toBeNull();
    store["bad"] = "{not json";
    expect(cacheGet("bad")).toBeNull();
  });
});

describe("fetchSchedule", () => {
  it("returns live data and caches it", async () => {
    global.fetch = async () => ({ ok: true, json: async () => ({ schedule: {}, gym: [], principles: [] }) });
    const r = await fetchSchedule();
    expect(r.stale).toBe(false);
    expect(r.data.gym).toEqual([]);
    expect(cacheGet("health.schedule")).toEqual({ schedule: {}, gym: [], principles: [] });
  });
  it("falls back to cache when the network fails", async () => {
    cacheSet("health.schedule", { schedule: {}, gym: [{ day: "Mon" }], principles: [] });
    global.fetch = async () => { throw new Error("offline"); };
    const r = await fetchSchedule();
    expect(r.stale).toBe(true);
    expect(r.data.gym[0].day).toBe("Mon");
  });
});

describe("postCheckoff", () => {
  it("posts text/plain with the token merged in", async () => {
    let captured = null;
    global.fetch = async (url, opts) => { captured = { url, opts }; return { ok: true, json: async () => ({ ok: true }) }; };
    await postCheckoff({ date: "2026-07-12", person: "ayush", itemId: "x", itemLabel: "L", done: true });
    expect(captured.url).toBe("https://exec.test/x");
    expect(captured.opts.headers["Content-Type"]).toBe("text/plain");
    const body = JSON.parse(captured.opts.body);
    expect(body).toEqual({ token: "tok", date: "2026-07-12", person: "ayush", itemId: "x", itemLabel: "L", done: true });
  });
});

var SCHEDULE_CACHE_KEY = "health.schedule";

function cacheGet(key) {
  try { var raw = localStorage.getItem(key); return raw ? JSON.parse(raw) : null; }
  catch (e) { return null; }
}
function cacheSet(key, value) {
  try { localStorage.setItem(key, JSON.stringify(value)); } catch (e) { /* quota/full — ignore */ }
}

function fetchSchedule() {
  var url = CONFIG.EXEC_URL + "?token=" + encodeURIComponent(CONFIG.API_TOKEN);
  return fetch(url)
    .then(function (r) { if (!r.ok) throw new Error("http " + r.status); return r.json(); })
    .then(function (data) { cacheSet(SCHEDULE_CACHE_KEY, data); return { data: data, stale: false }; })
    .catch(function () { return { data: cacheGet(SCHEDULE_CACHE_KEY), stale: true }; });
}

function fetchLog(date) {
  var url = CONFIG.EXEC_URL + "?token=" + encodeURIComponent(CONFIG.API_TOKEN) +
    "&action=log&date=" + encodeURIComponent(date);
  return fetch(url)
    .then(function (r) { if (!r.ok) throw new Error("http " + r.status); return r.json(); })
    .then(function (j) { return (j && j.rows) || []; })
    .catch(function () { return []; });
}

function postCheckoff(payload) {
  var body = Object.assign({ token: CONFIG.API_TOKEN }, payload);
  return fetch(CONFIG.EXEC_URL, {
    method: "POST",
    headers: { "Content-Type": "text/plain" },
    body: JSON.stringify(body)
  })
    .then(function (r) { return r.json(); })
    .catch(function () { return { ok: false }; });
}

if (typeof module !== "undefined" && module.exports) {
  module.exports = { cacheGet, cacheSet, fetchSchedule, fetchLog, postCheckoff };
}

(function () {
  var state = {
    schedule: null, gym: [], principles: [],
    dayType: dayTypeForWeekday(new Date().getDay()),
    person: "ayush", tab: "home", log: {} // log: { itemId: true }
  };

  function nowMinutes() { var d = new Date(); return d.getHours() * 60 + d.getMinutes(); }
  function eventsFor(person) {
    if (!state.schedule) return [];
    return (state.schedule[state.dayType] && state.schedule[state.dayType][person]) || [];
  }
  function dayName() {
    return ({ office: "Office day", wfh: "WFH day", saturday: "Saturday", sunday: "Sunday" })[state.dayType];
  }

  function el(tag, cls, html) {
    var n = document.createElement(tag);
    if (cls) n.className = cls;
    if (html != null) n.innerHTML = html;
    return n;
  }
  function esc(s) { return String(s == null ? "" : s).replace(/[&<>]/g, function (c) { return ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]; }); }

  function renderNowCard(person) {
    var events = eventsFor(person);
    var nn = nowNext(events, nowMinutes());
    var cls = person === "simran" ? "her" : "you";
    var wrap = el("div");
    var now = el("div", "card now " + cls);
    if (nn.current) {
      now.innerHTML = '<div class="lbl">Now · ' + esc(dayName()) + '</div>' +
        '<div class="act">' + esc(nn.current.activity) + '</div>' +
        '<div class="det">' + esc(nn.current.details) + '</div>' +
        (nn.next ? '<div class="count">Next ' + esc(nn.next.timeLabel) + ' · ' + esc(nn.next.activity) + '</div>' : '');
    } else {
      now.innerHTML = '<div class="lbl">' + esc(dayName()) + '</div><div class="act">Not started yet</div>' +
        (nn.next ? '<div class="count">First: ' + esc(nn.next.timeLabel) + ' · ' + esc(nn.next.activity) + '</div>' : '');
    }
    wrap.appendChild(now);
    // Today's checkable timeline
    var list = el("div", "card");
    events.forEach(function (e) {
      var done = !!state.log[e.id];
      var item = el("div", "item" + (done ? " done" : ""));
      item.innerHTML = '<button class="check' + (done ? " on" : "") + '" data-id="' + esc(e.id) +
        '" data-label="' + esc(e.activity) + '" data-person="' + esc(person) + '"></button>' +
        '<div class="t">' + esc(e.timeLabel) + '</div>' +
        '<div class="col"><div class="a">' + esc(e.activity) + '</div>' +
        (e.details ? '<div class="det">' + esc(e.details) + '</div>' : '') + '</div>';
      list.appendChild(item);
    });
    wrap.appendChild(list);
    return wrap;
  }

  function renderBoth() {
    var row = el("div", "row");
    ["ayush", "simran"].forEach(function (p) {
      var events = eventsFor(p);
      var nn = nowNext(events, nowMinutes());
      var col = el("div", "col");
      col.appendChild(el("div", "lbl", CONFIG.PERSON_LABELS[p]));
      var c = el("div", "card now " + (p === "simran" ? "her" : "you"));
      c.innerHTML = '<div class="lbl">Now</div><div class="act" style="font-size:14px">' +
        esc(nn.current ? nn.current.activity : "—") + '</div>' +
        (nn.next ? '<div class="count">Next: ' + esc(nn.next.activity) + '</div>' : '');
      col.appendChild(c);
      row.appendChild(col);
    });
    return row;
  }

  function renderHome() {
    var panel = document.getElementById("tab-home");
    panel.innerHTML = "";
    if (!state.schedule) { panel.appendChild(el("div", "card", "Loading…")); return; }
    if (state.person === "both") panel.appendChild(renderBoth());
    else panel.appendChild(renderNowCard(state.person));
  }

  // Placeholder renderers filled in Task 7.
  function renderFood() { document.getElementById("tab-food").innerHTML = '<div class="card">Food (Task 7)</div>'; }
  function renderGym() { document.getElementById("tab-gym").innerHTML = '<div class="card">Gym (Task 7)</div>'; }
  function renderRules() { document.getElementById("tab-rules").innerHTML = '<div class="card">Rules (Task 7)</div>'; }

  function renderActiveTab() {
    ({ home: renderHome, food: renderFood, gym: renderGym, rules: renderRules })[state.tab]();
  }

  function setTab(tab) {
    state.tab = tab;
    document.querySelectorAll(".tabbar button").forEach(function (b) { b.classList.toggle("on", b.dataset.tab === tab); });
    document.querySelectorAll(".panel").forEach(function (p) { p.classList.toggle("on", p.id === "tab-" + tab); });
    renderActiveTab();
  }
  function setPerson(person) {
    state.person = person;
    document.querySelectorAll("#personSwitch button").forEach(function (b) { b.classList.toggle("on", b.dataset.person === person); });
    renderActiveTab();
  }

  function todayISO() {
    var d = new Date(), p = function (n) { return String(n).padStart(2, "0"); };
    return d.getFullYear() + "-" + p(d.getMonth() + 1) + "-" + p(d.getDate());
  }

  function wire() {
    document.getElementById("tabbar").addEventListener("click", function (e) {
      var b = e.target.closest("button[data-tab]"); if (b) setTab(b.dataset.tab);
    });
    document.getElementById("personSwitch").addEventListener("click", function (e) {
      var b = e.target.closest("button[data-person]"); if (b) setPerson(b.dataset.person);
    });
    document.getElementById("dayLabel").textContent = dayName();
  }

  function showBanner(msg) {
    var b = document.getElementById("banner");
    if (!msg) { b.hidden = true; return; }
    b.textContent = msg; b.hidden = false;
  }

  function boot() {
    wire();
    fetchSchedule().then(function (res) {
      if (!res.data) { showBanner("No data — check config / connection"); return; }
      state.schedule = res.data.schedule; state.gym = res.data.gym || []; state.principles = res.data.principles || [];
      if (res.stale) showBanner("Showing saved copy (offline)");
      return fetchLog(todayISO()).then(function (rows) {
        rows.forEach(function (r) { if (r.done) state.log[r.itemId] = true; });
        renderActiveTab();
      });
    });
  }

  // expose for Task 7 & 8 to extend
  window.HealthApp = { state: state, renderActiveTab: renderActiveTab, todayISO: todayISO, esc: esc, el: el, eventsFor: eventsFor, showBanner: showBanner };

  document.addEventListener("DOMContentLoaded", boot);
})();

  var foodMode = "today";
  function renderFood() {
    var panel = document.getElementById("tab-food");
    panel.innerHTML = "";
    var seg = el("div", "seg");
    seg.innerHTML = '<button data-mode="today" class="' + (foodMode === "today" ? "on" : "") + '">Today</button>' +
      '<button data-mode="prep" class="' + (foodMode === "prep" ? "on" : "") + '">Meal prep</button>';
    seg.addEventListener("click", function (e) { var b = e.target.closest("button"); if (b) { foodMode = b.dataset.mode; renderFood(); } });
    panel.appendChild(seg);

    if (foodMode === "today") {
      var person = state.person === "both" ? "ayush" : state.person;
      var meals = eventsFor(person).filter(function (e) { return e.kind === "meal"; });
      var pt = proteinTotal(meals), ct = calorieTotal(meals), target = PROTEIN_TARGET[person] || 150;
      var tot = el("div", "card");
      tot.innerHTML = '<div class="lbl">' + esc(CONFIG.PERSON_LABELS[person]) + ' · protein ' + pt + ' / ' + target + ' g</div>' +
        '<div class="prog"><div style="width:' + Math.min(100, Math.round(pt / target * 100)) + '%"></div></div>' +
        '<div class="count">~' + ct + ' kcal today</div>';
      panel.appendChild(tot);
      var list = el("div", "card");
      meals.forEach(function (m) {
        list.appendChild(el("div", "item",
          '<div class="t">' + esc(m.timeLabel) + '</div><div class="col"><div class="a">' + esc(m.activity) + '</div>' +
          '<div class="det">' + esc(m.details) + '</div>' +
          (m.calories ? '<div class="count" style="color:var(--ok)">' + m.calories + ' kcal' + (m.protein ? ' · ' + m.protein + 'g protein' : '') + '</div>' : '') +
          '</div>'));
      });
      panel.appendChild(list);
    } else {
      var person2 = state.person === "both" ? "ayush" : state.person;
      var rollup = mealPrepRollup(officeEvents(person2), OFFICE_DAY_COUNT); // office template, regardless of today
      var cook = el("div", "card");
      cook.innerHTML = '<h2>🍳 Batch cook (office week ×' + OFFICE_DAY_COUNT + ')</h2>';
      rollup.forEach(function (r) {
        cook.appendChild(el("div", "item", '<div class="col"><div class="a">' + esc(r.activity) + '</div><div class="det">' + esc(r.details) + '</div></div><div class="t">×' + r.count + '</div>'));
      });
      panel.appendChild(cook);
      var groc = el("div", "card");
      groc.innerHTML = '<h2>🛒 Grocery list</h2>';
      groceryList(state.schedule).forEach(function (g) {
        groc.appendChild(el("div", "item", '<div class="col"><div class="a">☐ ' + esc(g) + '</div></div>'));
      });
      panel.appendChild(groc);
    }
  }
  function officeEvents(person) {
    return (state.schedule.office && state.schedule.office[person]) || [];
  }

  function renderGym() {
    var panel = document.getElementById("tab-gym");
    panel.innerHTML = "";
    var today = ({ 1: "Monday", 2: "Tuesday", 3: "Wednesday", 4: "Thursday", 5: "Friday", 6: "Saturday", 0: "Sunday" })[new Date().getDay()];
    var todays = state.gym.filter(function (g) { return g.day === today; });
    if (todays.length) {
      var t = el("div", "card now you");
      t.innerHTML = '<div class="lbl">Today · ' + esc(today) + '</div><div class="act" style="font-size:15px">' +
        esc(todays[0].focusAyush) + '</div><div class="det">Simran: ' + esc(todays[0].focusSimran) + ' · ' + esc(todays[0].type) + '</div>';
      panel.appendChild(t);
    }
    var wk = el("div", "card");
    wk.innerHTML = '<h2>Weekly split</h2>';
    state.gym.forEach(function (g) {
      wk.appendChild(el("div", "item", '<div class="t">' + esc(g.day) + '</div><div class="col"><div class="a">' +
        esc(g.focusAyush) + '</div><div class="det">Simran: ' + esc(g.focusSimran) + '</div></div>'));
    });
    panel.appendChild(wk);
  }

  function renderRules() {
    var panel = document.getElementById("tab-rules");
    panel.innerHTML = "";
    var sub = el("div", "card");
    sub.innerHTML = '<h2>🔔 Reminders</h2><div class="det">Add once per phone: Settings → Calendar → Add Subscribed Calendar.</div>';
    ["ayush", "simran"].forEach(function (p) {
      var link = CONFIG.EXEC_URL + "?token=" + encodeURIComponent(CONFIG.API_TOKEN) + "&format=ics&person=" + p;
      var a = el("a", "item");
      a.href = link; a.textContent = "📅 Subscribe: " + CONFIG.PERSON_LABELS[p];
      a.style.display = "block"; a.style.color = "var(--accent)"; a.style.textDecoration = "none";
      sub.appendChild(a);
    });
    panel.appendChild(sub);
    var pr = el("div", "card");
    pr.innerHTML = '<h2>Principles</h2>';
    state.principles.forEach(function (x) {
      pr.appendChild(el("div", "item", '<div class="col"><div class="a">' + esc(x.topic) + '</div><div class="det">' + esc(x.guideline) + '</div></div>'));
    });
    panel.appendChild(pr);
  }

    document.getElementById("tab-home").addEventListener("click", function (e) {
      var btn = e.target.closest(".check"); if (!btn) return;
      var id = btn.dataset.id, label = btn.dataset.label, person = btn.dataset.person;
      var nowOn = !state.log[id];
      if (nowOn) state.log[id] = true; else delete state.log[id];
      renderHome();
      postCheckoff({ date: todayISO(), person: person, itemId: id, itemLabel: label, done: nowOn })
        .then(function (r) { if (!r || r.ok !== true) showBanner("Check-off didn't sync (saved locally)"); });
    });

var CACHE = "health-v1";
var SHELL = [
  "./", "./index.html", "./app.css",
  "./config.js", "./js/schedule.js", "./js/mealprep.js", "./js/api.js", "./js/app.js",
  "./manifest.webmanifest", "./icons/icon-192.png", "./icons/icon-512.png"
];

self.addEventListener("install", function (e) {
  e.waitUntil(caches.open(CACHE).then(function (c) { return c.addAll(SHELL); }).then(function () { return self.skipWaiting(); }));
});
self.addEventListener("activate", function (e) {
  e.waitUntil(caches.keys().then(function (keys) {
    return Promise.all(keys.map(function (k) { return k === CACHE ? null : caches.delete(k); }));
  }).then(function () { return self.clients.claim(); }));
});
self.addEventListener("fetch", function (e) {
  var req = e.request;
  if (req.method !== "GET") return; // never cache POST check-offs
  var url = new URL(req.url);
  if (url.origin !== self.location.origin) return; // let backend calls hit the network
  e.respondWith(
    caches.match(req).then(function (cached) {
      var network = fetch(req).then(function (res) {
        if (res && res.ok) { var copy = res.clone(); caches.open(CACHE).then(function (c) { c.put(req, copy); }); }
        return res;
      }).catch(function () { return cached; });
      return cached || network;
    })
  );
});

  if ("serviceWorker" in navigator) {
    window.addEventListener("load", function () { navigator.serviceWorker.register("sw.js"); });
  }