@morphemecms/cms 0.0.0-stage → 0.1.0

package/theme/ui/toolbar.script.ts

@@ -0,0 +1,43 @@
+// What a toolbar (Toolbar.tsx, toolbarClass, role="toolbar") does on the site: it is one stop for Tab, and the arrow
+// keys (left and right, up and down on a vertical one) and Home and End move between its actions (WAI-ARIA's toolbar
+// pattern). Run on every page by the theme's Base.astro (blockScripts, packages/editor/site/blockScripts.ts); without a toolbar it does
+// nothing.
+const actions = 'a[href], button:not(:disabled), input:not(:disabled)';
+
+export default function toolbar() {
+  document.querySelectorAll<HTMLElement>('.toolbar[role="toolbar"]').forEach((bar) => {
+    const items = () => [...bar.querySelectorAll<HTMLElement>(actions)].filter((el) => el.closest('[role="toolbar"]') === bar);
+    const vertical = bar.getAttribute('aria-orientation') === 'vertical';
+    // The one Tab stops at: the one last moved to (at first the first).
+    const pick = (to: HTMLElement) => items().forEach((el) => (el.tabIndex = el === to ? 0 : -1));
+    const first = items()[0];
+    if (first) pick(first);
+
+    bar.addEventListener('focusin', (e) => {
+      const at = items().find((el) => el === e.target);
+      if (at) pick(at);
+    });
+    bar.addEventListener('keydown', (e) => {
+      const all = items();
+      const at = all.indexOf(document.activeElement as HTMLElement);
+      if (at < 0) return;
+      const back = vertical ? 'ArrowUp' : 'ArrowLeft';
+      const next = vertical ? 'ArrowDown' : 'ArrowRight';
+      const to =
+        e.key === next
+          ? (at + 1) % all.length
+          : e.key === back
+            ? (at - 1 + all.length) % all.length
+            : e.key === 'Home'
+              ? 0
+              : e.key === 'End'
+                ? all.length - 1
+                : -1;
+      // In a field in it, the keys move the caret as usual.
+      if (to < 0 || all[at] instanceof HTMLInputElement) return;
+      e.preventDefault();
+      pick(all[to]);
+      all[to].focus();
+    });
+  });
+}

package/theme/ui/tooltip.script.ts

@@ -0,0 +1,68 @@
+// What a tooltip (Tooltip.tsx) does on the site: it shows a moment after the mouse comes over its anchor and at once
+// when the anchor gets focus from the keyboard; it stays while the mouse is over the anchor or the tooltip and while
+// focus is in them, and goes when they leave, or with Escape (WCAG 1.4.13: it can be dismissed, hovered and stays).
+// Over its anchor, under it when there is no room above, and moved sideways to stay inside the window. Not on a touch
+// (a tap does what the anchor does). Run on every page by the theme's Base.astro (blockScripts, packages/editor/site/blockScripts.ts);
+// without a tooltip on the page it does nothing.
+const SHOW_MS = 500;
+const HIDE_MS = 150;
+const EDGE = 8;
+
+export default function tooltips() {
+  document.querySelectorAll<HTMLElement>('[data-tooltip]').forEach((anchor) => {
+    const tip = anchor.querySelector<HTMLElement>('.tooltip');
+    if (!tip) return;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    const place = () => {
+      anchor.removeAttribute('data-tooltip-below');
+      tip.style.removeProperty('--tooltip-shift');
+      const at = anchor.getBoundingClientRect();
+      if (at.top - tip.offsetHeight - EDGE < 0) anchor.setAttribute('data-tooltip-below', '');
+      const box = tip.getBoundingClientRect();
+      const shift = Math.max(EDGE - box.left, Math.min(0, innerWidth - EDGE - box.right));
+      if (shift) tip.style.setProperty('--tooltip-shift', `${shift}px`);
+    };
+    const show = () => {
+      clearTimeout(timer);
+      if (anchor.hasAttribute('data-tooltip-open')) return;
+      anchor.setAttribute('data-tooltip-open', '');
+      place();
+    };
+    const hide = () => {
+      clearTimeout(timer);
+      anchor.removeAttribute('data-tooltip-open');
+    };
+    const later = (run: () => void, ms: number) => {
+      clearTimeout(timer);
+      timer = setTimeout(run, ms);
+    };
+
+    // Over it with the mouse, and focus in it from the keyboard: it shows while either is so.
+    let hovered = false;
+    let focused = false;
+    anchor.addEventListener('pointerenter', (e) => {
+      if (e.pointerType === 'touch') return;
+      hovered = true;
+      later(show, SHOW_MS);
+    });
+    anchor.addEventListener('pointerleave', (e) => {
+      if (e.pointerType === 'touch') return;
+      hovered = false;
+      if (!focused) later(hide, HIDE_MS);
+    });
+    anchor.addEventListener('focusin', (e) => {
+      if (!(e.target as HTMLElement).matches(':focus-visible')) return;
+      focused = true;
+      show();
+    });
+    anchor.addEventListener('focusout', (e) => {
+      if (anchor.contains(e.relatedTarget as Node | null)) return;
+      focused = false;
+      if (!hovered) later(hide, HIDE_MS);
+    });
+    // A tap or a click on the anchor does what it does, without the tooltip over it (not one on a rich tooltip's action).
+    anchor.addEventListener('pointerdown', (e) => !tip.contains(e.target as Node) && hide());
+    addEventListener('keydown', (e) => e.key === 'Escape' && anchor.hasAttribute('data-tooltip-open') && hide());
+  });
+}

