@hpcc-js/observablehq-compiler 3.4.0 → 3.5.1

package/dist/runtime.js

@@ -0,0 +1,2501 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var _a;
+const _RuntimeError = class _RuntimeError extends Error {
+  constructor(message, input2) {
+    super(message);
+    this.input = input2;
+  }
+};
+__name(_RuntimeError, "RuntimeError");
+let RuntimeError = _RuntimeError;
+RuntimeError.prototype.name = "RuntimeError";
+function generatorish(value) {
+  return value && typeof value.next === "function" && typeof value.return === "function";
+}
+__name(generatorish, "generatorish");
+function constant(x) {
+  return () => x;
+}
+__name(constant, "constant");
+function identity(x) {
+  return x;
+}
+__name(identity, "identity");
+function rethrow(error) {
+  return () => {
+    throw error;
+  };
+}
+__name(rethrow, "rethrow");
+const prototype = Array.prototype;
+const map = prototype.map;
+function noop() {
+}
+__name(noop, "noop");
+const TYPE_NORMAL = 1;
+const TYPE_IMPLICIT = 2;
+const TYPE_DUPLICATE = 3;
+const no_observer = Symbol("no-observer");
+const no_value = Promise.resolve();
+function Variable(type, module, observer, options) {
+  if (!observer) observer = no_observer;
+  Object.defineProperties(this, {
+    _observer: { value: observer, writable: true },
+    _definition: { value: variable_undefined, writable: true },
+    _duplicate: { value: void 0, writable: true },
+    _duplicates: { value: void 0, writable: true },
+    _indegree: { value: NaN, writable: true },
+    // The number of computing inputs.
+    _inputs: { value: [], writable: true },
+    _invalidate: { value: noop, writable: true },
+    _module: { value: module },
+    _name: { value: null, writable: true },
+    _outputs: { value: /* @__PURE__ */ new Set(), writable: true },
+    _promise: { value: no_value, writable: true },
+    _reachable: { value: observer !== no_observer, writable: true },
+    // Is this variable transitively visible?
+    _rejector: { value: variable_rejector(this) },
+    _shadow: { value: initShadow(module, options) },
+    _type: { value: type },
+    _value: { value: void 0, writable: true },
+    _version: { value: 0, writable: true }
+  });
+}
+__name(Variable, "Variable");
+Object.defineProperties(Variable.prototype, {
+  _pending: { value: variable_pending, writable: true, configurable: true },
+  _fulfilled: { value: variable_fulfilled, writable: true, configurable: true },
+  _rejected: { value: variable_rejected, writable: true, configurable: true },
+  _resolve: { value: variable_resolve, writable: true, configurable: true },
+  define: { value: variable_define, writable: true, configurable: true },
+  delete: { value: variable_delete, writable: true, configurable: true },
+  import: { value: variable_import, writable: true, configurable: true }
+});
+function initShadow(module, options) {
+  if (!options?.shadow) return null;
+  return new Map(
+    Object.entries(options.shadow).map(([name, definition]) => [name, new Variable(TYPE_IMPLICIT, module).define([], definition)])
+  );
+}
+__name(initShadow, "initShadow");
+function variable_attach(variable) {
+  variable._module._runtime._dirty.add(variable);
+  variable._outputs.add(this);
+}
+__name(variable_attach, "variable_attach");
+function variable_detach(variable) {
+  variable._module._runtime._dirty.add(variable);
+  variable._outputs.delete(this);
+}
+__name(variable_detach, "variable_detach");
+function variable_undefined() {
+  throw variable_undefined;
+}
+__name(variable_undefined, "variable_undefined");
+function variable_stale() {
+  throw variable_stale;
+}
+__name(variable_stale, "variable_stale");
+function variable_rejector(variable) {
+  return (error) => {
+    if (error === variable_stale) throw error;
+    if (error === variable_undefined) throw new RuntimeError(`${variable._name} is not defined`, variable._name);
+    if (error instanceof Error && error.message) throw new RuntimeError(error.message, variable._name);
+    throw new RuntimeError(`${variable._name} could not be resolved`, variable._name);
+  };
+}
+__name(variable_rejector, "variable_rejector");
+function variable_duplicate(name) {
+  return () => {
+    throw new RuntimeError(`${name} is defined more than once`);
+  };
+}
+__name(variable_duplicate, "variable_duplicate");
+function variable_define(name, inputs, definition) {
+  switch (arguments.length) {
+    case 1: {
+      definition = name, name = inputs = null;
+      break;
+    }
+    case 2: {
+      definition = inputs;
+      if (typeof name === "string") inputs = null;
+      else inputs = name, name = null;
+      break;
+    }
+  }
+  return variable_defineImpl.call(
+    this,
+    name == null ? null : String(name),
+    inputs == null ? [] : map.call(inputs, this._resolve, this),
+    typeof definition === "function" ? definition : constant(definition)
+  );
+}
+__name(variable_define, "variable_define");
+function variable_resolve(name) {
+  return this._shadow?.get(name) ?? this._module._resolve(name);
+}
+__name(variable_resolve, "variable_resolve");
+function variable_defineImpl(name, inputs, definition) {
+  const scope = this._module._scope, runtime = this._module._runtime;
+  this._inputs.forEach(variable_detach, this);
+  inputs.forEach(variable_attach, this);
+  this._inputs = inputs;
+  this._definition = definition;
+  this._value = void 0;
+  if (definition === noop) runtime._variables.delete(this);
+  else runtime._variables.add(this);
+  if (name !== this._name || scope.get(name) !== this) {
+    let error, found;
+    if (this._name) {
+      if (this._outputs.size) {
+        scope.delete(this._name);
+        found = this._module._resolve(this._name);
+        found._outputs = this._outputs, this._outputs = /* @__PURE__ */ new Set();
+        found._outputs.forEach(function(output) {
+          output._inputs[output._inputs.indexOf(this)] = found;
+        }, this);
+        found._outputs.forEach(runtime._updates.add, runtime._updates);
+        runtime._dirty.add(found).add(this);
+        scope.set(this._name, found);
+      } else if ((found = scope.get(this._name)) === this) {
+        scope.delete(this._name);
+      } else if (found._type === TYPE_DUPLICATE) {
+        found._duplicates.delete(this);
+        this._duplicate = void 0;
+        if (found._duplicates.size === 1) {
+          found = found._duplicates.keys().next().value;
+          error = scope.get(this._name);
+          found._outputs = error._outputs, error._outputs = /* @__PURE__ */ new Set();
+          found._outputs.forEach(function(output) {
+            output._inputs[output._inputs.indexOf(error)] = found;
+          });
+          found._definition = found._duplicate, found._duplicate = void 0;
+          runtime._dirty.add(error).add(found);
+          runtime._updates.add(found);
+          scope.set(this._name, found);
+        }
+      } else {
+        throw new Error();
+      }
+    }
+    if (this._outputs.size) throw new Error();
+    if (name) {
+      if (found = scope.get(name)) {
+        if (found._type === TYPE_DUPLICATE) {
+          this._definition = variable_duplicate(name), this._duplicate = definition;
+          found._duplicates.add(this);
+        } else if (found._type === TYPE_IMPLICIT) {
+          this._outputs = found._outputs, found._outputs = /* @__PURE__ */ new Set();
+          this._outputs.forEach(function(output) {
+            output._inputs[output._inputs.indexOf(found)] = this;
+          }, this);
+          runtime._dirty.add(found).add(this);
+          scope.set(name, this);
+        } else {
+          found._duplicate = found._definition, this._duplicate = definition;
+          error = new Variable(TYPE_DUPLICATE, this._module);
+          error._name = name;
+          error._definition = this._definition = found._definition = variable_duplicate(name);
+          error._outputs = found._outputs, found._outputs = /* @__PURE__ */ new Set();
+          error._outputs.forEach(function(output) {
+            output._inputs[output._inputs.indexOf(found)] = error;
+          });
+          error._duplicates = /* @__PURE__ */ new Set([this, found]);
+          runtime._dirty.add(found).add(error);
+          runtime._updates.add(found).add(error);
+          scope.set(name, error);
+        }
+      } else {
+        scope.set(name, this);
+      }
+    }
+    this._name = name;
+  }
+  if (this._version > 0) ++this._version;
+  runtime._updates.add(this);
+  runtime._compute();
+  return this;
+}
+__name(variable_defineImpl, "variable_defineImpl");
+function variable_import(remote, name, module) {
+  if (arguments.length < 3) module = name, name = remote;
+  return variable_defineImpl.call(this, String(name), [module._resolve(String(remote))], identity);
+}
+__name(variable_import, "variable_import");
+function variable_delete() {
+  return variable_defineImpl.call(this, null, [], noop);
+}
+__name(variable_delete, "variable_delete");
+function variable_pending() {
+  if (this._observer.pending) this._observer.pending();
+}
+__name(variable_pending, "variable_pending");
+function variable_fulfilled(value) {
+  if (this._observer.fulfilled) this._observer.fulfilled(value, this._name);
+}
+__name(variable_fulfilled, "variable_fulfilled");
+function variable_rejected(error) {
+  if (this._observer.rejected) this._observer.rejected(error, this._name);
+}
+__name(variable_rejected, "variable_rejected");
+const variable_variable = Symbol("variable");
+const variable_invalidation = Symbol("invalidation");
+const variable_visibility = Symbol("visibility");
+function Module(runtime, builtins = []) {
+  Object.defineProperties(this, {
+    _runtime: { value: runtime },
+    _scope: { value: /* @__PURE__ */ new Map() },
+    _builtins: { value: new Map([
+      ["@variable", variable_variable],
+      ["invalidation", variable_invalidation],
+      ["visibility", variable_visibility],
+      ...builtins
+    ]) },
+    _source: { value: null, writable: true }
+  });
+}
+__name(Module, "Module");
+Object.defineProperties(Module.prototype, {
+  _resolve: { value: module_resolve, writable: true, configurable: true },
+  redefine: { value: module_redefine, writable: true, configurable: true },
+  define: { value: module_define, writable: true, configurable: true },
+  derive: { value: module_derive, writable: true, configurable: true },
+  import: { value: module_import, writable: true, configurable: true },
+  value: { value: module_value, writable: true, configurable: true },
+  variable: { value: module_variable, writable: true, configurable: true },
+  builtin: { value: module_builtin, writable: true, configurable: true }
+});
+function module_redefine(name) {
+  const v = this._scope.get(name);
+  if (!v) throw new RuntimeError(`${name} is not defined`);
+  if (v._type === TYPE_DUPLICATE) throw new RuntimeError(`${name} is defined more than once`);
+  return v.define.apply(v, arguments);
+}
+__name(module_redefine, "module_redefine");
+function module_define() {
+  const v = new Variable(TYPE_NORMAL, this);
+  return v.define.apply(v, arguments);
+}
+__name(module_define, "module_define");
+function module_import() {
+  const v = new Variable(TYPE_NORMAL, this);
+  return v.import.apply(v, arguments);
+}
+__name(module_import, "module_import");
+function module_variable(observer, options) {
+  return new Variable(TYPE_NORMAL, this, observer, options);
+}
+__name(module_variable, "module_variable");
+async function module_value(name) {
+  let v = this._scope.get(name);
+  if (!v) throw new RuntimeError(`${name} is not defined`);
+  if (v._observer === no_observer) {
+    v = this.variable(true).define([name], identity);
+    try {
+      return await module_revalue(this._runtime, v);
+    } finally {
+      v.delete();
+    }
+  } else {
+    return module_revalue(this._runtime, v);
+  }
+}
+__name(module_value, "module_value");
+async function module_revalue(runtime, variable) {
+  await runtime._compute();
+  try {
+    return await variable._promise;
+  } catch (error) {
+    if (error === variable_stale) return module_revalue(runtime, variable);
+    throw error;
+  }
+}
+__name(module_revalue, "module_revalue");
+function module_derive(injects, injectModule) {
+  const map2 = /* @__PURE__ */ new Map();
+  const modules = /* @__PURE__ */ new Set();
+  const copies = [];
+  function alias(source) {
+    let target = map2.get(source);
+    if (target) return target;
+    target = new Module(source._runtime, source._builtins);
+    target._source = source;
+    map2.set(source, target);
+    copies.push([target, source]);
+    modules.add(source);
+    return target;
+  }
+  __name(alias, "alias");
+  const derive = alias(this);
+  for (const inject of injects) {
+    const { alias: alias2, name } = typeof inject === "object" ? inject : { name: inject };
+    derive.import(name, alias2 == null ? name : alias2, injectModule);
+  }
+  for (const module of modules) {
+    for (const [name, variable] of module._scope) {
+      if (variable._definition === identity) {
+        if (module === this && derive._scope.has(name)) continue;
+        const importedModule = variable._inputs[0]._module;
+        if (importedModule._source) alias(importedModule);
+      }
+    }
+  }
+  for (const [target, source] of copies) {
+    for (const [name, sourceVariable] of source._scope) {
+      const targetVariable = target._scope.get(name);
+      if (targetVariable && targetVariable._type !== TYPE_IMPLICIT) continue;
+      if (sourceVariable._definition === identity) {
+        const sourceInput = sourceVariable._inputs[0];
+        const sourceModule = sourceInput._module;
+        target.import(sourceInput._name, name, map2.get(sourceModule) || sourceModule);
+      } else {
+        target.define(name, sourceVariable._inputs.map(variable_name), sourceVariable._definition);
+      }
+    }
+  }
+  return derive;
+}
+__name(module_derive, "module_derive");
+function module_resolve(name) {
+  let variable = this._scope.get(name), value;
+  if (!variable) {
+    variable = new Variable(TYPE_IMPLICIT, this);
+    if (this._builtins.has(name)) {
+      variable.define(name, constant(this._builtins.get(name)));
+    } else if (this._runtime._builtin._scope.has(name)) {
+      variable.import(name, this._runtime._builtin);
+    } else {
+      try {
+        value = this._runtime._global(name);
+      } catch (error) {
+        return variable.define(name, rethrow(error));
+      }
+      if (value === void 0) {
+        this._scope.set(variable._name = name, variable);
+      } else {
+        variable.define(name, constant(value));
+      }
+    }
+  }
+  return variable;
+}
+__name(module_resolve, "module_resolve");
+function module_builtin(name, value) {
+  this._builtins.set(name, value);
+}
+__name(module_builtin, "module_builtin");
+function variable_name(variable) {
+  return variable._name;
+}
+__name(variable_name, "variable_name");
+const frame = typeof requestAnimationFrame === "function" ? requestAnimationFrame : typeof setImmediate === "function" ? setImmediate : (f) => setTimeout(f, 0);
+function Runtime(builtins, global = window_global) {
+  const builtin = this.module();
+  Object.defineProperties(this, {
+    _dirty: { value: /* @__PURE__ */ new Set() },
+    _updates: { value: /* @__PURE__ */ new Set() },
+    _precomputes: { value: [], writable: true },
+    _computing: { value: null, writable: true },
+    _init: { value: null, writable: true },
+    _modules: { value: /* @__PURE__ */ new Map() },
+    _variables: { value: /* @__PURE__ */ new Set() },
+    _disposed: { value: false, writable: true },
+    _builtin: { value: builtin },
+    _global: { value: global }
+  });
+  if (builtins) for (const name in builtins) {
+    new Variable(TYPE_IMPLICIT, builtin).define(name, [], builtins[name]);
+  }
+}
+__name(Runtime, "Runtime");
+Object.defineProperties(Runtime.prototype, {
+  _precompute: { value: runtime_precompute, writable: true, configurable: true },
+  _compute: { value: runtime_compute, writable: true, configurable: true },
+  _computeSoon: { value: runtime_computeSoon, writable: true, configurable: true },
+  _computeNow: { value: runtime_computeNow, writable: true, configurable: true },
+  dispose: { value: runtime_dispose, writable: true, configurable: true },
+  module: { value: runtime_module, writable: true, configurable: true }
+});
+function runtime_dispose() {
+  this._computing = Promise.resolve();
+  this._disposed = true;
+  this._variables.forEach((v) => {
+    v._invalidate();
+    v._version = NaN;
+  });
+}
+__name(runtime_dispose, "runtime_dispose");
+function runtime_module(define2, observer = noop) {
+  let module;
+  if (define2 === void 0) {
+    if (module = this._init) {
+      this._init = null;
+      return module;
+    }
+    return new Module(this);
+  }
+  module = this._modules.get(define2);
+  if (module) return module;
+  this._init = module = new Module(this);
+  this._modules.set(define2, module);
+  try {
+    define2(this, observer);
+  } finally {
+    this._init = null;
+  }
+  return module;
+}
+__name(runtime_module, "runtime_module");
+function runtime_precompute(callback) {
+  this._precomputes.push(callback);
+  this._compute();
+}
+__name(runtime_precompute, "runtime_precompute");
+function runtime_compute() {
+  return this._computing || (this._computing = this._computeSoon());
+}
+__name(runtime_compute, "runtime_compute");
+function runtime_computeSoon() {
+  return new Promise(frame).then(() => this._disposed ? void 0 : this._computeNow());
+}
+__name(runtime_computeSoon, "runtime_computeSoon");
+async function runtime_computeNow() {
+  let queue2 = [], variables, variable, precomputes = this._precomputes;
+  if (precomputes.length) {
+    this._precomputes = [];
+    for (const callback of precomputes) callback();
+    await runtime_defer(3);
+  }
+  variables = new Set(this._dirty);
+  variables.forEach(function(variable2) {
+    variable2._inputs.forEach(variables.add, variables);
+    const reachable = variable_reachable(variable2);
+    if (reachable > variable2._reachable) {
+      this._updates.add(variable2);
+    } else if (reachable < variable2._reachable) {
+      variable2._invalidate();
+    }
+    variable2._reachable = reachable;
+  }, this);
+  variables = new Set(this._updates);
+  variables.forEach(function(variable2) {
+    if (variable2._reachable) {
+      variable2._indegree = 0;
+      variable2._outputs.forEach(variables.add, variables);
+    } else {
+      variable2._indegree = NaN;
+      variables.delete(variable2);
+    }
+  });
+  this._computing = null;
+  this._updates.clear();
+  this._dirty.clear();
+  variables.forEach(function(variable2) {
+    variable2._outputs.forEach(variable_increment);
+  });
+  do {
+    variables.forEach(function(variable2) {
+      if (variable2._indegree === 0) {
+        queue2.push(variable2);
+      }
+    });
+    while (variable = queue2.pop()) {
+      variable_compute(variable);
+      variable._outputs.forEach(postqueue);
+      variables.delete(variable);
+    }
+    variables.forEach(function(variable2) {
+      if (variable_circular(variable2)) {
+        variable_error(variable2, new RuntimeError("circular definition"));
+        variable2._outputs.forEach(variable_decrement);
+        variables.delete(variable2);
+      }
+    });
+  } while (variables.size);
+  function postqueue(variable2) {
+    if (--variable2._indegree === 0) {
+      queue2.push(variable2);
+    }
+  }
+  __name(postqueue, "postqueue");
+}
+__name(runtime_computeNow, "runtime_computeNow");
+function runtime_defer(depth = 0) {
+  let p = Promise.resolve();
+  for (let i = 0; i < depth; ++i) p = p.then(() => {
+  });
+  return p;
+}
+__name(runtime_defer, "runtime_defer");
+function variable_circular(variable) {
+  const inputs = new Set(variable._inputs);
+  for (const i of inputs) {
+    if (i === variable) return true;
+    i._inputs.forEach(inputs.add, inputs);
+  }
+  return false;
+}
+__name(variable_circular, "variable_circular");
+function variable_increment(variable) {
+  ++variable._indegree;
+}
+__name(variable_increment, "variable_increment");
+function variable_decrement(variable) {
+  --variable._indegree;
+}
+__name(variable_decrement, "variable_decrement");
+function variable_value(variable) {
+  return variable._promise.catch(variable._rejector);
+}
+__name(variable_value, "variable_value");
+function variable_invalidator(variable) {
+  return new Promise(function(resolve2) {
+    variable._invalidate = resolve2;
+  });
+}
+__name(variable_invalidator, "variable_invalidator");
+function variable_intersector(invalidation, variable) {
+  let node = typeof IntersectionObserver === "function" && variable._observer && variable._observer._node;
+  let visible = !node, resolve2 = noop, reject = noop, promise, observer;
+  if (node) {
+    observer = new IntersectionObserver(([entry]) => (visible = entry.isIntersecting) && (promise = null, resolve2()));
+    observer.observe(node);
+    invalidation.then(() => (observer.disconnect(), observer = null, reject()));
+  }
+  return function(value) {
+    if (visible) return Promise.resolve(value);
+    if (!observer) return Promise.reject();
+    if (!promise) promise = new Promise((y, n) => (resolve2 = y, reject = n));
+    return promise.then(() => value);
+  };
+}
+__name(variable_intersector, "variable_intersector");
+function variable_compute(variable) {
+  variable._invalidate();
+  variable._invalidate = noop;
+  variable._pending();
+  const value0 = variable._value;
+  const version = ++variable._version;
+  const inputs = variable._inputs;
+  const definition = variable._definition;
+  let invalidation = null;
+  const promise = variable._promise = variable._promise.then(init, init).then(define2).then(generate);
+  function init() {
+    return Promise.all(inputs.map(variable_value));
+  }
+  __name(init, "init");
+  function define2(inputs2) {
+    if (variable._version !== version) throw variable_stale;
+    for (let i = 0, n = inputs2.length; i < n; ++i) {
+      switch (inputs2[i]) {
+        case variable_invalidation: {
+          inputs2[i] = invalidation = variable_invalidator(variable);
+          break;
+        }
+        case variable_visibility: {
+          if (!invalidation) invalidation = variable_invalidator(variable);
+          inputs2[i] = variable_intersector(invalidation, variable);
+          break;
+        }
+        case variable_variable: {
+          inputs2[i] = variable;
+          break;
+        }
+      }
+    }
+    return definition.apply(value0, inputs2);
+  }
+  __name(define2, "define");
+  function generate(value) {
+    if (variable._version !== version) throw variable_stale;
+    if (generatorish(value)) {
+      (invalidation || variable_invalidator(variable)).then(variable_return(value));
+      return variable_generate(variable, version, value);
+    }
+    return value;
+  }
+  __name(generate, "generate");
+  promise.then((value) => {
+    variable._value = value;
+    variable._fulfilled(value);
+  }, (error) => {
+    if (error === variable_stale || variable._version !== version) return;
+    variable._value = void 0;
+    variable._rejected(error);
+  });
+}
+__name(variable_compute, "variable_compute");
+function variable_generate(variable, version, generator) {
+  const runtime = variable._module._runtime;
+  let currentValue;
+  function compute(onfulfilled) {
+    return new Promise((resolve2) => resolve2(generator.next(currentValue))).then(({ done, value }) => {
+      return done ? void 0 : Promise.resolve(value).then(onfulfilled);
+    });
+  }
+  __name(compute, "compute");
+  function recompute() {
+    const promise = compute((value) => {
+      if (variable._version !== version) throw variable_stale;
+      currentValue = value;
+      postcompute(value, promise).then(() => runtime._precompute(recompute));
+      variable._fulfilled(value);
+      return value;
+    });
+    promise.catch((error) => {
+      if (error === variable_stale || variable._version !== version) return;
+      postcompute(void 0, promise);
+      variable._rejected(error);
+    });
+  }
+  __name(recompute, "recompute");
+  function postcompute(value, promise) {
+    variable._value = value;
+    variable._promise = promise;
+    variable._outputs.forEach(runtime._updates.add, runtime._updates);
+    return runtime._compute();
+  }
+  __name(postcompute, "postcompute");
+  return compute((value) => {
+    if (variable._version !== version) throw variable_stale;
+    currentValue = value;
+    runtime._precompute(recompute);
+    return value;
+  });
+}
+__name(variable_generate, "variable_generate");
+function variable_error(variable, error) {
+  variable._invalidate();
+  variable._invalidate = noop;
+  variable._pending();
+  ++variable._version;
+  variable._indegree = NaN;
+  (variable._promise = Promise.reject(error)).catch(noop);
+  variable._value = void 0;
+  variable._rejected(error);
+}
+__name(variable_error, "variable_error");
+function variable_return(generator) {
+  return function() {
+    generator.return();
+  };
+}
+__name(variable_return, "variable_return");
+function variable_reachable(variable) {
+  if (variable._observer !== no_observer) return true;
+  const outputs = new Set(variable._outputs);
+  for (const output of outputs) {
+    if (output._observer !== no_observer) return true;
+    output._outputs.forEach(outputs.add, outputs);
+  }
+  return false;
+}
+__name(variable_reachable, "variable_reachable");
+function window_global(name) {
+  return globalThis[name];
+}
+__name(window_global, "window_global");
+function dispatch(node, type, detail) {
+  detail = detail || {};
+  var document2 = node.ownerDocument, event = document2.defaultView.CustomEvent;
+  if (typeof event === "function") {
+    event = new event(type, { detail });
+  } else {
+    event = document2.createEvent("Event");
+    event.initEvent(type, false, false);
+    event.detail = detail;
+  }
+  node.dispatchEvent(event);
+}
+__name(dispatch, "dispatch");
+function isarray(value) {
+  return Array.isArray(value) || value instanceof Int8Array || value instanceof Int16Array || value instanceof Int32Array || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Uint16Array || value instanceof Uint32Array || value instanceof Float32Array || value instanceof Float64Array;
+}
+__name(isarray, "isarray");
+function isindex(key) {
+  return key === (key | 0) + "";
+}
+__name(isindex, "isindex");
+function inspectName(name) {
+  const n = document.createElement("span");
+  n.className = "observablehq--cellname";
+  n.textContent = `${name} = `;
+  return n;
+}
+__name(inspectName, "inspectName");
+const symbolToString = Symbol.prototype.toString;
+function formatSymbol(symbol) {
+  return symbolToString.call(symbol);
+}
+__name(formatSymbol, "formatSymbol");
+const { getOwnPropertySymbols, prototype: { hasOwnProperty } } = Object;
+const { toStringTag } = Symbol;
+const FORBIDDEN = {};
+const symbolsof = getOwnPropertySymbols;
+function isown(object, key) {
+  return hasOwnProperty.call(object, key);
+}
+__name(isown, "isown");
+function tagof(object) {
+  return object[toStringTag] || object.constructor && object.constructor.name || "Object";
+}
+__name(tagof, "tagof");
+function valueof$1(object, key) {
+  try {
+    const value = object[key];
+    if (value) value.constructor;
+    return value;
+  } catch (ignore) {
+    return FORBIDDEN;
+  }
+}
+__name(valueof$1, "valueof$1");
+const SYMBOLS = [
+  { symbol: "@@__IMMUTABLE_INDEXED__@@", name: "Indexed", modifier: true },
+  { symbol: "@@__IMMUTABLE_KEYED__@@", name: "Keyed", modifier: true },
+  { symbol: "@@__IMMUTABLE_LIST__@@", name: "List", arrayish: true },
+  { symbol: "@@__IMMUTABLE_MAP__@@", name: "Map" },
+  {
+    symbol: "@@__IMMUTABLE_ORDERED__@@",
+    name: "Ordered",
+    modifier: true,
+    prefix: true
+  },
+  { symbol: "@@__IMMUTABLE_RECORD__@@", name: "Record" },
+  {
+    symbol: "@@__IMMUTABLE_SET__@@",
+    name: "Set",
+    arrayish: true,
+    setish: true
+  },
+  { symbol: "@@__IMMUTABLE_STACK__@@", name: "Stack", arrayish: true }
+];
+function immutableName(obj) {
+  try {
+    let symbols = SYMBOLS.filter(({ symbol }) => obj[symbol] === true);
+    if (!symbols.length) return;
+    const name = symbols.find((s) => !s.modifier);
+    const prefix = name.name === "Map" && symbols.find((s) => s.modifier && s.prefix);
+    const arrayish = symbols.some((s) => s.arrayish);
+    const setish = symbols.some((s) => s.setish);
+    return {
+      name: `${prefix ? prefix.name : ""}${name.name}`,
+      symbols,
+      arrayish: arrayish && !setish,
+      setish
+    };
+  } catch (e) {
+    return null;
+  }
+}
+__name(immutableName, "immutableName");
+const { getPrototypeOf, getOwnPropertyDescriptors } = Object;
+const objectPrototype = getPrototypeOf({});
+function inspectExpanded(object, _2, name, proto) {
+  let arrayish = isarray(object);
+  let tag, fields, next, n;
+  if (object instanceof Map) {
+    if (object instanceof object.constructor) {
+      tag = `Map(${object.size})`;
+      fields = iterateMap$1;
+    } else {
+      tag = "Map()";
+      fields = iterateObject$1;
+    }
+  } else if (object instanceof Set) {
+    if (object instanceof object.constructor) {
+      tag = `Set(${object.size})`;
+      fields = iterateSet$1;
+    } else {
+      tag = "Set()";
+      fields = iterateObject$1;
+    }
+  } else if (arrayish) {
+    tag = `${object.constructor.name}(${object.length})`;
+    fields = iterateArray$1;
+  } else if (n = immutableName(object)) {
+    tag = `Immutable.${n.name}${n.name === "Record" ? "" : `(${object.size})`}`;
+    arrayish = n.arrayish;
+    fields = n.arrayish ? iterateImArray$1 : n.setish ? iterateImSet$1 : iterateImObject$1;
+  } else if (proto) {
+    tag = tagof(object);
+    fields = iterateProto;
+  } else {
+    tag = tagof(object);
+    fields = iterateObject$1;
+  }
+  const span = document.createElement("span");
+  span.className = "observablehq--expanded";
+  if (name) {
+    span.appendChild(inspectName(name));
+  }
+  const a = span.appendChild(document.createElement("a"));
+  a.innerHTML = `<svg width=8 height=8 class='observablehq--caret'>
+    <path d='M4 7L0 1h8z' fill='currentColor' />
+  </svg>`;
+  a.appendChild(document.createTextNode(`${tag}${arrayish ? " [" : " {"}`));
+  a.addEventListener("mouseup", function(event) {
+    event.stopPropagation();
+    replace(span, inspectCollapsed(object, null, name, proto));
+  });
+  fields = fields(object);
+  for (let i = 0; !(next = fields.next()).done && i < 20; ++i) {
+    span.appendChild(next.value);
+  }
+  if (!next.done) {
+    const a2 = span.appendChild(document.createElement("a"));
+    a2.className = "observablehq--field";
+    a2.style.display = "block";
+    a2.appendChild(document.createTextNode(`  … more`));
+    a2.addEventListener("mouseup", function(event) {
+      event.stopPropagation();
+      span.insertBefore(next.value, span.lastChild.previousSibling);
+      for (let i = 0; !(next = fields.next()).done && i < 19; ++i) {
+        span.insertBefore(next.value, span.lastChild.previousSibling);
+      }
+      if (next.done) span.removeChild(span.lastChild.previousSibling);
+      dispatch(span, "load");
+    });
+  }
+  span.appendChild(document.createTextNode(arrayish ? "]" : "}"));
+  return span;
+}
+__name(inspectExpanded, "inspectExpanded");
+function* iterateMap$1(map2) {
+  for (const [key, value] of map2) {
+    yield formatMapField$1(key, value);
+  }
+  yield* iterateObject$1(map2);
+}
+__name(iterateMap$1, "iterateMap$1");
+function* iterateSet$1(set) {
+  for (const value of set) {
+    yield formatSetField(value);
+  }
+  yield* iterateObject$1(set);
+}
+__name(iterateSet$1, "iterateSet$1");
+function* iterateImSet$1(set) {
+  for (const value of set) {
+    yield formatSetField(value);
+  }
+}
+__name(iterateImSet$1, "iterateImSet$1");
+function* iterateArray$1(array) {
+  for (let i = 0, n = array.length; i < n; ++i) {
+    if (i in array) {
+      yield formatField$1(i, valueof$1(array, i), "observablehq--index");
+    }
+  }
+  for (const key in array) {
+    if (!isindex(key) && isown(array, key)) {
+      yield formatField$1(key, valueof$1(array, key), "observablehq--key");
+    }
+  }
+  for (const symbol of symbolsof(array)) {
+    yield formatField$1(
+      formatSymbol(symbol),
+      valueof$1(array, symbol),
+      "observablehq--symbol"
+    );
+  }
+}
+__name(iterateArray$1, "iterateArray$1");
+function* iterateImArray$1(array) {
+  let i1 = 0;
+  for (const n = array.size; i1 < n; ++i1) {
+    yield formatField$1(i1, array.get(i1), true);
+  }
+}
+__name(iterateImArray$1, "iterateImArray$1");
+function* iterateProto(object) {
+  for (const key in getOwnPropertyDescriptors(object)) {
+    yield formatField$1(key, valueof$1(object, key), "observablehq--key");
+  }
+  for (const symbol of symbolsof(object)) {
+    yield formatField$1(
+      formatSymbol(symbol),
+      valueof$1(object, symbol),
+      "observablehq--symbol"
+    );
+  }
+  const proto = getPrototypeOf(object);
+  if (proto && proto !== objectPrototype) {
+    yield formatPrototype(proto);
+  }
+}
+__name(iterateProto, "iterateProto");
+function* iterateObject$1(object) {
+  for (const key in object) {
+    if (isown(object, key)) {
+      yield formatField$1(key, valueof$1(object, key), "observablehq--key");
+    }
+  }
+  for (const symbol of symbolsof(object)) {
+    yield formatField$1(
+      formatSymbol(symbol),
+      valueof$1(object, symbol),
+      "observablehq--symbol"
+    );
+  }
+  const proto = getPrototypeOf(object);
+  if (proto && proto !== objectPrototype) {
+    yield formatPrototype(proto);
+  }
+}
+__name(iterateObject$1, "iterateObject$1");
+function* iterateImObject$1(object) {
+  for (const [key, value] of object) {
+    yield formatField$1(key, value, "observablehq--key");
+  }
+}
+__name(iterateImObject$1, "iterateImObject$1");
+function formatPrototype(value) {
+  const item = document.createElement("div");
+  const span = item.appendChild(document.createElement("span"));
+  item.className = "observablehq--field";
+  span.className = "observablehq--prototype-key";
+  span.textContent = `  <prototype>`;
+  item.appendChild(document.createTextNode(": "));
+  item.appendChild(inspect$1(value, void 0, void 0, void 0, true));
+  return item;
+}
+__name(formatPrototype, "formatPrototype");
+function formatField$1(key, value, className) {
+  const item = document.createElement("div");
+  const span = item.appendChild(document.createElement("span"));
+  item.className = "observablehq--field";
+  span.className = className;
+  span.textContent = `  ${key}`;
+  item.appendChild(document.createTextNode(": "));
+  item.appendChild(inspect$1(value));
+  return item;
+}
+__name(formatField$1, "formatField$1");
+function formatMapField$1(key, value) {
+  const item = document.createElement("div");
+  item.className = "observablehq--field";
+  item.appendChild(document.createTextNode("  "));
+  item.appendChild(inspect$1(key));
+  item.appendChild(document.createTextNode(" => "));
+  item.appendChild(inspect$1(value));
+  return item;
+}
+__name(formatMapField$1, "formatMapField$1");
+function formatSetField(value) {
+  const item = document.createElement("div");
+  item.className = "observablehq--field";
+  item.appendChild(document.createTextNode("  "));
+  item.appendChild(inspect$1(value));
+  return item;
+}
+__name(formatSetField, "formatSetField");
+function hasSelection(elem) {
+  const sel = window.getSelection();
+  return sel.type === "Range" && (sel.containsNode(elem, true) || elem.contains(sel.anchorNode) || elem.contains(sel.focusNode));
+}
+__name(hasSelection, "hasSelection");
+function inspectCollapsed(object, shallow, name, proto) {
+  let arrayish = isarray(object);
+  let tag, fields, next, n;
+  if (object instanceof Map) {
+    if (object instanceof object.constructor) {
+      tag = `Map(${object.size})`;
+      fields = iterateMap;
+    } else {
+      tag = "Map()";
+      fields = iterateObject;
+    }
+  } else if (object instanceof Set) {
+    if (object instanceof object.constructor) {
+      tag = `Set(${object.size})`;
+      fields = iterateSet;
+    } else {
+      tag = "Set()";
+      fields = iterateObject;
+    }
+  } else if (arrayish) {
+    tag = `${object.constructor.name}(${object.length})`;
+    fields = iterateArray;
+  } else if (n = immutableName(object)) {
+    tag = `Immutable.${n.name}${n.name === "Record" ? "" : `(${object.size})`}`;
+    arrayish = n.arrayish;
+    fields = n.arrayish ? iterateImArray : n.setish ? iterateImSet : iterateImObject;
+  } else {
+    tag = tagof(object);
+    fields = iterateObject;
+  }
+  if (shallow) {
+    const span2 = document.createElement("span");
+    span2.className = "observablehq--shallow";
+    if (name) {
+      span2.appendChild(inspectName(name));
+    }
+    span2.appendChild(document.createTextNode(tag));
+    span2.addEventListener("mouseup", function(event) {
+      if (hasSelection(span2)) return;
+      event.stopPropagation();
+      replace(span2, inspectCollapsed(object));
+    });
+    return span2;
+  }
+  const span = document.createElement("span");
+  span.className = "observablehq--collapsed";
+  if (name) {
+    span.appendChild(inspectName(name));
+  }
+  const a = span.appendChild(document.createElement("a"));
+  a.innerHTML = `<svg width=8 height=8 class='observablehq--caret'>
+    <path d='M7 4L1 8V0z' fill='currentColor' />
+  </svg>`;
+  a.appendChild(document.createTextNode(`${tag}${arrayish ? " [" : " {"}`));
+  span.addEventListener("mouseup", function(event) {
+    if (hasSelection(span)) return;
+    event.stopPropagation();
+    replace(span, inspectExpanded(object, null, name, proto));
+  }, true);
+  fields = fields(object);
+  for (let i = 0; !(next = fields.next()).done && i < 20; ++i) {
+    if (i > 0) span.appendChild(document.createTextNode(", "));
+    span.appendChild(next.value);
+  }
+  if (!next.done) span.appendChild(document.createTextNode(", …"));
+  span.appendChild(document.createTextNode(arrayish ? "]" : "}"));
+  return span;
+}
+__name(inspectCollapsed, "inspectCollapsed");
+function* iterateMap(map2) {
+  for (const [key, value] of map2) {
+    yield formatMapField(key, value);
+  }
+  yield* iterateObject(map2);
+}
+__name(iterateMap, "iterateMap");
+function* iterateSet(set) {
+  for (const value of set) {
+    yield inspect$1(value, true);
+  }
+  yield* iterateObject(set);
+}
+__name(iterateSet, "iterateSet");
+function* iterateImSet(set) {
+  for (const value of set) {
+    yield inspect$1(value, true);
+  }
+}
+__name(iterateImSet, "iterateImSet");
+function* iterateImArray(array) {
+  let i0 = -1, i1 = 0;
+  for (const n = array.size; i1 < n; ++i1) {
+    if (i1 > i0 + 1) yield formatEmpty(i1 - i0 - 1);
+    yield inspect$1(array.get(i1), true);
+    i0 = i1;
+  }
+  if (i1 > i0 + 1) yield formatEmpty(i1 - i0 - 1);
+}
+__name(iterateImArray, "iterateImArray");
+function* iterateArray(array) {
+  let i0 = -1, i1 = 0;
+  for (const n = array.length; i1 < n; ++i1) {
+    if (i1 in array) {
+      if (i1 > i0 + 1) yield formatEmpty(i1 - i0 - 1);
+      yield inspect$1(valueof$1(array, i1), true);
+      i0 = i1;
+    }
+  }
+  if (i1 > i0 + 1) yield formatEmpty(i1 - i0 - 1);
+  for (const key in array) {
+    if (!isindex(key) && isown(array, key)) {
+      yield formatField(key, valueof$1(array, key), "observablehq--key");
+    }
+  }
+  for (const symbol of symbolsof(array)) {
+    yield formatField(formatSymbol(symbol), valueof$1(array, symbol), "observablehq--symbol");
+  }
+}
+__name(iterateArray, "iterateArray");
+function* iterateObject(object) {
+  for (const key in object) {
+    if (isown(object, key)) {
+      yield formatField(key, valueof$1(object, key), "observablehq--key");
+    }
+  }
+  for (const symbol of symbolsof(object)) {
+    yield formatField(formatSymbol(symbol), valueof$1(object, symbol), "observablehq--symbol");
+  }
+}
+__name(iterateObject, "iterateObject");
+function* iterateImObject(object) {
+  for (const [key, value] of object) {
+    yield formatField(key, value, "observablehq--key");
+  }
+}
+__name(iterateImObject, "iterateImObject");
+function formatEmpty(e) {
+  const span = document.createElement("span");
+  span.className = "observablehq--empty";
+  span.textContent = e === 1 ? "empty" : `empty × ${e}`;
+  return span;
+}
+__name(formatEmpty, "formatEmpty");
+function formatField(key, value, className) {
+  const fragment = document.createDocumentFragment();
+  const span = fragment.appendChild(document.createElement("span"));
+  span.className = className;
+  span.textContent = key;
+  fragment.appendChild(document.createTextNode(": "));
+  fragment.appendChild(inspect$1(value, true));
+  return fragment;
+}
+__name(formatField, "formatField");
+function formatMapField(key, value) {
+  const fragment = document.createDocumentFragment();
+  fragment.appendChild(inspect$1(key, true));
+  fragment.appendChild(document.createTextNode(" => "));
+  fragment.appendChild(inspect$1(value, true));
+  return fragment;
+}
+__name(formatMapField, "formatMapField");
+function format(date, fallback) {
+  if (!(date instanceof Date)) date = /* @__PURE__ */ new Date(+date);
+  if (isNaN(date)) return typeof fallback === "function" ? fallback(date) : fallback;
+  const hours = date.getUTCHours();
+  const minutes = date.getUTCMinutes();
+  const seconds = date.getUTCSeconds();
+  const milliseconds = date.getUTCMilliseconds();
+  return `${formatYear(date.getUTCFullYear())}-${pad(date.getUTCMonth() + 1, 2)}-${pad(date.getUTCDate(), 2)}${hours || minutes || seconds || milliseconds ? `T${pad(hours, 2)}:${pad(minutes, 2)}${seconds || milliseconds ? `:${pad(seconds, 2)}${milliseconds ? `.${pad(milliseconds, 3)}` : ``}` : ``}Z` : ``}`;
+}
+__name(format, "format");
+function formatYear(year) {
+  return year < 0 ? `-${pad(-year, 6)}` : year > 9999 ? `+${pad(year, 6)}` : pad(year, 4);
+}
+__name(formatYear, "formatYear");
+function pad(value, width2) {
+  return `${value}`.padStart(width2, "0");
+}
+__name(pad, "pad");
+function formatDate(date) {
+  return format(date, "Invalid Date");
+}
+__name(formatDate, "formatDate");
+var errorToString = Error.prototype.toString;
+function formatError(value) {
+  return value.stack || errorToString.call(value);
+}
+__name(formatError, "formatError");
+var regExpToString = RegExp.prototype.toString;
+function formatRegExp(value) {
+  return regExpToString.call(value);
+}
+__name(formatRegExp, "formatRegExp");
+const NEWLINE_LIMIT = 20;
+function formatString(string, shallow, expanded, name) {
+  if (shallow === false) {
+    if (count$1(string, /["\n]/g) <= count$1(string, /`|\${/g)) {
+      const span3 = document.createElement("span");
+      if (name) span3.appendChild(inspectName(name));
+      const textValue3 = span3.appendChild(document.createElement("span"));
+      textValue3.className = "observablehq--string";
+      textValue3.textContent = JSON.stringify(string);
+      return span3;
+    }
+    const lines = string.split("\n");
+    if (lines.length > NEWLINE_LIMIT && !expanded) {
+      const div = document.createElement("div");
+      if (name) div.appendChild(inspectName(name));
+      const textValue3 = div.appendChild(document.createElement("span"));
+      textValue3.className = "observablehq--string";
+      textValue3.textContent = "`" + templatify(lines.slice(0, NEWLINE_LIMIT).join("\n"));
+      const splitter = div.appendChild(document.createElement("span"));
+      const truncatedCount = lines.length - NEWLINE_LIMIT;
+      splitter.textContent = `Show ${truncatedCount} truncated line${truncatedCount > 1 ? "s" : ""}`;
+      splitter.className = "observablehq--string-expand";
+      splitter.addEventListener("mouseup", function(event) {
+        event.stopPropagation();
+        replace(div, inspect$1(string, shallow, true, name));
+      });
+      return div;
+    }
+    const span2 = document.createElement("span");
+    if (name) span2.appendChild(inspectName(name));
+    const textValue2 = span2.appendChild(document.createElement("span"));
+    textValue2.className = `observablehq--string${expanded ? " observablehq--expanded" : ""}`;
+    textValue2.textContent = "`" + templatify(string) + "`";
+    return span2;
+  }
+  const span = document.createElement("span");
+  if (name) span.appendChild(inspectName(name));
+  const textValue = span.appendChild(document.createElement("span"));
+  textValue.className = "observablehq--string";
+  textValue.textContent = JSON.stringify(string.length > 100 ? `${string.slice(0, 50)}…${string.slice(-49)}` : string);
+  return span;
+}
+__name(formatString, "formatString");
+function templatify(string) {
+  return string.replace(/[\\`\x00-\x09\x0b-\x19]|\${/g, templatifyChar);
+}
+__name(templatify, "templatify");
+function templatifyChar(char) {
+  var code = char.charCodeAt(0);
+  switch (code) {
+    case 8:
+      return "\\b";
+    case 9:
+      return "\\t";
+    case 11:
+      return "\\v";
+    case 12:
+      return "\\f";
+    case 13:
+      return "\\r";
+  }
+  return code < 16 ? "\\x0" + code.toString(16) : code < 32 ? "\\x" + code.toString(16) : "\\" + char;
+}
+__name(templatifyChar, "templatifyChar");
+function count$1(string, re) {
+  var n = 0;
+  while (re.exec(string)) ++n;
+  return n;
+}
+__name(count$1, "count$1");
+var toString$1 = Function.prototype.toString, TYPE_ASYNC = { prefix: "async ƒ" }, TYPE_ASYNC_GENERATOR = { prefix: "async ƒ*" }, TYPE_CLASS = { prefix: "class" }, TYPE_FUNCTION = { prefix: "ƒ" }, TYPE_GENERATOR = { prefix: "ƒ*" };
+function inspectFunction(f, name) {
+  var type, m, t = toString$1.call(f);
+  switch (f.constructor && f.constructor.name) {
+    case "AsyncFunction":
+      type = TYPE_ASYNC;
+      break;
+    case "AsyncGeneratorFunction":
+      type = TYPE_ASYNC_GENERATOR;
+      break;
+    case "GeneratorFunction":
+      type = TYPE_GENERATOR;
+      break;
+    default:
+      type = /^class\b/.test(t) ? TYPE_CLASS : TYPE_FUNCTION;
+      break;
+  }
+  if (type === TYPE_CLASS) {
+    return formatFunction(type, "", name);
+  }
+  if (m = /^(?:async\s*)?(\w+)\s*=>/.exec(t)) {
+    return formatFunction(type, "(" + m[1] + ")", name);
+  }
+  if (m = /^(?:async\s*)?\(\s*(\w+(?:\s*,\s*\w+)*)?\s*\)/.exec(t)) {
+    return formatFunction(type, m[1] ? "(" + m[1].replace(/\s*,\s*/g, ", ") + ")" : "()", name);
+  }
+  if (m = /^(?:async\s*)?function(?:\s*\*)?(?:\s*\w+)?\s*\(\s*(\w+(?:\s*,\s*\w+)*)?\s*\)/.exec(t)) {
+    return formatFunction(type, m[1] ? "(" + m[1].replace(/\s*,\s*/g, ", ") + ")" : "()", name);
+  }
+  return formatFunction(type, "(…)", name);
+}
+__name(inspectFunction, "inspectFunction");
+function formatFunction(type, args, cellname) {
+  var span = document.createElement("span");
+  span.className = "observablehq--function";
+  if (cellname) {
+    span.appendChild(inspectName(cellname));
+  }
+  var spanType = span.appendChild(document.createElement("span"));
+  spanType.className = "observablehq--keyword";
+  spanType.textContent = type.prefix;
+  span.appendChild(document.createTextNode(args));
+  return span;
+}
+__name(formatFunction, "formatFunction");
+const { prototype: { toString } } = Object;
+function inspect$1(value, shallow, expand, name, proto) {
+  let type = typeof value;
+  switch (type) {
+    case "boolean":
+    case "undefined": {
+      value += "";
+      break;
+    }
+    case "number": {
+      value = value === 0 && 1 / value < 0 ? "-0" : value + "";
+      break;
+    }
+    case "bigint": {
+      value = value + "n";
+      break;
+    }
+    case "symbol": {
+      value = formatSymbol(value);
+      break;
+    }
+    case "function": {
+      return inspectFunction(value, name);
+    }
+    case "string": {
+      return formatString(value, shallow, expand, name);
+    }
+    default: {
+      if (value === null) {
+        type = null, value = "null";
+        break;
+      }
+      if (value instanceof Date) {
+        type = "date", value = formatDate(value);
+        break;
+      }
+      if (value === FORBIDDEN) {
+        type = "forbidden", value = "[forbidden]";
+        break;
+      }
+      switch (toString.call(value)) {
+        case "[object RegExp]": {
+          type = "regexp", value = formatRegExp(value);
+          break;
+        }
+        case "[object Error]":
+        // https://github.com/lodash/lodash/blob/master/isError.js#L26
+        case "[object DOMException]": {
+          type = "error", value = formatError(value);
+          break;
+        }
+        default:
+          return (expand ? inspectExpanded : inspectCollapsed)(value, shallow, name, proto);
+      }
+      break;
+    }
+  }
+  const span = document.createElement("span");
+  if (name) span.appendChild(inspectName(name));
+  const n = span.appendChild(document.createElement("span"));
+  n.className = `observablehq--${type}`;
+  n.textContent = value;
+  return span;
+}
+__name(inspect$1, "inspect$1");
+function replace(spanOld, spanNew) {
+  if (spanOld.classList.contains("observablehq--inspect")) spanNew.classList.add("observablehq--inspect");
+  spanOld.parentNode.replaceChild(spanNew, spanOld);
+  dispatch(spanNew, "load");
+}
+__name(replace, "replace");
+const LOCATION_MATCH = /\s+\(\d+:\d+\)$/m;
+const _Inspector = class _Inspector {
+  constructor(node) {
+    if (!node) throw new Error("invalid node");
+    this._node = node;
+    node.classList.add("observablehq");
+  }
+  pending() {
+    const { _node } = this;
+    _node.classList.remove("observablehq--error");
+    _node.classList.add("observablehq--running");
+  }
+  fulfilled(value, name) {
+    const { _node } = this;
+    if (!isnode(value) || value.parentNode && value.parentNode !== _node) {
+      value = inspect$1(value, false, _node.firstChild && _node.firstChild.classList && _node.firstChild.classList.contains("observablehq--expanded"), name);
+      value.classList.add("observablehq--inspect");
+    }
+    _node.classList.remove("observablehq--running", "observablehq--error");
+    if (_node.firstChild !== value) {
+      if (_node.firstChild) {
+        while (_node.lastChild !== _node.firstChild) _node.removeChild(_node.lastChild);
+        _node.replaceChild(value, _node.firstChild);
+      } else {
+        _node.appendChild(value);
+      }
+    }
+    dispatch(_node, "update");
+  }
+  rejected(error, name) {
+    const { _node } = this;
+    _node.classList.remove("observablehq--running");
+    _node.classList.add("observablehq--error");
+    while (_node.lastChild) _node.removeChild(_node.lastChild);
+    var div = document.createElement("div");
+    div.className = "observablehq--inspect";
+    if (name) div.appendChild(inspectName(name));
+    div.appendChild(document.createTextNode((error + "").replace(LOCATION_MATCH, "")));
+    _node.appendChild(div);
+    dispatch(_node, "error", { error });
+  }
+};
+__name(_Inspector, "Inspector");
+let Inspector = _Inspector;
+Inspector.into = function(container) {
+  if (typeof container === "string") {
+    container = document.querySelector(container);
+    if (container == null) throw new Error("container not found");
+  }
+  return function() {
+    return new Inspector(container.appendChild(document.createElement("div")));
+  };
+};
+function isnode(value) {
+  return (value instanceof Element || value instanceof Text) && value instanceof value.constructor;
+}
+__name(isnode, "isnode");
+function inspect(value, expanded) {
+  const node = document.createElement("div");
+  new Inspector(node).fulfilled(value);
+  if (expanded) {
+    for (const path of expanded) {
+      let child = node;
+      for (const i of path)
+        child = child?.childNodes[i];
+      child?.dispatchEvent(new Event("mouseup"));
+    }
+  }
+  return node;
+}
+__name(inspect, "inspect");
+function inspectError(value) {
+  const node = document.createElement("div");
+  new Inspector(node).rejected(value);
+  return node;
+}
+__name(inspectError, "inspectError");
+function getExpanded(node) {
+  if (!isInspector(node))
+    return;
+  const expanded = node.querySelectorAll(".observablehq--expanded");
+  if (expanded.length)
+    return Array.from(expanded, (e) => getNodePath(node, e));
+}
+__name(getExpanded, "getExpanded");
+function isElement(node) {
+  return node.nodeType === 1;
+}
+__name(isElement, "isElement");
+function isInspector(node) {
+  return isElement(node) && node.classList.contains("observablehq");
+}
+__name(isInspector, "isInspector");
+function getNodePath(node, descendant) {
+  const path = [];
+  while (descendant !== node) {
+    path.push(getChildIndex(descendant));
+    descendant = descendant.parentNode;
+  }
+  return path.reverse();
+}
+__name(getNodePath, "getNodePath");
+function getChildIndex(node) {
+  return Array.prototype.indexOf.call(node.parentNode.childNodes, node);
+}
+__name(getChildIndex, "getChildIndex");
+const SRC_SELECTOR = [
+  "audio source[src]",
+  // audio
+  "audio[src]",
+  // audio
+  "img[src]",
+  // images
+  "picture source[src]",
+  // images
+  "video source[src]",
+  // videos
+  "video[src]"
+  // videos
+].join();
+const SRCSET_SELECTOR = [
+  "img[srcset]",
+  // images
+  "picture source[srcset]"
+  // images
+].join();
+const HREF_SELECTOR = [
+  "a[href][download]",
+  // download links
+  "link[href]"
+  // stylesheets
+].join();
+const ASSET_ATTRIBUTES = [
+  [SRC_SELECTOR, "src"],
+  [SRCSET_SELECTOR, "srcset"],
+  [HREF_SELECTOR, "href"]
+];
+function mapAssets(root2, assets) {
+  const resolve2 = /* @__PURE__ */ __name((s) => assets.get(asImportPath(s)) ?? s, "resolve");
+  for (const [selector, src] of ASSET_ATTRIBUTES) {
+    for (const element of root2.querySelectorAll(selector)) {
+      if (isRelExternal(element))
+        continue;
+      const source = decodeURI(element.getAttribute(src));
+      if (src === "srcset")
+        element.setAttribute(src, resolveSrcset(source, resolve2));
+      else
+        element.setAttribute(src, resolve2(source));
+    }
+  }
+}
+__name(mapAssets, "mapAssets");
+function isRelExternal(a) {
+  return /(?:^|\s)external(?:\s|$)/i.test(a.getAttribute("rel") ?? "");
+}
+__name(isRelExternal, "isRelExternal");
+function asPath(source) {
+  const i = source.indexOf("?");
+  const j = source.indexOf("#");
+  const k = i >= 0 && j >= 0 ? Math.min(i, j) : i >= 0 ? i : j;
+  return k >= 0 ? source.slice(0, k) : source;
+}
+__name(asPath, "asPath");
+function asImportPath(source) {
+  const path = asPath(source);
+  return isImportPath(path) ? path : `./${path}`;
+}
+__name(asImportPath, "asImportPath");
+function isImportPath(specifier) {
+  return ["./", "../", "/"].some((prefix) => specifier.startsWith(prefix));
+}
+__name(isImportPath, "isImportPath");
+function resolveSrcset(srcset, resolve2) {
+  return srcset.trim().split(/\s*,\s*/).filter((src) => src).map((src) => {
+    const parts = src.split(/\s+/);
+    const path = resolve2(parts[0]);
+    if (path)
+      parts[0] = encodeURI(path);
+    return parts.join(" ");
+  }).join(", ");
+}
+__name(resolveSrcset, "resolveSrcset");
+function display(state, value) {
+  const { root: root2, expanded } = state;
+  const node = isDisplayable(value, root2) ? value : inspect(value, expanded[root2.childNodes.length]);
+  displayNode(state, node);
+}
+__name(display, "display");
+function displayNode(state, node) {
+  if (node.nodeType === 11) {
+    let child;
+    while (child = node.firstChild) {
+      state.root.appendChild(child);
+    }
+  } else {
+    state.root.appendChild(node);
+  }
+}
+__name(displayNode, "displayNode");
+function displayError(state, value) {
+  displayNode(state, inspectError(value));
+}
+__name(displayError, "displayError");
+function isDisplayable(value, root2) {
+  return (value instanceof Element || value instanceof Text) && value instanceof value.constructor && (!value.parentNode || root2.contains(value));
+}
+__name(isDisplayable, "isDisplayable");
+function clear(state) {
+  state.autoclear = false;
+  state.expanded = Array.from(state.root.childNodes, getExpanded);
+  while (state.root.lastChild)
+    state.root.lastChild.remove();
+}
+__name(clear, "clear");
+function observe$1(state, { autodisplay, assets }) {
+  return {
+    _error: false,
+    _node: state.root,
+    // _node for visibility promise
+    pending() {
+      if (this._error) {
+        this._error = false;
+        clear(state);
+      }
+    },
+    fulfilled(value) {
+      if (autodisplay) {
+        if (assets && value instanceof Element)
+          mapAssets(value, assets);
+        clear(state);
+        display(state, value);
+      } else if (state.autoclear) {
+        clear(state);
+      }
+    },
+    rejected(error) {
+      console.error(error);
+      this._error = true;
+      clear(state);
+      displayError(state, error);
+    }
+  };
+}
+__name(observe$1, "observe$1");
+async function* observe(initialize) {
+  let resolve2;
+  let value;
+  let stale = false;
+  const dispose = initialize((x) => {
+    value = x;
+    if (resolve2) {
+      resolve2(x);
+      resolve2 = void 0;
+    } else {
+      stale = true;
+    }
+    return x;
+  });
+  if (dispose != null && typeof dispose !== "function") {
+    throw new Error(typeof dispose === "object" && "then" in dispose && typeof dispose.then === "function" ? "async initializers are not supported" : "initializer returned something, but not a dispose function");
+  }
+  try {
+    while (true) {
+      yield stale ? (stale = false, value) : new Promise((_2) => resolve2 = _2);
+    }
+  } finally {
+    if (dispose != null) {
+      dispose();
+    }
+  }
+}
+__name(observe, "observe");
+function input(element) {
+  return observe((change) => {
+    const event = eventof(element);
+    const value = valueof(element);
+    const inputted = /* @__PURE__ */ __name(() => change(valueof(element)), "inputted");
+    element.addEventListener(event, inputted);
+    if (value !== void 0)
+      change(value);
+    return () => element.removeEventListener(event, inputted);
+  });
+}
+__name(input, "input");
+function valueof(element) {
+  const input2 = element;
+  const select = element;
+  if ("type" in element) {
+    switch (element.type) {
+      case "range":
+      case "number":
+        return input2.valueAsNumber;
+      case "date":
+        return input2.valueAsDate;
+      case "checkbox":
+        return input2.checked;
+      case "file":
+        return input2.multiple ? input2.files : input2.files[0];
+      case "select-multiple":
+        return Array.from(select.selectedOptions, (o) => o.value);
+    }
+  }
+  return input2.value;
+}
+__name(valueof, "valueof");
+function eventof(element) {
+  if ("type" in element) {
+    switch (element.type) {
+      case "button":
+      case "submit":
+      case "checkbox":
+        return "click";
+      case "file":
+        return "change";
+    }
+  }
+  return "input";
+}
+__name(eventof, "eventof");
+async function* now() {
+  while (true) {
+    yield Date.now();
+  }
+}
+__name(now, "now");
+async function* queue(initialize) {
+  let resolve2;
+  const values = [];
+  const dispose = initialize((x) => {
+    values.push(x);
+    if (resolve2) {
+      resolve2(values.shift());
+      resolve2 = void 0;
+    }
+    return x;
+  });
+  if (dispose != null && typeof dispose !== "function") {
+    throw new Error(typeof dispose === "object" && "then" in dispose && typeof dispose.then === "function" ? "async initializers are not supported" : "initializer returned something, but not a dispose function");
+  }
+  try {
+    while (true) {
+      yield values.length ? values.shift() : new Promise((_2) => resolve2 = _2);
+    }
+  } finally {
+    if (dispose != null) {
+      dispose();
+    }
+  }
+}
+__name(queue, "queue");
+function width(target, options) {
+  return observe((notify) => {
+    let width2;
+    const observer = new ResizeObserver(([entry]) => {
+      const w = entry.contentRect.width;
+      if (w !== width2)
+        notify(width2 = w);
+    });
+    observer.observe(target, options);
+    return () => observer.disconnect();
+  });
+}
+__name(width, "width");
+const Generators = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  input,
+  now,
+  observe,
+  queue,
+  width
+}, Symbol.toStringTag, { value: "Module" }));
+function Mutable(value) {
+  let change;
+  return Object.defineProperty(observe((_2) => {
+    change = _2;
+    if (value !== void 0)
+      change(value);
+  }), "value", {
+    get: /* @__PURE__ */ __name(() => value, "get"),
+    set: /* @__PURE__ */ __name((x) => (value = x, void change?.(value)), "set")
+  });
+}
+__name(Mutable, "Mutable");
+function Mutator(value) {
+  const mutable = Mutable(value);
+  return [
+    mutable,
+    {
+      get value() {
+        return mutable.value;
+      },
+      set value(v) {
+        mutable.value = v;
+      }
+    }
+  ];
+}
+__name(Mutator, "Mutator");
+function define(main2, state, definition, observer = observe$1) {
+  const { id, body, inputs = [], outputs = [], output, autodisplay, autoview, automutable } = definition;
+  const variables = state.variables;
+  const v = main2.variable(observer(state, definition), { shadow: {} });
+  const vid = output ?? (outputs.length ? `cell ${id}` : null);
+  state.autoclear = true;
+  if (inputs.includes("display") || inputs.includes("view")) {
+    let displayVersion = -1;
+    const vd = new v.constructor(2, v._module);
+    vd.define(inputs.filter((i) => i !== "display" && i !== "view"), () => {
+      const version = v._version;
+      return (value) => {
+        if (version < displayVersion)
+          throw new Error("stale display");
+        else if (state.variables[0] !== v)
+          throw new Error("stale display");
+        else if (version > displayVersion)
+          clear(state);
+        displayVersion = version;
+        display(state, value);
+        return value;
+      };
+    });
+    v._shadow.set("display", vd);
+    if (inputs.includes("view")) {
+      const vv = new v.constructor(2, v._module, null, { shadow: {} });
+      vv._shadow.set("display", vd);
+      vv.define(["display"], (display2) => (value) => input(display2(value)));
+      v._shadow.set("view", vv);
+    }
+  } else if (!autodisplay) {
+    clear(state);
+  }
+  variables.push(v.define(vid, inputs, body));
+  if (output != null) {
+    if (autoview) {
+      const o = unprefix(output, "viewof$");
+      variables.push(main2.define(o, [output], input));
+    } else if (automutable) {
+      const o = unprefix(output, "mutable ");
+      const x = `cell ${id}`;
+      v.define(o, [x], ([mutable]) => mutable);
+      variables.push(
+        main2.define(output, inputs, body),
+        // initial value
+        main2.define(x, [output], Mutator),
+        main2.define(`mutable$${o}`, [x], ([, mutator]) => mutator)
+      );
+    }
+  } else {
+    for (const o of outputs) {
+      variables.push(main2.variable(true).define(o, [vid], (exports) => exports[o]));
+    }
+  }
+}
+__name(define, "define");
+function unprefix(name, prefix) {
+  if (!name.startsWith(prefix))
+    throw new Error(`expected ${prefix}: ${name}`);
+  return name.slice(prefix.length);
+}
+__name(unprefix, "unprefix");
+const files = /* @__PURE__ */ new Map();
+const FileAttachment = /* @__PURE__ */ __name((name, base = document.baseURI) => {
+  const href = new URL(name, base).href;
+  let file = files.get(href);
+  if (!file) {
+    file = new FileAttachmentImpl(href, name.split("/").pop());
+    files.set(href, file);
+  }
+  return file;
+}, "FileAttachment");
+async function fetchFile(file) {
+  const response = await fetch(file.href);
+  if (!response.ok)
+    throw new Error(`Unable to load file: ${file.name}`);
+  return response;
+}
+__name(fetchFile, "fetchFile");
+const _AbstractFile = class _AbstractFile {
+  constructor(name, mimeType = guessMimeType(name), lastModified, size) {
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "mimeType", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "lastModified", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "size", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperties(this, {
+      name: { value: `${name}`, enumerable: true },
+      mimeType: { value: `${mimeType}`, enumerable: true },
+      lastModified: { value: lastModified === void 0 ? void 0 : +lastModified, enumerable: true },
+      // prettier-ignore
+      size: { value: size === void 0 ? void 0 : +size, enumerable: true }
+    });
+  }
+  async url() {
+    return this.href;
+  }
+  async blob() {
+    return (await fetchFile(this)).blob();
+  }
+  async arrayBuffer() {
+    return (await fetchFile(this)).arrayBuffer();
+  }
+  async text(encoding) {
+    return encoding === void 0 ? (await fetchFile(this)).text() : new TextDecoder(encoding).decode(await this.arrayBuffer());
+  }
+  async json() {
+    return (await fetchFile(this)).json();
+  }
+  async stream() {
+    return (await fetchFile(this)).body;
+  }
+  async dsv({ delimiter = ",", array = false, typed = false } = {}) {
+    const [text2, d32] = await Promise.all([this.text(), import("https://cdn.jsdelivr.net/npm/d3-dsv/+esm")]);
+    const format2 = d32.dsvFormat(delimiter);
+    const parse = array ? format2.parseRows : format2.parse;
+    return parse(text2, typed && d32.autoType);
+  }
+  async csv(options) {
+    return this.dsv({ ...options, delimiter: "," });
+  }
+  async tsv(options) {
+    return this.dsv({ ...options, delimiter: "	" });
+  }
+  async image(props) {
+    const url = await this.url();
+    return new Promise((resolve2, reject) => {
+      const i = new Image();
+      if (new URL(url, document.baseURI).origin !== location.origin)
+        i.crossOrigin = "anonymous";
+      Object.assign(i, props);
+      i.onload = () => resolve2(i);
+      i.onerror = () => reject(new Error(`Unable to load file: ${this.name}`));
+      i.src = url;
+    });
+  }
+  async arrow() {
+    const [Arrow2, response] = await Promise.all([import("https://cdn.jsdelivr.net/npm/apache-arrow@17.0.0/+esm"), fetchFile(this)]);
+    return Arrow2.tableFromIPC(response);
+  }
+  async arquero(options) {
+    let request;
+    let from;
+    switch (this.mimeType) {
+      case "application/json":
+        request = this.text();
+        from = "fromJSON";
+        break;
+      // @ts-expect-error fall through
+      case "text/tab-separated-values":
+        if (options?.delimiter === void 0)
+          options = { ...options, delimiter: "	" };
+      // fall through
+      case "text/csv":
+        request = this.text();
+        from = "fromCSV";
+        break;
+      default:
+        if (/\.arrow$/i.test(this.name)) {
+          request = this.arrow();
+          from = "fromArrow";
+        } else if (/\.parquet$/i.test(this.name)) {
+          request = this.parquet();
+          from = "fromArrow";
+        } else {
+          throw new Error(`unable to determine Arquero loader: ${this.name}`);
+        }
+        break;
+    }
+    const [aq2, body] = await Promise.all([import("https://cdn.jsdelivr.net/npm/arquero/+esm"), request]);
+    return aq2[from](body, options);
+  }
+  async parquet() {
+    const [Arrow2, Parquet, buffer] = await Promise.all([import("https://cdn.jsdelivr.net/npm/apache-arrow@17.0.0/+esm"), import("https://cdn.jsdelivr.net/npm/parquet-wasm/+esm").then(async (Parquet2) => (await Parquet2.default("https://cdn.jsdelivr.net/npm/parquet-wasm/esm/parquet_wasm_bg.wasm"), Parquet2)), this.arrayBuffer()]);
+    return Arrow2.tableFromIPC(Parquet.readParquet(new Uint8Array(buffer)).intoIPCStream());
+  }
+  async xml(mimeType = "application/xml") {
+    return new DOMParser().parseFromString(await this.text(), mimeType);
+  }
+  async html() {
+    return this.xml("text/html");
+  }
+};
+__name(_AbstractFile, "AbstractFile");
+let AbstractFile = _AbstractFile;
+function guessMimeType(name) {
+  const i = name.lastIndexOf(".");
+  const j = name.lastIndexOf("/");
+  const extension = i > 0 && (j < 0 || i > j) ? name.slice(i).toLowerCase() : "";
+  switch (extension) {
+    case ".csv":
+      return "text/csv";
+    case ".tsv":
+      return "text/tab-separated-values";
+    case ".json":
+      return "application/json";
+    case ".html":
+      return "text/html";
+    case ".xml":
+      return "application/xml";
+    case ".png":
+      return "image/png";
+    case ".jpg":
+      return "image/jpg";
+    case ".js":
+      return "text/javascript";
+    default:
+      return "application/octet-stream";
+  }
+}
+__name(guessMimeType, "guessMimeType");
+const _FileAttachmentImpl = class _FileAttachmentImpl extends AbstractFile {
+  constructor(href, name, mimeType, lastModified, size) {
+    super(name, mimeType, lastModified, size);
+    Object.defineProperty(this, "href", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "href", { value: href });
+  }
+};
+__name(_FileAttachmentImpl, "FileAttachmentImpl");
+let FileAttachmentImpl = _FileAttachmentImpl;
+Object.defineProperty(FileAttachmentImpl, "name", { value: "FileAttachment" });
+FileAttachment.prototype = FileAttachmentImpl.prototype;
+function fileAttachments(resolve2) {
+  function FileAttachment2(name) {
+    const result = resolve2(name += "");
+    if (result == null)
+      throw new Error(`File not found: ${name}`);
+    if (typeof result === "object" && "url" in result) {
+      const { url, mimeType } = result;
+      return new FileAttachmentImpl(url, name, mimeType);
+    }
+    return new FileAttachmentImpl(result, name);
+  }
+  __name(FileAttachment2, "FileAttachment");
+  FileAttachment2.prototype = FileAttachmentImpl.prototype;
+  return FileAttachment2;
+}
+__name(fileAttachments, "fileAttachments");
+function sluggify(string, { length = 50, fallback = "untitled", separator = "-" } = {}) {
+  const parts = string.normalize("NFD").replace(/[\u0300-\u036f'‘’]/g, "").toLowerCase().split(/\W+/g).filter(nonempty);
+  let i = -1;
+  for (let l = 0, n = parts.length; ++i < n; ) {
+    if ((l += parts[i].length) + i > length) {
+      parts[i] = parts[i].substring(0, length - l + parts[i].length - i);
+      break;
+    }
+  }
+  return parts.slice(0, i + 1).filter(Boolean).join(separator) || fallback.slice(0, length);
+}
+__name(sluggify, "sluggify");
+function nonempty(string) {
+  return string.length > 0;
+}
+__name(nonempty, "nonempty");
+async function sha256(input2) {
+  const encoded = new TextEncoder().encode(input2);
+  const buffer = await crypto.subtle.digest("SHA-256", encoded);
+  return new Uint8Array(buffer).reduce((i, byte) => i << 8n | BigInt(byte), 0n);
+}
+__name(sha256, "sha256");
+function base36(int, length) {
+  return int.toString(36).padStart(length, "0").slice(0, length);
+}
+__name(base36, "base36");
+async function hash(strings, ...params) {
+  return base36(await sha256(JSON.stringify([strings, ...params])), 16);
+}
+__name(hash, "hash");
+async function nameHash(name) {
+  return /^[\w-]+$/.test(name) ? name : `${sluggify(basename(name))}.${base36(await sha256(name), 8)}`;
+}
+__name(nameHash, "nameHash");
+function basename(name) {
+  return name.replace(/^.*\//, "");
+}
+__name(basename, "basename");
+const DatabaseClient = /* @__PURE__ */ __name((name, options) => {
+  return new DatabaseClientImpl(name, normalizeOptions(options));
+}, "DatabaseClient");
+function normalizeOptions({ id, since } = {}) {
+  const options = {};
+  if (id !== void 0)
+    options.id = id;
+  if (since !== void 0)
+    options.since = new Date(since);
+  return options;
+}
+__name(normalizeOptions, "normalizeOptions");
+const _DatabaseClientImpl = class _DatabaseClientImpl {
+  constructor(name, options) {
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "options", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperties(this, {
+      name: { value: name, enumerable: true },
+      options: { value: options, enumerable: true }
+    });
+  }
+  async sql(strings, ...params) {
+    const path = await this.cachePath(strings, ...params);
+    const response = await fetch(path);
+    if (!response.ok)
+      throw new Error(`failed to fetch: ${path}`);
+    return await response.json().then(revive);
+  }
+  async cachePath(strings, ...params) {
+    return `.observable/cache/${await nameHash(this.name)}-${await hash(strings, ...params)}.json`;
+  }
+};
+__name(_DatabaseClientImpl, "DatabaseClientImpl");
+let DatabaseClientImpl = _DatabaseClientImpl;
+function revive({ rows, schema, date, ...meta }) {
+  for (const column of schema) {
+    switch (column.type) {
+      case "bigint": {
+        const { name } = column;
+        for (const row of rows) {
+          const value = row[name];
+          if (value == null)
+            continue;
+          row[name] = Number(value);
+        }
+        break;
+      }
+      case "date": {
+        const { name } = column;
+        for (const row of rows) {
+          const value = row[name];
+          if (value == null)
+            continue;
+          row[name] = asDate(value);
+        }
+        break;
+      }
+    }
+  }
+  if (date != null)
+    date = new Date(date);
+  return Object.assign(rows, { schema, date }, meta);
+}
+__name(revive, "revive");
+function asDate(value) {
+  return new Date(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(?::\d{2})?$/.test(value) ? value + "Z" : value);
+}
+__name(asDate, "asDate");
+DatabaseClient.revive = revive;
+DatabaseClient.prototype = DatabaseClientImpl.prototype;
+Object.defineProperty(DatabaseClientImpl, "name", { value: "DatabaseClient" });
+function canvas(width2, height) {
+  const canvas2 = document.createElement("canvas");
+  canvas2.width = width2;
+  canvas2.height = height;
+  return canvas2;
+}
+__name(canvas, "canvas");
+function context2d(width2, height, dpi = devicePixelRatio) {
+  const canvas2 = document.createElement("canvas");
+  canvas2.width = width2 * dpi;
+  canvas2.height = height * dpi;
+  canvas2.style.width = `${width2}px`;
+  const context = canvas2.getContext("2d");
+  context.scale(dpi, dpi);
+  return context;
+}
+__name(context2d, "context2d");
+function svg$1(width2, height) {
+  const svg2 = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width2} ${height}`);
+  svg2.setAttribute("width", `${width2}`);
+  svg2.setAttribute("height", `${height}`);
+  return svg2;
+}
+__name(svg$1, "svg$1");
+function text$1(value) {
+  return document.createTextNode(value);
+}
+__name(text$1, "text$1");
+let count = 0;
+function uid(name) {
+  return new Id(`O-${name == null ? "" : `${name}-`}${++count}`);
+}
+__name(uid, "uid");
+const _Id = class _Id {
+  constructor(id) {
+    Object.defineProperty(this, "id", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "href", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.id = id;
+    this.href = new URL(`#${id}`, location.href).href;
+  }
+  toString() {
+    return `url(${this.href})`;
+  }
+};
+__name(_Id, "Id");
+let Id = _Id;
+const DOM = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  canvas,
+  context2d,
+  svg: svg$1,
+  text: text$1,
+  uid
+}, Symbol.toStringTag, { value: "Module" }));
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var _Observer_promise;
+const _Observer = class _Observer {
+  constructor() {
+    _Observer_promise.set(this, void 0);
+    Object.defineProperty(this, "fulfilled", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "rejected", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.next();
+  }
+  async next() {
+    const value = await __classPrivateFieldGet(this, _Observer_promise, "f");
+    __classPrivateFieldSet(this, _Observer_promise, new Promise((res, rej) => (this.fulfilled = res, this.rejected = rej)), "f");
+    return { done: false, value };
+  }
+  throw() {
+    return { done: true };
+  }
+  return() {
+    return { done: true };
+  }
+};
+__name(_Observer, "Observer");
+let Observer = _Observer;
+_Observer_promise = /* @__PURE__ */ new WeakMap();
+const _ = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/lodash/+esm").then((_2) => _2.default), "_");
+const aq = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/arquero/+esm"), "aq");
+const Arrow = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/apache-arrow@17.0.0/+esm"), "Arrow");
+const d3 = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/d3/+esm"), "d3");
+const dot = /* @__PURE__ */ __name(() => import("./dot-DK4iDc2-.js").then((_2) => _2.dot), "dot");
+const duckdb = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/@duckdb/duckdb-wasm@1.29.0/+esm"), "duckdb");
+const DuckDBClient = /* @__PURE__ */ __name(() => import("./duckdb-DkM9_nXT.js").then((_2) => _2.DuckDBClient), "DuckDBClient");
+const echarts = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/echarts/dist/echarts.esm.min.js/+esm"), "echarts");
+const htl = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/htl/+esm"), "htl");
+const html = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/htl/+esm").then((_2) => _2.html), "html");
+const svg = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/htl/+esm").then((_2) => _2.svg), "svg");
+const Inputs = /* @__PURE__ */ __name(() => import("./inputs-CsCXZHQ8.js"), "Inputs");
+const L = /* @__PURE__ */ __name(() => import("./leaflet-CkvVhxBL.js"), "L");
+const mapboxgl = /* @__PURE__ */ __name(() => import("./mapboxgl-C0i2HzjJ.js").then((_2) => _2.default), "mapboxgl");
+const md = /* @__PURE__ */ __name(() => import("./md-Bxvu6Hld.js").then((_2) => _2.md), "md");
+const mermaid = /* @__PURE__ */ __name(() => import("./mermaid-CFg6sgdO.js").then((_2) => _2.mermaid), "mermaid");
+const Plot = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/@observablehq/plot/+esm"), "Plot");
+const React = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/react/+esm"), "React");
+const ReactDOM = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/react-dom/client/+esm"), "ReactDOM");
+const tex = /* @__PURE__ */ __name(() => import("./tex-ayRXOMLZ.js").then((_2) => _2.tex), "tex");
+const topojson = /* @__PURE__ */ __name(() => import("https://cdn.jsdelivr.net/npm/topojson-client/+esm"), "topojson");
+const vl = /* @__PURE__ */ __name(() => import("./vega-lite-CESXoehe.js").then((_2) => _2.vl), "vl");
+const recommendedLibraries = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Arrow,
+  DuckDBClient,
+  Inputs,
+  L,
+  Plot,
+  React,
+  ReactDOM,
+  _,
+  aq,
+  d3,
+  dot,
+  duckdb,
+  echarts,
+  htl,
+  html,
+  mapboxgl,
+  md,
+  mermaid,
+  svg,
+  tex,
+  topojson,
+  vl
+}, Symbol.toStringTag, { value: "Module" }));
+require2.resolve = resolve;
+function require2(...specifiers) {
+  return specifiers.length === 1 ? import(
+    /* @vite-ignore */
+    resolve(specifiers[0])
+  ) : Promise.all(specifiers.map((s) => require2(s))).then((modules) => Object.assign({}, ...modules));
+}
+__name(require2, "require");
+function parseNpmSpecifier(specifier) {
+  const parts = specifier.split("/");
+  const namerange = specifier.startsWith("@") ? [parts.shift(), parts.shift()].join("/") : parts.shift();
+  const ranged = namerange.indexOf("@", 1);
+  const name = ranged > 0 ? namerange.slice(0, ranged) : namerange;
+  const range = ranged > 0 ? namerange.slice(ranged) : "";
+  const path = parts.length > 0 ? `/${parts.join("/")}` : "";
+  return { name, range, path };
+}
+__name(parseNpmSpecifier, "parseNpmSpecifier");
+function resolve(_specifier) {
+  const specifier = String(_specifier);
+  if (isProtocol(specifier) || isLocal(specifier))
+    return specifier;
+  const { name, range, path } = parseNpmSpecifier(specifier);
+  return `https://cdn.jsdelivr.net/npm/${name}${range}${path + (isFile(path) || isDirectory(path) ? "" : "/+esm")}`;
+}
+__name(resolve, "resolve");
+function isProtocol(specifier) {
+  return /^\w+:/.test(specifier);
+}
+__name(isProtocol, "isProtocol");
+function isLocal(specifier) {
+  return /^(\.\/|\.\.\/|\/)/.test(specifier);
+}
+__name(isLocal, "isLocal");
+function isFile(specifier) {
+  return /(\.\w*)$/.test(specifier);
+}
+__name(isFile, "isFile");
+function isDirectory(specifier) {
+  return /(\/)$/.test(specifier);
+}
+__name(isDirectory, "isDirectory");
+const aapl = /* @__PURE__ */ __name(() => csv(dataset("aapl.csv")), "aapl");
+const alphabet = /* @__PURE__ */ __name(() => csv(dataset("alphabet.csv")), "alphabet");
+const cars = /* @__PURE__ */ __name(() => csv(dataset("cars.csv")), "cars");
+const citywages = /* @__PURE__ */ __name(() => csv(dataset("citywages.csv")), "citywages");
+const diamonds = /* @__PURE__ */ __name(() => csv(dataset("diamonds.csv")), "diamonds");
+const flare = /* @__PURE__ */ __name(() => csv(dataset("flare.csv")), "flare");
+const industries = /* @__PURE__ */ __name(() => csv(dataset("industries.csv")), "industries");
+const miserables = /* @__PURE__ */ __name(() => json(dataset("miserables.json")), "miserables");
+const olympians = /* @__PURE__ */ __name(() => csv(dataset("olympians.csv")), "olympians");
+const penguins = /* @__PURE__ */ __name(() => csv(dataset("penguins.csv")), "penguins");
+const pizza = /* @__PURE__ */ __name(() => csv(dataset("pizza.csv")), "pizza");
+const weather = /* @__PURE__ */ __name(() => csv(dataset("weather.csv")), "weather");
+function dataset(name) {
+  return `https://cdn.jsdelivr.net/npm/@observablehq/sample-datasets/${name}`;
+}
+__name(dataset, "dataset");
+async function json(url) {
+  const response = await fetch(url);
+  if (!response.ok)
+    throw new Error(`unable to fetch ${url}: status ${response.status}`);
+  return response.json();
+}
+__name(json, "json");
+async function text(url) {
+  const response = await fetch(url);
+  if (!response.ok)
+    throw new Error(`unable to fetch ${url}: status ${response.status}`);
+  return response.text();
+}
+__name(text, "text");
+async function csv(url, typed) {
+  const [contents, d32] = await Promise.all([text(url), import("https://cdn.jsdelivr.net/npm/d3-dsv/+esm")]);
+  return d32.csvParse(contents, d32.autoType);
+}
+__name(csv, "csv");
+const sampleDatasets = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  aapl,
+  alphabet,
+  cars,
+  citywages,
+  diamonds,
+  flare,
+  industries,
+  miserables,
+  olympians,
+  penguins,
+  pizza,
+  weather
+}, Symbol.toStringTag, { value: "Module" }));
+const root = document.querySelector("main") ?? document.body;
+const library = {
+  now: /* @__PURE__ */ __name(() => now(), "now"),
+  width: /* @__PURE__ */ __name(() => width(root), "width"),
+  DatabaseClient: /* @__PURE__ */ __name(() => DatabaseClient, "DatabaseClient"),
+  FileAttachment: /* @__PURE__ */ __name(() => FileAttachment, "FileAttachment"),
+  Generators: /* @__PURE__ */ __name(() => Generators, "Generators"),
+  Mutable: /* @__PURE__ */ __name(() => Mutable, "Mutable"),
+  DOM: /* @__PURE__ */ __name(() => DOM, "DOM"),
+  // deprecated!
+  require: /* @__PURE__ */ __name(() => require2, "require"),
+  // deprecated!
+  __ojs_observer: /* @__PURE__ */ __name(() => () => new Observer(), "__ojs_observer"),
+  ...recommendedLibraries,
+  ...sampleDatasets
+};
+let NotebookRuntime$1 = (_a = class {
+  constructor(builtins = library) {
+    Object.defineProperty(this, "runtime", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "main", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    const runtime = new Runtime({ ...builtins, __ojs_runtime: /* @__PURE__ */ __name(() => runtime, "__ojs_runtime") });
+    this.runtime = Object.assign(runtime, { fileAttachments });
+    this.main = runtime.module();
+  }
+  define(state, definition, observer) {
+    define(this.main, state, definition, observer);
+  }
+}, __name(_a, "NotebookRuntime"), _a);
+const defaultNotebook = new NotebookRuntime$1();
+defaultNotebook.runtime;
+const main = defaultNotebook.main;
+defaultNotebook.define.bind(defaultNotebook);
+main.constructor.prototype.defines = function(name) {
+  return this._scope.has(name) || this._builtins.has(name) || this._runtime._builtin._scope.has(name);
+};
+const _NotebookRuntime = class _NotebookRuntime extends NotebookRuntime$1 {
+  stateById = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  has(cellId) {
+    return this.stateById.has(cellId);
+  }
+  async add(cellId, definition, placeholderDiv) {
+    let state = this.stateById.get(cellId);
+    if (state) {
+      this.remove(cellId);
+    }
+    state = { root: placeholderDiv, expanded: [], variables: [] };
+    this.stateById.set(cellId, state);
+    this.define(state, definition);
+    await this.runtime._computeNow();
+  }
+  async remove(cellId) {
+    const state = this.stateById.get(cellId);
+    if (!state) return;
+    [...state.variables].forEach((v) => v.delete());
+    this.stateById.delete(cellId);
+    state.root?.remove();
+    await this.runtime._computeNow();
+  }
+  async removeAll() {
+    const keys = [...this.stateById.keys()];
+    for (const key of keys) {
+      this.remove(key);
+    }
+    await this.runtime._computeNow();
+  }
+  render(definitions, target) {
+    definitions.forEach((definition) => {
+      const placeholderDiv = document.createElement("div");
+      placeholderDiv.id = `cell-${definition.id}`;
+      placeholderDiv.className = "observablehq observablehq--cell";
+      this.stateById.set(definition.id, { root: placeholderDiv, expanded: [], variables: [] });
+      this.define(this.stateById.get(definition.id), definition);
+      target.appendChild(placeholderDiv);
+    });
+  }
+};
+__name(_NotebookRuntime, "NotebookRuntime");
+let NotebookRuntime = _NotebookRuntime;
+export {
+  NotebookRuntime
+};
+//# sourceMappingURL=runtime.js.map
+!function(){"use strict";try{if("undefined"!=typeof document){var e=document.createElement("style");e.appendChild(document.createTextNode('@import"https://cdn.jsdelivr.net/npm/@observablehq/inputs/dist/index.css";:root{--serif: "Source Serif 4", "Iowan Old Style", "Apple Garamond", "Palatino Linotype", "Times New Roman", "Droid Serif", Times, serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";--sans-serif: "Inter", -apple-system, BlinkMacSystemFont, "avenir next", avenir, helvetica, "helvetica neue", ubuntu, roboto, noto, "segoe ui", arial, sans-serif;--monospace: "Spline Sans Mono", Menlo, Consolas, monospace;--monospace-font: 14px/1.5 var(--monospace);--max-width: 960px }html{font:17px/1.5 var(--serif);-webkit-text-size-adjust:100%;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;background:var(--theme-background);color:var(--theme-foreground);margin:16px 0;padding:16px 24px}body{margin:auto;max-width:var(--max-width)}h1,h2,h3,h4,h5,h6{color:var(--theme-foreground-alt);font-weight:700;line-height:1.15;margin-top:0;margin-bottom:.25rem;text-wrap:balance}h2+p,h3+p,h4+p,h2+table,h3+table,h4+table{margin-top:0}.observablehq:first-of-type h1+h2{color:var(--theme-foreground);font-size:20px;font-style:italic;font-weight:400;margin-bottom:1rem}a[href]{color:var(--theme-foreground-focus);text-decoration:none}a[href]:hover,a[href]:focus{text-decoration:underline}pre,code,tt{font-family:var(--monospace);font-size:82.35294117%}pre code,figcaption code{font-size:inherit}pre[data-language]{position:relative}pre[data-language]:before{content:attr(data-language);float:right;margin:-4px -8px -4px -4px;padding:4px;font-size:12px;line-height:21px;color:var(--theme-foreground-muted)}h1 code,h2 code,h3 code,h4 code,h5 code,h6 code{font-size:88.235294117%}h2[id] a[href],h3[id] a[href]{color:inherit}pre{line-height:1.5}img{max-width:100%}p,table,figure,figcaption,h1,h2,h3,h4,h5,h6,.katex-display{max-width:640px}blockquote,ol,ul{max-width:600px}blockquote{margin:1rem 1.5rem}ul,ol{padding-left:28px}hr{height:1px;margin:1rem 0;padding:1rem 0;border:none;background:no-repeat center/100% 1px linear-gradient(to right,var(--theme-foreground-faintest),var(--theme-foreground-faintest))}pre{background-color:var(--theme-background-alt);border-radius:4px;margin:1rem -1rem;min-height:1.5em;padding:4px 1rem;overflow-x:auto;box-sizing:border-box;white-space:pre-wrap}input:not([type]),input[type=email],input[type=number],input[type=password],input[type=range],input[type=search],input[type=tel],input[type=text],input[type=url]{width:240px}input,canvas,button{vertical-align:middle}button,input,textarea{accent-color:var(--theme-foreground-focus)}table{width:100%;border-collapse:collapse;font:13px/1.2 var(--sans-serif)}table pre,table code,table tt{font-size:inherit;line-height:inherit}th>pre:only-child,td>pre:only-child{margin:0;padding:0}th{color:var(--theme-foreground);text-align:left;vertical-align:bottom}td{color:var(--theme-foreground-alt);vertical-align:top}th,td{padding:3px 6.5px 3px 0}th:last-child,td:last-child{padding-right:0}tr:not(:last-child){border-bottom:solid 1px var(--theme-foreground-faintest)}thead tr{border-bottom:solid 1px var(--theme-foreground-fainter)}figure,table{margin:1rem 0}figure img{max-width:100%}figure>h2,figure>h3{font-family:var(--sans-serif)}figure>h2{font-size:20px}figure>h3{font-size:16px;font-weight:400}figcaption{font:small var(--sans-serif);color:var(--theme-foreground-muted)}.observablehq--collapsed,.observablehq--expanded.observablehq--inspect a{cursor:pointer}.observablehq--caret{margin-right:4px;vertical-align:baseline}.observablehq--field{text-indent:-1rem;margin-left:1rem}.observablehq--inspect{font:var(--monospace-font);overflow-x:auto;white-space:pre;display:block;padding:2px 0}.observablehq--inspect.observablehq--import{white-space:normal}.observablehq--inspect::-webkit-scrollbar{display:none}.observablehq--error .observablehq--inspect{word-break:break-all;white-space:pre-wrap}.observablehq--string-expand{margin-left:6px;padding:2px 6px;border-radius:2px;font-size:80%;background:var(--theme-background-alt);cursor:pointer;vertical-align:middle}.observablehq--keyword{color:var(--syntax-keyword)}.observablehq--index,.observablehq--key{color:var(--syntax-definition)}.observablehq--symbol,.observablehq--regexp,.observablehq--string{color:var(--syntax-string)}.observablehq--null{color:var(--syntax-keyword)}.observablehq--undefined{color:var(--syntax-variable)}.observablehq--prototype-key{color:var(--syntax-comment)}.observablehq--bigint,.observablehq--boolean,.observablehq--date,.observablehq--forbidden,.observablehq--number{color:var(--syntax-literal)}.observablehq--error{color:var(--theme-error)}.observablehq--cell{margin:17px 0;min-height:1px}.tok-link{color:var(--syntax-link)}.tok-strong{font-weight:600}.tok-emphasis{font-style:italic}.tok-keyword{color:var(--syntax-keyword)}.tok-atom{color:var(--syntax-atom)}.tok-literal{color:var(--syntax-literal)}.tok-string{color:var(--syntax-string)}.tok-comment{color:var(--syntax-comment)}.tok-invalid{color:var(--syntax-invalid)}.tok-variable{color:var(--syntax-variable)}.tok-definition{color:var(--syntax-definition)}.tok-meta{color:var(--syntax-meta)}.plot-d6a7b5{--plot-background: var(--theme-background)}p .plot-d6a7b5{display:inline-block}.observablehq--cell:empty{min-height:0}.observablehq--cell:not(:empty)+pre{margin-top:-11px}:root{--syntax-link: var(--theme-foreground-focus);--syntax-keyword: #e36209;--syntax-atom: #032f62;--syntax-literal: #6f42c1;--syntax-string: #22863a;--syntax-comment: var(--theme-foreground-muted);--syntax-invalid: var(--theme-error);--syntax-definition: #005cc5;--syntax-variable: var(--theme-foreground-alt);--syntax-meta: #d73a49}:root{--theme-background-b: color-mix(in srgb, var(--theme-foreground) 4%, var(--theme-background-a));--theme-background: var(--theme-background-a);--theme-background-alt: var(--theme-background-b);--theme-foreground-alt: color-mix(in srgb, var(--theme-foreground) 90%, var(--theme-background-a));--theme-foreground-muted: color-mix(in srgb, var(--theme-foreground) 60%, var(--theme-background-a));--theme-foreground-faint: color-mix(in srgb, var(--theme-foreground) 50%, var(--theme-background-a));--theme-foreground-fainter: color-mix(in srgb, var(--theme-foreground) 30%, var(--theme-background-a));--theme-foreground-faintest: color-mix(in srgb, var(--theme-foreground) 14%, var(--theme-background-a));--theme-error: #e7040f;color-scheme:light}:root{--theme-foreground: #1b1e23;--theme-foreground-focus: #3b5fc0;--theme-background-a: #ffffff}.inputs-3a86ea-table tr:not(:last-child) td,.inputs-3a86ea-table tr:not(:last-child) th{border-bottom-color:var(--theme-foreground-faintest)}.inputs-3a86ea-table thead tr td,.inputs-3a86ea-table thead tr th{border-bottom-color:var(--theme-foreground-fainter)}.inputs-3a86ea-table thead th{background:var(--theme-background)}')),document.head.appendChild(e)}}catch(r){console.error("vite-plugin-css-injected-by-js",r)}}();