@x8r/sapphire 0.1.0

package/src/commands.ts

@@ -0,0 +1,36 @@
+import type { SapphireRegistry } from "./registry";
+
+export interface MatchedCommand {
+  extId: string;
+  name: string;
+}
+
+export function findMatchingCommand(registry: SapphireRegistry, e: Pick<KeyboardEvent, "key" | "ctrlKey" | "metaKey" | "shiftKey" | "altKey">): MatchedCommand | null {
+  for (const ext of registry.list()) {
+    if (!ext.enabled) continue;
+    const commands = ext.manifest.commands ?? {};
+    for (const [name, cmd] of Object.entries(commands)) {
+      const shortcut = cmd.suggested_key?.default ?? cmd.suggested_key?.windows ?? "";
+      if (!shortcut) continue;
+      const parts = shortcut.toLowerCase().split("+").map((s) => s.trim());
+      const needsCtrl = parts.includes("ctrl");
+      const needsShift = parts.includes("shift");
+      const needsAlt = parts.includes("alt");
+      const key = parts.find((p) => !["ctrl", "shift", "alt", "command"].includes(p));
+      if (
+        key &&
+        e.key.toLowerCase() === key &&
+        (needsCtrl ? e.ctrlKey || e.metaKey : true) &&
+        (needsShift ? e.shiftKey : !e.shiftKey) &&
+        (needsAlt ? e.altKey : !e.altKey)
+      ) {
+        return { extId: ext.id, name };
+      }
+    }
+  }
+  return null;
+}
+
+export function triggerCommand(registry: SapphireRegistry, extId: string, name: string): void {
+  registry.broadcast(extId, (e) => e.commandsOnCommand, [name]);
+}

package/src/contentScripts.ts

@@ -0,0 +1,103 @@
+import { installChromeApi } from "./chromeApi";
+import { readExtFileText } from "./fileStore";
+import { injectScript, injectStyle } from "./htmlInject";
+import { urlMatchesPatterns } from "./manifest";
+import type { ExtensionState, SapphireRegistry } from "./registry";
+import type { ChromeManifestContentScript, ContentScriptRegistration, SapphireHostBindings } from "./types";
+
+export function registerContentScripts(ext: ExtensionState, registry: SapphireRegistry): void {
+  const scripts: ChromeManifestContentScript[] = ext.manifest.content_scripts ?? [];
+  for (const cs of scripts) {
+    registry.contentScripts.push({
+      extId: ext.id,
+      matches: cs.matches ?? [],
+      excludeMatches: cs.exclude_matches ?? [],
+      js: cs.js ?? [],
+      css: cs.css ?? [],
+      runAt: cs.run_at ?? "document_idle",
+      allFrames: cs.all_frames ?? false,
+    });
+  }
+}
+
+export function unregisterContentScripts(extId: string, registry: SapphireRegistry): void {
+  for (let i = registry.contentScripts.length - 1; i >= 0; i--) {
+    if (registry.contentScripts[i].extId === extId) registry.contentScripts.splice(i, 1);
+  }
+}
+
+function generateDocumentId(): string {
+  return typeof crypto?.randomUUID === "function" ? crypto.randomUUID().replace(/-/g, "") : Math.random().toString(36).slice(2).padEnd(32, "0");
+}
+
+export async function injectContentScripts(
+  win: Window,
+  tabId: number,
+  url: string,
+  isTopLevel: boolean,
+  registry: SapphireRegistry,
+  host: SapphireHostBindings,
+): Promise<void> {
+  if (!url) return;
+  const matching = registry.contentScripts.filter(
+    (cs) => (isTopLevel || cs.allFrames) && urlMatchesPatterns(url, cs.matches, cs.excludeMatches),
+  );
+  if (!matching.length) return;
+
+  const documentId = generateDocumentId();
+  const frameId = isTopLevel ? 0 : 1;
+
+  const installedExts = new Set<string>();
+  const ensureChromeApi = (extId: string) => {
+    if (installedExts.has(extId)) return;
+    installedExts.add(extId);
+    installChromeApi(win, {
+      extId,
+      tabId,
+      isBackground: false,
+      registry,
+      host,
+      senderUrl: url,
+      senderFrameId: frameId,
+      senderDocumentId: documentId,
+    });
+  };
+
+  const byRunAt: Record<ContentScriptRegistration["runAt"], ContentScriptRegistration[]> = {
+    document_start: [],
+    document_end: [],
+    document_idle: [],
+  };
+  for (const cs of matching) {
+    const ext = registry.get(cs.extId);
+    if (!ext?.enabled) continue;
+    byRunAt[cs.runAt].push(cs);
+  }
+
+  const injectGroup = async (group: ContentScriptRegistration[]) => {
+    for (const cs of group) {
+      ensureChromeApi(cs.extId);
+      for (const cssFile of cs.css) {
+        const css = await readExtFileText(cs.extId, cssFile);
+        if (css) injectStyle(win, css);
+      }
+      for (const jsFile of cs.js) {
+        const code = await readExtFileText(cs.extId, jsFile);
+        if (code) injectScript(win, code);
+      }
+    }
+  };
+
+  await injectGroup(byRunAt.document_start);
+  if (byRunAt.document_end.length) {
+    win.addEventListener("DOMContentLoaded", () => void injectGroup(byRunAt.document_end), { once: true });
+  }
+  if (byRunAt.document_idle.length) {
+    win.addEventListener("load", () => void injectGroup(byRunAt.document_idle), { once: true });
+  }
+
+  const tab = host.getTab(tabId);
+  for (const extId of new Set(matching.map((cs) => cs.extId))) {
+    registry.broadcast(extId, (e) => e.tabsOnUpdated, [tabId, { status: "complete" }, tab]);
+  }
+}