package/worker/consent.js

@@ -0,0 +1,141 @@
+// The visitors' answers in the cookie banner, so the site can show that a visitor said yes (GDPR article 7(1)): the
+// consent log, "Samtykker" under "Privatliv" in the editor (packages/editor/src/consents.ts, Consents.tsx).
+// Kept in Cloudflare D1 (the binding CONSENT in wrangler.jsonc), never in the repository: one row per answer, with the
+// random consent id the visitor's browser keeps (consentId in src/scripts/tracking.ts, shown in the banner under
+// "Cookieindstillinger"), when, the yes or no to each category the banner asked about, and the banner it was given in
+// (the commit the site was built from, /editor/version.json). No IP address, no user agent: nothing more about the
+// visitor than the answer. An answer older than two years is deleted (forgetOldConsents, each hour); the banner asks
+// again after one. Without the binding (a preview of a branch) nothing is kept and the editor says so.
+//   POST   /api/consent                     a visitor's answer, from the site's own pages: { id, choices }
+//   GET    /api/consent?q=<id>              the answers, newest first (at most LIMIT), those of a consent id starting with q
+//   GET    /api/consent?format=csv          all of them, as a file to save
+//   DELETE /api/consent                     { id } deletes the answers of a consent id (a visitor asked for it)
+// Only someone who can save the site (write access to the repository on GitHub) can read or delete them.
+import { isConsentCategory } from '../lib/cookieCategories.mjs';
+import { json } from './not-found.js';
+import { mayEdit } from './session.js';
+
+/** How long an answer is kept: two years, the banner asks again after one. */
+export const KEEP_DAYS = 730;
+const LIMIT = 500;
+// A consent id: crypto.randomUUID() in the visitor's browser.
+const ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+
+// The table, made the first time an isolate needs it (D1 has no migrations on deploy).
+let ready;
+const table = (db) =>
+  (ready ??= db
+    .batch([
+      db.prepare(
+        'CREATE TABLE IF NOT EXISTS consents (row INTEGER PRIMARY KEY, id TEXT NOT NULL, at TEXT NOT NULL, choices TEXT NOT NULL, version TEXT NOT NULL)',
+      ),
+      db.prepare('CREATE INDEX IF NOT EXISTS consents_id ON consents (id)'),
+      db.prepare('CREATE INDEX IF NOT EXISTS consents_at ON consents (at)'),
+    ])
+    .catch((e) => {
+      ready = undefined;
+      throw e;
+    }));
+
+// The commit the site was built from (the banner the visitor answered), as the deployed build says it.
+let version;
+async function versionOf(env, url) {
+  if (version) return version;
+  try {
+    const res = await env.ASSETS.fetch(new URL('/editor/version.json', url.origin));
+    version = String((await res.json()).commit ?? '');
+  } catch {
+    return '';
+  }
+  return version;
+}
+
+/** The answer as the banner sends it, or null: a consent id and a yes or no to each category asked about. */
+function answerOf(body) {
+  if (!body || typeof body !== 'object' || typeof body.id !== 'string' || !ID.test(body.id)) return null;
+  const entries = Object.entries(body.choices ?? {});
+  if (!entries.length || !entries.every(([category, yes]) => isConsentCategory(category) && typeof yes === 'boolean')) return null;
+  return { id: body.id, choices: Object.fromEntries(entries) };
+}
+
+// Only the site's own pages send an answer (not another site, not a robot posting from nowhere).
+const fromSite = (request, url) => request.headers.get('origin') === url.origin;
+
+export async function handleConsent(request, env) {
+  const url = new URL(request.url);
+  if (request.method === 'POST') {
+    if (!fromSite(request, url)) return json({ error: 'forbidden' }, 403);
+    const text = await request.text();
+    const answer = text.length <= 2000 ? answerOf(safeJson(text)) : null;
+    if (!answer) return json({ error: 'invalid' }, 400);
+    if (!env.CONSENT) return new Response(null, { status: 204 });
+    await table(env.CONSENT);
+    await env.CONSENT.prepare('INSERT INTO consents (id, at, choices, version) VALUES (?, ?, ?, ?)')
+      .bind(answer.id, new Date().toISOString(), JSON.stringify(answer.choices), await versionOf(env, url))
+      .run();
+    return new Response(null, { status: 204 });
+  }
+  if (!(await mayEdit(request))) return json({ error: 'forbidden' }, 403);
+  if (!env.CONSENT) return json({ error: 'unavailable' }, 503);
+  await table(env.CONSENT);
+  if (request.method === 'GET' && url.searchParams.get('format') === 'csv') return csv(await rows(env.CONSENT, '', 0));
+  if (request.method === 'GET') {
+    const q = (url.searchParams.get('q') ?? '')
+      .trim()
+      .toLowerCase()
+      .replace(/[^0-9a-f-]/g, '');
+    const total = await env.CONSENT.prepare('SELECT COUNT(*) AS n FROM consents').first('n');
+    return json({ entries: await rows(env.CONSENT, q, LIMIT), total });
+  }
+  if (request.method === 'DELETE') {
+    const id = safeJson(await request.text())?.id;
+    if (typeof id !== 'string' || !ID.test(id)) return json({ error: 'invalid' }, 400);
+    const { meta } = await env.CONSENT.prepare('DELETE FROM consents WHERE id = ?').bind(id).run();
+    return json({ deleted: meta.changes });
+  }
+  return json({ error: 'method' }, 405);
+}
+
+/** Deletes the answers older than KEEP_DAYS (scheduled in packages/editor/worker/index.js). Never fails the cron. */
+export async function forgetOldConsents(env) {
+  if (!env.CONSENT) return;
+  try {
+    await table(env.CONSENT);
+    const before = new Date(Date.now() - KEEP_DAYS * 24 * 60 * 60 * 1000).toISOString();
+    await env.CONSENT.prepare('DELETE FROM consents WHERE at < ?').bind(before).run();
+  } catch {}
+}
+
+// The answers, newest first: those of a consent id starting with `q`, at most `limit` (0: all).
+async function rows(db, q, limit) {
+  const where = q ? 'WHERE id LIKE ?' : '';
+  const sql = `SELECT id, at, choices, version FROM consents ${where} ORDER BY at DESC${limit ? ` LIMIT ${limit}` : ''}`;
+  const statement = q ? db.prepare(sql).bind(`${q}%`) : db.prepare(sql);
+  const { results } = await statement.all();
+  return results.map((r) => ({ id: r.id, at: r.at, choices: safeJson(r.choices) ?? {}, version: r.version }));
+}
+
+// All the answers as CSV: one column per category any answer has, true or false, empty when it was not asked.
+function csv(entries) {
+  const categories = [...new Set(entries.flatMap((e) => Object.keys(e.choices)))];
+  const cell = (value) => `"${String(value).replace(/"/g, '""')}"`;
+  const lines = [
+    ['id', 'at', ...categories, 'version'].map(cell).join(','),
+    ...entries.map((e) => [e.id, e.at, ...categories.map((c) => (c in e.choices ? e.choices[c] : '')), e.version].map(cell).join(',')),
+  ];
+  return new Response(`${lines.join('\r\n')}\r\n`, {
+    headers: {
+      'content-type': 'text/csv; charset=utf-8',
+      'content-disposition': `attachment; filename="samtykker-${new Date().toISOString().slice(0, 10)}.csv"`,
+      'cache-control': 'no-store',
+    },
+  });
+}
+
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}

