@tlockney/cdp-kernel 0.6.0 → 0.7.1

package/dist/browser/worker.js

@@ -0,0 +1,1071 @@
+// runtime/comm.mjs
+var Comm = class {
+  #send;
+  #onClosed;
+  #msgHandlers = [];
+  #closeHandlers = [];
+  closed = false;
+  constructor(id, targetName, send, onClosed) {
+    this.id = id;
+    this.targetName = targetName;
+    this.#send = send;
+    this.#onClosed = onClosed;
+  }
+  send(data = {}, { metadata = {}, buffers = [] } = {}) {
+    if (this.closed) return;
+    this.#send("comm_msg", { comm_id: this.id, data }, metadata, buffers);
+  }
+  close(data = {}, { metadata = {}, buffers = [] } = {}) {
+    if (this.closed) return;
+    this.#send("comm_close", { comm_id: this.id, data }, metadata, buffers);
+    void this._closed({ data, metadata, buffers });
+  }
+  onMsg(handler) {
+    this.#msgHandlers.push(handler);
+  }
+  onClose(handler) {
+    this.#closeHandlers.push(handler);
+  }
+  async _receive(msg) {
+    for (const handler of this.#msgHandlers) await handler(msg);
+  }
+  async _closed(msg) {
+    if (this.closed) return;
+    this.closed = true;
+    this.#onClosed(this.id);
+    for (const handler of this.#closeHandlers) await handler(msg);
+  }
+};
+function createComms(send, newId = () => crypto.randomUUID()) {
+  const comms = /* @__PURE__ */ new Map();
+  const targets = /* @__PURE__ */ new Map();
+  const forget = (id) => comms.delete(id);
+  function track(id, targetName) {
+    const comm = new Comm(id, targetName, send, forget);
+    comms.set(id, comm);
+    return comm;
+  }
+  const api = {
+    open(targetName, data = {}, { metadata = {}, buffers = [] } = {}) {
+      const comm = track(newId(), targetName);
+      send("comm_open", { comm_id: comm.id, target_name: targetName, data }, metadata, buffers);
+      return comm;
+    },
+    registerTarget(targetName, handler) {
+      targets.set(targetName, handler);
+    },
+    unregisterTarget(targetName) {
+      targets.delete(targetName);
+    }
+  };
+  async function dispatch(msgType, content, metadata, buffers) {
+    const msg = { data: content.data ?? {}, metadata: metadata ?? {}, buffers: buffers ?? [] };
+    if (msgType === "comm_open") {
+      const handler = targets.get(content.target_name);
+      if (!handler) return false;
+      const comm2 = track(content.comm_id, content.target_name);
+      try {
+        await handler(comm2, msg);
+      } catch (err) {
+        comm2.closed = true;
+        forget(comm2.id);
+        throw err;
+      }
+      return true;
+    }
+    const comm = comms.get(content.comm_id);
+    if (!comm) return false;
+    if (msgType === "comm_msg") await comm._receive(msg);
+    else if (msgType === "comm_close") await comm._closed(msg);
+    else return false;
+    return true;
+  }
+  function list2() {
+    return [...comms.values()].map((comm) => ({ commId: comm.id, targetName: comm.targetName }));
+  }
+  return { api, dispatch, list: list2 };
+}
+
+// runtime/widget.mjs
+var WIDGET_PROTOCOL_VERSION = "2.1.0";
+var WIDGET_TARGET = "jupyter.widget";
+var CONTROL_TARGET = "jupyter.widget.control";
+var VIEW_MIME = "application/vnd.jupyter.widget-view+json";
+var ANYWIDGET_MODEL = {
+  _model_name: "AnyModel",
+  _model_module: "anywidget",
+  _model_module_version: "*",
+  _view_name: "AnyView",
+  _view_module: "anywidget",
+  _view_module_version: "*",
+  _view_count: null
+};
+function isBinary(value) {
+  return value instanceof Uint8Array || value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+function toBytes(value) {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+}
+function removeBuffers(state) {
+  const bufferPaths = [];
+  const buffers = [];
+  function walk(value, path) {
+    if (isBinary(value)) {
+      bufferPaths.push(path);
+      buffers.push(toBytes(value));
+      return null;
+    }
+    if (Array.isArray(value)) return value.map((item, i) => walk(item, [...path, i]));
+    if (value !== null && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walk(v, [...path, k])]));
+    }
+    return value;
+  }
+  return { state: walk(state, []), bufferPaths, buffers };
+}
+function putBuffers(state, bufferPaths = [], buffers = []) {
+  bufferPaths.forEach((path, i) => {
+    let obj = state;
+    for (const key2 of path.slice(0, -1)) obj = obj[key2];
+    obj[path[path.length - 1]] = buffers[i];
+  });
+  return state;
+}
+var Widget = class {
+  #comm;
+  #state;
+  #listeners = /* @__PURE__ */ new Map();
+  // event -> Set<listener>
+  constructor(comm, state, $display2) {
+    this.#comm = comm;
+    this.#state = state;
+    this[$display2] = () => ({
+      [VIEW_MIME]: { version_major: 2, version_minor: 1, model_id: this.id },
+      "text/plain": `Widget(${this.id})`
+    });
+  }
+  get id() {
+    return this.#comm.id;
+  }
+  get closed() {
+    return this.#comm.closed;
+  }
+  get(key2) {
+    return this.#state[key2];
+  }
+  /** set("key", value) or set({ key: value, ... }); syncs to the frontend. */
+  set(keyOrChanges, value) {
+    const changes = typeof keyOrChanges === "string" ? { [keyOrChanges]: value } : keyOrChanges;
+    this.#apply(changes);
+    if (this.closed) return;
+    const { state, bufferPaths, buffers } = removeBuffers(changes);
+    this.#comm.send({ method: "update", state, buffer_paths: bufferPaths }, { buffers });
+  }
+  on(event, listener) {
+    if (!this.#listeners.has(event)) this.#listeners.set(event, /* @__PURE__ */ new Set());
+    this.#listeners.get(event).add(listener);
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+  }
+  /** A custom message, delivered to the view's model.on("msg:custom"). */
+  send(content, buffers = []) {
+    this.#comm.send({ method: "custom", content }, { buffers });
+  }
+  close() {
+    this.#comm.close();
+  }
+  /** The full state, as the frontend sees it (for request_state). */
+  fullState() {
+    return { ...ANYWIDGET_MODEL, ...this.#state };
+  }
+  async #emit(event, ...args) {
+    for (const listener of this.#listeners.get(event) ?? []) await listener(...args);
+  }
+  async #apply(changes) {
+    const previous = {};
+    for (const [key2, value] of Object.entries(changes)) {
+      previous[key2] = this.#state[key2];
+      this.#state[key2] = value;
+    }
+    for (const key2 of Object.keys(changes)) await this.#emit(`change:${key2}`, changes[key2], previous[key2]);
+    await this.#emit("change", changes);
+  }
+  async _receive(msg) {
+    const { method } = msg.data;
+    if (method === "update") {
+      const changes = putBuffers(msg.data.state ?? {}, msg.data.buffer_paths, msg.buffers);
+      await this.#apply(changes);
+    } else if (method === "request_state") {
+      const { state, bufferPaths, buffers } = removeBuffers(this.fullState());
+      this.#comm.send({ method: "update", state, buffer_paths: bufferPaths }, { buffers });
+    } else if (method === "custom") {
+      await this.#emit("msg:custom", msg.data.content, msg.buffers);
+    }
+  }
+};
+function createWidgetFactory(commApi, $display2) {
+  const live = /* @__PURE__ */ new Map();
+  commApi.registerTarget(CONTROL_TARGET, (control) => {
+    control.onMsg((msg) => {
+      if (msg.data.method !== "request_states") return;
+      const states = {};
+      for (const widget of live.values()) {
+        const full = widget.fullState();
+        states[widget.id] = {
+          model_name: full._model_name,
+          model_module: full._model_module,
+          model_module_version: full._model_module_version,
+          state: full
+        };
+      }
+      const { state, bufferPaths, buffers } = removeBuffers(states);
+      control.send({ method: "update_states", states: state, buffer_paths: bufferPaths }, { buffers });
+    });
+  });
+  return function widget({ esm, css, state = {} } = {}) {
+    if (typeof esm !== "string") throw new TypeError("jupyter.widget needs an `esm` module string");
+    const initial = { ...state };
+    const full = {
+      ...ANYWIDGET_MODEL,
+      _esm: esm,
+      ...css === void 0 ? {} : { _css: css },
+      _anywidget_id: "cdp-kernel.widget",
+      ...initial
+    };
+    const { state: wire, bufferPaths, buffers } = removeBuffers(full);
+    const comm = commApi.open(WIDGET_TARGET, { state: wire, buffer_paths: bufferPaths }, {
+      metadata: { version: WIDGET_PROTOCOL_VERSION },
+      buffers
+    });
+    const instance = new Widget(comm, { ...full }, $display2);
+    live.set(comm.id, instance);
+    comm.onMsg((msg) => instance._receive(msg));
+    comm.onClose(() => {
+      live.delete(comm.id);
+    });
+    return instance;
+  };
+}
+
+// runtime/display.mjs
+var $display = Symbol.for("Jupyter.display");
+var rawToEntity = /* @__PURE__ */ new Map([
+  ["&", "&amp;"],
+  ["<", "&lt;"],
+  [">", "&gt;"],
+  ['"', "&quot;"],
+  ["'", "&#39;"]
+]);
+var rawRe = new RegExp(`[${[...rawToEntity.keys()].join("")}]`, "g");
+function escapeHTML(str) {
+  return str.replaceAll(rawRe, (m) => rawToEntity.get(m) ?? m);
+}
+function isVegaLike(obj) {
+  return obj !== null && typeof obj === "object" && "toSpec" in obj;
+}
+function extractVega(obj) {
+  const spec = obj.toSpec();
+  if (typeof spec !== "object" || spec === null || !("$schema" in spec)) return null;
+  let mediaType = "application/vnd.vega.v5+json";
+  if (spec.$schema === "https://vega.github.io/schema/vega-lite/v4.json") {
+    mediaType = "application/vnd.vegalite.v4+json";
+  } else if (spec.$schema === "https://vega.github.io/schema/vega-lite/v5.json") {
+    mediaType = "application/vnd.vegalite.v5+json";
+  }
+  const summary = summarizeChart(spec);
+  return summary === void 0 ? { [mediaType]: spec } : { [mediaType]: spec, "text/plain": summary };
+}
+var VL_TYPES = { Q: "quantitative", N: "nominal", O: "ordinal", T: "temporal", G: "geojson" };
+var MAX_CHILDREN = 6;
+function clip(str, max = 60) {
+  return str.length > max ? `${str.slice(0, max - 1)}\u2026` : str;
+}
+function formatNumber(n) {
+  return Number.isInteger(n) ? String(n) : String(Number(n.toPrecision(4)));
+}
+function titleText(title) {
+  const text = typeof title === "object" && title !== null && !Array.isArray(title) ? title.text : title;
+  const str = Array.isArray(text) ? text.join(" ") : typeof text === "string" ? text : "";
+  return str ? ` "${clip(str, 80)}"` : "";
+}
+function getField(row, field) {
+  if (row === null || typeof row !== "object") return void 0;
+  if (field in row) return row[field];
+  if (field.includes("\\")) return row[field.replace(/\\(.)/g, "$1")];
+  return field.split(".").reduce((obj, key2) => obj === null || typeof obj !== "object" ? void 0 : obj[key2], row);
+}
+function fieldStats(rows, field, type) {
+  const values = [];
+  for (const row of rows) {
+    const value = getField(row, field);
+    if (value !== void 0 && value !== null && value !== "") values.push(value);
+  }
+  if (values.length === 0) return "";
+  if (type === "quantitative") {
+    let min = Infinity;
+    let max = -Infinity;
+    for (const value of values) {
+      const n = Number(value);
+      if (!Number.isFinite(n)) continue;
+      if (n < min) min = n;
+      if (n > max) max = n;
+    }
+    if (min > max) return "";
+    return min === max ? formatNumber(min) : `${formatNumber(min)} to ${formatNumber(max)}`;
+  }
+  if (type === "temporal") {
+    let min;
+    let max;
+    for (const value of values) {
+      const t = value instanceof Date ? value.getTime() : typeof value === "number" ? value : Date.parse(String(value));
+      if (!Number.isFinite(t)) continue;
+      if (min === void 0 || t < min.t) min = { t, value };
+      if (max === void 0 || t > max.t) max = { t, value };
+    }
+    if (min === void 0) return "";
+    const show = ({ value }) => typeof value === "string" ? clip(value, 30) : new Date(value instanceof Date ? value.getTime() : value).toISOString();
+    return min.t === max.t ? show(min) : `${show(min)} to ${show(max)}`;
+  }
+  const distinct = new Set(values.map((value) => typeof value === "object" ? JSON.stringify(value) : String(value)));
+  return `${distinct.size} ${distinct.size === 1 ? "value" : "values"}`;
+}
+function encodingSummary(encoding, rows) {
+  const parts = [];
+  for (const [channel, def] of Object.entries(encoding)) {
+    if (channel === "tooltip" || def === null || typeof def !== "object" || Array.isArray(def)) continue;
+    if (def.field === void 0 && def.aggregate === void 0) continue;
+    let name = typeof def.field === "string" ? def.field : def.field?.repeat ? `repeat ${def.field.repeat}` : "";
+    if (def.aggregate !== void 0) name = `${def.aggregate}(${name})`;
+    else if (def.timeUnit !== void 0) name = `${typeof def.timeUnit === "string" ? def.timeUnit : "time"}(${name})`;
+    const type = VL_TYPES[def.type] ?? def.type;
+    const details = [];
+    if (typeof type === "string") details.push(type);
+    if (rows && typeof def.field === "string" && def.aggregate === void 0) {
+      const stats = fieldStats(rows, def.field, type);
+      if (stats) details.push(stats);
+    }
+    parts.push(`${channel}=${clip(name, 40)}${details.length ? ` (${details.join(", ")})` : ""}`);
+  }
+  return parts;
+}
+function vlRows(data, datasets) {
+  if (data === null || typeof data !== "object") return void 0;
+  if (Array.isArray(data.values)) return data.values;
+  if (typeof data.name === "string" && Array.isArray(datasets?.[data.name])) return datasets[data.name];
+  return void 0;
+}
+function vlDataNote(data, rows) {
+  if (rows) return `${rows.length} ${rows.length === 1 ? "row" : "rows"}`;
+  if (typeof data?.url === "string") return `data from ${clip(data.url)}`;
+  return "";
+}
+function fieldList(def) {
+  if (Array.isArray(def)) return def.join(", ");
+  if (def === null || typeof def !== "object") return "";
+  if (typeof def.field === "string") return def.field;
+  return Object.values(def).map(fieldList).filter(Boolean).join(", ");
+}
+function summarizeVegaLiteView(spec, label, inherited, datasets, depth, lines) {
+  const indent = "  ".repeat(depth);
+  const data = spec.data ?? inherited.data;
+  const rows = vlRows(data, datasets);
+  const head = `${indent}${label}`;
+  const title = titleText(spec.title);
+  const children = spec.layer ?? spec.concat ?? spec.hconcat ?? spec.vconcat;
+  if (Array.isArray(children)) {
+    const noun = spec.layer ? "layer" : "view";
+    const note = [`${children.length} ${children.length === 1 ? noun : `${noun}s`}`, vlDataNote(data, rows)].filter(Boolean);
+    lines.push(`${head}${spec.layer ? "layered" : "concatenated"} chart${title}: ${note.join(", ")}`);
+    const encoding2 = spec.layer ? { ...inherited.encoding, ...spec.encoding } : {};
+    children.slice(0, MAX_CHILDREN).forEach((child, i) => {
+      if (child !== null && typeof child === "object") {
+        summarizeVegaLiteView(child, `${noun} ${i + 1}: `, { data, encoding: encoding2 }, datasets, depth + 1, lines);
+      }
+    });
+    if (children.length > MAX_CHILDREN) lines.push(`${indent}  \u2026 ${children.length - MAX_CHILDREN} more`);
+    return;
+  }
+  if ((spec.facet !== void 0 || spec.repeat !== void 0) && spec.spec !== null && typeof spec.spec === "object") {
+    const what = spec.facet !== void 0 ? `faceted by ${fieldList(spec.facet)}` : `repeated over ${fieldList(spec.repeat)}`;
+    const note = vlDataNote(data, rows);
+    lines.push(`${head}chart${title} ${what}${note ? `, ${note}` : ""}`);
+    summarizeVegaLiteView(spec.spec, "each panel: ", { data, encoding: {} }, datasets, depth + 1, lines);
+    return;
+  }
+  const mark = typeof spec.mark === "string" ? spec.mark : spec.mark?.type;
+  const encoding = { ...inherited.encoding, ...spec.encoding };
+  const parts = encodingSummary(encoding, rows);
+  if (spec.data !== void 0 || depth === 0) {
+    const note = vlDataNote(data, rows);
+    if (note) parts.push(note);
+  }
+  lines.push(`${head}${typeof mark === "string" ? `${mark} ` : ""}chart${title}${parts.length ? `: ${parts.join(", ")}` : ""}`);
+}
+function vegaMarkTypes(marks, types) {
+  if (!Array.isArray(marks)) return types;
+  for (const mark of marks) {
+    if (typeof mark?.type === "string") types.add(mark.type);
+    vegaMarkTypes(mark?.marks, types);
+  }
+  return types;
+}
+function summarizeVega(spec) {
+  const sections = [];
+  const marks = [...vegaMarkTypes(spec.marks, /* @__PURE__ */ new Set())];
+  if (marks.length) sections.push(`marks ${marks.join(", ")}`);
+  const list2 = (items, describe) => {
+    const shown = items.slice(0, MAX_CHILDREN).map(describe);
+    if (items.length > MAX_CHILDREN) shown.push(`\u2026 ${items.length - MAX_CHILDREN} more`);
+    return shown.join(", ");
+  };
+  const data = Array.isArray(spec.data) ? spec.data.filter((d) => d !== null && typeof d === "object") : [];
+  if (data.length) {
+    sections.push(`data ${list2(data, (d) => {
+      const name = clip(String(d.name ?? "?"), 30);
+      if (Array.isArray(d.values)) return `${name} (${d.values.length} ${d.values.length === 1 ? "row" : "rows"})`;
+      if (typeof d.url === "string") return `${name} (from ${clip(d.url)})`;
+      if (d.source !== void 0) return `${name} (from ${clip(String(d.source), 30)})`;
+      return name;
+    })}`);
+  }
+  const scales = Array.isArray(spec.scales) ? spec.scales.filter((s) => s !== null && typeof s === "object") : [];
+  if (scales.length) {
+    sections.push(`scales ${list2(scales, (s) => `${clip(String(s.name ?? "?"), 30)} (${s.type ?? "linear"})`)}`);
+  }
+  return `Vega chart${titleText(spec.title)}${sections.length ? `: ${sections.join("; ")}` : ""}`;
+}
+function summarizeChart(spec) {
+  try {
+    if (typeof spec.$schema === "string" && spec.$schema.includes("/vega-lite/")) {
+      const lines = [];
+      summarizeVegaLiteView(spec, "Vega-Lite ", { encoding: {} }, spec.datasets, 0, lines);
+      return lines.join("\n");
+    }
+    return summarizeVega(spec);
+  } catch {
+    return void 0;
+  }
+}
+function isDataFrameLike(obj) {
+  return obj !== null && typeof obj === "object" && obj.schema !== void 0 && typeof obj.schema === "object" && typeof obj.head === "function" && typeof obj.toRecords === "function";
+}
+function mapPolarsTypeToJSONSchema(colType) {
+  const typeMapping = {
+    Null: "null",
+    Bool: "boolean",
+    Int8: "integer",
+    Int16: "integer",
+    Int32: "integer",
+    Int64: "integer",
+    UInt8: "integer",
+    UInt16: "integer",
+    UInt32: "integer",
+    UInt64: "integer",
+    Float32: "number",
+    Float64: "number",
+    Date: "string",
+    Datetime: "string",
+    Utf8: "string",
+    Categorical: "string",
+    List: "array",
+    Struct: "object"
+  };
+  const dataType = typeof colType?.toJSON === "function" ? colType.toJSON()["DataType"] : void 0;
+  return typeMapping[dataType] || "string";
+}
+function extractDataFrame(df) {
+  const fields = [];
+  for (const [name, colType] of Object.entries(df.schema)) {
+    fields.push({ name, type: mapPolarsTypeToJSONSchema(colType) });
+  }
+  const data = df.head(50).toRecords();
+  let html = "<table><thead><tr>";
+  for (const field of fields) html += `<th>${escapeHTML(String(field.name))}</th>`;
+  html += "</tr></thead><tbody>";
+  for (const row of df.head(10).toRecords()) {
+    html += "<tr>";
+    for (const field of fields) html += `<td>${escapeHTML(String(row[field.name]))}</td>`;
+    html += "</tr>";
+  }
+  html += "</tbody></table>";
+  const size = [];
+  if (Number.isInteger(df.height)) size.push(`${df.height} ${df.height === 1 ? "row" : "rows"}`);
+  size.push(`${fields.length} ${fields.length === 1 ? "column" : "columns"}`);
+  const columns = fields.slice(0, 20).map((field) => `${clip(String(field.name), 40)} (${field.type})`);
+  if (fields.length > 20) columns.push(`\u2026 ${fields.length - 20} more`);
+  return {
+    "application/vnd.dataresource+json": { data, schema: { fields } },
+    "text/html": html,
+    "text/plain": `DataFrame (${size.join(", ")})${columns.length ? `: ${columns.join(", ")}` : ""}`
+  };
+}
+function isCanvasLike(obj) {
+  return obj !== null && typeof obj === "object" && "toDataURL" in obj;
+}
+function isJpg(obj) {
+  return obj instanceof Uint8Array && obj.length >= 4 && obj[0] === 255 && obj[1] === 216 && obj[obj.length - 2] === 255 && obj[obj.length - 1] === 217;
+}
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function isPng(obj) {
+  return obj instanceof Uint8Array && obj.length >= PNG_SIGNATURE.length && PNG_SIGNATURE.every((byte, i) => obj[i] === byte);
+}
+function isSVGElementLike(obj) {
+  return obj !== null && typeof obj === "object" && typeof obj.outerHTML === "string" && obj.outerHTML.startsWith("<svg");
+}
+function isHTMLElementLike(obj) {
+  return obj !== null && typeof obj === "object" && typeof obj.outerHTML === "string";
+}
+function hasDisplaySymbol(obj) {
+  return obj !== null && typeof obj === "object" && typeof obj[$display] === "function";
+}
+function isMediaBundle(obj) {
+  return obj !== null && typeof obj === "object" && !Array.isArray(obj);
+}
+function createJupyter(host2) {
+  async function format2(obj) {
+    return await formatNow(obj);
+  }
+  function formatNow(obj) {
+    if (hasDisplaySymbol(obj)) return obj[$display]();
+    if (typeof obj !== "object" || obj === null) return { "text/plain": host2.inspect(obj) };
+    if (isCanvasLike(obj)) {
+      const [prefix, data] = obj.toDataURL().split(",");
+      return { [prefix.split(":")[1].split(";")[0]]: data };
+    }
+    if (isVegaLike(obj)) {
+      const vega = extractVega(obj);
+      if (vega) return vega;
+    }
+    if (isDataFrameLike(obj)) return extractDataFrame(obj);
+    if (isJpg(obj)) return { "image/jpeg": host2.base64(obj) };
+    if (isPng(obj)) return { "image/png": host2.base64(obj) };
+    if (isSVGElementLike(obj)) return { "image/svg+xml": obj.outerHTML };
+    if (isHTMLElementLike(obj)) return { "text/html": obj.outerHTML };
+    return { "text/plain": host2.inspect(obj) };
+  }
+  function taggedTemplate(mediatype) {
+    return (strings, ...values) => {
+      const payload = strings.reduce((acc, string, i) => acc + string + (values[i] !== void 0 ? values[i] : ""), "");
+      return { [$display]: () => ({ [mediatype]: payload }) };
+    };
+  }
+  function image(obj) {
+    if (typeof obj === "string") {
+      try {
+        obj = host2.readFile(obj);
+      } catch {
+      }
+    }
+    if (isJpg(obj)) return { [$display]: () => ({ "image/jpeg": host2.base64(obj) }) };
+    if (isPng(obj)) return { [$display]: () => ({ "image/png": host2.base64(obj) }) };
+    throw new TypeError(
+      "Object is not a valid image or a path to an image. `jupyter.image` supports displaying JPG or PNG images."
+    );
+  }
+  function broadcast(msgType, content, { metadata = {}, buffers = [] } = {}) {
+    host2.send(msgType, content, metadata, buffers);
+  }
+  async function display(obj, options = { raw: false, update: false }) {
+    const bundle = options.raw && isMediaBundle(obj) ? obj : await format2(obj);
+    broadcast(options.update ? "update_display_data" : "display_data", {
+      data: bundle,
+      metadata: {},
+      transient: options.display_id ? { display_id: options.display_id } : {}
+    });
+  }
+  async function broadcastResult(executionCount, result) {
+    if (result === void 0) return;
+    try {
+      broadcast("execute_result", {
+        execution_count: executionCount,
+        data: await format2(result),
+        metadata: {},
+        // nbclient crashes on a null `transient`; Deno learned this too.
+        transient: {}
+      });
+    } catch (err) {
+      broadcast("error", {
+        ename: err instanceof Error ? err.name : "Error",
+        evalue: err instanceof Error ? err.message : String(err),
+        traceback: err instanceof Error && err.stack ? err.stack.split("\n") : []
+      });
+    }
+  }
+  function confirm(message = "Confirm") {
+    const answer2 = host2.input(`${message} [y/N] `, false);
+    return answer2 === "Y" || answer2 === "y";
+  }
+  function prompt(message = "Prompt", defaultValue = "", { password = false } = {}) {
+    if (defaultValue != "") message += ` [${defaultValue}]`;
+    const answer2 = host2.input(message, password);
+    return answer2 === "" ? defaultValue : answer2;
+  }
+  const comms = createComms((msgType, content, metadata, buffers) => host2.send(msgType, content, metadata, buffers));
+  return {
+    namespace: {
+      broadcast,
+      display,
+      format: format2,
+      md: taggedTemplate("text/markdown"),
+      html: taggedTemplate("text/html"),
+      svg: taggedTemplate("image/svg+xml"),
+      image,
+      $display,
+      comm: comms.api,
+      widget: createWidgetFactory(comms.api, $display)
+    },
+    broadcastResult,
+    formatNow,
+    confirm,
+    prompt,
+    commDispatch: comms.dispatch
+  };
+}
+
+// runtime/evaluator.mjs
+function propertyNames(value) {
+  if (value === null || value === void 0) return [];
+  const names = /* @__PURE__ */ new Set();
+  for (let o = Object(value); o !== null; o = Object.getPrototypeOf(o)) {
+    for (const name of Object.getOwnPropertyNames(o)) names.add(name);
+  }
+  return [...names];
+}
+function createHandler(shim, evaluate = (code) => (0, eval)(code)) {
+  const handles = /* @__PURE__ */ new Map();
+  let nextHandle = 0;
+  const remote = (value) => {
+    const objectId = `h${++nextHandle}`;
+    handles.set(objectId, value);
+    return { type: value === null ? "object" : typeof value, objectId };
+  };
+  const take = (objectId) => {
+    const value = handles.get(objectId);
+    handles.delete(objectId);
+    return value;
+  };
+  return async function handle2(request) {
+    switch (request.op) {
+      case "ping":
+        return {};
+      case "eval": {
+        handles.clear();
+        try {
+          const box = await evaluate(request.code);
+          return { result: box === void 0 ? { type: "undefined" } : remote(box[0]) };
+        } catch (err) {
+          return {
+            exceptionDetails: { text: "Uncaught", lineNumber: 0, columnNumber: 0, exception: remote(err) }
+          };
+        }
+      }
+      case "broadcast":
+        await shim.broadcastResult(request.count, take(request.handle));
+        return {};
+      case "format":
+        return { value: await shim.formatJson(request.handle === void 0 ? void 0 : take(request.handle)) };
+      case "describe":
+        return { value: shim.describeError(take(request.handle)) };
+      case "comm":
+        try {
+          const handled = await shim.commDispatch(request.msgType, request.content, request.metadata, request.buffers);
+          return { handled: handled === true };
+        } catch (err) {
+          return { error: JSON.parse(shim.describeError(err)) };
+        }
+      case "props": {
+        if (typeof shim.resolvePath === "function") {
+          const resolved = shim.resolvePath(request.expr);
+          return { names: resolved.found && !resolved.accessor ? propertyNames(resolved.value) : [] };
+        }
+        let value;
+        try {
+          value = evaluate(`(${request.expr})`);
+        } catch {
+          return { names: [] };
+        }
+        return { names: propertyNames(value) };
+      }
+      case "inspect":
+        return { text: shim.inspectPath(request.path, request.detail ?? 0) };
+      case "barrier":
+        return { value: shim.barrier() };
+      default:
+        throw new Error(`unknown request ${JSON.stringify(request.op)}`);
+    }
+  };
+}
+
+// runtime/format.mjs
+var MAX_ITEMS = 100;
+function quote(s) {
+  const q = !s.includes("'") ? "'" : !s.includes('"') ? '"' : !s.includes("`") && !s.includes("${") ? "`" : "'";
+  const escaped = s.replaceAll("\\", "\\\\").replaceAll("\n", "\\n").replaceAll(q, `\\${q}`);
+  return `${q}${escaped}${q}`;
+}
+function key(k) {
+  return typeof k === "symbol" ? `[${k.toString()}]` : /^[A-Za-z_$][\w$]*$/.test(k) ? k : quote(k);
+}
+function className(value) {
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) return "[Object: null prototype]";
+  const name = proto.constructor?.name;
+  return name && name !== "Object" ? name : "";
+}
+function list(open, items, close, more) {
+  if (more > 0) items.push(`... ${more} more item${more === 1 ? "" : "s"}`);
+  return items.length === 0 ? `${open}${close}` : `${open} ${items.join(", ")} ${close}`;
+}
+function inspect(value, { depth = 2 } = {}) {
+  const seen = [];
+  const show = (v, level) => {
+    switch (typeof v) {
+      case "string":
+        return quote(v);
+      case "bigint":
+        return `${v}n`;
+      case "symbol":
+        return v.toString();
+      case "undefined":
+        return "undefined";
+      case "function": {
+        const isClass = /^class\b/.test(Function.prototype.toString.call(v));
+        return isClass ? `[class ${v.name || "(anonymous)"}]` : `[Function${v.name ? `: ${v.name}` : " (anonymous)"}]`;
+      }
+      case "number":
+        return Object.is(v, -0) ? "-0" : String(v);
+      case "boolean":
+        return String(v);
+    }
+    if (v === null) return "null";
+    if (seen.includes(v)) return "[Circular *1]";
+    if (v instanceof Date) return Number.isNaN(v.getTime()) ? "Invalid Date" : v.toISOString();
+    if (v instanceof RegExp) return String(v);
+    if (v instanceof Error) return v.stack ?? `${v.name}: ${v.message}`;
+    if (v instanceof Promise) return "Promise { <unknown> }";
+    if (level > depth) return Array.isArray(v) ? "[Array]" : `[${className(v) || "Object"}]`;
+    seen.push(v);
+    try {
+      if (Array.isArray(v) || ArrayBuffer.isView(v)) {
+        const items2 = Array.from(v).slice(0, MAX_ITEMS).map((x) => show(x, level + 1));
+        const prefix = Array.isArray(v) ? "" : `${v.constructor.name}(${v.length}) `;
+        return prefix + list("[", items2, "]", v.length - items2.length);
+      }
+      if (v instanceof Map) {
+        const items2 = [...v].slice(0, MAX_ITEMS).map(([k, x]) => `${show(k, level + 1)} => ${show(x, level + 1)}`);
+        return `Map(${v.size}) ` + list("{", items2, "}", v.size - items2.length);
+      }
+      if (v instanceof Set) {
+        const items2 = [...v].slice(0, MAX_ITEMS).map((x) => show(x, level + 1));
+        return `Set(${v.size}) ` + list("{", items2, "}", v.size - items2.length);
+      }
+      const keys = Reflect.ownKeys(v).filter((k) => Object.getOwnPropertyDescriptor(v, k)?.enumerable);
+      const items = keys.slice(0, MAX_ITEMS).map((k) => {
+        const d = Object.getOwnPropertyDescriptor(v, k);
+        const shown = d.get || d.set ? `[${d.get ? "Getter" : ""}${d.get && d.set ? "/" : ""}${d.set ? "Setter" : ""}]` : show(d.value, level + 1);
+        return `${key(k)}: ${shown}`;
+      });
+      const name = className(v);
+      return (name ? `${name} ` : "") + list("{", items, "}", keys.length - items.length);
+    } finally {
+      seen.pop();
+    }
+  };
+  return show(value, 0);
+}
+function format(...args) {
+  let out = [];
+  let rest = args;
+  if (typeof args[0] === "string" && args.length > 1 && args[0].includes("%")) {
+    let i = 1;
+    const text = args[0].replace(/%[sdifoOjc%]/g, (spec) => {
+      if (spec === "%%") return "%";
+      if (i >= args.length) return spec;
+      const a = args[i++];
+      switch (spec) {
+        case "%s":
+          return typeof a === "string" ? a : inspect(a, { depth: 1 });
+        case "%d":
+        case "%i":
+          return typeof a === "bigint" ? `${a}n` : String(spec === "%i" ? Math.trunc(Number(a)) : Number(a));
+        case "%f":
+          return String(Number(a));
+        case "%j":
+          return JSON.stringify(a);
+        case "%c":
+          return "";
+        default:
+          return inspect(a, { depth: 4 });
+      }
+    });
+    out = [text];
+    rest = args.slice(i);
+  }
+  for (const a of rest) out.push(typeof a === "string" ? a : inspect(a));
+  return out.join(" ");
+}
+
+// runtime/introspect.mjs
+var PREVIEW_CHARS = 1500;
+var SOURCE_CHARS = 4e3;
+var MAX_PROPERTIES = 40;
+var IDENTIFIER_PATH = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/;
+function resolvePath(path, root = globalThis) {
+  if (!IDENTIFIER_PATH.test(path)) return { found: false };
+  let value = root;
+  for (const name of path.split(".")) {
+    if (value === null || value === void 0) return { found: false };
+    let descriptor;
+    for (let o = Object(value); o !== null && descriptor === void 0; o = Object.getPrototypeOf(o)) {
+      descriptor = Object.getOwnPropertyDescriptor(o, name);
+    }
+    if (descriptor === void 0) return { found: false };
+    if (!("value" in descriptor)) return { found: true, accessor: true, name };
+    value = descriptor.value;
+  }
+  return { found: true, value };
+}
+function truncate(text, limit) {
+  return text.length > limit ? `${text.slice(0, limit)}\u2026 (${text.length - limit} more characters)` : text;
+}
+function signatureOf(fn) {
+  let source;
+  try {
+    source = Function.prototype.toString.call(fn);
+  } catch {
+    return `${fn.name || "anonymous"}(\u2026)`;
+  }
+  if (/^class\b/.test(source)) return `class ${fn.name || "(anonymous)"}`;
+  const params = /^[^(]*\(([^)]*)\)/.exec(source)?.[1];
+  const native = /\{\s*\[native code\]\s*\}$/.test(source);
+  const written = (params ?? "").replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim();
+  const args = native ? Array.from({ length: fn.length }, (_, i) => `arg${i}`).join(", ") : written;
+  const arrow = !/^(?:async\s+)?function\b/.test(source) && /=>/.test(source.split("{")[0] ?? "");
+  const name = fn.name || (arrow ? "(arrow function)" : "anonymous");
+  const prefix = /^async\b/.test(source) ? "async " : "";
+  return `${prefix}${name}(${args})`;
+}
+function typeOf(value) {
+  if (value === null) return "null";
+  if (typeof value !== "object" && typeof value !== "function") return typeof value;
+  const name = Object.getPrototypeOf(value)?.constructor?.name;
+  if (typeof value === "function") return /^class\b/.test(safeSource(value)) ? "class" : "function";
+  return name && name !== "Object" ? `object (${name})` : "object";
+}
+function safeSource(fn) {
+  try {
+    return Function.prototype.toString.call(fn);
+  } catch {
+    return "";
+  }
+}
+function propertyNames2(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) return [];
+  try {
+    const internal = ["length", "name", "prototype", "arguments", "caller"];
+    return Object.getOwnPropertyNames(value).filter((n) => !(typeof value === "function" && internal.includes(n)));
+  } catch {
+    return [];
+  }
+}
+function describeValue(value, { inspect: inspect2, detail = 0 }) {
+  const lines = [`Type: ${typeOf(value)}`];
+  if (typeof value === "function") lines.push(`Signature: ${signatureOf(value)}`);
+  let preview;
+  try {
+    preview = inspect2(value);
+  } catch (err) {
+    preview = `(inspect failed: ${err instanceof Error ? err.message : String(err)})`;
+  }
+  lines.push(`Value: ${truncate(preview, PREVIEW_CHARS)}`);
+  const names = propertyNames2(value);
+  if (names.length > 0) {
+    const shown = names.slice(0, MAX_PROPERTIES).join(", ");
+    lines.push(`Properties: ${shown}${names.length > MAX_PROPERTIES ? `, \u2026 (${names.length - MAX_PROPERTIES} more)` : ""}`);
+  }
+  if (detail > 0 && typeof value === "function") lines.push(`Source:
+${truncate(safeSource(value), SOURCE_CHARS)}`);
+  return lines.join("\n");
+}
+function inspectPath(path, { inspect: inspect2, detail = 0, root = globalThis }) {
+  const resolved = resolvePath(path, root);
+  if (!resolved.found) return null;
+  if (resolved.accessor) {
+    return `Type: accessor property
+${resolved.name} has a getter, which isn't called for inspection: it could have side effects.`;
+  }
+  return describeValue(resolved.value, { inspect: inspect2, detail });
+}
+
+// runtime/cdn.mjs
+var DEFAULT_CDN = "https://esm.sh/";
+function resolveSpecifier(specifier, base, cdn2 = DEFAULT_CDN) {
+  if (/^(?:https?|data|blob):/.test(specifier)) return specifier;
+  if (/^\.{0,2}\//.test(specifier)) return new URL(specifier, base).href;
+  if (specifier.startsWith("npm:")) return cdn2 + specifier.slice(4);
+  if (specifier.startsWith("jsr:")) return `${cdn2}jsr/${specifier.slice(4).replace(/^\//, "")}`;
+  return cdn2 + specifier;
+}
+
+// runtime/browser-worker.mjs
+function base64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary);
+}
+var post = (message) => globalThis.postMessage(message);
+var stream = (name) => (...args) => post({ kind: "stream", name, text: format(...args) + "\n" });
+Object.assign(console, {
+  log: stream("stdout"),
+  info: stream("stdout"),
+  debug: stream("stdout"),
+  dir: (value) => post({ kind: "stream", name: "stdout", text: inspect(value, { depth: 4 }) + "\n" }),
+  warn: stream("stderr"),
+  error: stream("stderr")
+});
+function reportUncaught(kind, err) {
+  post({ kind: "stream", name: "stderr", text: `${kind}: ${err instanceof Error ? err.stack ?? err.message : inspect(err)}
+` });
+}
+globalThis.addEventListener("unhandledrejection", (event) => {
+  event.preventDefault();
+  reportUncaught("Uncaught (in promise)", event.reason);
+});
+globalThis.addEventListener("error", (event) => {
+  event.preventDefault();
+  reportUncaught("Uncaught", event.error ?? event.message);
+});
+var jupyter = createJupyter({
+  inspect: (value) => inspect(value, { depth: 4 }),
+  base64,
+  readFile() {
+    throw new Error("the browser target has no file system to read from; pass the image bytes instead");
+  },
+  send(msgType, content, metadata, buffers) {
+    post({ kind: "iopub", msg_type: msgType, content, metadata, buffers: buffers.map(base64), barrier: 0 });
+  },
+  // A synchronous prompt would need SharedArrayBuffer and Atomics.wait, so
+  // a cross-origin isolated page; until then, as with no stdin.
+  input: () => null
+});
+var cdn = DEFAULT_CDN;
+var hostCalls = /* @__PURE__ */ new Map();
+var hostListeners = /* @__PURE__ */ new Set();
+var nextHostId = 0;
+function hostError(error) {
+  const err = new Error(String(error?.message ?? "the host request failed"));
+  if (typeof error?.name === "string") err.name = error.name;
+  if (error?.code !== void 0) err.code = error.code;
+  return err;
+}
+var host = {
+  /** Resolves with the page's answer; aborting `signal` cancels the call on the page too. */
+  request(method, params, { signal, transfer } = {}) {
+    if (signal?.aborted) return Promise.reject(signal.reason);
+    const id = ++nextHostId;
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        hostCalls.delete(id);
+        post({ kind: "host", id, cancel: true });
+        reject(signal.reason);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      const done = () => signal?.removeEventListener("abort", onAbort);
+      try {
+        globalThis.postMessage({ kind: "host", id, method, params }, transfer ?? []);
+      } catch (err) {
+        done();
+        throw err;
+      }
+      hostCalls.set(id, { resolve, reject, done });
+    });
+  },
+  /** Calls `listener(event, value)` for each event the page sends; returns a function that stops it. */
+  onEvent(listener) {
+    hostListeners.add(listener);
+    return () => hostListeners.delete(listener);
+  }
+};
+function receiveHost(msg) {
+  if (msg.id === void 0) {
+    for (const listener of hostListeners) {
+      try {
+        listener(msg.event, msg.value);
+      } catch (err) {
+        reportUncaught("Uncaught", err);
+      }
+    }
+    return;
+  }
+  const call = hostCalls.get(msg.id);
+  if (!call) return;
+  hostCalls.delete(msg.id);
+  call.done();
+  if (msg.error !== void 0) call.reject(hostError(msg.error));
+  else call.resolve(msg.result);
+}
+async function preload(urls, base) {
+  for (const specifier of Array.isArray(urls) ? urls : []) {
+    try {
+      const mod = await import(new URL(specifier, base).href);
+      if (typeof mod.default === "function") await mod.default({ host, jupyter: jupyter.namespace });
+    } catch (err) {
+      reportUncaught(`Preloading ${specifier} failed`, err);
+    }
+  }
+}
+var handle = null;
+function install({ base, cdn: cdnBase }) {
+  if (typeof cdnBase === "string") cdn = cdnBase.endsWith("/") ? cdnBase : cdnBase + "/";
+  const url = new URL("$cdpk$repl.mjs", base).href;
+  globalThis.__cdpk = {
+    import: (specifier, options) => import(resolveSpecifier(specifier, url, cdn)),
+    meta: { url, resolve: (specifier) => resolveSpecifier(specifier, url, cdn) },
+    // inspect_request (#10): by descriptor, so nothing runs.
+    describeForInspect: (value, detail) => describeValue(value, { inspect: (v) => inspect(v, { depth: 2 }), detail }),
+    inspectPath: (path, detail) => inspectPath(path, { inspect: (v) => inspect(v, { depth: 2 }), detail }),
+    resolvePath,
+    barrier: () => 0,
+    broadcastResult: jupyter.broadcastResult,
+    // execute_request's user_expressions (#340).
+    formatJson: async (value) => JSON.stringify(await jupyter.namespace.format(value)),
+    async commDispatch(msgType, content, metadata, buffers64) {
+      const buffers = buffers64.map((b) => Uint8Array.from(atob(b), (c) => c.charCodeAt(0)));
+      return await jupyter.commDispatch(msgType, content, metadata, buffers);
+    },
+    describeError(value) {
+      if (value instanceof Error) {
+        return JSON.stringify({ name: value.name, message: value.message, stack: value.stack ?? "" });
+      }
+      return JSON.stringify({ name: "Error", message: inspect(value), stack: "" });
+    }
+  };
+  Object.defineProperty(globalThis, "__cdpk", { enumerable: false });
+  globalThis.jupyter = jupyter.namespace;
+  globalThis.prompt = jupyter.prompt;
+  globalThis.confirm = jupyter.confirm;
+  handle = createHandler(globalThis.__cdpk, (code) => (0, eval)(code));
+}
+async function answer(req) {
+  if (req.op === "info") {
+    install(req);
+    await preload(req.preload, req.base);
+    return { userAgent: globalThis.navigator?.userAgent ?? "" };
+  }
+  if (handle === null) throw new Error("the driver wasn't sent info first");
+  return await handle(req);
+}
+globalThis.addEventListener("message", (event) => {
+  const req = event.data;
+  if (req?.op === "host") return receiveHost(req);
+  answer(req).then(
+    (reply) => post({ kind: "reply", id: req.id, ...reply }),
+    (err) => post({ kind: "reply", id: req.id, failure: String(err?.stack ?? err) })
+  );
+});
+//# sourceMappingURL=worker.js.map