docs/source/Leaflet_US_Choropleth.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bc94d6b8-30e0-40ee-9590-1a24de624b19",
   "metadata": {},
   "source": [
    "# Leaflet United States Choropleth Map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "265d4dcb-cab2-42cf-8e6d-1d49dd93f0e4",
   "metadata": {},
   "source": [
    "Leaflet is an open source javascrip library for interactive maps. Used by companies like NPR, Github and Financial Times the **Leaflet United States Chloropleth Map** allows you to make a publication quality choropleth map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b43b0e3-f9b4-4963-b765-af79e4510a4e",
   "metadata": {},
   "source": [
    "### Set Up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4b39df27-645e-4de7-9db1-8ff497f4afbc",
   "metadata": {},
   "outputs": [],
   "source": [
    "from observable_jupyter import embed\n",
    "import pandas as pd\n",
    "import json"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "313c19e6-a998-4bbb-97f7-ab5ba89d5c1c",
   "metadata": {},
   "source": [
    "### Load and Format Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "39242805-ed31-45e5-9af0-fea5e77f349f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>State</th>\n",
       "      <th>RainFall (in)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Mississippi</td>\n",
       "      <td>66.84</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Louisiana</td>\n",
       "      <td>66.23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Alabama</td>\n",
       "      <td>65.06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Tennessee</td>\n",
       "      <td>58.89</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Georgia</td>\n",
       "      <td>57.11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         State  RainFall (in)\n",
       "0  Mississippi          66.84\n",
       "1    Louisiana          66.23\n",
       "2      Alabama          65.06\n",
       "3    Tennessee          58.89\n",
       "4      Georgia          57.11"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rain_df = pd.read_csv(\"Demo_Data/Rain_Data.csv\")\n",
    "rain_df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd38ceac-57f2-4417-9157-bfcf03fe6f01",
   "metadata": {},
   "source": [
    "The following block of code structures the data into a format accepted by Observable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a714a1ae-cd37-464f-a782-e9a247176a57",
   "metadata": {},
   "outputs": [],
   "source": [
    "result = rain_df.to_json(orient=\"records\")\n",
    "parsed = json.loads(result)\n",
    "data = json.dumps(parsed, indent=4)\n",
    "Formated_Data = json.loads(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d43ab992-144a-4f14-a369-be1bf67d2e96",
   "metadata": {},
   "source": [
    "### Embed your data into the visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb75c8ea-e85c-4559-b896-2d1e623a8511",
   "metadata": {},
   "source": [
    "The **Leaflet United States Choropleth Map** consists of two **cells**:<br>\n",
    "\n",
    "1. **map** : Depicts the map and the associated data\n",
    "2. **leaflet** : Depicts the checklist filter tool"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5f819aa-e5c6-42e7-a1f0-fb3ca17135e5",
   "metadata": {},
   "source": [
    "To make your visualization work you will need to access the **input variables**:\n",
    "\n",
    "1. **quantitative_data** : Set equal to your formated data\n",
    "2. **ID_Column** : set equal to the column that contains your state names\n",
    "3. **Quant_Column** : Should be set to the name of the column containing the quantitative data you want to display.\n",
    "4. **toolTip_title** : List of strings where index 0 should discribe the quantitiative data and index 1 should contain units.\n",
    "5. **Levels** : List of length 7 representing different cutoffs for colors depicted on the map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1b3e12d4-0a29-4ec2-96aa-0c3ca5e8dada",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"text-align: right; position: relative\">\n",
       "    \n",
       "<style>\n",
       ".observable-logo {\n",
       "  position: absolute;\n",
       "  bottom: 0;\n",
       "  right: 0;\n",
       "  margin-bottom: 5px;\n",
       "  margin-right: 1px;\n",
       "  transition: background-color 0.2s;\n",
       "}\n",
       ".observable-logo svg {\n",
       "  opacity: 0.5;\n",
       "  transition: opacity 0.2s;\n",
       "}\n",
       ".observable-logo span {\n",
       "  opacity: 0;\n",
       "  transition: opacity 0.2s;\n",
       "  padding-right: .2em;\n",
       "  padding-left: .2em;\n",
       "}\n",
       ".observable-logo:hover {\n",
       "  background-color: white;\n",
       "}\n",
       ".observable-logo:hover span {\n",
       "  opacity: .8;\n",
       "}\n",
       ".observable-logo:hover svg {\n",
       "  opacity: .8;\n",
       "}\n",
       ".observable-link:hover ~ iframe {\n",
       "  outline: solid 1px #E0E0E0;\n",
       "  box-shadow: 0 0 3px;\n",
       "  transition: box-shadow 0.2s;\n",
       "}\n",
       ".observable-link ~ iframe {\n",
       "    outline: none;\n",
       "}\n",
       "/* Colab-only rule - untested */\n",
       "body > .output-area > .output-body {\n",
       "  margin-right: 2px;\n",
       "}\n",
       "</style>\n",
       "<a class=\"observable-link\" href=\"https://observablehq.com/@rstorni/leaflet-map\" target=\"_blank\" style=\"text-decoration: none; color: inherit;\">\n",
       "<div class=\"observable-logo\" style=\"display: flex; align-items: center; justify-content: flex-end;\">\n",
       "<span>Edit @rstorni/leaflet-map on Observable</span>\n",
       "<svg role=\"img\" viewBox=\"0 0 25 28\" width=\"25\" height=\"28\" aria-label=\"Observable\" fill=\"currentColor\" class=\"near-black\" style=\"width: 18px;\"><path d=\"M12.5 22.6667C11.3458 22.6667 10.3458 22.4153 9.5 21.9127C8.65721 21.412 7.98339 20.7027 7.55521 19.8654C7.09997 18.9942 6.76672 18.0729 6.56354 17.1239C6.34796 16.0947 6.24294 15.0483 6.25 14C6.25 13.1699 6.30417 12.3764 6.41354 11.6176C6.52188 10.8598 6.72292 10.0894 7.01563 9.30748C7.30833 8.52555 7.68542 7.84763 8.14479 7.27274C8.62304 6.68378 9.24141 6.20438 9.95208 5.87163C10.6979 5.51244 11.5458 5.33333 12.5 5.33333C13.6542 5.33333 14.6542 5.58467 15.5 6.08733C16.3428 6.588 17.0166 7.29733 17.4448 8.13459C17.8969 8.99644 18.2271 9.9103 18.4365 10.8761C18.6448 11.841 18.75 12.883 18.75 14C18.75 14.8301 18.6958 15.6236 18.5865 16.3824C18.4699 17.1702 18.2639 17.9446 17.9719 18.6925C17.6698 19.4744 17.2948 20.1524 16.8427 20.7273C16.3906 21.3021 15.7927 21.7692 15.0479 22.1284C14.3031 22.4876 13.4542 22.6667 12.5 22.6667ZM14.7063 16.2945C15.304 15.6944 15.6365 14.864 15.625 14C15.625 13.1073 15.326 12.3425 14.7292 11.7055C14.1313 11.0685 13.3885 10.75 12.5 10.75C11.6115 10.75 10.8688 11.0685 10.2708 11.7055C9.68532 12.3123 9.36198 13.1405 9.375 14C9.375 14.8927 9.67396 15.6575 10.2708 16.2945C10.8688 16.9315 11.6115 17.25 12.5 17.25C13.3885 17.25 14.124 16.9315 14.7063 16.2945ZM12.5 27C19.4031 27 25 21.1792 25 14C25 6.82075 19.4031 1 12.5 1C5.59687 1 0 6.82075 0 14C0 21.1792 5.59687 27 12.5 27Z\" fill=\"currentColor\"></path></svg>\n",
       "\n",
       "</div>\n",
       "</a>\n",
       "\n",
       "    <iframe id=\"observable-embed-div-29285319479051364\" sandbox=\"allow-scripts\" style=\"overflow: auto; min-width: 100%; width: 0px;\" frameBorder=\"0\"></iframe>\n",
       "</div>\n",
       "<script>\n",
       "var ObservableJupyterWrapper = (function (exports) {\n",
       "  'use strict';\n",
       "\n",
       "  function getFrameByEvent(event) {\n",
       "    return [...document.getElementsByTagName(\"iframe\")].filter(iframe => {\n",
       "      return iframe.contentWindow === event.source;\n",
       "    })[0];\n",
       "  }\n",
       "\n",
       "  // Each embed gets its own event listener.\n",
       "  function listenToSize(iframe) {\n",
       "    function onMessage(msg) {\n",
       "      if (!document.body.contains(iframe)) {\n",
       "        // iframe is gone\n",
       "        removeEventListener(\"message\", onMessage);\n",
       "      }\n",
       "      const senderIframe = getFrameByEvent(msg);\n",
       "      if (msg.data.type === \"iframeSize\" && senderIframe === iframe) {\n",
       "        iframe.height = msg.data.height;\n",
       "      }\n",
       "    }\n",
       "\n",
       "    window.addEventListener(\"message\", onMessage);\n",
       "  }\n",
       "\n",
       "  exports.listenToSize = listenToSize;\n",
       "\n",
       "  return exports;\n",
       "\n",
       "}({}));\n",
       "\n",
       "</script>\n",
       "<script>\n",
       "iframeSrc = `<!DOCTYPE html>\n",
       "<link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/@observablehq/inspector@3/dist/inspector.css\">\n",
       "<style>\n",
       "body {\n",
       "  margin: 0;\n",
       "}\n",
       "</style>\n",
       "OPENSCRIPT\n",
       "var ObservableJupyterIframe = (function (exports) {\n",
       "  'use strict';\n",
       "\n",
       "  function dispatch(node, type, detail) {\n",
       "    detail = detail || {};\n",
       "    var document = node.ownerDocument, event = document.defaultView.CustomEvent;\n",
       "    if (typeof event === \"function\") {\n",
       "      event = new event(type, {detail: detail});\n",
       "    } else {\n",
       "      event = document.createEvent(\"Event\");\n",
       "      event.initEvent(type, false, false);\n",
       "      event.detail = detail;\n",
       "    }\n",
       "    node.dispatchEvent(event);\n",
       "  }\n",
       "\n",
       "  // TODO https://twitter.com/mbostock/status/702737065121742848\n",
       "  function isarray(value) {\n",
       "    return Array.isArray(value)\n",
       "        || value instanceof Int8Array\n",
       "        || value instanceof Int16Array\n",
       "        || value instanceof Int32Array\n",
       "        || value instanceof Uint8Array\n",
       "        || value instanceof Uint8ClampedArray\n",
       "        || value instanceof Uint16Array\n",
       "        || value instanceof Uint32Array\n",
       "        || value instanceof Float32Array\n",
       "        || value instanceof Float64Array;\n",
       "  }\n",
       "\n",
       "  // Non-integer keys in arrays, e.g. [1, 2, 0.5: \"value\"].\n",
       "  function isindex(key) {\n",
       "    return key === (key | 0) + \"\";\n",
       "  }\n",
       "\n",
       "  function inspectName(name) {\n",
       "    const n = document.createElement(\"span\");\n",
       "    n.className = \"observablehq--cellname\";\n",
       "    n.textContent = \\`\\${name} = \\`;\n",
       "    return n;\n",
       "  }\n",
       "\n",
       "  const symbolToString = Symbol.prototype.toString;\n",
       "\n",
       "  // Symbols do not coerce to strings; they must be explicitly converted.\n",
       "  function formatSymbol(symbol) {\n",
       "    return symbolToString.call(symbol);\n",
       "  }\n",
       "\n",
       "  const {getOwnPropertySymbols, prototype: {hasOwnProperty}} = Object;\n",
       "  const {toStringTag} = Symbol;\n",
       "\n",
       "  const FORBIDDEN = {};\n",
       "\n",
       "  const symbolsof = getOwnPropertySymbols;\n",
       "\n",
       "  function isown(object, key) {\n",
       "    return hasOwnProperty.call(object, key);\n",
       "  }\n",
       "\n",
       "  function tagof(object) {\n",
       "    return object[toStringTag]\n",
       "        || (object.constructor && object.constructor.name)\n",
       "        || \"Object\";\n",
       "  }\n",
       "\n",
       "  function valueof(object, key) {\n",
       "    try {\n",
       "      const value = object[key];\n",
       "      if (value) value.constructor; // Test for SecurityError.\n",
       "      return value;\n",
       "    } catch (ignore) {\n",
       "      return FORBIDDEN;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  const SYMBOLS = [\n",
       "    { symbol: \"@@__IMMUTABLE_INDEXED__@@\", name: \"Indexed\", modifier: true },\n",
       "    { symbol: \"@@__IMMUTABLE_KEYED__@@\", name: \"Keyed\", modifier: true },\n",
       "    { symbol: \"@@__IMMUTABLE_LIST__@@\", name: \"List\", arrayish: true },\n",
       "    { symbol: \"@@__IMMUTABLE_MAP__@@\", name: \"Map\" },\n",
       "    {\n",
       "      symbol: \"@@__IMMUTABLE_ORDERED__@@\",\n",
       "      name: \"Ordered\",\n",
       "      modifier: true,\n",
       "      prefix: true\n",
       "    },\n",
       "    { symbol: \"@@__IMMUTABLE_RECORD__@@\", name: \"Record\" },\n",
       "    {\n",
       "      symbol: \"@@__IMMUTABLE_SET__@@\",\n",
       "      name: \"Set\",\n",
       "      arrayish: true,\n",
       "      setish: true\n",
       "    },\n",
       "    { symbol: \"@@__IMMUTABLE_STACK__@@\", name: \"Stack\", arrayish: true }\n",
       "  ];\n",
       "\n",
       "  function immutableName(obj) {\n",
       "    try {\n",
       "      let symbols = SYMBOLS.filter(({ symbol }) => obj[symbol] === true);\n",
       "      if (!symbols.length) return;\n",
       "\n",
       "      const name = symbols.find(s => !s.modifier);\n",
       "      const prefix =\n",
       "        name.name === \"Map\" && symbols.find(s => s.modifier && s.prefix);\n",
       "\n",
       "      const arrayish = symbols.some(s => s.arrayish);\n",
       "      const setish = symbols.some(s => s.setish);\n",
       "\n",
       "      return {\n",
       "        name: \\`\\${prefix ? prefix.name : \"\"}\\${name.name}\\`,\n",
       "        symbols,\n",
       "        arrayish: arrayish && !setish,\n",
       "        setish\n",
       "      };\n",
       "    } catch (e) {\n",
       "      return null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  const {getPrototypeOf, getOwnPropertyDescriptors} = Object;\n",
       "  const objectPrototype = getPrototypeOf({});\n",
       "\n",
       "  function inspectExpanded(object, _, name, proto) {\n",
       "    let arrayish = isarray(object);\n",
       "    let tag, fields, next, n;\n",
       "\n",
       "    if (object instanceof Map) {\n",
       "      if (object instanceof object.constructor) {\n",
       "        tag = \\`Map(\\${object.size})\\`;\n",
       "        fields = iterateMap;\n",
       "      } else { // avoid incompatible receiver error for prototype\n",
       "        tag = \"Map()\";\n",
       "        fields = iterateObject;\n",
       "      }\n",
       "    } else if (object instanceof Set) {\n",
       "      if (object instanceof object.constructor) {\n",
       "        tag = \\`Set(\\${object.size})\\`;\n",
       "        fields = iterateSet;\n",
       "      } else { // avoid incompatible receiver error for prototype\n",
       "        tag = \"Set()\";\n",
       "        fields = iterateObject;\n",
       "      }\n",
       "    } else if (arrayish) {\n",
       "      tag = \\`\\${object.constructor.name}(\\${object.length})\\`;\n",
       "      fields = iterateArray;\n",
       "    } else if ((n = immutableName(object))) {\n",
       "      tag = \\`Immutable.\\${n.name}\\${n.name === \"Record\" ? \"\" : \\`(\\${object.size})\\`}\\`;\n",
       "      arrayish = n.arrayish;\n",
       "      fields = n.arrayish\n",
       "        ? iterateImArray\n",
       "        : n.setish\n",
       "        ? iterateImSet\n",
       "        : iterateImObject;\n",
       "    } else if (proto) {\n",
       "      tag = tagof(object);\n",
       "      fields = iterateProto;\n",
       "    } else {\n",
       "      tag = tagof(object);\n",
       "      fields = iterateObject;\n",
       "    }\n",
       "\n",
       "    const span = document.createElement(\"span\");\n",
       "    span.className = \"observablehq--expanded\";\n",
       "    if (name) {\n",
       "      span.appendChild(inspectName(name));\n",
       "    }\n",
       "    const a = span.appendChild(document.createElement(\"a\"));\n",
       "    a.innerHTML = \\`<svg width=8 height=8 class='observablehq--caret'>\n",
       "    <path d='M4 7L0 1h8z' fill='currentColor' />\n",
       "  </svg>\\`;\n",
       "    a.appendChild(document.createTextNode(\\`\\${tag}\\${arrayish ? \" [\" : \" {\"}\\`));\n",
       "    a.addEventListener(\"mouseup\", function(event) {\n",
       "      event.stopPropagation();\n",
       "      replace(span, inspectCollapsed(object, null, name, proto));\n",
       "    });\n",
       "\n",
       "    fields = fields(object);\n",
       "    for (let i = 0; !(next = fields.next()).done && i < 20; ++i) {\n",
       "      span.appendChild(next.value);\n",
       "    }\n",
       "\n",
       "    if (!next.done) {\n",
       "      const a = span.appendChild(document.createElement(\"a\"));\n",
       "      a.className = \"observablehq--field\";\n",
       "      a.style.display = \"block\";\n",
       "      a.appendChild(document.createTextNode(\\`  … more\\`));\n",
       "      a.addEventListener(\"mouseup\", function(event) {\n",
       "        event.stopPropagation();\n",
       "        span.insertBefore(next.value, span.lastChild.previousSibling);\n",
       "        for (let i = 0; !(next = fields.next()).done && i < 19; ++i) {\n",
       "          span.insertBefore(next.value, span.lastChild.previousSibling);\n",
       "        }\n",
       "        if (next.done) span.removeChild(span.lastChild.previousSibling);\n",
       "        dispatch(span, \"load\");\n",
       "      });\n",
       "    }\n",
       "\n",
       "    span.appendChild(document.createTextNode(arrayish ? \"]\" : \"}\"));\n",
       "\n",
       "    return span;\n",
       "  }\n",
       "\n",
       "  function* iterateMap(map) {\n",
       "    for (const [key, value] of map) {\n",
       "      yield formatMapField(key, value);\n",
       "    }\n",
       "    yield* iterateObject(map);\n",
       "  }\n",
       "\n",
       "  function* iterateSet(set) {\n",
       "    for (const value of set) {\n",
       "      yield formatSetField(value);\n",
       "    }\n",
       "    yield* iterateObject(set);\n",
       "  }\n",
       "\n",
       "  function* iterateImSet(set) {\n",
       "    for (const value of set) {\n",
       "      yield formatSetField(value);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* iterateArray(array) {\n",
       "    for (let i = 0, n = array.length; i < n; ++i) {\n",
       "      if (i in array) {\n",
       "        yield formatField(i, valueof(array, i), \"observablehq--index\");\n",
       "      }\n",
       "    }\n",
       "    for (const key in array) {\n",
       "      if (!isindex(key) && isown(array, key)) {\n",
       "        yield formatField(key, valueof(array, key), \"observablehq--key\");\n",
       "      }\n",
       "    }\n",
       "    for (const symbol of symbolsof(array)) {\n",
       "      yield formatField(\n",
       "        formatSymbol(symbol),\n",
       "        valueof(array, symbol),\n",
       "        \"observablehq--symbol\"\n",
       "      );\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* iterateImArray(array) {\n",
       "    let i1 = 0;\n",
       "    for (const n = array.size; i1 < n; ++i1) {\n",
       "      yield formatField(i1, array.get(i1), true);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* iterateProto(object) {\n",
       "    for (const key in getOwnPropertyDescriptors(object)) {\n",
       "      yield formatField(key, valueof(object, key), \"observablehq--key\");\n",
       "    }\n",
       "    for (const symbol of symbolsof(object)) {\n",
       "      yield formatField(\n",
       "        formatSymbol(symbol),\n",
       "        valueof(object, symbol),\n",
       "        \"observablehq--symbol\"\n",
       "      );\n",
       "    }\n",
       "\n",
       "    const proto = getPrototypeOf(object);\n",
       "    if (proto && proto !== objectPrototype) {\n",
       "      yield formatPrototype(proto);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* iterateObject(object) {\n",
       "    for (const key in object) {\n",
       "      if (isown(object, key)) {\n",
       "        yield formatField(key, valueof(object, key), \"observablehq--key\");\n",
       "      }\n",
       "    }\n",
       "    for (const symbol of symbolsof(object)) {\n",
       "      yield formatField(\n",
       "        formatSymbol(symbol),\n",
       "        valueof(object, symbol),\n",
       "        \"observablehq--symbol\"\n",
       "      );\n",
       "    }\n",
       "\n",
       "    const proto = getPrototypeOf(object);\n",
       "    if (proto && proto !== objectPrototype) {\n",
       "      yield formatPrototype(proto);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* iterateImObject(object) {\n",
       "    for (const [key, value] of object) {\n",
       "      yield formatField(key, value, \"observablehq--key\");\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function formatPrototype(value) {\n",
       "    const item = document.createElement(\"div\");\n",
       "    const span = item.appendChild(document.createElement(\"span\"));\n",
       "    item.className = \"observablehq--field\";\n",
       "    span.className = \"observablehq--prototype-key\";\n",
       "    span.textContent = \\`  <prototype>\\`;\n",
       "    item.appendChild(document.createTextNode(\": \"));\n",
       "    item.appendChild(inspect(value, undefined, undefined, undefined, true));\n",
       "    return item;\n",
       "  }\n",
       "\n",
       "  function formatField(key, value, className) {\n",
       "    const item = document.createElement(\"div\");\n",
       "    const span = item.appendChild(document.createElement(\"span\"));\n",
       "    item.className = \"observablehq--field\";\n",
       "    span.className = className;\n",
       "    span.textContent = \\`  \\${key}\\`;\n",
       "    item.appendChild(document.createTextNode(\": \"));\n",
       "    item.appendChild(inspect(value));\n",
       "    return item;\n",
       "  }\n",
       "\n",
       "  function formatMapField(key, value) {\n",
       "    const item = document.createElement(\"div\");\n",
       "    item.className = \"observablehq--field\";\n",
       "    item.appendChild(document.createTextNode(\"  \"));\n",
       "    item.appendChild(inspect(key));\n",
       "    item.appendChild(document.createTextNode(\" => \"));\n",
       "    item.appendChild(inspect(value));\n",
       "    return item;\n",
       "  }\n",
       "\n",
       "  function formatSetField(value) {\n",
       "    const item = document.createElement(\"div\");\n",
       "    item.className = \"observablehq--field\";\n",
       "    item.appendChild(document.createTextNode(\"  \"));\n",
       "    item.appendChild(inspect(value));\n",
       "    return item;\n",
       "  }\n",
       "\n",
       "  function hasSelection(elem) {\n",
       "    const sel = window.getSelection();\n",
       "    return (\n",
       "      sel.type === \"Range\" &&\n",
       "      (sel.containsNode(elem, true) ||\n",
       "        sel.anchorNode.isSelfOrDescendant(elem) ||\n",
       "        sel.focusNode.isSelfOrDescendant(elem))\n",
       "    );\n",
       "  }\n",
       "\n",
       "  function inspectCollapsed(object, shallow, name, proto) {\n",
       "    let arrayish = isarray(object);\n",
       "    let tag, fields, next, n;\n",
       "\n",
       "    if (object instanceof Map) {\n",
       "      if (object instanceof object.constructor) {\n",
       "        tag = \\`Map(\\${object.size})\\`;\n",
       "        fields = iterateMap\\$1;\n",
       "      } else { // avoid incompatible receiver error for prototype\n",
       "        tag = \"Map()\";\n",
       "        fields = iterateObject\\$1;\n",
       "      }\n",
       "    } else if (object instanceof Set) {\n",
       "      if (object instanceof object.constructor) {\n",
       "        tag = \\`Set(\\${object.size})\\`;\n",
       "        fields = iterateSet\\$1;\n",
       "      } else { // avoid incompatible receiver error for prototype\n",
       "        tag = \"Set()\";\n",
       "        fields = iterateObject\\$1;\n",
       "      }\n",
       "    } else if (arrayish) {\n",
       "      tag = \\`\\${object.constructor.name}(\\${object.length})\\`;\n",
       "      fields = iterateArray\\$1;\n",
       "    } else if ((n = immutableName(object))) {\n",
       "      tag = \\`Immutable.\\${n.name}\\${n.name === 'Record' ? '' : \\`(\\${object.size})\\`}\\`;\n",
       "      arrayish = n.arrayish;\n",
       "      fields = n.arrayish ? iterateImArray\\$1 : n.setish ? iterateImSet\\$1 : iterateImObject\\$1;\n",
       "    } else {\n",
       "      tag = tagof(object);\n",
       "      fields = iterateObject\\$1;\n",
       "    }\n",
       "\n",
       "    if (shallow) {\n",
       "      const span = document.createElement(\"span\");\n",
       "      span.className = \"observablehq--shallow\";\n",
       "      if (name) {\n",
       "        span.appendChild(inspectName(name));\n",
       "      }\n",
       "      span.appendChild(document.createTextNode(tag));\n",
       "      span.addEventListener(\"mouseup\", function(event) {\n",
       "        if (hasSelection(span)) return;\n",
       "        event.stopPropagation();\n",
       "        replace(span, inspectCollapsed(object));\n",
       "      });\n",
       "      return span;\n",
       "    }\n",
       "\n",
       "    const span = document.createElement(\"span\");\n",
       "    span.className = \"observablehq--collapsed\";\n",
       "    if (name) {\n",
       "      span.appendChild(inspectName(name));\n",
       "    }\n",
       "    const a = span.appendChild(document.createElement(\"a\"));\n",
       "    a.innerHTML = \\`<svg width=8 height=8 class='observablehq--caret'>\n",
       "    <path d='M7 4L1 8V0z' fill='currentColor' />\n",
       "  </svg>\\`;\n",
       "    a.appendChild(document.createTextNode(\\`\\${tag}\\${arrayish ? \" [\" : \" {\"}\\`));\n",
       "    span.addEventListener(\"mouseup\", function(event) {\n",
       "      if (hasSelection(span)) return;\n",
       "      event.stopPropagation();\n",
       "      replace(span, inspectExpanded(object, null, name, proto));\n",
       "    }, true);\n",
       "\n",
       "    fields = fields(object);\n",
       "    for (let i = 0; !(next = fields.next()).done && i < 20; ++i) {\n",
       "      if (i > 0) span.appendChild(document.createTextNode(\", \"));\n",
       "      span.appendChild(next.value);\n",
       "    }\n",
       "\n",
       "    if (!next.done) span.appendChild(document.createTextNode(\", …\"));\n",
       "    span.appendChild(document.createTextNode(arrayish ? \"]\" : \"}\"));\n",
       "\n",
       "    return span;\n",
       "  }\n",
       "\n",
       "  function* iterateMap\\$1(map) {\n",
       "    for (const [key, value] of map) {\n",
       "      yield formatMapField\\$1(key, value);\n",
       "    }\n",
       "    yield* iterateObject\\$1(map);\n",
       "  }\n",
       "\n",
       "  function* iterateSet\\$1(set) {\n",
       "    for (const value of set) {\n",
       "      yield inspect(value, true);\n",
       "    }\n",
       "    yield* iterateObject\\$1(set);\n",
       "  }\n",
       "\n",
       "  function* iterateImSet\\$1(set) {\n",
       "    for (const value of set) {\n",
       "      yield inspect(value, true);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* iterateImArray\\$1(array) {\n",
       "    let i0 = -1, i1 = 0;\n",
       "    for (const n = array.size; i1 < n; ++i1) {\n",
       "      if (i1 > i0 + 1) yield formatEmpty(i1 - i0 - 1);\n",
       "      yield inspect(array.get(i1), true);\n",
       "      i0 = i1;\n",
       "    }\n",
       "    if (i1 > i0 + 1) yield formatEmpty(i1 - i0 - 1);\n",
       "  }\n",
       "\n",
       "  function* iterateArray\\$1(array) {\n",
       "    let i0 = -1, i1 = 0;\n",
       "    for (const n = array.length; i1 < n; ++i1) {\n",
       "      if (i1 in array) {\n",
       "        if (i1 > i0 + 1) yield formatEmpty(i1 - i0 - 1);\n",
       "        yield inspect(valueof(array, i1), true);\n",
       "        i0 = i1;\n",
       "      }\n",
       "    }\n",
       "    if (i1 > i0 + 1) yield formatEmpty(i1 - i0 - 1);\n",
       "    for (const key in array) {\n",
       "      if (!isindex(key) && isown(array, key)) {\n",
       "        yield formatField\\$1(key, valueof(array, key), \"observablehq--key\");\n",
       "      }\n",
       "    }\n",
       "    for (const symbol of symbolsof(array)) {\n",
       "      yield formatField\\$1(formatSymbol(symbol), valueof(array, symbol), \"observablehq--symbol\");\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* iterateObject\\$1(object) {\n",
       "    for (const key in object) {\n",
       "      if (isown(object, key)) {\n",
       "        yield formatField\\$1(key, valueof(object, key), \"observablehq--key\");\n",
       "      }\n",
       "    }\n",
       "    for (const symbol of symbolsof(object)) {\n",
       "      yield formatField\\$1(formatSymbol(symbol), valueof(object, symbol), \"observablehq--symbol\");\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* iterateImObject\\$1(object) {\n",
       "    for (const [key, value] of object) {\n",
       "      yield formatField\\$1(key, value, \"observablehq--key\");\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function formatEmpty(e) {\n",
       "    const span = document.createElement(\"span\");\n",
       "    span.className = \"observablehq--empty\";\n",
       "    span.textContent = e === 1 ? \"empty\" : \\`empty × \\${e}\\`;\n",
       "    return span;\n",
       "  }\n",
       "\n",
       "  function formatField\\$1(key, value, className) {\n",
       "    const fragment = document.createDocumentFragment();\n",
       "    const span = fragment.appendChild(document.createElement(\"span\"));\n",
       "    span.className = className;\n",
       "    span.textContent = key;\n",
       "    fragment.appendChild(document.createTextNode(\": \"));\n",
       "    fragment.appendChild(inspect(value, true));\n",
       "    return fragment;\n",
       "  }\n",
       "\n",
       "  function formatMapField\\$1(key, value) {\n",
       "    const fragment = document.createDocumentFragment();\n",
       "    fragment.appendChild(inspect(key, true));\n",
       "    fragment.appendChild(document.createTextNode(\" => \"));\n",
       "    fragment.appendChild(inspect(value, true));\n",
       "    return fragment;\n",
       "  }\n",
       "\n",
       "  function format(date, fallback) {\n",
       "    if (!(date instanceof Date)) date = new Date(+date);\n",
       "    if (isNaN(date)) return typeof fallback === \"function\" ? fallback(date) : fallback;\n",
       "    const hours = date.getUTCHours();\n",
       "    const minutes = date.getUTCMinutes();\n",
       "    const seconds = date.getUTCSeconds();\n",
       "    const milliseconds = date.getUTCMilliseconds();\n",
       "    return \\`\\${formatYear(date.getUTCFullYear())}-\\${pad(date.getUTCMonth() + 1, 2)}-\\${pad(date.getUTCDate(), 2)}\\${\n",
       "    hours || minutes || seconds || milliseconds ? \\`T\\${pad(hours, 2)}:\\${pad(minutes, 2)}\\${\n",
       "      seconds || milliseconds ? \\`:\\${pad(seconds, 2)}\\${\n",
       "        milliseconds ? \\`.\\${pad(milliseconds, 3)}\\` : \\`\\`\n",
       "      }\\` : \\`\\`\n",
       "    }Z\\` : \\`\\`\n",
       "  }\\`;\n",
       "  }\n",
       "\n",
       "  function formatYear(year) {\n",
       "    return year < 0 ? \\`-\\${pad(-year, 6)}\\`\n",
       "      : year > 9999 ? \\`+\\${pad(year, 6)}\\`\n",
       "      : pad(year, 4);\n",
       "  }\n",
       "\n",
       "  function pad(value, width) {\n",
       "    return \\`\\${value}\\`.padStart(width, \"0\");\n",
       "  }\n",
       "\n",
       "  function formatDate(date) {\n",
       "    return format(date, \"Invalid Date\");\n",
       "  }\n",
       "\n",
       "  var errorToString = Error.prototype.toString;\n",
       "\n",
       "  function formatError(value) {\n",
       "    return value.stack || errorToString.call(value);\n",
       "  }\n",
       "\n",
       "  var regExpToString = RegExp.prototype.toString;\n",
       "\n",
       "  function formatRegExp(value) {\n",
       "    return regExpToString.call(value);\n",
       "  }\n",
       "\n",
       "  /* eslint-disable no-control-regex */\n",
       "  const NEWLINE_LIMIT = 20;\n",
       "\n",
       "  function formatString(string, shallow, expanded, name) {\n",
       "    if (shallow === false) {\n",
       "      // String has fewer escapes displayed with double quotes\n",
       "      if (count(string, /[\"\\\\n]/g) <= count(string, /\\`|\\\\\\${/g)) {\n",
       "        const span = document.createElement(\"span\");\n",
       "        if (name) span.appendChild(inspectName(name));\n",
       "        const textValue = span.appendChild(document.createElement(\"span\"));\n",
       "        textValue.className = \"observablehq--string\";\n",
       "        textValue.textContent = JSON.stringify(string);\n",
       "        return span;\n",
       "      }\n",
       "      const lines = string.split(\"\\\\n\");\n",
       "      if (lines.length > NEWLINE_LIMIT && !expanded) {\n",
       "        const div = document.createElement(\"div\");\n",
       "        if (name) div.appendChild(inspectName(name));\n",
       "        const textValue = div.appendChild(document.createElement(\"span\"));\n",
       "        textValue.className = \"observablehq--string\";\n",
       "        textValue.textContent = \"\\`\" + templatify(lines.slice(0, NEWLINE_LIMIT).join(\"\\\\n\"));\n",
       "        const splitter = div.appendChild(document.createElement(\"span\"));\n",
       "        const truncatedCount = lines.length - NEWLINE_LIMIT;\n",
       "        splitter.textContent = \\`Show \\${truncatedCount} truncated line\\${truncatedCount > 1 ? \"s\": \"\"}\\`; splitter.className = \"observablehq--string-expand\";\n",
       "        splitter.addEventListener(\"mouseup\", function (event) {\n",
       "          event.stopPropagation();\n",
       "          replace(div, inspect(string, shallow, true, name));\n",
       "        });\n",
       "        return div;\n",
       "      }\n",
       "      const span = document.createElement(\"span\");\n",
       "      if (name) span.appendChild(inspectName(name));\n",
       "      const textValue = span.appendChild(document.createElement(\"span\"));\n",
       "      textValue.className = \\`observablehq--string\\${expanded ? \" observablehq--expanded\" : \"\"}\\`;\n",
       "      textValue.textContent = \"\\`\" + templatify(string) + \"\\`\";\n",
       "      return span;\n",
       "    }\n",
       "\n",
       "    const span = document.createElement(\"span\");\n",
       "    if (name) span.appendChild(inspectName(name));\n",
       "    const textValue = span.appendChild(document.createElement(\"span\"));\n",
       "    textValue.className = \"observablehq--string\";\n",
       "    textValue.textContent = JSON.stringify(string.length > 100 ?\n",
       "      \\`\\${string.slice(0, 50)}…\\${string.slice(-49)}\\` : string);\n",
       "    return span;\n",
       "  }\n",
       "\n",
       "  function templatify(string) {\n",
       "    return string.replace(/[\\\\\\\\\\`\\\\x00-\\\\x09\\\\x0b-\\\\x19]|\\\\\\${/g, templatifyChar);\n",
       "  }\n",
       "\n",
       "  function templatifyChar(char) {\n",
       "    var code = char.charCodeAt(0);\n",
       "    switch (code) {\n",
       "      case 0x8: return \"\\\\\\\\b\";\n",
       "      case 0x9: return \"\\\\\\\\t\";\n",
       "      case 0xb: return \"\\\\\\\\v\";\n",
       "      case 0xc: return \"\\\\\\\\f\";\n",
       "      case 0xd: return \"\\\\\\\\r\";\n",
       "    }\n",
       "    return code < 0x10 ? \"\\\\\\\\x0\" + code.toString(16)\n",
       "        : code < 0x20 ? \"\\\\\\\\x\" + code.toString(16)\n",
       "        : \"\\\\\\\\\" + char;\n",
       "  }\n",
       "\n",
       "  function count(string, re) {\n",
       "    var n = 0;\n",
       "    while (re.exec(string)) ++n;\n",
       "    return n;\n",
       "  }\n",
       "\n",
       "  var toString = Function.prototype.toString,\n",
       "      TYPE_ASYNC = {prefix: \"async ƒ\"},\n",
       "      TYPE_ASYNC_GENERATOR = {prefix: \"async ƒ*\"},\n",
       "      TYPE_CLASS = {prefix: \"class\"},\n",
       "      TYPE_FUNCTION = {prefix: \"ƒ\"},\n",
       "      TYPE_GENERATOR = {prefix: \"ƒ*\"};\n",
       "\n",
       "  function inspectFunction(f, name) {\n",
       "    var type, m, t = toString.call(f);\n",
       "\n",
       "    switch (f.constructor && f.constructor.name) {\n",
       "      case \"AsyncFunction\": type = TYPE_ASYNC; break;\n",
       "      case \"AsyncGeneratorFunction\": type = TYPE_ASYNC_GENERATOR; break;\n",
       "      case \"GeneratorFunction\": type = TYPE_GENERATOR; break;\n",
       "      default: type = /^class\\\\b/.test(t) ? TYPE_CLASS : TYPE_FUNCTION; break;\n",
       "    }\n",
       "\n",
       "    // A class, possibly named.\n",
       "    // class Name\n",
       "    if (type === TYPE_CLASS) {\n",
       "      return formatFunction(type, \"\", name);\n",
       "    }\n",
       "\n",
       "    // An arrow function with a single argument.\n",
       "    // foo =>\n",
       "    // async foo =>\n",
       "    if ((m = /^(?:async\\\\s*)?(\\\\w+)\\\\s*=>/.exec(t))) {\n",
       "      return formatFunction(type, \"(\" + m[1] + \")\", name);\n",
       "    }\n",
       "\n",
       "    // An arrow function with parenthesized arguments.\n",
       "    // (…)\n",
       "    // async (…)\n",
       "    if ((m = /^(?:async\\\\s*)?\\\\(\\\\s*(\\\\w+(?:\\\\s*,\\\\s*\\\\w+)*)?\\\\s*\\\\)/.exec(t))) {\n",
       "      return formatFunction(type, m[1] ? \"(\" + m[1].replace(/\\\\s*,\\\\s*/g, \", \") + \")\" : \"()\", name);\n",
       "    }\n",
       "\n",
       "    // A function, possibly: async, generator, anonymous, simply arguments.\n",
       "    // function name(…)\n",
       "    // function* name(…)\n",
       "    // async function name(…)\n",
       "    // async function* name(…)\n",
       "    if ((m = /^(?:async\\\\s*)?function(?:\\\\s*\\\\*)?(?:\\\\s*\\\\w+)?\\\\s*\\\\(\\\\s*(\\\\w+(?:\\\\s*,\\\\s*\\\\w+)*)?\\\\s*\\\\)/.exec(t))) {\n",
       "      return formatFunction(type, m[1] ? \"(\" + m[1].replace(/\\\\s*,\\\\s*/g, \", \") + \")\" : \"()\", name);\n",
       "    }\n",
       "\n",
       "    // Something else, like destructuring, comments or default values.\n",
       "    return formatFunction(type, \"(…)\", name);\n",
       "  }\n",
       "\n",
       "  function formatFunction(type, args, cellname) {\n",
       "    var span = document.createElement(\"span\");\n",
       "    span.className = \"observablehq--function\";\n",
       "    if (cellname) {\n",
       "      span.appendChild(inspectName(cellname));\n",
       "    }\n",
       "    var spanType = span.appendChild(document.createElement(\"span\"));\n",
       "    spanType.className = \"observablehq--keyword\";\n",
       "    spanType.textContent = type.prefix;\n",
       "    span.appendChild(document.createTextNode(args));\n",
       "    return span;\n",
       "  }\n",
       "\n",
       "  const {prototype: {toString: toString\\$1}} = Object;\n",
       "\n",
       "  function inspect(value, shallow, expand, name, proto) {\n",
       "    let type = typeof value;\n",
       "    switch (type) {\n",
       "      case \"boolean\":\n",
       "      case \"undefined\": { value += \"\"; break; }\n",
       "      case \"number\": { value = value === 0 && 1 / value < 0 ? \"-0\" : value + \"\"; break; }\n",
       "      case \"bigint\": { value = value + \"n\"; break; }\n",
       "      case \"symbol\": { value = formatSymbol(value); break; }\n",
       "      case \"function\": { return inspectFunction(value, name); }\n",
       "      case \"string\": { return formatString(value, shallow, expand, name); }\n",
       "      default: {\n",
       "        if (value === null) { type = null, value = \"null\"; break; }\n",
       "        if (value instanceof Date) { type = \"date\", value = formatDate(value); break; }\n",
       "        if (value === FORBIDDEN) { type = \"forbidden\", value = \"[forbidden]\"; break; }\n",
       "        switch (toString\\$1.call(value)) {\n",
       "          case \"[object RegExp]\": { type = \"regexp\", value = formatRegExp(value); break; }\n",
       "          case \"[object Error]\": // https://github.com/lodash/lodash/blob/master/isError.js#L26\n",
       "          case \"[object DOMException]\": { type = \"error\", value = formatError(value); break; }\n",
       "          default: return (expand ? inspectExpanded : inspectCollapsed)(value, shallow, name, proto);\n",
       "        }\n",
       "        break;\n",
       "      }\n",
       "    }\n",
       "    const span = document.createElement(\"span\");\n",
       "    if (name) span.appendChild(inspectName(name));\n",
       "    const n = span.appendChild(document.createElement(\"span\"));\n",
       "    n.className = \\`observablehq--\\${type}\\`;\n",
       "    n.textContent = value;\n",
       "    return span;\n",
       "  }\n",
       "\n",
       "  function replace(spanOld, spanNew) {\n",
       "    if (spanOld.classList.contains(\"observablehq--inspect\")) spanNew.classList.add(\"observablehq--inspect\");\n",
       "    spanOld.parentNode.replaceChild(spanNew, spanOld);\n",
       "    dispatch(spanNew, \"load\");\n",
       "  }\n",
       "\n",
       "  const LOCATION_MATCH = /\\\\s+\\\\(\\\\d+:\\\\d+\\\\)\\$/m;\n",
       "\n",
       "  class Inspector {\n",
       "    constructor(node) {\n",
       "      if (!node) throw new Error(\"invalid node\");\n",
       "      this._node = node;\n",
       "      node.classList.add(\"observablehq\");\n",
       "    }\n",
       "    pending() {\n",
       "      const {_node} = this;\n",
       "      _node.classList.remove(\"observablehq--error\");\n",
       "      _node.classList.add(\"observablehq--running\");\n",
       "    }\n",
       "    fulfilled(value, name) {\n",
       "      const {_node} = this;\n",
       "      if (!isnode(value) || (value.parentNode && value.parentNode !== _node)) {\n",
       "        value = inspect(value, false, _node.firstChild // TODO Do this better.\n",
       "            && _node.firstChild.classList\n",
       "            && _node.firstChild.classList.contains(\"observablehq--expanded\"), name);\n",
       "        value.classList.add(\"observablehq--inspect\");\n",
       "      }\n",
       "      _node.classList.remove(\"observablehq--running\", \"observablehq--error\");\n",
       "      if (_node.firstChild !== value) {\n",
       "        if (_node.firstChild) {\n",
       "          while (_node.lastChild !== _node.firstChild) _node.removeChild(_node.lastChild);\n",
       "          _node.replaceChild(value, _node.firstChild);\n",
       "        } else {\n",
       "          _node.appendChild(value);\n",
       "        }\n",
       "      }\n",
       "      dispatch(_node, \"update\");\n",
       "    }\n",
       "    rejected(error, name) {\n",
       "      const {_node} = this;\n",
       "      _node.classList.remove(\"observablehq--running\");\n",
       "      _node.classList.add(\"observablehq--error\");\n",
       "      while (_node.lastChild) _node.removeChild(_node.lastChild);\n",
       "      var div = document.createElement(\"div\");\n",
       "      div.className = \"observablehq--inspect\";\n",
       "      if (name) div.appendChild(inspectName(name));\n",
       "      div.appendChild(document.createTextNode((error + \"\").replace(LOCATION_MATCH, \"\")));\n",
       "      _node.appendChild(div);\n",
       "      dispatch(_node, \"error\", {error: error});\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Inspector.into = function(container) {\n",
       "    if (typeof container === \"string\") {\n",
       "      container = document.querySelector(container);\n",
       "      if (container == null) throw new Error(\"container not found\");\n",
       "    }\n",
       "    return function() {\n",
       "      return new Inspector(container.appendChild(document.createElement(\"div\")));\n",
       "    };\n",
       "  };\n",
       "\n",
       "  // Returns true if the given value is something that should be added to the DOM\n",
       "  // by the inspector, rather than being inspected. This deliberately excludes\n",
       "  // DocumentFragment since appending a fragment “dissolves” (mutates) the\n",
       "  // fragment, and we wish for the inspector to not have side-effects. Also,\n",
       "  // HTMLElement.prototype is an instanceof Element, but not an element!\n",
       "  function isnode(value) {\n",
       "    return (value instanceof Element || value instanceof Text)\n",
       "        && (value instanceof value.constructor);\n",
       "  }\n",
       "\n",
       "  var EOL = {},\n",
       "      EOF = {},\n",
       "      QUOTE = 34,\n",
       "      NEWLINE = 10,\n",
       "      RETURN = 13;\n",
       "\n",
       "  function objectConverter(columns) {\n",
       "    return new Function(\"d\", \"return {\" + columns.map(function(name, i) {\n",
       "      return JSON.stringify(name) + \": d[\" + i + \"] || \\\\\"\\\\\"\";\n",
       "    }).join(\",\") + \"}\");\n",
       "  }\n",
       "\n",
       "  function customConverter(columns, f) {\n",
       "    var object = objectConverter(columns);\n",
       "    return function(row, i) {\n",
       "      return f(object(row), i, columns);\n",
       "    };\n",
       "  }\n",
       "\n",
       "  // Compute unique columns in order of discovery.\n",
       "  function inferColumns(rows) {\n",
       "    var columnSet = Object.create(null),\n",
       "        columns = [];\n",
       "\n",
       "    rows.forEach(function(row) {\n",
       "      for (var column in row) {\n",
       "        if (!(column in columnSet)) {\n",
       "          columns.push(columnSet[column] = column);\n",
       "        }\n",
       "      }\n",
       "    });\n",
       "\n",
       "    return columns;\n",
       "  }\n",
       "\n",
       "  function pad\\$1(value, width) {\n",
       "    var s = value + \"\", length = s.length;\n",
       "    return length < width ? new Array(width - length + 1).join(0) + s : s;\n",
       "  }\n",
       "\n",
       "  function formatYear\\$1(year) {\n",
       "    return year < 0 ? \"-\" + pad\\$1(-year, 6)\n",
       "      : year > 9999 ? \"+\" + pad\\$1(year, 6)\n",
       "      : pad\\$1(year, 4);\n",
       "  }\n",
       "\n",
       "  function formatDate\\$1(date) {\n",
       "    var hours = date.getUTCHours(),\n",
       "        minutes = date.getUTCMinutes(),\n",
       "        seconds = date.getUTCSeconds(),\n",
       "        milliseconds = date.getUTCMilliseconds();\n",
       "    return isNaN(date) ? \"Invalid Date\"\n",
       "        : formatYear\\$1(date.getUTCFullYear()) + \"-\" + pad\\$1(date.getUTCMonth() + 1, 2) + \"-\" + pad\\$1(date.getUTCDate(), 2)\n",
       "        + (milliseconds ? \"T\" + pad\\$1(hours, 2) + \":\" + pad\\$1(minutes, 2) + \":\" + pad\\$1(seconds, 2) + \".\" + pad\\$1(milliseconds, 3) + \"Z\"\n",
       "        : seconds ? \"T\" + pad\\$1(hours, 2) + \":\" + pad\\$1(minutes, 2) + \":\" + pad\\$1(seconds, 2) + \"Z\"\n",
       "        : minutes || hours ? \"T\" + pad\\$1(hours, 2) + \":\" + pad\\$1(minutes, 2) + \"Z\"\n",
       "        : \"\");\n",
       "  }\n",
       "\n",
       "  function dsv(delimiter) {\n",
       "    var reFormat = new RegExp(\"[\\\\\"\" + delimiter + \"\\\\n\\\\r]\"),\n",
       "        DELIMITER = delimiter.charCodeAt(0);\n",
       "\n",
       "    function parse(text, f) {\n",
       "      var convert, columns, rows = parseRows(text, function(row, i) {\n",
       "        if (convert) return convert(row, i - 1);\n",
       "        columns = row, convert = f ? customConverter(row, f) : objectConverter(row);\n",
       "      });\n",
       "      rows.columns = columns || [];\n",
       "      return rows;\n",
       "    }\n",
       "\n",
       "    function parseRows(text, f) {\n",
       "      var rows = [], // output rows\n",
       "          N = text.length,\n",
       "          I = 0, // current character index\n",
       "          n = 0, // current line number\n",
       "          t, // current token\n",
       "          eof = N <= 0, // current token followed by EOF?\n",
       "          eol = false; // current token followed by EOL?\n",
       "\n",
       "      // Strip the trailing newline.\n",
       "      if (text.charCodeAt(N - 1) === NEWLINE) --N;\n",
       "      if (text.charCodeAt(N - 1) === RETURN) --N;\n",
       "\n",
       "      function token() {\n",
       "        if (eof) return EOF;\n",
       "        if (eol) return eol = false, EOL;\n",
       "\n",
       "        // Unescape quotes.\n",
       "        var i, j = I, c;\n",
       "        if (text.charCodeAt(j) === QUOTE) {\n",
       "          while (I++ < N && text.charCodeAt(I) !== QUOTE || text.charCodeAt(++I) === QUOTE);\n",
       "          if ((i = I) >= N) eof = true;\n",
       "          else if ((c = text.charCodeAt(I++)) === NEWLINE) eol = true;\n",
       "          else if (c === RETURN) { eol = true; if (text.charCodeAt(I) === NEWLINE) ++I; }\n",
       "          return text.slice(j + 1, i - 1).replace(/\"\"/g, \"\\\\\"\");\n",
       "        }\n",
       "\n",
       "        // Find next delimiter or newline.\n",
       "        while (I < N) {\n",
       "          if ((c = text.charCodeAt(i = I++)) === NEWLINE) eol = true;\n",
       "          else if (c === RETURN) { eol = true; if (text.charCodeAt(I) === NEWLINE) ++I; }\n",
       "          else if (c !== DELIMITER) continue;\n",
       "          return text.slice(j, i);\n",
       "        }\n",
       "\n",
       "        // Return last token before EOF.\n",
       "        return eof = true, text.slice(j, N);\n",
       "      }\n",
       "\n",
       "      while ((t = token()) !== EOF) {\n",
       "        var row = [];\n",
       "        while (t !== EOL && t !== EOF) row.push(t), t = token();\n",
       "        if (f && (row = f(row, n++)) == null) continue;\n",
       "        rows.push(row);\n",
       "      }\n",
       "\n",
       "      return rows;\n",
       "    }\n",
       "\n",
       "    function preformatBody(rows, columns) {\n",
       "      return rows.map(function(row) {\n",
       "        return columns.map(function(column) {\n",
       "          return formatValue(row[column]);\n",
       "        }).join(delimiter);\n",
       "      });\n",
       "    }\n",
       "\n",
       "    function format(rows, columns) {\n",
       "      if (columns == null) columns = inferColumns(rows);\n",
       "      return [columns.map(formatValue).join(delimiter)].concat(preformatBody(rows, columns)).join(\"\\\\n\");\n",
       "    }\n",
       "\n",
       "    function formatBody(rows, columns) {\n",
       "      if (columns == null) columns = inferColumns(rows);\n",
       "      return preformatBody(rows, columns).join(\"\\\\n\");\n",
       "    }\n",
       "\n",
       "    function formatRows(rows) {\n",
       "      return rows.map(formatRow).join(\"\\\\n\");\n",
       "    }\n",
       "\n",
       "    function formatRow(row) {\n",
       "      return row.map(formatValue).join(delimiter);\n",
       "    }\n",
       "\n",
       "    function formatValue(value) {\n",
       "      return value == null ? \"\"\n",
       "          : value instanceof Date ? formatDate\\$1(value)\n",
       "          : reFormat.test(value += \"\") ? \"\\\\\"\" + value.replace(/\"/g, \"\\\\\"\\\\\"\") + \"\\\\\"\"\n",
       "          : value;\n",
       "    }\n",
       "\n",
       "    return {\n",
       "      parse: parse,\n",
       "      parseRows: parseRows,\n",
       "      format: format,\n",
       "      formatBody: formatBody,\n",
       "      formatRows: formatRows,\n",
       "      formatRow: formatRow,\n",
       "      formatValue: formatValue\n",
       "    };\n",
       "  }\n",
       "\n",
       "  var csv = dsv(\",\");\n",
       "\n",
       "  var csvParse = csv.parse;\n",
       "  var csvParseRows = csv.parseRows;\n",
       "\n",
       "  var tsv = dsv(\"\\\\t\");\n",
       "\n",
       "  var tsvParse = tsv.parse;\n",
       "  var tsvParseRows = tsv.parseRows;\n",
       "\n",
       "  function autoType(object) {\n",
       "    for (var key in object) {\n",
       "      var value = object[key].trim(), number, m;\n",
       "      if (!value) value = null;\n",
       "      else if (value === \"true\") value = true;\n",
       "      else if (value === \"false\") value = false;\n",
       "      else if (value === \"NaN\") value = NaN;\n",
       "      else if (!isNaN(number = +value)) value = number;\n",
       "      else if (m = value.match(/^([-+]\\\\d{2})?\\\\d{4}(-\\\\d{2}(-\\\\d{2})?)?(T\\\\d{2}:\\\\d{2}(:\\\\d{2}(\\\\.\\\\d{3})?)?(Z|[-+]\\\\d{2}:\\\\d{2})?)?\\$/)) {\n",
       "        if (fixtz && !!m[4] && !m[7]) value = value.replace(/-/g, \"/\").replace(/T/, \" \");\n",
       "        value = new Date(value);\n",
       "      }\n",
       "      else continue;\n",
       "      object[key] = value;\n",
       "    }\n",
       "    return object;\n",
       "  }\n",
       "\n",
       "  // https://github.com/d3/d3-dsv/issues/45\n",
       "  const fixtz = new Date(\"2019-01-01T00:00\").getHours() || new Date(\"2019-07-01T00:00\").getHours();\n",
       "\n",
       "  const metas = new Map;\n",
       "  const queue = [];\n",
       "  const map = queue.map;\n",
       "  const some = queue.some;\n",
       "  const hasOwnProperty\\$1 = queue.hasOwnProperty;\n",
       "  const origin = \"https://cdn.jsdelivr.net/npm/\";\n",
       "  const identifierRe = /^((?:@[^/@]+\\\\/)?[^/@]+)(?:@([^/]+))?(?:\\\\/(.*))?\\$/;\n",
       "  const versionRe = /^\\\\d+\\\\.\\\\d+\\\\.\\\\d+(-[\\\\w-.+]+)?\\$/;\n",
       "  const extensionRe = /\\\\.[^/]*\\$/;\n",
       "  const mains = [\"unpkg\", \"jsdelivr\", \"browser\", \"main\"];\n",
       "\n",
       "  class RequireError extends Error {\n",
       "    constructor(message) {\n",
       "      super(message);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  RequireError.prototype.name = RequireError.name;\n",
       "\n",
       "  function main(meta) {\n",
       "    for (const key of mains) {\n",
       "      const value = meta[key];\n",
       "      if (typeof value === \"string\") {\n",
       "        return extensionRe.test(value) ? value : \\`\\${value}.js\\`;\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function parseIdentifier(identifier) {\n",
       "    const match = identifierRe.exec(identifier);\n",
       "    return match && {\n",
       "      name: match[1],\n",
       "      version: match[2],\n",
       "      path: match[3]\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function resolveMeta(target) {\n",
       "    const url = \\`\\${origin}\\${target.name}\\${target.version ? \\`@\\${target.version}\\` : \"\"}/package.json\\`;\n",
       "    let meta = metas.get(url);\n",
       "    if (!meta) metas.set(url, meta = fetch(url).then(response => {\n",
       "      if (!response.ok) throw new RequireError(\"unable to load package.json\");\n",
       "      if (response.redirected && !metas.has(response.url)) metas.set(response.url, meta);\n",
       "      return response.json();\n",
       "    }));\n",
       "    return meta;\n",
       "  }\n",
       "\n",
       "  async function resolve(name, base) {\n",
       "    if (name.startsWith(origin)) name = name.substring(origin.length);\n",
       "    if (/^(\\\\w+:)|\\\\/\\\\//i.test(name)) return name;\n",
       "    if (/^[.]{0,2}\\\\//i.test(name)) return new URL(name, base == null ? location : base).href;\n",
       "    if (!name.length || /^[\\\\s._]/.test(name) || /\\\\s\\$/.test(name)) throw new RequireError(\"illegal name\");\n",
       "    const target = parseIdentifier(name);\n",
       "    if (!target) return \\`\\${origin}\\${name}\\`;\n",
       "    if (!target.version && base != null && base.startsWith(origin)) {\n",
       "      const meta = await resolveMeta(parseIdentifier(base.substring(origin.length)));\n",
       "      target.version = meta.dependencies && meta.dependencies[target.name] || meta.peerDependencies && meta.peerDependencies[target.name];\n",
       "    }\n",
       "    if (target.path && !extensionRe.test(target.path)) target.path += \".js\";\n",
       "    if (target.path && target.version && versionRe.test(target.version)) return \\`\\${origin}\\${target.name}@\\${target.version}/\\${target.path}\\`;\n",
       "    const meta = await resolveMeta(target);\n",
       "    return \\`\\${origin}\\${meta.name}@\\${meta.version}/\\${target.path || main(meta) || \"index.js\"}\\`;\n",
       "  }\n",
       "\n",
       "  var require = requireFrom(resolve);\n",
       "\n",
       "  function requireFrom(resolver) {\n",
       "    const cache = new Map;\n",
       "    const requireBase = requireRelative(null);\n",
       "\n",
       "    function requireAbsolute(url) {\n",
       "      if (typeof url !== \"string\") return url;\n",
       "      let module = cache.get(url);\n",
       "      if (!module) cache.set(url, module = new Promise((resolve, reject) => {\n",
       "        const script = document.createElement(\"script\");\n",
       "        script.onload = () => {\n",
       "          try { resolve(queue.pop()(requireRelative(url))); }\n",
       "          catch (error) { reject(new RequireError(\"invalid module\")); }\n",
       "          script.remove();\n",
       "        };\n",
       "        script.onerror = () => {\n",
       "          reject(new RequireError(\"unable to load module\"));\n",
       "          script.remove();\n",
       "        };\n",
       "        script.async = true;\n",
       "        script.src = url;\n",
       "        window.define = define;\n",
       "        document.head.appendChild(script);\n",
       "      }));\n",
       "      return module;\n",
       "    }\n",
       "\n",
       "    function requireRelative(base) {\n",
       "      return name => Promise.resolve(resolver(name, base)).then(requireAbsolute);\n",
       "    }\n",
       "\n",
       "    function requireAlias(aliases) {\n",
       "      return requireFrom((name, base) => {\n",
       "        if (name in aliases) {\n",
       "          name = aliases[name], base = null;\n",
       "          if (typeof name !== \"string\") return name;\n",
       "        }\n",
       "        return resolver(name, base);\n",
       "      });\n",
       "    }\n",
       "\n",
       "    function require(name) {\n",
       "      return arguments.length > 1\n",
       "          ? Promise.all(map.call(arguments, requireBase)).then(merge)\n",
       "          : requireBase(name);\n",
       "    }\n",
       "\n",
       "    require.alias = requireAlias;\n",
       "    require.resolve = resolver;\n",
       "\n",
       "    return require;\n",
       "  }\n",
       "\n",
       "  function merge(modules) {\n",
       "    const o = {};\n",
       "    for (const m of modules) {\n",
       "      for (const k in m) {\n",
       "        if (hasOwnProperty\\$1.call(m, k)) {\n",
       "          if (m[k] == null) Object.defineProperty(o, k, {get: getter(m, k)});\n",
       "          else o[k] = m[k];\n",
       "        }\n",
       "      }\n",
       "    }\n",
       "    return o;\n",
       "  }\n",
       "\n",
       "  function getter(object, name) {\n",
       "    return () => object[name];\n",
       "  }\n",
       "\n",
       "  function isbuiltin(name) {\n",
       "    name = name + \"\";\n",
       "    return name === \"exports\" || name === \"module\";\n",
       "  }\n",
       "\n",
       "  function define(name, dependencies, factory) {\n",
       "    const n = arguments.length;\n",
       "    if (n < 2) factory = name, dependencies = [];\n",
       "    else if (n < 3) factory = dependencies, dependencies = typeof name === \"string\" ? [] : name;\n",
       "    queue.push(some.call(dependencies, isbuiltin) ? require => {\n",
       "      const exports = {};\n",
       "      const module = {exports};\n",
       "      return Promise.all(map.call(dependencies, name => {\n",
       "        name = name + \"\";\n",
       "        return name === \"exports\" ? exports : name === \"module\" ? module : require(name);\n",
       "      })).then(dependencies => {\n",
       "        factory.apply(null, dependencies);\n",
       "        return module.exports;\n",
       "      });\n",
       "    } : require => {\n",
       "      return Promise.all(map.call(dependencies, require)).then(dependencies => {\n",
       "        return typeof factory === \"function\" ? factory.apply(null, dependencies) : factory;\n",
       "      });\n",
       "    });\n",
       "  }\n",
       "\n",
       "  define.amd = {};\n",
       "\n",
       "  function dependency(name, version, main) {\n",
       "    return {\n",
       "      resolve(path = main) {\n",
       "        return \\`https://cdn.jsdelivr.net/npm/\\${name}@\\${version}/\\${path}\\`;\n",
       "      }\n",
       "    };\n",
       "  }\n",
       "\n",
       "  const d3 = dependency(\"d3\", \"7.0.4\", \"dist/d3.min.js\");\n",
       "  const inputs = dependency(\"@observablehq/inputs\", \"0.9.7\", \"dist/inputs.min.js\");\n",
       "  const plot = dependency(\"@observablehq/plot\", \"0.2.4\", \"dist/plot.umd.min.js\");\n",
       "  const graphviz = dependency(\"@observablehq/graphviz\", \"0.2.1\", \"dist/graphviz.min.js\");\n",
       "  const highlight = dependency(\"@observablehq/highlight.js\", \"2.0.0\", \"highlight.min.js\");\n",
       "  const katex = dependency(\"@observablehq/katex\", \"0.11.1\", \"dist/katex.min.js\");\n",
       "  const lodash = dependency(\"lodash\", \"4.17.21\", \"lodash.min.js\");\n",
       "  const htl = dependency(\"htl\", \"0.3.1\", \"dist/htl.min.js\");\n",
       "  const jszip = dependency(\"jszip\", \"3.7.1\", \"dist/jszip.min.js\");\n",
       "  const marked = dependency(\"marked\", \"0.3.12\", \"marked.min.js\");\n",
       "  const sql = dependency(\"sql.js\", \"1.6.1\", \"dist/sql-wasm.js\");\n",
       "  const vega = dependency(\"vega\", \"5.21.0\", \"build/vega.min.js\");\n",
       "  const vegalite = dependency(\"vega-lite\", \"5.1.1\", \"build/vega-lite.min.js\");\n",
       "  const vegaliteApi = dependency(\"vega-lite-api\", \"5.0.0\", \"build/vega-lite-api.min.js\");\n",
       "  const arrow = dependency(\"apache-arrow\", \"4.0.1\", \"Arrow.es2015.min.js\");\n",
       "  const arquero = dependency(\"arquero\", \"4.8.7\", \"dist/arquero.min.js\");\n",
       "  const topojson = dependency(\"topojson-client\", \"3.1.0\", \"dist/topojson-client.min.js\");\n",
       "  const exceljs = dependency(\"exceljs\", \"4.3.0\", \"dist/exceljs.min.js\");\n",
       "\n",
       "  async function sqlite(require) {\n",
       "    const init = await require(sql.resolve());\n",
       "    return init({locateFile: file => sql.resolve(\\`dist/\\${file}\\`)});\n",
       "  }\n",
       "\n",
       "  class SQLiteDatabaseClient {\n",
       "    constructor(db) {\n",
       "      Object.defineProperties(this, {\n",
       "        _db: {value: db}\n",
       "      });\n",
       "    }\n",
       "    static async open(source) {\n",
       "      const [SQL, buffer] = await Promise.all([sqlite(require), Promise.resolve(source).then(load)]);\n",
       "      return new SQLiteDatabaseClient(new SQL.Database(buffer));\n",
       "    }\n",
       "    async query(query, params) {\n",
       "      return await exec(this._db, query, params);\n",
       "    }\n",
       "    async queryRow(query, params) {\n",
       "      return (await this.query(query, params))[0] || null;\n",
       "    }\n",
       "    async explain(query, params) {\n",
       "      const rows = await this.query(\\`EXPLAIN QUERY PLAN \\${query}\\`, params);\n",
       "      return element(\"pre\", {className: \"observablehq--inspect\"}, [\n",
       "        text(rows.map(row => row.detail).join(\"\\\\n\"))\n",
       "      ]);\n",
       "    }\n",
       "    async describe(object) {\n",
       "      const rows = await (object === undefined\n",
       "        ? this.query(\\`SELECT name FROM sqlite_master WHERE type = 'table'\\`)\n",
       "        : this.query(\\`SELECT * FROM pragma_table_info(?)\\`, [object]));\n",
       "      if (!rows.length) throw new Error(\"Not found\");\n",
       "      const {columns} = rows;\n",
       "      return element(\"table\", {value: rows}, [\n",
       "        element(\"thead\", [element(\"tr\", columns.map(c => element(\"th\", [text(c)])))]),\n",
       "        element(\"tbody\", rows.map(r => element(\"tr\", columns.map(c => element(\"td\", [text(r[c])])))))\n",
       "      ]);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function load(source) {\n",
       "    return typeof source === \"string\" ? fetch(source).then(load)\n",
       "      : source instanceof Response || source instanceof Blob ? source.arrayBuffer().then(load)\n",
       "      : source instanceof ArrayBuffer ? new Uint8Array(source)\n",
       "      : source;\n",
       "  }\n",
       "\n",
       "  async function exec(db, query, params) {\n",
       "    const [result] = await db.exec(query, params);\n",
       "    if (!result) return [];\n",
       "    const {columns, values} = result;\n",
       "    const rows = values.map(row => Object.fromEntries(row.map((value, i) => [columns[i], value])));\n",
       "    rows.columns = columns;\n",
       "    return rows;\n",
       "  }\n",
       "\n",
       "  function element(name, props, children) {\n",
       "    if (arguments.length === 2) children = props, props = undefined;\n",
       "    const element = document.createElement(name);\n",
       "    if (props !== undefined) for (const p in props) element[p] = props[p];\n",
       "    if (children !== undefined) for (const c of children) element.appendChild(c);\n",
       "    return element;\n",
       "  }\n",
       "\n",
       "  function text(value) {\n",
       "    return document.createTextNode(value);\n",
       "  }\n",
       "\n",
       "  class Workbook {\n",
       "    constructor(workbook) {\n",
       "      Object.defineProperties(this, {\n",
       "        _: {value: workbook},\n",
       "        sheetNames: {\n",
       "          value: workbook.worksheets.map((s) => s.name),\n",
       "          enumerable: true,\n",
       "        },\n",
       "      });\n",
       "    }\n",
       "    sheet(name, options) {\n",
       "      const sname =\n",
       "        typeof name === \"number\"\n",
       "          ? this.sheetNames[name]\n",
       "          : this.sheetNames.includes((name += \"\"))\n",
       "          ? name\n",
       "          : null;\n",
       "      if (sname == null) throw new Error(\\`Sheet not found: \\${name}\\`);\n",
       "      const sheet = this._.getWorksheet(sname);\n",
       "      return extract(sheet, options);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function extract(sheet, {range, headers} = {}) {\n",
       "    let [[c0, r0], [c1, r1]] = parseRange(range, sheet);\n",
       "    const headerRow = headers ? sheet._rows[r0++] : null;\n",
       "    let names = new Set([\"#\"]);\n",
       "    for (let n = c0; n <= c1; n++) {\n",
       "      const value = headerRow ? valueOf(headerRow.findCell(n + 1)) : null;\n",
       "      let name = (value && value + \"\") || toColumn(n);\n",
       "      while (names.has(name)) name += \"_\";\n",
       "      names.add(name);\n",
       "    }\n",
       "    names = new Array(c0).concat(Array.from(names));\n",
       "\n",
       "    const output = new Array(r1 - r0 + 1);\n",
       "    for (let r = r0; r <= r1; r++) {\n",
       "      const row = (output[r - r0] = Object.create(null, {\"#\": {value: r + 1}}));\n",
       "      const _row = sheet.getRow(r + 1);\n",
       "      if (_row.hasValues)\n",
       "        for (let c = c0; c <= c1; c++) {\n",
       "          const value = valueOf(_row.findCell(c + 1));\n",
       "          if (value != null) row[names[c + 1]] = value;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    output.columns = names.filter(() => true); // Filter sparse columns\n",
       "    return output;\n",
       "  }\n",
       "\n",
       "  function valueOf(cell) {\n",
       "    if (!cell) return;\n",
       "    const {value} = cell;\n",
       "    if (value && typeof value === \"object\" && !(value instanceof Date)) {\n",
       "      if (value.formula || value.sharedFormula) {\n",
       "        return value.result && value.result.error ? NaN : value.result;\n",
       "      }\n",
       "      if (value.richText) {\n",
       "        return richText(value);\n",
       "      }\n",
       "      if (value.text) {\n",
       "        let {text} = value;\n",
       "        if (text.richText) text = richText(text);\n",
       "        return value.hyperlink && value.hyperlink !== text\n",
       "          ? \\`\\${value.hyperlink} \\${text}\\`\n",
       "          : text;\n",
       "      }\n",
       "      return value;\n",
       "    }\n",
       "    return value;\n",
       "  }\n",
       "\n",
       "  function richText(value) {\n",
       "    return value.richText.map((d) => d.text).join(\"\");\n",
       "  }\n",
       "\n",
       "  function parseRange(specifier = \":\", {columnCount, rowCount}) {\n",
       "    specifier += \"\";\n",
       "    if (!specifier.match(/^[A-Z]*\\\\d*:[A-Z]*\\\\d*\\$/))\n",
       "      throw new Error(\"Malformed range specifier\");\n",
       "    const [[c0 = 0, r0 = 0], [c1 = columnCount - 1, r1 = rowCount - 1]] =\n",
       "      specifier.split(\":\").map(fromCellReference);\n",
       "    return [\n",
       "      [c0, r0],\n",
       "      [c1, r1],\n",
       "    ];\n",
       "  }\n",
       "\n",
       "  // Returns the default column name for a zero-based column index.\n",
       "  // For example: 0 -> \"A\", 1 -> \"B\", 25 -> \"Z\", 26 -> \"AA\", 27 -> \"AB\".\n",
       "  function toColumn(c) {\n",
       "    let sc = \"\";\n",
       "    c++;\n",
       "    do {\n",
       "      sc = String.fromCharCode(64 + (c % 26 || 26)) + sc;\n",
       "    } while ((c = Math.floor((c - 1) / 26)));\n",
       "    return sc;\n",
       "  }\n",
       "\n",
       "  // Returns the zero-based indexes from a cell reference.\n",
       "  // For example: \"A1\" -> [0, 0], \"B2\" -> [1, 1], \"AA10\" -> [26, 9].\n",
       "  function fromCellReference(s) {\n",
       "    const [, sc, sr] = s.match(/^([A-Z]*)(\\\\d*)\\$/);\n",
       "    let c = 0;\n",
       "    if (sc)\n",
       "      for (let i = 0; i < sc.length; i++)\n",
       "        c += Math.pow(26, sc.length - i - 1) * (sc.charCodeAt(i) - 64);\n",
       "    return [c ? c - 1 : undefined, sr ? +sr - 1 : undefined];\n",
       "  }\n",
       "\n",
       "  async function remote_fetch(file) {\n",
       "    const response = await fetch(await file.url());\n",
       "    if (!response.ok) throw new Error(\\`Unable to load file: \\${file.name}\\`);\n",
       "    return response;\n",
       "  }\n",
       "\n",
       "  async function dsv\\$1(file, delimiter, {array = false, typed = false} = {}) {\n",
       "    const text = await file.text();\n",
       "    return (delimiter === \"\\\\t\"\n",
       "        ? (array ? tsvParseRows : tsvParse)\n",
       "        : (array ? csvParseRows : csvParse))(text, typed && autoType);\n",
       "  }\n",
       "\n",
       "  class AbstractFile {\n",
       "    constructor(name) {\n",
       "      Object.defineProperty(this, \"name\", {value: name, enumerable: true});\n",
       "    }\n",
       "    async blob() {\n",
       "      return (await remote_fetch(this)).blob();\n",
       "    }\n",
       "    async arrayBuffer() {\n",
       "      return (await remote_fetch(this)).arrayBuffer();\n",
       "    }\n",
       "    async text() {\n",
       "      return (await remote_fetch(this)).text();\n",
       "    }\n",
       "    async json() {\n",
       "      return (await remote_fetch(this)).json();\n",
       "    }\n",
       "    async stream() {\n",
       "      return (await remote_fetch(this)).body;\n",
       "    }\n",
       "    async csv(options) {\n",
       "      return dsv\\$1(this, \",\", options);\n",
       "    }\n",
       "    async tsv(options) {\n",
       "      return dsv\\$1(this, \"\\\\t\", options);\n",
       "    }\n",
       "    async image() {\n",
       "      const url = await this.url();\n",
       "      return new Promise((resolve, reject) => {\n",
       "        const i = new Image;\n",
       "        if (new URL(url, document.baseURI).origin !== new URL(location).origin) {\n",
       "          i.crossOrigin = \"anonymous\";\n",
       "        }\n",
       "        i.onload = () => resolve(i);\n",
       "        i.onerror = () => reject(new Error(\\`Unable to load file: \\${this.name}\\`));\n",
       "        i.src = url;\n",
       "      });\n",
       "    }\n",
       "    async arrow() {\n",
       "      const [Arrow, response] = await Promise.all([require(arrow.resolve()), remote_fetch(this)]);\n",
       "      return Arrow.Table.from(response);\n",
       "    }\n",
       "    async sqlite() {\n",
       "      return SQLiteDatabaseClient.open(remote_fetch(this));\n",
       "    }\n",
       "    async zip() {\n",
       "      const [JSZip, buffer] = await Promise.all([require(jszip.resolve()), this.arrayBuffer()]);\n",
       "      return new ZipArchive(await JSZip.loadAsync(buffer));\n",
       "    }\n",
       "    async xml(mimeType = \"application/xml\") {\n",
       "      return (new DOMParser).parseFromString(await this.text(), mimeType);\n",
       "    }\n",
       "    async html() {\n",
       "      return this.xml(\"text/html\");\n",
       "    }\n",
       "    async xlsx() {\n",
       "      const [ExcelJS, buffer] = await Promise.all([require(exceljs.resolve()), this.arrayBuffer()]);\n",
       "      return new Workbook(await new ExcelJS.Workbook().xlsx.load(buffer));\n",
       "    }\n",
       "  }\n",
       "\n",
       "  class FileAttachment extends AbstractFile {\n",
       "    constructor(url, name) {\n",
       "      super(name);\n",
       "      Object.defineProperty(this, \"_url\", {value: url});\n",
       "    }\n",
       "    async url() {\n",
       "      return (await this._url) + \"\";\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function NoFileAttachments(name) {\n",
       "    throw new Error(\\`File not found: \\${name}\\`);\n",
       "  }\n",
       "\n",
       "  function FileAttachments(resolve) {\n",
       "    return Object.assign(\n",
       "      name => {\n",
       "        const url = resolve(name += \"\"); // Returns a Promise, string, or null.\n",
       "        if (url == null) throw new Error(\\`File not found: \\${name}\\`);\n",
       "        return new FileAttachment(url, name);\n",
       "      },\n",
       "      {prototype: FileAttachment.prototype} // instanceof\n",
       "    );\n",
       "  }\n",
       "\n",
       "  class ZipArchive {\n",
       "    constructor(archive) {\n",
       "      Object.defineProperty(this, \"_\", {value: archive});\n",
       "      this.filenames = Object.keys(archive.files).filter(name => !archive.files[name].dir);\n",
       "    }\n",
       "    file(path) {\n",
       "      const object = this._.file(path += \"\");\n",
       "      if (!object || object.dir) throw new Error(\\`file not found: \\${path}\\`);\n",
       "      return new ZipArchiveEntry(object);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  class ZipArchiveEntry extends AbstractFile {\n",
       "    constructor(object) {\n",
       "      super(object.name);\n",
       "      Object.defineProperty(this, \"_\", {value: object});\n",
       "      Object.defineProperty(this, \"_url\", {writable: true});\n",
       "    }\n",
       "    async url() {\n",
       "      return this._url || (this._url = this.blob().then(URL.createObjectURL));\n",
       "    }\n",
       "    async blob() {\n",
       "      return this._.async(\"blob\");\n",
       "    }\n",
       "    async arrayBuffer() {\n",
       "      return this._.async(\"arraybuffer\");\n",
       "    }\n",
       "    async text() {\n",
       "      return this._.async(\"text\");\n",
       "    }\n",
       "    async json() {\n",
       "      return JSON.parse(await this.text());\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function canvas(width, height) {\n",
       "    var canvas = document.createElement(\"canvas\");\n",
       "    canvas.width = width;\n",
       "    canvas.height = height;\n",
       "    return canvas;\n",
       "  }\n",
       "\n",
       "  function context2d(width, height, dpi) {\n",
       "    if (dpi == null) dpi = devicePixelRatio;\n",
       "    var canvas = document.createElement(\"canvas\");\n",
       "    canvas.width = width * dpi;\n",
       "    canvas.height = height * dpi;\n",
       "    canvas.style.width = width + \"px\";\n",
       "    var context = canvas.getContext(\"2d\");\n",
       "    context.scale(dpi, dpi);\n",
       "    return context;\n",
       "  }\n",
       "\n",
       "  function download(value, name = \"untitled\", label = \"Save\") {\n",
       "    const a = document.createElement(\"a\");\n",
       "    const b = a.appendChild(document.createElement(\"button\"));\n",
       "    b.textContent = label;\n",
       "    a.download = name;\n",
       "\n",
       "    async function reset() {\n",
       "      await new Promise(requestAnimationFrame);\n",
       "      URL.revokeObjectURL(a.href);\n",
       "      a.removeAttribute(\"href\");\n",
       "      b.textContent = label;\n",
       "      b.disabled = false;\n",
       "    }\n",
       "\n",
       "    a.onclick = async event => {\n",
       "      b.disabled = true;\n",
       "      if (a.href) return reset(); // Already saved.\n",
       "      b.textContent = \"Saving…\";\n",
       "      try {\n",
       "        const object = await (typeof value === \"function\" ? value() : value);\n",
       "        b.textContent = \"Download\";\n",
       "        a.href = URL.createObjectURL(object); // eslint-disable-line require-atomic-updates\n",
       "      } catch (ignore) {\n",
       "        b.textContent = label;\n",
       "      }\n",
       "      if (event.eventPhase) return reset(); // Already downloaded.\n",
       "      b.disabled = false;\n",
       "    };\n",
       "\n",
       "    return a;\n",
       "  }\n",
       "\n",
       "  var namespaces = {\n",
       "    math: \"http://www.w3.org/1998/Math/MathML\",\n",
       "    svg: \"http://www.w3.org/2000/svg\",\n",
       "    xhtml: \"http://www.w3.org/1999/xhtml\",\n",
       "    xlink: \"http://www.w3.org/1999/xlink\",\n",
       "    xml: \"http://www.w3.org/XML/1998/namespace\",\n",
       "    xmlns: \"http://www.w3.org/2000/xmlns/\"\n",
       "  };\n",
       "\n",
       "  function element\\$1(name, attributes) {\n",
       "    var prefix = name += \"\", i = prefix.indexOf(\":\"), value;\n",
       "    if (i >= 0 && (prefix = name.slice(0, i)) !== \"xmlns\") name = name.slice(i + 1);\n",
       "    var element = namespaces.hasOwnProperty(prefix) // eslint-disable-line no-prototype-builtins\n",
       "        ? document.createElementNS(namespaces[prefix], name)\n",
       "        : document.createElement(name);\n",
       "    if (attributes) for (var key in attributes) {\n",
       "      prefix = key, i = prefix.indexOf(\":\"), value = attributes[key];\n",
       "      if (i >= 0 && (prefix = key.slice(0, i)) !== \"xmlns\") key = key.slice(i + 1);\n",
       "      if (namespaces.hasOwnProperty(prefix)) element.setAttributeNS(namespaces[prefix], key, value); // eslint-disable-line no-prototype-builtins\n",
       "      else element.setAttribute(key, value);\n",
       "    }\n",
       "    return element;\n",
       "  }\n",
       "\n",
       "  function input(type) {\n",
       "    var input = document.createElement(\"input\");\n",
       "    if (type != null) input.type = type;\n",
       "    return input;\n",
       "  }\n",
       "\n",
       "  function range(min, max, step) {\n",
       "    if (arguments.length === 1) max = min, min = null;\n",
       "    var input = document.createElement(\"input\");\n",
       "    input.min = min = min == null ? 0 : +min;\n",
       "    input.max = max = max == null ? 1 : +max;\n",
       "    input.step = step == null ? \"any\" : step = +step;\n",
       "    input.type = \"range\";\n",
       "    return input;\n",
       "  }\n",
       "\n",
       "  function select(values) {\n",
       "    var select = document.createElement(\"select\");\n",
       "    Array.prototype.forEach.call(values, function(value) {\n",
       "      var option = document.createElement(\"option\");\n",
       "      option.value = option.textContent = value;\n",
       "      select.appendChild(option);\n",
       "    });\n",
       "    return select;\n",
       "  }\n",
       "\n",
       "  function svg(width, height) {\n",
       "    var svg = document.createElementNS(\"http://www.w3.org/2000/svg\", \"svg\");\n",
       "    svg.setAttribute(\"viewBox\", [0, 0, width, height]);\n",
       "    svg.setAttribute(\"width\", width);\n",
       "    svg.setAttribute(\"height\", height);\n",
       "    return svg;\n",
       "  }\n",
       "\n",
       "  function text\\$1(value) {\n",
       "    return document.createTextNode(value);\n",
       "  }\n",
       "\n",
       "  var count\\$1 = 0;\n",
       "\n",
       "  function uid(name) {\n",
       "    return new Id(\"O-\" + (name == null ? \"\" : name + \"-\") + ++count\\$1);\n",
       "  }\n",
       "\n",
       "  function Id(id) {\n",
       "    this.id = id;\n",
       "    this.href = new URL(\\`#\\${id}\\`, location) + \"\";\n",
       "  }\n",
       "\n",
       "  Id.prototype.toString = function() {\n",
       "    return \"url(\" + this.href + \")\";\n",
       "  };\n",
       "\n",
       "  var DOM = {\n",
       "    canvas: canvas,\n",
       "    context2d: context2d,\n",
       "    download: download,\n",
       "    element: element\\$1,\n",
       "    input: input,\n",
       "    range: range,\n",
       "    select: select,\n",
       "    svg: svg,\n",
       "    text: text\\$1,\n",
       "    uid: uid\n",
       "  };\n",
       "\n",
       "  function buffer(file) {\n",
       "    return new Promise(function(resolve, reject) {\n",
       "      var reader = new FileReader;\n",
       "      reader.onload = function() { resolve(reader.result); };\n",
       "      reader.onerror = reject;\n",
       "      reader.readAsArrayBuffer(file);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function text\\$2(file) {\n",
       "    return new Promise(function(resolve, reject) {\n",
       "      var reader = new FileReader;\n",
       "      reader.onload = function() { resolve(reader.result); };\n",
       "      reader.onerror = reject;\n",
       "      reader.readAsText(file);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function url(file) {\n",
       "    return new Promise(function(resolve, reject) {\n",
       "      var reader = new FileReader;\n",
       "      reader.onload = function() { resolve(reader.result); };\n",
       "      reader.onerror = reject;\n",
       "      reader.readAsDataURL(file);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  var Files = {\n",
       "    buffer: buffer,\n",
       "    text: text\\$2,\n",
       "    url: url\n",
       "  };\n",
       "\n",
       "  function that() {\n",
       "    return this;\n",
       "  }\n",
       "\n",
       "  function disposable(value, dispose) {\n",
       "    let done = false;\n",
       "    if (typeof dispose !== \"function\") {\n",
       "      throw new Error(\"dispose is not a function\");\n",
       "    }\n",
       "    return {\n",
       "      [Symbol.iterator]: that,\n",
       "      next: () => done ? {done: true} : (done = true, {done: false, value}),\n",
       "      return: () => (done = true, dispose(value), {done: true}),\n",
       "      throw: () => ({done: done = true})\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function* filter(iterator, test) {\n",
       "    var result, index = -1;\n",
       "    while (!(result = iterator.next()).done) {\n",
       "      if (test(result.value, ++index)) {\n",
       "        yield result.value;\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function observe(initialize) {\n",
       "    let stale = false;\n",
       "    let value;\n",
       "    let resolve;\n",
       "    const dispose = initialize(change);\n",
       "\n",
       "    if (dispose != null && typeof dispose !== \"function\") {\n",
       "      throw new Error(typeof dispose.then === \"function\"\n",
       "          ? \"async initializers are not supported\"\n",
       "          : \"initializer returned something, but not a dispose function\");\n",
       "    }\n",
       "\n",
       "    function change(x) {\n",
       "      if (resolve) resolve(x), resolve = null;\n",
       "      else stale = true;\n",
       "      return value = x;\n",
       "    }\n",
       "\n",
       "    function next() {\n",
       "      return {done: false, value: stale\n",
       "          ? (stale = false, Promise.resolve(value))\n",
       "          : new Promise(_ => (resolve = _))};\n",
       "    }\n",
       "\n",
       "    return {\n",
       "      [Symbol.iterator]: that,\n",
       "      throw: () => ({done: true}),\n",
       "      return: () => (dispose != null && dispose(), {done: true}),\n",
       "      next\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function input\\$1(input) {\n",
       "    return observe(function(change) {\n",
       "      var event = eventof(input), value = valueof\\$1(input);\n",
       "      function inputted() { change(valueof\\$1(input)); }\n",
       "      input.addEventListener(event, inputted);\n",
       "      if (value !== undefined) change(value);\n",
       "      return function() { input.removeEventListener(event, inputted); };\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function valueof\\$1(input) {\n",
       "    switch (input.type) {\n",
       "      case \"range\":\n",
       "      case \"number\": return input.valueAsNumber;\n",
       "      case \"date\": return input.valueAsDate;\n",
       "      case \"checkbox\": return input.checked;\n",
       "      case \"file\": return input.multiple ? input.files : input.files[0];\n",
       "      case \"select-multiple\": return Array.from(input.selectedOptions, o => o.value);\n",
       "      default: return input.value;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function eventof(input) {\n",
       "    switch (input.type) {\n",
       "      case \"button\":\n",
       "      case \"submit\":\n",
       "      case \"checkbox\": return \"click\";\n",
       "      case \"file\": return \"change\";\n",
       "      default: return \"input\";\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function* map\\$1(iterator, transform) {\n",
       "    var result, index = -1;\n",
       "    while (!(result = iterator.next()).done) {\n",
       "      yield transform(result.value, ++index);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function queue\\$1(initialize) {\n",
       "    let resolve;\n",
       "    const queue = [];\n",
       "    const dispose = initialize(push);\n",
       "\n",
       "    if (dispose != null && typeof dispose !== \"function\") {\n",
       "      throw new Error(typeof dispose.then === \"function\"\n",
       "          ? \"async initializers are not supported\"\n",
       "          : \"initializer returned something, but not a dispose function\");\n",
       "    }\n",
       "\n",
       "    function push(x) {\n",
       "      queue.push(x);\n",
       "      if (resolve) resolve(queue.shift()), resolve = null;\n",
       "      return x;\n",
       "    }\n",
       "\n",
       "    function next() {\n",
       "      return {done: false, value: queue.length\n",
       "          ? Promise.resolve(queue.shift())\n",
       "          : new Promise(_ => (resolve = _))};\n",
       "    }\n",
       "\n",
       "    return {\n",
       "      [Symbol.iterator]: that,\n",
       "      throw: () => ({done: true}),\n",
       "      return: () => (dispose != null && dispose(), {done: true}),\n",
       "      next\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function* range\\$1(start, stop, step) {\n",
       "    start = +start;\n",
       "    stop = +stop;\n",
       "    step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;\n",
       "    var i = -1, n = Math.max(0, Math.ceil((stop - start) / step)) | 0;\n",
       "    while (++i < n) {\n",
       "      yield start + i * step;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function valueAt(iterator, i) {\n",
       "    if (!isFinite(i = +i) || i < 0 || i !== i | 0) return;\n",
       "    var result, index = -1;\n",
       "    while (!(result = iterator.next()).done) {\n",
       "      if (++index === i) {\n",
       "        return result.value;\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function worker(source) {\n",
       "    const url = URL.createObjectURL(new Blob([source], {type: \"text/javascript\"}));\n",
       "    const worker = new Worker(url);\n",
       "    return disposable(worker, () => {\n",
       "      worker.terminate();\n",
       "      URL.revokeObjectURL(url);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  var Generators = {\n",
       "    disposable: disposable,\n",
       "    filter: filter,\n",
       "    input: input\\$1,\n",
       "    map: map\\$1,\n",
       "    observe: observe,\n",
       "    queue: queue\\$1,\n",
       "    range: range\\$1,\n",
       "    valueAt: valueAt,\n",
       "    worker: worker\n",
       "  };\n",
       "\n",
       "  function template(render, wrapper) {\n",
       "    return function(strings) {\n",
       "      var string = strings[0],\n",
       "          parts = [], part,\n",
       "          root = null,\n",
       "          node, nodes,\n",
       "          walker,\n",
       "          i, n, j, m, k = -1;\n",
       "\n",
       "      // Concatenate the text using comments as placeholders.\n",
       "      for (i = 1, n = arguments.length; i < n; ++i) {\n",
       "        part = arguments[i];\n",
       "        if (part instanceof Node) {\n",
       "          parts[++k] = part;\n",
       "          string += \"<!--o:\" + k + \"-->\";\n",
       "        } else if (Array.isArray(part)) {\n",
       "          for (j = 0, m = part.length; j < m; ++j) {\n",
       "            node = part[j];\n",
       "            if (node instanceof Node) {\n",
       "              if (root === null) {\n",
       "                parts[++k] = root = document.createDocumentFragment();\n",
       "                string += \"<!--o:\" + k + \"-->\";\n",
       "              }\n",
       "              root.appendChild(node);\n",
       "            } else {\n",
       "              root = null;\n",
       "              string += node;\n",
       "            }\n",
       "          }\n",
       "          root = null;\n",
       "        } else {\n",
       "          string += part;\n",
       "        }\n",
       "        string += strings[i];\n",
       "      }\n",
       "\n",
       "      // Render the text.\n",
       "      root = render(string);\n",
       "\n",
       "      // Walk the rendered content to replace comment placeholders.\n",
       "      if (++k > 0) {\n",
       "        nodes = new Array(k);\n",
       "        walker = document.createTreeWalker(root, NodeFilter.SHOW_COMMENT, null, false);\n",
       "        while (walker.nextNode()) {\n",
       "          node = walker.currentNode;\n",
       "          if (/^o:/.test(node.nodeValue)) {\n",
       "            nodes[+node.nodeValue.slice(2)] = node;\n",
       "          }\n",
       "        }\n",
       "        for (i = 0; i < k; ++i) {\n",
       "          if (node = nodes[i]) {\n",
       "            node.parentNode.replaceChild(parts[i], node);\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "\n",
       "      // Is the rendered content\n",
       "      // … a parent of a single child? Detach and return the child.\n",
       "      // … a document fragment? Replace the fragment with an element.\n",
       "      // … some other node? Return it.\n",
       "      return root.childNodes.length === 1 ? root.removeChild(root.firstChild)\n",
       "          : root.nodeType === 11 ? ((node = wrapper()).appendChild(root), node)\n",
       "          : root;\n",
       "    };\n",
       "  }\n",
       "\n",
       "  var html = template(function(string) {\n",
       "    var template = document.createElement(\"template\");\n",
       "    template.innerHTML = string.trim();\n",
       "    return document.importNode(template.content, true);\n",
       "  }, function() {\n",
       "    return document.createElement(\"span\");\n",
       "  });\n",
       "\n",
       "  function md(require) {\n",
       "    return require(marked.resolve()).then(function(marked) {\n",
       "      return template(\n",
       "        function(string) {\n",
       "          var root = document.createElement(\"div\");\n",
       "          root.innerHTML = marked(string, {langPrefix: \"\"}).trim();\n",
       "          var code = root.querySelectorAll(\"pre code[class]\");\n",
       "          if (code.length > 0) {\n",
       "            require(highlight.resolve()).then(function(hl) {\n",
       "              code.forEach(function(block) {\n",
       "                function done() {\n",
       "                  hl.highlightBlock(block);\n",
       "                  block.parentNode.classList.add(\"observablehq--md-pre\");\n",
       "                }\n",
       "                if (hl.getLanguage(block.className)) {\n",
       "                  done();\n",
       "                } else {\n",
       "                  require(highlight.resolve(\"async-languages/index.js\"))\n",
       "                    .then(index => {\n",
       "                      if (index.has(block.className)) {\n",
       "                        return require(highlight.resolve(\"async-languages/\" + index.get(block.className))).then(language => {\n",
       "                          hl.registerLanguage(block.className, language);\n",
       "                        });\n",
       "                      }\n",
       "                    })\n",
       "                    .then(done, done);\n",
       "                }\n",
       "              });\n",
       "            });\n",
       "          }\n",
       "          return root;\n",
       "        },\n",
       "        function() {\n",
       "          return document.createElement(\"div\");\n",
       "        }\n",
       "      );\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function Mutable(value) {\n",
       "    let change;\n",
       "    Object.defineProperties(this, {\n",
       "      generator: {value: observe(_ => void (change = _))},\n",
       "      value: {get: () => value, set: x => change(value = x)} // eslint-disable-line no-setter-return\n",
       "    });\n",
       "    if (value !== undefined) change(value);\n",
       "  }\n",
       "\n",
       "  function* now() {\n",
       "    while (true) {\n",
       "      yield Date.now();\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function delay(duration, value) {\n",
       "    return new Promise(function(resolve) {\n",
       "      setTimeout(function() {\n",
       "        resolve(value);\n",
       "      }, duration);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  var timeouts = new Map;\n",
       "\n",
       "  function timeout(now, time) {\n",
       "    var t = new Promise(function(resolve) {\n",
       "      timeouts.delete(time);\n",
       "      var delay = time - now;\n",
       "      if (!(delay > 0)) throw new Error(\"invalid time\");\n",
       "      if (delay > 0x7fffffff) throw new Error(\"too long to wait\");\n",
       "      setTimeout(resolve, delay);\n",
       "    });\n",
       "    timeouts.set(time, t);\n",
       "    return t;\n",
       "  }\n",
       "\n",
       "  function when(time, value) {\n",
       "    var now;\n",
       "    return (now = timeouts.get(time = +time)) ? now.then(() => value)\n",
       "        : (now = Date.now()) >= time ? Promise.resolve(value)\n",
       "        : timeout(now, time).then(() => value);\n",
       "  }\n",
       "\n",
       "  function tick(duration, value) {\n",
       "    return when(Math.ceil((Date.now() + 1) / duration) * duration, value);\n",
       "  }\n",
       "\n",
       "  var Promises = {\n",
       "    delay: delay,\n",
       "    tick: tick,\n",
       "    when: when\n",
       "  };\n",
       "\n",
       "  function resolve\\$1(name, base) {\n",
       "    if (/^(\\\\w+:)|\\\\/\\\\//i.test(name)) return name;\n",
       "    if (/^[.]{0,2}\\\\//i.test(name)) return new URL(name, base == null ? location : base).href;\n",
       "    if (!name.length || /^[\\\\s._]/.test(name) || /\\\\s\\$/.test(name)) throw new Error(\"illegal name\");\n",
       "    return \"https://unpkg.com/\" + name;\n",
       "  }\n",
       "\n",
       "  function requirer(resolve) {\n",
       "    return resolve == null ? require : requireFrom(resolve);\n",
       "  }\n",
       "\n",
       "  var svg\\$1 = template(function(string) {\n",
       "    var root = document.createElementNS(\"http://www.w3.org/2000/svg\", \"g\");\n",
       "    root.innerHTML = string.trim();\n",
       "    return root;\n",
       "  }, function() {\n",
       "    return document.createElementNS(\"http://www.w3.org/2000/svg\", \"g\");\n",
       "  });\n",
       "\n",
       "  var raw = String.raw;\n",
       "\n",
       "  function style(href) {\n",
       "    return new Promise(function(resolve, reject) {\n",
       "      var link = document.createElement(\"link\");\n",
       "      link.rel = \"stylesheet\";\n",
       "      link.href = href;\n",
       "      link.onerror = reject;\n",
       "      link.onload = resolve;\n",
       "      document.head.appendChild(link);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function tex(require) {\n",
       "    return Promise.all([\n",
       "      require(katex.resolve()),\n",
       "      style(katex.resolve(\"dist/katex.min.css\"))\n",
       "    ]).then(function(values) {\n",
       "      var katex = values[0], tex = renderer();\n",
       "\n",
       "      function renderer(options) {\n",
       "        return function() {\n",
       "          var root = document.createElement(\"div\");\n",
       "          katex.render(raw.apply(String, arguments), root, options);\n",
       "          return root.removeChild(root.firstChild);\n",
       "        };\n",
       "      }\n",
       "\n",
       "      tex.options = renderer;\n",
       "      tex.block = renderer({displayMode: true});\n",
       "      return tex;\n",
       "    });\n",
       "  }\n",
       "\n",
       "  async function vl(require) {\n",
       "    const [v, vl, api] = await Promise.all([vega, vegalite, vegaliteApi].map(d => require(d.resolve())));\n",
       "    return api.register(v, vl);\n",
       "  }\n",
       "\n",
       "  function width() {\n",
       "    return observe(function(change) {\n",
       "      var width = change(document.body.clientWidth);\n",
       "      function resized() {\n",
       "        var w = document.body.clientWidth;\n",
       "        if (w !== width) change(width = w);\n",
       "      }\n",
       "      window.addEventListener(\"resize\", resized);\n",
       "      return function() {\n",
       "        window.removeEventListener(\"resize\", resized);\n",
       "      };\n",
       "    });\n",
       "  }\n",
       "\n",
       "  var Library = Object.assign(function Library(resolver) {\n",
       "    const require = requirer(resolver);\n",
       "    Object.defineProperties(this, properties({\n",
       "      FileAttachment: () => NoFileAttachments,\n",
       "      Arrow: () => require(arrow.resolve()),\n",
       "      Inputs: () => require(inputs.resolve()),\n",
       "      Mutable: () => Mutable,\n",
       "      Plot: () => require(plot.resolve()),\n",
       "      SQLite: () => sqlite(require),\n",
       "      SQLiteDatabaseClient: () => SQLiteDatabaseClient,\n",
       "      _: () => require(lodash.resolve()),\n",
       "      aq: () => require.alias({\"apache-arrow\": arrow.resolve()})(arquero.resolve()),\n",
       "      d3: () => require(d3.resolve()),\n",
       "      dot: () => require(graphviz.resolve()),\n",
       "      htl: () => require(htl.resolve()),\n",
       "      html: () => html,\n",
       "      md: () => md(require),\n",
       "      now,\n",
       "      require: () => require,\n",
       "      resolve: () => resolve\\$1,\n",
       "      svg: () => svg\\$1,\n",
       "      tex: () => tex(require),\n",
       "      topojson: () => require(topojson.resolve()),\n",
       "      vl: () => vl(require),\n",
       "      width,\n",
       "\n",
       "      // Note: these are namespace objects, and thus exposed directly rather than\n",
       "      // being wrapped in a function. This allows library.Generators to resolve,\n",
       "      // rather than needing module.value.\n",
       "      DOM,\n",
       "      Files,\n",
       "      Generators,\n",
       "      Promises\n",
       "    }));\n",
       "  }, {resolve: require.resolve});\n",
       "\n",
       "  function properties(values) {\n",
       "    return Object.fromEntries(Object.entries(values).map(property));\n",
       "  }\n",
       "\n",
       "  function property([key, value]) {\n",
       "    return [key, ({value, writable: true, enumerable: true})];\n",
       "  }\n",
       "\n",
       "  function RuntimeError(message, input) {\n",
       "    this.message = message + \"\";\n",
       "    this.input = input;\n",
       "  }\n",
       "\n",
       "  RuntimeError.prototype = Object.create(Error.prototype);\n",
       "  RuntimeError.prototype.name = \"RuntimeError\";\n",
       "  RuntimeError.prototype.constructor = RuntimeError;\n",
       "\n",
       "  function generatorish(value) {\n",
       "    return value\n",
       "        && typeof value.next === \"function\"\n",
       "        && typeof value.return === \"function\";\n",
       "  }\n",
       "\n",
       "  function load\\$1(notebook, library, observer) {\n",
       "    if (typeof library == \"function\") observer = library, library = null;\n",
       "    if (typeof observer !== \"function\") throw new Error(\"invalid observer\");\n",
       "    if (library == null) library = new Library();\n",
       "\n",
       "    const {modules, id} = notebook;\n",
       "    const map = new Map;\n",
       "    const runtime = new Runtime(library);\n",
       "    const main = runtime_module(id);\n",
       "\n",
       "    function runtime_module(id) {\n",
       "      let module = map.get(id);\n",
       "      if (!module) map.set(id, module = runtime.module());\n",
       "      return module;\n",
       "    }\n",
       "\n",
       "    for (const m of modules) {\n",
       "      const module = runtime_module(m.id);\n",
       "      let i = 0;\n",
       "      for (const v of m.variables) {\n",
       "        if (v.from) module.import(v.remote, v.name, runtime_module(v.from));\n",
       "        else if (module === main) module.variable(observer(v, i, m.variables)).define(v.name, v.inputs, v.value);\n",
       "        else module.define(v.name, v.inputs, v.value);\n",
       "        ++i;\n",
       "      }\n",
       "    }\n",
       "\n",
       "    return runtime;\n",
       "  }\n",
       "\n",
       "  var prototype = Array.prototype;\n",
       "  var map\\$2 = prototype.map;\n",
       "  var forEach = prototype.forEach;\n",
       "\n",
       "  function constant(x) {\n",
       "    return function() {\n",
       "      return x;\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function identity(x) {\n",
       "    return x;\n",
       "  }\n",
       "\n",
       "  function rethrow(e) {\n",
       "    return function() {\n",
       "      throw e;\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function noop() {}\n",
       "\n",
       "  var TYPE_NORMAL = 1; // a normal variable\n",
       "  var TYPE_IMPLICIT = 2; // created on reference\n",
       "  var TYPE_DUPLICATE = 3; // created on duplicate definition\n",
       "\n",
       "  var no_observer = {};\n",
       "\n",
       "  function Variable(type, module, observer) {\n",
       "    if (!observer) observer = no_observer;\n",
       "    Object.defineProperties(this, {\n",
       "      _observer: {value: observer, writable: true},\n",
       "      _definition: {value: variable_undefined, writable: true},\n",
       "      _duplicate: {value: undefined, writable: true},\n",
       "      _duplicates: {value: undefined, writable: true},\n",
       "      _indegree: {value: NaN, writable: true}, // The number of computing inputs.\n",
       "      _inputs: {value: [], writable: true},\n",
       "      _invalidate: {value: noop, writable: true},\n",
       "      _module: {value: module},\n",
       "      _name: {value: null, writable: true},\n",
       "      _outputs: {value: new Set, writable: true},\n",
       "      _promise: {value: Promise.resolve(undefined), writable: true},\n",
       "      _reachable: {value: observer !== no_observer, writable: true}, // Is this variable transitively visible?\n",
       "      _rejector: {value: variable_rejector(this)},\n",
       "      _type: {value: type},\n",
       "      _value: {value: undefined, writable: true},\n",
       "      _version: {value: 0, writable: true}\n",
       "    });\n",
       "  }\n",
       "\n",
       "  Object.defineProperties(Variable.prototype, {\n",
       "    _pending: {value: variable_pending, writable: true, configurable: true},\n",
       "    _fulfilled: {value: variable_fulfilled, writable: true, configurable: true},\n",
       "    _rejected: {value: variable_rejected, writable: true, configurable: true},\n",
       "    define: {value: variable_define, writable: true, configurable: true},\n",
       "    delete: {value: variable_delete, writable: true, configurable: true},\n",
       "    import: {value: variable_import, writable: true, configurable: true}\n",
       "  });\n",
       "\n",
       "  function variable_attach(variable) {\n",
       "    variable._module._runtime._dirty.add(variable);\n",
       "    variable._outputs.add(this);\n",
       "  }\n",
       "\n",
       "  function variable_detach(variable) {\n",
       "    variable._module._runtime._dirty.add(variable);\n",
       "    variable._outputs.delete(this);\n",
       "  }\n",
       "\n",
       "  function variable_undefined() {\n",
       "    throw variable_undefined;\n",
       "  }\n",
       "\n",
       "  function variable_stale() {\n",
       "    throw variable_stale;\n",
       "  }\n",
       "\n",
       "  function variable_rejector(variable) {\n",
       "    return function(error) {\n",
       "      if (error === variable_stale) throw error;\n",
       "      if (error === variable_undefined) throw new RuntimeError(variable._name + \" is not defined\", variable._name);\n",
       "      if (error instanceof Error && error.message) throw new RuntimeError(error.message, variable._name);\n",
       "      throw new RuntimeError(variable._name + \" could not be resolved\", variable._name);\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function variable_duplicate(name) {\n",
       "    return function() {\n",
       "      throw new RuntimeError(name + \" is defined more than once\");\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function variable_define(name, inputs, definition) {\n",
       "    switch (arguments.length) {\n",
       "      case 1: {\n",
       "        definition = name, name = inputs = null;\n",
       "        break;\n",
       "      }\n",
       "      case 2: {\n",
       "        definition = inputs;\n",
       "        if (typeof name === \"string\") inputs = null;\n",
       "        else inputs = name, name = null;\n",
       "        break;\n",
       "      }\n",
       "    }\n",
       "    return variable_defineImpl.call(this,\n",
       "      name == null ? null : name + \"\",\n",
       "      inputs == null ? [] : map\\$2.call(inputs, this._module._resolve, this._module),\n",
       "      typeof definition === \"function\" ? definition : constant(definition)\n",
       "    );\n",
       "  }\n",
       "\n",
       "  function variable_defineImpl(name, inputs, definition) {\n",
       "    var scope = this._module._scope, runtime = this._module._runtime;\n",
       "\n",
       "    this._inputs.forEach(variable_detach, this);\n",
       "    inputs.forEach(variable_attach, this);\n",
       "    this._inputs = inputs;\n",
       "    this._definition = definition;\n",
       "    this._value = undefined;\n",
       "\n",
       "    // Is this an active variable (that may require disposal)?\n",
       "    if (definition === noop) runtime._variables.delete(this);\n",
       "    else runtime._variables.add(this);\n",
       "\n",
       "    // Did the variable’s name change? Time to patch references!\n",
       "    if (name !== this._name || scope.get(name) !== this) {\n",
       "      var error, found;\n",
       "\n",
       "      if (this._name) { // Did this variable previously have a name?\n",
       "        if (this._outputs.size) { // And did other variables reference this variable?\n",
       "          scope.delete(this._name);\n",
       "          found = this._module._resolve(this._name);\n",
       "          found._outputs = this._outputs, this._outputs = new Set;\n",
       "          found._outputs.forEach(function(output) { output._inputs[output._inputs.indexOf(this)] = found; }, this);\n",
       "          found._outputs.forEach(runtime._updates.add, runtime._updates);\n",
       "          runtime._dirty.add(found).add(this);\n",
       "          scope.set(this._name, found);\n",
       "        } else if ((found = scope.get(this._name)) === this) { // Do no other variables reference this variable?\n",
       "          scope.delete(this._name); // It’s safe to delete!\n",
       "        } else if (found._type === TYPE_DUPLICATE) { // Do other variables assign this name?\n",
       "          found._duplicates.delete(this); // This variable no longer assigns this name.\n",
       "          this._duplicate = undefined;\n",
       "          if (found._duplicates.size === 1) { // Is there now only one variable assigning this name?\n",
       "            found = found._duplicates.keys().next().value; // Any references are now fixed!\n",
       "            error = scope.get(this._name);\n",
       "            found._outputs = error._outputs, error._outputs = new Set;\n",
       "            found._outputs.forEach(function(output) { output._inputs[output._inputs.indexOf(error)] = found; });\n",
       "            found._definition = found._duplicate, found._duplicate = undefined;\n",
       "            runtime._dirty.add(error).add(found);\n",
       "            runtime._updates.add(found);\n",
       "            scope.set(this._name, found);\n",
       "          }\n",
       "        } else {\n",
       "          throw new Error;\n",
       "        }\n",
       "      }\n",
       "\n",
       "      if (this._outputs.size) throw new Error;\n",
       "\n",
       "      if (name) { // Does this variable have a new name?\n",
       "        if (found = scope.get(name)) { // Do other variables reference or assign this name?\n",
       "          if (found._type === TYPE_DUPLICATE) { // Do multiple other variables already define this name?\n",
       "            this._definition = variable_duplicate(name), this._duplicate = definition;\n",
       "            found._duplicates.add(this);\n",
       "          } else if (found._type === TYPE_IMPLICIT) { // Are the variable references broken?\n",
       "            this._outputs = found._outputs, found._outputs = new Set; // Now they’re fixed!\n",
       "            this._outputs.forEach(function(output) { output._inputs[output._inputs.indexOf(found)] = this; }, this);\n",
       "            runtime._dirty.add(found).add(this);\n",
       "            scope.set(name, this);\n",
       "          } else { // Does another variable define this name?\n",
       "            found._duplicate = found._definition, this._duplicate = definition; // Now they’re duplicates.\n",
       "            error = new Variable(TYPE_DUPLICATE, this._module);\n",
       "            error._name = name;\n",
       "            error._definition = this._definition = found._definition = variable_duplicate(name);\n",
       "            error._outputs = found._outputs, found._outputs = new Set;\n",
       "            error._outputs.forEach(function(output) { output._inputs[output._inputs.indexOf(found)] = error; });\n",
       "            error._duplicates = new Set([this, found]);\n",
       "            runtime._dirty.add(found).add(error);\n",
       "            runtime._updates.add(found).add(error);\n",
       "            scope.set(name, error);\n",
       "          }\n",
       "        } else {\n",
       "          scope.set(name, this);\n",
       "        }\n",
       "      }\n",
       "\n",
       "      this._name = name;\n",
       "    }\n",
       "\n",
       "    // If this redefined variable was previously evaluated, invalidate it. (If the\n",
       "    // variable was never evaluated, then the invalidated value could never have\n",
       "    // been exposed and we can avoid this extra work.)\n",
       "    if (this._version > 0) ++this._version;\n",
       "\n",
       "    runtime._updates.add(this);\n",
       "    runtime._compute();\n",
       "    return this;\n",
       "  }\n",
       "\n",
       "  function variable_import(remote, name, module) {\n",
       "    if (arguments.length < 3) module = name, name = remote;\n",
       "    return variable_defineImpl.call(this, name + \"\", [module._resolve(remote + \"\")], identity);\n",
       "  }\n",
       "\n",
       "  function variable_delete() {\n",
       "    return variable_defineImpl.call(this, null, [], noop);\n",
       "  }\n",
       "\n",
       "  function variable_pending() {\n",
       "    if (this._observer.pending) this._observer.pending();\n",
       "  }\n",
       "\n",
       "  function variable_fulfilled(value) {\n",
       "    if (this._observer.fulfilled) this._observer.fulfilled(value, this._name);\n",
       "  }\n",
       "\n",
       "  function variable_rejected(error) {\n",
       "    if (this._observer.rejected) this._observer.rejected(error, this._name);\n",
       "  }\n",
       "\n",
       "  function Module(runtime, builtins = []) {\n",
       "    Object.defineProperties(this, {\n",
       "      _runtime: {value: runtime},\n",
       "      _scope: {value: new Map},\n",
       "      _builtins: {value: new Map([\n",
       "        [\"invalidation\", variable_invalidation],\n",
       "        [\"visibility\", variable_visibility],\n",
       "        ...builtins\n",
       "      ])},\n",
       "      _source: {value: null, writable: true}\n",
       "    });\n",
       "  }\n",
       "\n",
       "  Object.defineProperties(Module.prototype, {\n",
       "    _copy: {value: module_copy, writable: true, configurable: true},\n",
       "    _resolve: {value: module_resolve, writable: true, configurable: true},\n",
       "    redefine: {value: module_redefine, writable: true, configurable: true},\n",
       "    define: {value: module_define, writable: true, configurable: true},\n",
       "    derive: {value: module_derive, writable: true, configurable: true},\n",
       "    import: {value: module_import, writable: true, configurable: true},\n",
       "    value: {value: module_value, writable: true, configurable: true},\n",
       "    variable: {value: module_variable, writable: true, configurable: true},\n",
       "    builtin: {value: module_builtin, writable: true, configurable: true}\n",
       "  });\n",
       "\n",
       "  function module_redefine(name) {\n",
       "    var v = this._scope.get(name);\n",
       "    if (!v) throw new RuntimeError(name + \" is not defined\");\n",
       "    if (v._type === TYPE_DUPLICATE) throw new RuntimeError(name + \" is defined more than once\");\n",
       "    return v.define.apply(v, arguments);\n",
       "  }\n",
       "\n",
       "  function module_define() {\n",
       "    var v = new Variable(TYPE_NORMAL, this);\n",
       "    return v.define.apply(v, arguments);\n",
       "  }\n",
       "\n",
       "  function module_import() {\n",
       "    var v = new Variable(TYPE_NORMAL, this);\n",
       "    return v.import.apply(v, arguments);\n",
       "  }\n",
       "\n",
       "  function module_variable(observer) {\n",
       "    return new Variable(TYPE_NORMAL, this, observer);\n",
       "  }\n",
       "\n",
       "  async function module_value(name) {\n",
       "    var v = this._scope.get(name);\n",
       "    if (!v) throw new RuntimeError(name + \" is not defined\");\n",
       "    if (v._observer === no_observer) {\n",
       "      v._observer = true;\n",
       "      this._runtime._dirty.add(v);\n",
       "    }\n",
       "    return module_revalue(this._runtime, v);\n",
       "  }\n",
       "\n",
       "  // If the variable is redefined before its value resolves, try again.\n",
       "  async function module_revalue(runtime, variable) {\n",
       "    await runtime._compute();\n",
       "    try {\n",
       "      return await variable._promise;\n",
       "    } catch (error) {\n",
       "      if (error === variable_stale) return module_revalue(runtime, variable);\n",
       "      throw error;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function module_derive(injects, injectModule) {\n",
       "    var copy = new Module(this._runtime, this._builtins);\n",
       "    copy._source = this;\n",
       "    forEach.call(injects, function(inject) {\n",
       "      if (typeof inject !== \"object\") inject = {name: inject + \"\"};\n",
       "      if (inject.alias == null) inject.alias = inject.name;\n",
       "      copy.import(inject.name, inject.alias, injectModule);\n",
       "    });\n",
       "    Promise.resolve().then(() => {\n",
       "      const modules = new Set([this]);\n",
       "      for (const module of modules) {\n",
       "        for (const variable of module._scope.values()) {\n",
       "          if (variable._definition === identity) { // import\n",
       "            const module = variable._inputs[0]._module;\n",
       "            const source = module._source || module;\n",
       "            if (source === this) { // circular import-with!\n",
       "              console.warn(\"circular module definition; ignoring\"); // eslint-disable-line no-console\n",
       "              return;\n",
       "            }\n",
       "            modules.add(source);\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "      this._copy(copy, new Map);\n",
       "    });\n",
       "    return copy;\n",
       "  }\n",
       "\n",
       "  function module_copy(copy, map) {\n",
       "    copy._source = this;\n",
       "    map.set(this, copy);\n",
       "    for (const [name, source] of this._scope) {\n",
       "      var target = copy._scope.get(name);\n",
       "      if (target && target._type === TYPE_NORMAL) continue; // injection\n",
       "      if (source._definition === identity) { // import\n",
       "        var sourceInput = source._inputs[0],\n",
       "            sourceModule = sourceInput._module;\n",
       "        copy.import(sourceInput._name, name, map.get(sourceModule)\n",
       "          || (sourceModule._source\n",
       "             ? sourceModule._copy(new Module(copy._runtime, copy._builtins), map) // import-with\n",
       "             : sourceModule));\n",
       "      } else {\n",
       "        copy.define(name, source._inputs.map(variable_name), source._definition);\n",
       "      }\n",
       "    }\n",
       "    return copy;\n",
       "  }\n",
       "\n",
       "  function module_resolve(name) {\n",
       "    var variable = this._scope.get(name), value;\n",
       "    if (!variable) {\n",
       "      variable = new Variable(TYPE_IMPLICIT, this);\n",
       "      if (this._builtins.has(name)) {\n",
       "        variable.define(name, constant(this._builtins.get(name)));\n",
       "      } else if (this._runtime._builtin._scope.has(name)) {\n",
       "        variable.import(name, this._runtime._builtin);\n",
       "      } else {\n",
       "        try {\n",
       "          value = this._runtime._global(name);\n",
       "        } catch (error) {\n",
       "          return variable.define(name, rethrow(error));\n",
       "        }\n",
       "        if (value === undefined) {\n",
       "          this._scope.set(variable._name = name, variable);\n",
       "        } else {\n",
       "          variable.define(name, constant(value));\n",
       "        }\n",
       "      }\n",
       "    }\n",
       "    return variable;\n",
       "  }\n",
       "\n",
       "  function module_builtin(name, value) {\n",
       "    this._builtins.set(name, value);\n",
       "  }\n",
       "\n",
       "  function variable_name(variable) {\n",
       "    return variable._name;\n",
       "  }\n",
       "\n",
       "  const frame = typeof requestAnimationFrame === \"function\" ? requestAnimationFrame\n",
       "    : typeof setImmediate === \"function\" ? setImmediate\n",
       "    : f => setTimeout(f, 0);\n",
       "\n",
       "  var variable_invalidation = {};\n",
       "  var variable_visibility = {};\n",
       "\n",
       "  function Runtime(builtins = new Library, global = window_global) {\n",
       "    var builtin = this.module();\n",
       "    Object.defineProperties(this, {\n",
       "      _dirty: {value: new Set},\n",
       "      _updates: {value: new Set},\n",
       "      _precomputes: {value: [], writable: true},\n",
       "      _computing: {value: null, writable: true},\n",
       "      _init: {value: null, writable: true},\n",
       "      _modules: {value: new Map},\n",
       "      _variables: {value: new Set},\n",
       "      _disposed: {value: false, writable: true},\n",
       "      _builtin: {value: builtin},\n",
       "      _global: {value: global}\n",
       "    });\n",
       "    if (builtins) for (var name in builtins) {\n",
       "      (new Variable(TYPE_IMPLICIT, builtin)).define(name, [], builtins[name]);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Object.defineProperties(Runtime, {\n",
       "    load: {value: load\\$1, writable: true, configurable: true}\n",
       "  });\n",
       "\n",
       "  Object.defineProperties(Runtime.prototype, {\n",
       "    _precompute: {value: runtime_precompute, writable: true, configurable: true},\n",
       "    _compute: {value: runtime_compute, writable: true, configurable: true},\n",
       "    _computeSoon: {value: runtime_computeSoon, writable: true, configurable: true},\n",
       "    _computeNow: {value: runtime_computeNow, writable: true, configurable: true},\n",
       "    dispose: {value: runtime_dispose, writable: true, configurable: true},\n",
       "    module: {value: runtime_module, writable: true, configurable: true},\n",
       "    fileAttachments: {value: FileAttachments, writable: true, configurable: true}\n",
       "  });\n",
       "\n",
       "  function runtime_dispose() {\n",
       "    this._computing = Promise.resolve();\n",
       "    this._disposed = true;\n",
       "    this._variables.forEach(v => {\n",
       "      v._invalidate();\n",
       "      v._version = NaN;\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function runtime_module(define, observer = noop) {\n",
       "    let module;\n",
       "    if (define === undefined) {\n",
       "      if (module = this._init) {\n",
       "        this._init = null;\n",
       "        return module;\n",
       "      }\n",
       "      return new Module(this);\n",
       "    }\n",
       "    module = this._modules.get(define);\n",
       "    if (module) return module;\n",
       "    this._init = module = new Module(this);\n",
       "    this._modules.set(define, module);\n",
       "    try {\n",
       "      define(this, observer);\n",
       "    } finally {\n",
       "      this._init = null;\n",
       "    }\n",
       "    return module;\n",
       "  }\n",
       "\n",
       "  function runtime_precompute(callback) {\n",
       "    this._precomputes.push(callback);\n",
       "    this._compute();\n",
       "  }\n",
       "\n",
       "  function runtime_compute() {\n",
       "    return this._computing || (this._computing = this._computeSoon());\n",
       "  }\n",
       "\n",
       "  function runtime_computeSoon() {\n",
       "    return new Promise(frame).then(() => this._disposed ? undefined : this._computeNow());\n",
       "  }\n",
       "\n",
       "  async function runtime_computeNow() {\n",
       "    var queue = [],\n",
       "        variables,\n",
       "        variable,\n",
       "        precomputes = this._precomputes;\n",
       "\n",
       "    // If there are any paused generators, resume them before computing so they\n",
       "    // can update (if synchronous) before computing downstream variables.\n",
       "    if (precomputes.length) {\n",
       "      this._precomputes = [];\n",
       "      for (const callback of precomputes) callback();\n",
       "      await runtime_defer(3);\n",
       "    }\n",
       "\n",
       "    // Compute the reachability of the transitive closure of dirty variables.\n",
       "    // Any newly-reachable variable must also be recomputed.\n",
       "    // Any no-longer-reachable variable must be terminated.\n",
       "    variables = new Set(this._dirty);\n",
       "    variables.forEach(function(variable) {\n",
       "      variable._inputs.forEach(variables.add, variables);\n",
       "      const reachable = variable_reachable(variable);\n",
       "      if (reachable > variable._reachable) {\n",
       "        this._updates.add(variable);\n",
       "      } else if (reachable < variable._reachable) {\n",
       "        variable._invalidate();\n",
       "      }\n",
       "      variable._reachable = reachable;\n",
       "    }, this);\n",
       "\n",
       "    // Compute the transitive closure of updating, reachable variables.\n",
       "    variables = new Set(this._updates);\n",
       "    variables.forEach(function(variable) {\n",
       "      if (variable._reachable) {\n",
       "        variable._indegree = 0;\n",
       "        variable._outputs.forEach(variables.add, variables);\n",
       "      } else {\n",
       "        variable._indegree = NaN;\n",
       "        variables.delete(variable);\n",
       "      }\n",
       "    });\n",
       "\n",
       "    this._computing = null;\n",
       "    this._updates.clear();\n",
       "    this._dirty.clear();\n",
       "\n",
       "    // Compute the indegree of updating variables.\n",
       "    variables.forEach(function(variable) {\n",
       "      variable._outputs.forEach(variable_increment);\n",
       "    });\n",
       "\n",
       "    do {\n",
       "      // Identify the root variables (those with no updating inputs).\n",
       "      variables.forEach(function(variable) {\n",
       "        if (variable._indegree === 0) {\n",
       "          queue.push(variable);\n",
       "        }\n",
       "      });\n",
       "\n",
       "      // Compute the variables in topological order.\n",
       "      while (variable = queue.pop()) {\n",
       "        variable_compute(variable);\n",
       "        variable._outputs.forEach(postqueue);\n",
       "        variables.delete(variable);\n",
       "      }\n",
       "\n",
       "      // Any remaining variables are circular, or depend on them.\n",
       "      variables.forEach(function(variable) {\n",
       "        if (variable_circular(variable)) {\n",
       "          variable_error(variable, new RuntimeError(\"circular definition\"));\n",
       "          variable._outputs.forEach(variable_decrement);\n",
       "          variables.delete(variable);\n",
       "        }\n",
       "      });\n",
       "    } while (variables.size);\n",
       "\n",
       "    function postqueue(variable) {\n",
       "      if (--variable._indegree === 0) {\n",
       "        queue.push(variable);\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  // We want to give generators, if they’re defined synchronously, a chance to\n",
       "  // update before computing downstream variables. This creates a synchronous\n",
       "  // promise chain of the given depth that we’ll await before recomputing\n",
       "  // downstream variables.\n",
       "  function runtime_defer(depth = 0) {\n",
       "    let p = Promise.resolve();\n",
       "    for (let i = 0; i < depth; ++i) p = p.then(() => {});\n",
       "    return p;\n",
       "  }\n",
       "\n",
       "  function variable_circular(variable) {\n",
       "    const inputs = new Set(variable._inputs);\n",
       "    for (const i of inputs) {\n",
       "      if (i === variable) return true;\n",
       "      i._inputs.forEach(inputs.add, inputs);\n",
       "    }\n",
       "    return false;\n",
       "  }\n",
       "\n",
       "  function variable_increment(variable) {\n",
       "    ++variable._indegree;\n",
       "  }\n",
       "\n",
       "  function variable_decrement(variable) {\n",
       "    --variable._indegree;\n",
       "  }\n",
       "\n",
       "  function variable_value(variable) {\n",
       "    return variable._promise.catch(variable._rejector);\n",
       "  }\n",
       "\n",
       "  function variable_invalidator(variable) {\n",
       "    return new Promise(function(resolve) {\n",
       "      variable._invalidate = resolve;\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function variable_intersector(invalidation, variable) {\n",
       "    let node = typeof IntersectionObserver === \"function\" && variable._observer && variable._observer._node;\n",
       "    let visible = !node, resolve = noop, reject = noop, promise, observer;\n",
       "    if (node) {\n",
       "      observer = new IntersectionObserver(([entry]) => (visible = entry.isIntersecting) && (promise = null, resolve()));\n",
       "      observer.observe(node);\n",
       "      invalidation.then(() => (observer.disconnect(), observer = null, reject()));\n",
       "    }\n",
       "    return function(value) {\n",
       "      if (visible) return Promise.resolve(value);\n",
       "      if (!observer) return Promise.reject();\n",
       "      if (!promise) promise = new Promise((y, n) => (resolve = y, reject = n));\n",
       "      return promise.then(() => value);\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function variable_compute(variable) {\n",
       "    variable._invalidate();\n",
       "    variable._invalidate = noop;\n",
       "    variable._pending();\n",
       "\n",
       "    const value0 = variable._value;\n",
       "    const version = ++variable._version;\n",
       "\n",
       "    // Lazily-constructed invalidation variable; only constructed if referenced as an input.\n",
       "    let invalidation = null;\n",
       "\n",
       "    // If the variable doesn’t have any inputs, we can optimize slightly.\n",
       "    const promise = variable._promise = (variable._inputs.length\n",
       "        ? Promise.all(variable._inputs.map(variable_value)).then(define)\n",
       "        : new Promise(resolve => resolve(variable._definition.call(value0))))\n",
       "      .then(generate);\n",
       "\n",
       "    // Compute the initial value of the variable.\n",
       "    function define(inputs) {\n",
       "      if (variable._version !== version) throw variable_stale;\n",
       "\n",
       "      // Replace any reference to invalidation with the promise, lazily.\n",
       "      for (var i = 0, n = inputs.length; i < n; ++i) {\n",
       "        switch (inputs[i]) {\n",
       "          case variable_invalidation: {\n",
       "            inputs[i] = invalidation = variable_invalidator(variable);\n",
       "            break;\n",
       "          }\n",
       "          case variable_visibility: {\n",
       "            if (!invalidation) invalidation = variable_invalidator(variable);\n",
       "            inputs[i] = variable_intersector(invalidation, variable);\n",
       "            break;\n",
       "          }\n",
       "        }\n",
       "      }\n",
       "\n",
       "      return variable._definition.apply(value0, inputs);\n",
       "    }\n",
       "\n",
       "    // If the value is a generator, then retrieve its first value, and dispose of\n",
       "    // the generator if the variable is invalidated. Note that the cell may\n",
       "    // already have been invalidated here, in which case we need to terminate the\n",
       "    // generator immediately!\n",
       "    function generate(value) {\n",
       "      if (variable._version !== version) throw variable_stale;\n",
       "      if (generatorish(value)) {\n",
       "        (invalidation || variable_invalidator(variable)).then(variable_return(value));\n",
       "        return variable_generate(variable, version, value);\n",
       "      }\n",
       "      return value;\n",
       "    }\n",
       "\n",
       "    promise.then((value) => {\n",
       "      variable._value = value;\n",
       "      variable._fulfilled(value);\n",
       "    }, (error) => {\n",
       "      if (error === variable_stale) return;\n",
       "      variable._value = undefined;\n",
       "      variable._rejected(error);\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function variable_generate(variable, version, generator) {\n",
       "    const runtime = variable._module._runtime;\n",
       "    let currentValue; // so that yield resolves to the yielded value\n",
       "\n",
       "    // Retrieve the next value from the generator; if successful, invoke the\n",
       "    // specified callback. The returned promise resolves to the yielded value, or\n",
       "    // to undefined if the generator is done.\n",
       "    function compute(onfulfilled) {\n",
       "      return new Promise(resolve => resolve(generator.next(currentValue))).then(({done, value}) => {\n",
       "        return done ? undefined : Promise.resolve(value).then(onfulfilled);\n",
       "      });\n",
       "    }\n",
       "\n",
       "    // Retrieve the next value from the generator; if successful, fulfill the\n",
       "    // variable, compute downstream variables, and schedule the next value to be\n",
       "    // pulled from the generator at the start of the next animation frame. If not\n",
       "    // successful, reject the variable, compute downstream variables, and return.\n",
       "    function recompute() {\n",
       "      const promise = compute((value) => {\n",
       "        if (variable._version !== version) throw variable_stale;\n",
       "        currentValue = value;\n",
       "        postcompute(value, promise).then(() => runtime._precompute(recompute));\n",
       "        variable._fulfilled(value);\n",
       "        return value;\n",
       "      });\n",
       "      promise.catch((error) => {\n",
       "        if (error === variable_stale) throw error;\n",
       "        if (variable._version !== version) throw variable_stale;\n",
       "        postcompute(undefined, promise);\n",
       "        variable._rejected(error);\n",
       "      });\n",
       "    }\n",
       "\n",
       "    // After the generator fulfills or rejects, set its current value, promise,\n",
       "    // and schedule any downstream variables for update.\n",
       "    function postcompute(value, promise) {\n",
       "      variable._value = value;\n",
       "      variable._promise = promise;\n",
       "      variable._outputs.forEach(runtime._updates.add, runtime._updates);\n",
       "      return runtime._compute();\n",
       "    }\n",
       "\n",
       "    // When retrieving the first value from the generator, the promise graph is\n",
       "    // already established, so we only need to queue the next pull.\n",
       "    return compute((value) => {\n",
       "      if (variable._version !== version) throw variable_stale;\n",
       "      currentValue = value;\n",
       "      runtime._precompute(recompute);\n",
       "      return value;\n",
       "    });\n",
       "  }\n",
       "\n",
       "  function variable_error(variable, error) {\n",
       "    variable._invalidate();\n",
       "    variable._invalidate = noop;\n",
       "    variable._pending();\n",
       "    ++variable._version;\n",
       "    variable._indegree = NaN;\n",
       "    (variable._promise = Promise.reject(error)).catch(noop);\n",
       "    variable._value = undefined;\n",
       "    variable._rejected(error);\n",
       "  }\n",
       "\n",
       "  function variable_return(generator) {\n",
       "    return function() {\n",
       "      generator.return();\n",
       "    };\n",
       "  }\n",
       "\n",
       "  function variable_reachable(variable) {\n",
       "    if (variable._observer !== no_observer) return true; // Directly reachable.\n",
       "    var outputs = new Set(variable._outputs);\n",
       "    for (const output of outputs) {\n",
       "      if (output._observer !== no_observer) return true;\n",
       "      output._outputs.forEach(outputs.add, outputs);\n",
       "    }\n",
       "    return false;\n",
       "  }\n",
       "\n",
       "  function window_global(name) {\n",
       "    return window[name];\n",
       "  }\n",
       "\n",
       "  const MONITOR_INTERVAL = 200;\n",
       "\n",
       "  class DocumentBodyDimensionsMutationObserverMonitor {\n",
       "    constructor() {\n",
       "      this.lastHeight = -1;\n",
       "\n",
       "      this.onMutation = entries => {\n",
       "        const height = document.body.clientHeight;\n",
       "        if (height !== this.lastHeight) {\n",
       "          this.lastHeight = height;\n",
       "          postHeight(this.lastHeight);\n",
       "        }\n",
       "      };\n",
       "    }\n",
       "\n",
       "    start() {\n",
       "      this.observer = new MutationObserver(this.onMutation);\n",
       "      this.observer.observe(document.body, {\n",
       "        childList: true,\n",
       "        attributes: true,\n",
       "        subtree: true\n",
       "      });\n",
       "    }\n",
       "  }\n",
       "\n",
       "  class DocumentBodyDimensionsResizeObserverMonitor {\n",
       "    constructor() {\n",
       "      if (typeof window.ResizeObserver === \"undefined\") {\n",
       "        throw Error(\"ResizeObserver is not supported\");\n",
       "      }\n",
       "      this.lastHeight = -1;\n",
       "\n",
       "      this.onResize = entries => {\n",
       "        for (let entry of entries) {\n",
       "          const height = entry.contentRect.height;\n",
       "          if (height !== this.lastHeight) {\n",
       "            this.lastHeight = height;\n",
       "            postHeight(this.lastHeight);\n",
       "          }\n",
       "        }\n",
       "      };\n",
       "    }\n",
       "\n",
       "    start() {\n",
       "      this.observer = new ResizeObserver(this.onResize);\n",
       "      this.observer.observe(document.body);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  class DocumentBodyDimensionsPollingMonitor {\n",
       "    constructor() {\n",
       "      this.lastHeight = -1;\n",
       "      this.timer = undefined;\n",
       "\n",
       "      this.checkAndSchedule = () => {\n",
       "        if (!this.monitoring) return;\n",
       "        this.check();\n",
       "        this.monitoring = setTimeout(this.checkAndSchedule, MONITOR_INTERVAL);\n",
       "      };\n",
       "    }\n",
       "\n",
       "    start() {\n",
       "      if (!this.monitoring) {\n",
       "        this.monitoring = true;\n",
       "        this.checkAndSchedule();\n",
       "      }\n",
       "    }\n",
       "\n",
       "    stop() {\n",
       "      if (this.monitoring) {\n",
       "        clearTimeout(this.monitoring);\n",
       "      }\n",
       "      this.monitoring = undefined;\n",
       "    }\n",
       "\n",
       "    check() {\n",
       "      const height = document.body.clientHeight;\n",
       "      if (height !== this.lastHeight) {\n",
       "        this.lastHeight = height;\n",
       "        postHeight(this.lastHeight);\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function postHeight(height) {\n",
       "    window.parent.postMessage(\n",
       "      {\n",
       "        type: \"iframeSize\",\n",
       "        height\n",
       "      },\n",
       "      \"*\"\n",
       "    );\n",
       "  }\n",
       "\n",
       "  const monitor = () => {\n",
       "    if (typeof window.ResizeObserver !== \"undefined\") {\n",
       "      new DocumentBodyDimensionsResizeObserverMonitor().start();\n",
       "    } else {\n",
       "      new DocumentBodyDimensionsMutationObserverMonitor().start();\n",
       "    }\n",
       "  };\n",
       "\n",
       "  const embed = async (slug, into, cells, inputs = {}) => {\n",
       "    const moduleUrl = \"https://api.observablehq.com/\" + slug + \".js?v=3\";\n",
       "    const define = (await import(moduleUrl)).default;\n",
       "    const inspect = Inspector.into(into);\n",
       "    const filter = cells ? name => cells.includes(name) : name => true;\n",
       "    const main = new Runtime().module(define, name => filter(name) ? inspect() : true);\n",
       "    for (let name of Object.keys(inputs)) {\n",
       "      main.redefine(name, inputs[name]);\n",
       "    }\n",
       "    return main;\n",
       "  };\n",
       "\n",
       "  exports.DocumentBodyDimensionsMutationObserverMonitor = DocumentBodyDimensionsMutationObserverMonitor;\n",
       "  exports.DocumentBodyDimensionsPollingMonitor = DocumentBodyDimensionsPollingMonitor;\n",
       "  exports.DocumentBodyDimensionsResizeObserverMonitor = DocumentBodyDimensionsResizeObserverMonitor;\n",
       "  exports.embed = embed;\n",
       "  exports.monitor = monitor;\n",
       "\n",
       "  return exports;\n",
       "\n",
       "}({}));\n",
       "\n",
       "CLOSESCRIPT\n",
       "<div style=\"overflow: auto;\"></div>\n",
       "<script type=\"module\">\n",
       "const inputs = {\"quantitative_data\": [{\"State\": \"Mississippi\", \"RainFall (in)\": 66.84}, {\"State\": \"Louisiana\", \"RainFall (in)\": 66.23}, {\"State\": \"Alabama\", \"RainFall (in)\": 65.06}, {\"State\": \"Tennessee\", \"RainFall (in)\": 58.89}, {\"State\": \"Georgia\", \"RainFall (in)\": 57.11}, {\"State\": \"Florida\", \"RainFall (in)\": 55.93}, {\"State\": \"Massachusetts\", \"RainFall (in)\": 54.81}, {\"State\": \"Kentucky\", \"RainFall (in)\": 53.44}, {\"State\": \"Connecticut\", \"RainFall (in)\": 51.27}, {\"State\": \"Arkansas\", \"RainFall (in)\": 50.85}, {\"State\": \"Rhode Island\", \"RainFall (in)\": 49.86}, {\"State\": \"New Jersey\", \"RainFall (in)\": 47.94}, {\"State\": \"South Carolina\", \"RainFall (in)\": 47.41}, {\"State\": \"North Carolina\", \"RainFall (in)\": 47.34}, {\"State\": \"New York\", \"RainFall (in)\": 46.3}, {\"State\": \"Pennsylvania\", \"RainFall (in)\": 46.07}, {\"State\": \"New Hampshire\", \"RainFall (in)\": 45.92}, {\"State\": \"Indiana\", \"RainFall (in)\": 45.37}, {\"State\": \"Missouri\", \"RainFall (in)\": 44.05}, {\"State\": \"Washington\", \"RainFall (in)\": 43.89}, {\"State\": \"West Virginia\", \"RainFall (in)\": 42.52}, {\"State\": \"Ohio\", \"RainFall (in)\": 41.71}, {\"State\": \"Vermont\", \"RainFall (in)\": 41.67}, {\"State\": \"Maryland\", \"RainFall (in)\": 41.53}, {\"State\": \"Illinois\", \"RainFall (in)\": 41.12}, {\"State\": \"Virginia\", \"RainFall (in)\": 40.86}, {\"State\": \"Delaware\", \"RainFall (in)\": 40.57}, {\"State\": \"Maine\", \"RainFall (in)\": 39.34}, {\"State\": \"Oklahoma\", \"RainFall (in)\": 33.64}, {\"State\": \"Michigan\", \"RainFall (in)\": 32.9}, {\"State\": \"Iowa\", \"RainFall (in)\": 31.07}, {\"State\": \"Wisconsin\", \"RainFall (in)\": 29.94}, {\"State\": \"Texas\", \"RainFall (in)\": 28.78}, {\"State\": \"Oregon\", \"RainFall (in)\": 28.49}, {\"State\": \"Kansas\", \"RainFall (in)\": 27.26}, {\"State\": \"Minnesota\", \"RainFall (in)\": 23.78}, {\"State\": \"Nebraska\", \"RainFall (in)\": 22.63}, {\"State\": \"Idaho\", \"RainFall (in)\": 21.0}, {\"State\": \"California\", \"RainFall (in)\": 18.9}, {\"State\": \"South Dakota\", \"RainFall (in)\": 18.14}, {\"State\": \"Colorado\", \"RainFall (in)\": 17.04}, {\"State\": \"North Dakota\", \"RainFall (in)\": 15.65}, {\"State\": \"Wyoming\", \"RainFall (in)\": 14.39}, {\"State\": \"Montana\", \"RainFall (in)\": 14.33}, {\"State\": \"Utah\", \"RainFall (in)\": 13.57}, {\"State\": \"Arizona\", \"RainFall (in)\": 12.61}, {\"State\": \"New Mexico\", \"RainFall (in)\": 12.38}, {\"State\": \"Nevada\", \"RainFall (in)\": 9.56}], \"ID_Column\": \"State\", \"Quant_Column\": \"RainFall (in)\", \"toolTip_title\": [\"Annual Rainfall\", \" inches\"], \"Levels\": [10, 20, 30, 40, 50, 55, 60]};\n",
       "const slug = '@rstorni/leaflet-map';\n",
       "const into = document.getElementsByTagName('div')[0];\n",
       "const cells = ['map', 'leaflet']\n",
       "ObservableJupyterIframe.embed(slug, into, cells, inputs).then(m => {window.main = m;});\n",
       "ObservableJupyterIframe.monitor()\n",
       "window.addEventListener('unload', () => {\n",
       "  if (typeof window.main !== 'undefined') {\n",
       "      window.main._runtime.dispose();\n",
       "  }\n",
       "});\n",
       "CLOSESCRIPT\n",
       "`.replace(/OPENSCRIPT/gi, '<sc' + 'ript>').replace(/CLOSESCRIPT/gi, '</sc' + 'ript>')\n",
       "document.getElementById('observable-embed-div-29285319479051364').srcdoc = iframeSrc;\n",
       "ObservableJupyterWrapper.listenToSize(document.getElementById('observable-embed-div-29285319479051364'));\n",
       "</script>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "embed(\"@rstorni/leaflet-map\",\n",
    "     cells = [\"map\", \"leaflet\"],\n",
    "     inputs = {\n",
    "         \"quantitative_data\" : Formated_Data,\n",
    "         \"ID_Column\" : \"State\",\n",
    "         \"Quant_Column\" : \"RainFall (in)\",\n",
    "         \"toolTip_title\" : [\"Annual Rainfall\", \" inches\"],\n",
    "         \"Levels\" : [10, 20, 30, 40, 50, 55, 60]\n",
    "     }\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08624f25-29d6-40b4-b13e-80ac44b6cb0d",
   "metadata": {},
   "source": [
    "[Leaflet_US_Choropleth.png](Images/Thumbnails/Leaflet_US_Choropleth.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}