package/src/crx.ts

@@ -0,0 +1,60 @@
+export function crxToZip(buffer: ArrayBuffer): ArrayBuffer {
+  const view = new DataView(buffer);
+  const magic = String.fromCharCode(view.getUint8(0), view.getUint8(1), view.getUint8(2), view.getUint8(3));
+  if (magic !== "Cr24") {
+    return buffer; 
+  }
+  const version = view.getUint32(4, true);
+  let zipStart: number;
+  if (version === 2) {
+    const pubKeyLen = view.getUint32(8, true);
+    const sigLen = view.getUint32(12, true);
+    zipStart = 16 + pubKeyLen + sigLen;
+  } else if (version === 3) {
+    const headerSize = view.getUint32(8, true);
+    zipStart = 12 + headerSize;
+  } else {
+    throw new Error(`unknown CRX version: ${version}`);
+  }
+  return buffer.slice(zipStart);
+}
+
+export function generateExtensionId(seed: string): string {
+  let hash = 0;
+  for (let i = 0; i < seed.length; i++) {
+    hash = (hash << 5) - hash + seed.charCodeAt(i);
+    hash |= 0;
+  }
+  const chars = "abcdefghijklmnopqrstuvwxyz";
+  let id = "";
+  let n = Math.abs(hash);
+  for (let i = 0; i < 32; i++) {
+    id += chars[n % 26];
+    n = Math.floor(n / 26) + i * 7;
+  }
+  return id.substring(0, 32);
+}
+
+const MIME_TYPES: Record<string, string> = {
+  js: "application/javascript",
+  mjs: "application/javascript",
+  css: "text/css",
+  html: "text/html",
+  htm: "text/html",
+  json: "application/json",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  webp: "image/webp",
+  ico: "image/x-icon",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+};
+
+export function guessMime(path: string): string {
+  const ext = path.split(".").pop()?.toLowerCase() ?? "";
+  return MIME_TYPES[ext] ?? "application/octet-stream";
+}

package/src/db.ts