package/worker/editor-github.js

@@ -0,0 +1,167 @@
+// What the editor asks of GitHub, through the Worker (packages/editor/src/github.ts): the browser never has the token
+// (packages/editor/worker/session.js), so every request to GitHub goes from here with it. The site's files come through the cache in
+// R2 (packages/editor/worker/files.js), and only to a sign-in GitHub says may read the repository (`access`, ten minutes).
+//   GET  /api/github/head          the branch's commit and root tree (always from GitHub)
+//   POST /api/github/files         { tree?, folders?, depth?, paths? }: the files in folders (`depth` levels down) and at
+//                                  paths, at a root tree, or at the branch's head
+//   POST /api/github/trees         { at: [{ root, path }] }: the folders at paths under root trees, with their entries
+//   POST /api/github/texts         { oids }: files' texts by their blob ids (at most 100)
+//   GET  /api/github/blob/<oid>    a file's bytes; ?repo=<owner>/<name> from another repository (the store), not cached
+//   POST /api/github/commit        { message, changes: [{ path, content (base64) | null, oid | null }] }: one commit,
+//                                  refused (409) when a file was changed or created elsewhere since the editor loaded it
+//   POST /api/github/graphql       any other question to GitHub's GraphQL API (who is signed in, the history, the
+//                                  store): only questions, never a change
+//   POST /api/github/logout        "Log ud": the cookie goes, and GitHub forgets the token
+import { config } from '@site/config';
+import { access, forget, noSession, sessionToken } from './session.js';
+import { filesOf, GitHubError } from './files.js';
+import { json } from './not-found.js';
+
+const OID = /^[0-9a-f]{40}([0-9a-f]{24})?$/;
+const isOid = (s) => typeof s === 'string' && OID.test(s);
+const isPath = (s) => typeof s === 'string' && s.length > 0 && s.length <= 1000 && !s.startsWith('/') && !s.split('/').includes('..');
+
+export async function handleGitHub(request, env, ctx) {
+  const route = new URL(request.url).pathname.slice('/api/github/'.length);
+  const method = request.method;
+  if (route === 'logout' && method === 'POST') return logout(request, env, ctx);
+  const token = sessionToken(request);
+  if (!token) return json({ error: 'signed out' }, 401);
+  const files = filesOf(env, token, ctx);
+  try {
+    if (route === 'graphql' && method === 'POST') return await question(request, files);
+    // The site's own files: only to someone GitHub says may read the repository.
+    const may = await access(request, files.ask);
+    if (!may) return json({ error: 'signed out' }, 401);
+    if (!may.read) return json({ error: 'forbidden' }, 403);
+    if (route === 'head' && method === 'GET') return json(await files.head());
+    if (route.startsWith('blob/') && method === 'GET') return await blob(request, route.slice('blob/'.length), files);
+    if (method !== 'POST') return json({ error: 'method' }, 405);
+    const body = await request.json().catch(() => ({}));
+    if (route === 'files') return await listed(body, files);
+    if (route === 'trees') return await folders(body, files);
+    if (route === 'texts') return await texts(body, files);
+    if (route === 'commit') return await commit(body, files);
+    return json({ error: 'not found' }, 404);
+  } catch (e) {
+    if (e instanceof GitHubError) return json({ error: e.message || undefined, status: e.status }, e.status === 401 ? 401 : 502);
+    throw e;
+  } finally {
+    await files.finish(route.replace(/\/.*/, ''));
+  }
+}
+
+// A question to GitHub's GraphQL API as it is, and GitHub's answer. A change (a mutation) only goes through `commit`.
+async function question(request, files) {
+  const body = await request.text();
+  let query;
+  try {
+    ({ query } = JSON.parse(body));
+  } catch {}
+  if (typeof query !== 'string' || /\b(mutation|subscription)\b/.test(withoutStrings(query))) return json({ error: 'only questions' }, 400);
+  const res = await files.ask('https://api.github.com/graphql', { method: 'POST', headers: { 'content-type': 'application/json' }, body });
+  return new Response(res.body, { status: res.status, headers: { 'content-type': 'application/json', 'cache-control': 'no-store' } });
+}
+
+// GraphQL without its strings and comments, where a file's name could say anything.
+const withoutStrings = (query) => query.replace(/"""[\s\S]*?"""|"(?:\\.|[^"\\])*"|#[^\n]*/g, '""');
+
+async function listed({ tree, folders = [], depth = 3, paths = [] }, files) {
+  if (
+    (tree !== undefined && !isOid(tree)) ||
+    !Array.isArray(folders) ||
+    !folders.every(isPath) ||
+    !Array.isArray(paths) ||
+    !paths.every(isPath) ||
+    !Number.isInteger(depth) ||
+    depth < 1 ||
+    depth > 20
+  )
+    return json({ error: 'request' }, 400);
+  const at = tree ? { tree } : await files.head();
+  const [lists, entries] = await Promise.all([files.filesIn(at.tree, folders, depth), files.entriesAt(at.tree, paths)]);
+  return json({
+    ...at,
+    folders: lists,
+    // At a path: a file, or anything else git has there (a folder), whose text is never asked.
+    paths: entries.map((e, i) => e && { path: paths[i], oid: e.oid, binary: e.type !== 'blob' || e.binary === true }),
+  });
+}
+
+async function folders({ at }, files) {
+  if (!Array.isArray(at) || at.length > 200 || !at.every((a) => isOid(a?.root) && (a.path === '' || isPath(a.path))))
+    return json({ error: 'request' }, 400);
+  const oids = await files.foldersAt(at);
+  const trees = await files.treesOf(oids.filter(Boolean));
+  return json({
+    trees: oids.map((oid) => {
+      const entries = oid && trees.get(oid);
+      return entries ? { oid, entries: entries.map((e) => ({ name: e.name, oid: e.oid, type: e.type, binary: e.binary === true })) } : null;
+    }),
+  });
+}
+
+async function texts({ oids }, files) {
+  if (!Array.isArray(oids) || oids.length > 100 || !oids.every(isOid)) return json({ error: 'request' }, 400);
+  const found = await files.texts(oids);
+  return json({ texts: Object.fromEntries([...found].filter(([, text]) => text !== undefined)) });
+}
+
+async function blob(request, oid, files) {
+  const repo = new URL(request.url).searchParams.get('repo')?.split('/');
+  if (!isOid(oid) || (repo && (repo.length !== 2 || !repo.every((p) => /^[\w.-]+$/.test(p))))) return json({ error: 'request' }, 400);
+  const bytes = await files.bytes(oid, repo ? { owner: repo[0], name: repo[1] } : config.repo);
+  if (!bytes) return json({ error: 'not found' }, 404);
+  // A blob id's bytes never change.
+  return new Response(bytes, {
+    headers: { 'content-type': 'application/octet-stream', 'cache-control': 'private, max-age=31536000, immutable' },
+  });
+}
+
+async function commit({ message, changes }, files) {
+  if (
+    typeof message !== 'string' ||
+    !message ||
+    !Array.isArray(changes) ||
+    !changes.length ||
+    !changes.every((c) => isPath(c?.path) && (c.content === null || typeof c.content === 'string') && (c.oid === null || isOid(c.oid)))
+  )
+    return json({ error: 'request' }, 400);
+  // The branch's commit, then the files in that same commit, so a push in between cannot slip past the check (the
+  // commit is refused unless the branch is still at this commit).
+  const at = await files.head();
+  const now = await files.entriesAt(
+    at.tree,
+    changes.map((c) => c.path),
+  );
+  const conflict = changes.findIndex((c, i) => (now[i]?.oid ?? null) !== c.oid);
+  if (conflict >= 0) return json({ conflict: changes[conflict].oid ? 'changed' : 'exists' }, 409);
+  return json(
+    await files.save(
+      at,
+      message,
+      changes.map((c) => ({ path: c.path, contents: c.content })),
+    ),
+  );
+}
+
+async function logout(request, env, ctx) {
+  const token = sessionToken(request);
+  if (token) {
+    await forget(token);
+    // GitHub forgets the token too, so it is no good to anyone after "Log ud".
+    if (env.GITHUB_CLIENT_ID && env.GITHUB_CLIENT_SECRET)
+      ctx.waitUntil(
+        fetch(`https://api.github.com/applications/${env.GITHUB_CLIENT_ID}/token`, {
+          method: 'DELETE',
+          headers: {
+            authorization: `Basic ${btoa(`${env.GITHUB_CLIENT_ID}:${env.GITHUB_CLIENT_SECRET}`)}`,
+            accept: 'application/vnd.github+json',
+            'user-agent': `${config.repo.name}-worker`,
+          },
+          body: JSON.stringify({ access_token: token }),
+        }).catch(() => {}),
+      );
+  }
+  return new Response(null, { status: 204, headers: { 'set-cookie': noSession(), 'cache-control': 'no-store' } });
+}