@@ -0,0 +1,81 @@
+const DB_NAME = "sapphire_extensions";
+const DB_VERSION = 1;
+
+export const EXT_STORE = "extensions";
+export const EXT_FILES_STORE = "extension_files";
+export const EXT_STORAGE_STORE = "extension_storage";
+
+let dbPromise: Promise<IDBDatabase> | null = null;
+
+function openDB(): Promise<IDBDatabase> {
+  if (dbPromise) return dbPromise;
+  dbPromise = new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(EXT_STORE)) {
+        db.createObjectStore(EXT_STORE, { keyPath: "id" });
+      }
+      if (!db.objectStoreNames.contains(EXT_FILES_STORE)) {
+        db.createObjectStore(EXT_FILES_STORE);
+      }
+      if (!db.objectStoreNames.contains(EXT_STORAGE_STORE)) {
+        db.createObjectStore(EXT_STORAGE_STORE);
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+  return dbPromise;
+}
+
+export async function dbGet<T = unknown>(store: string, key: IDBValidKey): Promise<T | undefined> {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readonly");
+    const req = tx.objectStore(store).get(key);
+    req.onsuccess = () => resolve(req.result as T | undefined);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function dbPut(store: string, key: IDBValidKey | null, value: unknown): Promise<IDBValidKey> {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readwrite");
+    const objStore = tx.objectStore(store);
+    const req = key === null ? objStore.put(value) : objStore.put(value, key);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function dbDelete(store: string, key: IDBValidKey): Promise<void> {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readwrite");
+    const req = tx.objectStore(store).delete(key);
+    req.onsuccess = () => resolve();
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function dbGetAll<T = unknown>(store: string): Promise<T[]> {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readonly");
+    const req = tx.objectStore(store).getAll();
+    req.onsuccess = () => resolve(req.result as T[]);
+    req.onerror = () => reject(req.error);
+  });
+}
+
+export async function dbGetAllKeys(store: string): Promise<IDBValidKey[]> {
+  const db = await openDB();
+  return new Promise((resolve, reject) => {
+    const tx = db.transaction(store, "readonly");
+    const req = tx.objectStore(store).getAllKeys();
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}

package/src/dnr.ts

@@ -0,0 +1,88 @@
+import type { DNRDecision, DNRRule } from "./types";
+import type { ExtensionState, SapphireRegistry } from "./registry";
+
+export function recomputeStaticRules(ext: ExtensionState): void {
+  ext.staticRules = [];
+  for (const id of ext.enabledRulesetIds) {
+    const rules = ext.rulesetRules.get(id);
+    if (rules) ext.staticRules.push(...rules);
+  }
+}
+
+function ruleMatchesUrl(rule: DNRRule, requestUrl: string): boolean {
+  const cond = rule.condition;
+  if (cond.urlFilter) {
+    const pattern = cond.urlFilter
+      .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+      .replace(/\*/g, ".*")
+      .replace(/\|\|/g, "(?:https?://)(?:[^/]*\\.)?")
+      .replace(/\^/g, "[/?&#]");
+    try {
+      if (!new RegExp(pattern, "i").test(requestUrl)) return false;
+    } catch {
+      return false;
+    }
+  }
+  if (cond.regexFilter) {
+    try {
+      if (!new RegExp(cond.regexFilter, "i").test(requestUrl)) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+function ruleMatchesResourceType(rule: DNRRule, resourceType?: string): boolean {
+  if (!rule.condition.resourceTypes?.length) return true;
+  return resourceType ? rule.condition.resourceTypes.includes(resourceType) : false;
+}
+
+function ruleMatchesInitiator(rule: DNRRule, initiatorUrl?: string): boolean {
+  const cond = rule.condition;
+  if (!initiatorUrl) return !cond.initiatorDomains?.length;
+  let initHost: string;
+  try {
+    initHost = new URL(initiatorUrl).hostname;
+  } catch {
+    return !cond.initiatorDomains?.length;
+  }
+  if (cond.initiatorDomains?.length && !cond.initiatorDomains.some((d) => initHost === d || initHost.endsWith(`.${d}`))) {
+    return false;
+  }
+  if (cond.excludedInitiatorDomains?.some((d) => initHost === d || initHost.endsWith(`.${d}`))) {
+    return false;
+  }
+  return true;
+}
+
+export function checkDeclarativeNetRequest(
+  registry: SapphireRegistry,
+  requestUrl: string,
+  initiatorUrl?: string,
+  resourceType?: string,
+): DNRDecision | null {
+  for (const ext of registry.list()) {
+    if (!ext.enabled) continue;
+    const rules = [...ext.dynamicRules, ...ext.staticRules].sort((a, b) => (b.priority ?? 1) - (a.priority ?? 1));
+    for (const rule of rules) {
+      if (!ruleMatchesUrl(rule, requestUrl)) continue;
+      if (!ruleMatchesResourceType(rule, resourceType)) continue;
+      if (!ruleMatchesInitiator(rule, initiatorUrl)) continue;
+
+      const action = rule.action;
+      if (action.type === "block") return { action: "block" };
+      if (action.type === "redirect") {
+        const redirectUrl = action.redirect?.url ?? action.redirect?.regexSubstitution;
+        if (redirectUrl) return { action: "redirect", url: redirectUrl };
+      }
+      if (action.type === "upgradeScheme") {
+        return { action: "redirect", url: requestUrl.replace(/^http:/, "https:") };
+      }
+      if (action.type === "modifyHeaders") {
+        return { action: "modifyHeaders", headers: action.requestHeaders ?? [], responseHeaders: action.responseHeaders ?? [] };
+      }
+    }
+  }
+  return null;
+}

package/src/eventHub.ts

@@ -0,0 +1,56 @@
+export type Listener = (...args: any[]) => any;
+
+export class EventHub {
+  private listeners: Listener[] = [];
+
+  addListener = (fn: Listener): void => {
+    if (typeof fn === "function" && !this.listeners.includes(fn)) {
+      this.listeners.push(fn);
+    }
+  };
+
+  removeListener = (fn: Listener): void => {
+    const i = this.listeners.indexOf(fn);
+    if (i > -1) this.listeners.splice(i, 1);
+  };
+
+  hasListener = (fn: Listener): boolean => this.listeners.includes(fn);
+
+  hasListeners = (): boolean => this.listeners.length > 0;
+
+  fire(...args: unknown[]): void {
+    for (const fn of [...this.listeners]) {
+      queueMicrotask(() => {
+        try {
+          fn(...args);
+        } catch (e) {
+          console.error("[sapphire] event listener threw", e);
+        }
+      });
+    }
+  }
+
+  fireUntilHandled(...args: unknown[]): unknown {
+    for (const fn of [...this.listeners]) {
+      try {
+        const result = fn(...args);
+        if (result !== undefined) return result;
+      } catch (e) {
+        console.error("[sapphire] event listener threw", e);
+      }
+    }
+    return undefined;
+  }
+
+  snapshot(): Listener[] {
+    return [...this.listeners];
+  }
+
+  toApi() {
+    return {
+      addListener: this.addListener,
+      removeListener: this.removeListener,
+      hasListener: this.hasListener,
+    };
+  }
+}

package/src/extensions.ts

@@ -0,0 +1,216 @@
+import JSZip from "jszip";
+import { crxToZip, generateExtensionId } from "./crx";
+import { dbDelete, dbGet, dbGetAll, dbGetAllKeys, dbPut, EXT_FILES_STORE, EXT_STORAGE_STORE, EXT_STORE } from "./db";
+import { readExtFileText, readExtFileURL } from "./fileStore";
+import { startBackground, stopBackground } from "./background";
+import { registerContentScripts, unregisterContentScripts } from "./contentScripts";
+import { getDefaultIcon, resolveManifestI18n } from "./manifest";
+import { recomputeStaticRules } from "./dnr";
+import type { SapphireRegistry } from "./registry";
+import type { ChromeManifest, ExtensionMeta, SapphireHostBindings } from "./types";
+
+export interface InstalledExtensionSummary {
+  id: string;
+  name: string;
+  version: string | undefined;
+  enabled: boolean;
+  manifest: ChromeManifest;
+  iconUrl: string | null;
+  title: string | null;
+  badgeText: string;
+  badgeColor: string | null;
+  hasPopup: boolean;
+}
+
+async function loadMessages(extId: string, manifest: ChromeManifest): Promise<Record<string, { message: string }>> {
+  const defaultLocale = manifest.default_locale ?? "en";
+  const primary = await readExtFileText(extId, `_locales/${defaultLocale}/messages.json`);
+  if (primary) {
+    try {
+      return JSON.parse(primary);
+    } catch {
+    }
+  }
+  if (defaultLocale !== "en") {
+    const en = await readExtFileText(extId, "_locales/en/messages.json");
+    if (en) {
+      try {
+        return JSON.parse(en);
+      } catch {
+      }
+    }
+  }
+  return {};
+}
+
+export async function loadExtension(
+  meta: ExtensionMeta,
+  registry: SapphireRegistry,
+  host: SapphireHostBindings,
+  backgroundRoot: HTMLElement,
+): Promise<void> {
+  const ext = registry.createExtensionState(meta.id, meta.manifest, meta.enabled !== false, meta.installedAt, meta.filename);
+
+  ext.messages = await loadMessages(ext.id, ext.manifest);
+  resolveManifestI18n(ext.manifest, ext.messages);
+  registerContentScripts(ext, registry);
+
+  const defaultIconPath = getDefaultIcon(ext.manifest);
+  if (defaultIconPath) {
+    try {
+      ext.iconUrl = await readExtFileURL(ext.id, defaultIconPath);
+    } catch (e) {
+      console.warn(`[sapphire] failed to resolve default icon for ${ext.manifest.name}`, e);
+    }
+  }
+
+  const ruleResources = ext.manifest.declarative_net_request?.rule_resources ?? [];
+  for (const ruleSet of ruleResources) {
+    if (!ruleSet.path || !ruleSet.id) continue;
+    const rulesText = await readExtFileText(ext.id, ruleSet.path);
+    if (!rulesText) continue;
+    try {
+      ext.rulesetRules.set(ruleSet.id, JSON.parse(rulesText));
+      if (ruleSet.enabled !== false) ext.enabledRulesetIds.add(ruleSet.id);
+    } catch (e) {
+      console.warn(`[sapphire] failed to parse rule set ${ruleSet.path}`, e);
+    }
+  }
+  recomputeStaticRules(ext);
+
+  if (ext.enabled) {
+    try {
+      await startBackground(ext, registry, host, backgroundRoot);
+    } catch (e) {
+      console.error(`[sapphire] failed to start background for ${ext.manifest.name}`, e);
+    }
+  }
+
+  registry.notifyChange();
+}
+
+export async function loadStoredExtensions(registry: SapphireRegistry, host: SapphireHostBindings, backgroundRoot: HTMLElement): Promise<number> {
+  const stored = await dbGetAll<ExtensionMeta>(EXT_STORE);
+  for (const meta of stored) {
+    try {
+      await loadExtension(meta, registry, host, backgroundRoot);
+    } catch (e) {
+      console.error(`[sapphire] failed to load stored extension ${meta.id}`, e);
+    }
+  }
+  return stored.length;
+}
+
+export async function installExtension(
+  buffer: ArrayBuffer,
+  filename: string,
+  registry: SapphireRegistry,
+  host: SapphireHostBindings,
+  backgroundRoot: HTMLElement,
+): Promise<string> {
+  const zipBuffer = crxToZip(buffer);
+  const zip = await JSZip.loadAsync(zipBuffer);
+
+  const manifestFile = zip.file("manifest.json");
+  if (!manifestFile) throw new Error("no manifest.json found in extension");
+  const manifestText = await manifestFile.async("text");
+
+  let manifest: ChromeManifest;
+  try {
+    manifest = JSON.parse(manifestText);
+  } catch (e) {
+    throw new Error(`invalid manifest: ${(e as Error).message}`);
+  }
+
+  const extId = generateExtensionId(manifest.name + (manifest.version ?? ""));
+
+  const fileOps: Promise<void>[] = [];
+  zip.forEach((path, file) => {
+    if (file.dir) return;
+    fileOps.push(
+      file
+        .async("arraybuffer")
+        .then((ab) => dbPut(EXT_FILES_STORE, `${extId}/${path}`, ab))
+        .then(() => undefined)
+        .catch((e) => {
+          console.error(`[sapphire] failed to store file ${path} for ${manifest.name}`, e);
+        }),
+    );
+  });
+  await Promise.all(fileOps);
+
+  const meta: ExtensionMeta = {
+    id: extId,
+    manifest,
+    enabled: true,
+    installedAt: Date.now(),
+    filename,
+    fileList: [],
+  };
+  await dbPut(EXT_STORE, null, meta);
+  await loadExtension(meta, registry, host, backgroundRoot);
+  return extId;
+}
+
+export async function uninstallExtension(extId: string, registry: SapphireRegistry): Promise<void> {
+  const ext = registry.get(extId);
+  if (!ext) return;
+
+  stopBackground(ext);
+  unregisterContentScripts(extId, registry);
+  registry.remove(extId);
+
+  await dbDelete(EXT_STORE, extId);
+  const fileKeys = await dbGetAllKeys(EXT_FILES_STORE);
+  for (const k of fileKeys.filter((key) => typeof key === "string" && key.startsWith(`${extId}/`))) {
+    await dbDelete(EXT_FILES_STORE, k);
+  }
+  const storageKeys = await dbGetAllKeys(EXT_STORAGE_STORE);
+  for (const k of storageKeys.filter((key) => typeof key === "string" && key.startsWith(`${extId}/`))) {
+    await dbDelete(EXT_STORAGE_STORE, k);
+  }
+  registry.notifyChange();
+}
+
+export async function setExtensionEnabled(
+  extId: string,
+  enabled: boolean,
+  registry: SapphireRegistry,
+  host: SapphireHostBindings,
+  backgroundRoot: HTMLElement,
+): Promise<void> {
+  const ext = registry.get(extId);
+  if (!ext) return;
+  ext.enabled = enabled;
+  const stored = await dbGet<ExtensionMeta>(EXT_STORE, extId);
+  if (stored) {
+    stored.enabled = enabled;
+    await dbPut(EXT_STORE, null, stored);
+  }
+  if (enabled) {
+    await startBackground(ext, registry, host, backgroundRoot);
+  } else {
+    stopBackground(ext);
+  }
+  registry.notifyChange();
+}
+
+export function getInstalledExtensions(registry: SapphireRegistry): InstalledExtensionSummary[] {
+  return registry.list().map((ext) => ({
+    id: ext.id,
+    name: ext.manifest.name,
+    version: ext.manifest.version,
+    enabled: ext.enabled,
+    manifest: ext.manifest,
+    iconUrl: ext.iconUrl,
+    title: ext.title,
+    badgeText: ext.badgeText,
+    badgeColor: ext.badgeColor,
+    hasPopup: Boolean(
+      ext.popupPage ??
+        ext.manifest.action?.default_popup ??
+        ext.manifest.browser_action?.default_popup ??
+        ext.manifest.page_action?.default_popup,
+    ),
+  }));
+}

package/src/fileStore.ts

@@ -0,0 +1,22 @@
+import { dbGet } from "./db";
+import { EXT_FILES_STORE } from "./db";
+import { guessMime } from "./crx";
+
+export async function readExtFile(extId: string, path: string): Promise<ArrayBuffer | null> {
+  const key = `${extId}/${path.replace(/^\//, "")}`;
+  const ab = await dbGet<ArrayBuffer>(EXT_FILES_STORE, key);
+  return ab ?? null;
+}
+
+export async function readExtFileText(extId: string, path: string): Promise<string | null> {
+  const ab = await readExtFile(extId, path);
+  if (!ab) return null;
+  return new TextDecoder().decode(ab);
+}
+
+export async function readExtFileURL(extId: string, path: string): Promise<string | null> {
+  const ab = await readExtFile(extId, path);
+  if (!ab) return null;
+  const mime = guessMime(path);
+  return URL.createObjectURL(new Blob([ab], { type: mime }));
+}