package/worker/editor-host.js

@@ -0,0 +1,74 @@
+// The editor on its own address (EDITOR_HOST, e.g. editor.example.dk), apart from the public
+// site: the editor's GitHub sign-in is a cookie no script can read (packages/editor/worker/session.js), but a script on the
+// same address (the site's third-party scripts, Google after consent, Calendly) could ask the Worker in the
+// editor's name, and read what the editor keeps in the browser. See docs/editor.md.
+// Without EDITOR_HOST (a variable on the Worker) the editor is at /editor/ on every address, as before.
+//   On EDITOR_HOST: the editor (/editor/), the sign-in (/oauth/), what the editor asks the Worker
+//     (/api/, packages/editor/worker/not-found.js) and files (scripts, styles, images)
+//     are served; the address alone opens the editor; any other page goes to the public site
+//     (PUBLIC_HOST, else EDITOR_HOST without "editor."), so no page of the site runs there.
+//   On any other address: the editor, the sign-in and /api/ go to EDITOR_HOST. The editor's page first
+//     removes what the editor kept on that address (the sign-in's cookie above all).
+//   A page the editor fetches as text for its preview ("Forhåndsvis", packages/editor/src/pagePreview.tsx,
+//     with the header X-Editor-Preview) is served on EDITOR_HOST too; the editor shows it without the
+//     site's scripts.
+
+import { noSession } from './session.js';
+
+// The site's pages and feeds: no file ending, or one of these.
+const PAGE = /(^|\/)[^./]*$|\.(html?|xml)$/i;
+
+/** A response for a request that belongs on the other address, or undefined to serve it here. */
+export function editorHost(url, env, request) {
+  const editor = env.EDITOR_HOST?.trim().toLowerCase();
+  if (!editor) return undefined;
+  const own =
+    url.pathname.startsWith('/editor/') ||
+    url.pathname === '/editor' ||
+    url.pathname.startsWith('/oauth/') ||
+    url.pathname.startsWith('/api/');
+
+  if (url.hostname === editor) {
+    if (url.pathname === '/' && !url.search) return redirect(`https://${editor}/editor/`, 302);
+    if (own || !PAGE.test(url.pathname) || request?.headers.get('x-editor-preview')) return undefined;
+    const site = env.PUBLIC_HOST?.trim() || editor.replace(/^editor\./, '');
+    return redirect(`https://${site}${url.pathname}${url.search}`, 302);
+  }
+
+  if (!own) return undefined;
+  const to = `https://${editor}${url.pathname}${url.search}`;
+  if (url.pathname === '/editor/' || url.pathname === '/editor') return cleanUp(to);
+  return redirect(to, 301);
+}
+
+const redirect = (location, status) => new Response(null, { status, headers: { location, 'cache-control': 'no-store' } });
+
+// The editor's page on the old address: removes the sign-in (its cookie), the editor's settings and its copy of the
+// files (IndexedDB "editor") and its service worker there, then opens the editor on its own address,
+// with what came after "#" (the open screen).
+function cleanUp(to) {
+  const js = JSON.stringify(to).replace(/</g, '\\u003c');
+  const html = `<!doctype html><html lang="da"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="robots" content="noindex"><title>Editoren er flyttet</title></head>
+<body style="font-family: system-ui, sans-serif; padding: 2rem"><p>Editoren er flyttet til <a href=${JSON.stringify(to)}>${to.replace(/^https:\/\//, '').replace(/[?#].*$/, '')}</a> …</p><script>
+(async () => {
+  try {
+    for (const key of Object.keys(localStorage)) if (key.startsWith('editor-')) localStorage.removeItem(key);
+  } catch {}
+  try {
+    indexedDB.deleteDatabase('editor');
+  } catch {}
+  try {
+    for (const r of (await navigator.serviceWorker?.getRegistrations()) ?? []) if (new URL(r.scope).pathname.startsWith('/editor/')) await r.unregister();
+  } catch {}
+  location.replace(${js} + location.hash);
+})();
+</script></body></html>`;
+  return new Response(html, {
+    headers: {
+      'content-type': 'text/html; charset=utf-8',
+      'cache-control': 'no-store',
+      'x-robots-tag': 'noindex',
+      'set-cookie': noSession(),
+    },
+  });
+}