https://eco-exp2.netlify.app/exp2_files/libs/quarto-ojs/quarto-ojs-runtime.js

1// quarto-ojs-runtime v0.0.15 Copyright 2023 undefined
2var EOL = {},
3    EOF = {},
4    QUOTE = 34,
5    NEWLINE = 10,
6    RETURN = 13;
7
8function objectConverter(columns) {
9  return new Function("d", "return {" + columns.map(function(name, i) {
10    return JSON.stringify(name) + ": d[" + i + "] || \"\"";
11  }).join(",") + "}");
12}
13
14function customConverter(columns, f) {
15  var object = objectConverter(columns);
16  return function(row, i) {
17    return f(object(row), i, columns);
18  };
19}
20
21// Compute unique columns in order of discovery.
22function inferColumns(rows) {
23  var columnSet = Object.create(null),
24      columns = [];
25
26  rows.forEach(function(row) {
27    for (var column in row) {
28      if (!(column in columnSet)) {
29        columns.push(columnSet[column] = column);
30      }
31    }
32  });
33
34  return columns;
35}
36
37function pad$1(value, width) {
38  var s = value + "", length = s.length;
39  return length < width ? new Array(width - length + 1).join(0) + s : s;
40}
41
42function formatYear$1(year) {
43  return year < 0 ? "-" + pad$1(-year, 6)
44    : year > 9999 ? "+" + pad$1(year, 6)
45    : pad$1(year, 4);
46}
47
48function formatDate$2(date) {
49  var hours = date.getUTCHours(),
50      minutes = date.getUTCMinutes(),
51      seconds = date.getUTCSeconds(),
52      milliseconds = date.getUTCMilliseconds();
53  return isNaN(date) ? "Invalid Date"
54      : formatYear$1(date.getUTCFullYear()) + "-" + pad$1(date.getUTCMonth() + 1, 2) + "-" + pad$1(date.getUTCDate(), 2)
55      + (milliseconds ? "T" + pad$1(hours, 2) + ":" + pad$1(minutes, 2) + ":" + pad$1(seconds, 2) + "." + pad$1(milliseconds, 3) + "Z"
56      : seconds ? "T" + pad$1(hours, 2) + ":" + pad$1(minutes, 2) + ":" + pad$1(seconds, 2) + "Z"
57      : minutes || hours ? "T" + pad$1(hours, 2) + ":" + pad$1(minutes, 2) + "Z"
58      : "");
59}
60
61function dsv$1(delimiter) {
62  var reFormat = new RegExp("[\"" + delimiter + "\n\r]"),
63      DELIMITER = delimiter.charCodeAt(0);
64
65  function parse(text, f) {
66    var convert, columns, rows = parseRows(text, function(row, i) {
67      if (convert) return convert(row, i - 1);
68      columns = row, convert = f ? customConverter(row, f) : objectConverter(row);
69    });
70    rows.columns = columns || [];
71    return rows;
72  }
73
74  function parseRows(text, f) {
75    var rows = [], // output rows
76        N = text.length,
77        I = 0, // current character index
78        n = 0, // current line number
79        t, // current token
80        eof = N <= 0, // current token followed by EOF?
81        eol = false; // current token followed by EOL?
82
83    // Strip the trailing newline.
84    if (text.charCodeAt(N - 1) === NEWLINE) --N;
85    if (text.charCodeAt(N - 1) === RETURN) --N;
86
87    function token() {
88      if (eof) return EOF;
89      if (eol) return eol = false, EOL;
90
91      // Unescape quotes.
92      var i, j = I, c;
93      if (text.charCodeAt(j) === QUOTE) {
94        while (I++ < N && text.charCodeAt(I) !== QUOTE || text.charCodeAt(++I) === QUOTE);
95        if ((i = I) >= N) eof = true;
96        else if ((c = text.charCodeAt(I++)) === NEWLINE) eol = true;
97        else if (c === RETURN) { eol = true; if (text.charCodeAt(I) === NEWLINE) ++I; }
98        return text.slice(j + 1, i - 1).replace(/""/g, "\"");
99      }
100
101      // Find next delimiter or newline.
102      while (I < N) {
103        if ((c = text.charCodeAt(i = I++)) === NEWLINE) eol = true;
104        else if (c === RETURN) { eol = true; if (text.charCodeAt(I) === NEWLINE) ++I; }
105        else if (c !== DELIMITER) continue;
106        return text.slice(j, i);
107      }
108
109      // Return last token before EOF.
110      return eof = true, text.slice(j, N);
111    }
112
113    while ((t = token()) !== EOF) {
114      var row = [];
115      while (t !== EOL && t !== EOF) row.push(t), t = token();
116      if (f && (row = f(row, n++)) == null) continue;
117      rows.push(row);
118    }
119
120    return rows;
121  }
122
123  function preformatBody(rows, columns) {
124    return rows.map(function(row) {
125      return columns.map(function(column) {
126        return formatValue(row[column]);
127      }).join(delimiter);
128    });
129  }
130
131  function format(rows, columns) {
132    if (columns == null) columns = inferColumns(rows);
133    return [columns.map(formatValue).join(delimiter)].concat(preformatBody(rows, c

133olumns)).join("\n");
134  }
135
136  function formatBody(rows, columns) {
137    if (columns == null) columns = inferColumns(rows);
138    return preformatBody(rows, columns).join("\n");
139  }
140
141  function formatRows(rows) {
142    return rows.map(formatRow).join("\n");
143  }
144
145  function formatRow(row) {
146    return row.map(formatValue).join(delimiter);
147  }
148
149  function formatValue(value) {
150    return value == null ? ""
151        : value instanceof Date ? formatDate$2(value)
152        : reFormat.test(value += "") ? "\"" + value.replace(/"/g, "\"\"") + "\""
153        : value;
154  }
155
156  return {
157    parse: parse,
158    parseRows: parseRows,
159    format: format,
160    formatBody: formatBody,
161    formatRows: formatRows,
162    formatRow: formatRow,
163    formatValue: formatValue
164  };
165}
166
167var csv = dsv$1(",");
168
169var csvParse = csv.parse;
170var csvParseRows = csv.parseRows;
171
172var tsv = dsv$1("\t");
173
174var tsvParse = tsv.parse;
175var tsvParseRows = tsv.parseRows;
176
177function autoType(object) {
178  for (var key in object) {
179    var value = object[key].trim(), number, m;
180    if (!value) value = null;
181    else if (value === "true") value = true;
182    else if (value === "false") value = false;
183    else if (value === "NaN") value = NaN;
184    else if (!isNaN(number = +value)) value = number;
185    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})?)?$/)) {
186      if (fixtz && !!m[4] && !m[7]) value = value.replace(/-/g, "/").replace(/T/, " ");
187      value = new Date(value);
188    }
189    else continue;
190    object[key] = value;
191  }
192  return object;
193}
194
195// https://github.com/d3/d3-dsv/issues/45
196const fixtz = new Date("2019-01-01T00:00").getHours() || new Date("2019-07-01T00:00").getHours();
197
198function dependency(name, version, main) {
199  return {
200    resolve(path = main) {
201      return `${name}@${version}/${path}`;
202    }
203  };
204}
205
206const d3 = dependency("d3", "7.6.1", "dist/d3.min.js");
207const inputs = dependency("@observablehq/inputs", "0.10.4", "dist/inputs.min.js");
208const plot = dependency("@observablehq/plot", "0.6.0", "dist/plot.umd.min.js");
209const graphviz = dependency("@observablehq/graphviz", "0.2.1", "dist/graphviz.min.js");
210const highlight = dependency("@observablehq/highlight.js", "2.0.0", "highlight.min.js");
211const katex = dependency("@observablehq/katex", "0.11.1", "dist/katex.min.js");
212const lodash = dependency("lodash", "4.17.21", "lodash.min.js");
213const htl = dependency("htl", "0.3.1", "dist/htl.min.js");
214const jszip = dependency("jszip", "3.10.0", "dist/jszip.min.js");
215const marked = dependency("marked", "0.3.12", "marked.min.js");
216const sql = dependency("sql.js", "1.7.0", "dist/sql-wasm.js");
217const vega = dependency("vega", "5.22.1", "build/vega.min.js");
218const vegalite = dependency("vega-lite", "5.5.0", "build/vega-lite.min.js");
219const vegaliteApi = dependency("vega-lite-api", "5.0.0", "build/vega-lite-api.min.js");
220const arrow4 = dependency("apache-arrow", "4.0.1", "Arrow.es2015.min.js");
221const arrow9 = dependency("apache-arrow", "9.0.0", "+esm");
222const arquero = dependency("arquero", "4.8.8", "dist/arquero.min.js");
223const topojson = dependency("topojson-client", "3.1.0", "dist/topojson-client.min.js");
224const exceljs = dependency("exceljs", "4.3.0", "dist/exceljs.min.js");
225const mermaid$1 = dependency("mermaid", "9.1.6", "dist/mermaid.min.js");
226const leaflet$1 = dependency("leaflet", "1.8.0", "dist/leaflet.js");
227const duckdb = dependency("@duckdb/duckdb-wasm", "1.17.0", "+esm");
228
229const metas = new Map;
230const queue$1 = [];
231const map$2 = queue$1.map;
232const some = queue$1.some;
233const hasOwnProperty$2 = queue$1.hasOwnProperty;
234const identifierRe = /^((?:@[^/@]+\/)?[^/@]+)(?:@([^/]+))?(?:\/(.*))?$/;
235const versionRe = /^\d+\.\d+\.\d+(-[\w-.+]+)?$/;
236const extensionRe = /(?:\.[^/]*|\/)$/;
237
238class RequireError extends Error {
239  constructor(message) {
240    super(message);
241  }
242}
243
244RequireError.prototype.name = RequireError.name;
245
246function parseIdentifier(identifier) {
247  const match = identifierRe.exec(identifier);
248  return match && {
249    name: match[1],
250    version: match[2],
251    path: match[3]
252  };
253}
254
255function resolveFrom(origin = "https://cdn.jsdelivr.net/npm/", mains = ["unpkg", "jsdelivr", "browser", "main"]) {
256  if (!/\/$/.test(origin)) throw new Error("origin lacks trailing slash");
257
258  function main(meta) {
259    for (const key of mains) {
260      let value = meta[key];
261      if (typeof value === "string") {
262        if (value.startsWith("./")) value = value.slice(2);
263        return extensionRe.test(value) ? value : `${value}.js`;
264      }
265    }
266  }
267
268  function resolveMeta(target) {
269    const url = `${origin}${target.name}${target.version ? `@${target.version}` : ""}/package.json`;
270    let meta = metas.get(url);
271    if (!meta) metas.set(url, meta = fetch(url).then(response => {
272      if (!response.ok) throw new RequireError("unable to load package.json");
273      if (response.redirected && !metas.has(response.url)) metas.set(response.url, meta);
274      return response.json();
275    }));
276    return meta;
277  }
278
279  return async function resolve(name, base) {
280    if (name.startsWith(origin)) name = name.substring(origin.length);
281    if (/^(\w+:)|\/\//i.test(name)) return name;
282    if (/^[.]{0,2}\//i.test(name)) return new URL(name, base == null ? location : base).href;
283    if (!name.length || /^[\s._]/.test(name) || /\s$/.test(name)) throw new RequireError("illegal name");
284    const target = parseIdentifier(name);
285    if (!target) return `${origin}${name}`;
286    if (!target.version && base != null && base.startsWith(origin)) {
287      const meta = await resolveMeta(parseIdentifier(base.substring(origin.length)));
288      target.version = meta.dependencies && meta.dependencies[target.name] || meta.peerDepen

288dencies && meta.peerDependencies[target.name];
289    }
290    if (target.path && !extensionRe.test(target.path)) target.path += ".js";
291    if (target.path && target.version && versionRe.test(target.version)) return `${origin}${target.name}@${target.version}/${target.path}`;
292    const meta = await resolveMeta(target);
293    return `${origin}${meta.name}@${meta.version}/${target.path || main(meta) || "index.js"}`;
294  };
295}
296
297var require = requireFrom(resolveFrom());
298let requestsInFlight = 0;
299let prevDefine = undefined;
300
301function requireFrom(resolver) {
302  const cache = new Map;
303  const requireBase = requireRelative(null);
304
305  function requireAbsolute(url) {
306    if (typeof url !== "string") return url;
307    let module = cache.get(url);
308    if (!module) cache.set(url, module = new Promise((resolve, reject) => {
309      const script = document.createElement("script");
310      script.onload = () => {
311        try { resolve(queue$1.pop()(requireRelative(url))); }
312        catch (error) { reject(new RequireError("invalid module")); }
313        script.remove();
314        requestsInFlight--;
315        if (requestsInFlight === 0) {
316          window.define = prevDefine;
317        }
318      };
319      script.onerror = () => {
320        reject(new RequireError("unable to load module"));
321        script.remove();
322        requestsInFlight--;
323        if (requestsInFlight === 0) {
324          window.define = prevDefine;
325        }
326      };
327      script.async = true;
328      script.src = url;
329      if (requestsInFlight === 0) {
330        prevDefine = window.define;
331        window.define = define;
332      }
333      requestsInFlight++;
334
335      document.head.appendChild(script);
336    }));
337    return module;
338  }
339
340  function requireRelative(base) {
341    return name => Promise.resolve(resolver(name, base)).then(requireAbsolute);
342  }
343
344  function requireAlias(aliases) {
345    return requireFrom((name, base) => {
346      if (name in aliases) {
347        name = aliases[name], base = null;
348        if (typeof name !== "string") return name;
349      }
350      return resolver(name, base);
351    });
352  }
353
354  function require(name) {
355    return arguments.length > 1
356        ? Promise.all(map$2.call(arguments, requireBase)).then(merge)
357        : requireBase(name);
358  }
359
360  require.alias = requireAlias;
361  require.resolve = resolver;
362
363  return require;
364}
365
366function merge(modules) {
367  const o = {};
368  for (const m of modules) {
369    for (const k in m) {
370      if (hasOwnProperty$2.call(m, k)) {
371        if (m[k] == null) Object.defineProperty(o, k, {get: getter(m, k)});
372        else o[k] = m[k];
373      }
374    }
375  }
376  return o;
377}
378
379function getter(object, name) {
380  return () => object[name];
381}
382
383function isbuiltin(name) {
384  name = name + "";
385  return name === "exports" || name === "module";
386}
387
388function define(name, dependencies, factory) {
389  const n = arguments.length;
390  if (n < 2) factory = name, dependencies = [];
391  else if (n < 3) factory = dependencies, dependencies = typeof name === "string" ? [] : name;
392  queue$1.push(some.call(dependencies, isbuiltin) ? require => {
393    const exports = {};
394    const module = {exports};
395    return Promise.all(map$2.call(dependencies, name => {
396      name = name + "";
397      return name === "exports" ? exports : name === "module" ? module : require(name);
398    })).then(dependencies => {
399      factory.apply(null, dependencies);
400      return module.exports;
401    });
402  } : require => {
403    return Promise.all(map$2.call(dependencies, require)).then(dependencies => {
404      return typeof factory === "function" ? factory.apply(null, dependencies) : factory;
405    });
406  });
407}
408
409define.amd = {};
410
411// TODO Allow this to be overridden using the Library’s resolver.
412const cdn = "https://cdn.observableusercontent.com/npm/";
413
414let requireDefault = require;
415
416function setDefaultRequire(require) {
417  requireDefault = require;
418}
419
420function requirer(resolver) {
421  return resolver == null ? requireDefault : requireFrom(resolver);
422}
423
424function fromEntries(obj) {
425  const result = {};
426  for (const [key, value] of obj) {
427    result[key] = value;
428  }
429  return result;
430}
431
432async function SQLite(require) {
433  const [init, dist] = await Promise.all([require(sql.resolve()), require.resolve(sql.resolve("dist/"))]);
434  return init({locateFile: file => `${dist}${file}`});
435}
436
437class SQLiteDatabaseClient {
438  constructor(db) {
439    Object.defineProperties(this, {
440      _db: {value: db}
441    });
442  }
443  static async open(source) {
444    const [SQL, buffer] = await Promise.all([SQLite(requireDefault), Promise.resolve(source).then(load$1)]);
445    return new SQLiteDatabaseClient(new SQL.Database(buffer));
446  }
447  async query(query, params) {
448    return await exec(this._db, query, params);
449  }
450  async queryRow(query, params) {
451    return (await this.query(query, params))[0] || null;
452  }
453  async explain(query, params) {
454    const rows = await this.query(`EXPLAIN QUERY PLAN ${query}`, params);
455    return element$1("pre", {className: "observablehq--inspect"}, [
456      text$2(rows.map(row => row.detail).join("\n"))
457    ]);
458  }

459  async describeTables({schema} = {}) {
460    return this.query(`SELECT NULLIF(schema, 'main') AS schema, name FROM pragma_table_list() WHERE type = 'table'${schema == null ? "" : ` AND schema = ?`} AND name NOT LIKE 'sqlite_%'`, schema == null ? [] : [schema]);
461  }
462  async describeColumns({schema, table} = {}) {
463    if (table == null) throw new Error(`missing table`);
464    const rows = await this.query(`SELECT name, type, "notnull" FROM pragma_table_info(?${schema == null ? "" : `, ?`}) ORDER BY cid`, schema == null ? [table] : [table, schema]);
465    if (!rows.length) throw new Error(`table not found: ${table}`);
466    return rows.map(({name, type, notnull}) => ({name, type: sqliteType(type), databaseType: type, nullable: !notnull}));
467  }
468  async describe(object) {
469    const rows = await (object === undefined
470      ? this.query(`SELECT name FROM sqlite_master WHERE type = 'table'`)
471      : this.query(`SELECT * FROM pragma_table_info(?)`, [object]));
472    if (!rows.length) throw new Error("Not found");
473    const {columns} = rows;
474    return element$1("table", {value: rows}, [
475      element$1("thead", [element$1("tr", columns.map(c => element$1("th", [text$2(c)])))]),
476      element$1("tbody", rows.map(r => element$1("tr", columns.map(c => element$1("td", [text$2(r[c])])))))
477    ]);
478  }
479  async sql() {
480    return this.query(...this.queryTag.apply(this, arguments));
481  }
482  queryTag(strings, ...params) {
483    return [strings.join("?"), params];
484  }
485}
486
487Object.defineProperty(SQLiteDatabaseClient.prototype, "dialect", {
488  value: "sqlite"
489});
490
491// https://www.sqlite.org/datatype3.html
492function sqliteType(type) {
493  switch (type) {
494    case "NULL":
495      return "null";
496    case "INT":
497    case "INTEGER":
498    case "TINYINT":
499    case "SMALLINT":
500    case "MEDIUMINT":
501    case "BIGINT":
502    case "UNSIGNED BIG INT":
503    case "INT2":
504    case "INT8":
505      return "integer";
506    case "TEXT":
507    case "CLOB":
508      return "string";
509    case "REAL":
510    case "DOUBLE":
511    case "DOUBLE PRECISION":
512    case "FLOAT":
513    case "NUMERIC":
514      return "number";
515    case "BLOB":
516      return "buffer";
517    case "DATE":
518    case "DATETIME":
519      return "string"; // TODO convert strings to Date instances in sql.js
520    default:
521      return /^(?:(?:(?:VARYING|NATIVE) )?CHARACTER|(?:N|VAR|NVAR)CHAR)\(/.test(type) ? "string"
522        : /^(?:DECIMAL|NUMERIC)\(/.test(type) ? "number"
523        : "other";
524  }
525}
526
527function load$1(source) {
528  return typeof source === "string" ? fetch(source).then(load$1)
529    : source instanceof Response || source instanceof Blob ? source.arrayBuffer().then(load$1)
530    : source instanceof ArrayBuffer ? new Uint8Array(source)
531    : source;
532}
533
534async function exec(db, query, params) {
535  const [result] = await db.exec(query, params);
536  if (!result) return [];
537  const {columns, values} = result;
538  const rows = values.map(row => fromEntries(row.map((value, i) => [columns[i], value])));
539  rows.columns = columns;
540  return rows;
541}
542
543function element$1(name, props, children) {
544  if (arguments.length === 2) children = props, props = undefined;
545  const element = document.createElement(name);
546  if (props !== undefined) for (const p in props) element[p] = props[p];
547  if (children !== undefined) for (const c of children) element.appendChild(c);
548  return element;
549}
550
551function text$2(value) {
552  return document.createTextNode(value);
553}
554
555class Workbook {
556  constructor(workbook) {
557    Object.defineProperties(this, {
558      _: {value: workbook},
559      sheetNames: {
560        value: workbook.worksheets.map((s) => s.name),
561        enumerable: true
562      }
563    });
564  }
565  sheet(name, options) {
566    const sname =
567      typeof name === "number"
568        ? this.sheetNames[name]
569        : this.sheetNames.includes((name += ""))
570        ? name
571        : null;
572    if (sname == null) throw new Error(`Sheet not found: ${name}`);
573    const sheet = this._.getWorksheet(sname);
574    return extract(sheet, options);
575  }
576}
577
578function extract(sheet, {range, headers} = {}) {
579  let [[c0, r0], [c1, r1]] = parseRange(range, sheet);
580  const headerRow = headers ? sheet._rows[r0++] : null;
581  let names = new Set(["#"]);
582  for (let n = c0; n <= c1; n++) {
583    const value = headerRow ? valueOf(headerRow.findCell(n + 1)) : null;
584    let name = (value && value + "") || toColumn(n);
585    while (names.has(name)) name += "_";
586    names.add(name);
587  }

588  names = new Array(c0).concat(Array.from(names));
589
590  const output = new Array(r1 - r0 + 1);
591  for (let r = r0; r <= r1; r++) {
592    const row = (output[r - r0] = Object.create(null, {"#": {value: r + 1}}));
593    const _row = sheet.getRow(r + 1);
594    if (_row.hasValues)
595      for (let c = c0; c <= c1; c++) {
596        const value = valueOf(_row.findCell(c + 1));
597        if (value != null) row[names[c + 1]] = value;
598      }
599  }
600
601  output.columns = names.filter(() => true); // Filter sparse columns
602  return output;
603}
604
605function valueOf(cell) {
606  if (!cell) return;
607  const {value} = cell;
608  if (value && typeof value === "object" && !(value instanceof Date)) {
609    if (value.formula || value.sharedFormula) {
610      return value.result && value.result.error ? NaN : value.result;
611    }
612    if (value.richText) {
613      return richText(value);
614    }
615    if (value.text) {
616      let {text} = value;
617      if (text.richText) text = richText(text);
618      return value.hyperlink && value.hyperlink !== text
619        ? `${value.hyperlink} ${text}`
620        : text;
621    }
622    return value;
623  }
624  return value;
625}
626
627function richText(value) {
628  return value.richText.map((d) => d.text).join("");
629}
630
631function parseRange(specifier = ":", {columnCount, rowCount}) {
632  specifier += "";
633  if (!specifier.match(/^[A-Z]*\d*:[A-Z]*\d*$/))
634    throw new Error("Malformed range specifier");
635  const [[c0 = 0, r0 = 0], [c1 = columnCount - 1, r1 = rowCount - 1]] =
636    specifier.split(":").map(fromCellReference);
637  return [
638    [c0, r0],
639    [c1, r1]
640  ];
641}
642
643// Returns the default column name for a zero-based column index.
644// For example: 0 -> "A", 1 -> "B", 25 -> "Z", 26 -> "AA", 27 -> "AB".
645function toColumn(c) {
646  let sc = "";
647  c++;
648  do {
649    sc = String.fromCharCode(64 + (c % 26 || 26)) + sc;
650  } while ((c = Math.floor((c - 1) / 26)));
651  return sc;
652}
653
654// Returns the zero-based indexes from a cell reference.
655// For example: "A1" -> [0, 0], "B2" -> [1, 1], "AA10" -> [26, 9].
656function fromCellReference(s) {

657  const [, sc, sr] = s.match(/^([A-Z]*)(\d*)$/);
658  let c = 0;
659  if (sc)
660    for (let i = 0; i < sc.length; i++)
661      c += Math.pow(26, sc.length - i - 1) * (sc.charCodeAt(i) - 64);
662  return [c ? c - 1 : undefined, sr ? +sr - 1 : undefined];
663}
664
665async function remote_fetch(file) {
666  const response = await fetch(await file.url());
667  if (!response.ok) throw new Error(`Unable to load file: ${file.name}`);
668  return response;
669}
670
671async function dsv(file, delimiter, {array = false, typed = false} = {}) {
672  const text = await file.text();
673  return (delimiter === "\t"
674      ? (array ? tsvParseRows : tsvParse)
675      : (array ? csvParseRows : csvParse))(text, typed && autoType);
676}
677
678class AbstractFile {
679  constructor(name, mimeType) {
680    Object.defineProperty(this, "name", {value: name, enumerable: true});
681    if (mimeType !== undefined) Object.defineProperty(this, "mimeType", {value: mimeType + "", enumerable: true});
682  }
683  async blob() {
684    return (await remote_fetch(this)).blob();
685  }
686  async arrayBuffer() {
687    return (await remote_fetch(this)).arrayBuffer();
688  }
689  async text() {
690    return (await remote_fetch(this)).text();
691  }
692  async json() {
693    return (await remote_fetch(this)).json();
694  }
695  async stream() {
696    return (await remote_fetch(this)).body;
697  }
698  async csv(options) {
699    return dsv(this, ",", options);
700  }
701  async tsv(options) {
702    return dsv(this, "\t", options);
703  }
704  async image(props) {
705    const url = await this.url();
706    return new Promise((resolve, reject) => {
707      const i = new Image();
708      if (new URL(url, document.baseURI).origin !== new URL(location).origin) {
709        i.crossOrigin = "anonymous";
710      }
711      Object.assign(i, props);
712      i.onload = () => resolve(i);
713      i.onerror = () => reject(new Error(`Unable to load file: ${this.name}`));
714      i.src = url;
715    });
716  }
717  async arrow({version = 4} = {}) {
718    switch (version) {
719      case 4: {
720        const [Arrow, response] = await Promise.all([requireDefault(arrow4.resolve()), remote_fetch(this)]);
721        return Arrow.Table.from(response);
722      }
723      case 9: {
724        const [Arrow, response] = await Promise.all([import(`${cdn}${arrow9.resolve()}`), remote_fetch(this)]);
725        return Arrow.tableFromIPC(response);
726      }
727      default: throw new Error(`unsupported arrow version: ${version}`);
728    }
729  }
730  async sqlite() {
731    return SQLiteDatabaseClient.open(remote_fetch(this));
732  }
733  async zip() {
734    const [JSZip, buffer] = await Promise.all([requireDefault(jszip.resolve()), this.arrayBuffer()]);
735    return new ZipArchive(await JSZip.loadAsync(buffer));
736  }
737  async xml(mimeType = "application/xml") {
738    return (new DOMParser).parseFromString(await this.text(), mimeType);
739  }
740  async html() {
741    return this.xml("text/html");
742  }
743  async xlsx() {
744    const [ExcelJS, buffer] = await Promise.all([requireDefault(exceljs.resolve()), this.arrayBuffer()]);
745    return new Workbook(await new ExcelJS.Workbook().xlsx.load(buffer));
746  }
747}
748
749class FileAttachment extends AbstractFile {
750  constructor(url, name, mimeType) {
751    super(name, mimeType);
752    Object.defineProperty(this, "_url", {value: url});
753  }
754  async url() {
755    return (await this._url) + "";
756  }
757}
758
759function NoFileAttachments(name) {
760  throw new Error(`File not found: ${name}`);
761}
762
763function FileAttachments(resolve) {
764  return Object.assign(
765    name => {
766      const result = resolve(name += "");
767      if (result == null) throw new Error(`File not found: ${name}`);
768      if (typeof result === "object" && "url" in result) {
769        const {url, mimeType} = result;
770        return new FileAttachment(url, name, mimeType);
771      }
772      return new FileAttachment(result, name);
773    },
774    {prototype: FileAttachment.prototype} // instanceof
775  );
776}
777
778class ZipArchive {
779  constructor(archive) {
780    Object.defineProperty(this, "_", {value: archive});
781    this.filenames = Object.keys(archive.files).filter(name => !archive.files[name].dir);
782  }
783  file(path) {
784    const object = this._.file(path += "");
785    if (!object || object.dir) throw new Error(`file not found: ${path}`);
786    return new ZipArchiveEntry(object);
787  }
788}
789
790class ZipArchiveEntry extends AbstractFile {
791  constructor(object) {
792    super(object.name);

793    Object.defineProperty(this, "_", {value: object});
794    Object.defineProperty(this, "_url", {writable: true});
795  }
796  async url() {
797    return this._url || (this._url = this.blob().then(URL.createObjectURL));
798  }
799  async blob() {
800    return this._.async("blob");
801  }
802  async arrayBuffer() {
803    return this._.async("arraybuffer");
804  }
805  async text() {
806    return this._.async("text");
807  }
808  async json() {
809    return JSON.parse(await this.text());
810  }
811}
812
813function canvas(width, height) {
814  var canvas = document.createElement("canvas");
815  canvas.width = width;
816  canvas.height = height;
817  return canvas;
818}
819
820function context2d(width, height, dpi) {
821  if (dpi == null) dpi = devicePixelRatio;
822  var canvas = document.createElement("canvas");
823  canvas.width = width * dpi;
824  canvas.height = height * dpi;
825  canvas.style.width = width + "px";
826  var context = canvas.getContext("2d");
827  context.scale(dpi, dpi);
828  return context;
829}
830
831function download(value, name = "untitled", label = "Save") {
832  const a = document.createElement("a");
833  const b = a.appendChild(document.createElement("button"));
834  b.textContent = label;

835  a.download = name;
836
837  async function reset() {
838    await new Promise(requestAnimationFrame);
839    URL.revokeObjectURL(a.href);
840    a.removeAttribute("href");
841    b.textContent = label;
842    b.disabled = false;
843  }
844
845  a.onclick = async event => {
846    b.disabled = true;
847    if (a.href) return reset(); // Already saved.
848    b.textContent = "Saving…";
849    try {
850      const object = await (typeof value === "function" ? value() : value);
851      b.textContent = "Download";
852      a.href = URL.createObjectURL(object); // eslint-disable-line require-atomic-updates
853    } catch (ignore) {
854      b.textContent = label;
855    }
856    if (event.eventPhase) return reset(); // Already downloaded.
857    b.disabled = false;
858  };
859
860  return a;
861}
862
863var namespaces = {
864  math: "http://www.w3.org/1998/Math/MathML",
865  svg: "http://www.w3.org/2000/svg",
866  xhtml: "http://www.w3.org/1999/xhtml",
867  xlink: "http://www.w3.org/1999/xlink",
868  xml: "http://www.w3.org/XML/1998/namespace",
869  xmlns: "http://www.w3.org/2000/xmlns/"
870};
871
872function element(name, attributes) {
873  var prefix = name += "", i = prefix.indexOf(":"), value;
874  if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
875  var element = namespaces.hasOwnProperty(prefix) // eslint-disable-line no-prototype-builtins
876      ? document.createElementNS(namespaces[prefix], name)
877      : document.createElement(name);
878  if (attributes) for (var key in attributes) {
879    prefix = key, i = prefix.indexOf(":"), value = attributes[key];
880    if (i >= 0 && (prefix = key.slice(0, i)) !== "xmlns") key = key.slice(i + 1);
881    if (namespaces.hasOwnProperty(prefix)) element.setAttributeNS(namespaces[prefix], key, value); // eslint-disable-line no-prototype-builtins
882    else element.setAttribute(key, value);
883  }
884  return element;
885}
886
887function input$1(type) {
888  var input = document.createElement("input");
889  if (type != null) input.type = type;
890  return input;
891}
892
893function range$1(min, max, step) {
894  if (arguments.length === 1) max = min, min = null;
895  var input = document.createElement("input");
896  input.min = min = min == null ? 0 : +min;
897  input.max = max = max == null ? 1 : +max;
898  input.step = step == null ? "any" : step = +step;
899  input.type = "range";
900  return input;
901}
902
903function select(values) {
904  var select = document.createElement("select");
905  Array.prototype.forEach.call(values, function(value) {
906    var option = document.createElement("option");
907    option.value = option.textContent = value;
908    select.appendChild(option);
909  });
910  return select;
911}
912
913function svg$1(width, height) {
914  var svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
915  svg.setAttribute("viewBox", [0, 0, width, height]);
916  svg.setAttribute("width", width);
917  svg.setAttribute("height", height);
918  return svg;
919}
920
921function text$1(value) {
922  return document.createTextNode(value);
923}
924
925var count$1 = 0;
926
927function uid(name) {
928  return new Id("O-" + (name == null ? "" : name + "-") + ++count$1);
929}
930
931function Id(id) {
932  this.id = id;
933  this.href = new URL(`#${id}`, location) + "";
934}
935
936Id.prototype.toString = function() {
937  return "url(" + this.href + ")";
938};
939
940var DOM = /*#__PURE__*/Object.freeze({
941__proto__: null,
942canvas: canvas,
943context2d: context2d,
944download: download,
945element: element,
946input: input$1,
947range: range$1,
948select: select,
949svg: svg$1,
950text: text$1,
951uid: uid
952});
953
954function buffer(file) {
955  return new Promise(function(resolve, reject) {
956    var reader = new FileReader;
957    reader.onload = function() { resolve(reader.result); };
958    reader.onerror = reject;
959    reader.readAsArrayBuffer(file);
960  });
961}
962
963function text(file) {
964  return new Promise(function(resolve, reject) {
965    var reader = new FileReader;
966    reader.onload = function() { resolve(reader.result); };
967    reader.onerror = reject;
968    reader.readAsText(file);
969  });
970}
971
972function url(file) {
973  return new Promise(function(resolve, reject) {
974    var reader = new FileReader;
975    reader.onload = function() { resolve(reader.result); };
976    reader.onerror = reject;
977    reader.readAsDataURL(file);
978  });
979}
980
981var Files = /*#__PURE__*/Object.freeze({
982__proto__: null,
983buffer: buffer,
984text: text,
985url: url
986});
987
988function that() {
989  return this;
990}
991
992function disposable(value, dispose) {
993  let done = false;

994  if (typeof dispose !== "function") {
995    throw new Error("dispose is not a function");
996  }
997  return {
998    [Symbol.iterator]: that,
999    next: () => done ? {done: true} : (done = true, {done: false, value}),
1000    return: () => (done = true, dispose(value), {done: true}),
1001    throw: () => ({done: done = true})
1002  };
1003}
1004
1005function* filter(iterator, test) {
1006  var result, index = -1;
1007  while (!(result = iterator.next()).done) {
1008    if (test(result.value, ++index)) {
1009      yield result.value;
1010    }
1011  }
1012}
1013
1014function observe(initialize) {
1015  let stale = false;
1016  let value;
1017  let resolve;
1018  const dispose = initialize(change);
1019
1020  if (dispose != null && typeof dispose !== "function") {
1021    throw new Error(typeof dispose.then === "function"
1022        ? "async initializers are not supported"
1023        : "initializer returned something, but not a dispose function");
1024  }
1025
1026  function change(x) {
1027    if (resolve) resolve(x), resolve = null;
1028    else stale = true;
1029    return value = x;
1030  }
1031
1032  function next() {
1033    return {done: false, value: stale
1034        ? (stale = false, Promise.resolve(value))
1035        : new Promise(_ => (resolve = _))};
1036  }
1037
1038  return {
1039    [Symbol.iterator]: that,
1040    throw: () => ({done: true}),
1041    return: () => (dispose != null && dispose(), {done: true}),
1042    next
1043  };
1044}
1045
1046function input(input) {
1047  return observe(function(change) {
1048    var event = eventof(input), value = valueof$1(input);
1049    function inputted() { change(valueof$1(input)); }
1050    input.addEventListener(event, inputted);
1051    if (value !== undefined) change(value);
1052    return function() { input.removeEventListener(event, inputted); };
1053  });
1054}
1055
1056function valueof$1(input) {
1057  switch (input.type) {
1058    case "range":
1059    case "number": return input.valueAsNumber;
1060    case "date": return input.valueAsDate;
1061    case "checkbox": return input.checked;
1062    case "file": return input.multiple ? input.files : input.files[0];
1063    case "select-multiple": return Array.from(input.selectedOptions, o => o.value);
1064    default: return input.value;
1065  }
1066}
1067
1068function eventof(input) {
1069  switch (input.type) {
1070    case "button":
1071    case "submit":
1072    case "checkbox": return "click";
1073    case "file": return "change";
1074    default: return "input";
1075  }
1076}
1077
1078function* map$1(iterator, transform) {
1079  var result, index = -1;
1080  while (!(result = iterator.next()).done) {
1081    yield transform(result.value, ++index);
1082  }
1083}
1084
1085function queue(initialize) {
1086  let resolve;
1087  const queue = [];
1088  const dispose = initialize(push);
1089
1090  if (dispose != null && typeof dispose !== "function") {
1091    throw new Error(typeof dispose.then === "function"
1092        ? "async initializers are not supported"
1093        : "initializer returned something, but not a dispose function");
1094  }
1095
1096  function push(x) {
1097    queue.push(x);
1098    if (resolve) resolve(queue.shift()), resolve = null;
1099    return x;
1100  }
1101
1102  function next() {
1103    return {done: false, value: queue.length
1104        ? Promise.resolve(queue.shift())
1105        : new Promise(_ => (resolve = _))};
1106  }
1107
1108  return {
1109    [Symbol.iterator]: that,
1110    throw: () => ({done: true}),
1111    return: () => (dispose != null && dispose(), {done: true}),
1112    next
1113  };
1114}
1115
1116function* range(start, stop, step) {
1117  start = +start;
1118  stop = +stop;
1119  step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
1120  var i = -1, n = Math.max(0, Math.ceil((stop - start) / step)) | 0;
1121  while (++i < n) {
1122    yield start + i * step;
1123  }
1124}
1125
1126function valueAt(iterator, i) {
1127  if (!isFinite(i = +i) || i < 0 || i !== i | 0) return;
1128  var result, index = -1;
1129  while (!(result = iterator.next()).done) {
1130    if (++index === i) {
1131      return result.value;
1132    }
1133  }
1134}
1135
1136function worker(source) {
1137  const url = URL.createObjectURL(new Blob([source], {type: "text/javascript"}));
1138  const worker = new Worker(url);

1139  return disposable(worker, () => {
1140    worker.terminate();
1141    URL.revokeObjectURL(url);
1142  });
1143}
1144
1145var Generators$1 = /*#__PURE__*/Object.freeze({
1146__proto__: null,
1147disposable: disposable,
1148filter: filter,
1149input: input,
1150map: map$1,
1151observe: observe,
1152queue: queue,
1153range: range,
1154valueAt: valueAt,
1155worker: worker
1156});
1157
1158// Returns true if the vaue is an Apache Arrow table. This uses a “duck” test
1159// (instead of strict instanceof) because we want it to work with a range of
1160// Apache Arrow versions at least 7.0.0 or above.
1161// https://arrow.apache.org/docs/7.0/js/classes/Arrow_dom.Table.html
1162function isArrowTable(value) {
1163  return (
1164    value &&
1165    typeof value.getChild === "function" &&
1166    typeof value.toArray === "function" &&
1167    value.schema &&
1168    Array.isArray(value.schema.fields)
1169  );
1170}
1171
1172function getArrowTableSchema(table) {
1173  return table.schema.fields.map(getArrowFieldSchema);
1174}
1175
1176function getArrowFieldSchema(field) {
1177  return {
1178    name: field.name,
1179    type: getArrowType(field.type),
1180    nullable: field.nullable,
1181    databaseType: String(field.type)
1182  };
1183}
1184
1185// https://github.com/apache/arrow/blob/89f9a0948961f6e94f1ef5e4f310b707d22a3c11/js/src/enum.ts#L140-L141
1186function getArrowType(type) {
1187  switch (type.typeId) {
1188    case 2: // Int
1189      return "integer";
1190    case 3: // Float
1191    case 7: // Decimal
1192      return "number";
1193    case 4: // Binary
1194    case 15: // FixedSizeBinary
1195      return "buffer";
1196    case 5: // Utf8
1197      return "string";
1198    case 6: // Bool
1199      return "boolean";
1200    case 8: // Date
1201    case 9: // Time
1202    case 10: // Timestamp
1203      return "date";
1204    case 12: // List
1205    case 16: // FixedSizeList
1206      return "array";
1207    case 13: // Struct
1208    case 14: // Union
1209      return "object";
1210    case 11: // Interval
1211    case 17: // Map
1212    default:
1213      return "other";
1214  }
1215}
1216
1217// Adapted from https://observablehq.com/@cmudig/duckdb-client
1218// Copyright 2021 CMU Data Interaction Group
1219//
1220// Redistribution and use in source and binary forms, with or without
1221// modification, are permitted provided that the following conditions are met:
1222//
1223// 1. Redistributions of source code must retain the above copyright notice,
1224//    this list of conditions and the following disclaimer.
1225//
1226// 2. Redistributions in binary form must reproduce the above copyright notice,
1227//    this list of conditions and the following disclaimer in the documentation
1228//    and/or other materials provided with the distribution.
1229//
1230// 3. Neither the name of the copyright holder nor the names of its contributors
1231//    may be used to endorse or promote products derived from this software
1232//    without specific prior written permission.
1233//
1234// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1235// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1236// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1237// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
1238// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
1239// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
1240// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1241// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
1242// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1243// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
1244// POSSIBILITY OF SUCH DAMAGE.
1245
1246class DuckDBClient {
1247  constructor(db) {
1248    Object.defineProperties(this, {
1249      _db: {value: db}
1250    });
1251  }
1252
1253  async queryStream(query, params) {
1254    const connection = await this._db.connect();
1255    let reader, batch;
1256    try {
1257      if (params?.length > 0) {
1258        const statement = await connection.prepare(query);
1259        reader = await statement.send(...params);
1260      } else {
1261        reader = await connection.send(query);
1262      }
1263      batch = await reader.next();
1264      if (batch.done) throw new Error("missing first batch");
1265    } catch (error) {
1266      await connection.close();
1267      throw error;
1268    }
1269    return {
1270      schema: getArrowTableSchema(batch.value),
1271      async *readRows() {
1272        try {
1273          while (!batch.done) {
1274            yield batch.value.toArray();
1275            batch = await reader.next();
1276          }
1277        } finally {
1278          await connection.close();
1279        }
1280      }
1281    };
1282  }
1283
1284  async query(query, params) {
1285    const result = await this.queryStream(query, params);
1286    const results = [];
1287    for await (const rows of result.readRows()) {
1288      for (const row of rows) {
1289        results.push(row);
1290      }
1291    }
1292    results.schema = result.schema;
1293    return results;
1294  }
1295
1296  async queryRow(query, params) {
1297    const result = await this.queryStream(query, params);
1298    const reader = result.readRows();
1299    try {
1300      const {done, value} = await reader.next();
1301      return done || !value.length ? null : value[0];
1302    } finally {
1303      await reader.return();
1304    }
1305  }
1306
1307  async sql(strings, ...args) {
1308    return await this.query(strings.join("?"), args);
1309  }
1310
1311  queryTag(strings, ...params) {
1312    return [strings.join("?"), params];
1313  }
1314
1315  escape(name) {
1316    return `"${name}"`;
1317  }
1318
1319  async describeTables() {
1320    const tables = await this.query(`SHOW TABLES`);
1321    return tables.map(({name}) => ({name}));
1322  }
1323
1324  async describeColumns({table} = {}) {
1325    const columns = await this.query(`DESCRIBE ${table}`);
1326    return columns.map(({column_name, column_type, null: nullable}) => ({
1327      name: column_name,
1328      type: getDuckDBType(column_type),
1329      nullable: nullable !== "NO",
1330      databaseType: column_type
1331    }));
1332  }
1333
1334  static async of(sources = {}, config = {}) {
1335    const db = await createDuckDB();
1336    if (config.query?.castTimestampToDate === undefined) {
1337      config = {...config, query: {...config.query, castTimestampToDate: true}};
1338    }
1339    await db.open(config);
1340    await Promise.all(
1341      Object.entries(sources).map(async ([name, source]) => {
1342        if (source instanceof FileAttachment) { // bare file
1343          await insertFile(db, name, source);
1344        } else if (isArrowTable(source)) { // bare arrow table
1345          await insertArrowTable(db, name, source);
1346        } else if (Array.isArray(source)) { // bare array of objects
1347          await insertArray(db, name, source);
1348        } else if ("data" in source) { // data + options
1349          const {data, ...options} = source;
1350          if (isArrowTable(data)) {
1351            await insertArrowTable(db, name, data, options);
1352          } else {
1353            await insertArray(db, name, data, options);
1354          }
1355        } else if ("file" in source) { // file + options
1356          const {file, ...options} = source;
1357          await insertFile(db, name, file, options);
1358        } else {
1359          throw new Error(`invalid source: ${source}`);
1360        }
1361      })
1362    );
1363    return new DuckDBClient(db);
1364  }
1365}
1366
1367Object.defineProperty(DuckDBClient.prototype, "dialect", {
1368  value: "duckdb"
1369});
1370
1371async function insertFile(database, name, file, options) {
1372  const url = await file.url();
1373  if (url.startsWith("blob:")) {
1374    const buffer = await file.arrayBuffer();
1375    await database.registerFileBuffer(file.name, new Uint8Array(buffer));
1376  } else {
1377    await database.registerFileURL(file.name, url);
1378  }
1379  const connection = await database.connect();
1380  try {
1381    switch (file.mimeType) {
1382      case "text/csv":
1383        return await connection.insertCSVFromPath(file.name, {
1384          name,
1385          schema: "main",
1386          ...options
1387        });
1388      case "application/json":
1389        return await connection.insertJSONFromPath(file.name, {
1390          name,
1391          schema: "main",
1392          ...options
1393        });
1394      default:
1395        if (/\.arrow$/i.test(file.name)) {
1396          const buffer = new Uint8Array(await file.arrayBuffer());
1397          return await connection.insertArrowFromIPCStream(buffer, {
1398            name,
1399            schema: "main",
1400            ...options
1401          });
1402        }
1403        if (/\.parquet$/i.test(file.name)) {
1404          return await connection.query(
1405            `CREATE VIEW '${name}' AS SELECT * FROM parquet_scan('${file.name}')`
1406          );
1407        }
1408        throw new Error(`unknown file type: ${file.mimeType}`);
1409    }
1410  } finally {
1411    await connection.close();
1412  }
1413}
1414
1415async function insertArrowTable(database, name, table, options) {
1416  const arrow = await loadArrow();
1417  const buffer = arrow.tableToIPC(table);
1418  const connection = await database.connect();
1419  try {
1420    await connection.insertArrowFromIPCStream(buffer, {
1421      name,
1422      schema: "main",
1423      ...options
1424    });
1425  } finally {
1426    await connection.close();
1427  }
1428}
1429
1430async function insertArray(database, name, array, options) {
1431  const arrow = await loadArrow();
1432  const table = arrow.tableFromJSON(array);
1433  return await insertArrowTable(database, name, table, options);
1434}
1435
1436async function createDuckDB() {
1437  const duck = await import(`${cdn}

1437${duckdb.resolve()}`);
1438  const bundle = await duck.selectBundle({
1439    mvp: {
1440      mainModule: `${cdn}${duckdb.resolve("dist/duckdb-mvp.wasm")}`,
1441      mainWorker: `${cdn}${duckdb.resolve("dist/duckdb-browser-mvp.worker.js")}`
1442    },
1443    eh: {
1444      mainModule: `${cdn}${duckdb.resolve("dist/duckdb-eh.wasm")}`,
1445      mainWorker: `${cdn}${duckdb.resolve("dist/duckdb-browser-eh.worker.js")}`
1446    }
1447  });
1448  const logger = new duck.ConsoleLogger();
1449  const worker = await duck.createWorker(bundle.mainWorker);
1450  const db = new duck.AsyncDuckDB(logger, worker);
1451  await db.instantiate(bundle.mainModule);
1452  return db;
1453}
1454
1455async function loadArrow() {
1456  return await import(`${cdn}${arrow9.resolve()}`);
1457}
1458
1459// https://duckdb.org/docs/sql/data_types/overview
1460function getDuckDBType(type) {
1461  switch (type) {
1462    case "BIGINT":
1463    case "HUGEINT":
1464    case "UBIGINT":
1465      return "bigint";
1466    case "DOUBLE":
1467    case "REAL":
1468      return "number";
1469    case "INTEGER":
1470    case "SMALLINT":
1471    case "TINYINT":
1472    case "USMALLINT":
1473    case "UINTEGER":
1474    case "UTINYINT":
1475      return "integer";
1476    case "BOOLEAN":
1477      return "boolean";
1478    case "DATE":
1479    case "TIMESTAMP":
1480    case "TIMESTAMP WITH TIME ZONE":
1481      return "date";
1482    case "VARCHAR":
1483    case "UUID":
1484      return "string";
1485    // case "BLOB":
1486    // case "INTERVAL":
1487    // case "TIME":
1488    default:
1489      if (/^DECIMAL\(/.test(type)) return "integer";
1490      return "other";
1491  }
1492}
1493
1494function template(render, wrapper) {
1495  return function(strings) {
1496    var string = strings[0],
1497        parts = [], part,
1498        root = null,
1499        node, nodes,
1500        walker,
1501        i, n, j, m, k = -1;
1502
1503    // Concatenate the text using comments as placeholders.
1504    for (i = 1, n = arguments.length; i < n; ++i) {
1505      part = arguments[i];
1506      if (part instanceof Node) {
1507        parts[++k] = part;
1508        string += "<!--o:" + k + "-->";
1509      } else if (Array.isArray(part)) {
1510        for (j = 0, m = part.length; j < m; ++j) {
1511          node = part[j];
1512          if (node instanceof Node) {
1513            if (root === null) {
1514              parts[++k] = root = document.createDocumentFragment();
1515              string += "<!--o:" + k + "-->";
1516            }
1517            root.appendChild(node);
1518          } else {
1519            root = null;
1520            string += node;
1521          }
1522        }
1523        root = null;
1524      } else {
1525        string += part;
1526      }
1527      string += strings[i];
1528    }
1529
1530    // Render the text.
1531    root = render(string);
1532
1533    // Walk the rendered content to replace comment placeholders.
1534    if (++k > 0) {
1535      nodes = new Array(k);
1536      walker = document.createTreeWalker(root, NodeFilter.SHOW_COMMENT, null, false);
1537      while (walker.nextNode()) {
1538        node = walker.currentNode;
1539        if (/^o:/.test(node.nodeValue)) {
1540          nodes[+node.nodeValue.slice(2)] = node;
1541        }
1542      }
1543      for (i = 0; i < k; ++i) {
1544        if (node = nodes[i]) {
1545          node.parentNode.replaceChild(parts[i], node);
1546        }
1547      }
1548    }
1549
1550    // Is the rendered content
1551    // … a parent of a single child? Detach and return the child.
1552    // … a document fragment? Replace the fragment with an element.
1553    // … some other node? Return it.
1554    return root.childNodes.length === 1 ? root.removeChild(root.firstChild)
1555        : root.nodeType === 11 ? ((node = wrapper()).appendChild(root), node)
1556        : root;
1557  };
1558}
1559
1560const html$1 = template(function(string) {
1561  var template = document.createElement("template");
1562  template.innerHTML = string.trim();
1563  return document.importNode(template.content, true);
1564}, function() {
1565  return document.createElement("span");
1566});
1567
1568async function leaflet(require) {
1569  const L = await require(leaflet$1.resolve());
1570  if (!L._style) {
1571    const link = document.createElement("link");
1572    link.rel = "stylesheet";
1573    link.href = await require.resolve(leaflet$1.resolve("dist/leaflet.css"));
1574    L._style = document.head.appendChild(link);
1575  }
1576  return L;
1577}
1578
1579function md(require) {
1580  return require(marked.resolve()).then(function(marked) {
1581    return template(
1582      function(string) {
1583        var root = document.createElement("div");
1584        root.innerHTML = marked(string, {langPrefix: ""}).trim();
1585        var code = root.querySelectorAll("pre code[class]");
1586        if (code.length > 0) {
1587          require(highlight.resolve()).then(function(hl) {
1588            code.forEach(function(block) {
1589              function done() {
1590                hl.highlightBlock(block);
1591                block.parentNode.classList.add("observablehq--md-pre");
1592              }
1593              if (hl.getLanguage(block.className)) {
1594                done();
1595              } else {
1596                require(highlight.resolve("async-languages/index.js"))
1597                  .then(index => {
1598                    if (index.has(block.className)) {
1599                      return require(highlight.resolve("async-languages/" + index.get(block.className))).then(language => {
1600                        hl.registerLanguage(block.className, language);
1601                      });
1602                    }
1603                  })
1604                  .then(done, done);
1605              }
1606            });
1607          });
1608        }
1609        return root;
1610      },
1611      function() {
1612        return document.createElement("div");
1613      }
1614    );
1615  });
1616}
1617
1618async function mermaid(require) {
1619  const mer = await require(mermaid$1.resolve());
1620  mer.initialize({securityLevel: "loose", theme: "neutral"});
1621  return function mermaid() {
1622    const root = document.createElement("div");
1623    root.innerHTML = mer.render(uid().id, String.raw.apply(String, arguments));
1624    return root.removeChild(root.firstChild);
1625  };
1626}
1627
1628function Mutable(value) {
1629  let change;
1630  Object.defineProperties(this, {
1631    generator: {value: observe(_ => void (change = _))},
1632    value: {get: () => value, set: x => change(value = x)} // eslint-disable-line no-setter-return
1633  });
1634  if (value !== undefined) change(value);
1635}
1636
1637function* now() {
1638  while (true) {
1639    yield Date.now();
1640  }
1641}
1642
1643function delay(duration, value) {
1644  return new Promise(function(resolve) {
1645    setTimeout(function() {
1646      resolve(value);
1647    }, duration);
1648  });
1649}
1650
1651var timeouts = new Map;
1652
1653function timeout(now, time) {
1654  var t = new Promise(function(resolve) {
1655    timeouts.delete(time);

1656    var delay = time - now;
1657    if (!(delay > 0)) throw new Error("invalid time");
1658    if (delay > 0x7fffffff) throw new Error("too long to wait");
1659    setTimeout(resolve, delay);
1660  });
1661  timeouts.set(time, t);
1662  return t;
1663}
1664
1665function when(time, value) {
1666  var now;
1667  return (now = timeouts.get(time = +time)) ? now.then(() => value)
1668      : (now = Date.now()) >= time ? Promise.resolve(value)
1669      : timeout(now, time).then(() => value);
1670}
1671
1672function tick(duration, value) {
1673  return when(Math.ceil((Date.now() + 1) / duration) * duration, value);
1674}
1675
1676var Promises = /*#__PURE__*/Object.freeze({
1677__proto__: null,
1678delay: delay,
1679tick: tick,
1680when: when
1681});
1682
1683function resolve(name, base) {
1684  if (/^(\w+:)|\/\//i.test(name)) return name;
1685  if (/^[.]{0,2}\//i.test(name)) return new URL(name, base == null ? location : base).href;
1686  if (!name.length || /^[\s._]/.test(name) || /\s$/.test(name)) throw new Error("illegal name");
1687  return "https://unpkg.com/" + name;
1688}
1689
1690const svg = template(function(string) {
1691  var root = document.createElementNS("http://www.w3.org/2000/svg", "g");
1692  root.innerHTML = string.trim();
1693  return root;
1694}, function() {
1695  return document.createElementNS("http://www.w3.org/2000/svg", "g");
1696});
1697
1698var raw = String.raw;
1699
1700function style(href) {
1701  return new Promise(function(resolve, reject) {
1702    var link = document.createElement("link");
1703    link.rel = "stylesheet";
1704    link.href = href;
1705    link.onerror = reject;
1706    link.onload = resolve;
1707    document.head.appendChild(link);
1708  });
1709}
1710
1711function tex(require) {
1712  return Promise.all([
1713    require(katex.resolve()),
1714    require.resolve(katex.resolve("dist/katex.min.css")).then(style)
1715  ]).then(function(values) {
1716    var katex = values[0], tex = renderer();
1717
1718    function renderer(options) {
1719      return function() {
1720        var root = document.createElement("div");
1721        katex.render(raw.apply(String, arguments), root, options);
1722        return root.removeChild(root.firstChild);
1723      };
1724    }
1725
1726    tex.options = renderer;
1727    tex.block = renderer({displayMode: true});
1728    return tex;
1729  });
1730}
1731
1732async function vl(require) {
1733  const [v, vl, api] = await Promise.all([vega, vegalite, vegaliteApi].map(d => require(d.resolve())));
1734  return api.register(v, vl);
1735}
1736
1737function width() {
1738  return observe(function(change) {
1739    var width = change(document.body.clientWidth);
1740    function resized() {
1741      var w = document.body.clientWidth;
1742      if (w !== width) change(width = w);
1743    }
1744    window.addEventListener("resize", resized);
1745    return function() {
1746      window.removeEventListener("resize", resized);
1747    };
1748  });
1749}
1750
1751function ascending(a, b) {
1752  return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
1753}
1754
1755function descending(a, b) {
1756  return a == null || b == null ? NaN
1757    : b < a ? -1
1758    : b > a ? 1
1759    : b >= a ? 0
1760    : NaN;
1761}
1762
1763function bisector(f) {
1764  let compare1, compare2, delta;
1765
1766  // If an accessor is specified, promote it to a comparator. In this case we
1767  // can test whether the search value is (self-) comparable. We can’t do this
1768  // for a comparator (except for specific, known comparators) because we can’t
1769  // tell if the comparator is symmetric, and an asymmetric comparator can’t be
1770  // used to test whether a single value is comparable.
1771  if (f.length !== 2) {
1772    compare1 = ascending;
1773    compare2 = (d, x) => ascending(f(d), x);
1774    delta = (d, x) => f(d) - x;
1775  } else {
1776    compare1 = f === ascending || f === descending ? f : zero;
1777    compare2 = f;
1778    delta = f;
1779  }
1780
1781  function left(a, x, lo = 0, hi = a.length) {
1782    if (lo < hi) {
1783      if (compare1(x, x) !== 0) return hi;
1784      do {
1785        const mid = (lo + hi) >>> 1;
1786        if (compare2(a[mid], x) < 0) lo = mid + 1;
1787        else hi = mid;
1788      } while (lo < hi);
1789    }
1790    return lo;
1791  }
1792
1793  function right(a, x, lo = 0, hi = a.length) {
1794    if (lo < hi) {
1795      if (compare1(x, x) !== 0) return hi;
1796      do {
1797        const mid = (lo + hi) >>> 1;
1798        if (compare2(a[mid], x) <= 0) lo = mid + 1;
1799        else hi = mid;
1800      } while (lo < hi);
1801    }
1802    return lo;
1803  }
1804
1805  function center(a, x, lo = 0, hi = a.length) {
1806    const i = left(a, x, lo, hi - 1);
1807    return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
1808  }
1809
1810  return {left, center, right};
1811}
1812
1813function zero() {
1814  return 0;
1815}
1816
1817function number(x) {
1818  return x === null ? NaN : +x;
1819}
1820
1821bisector(ascending);
1822bisector(number).center;
1823
1824function reverse(values) {
1825  if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable");
1826  return Array.from(values).reverse();
1827}
1828
1829const nChecks = 20; // number of values to check in each array
1830
1831// We support two levels of DatabaseClient. The simplest DatabaseClient
1832// implements only the client.sql tagged template literal. More advanced
1833// DatabaseClients implement client.query and client.queryStream, which support
1834// streaming and abort, and the client.queryTag tagged template literal is used
1835// to translate the contents of a SQL cell or Table cell into the appropriate
1836// arguments for calling client.query or client.queryStream. For table cells, we

1837// additionally require client.describeColumns. The client.describeTables method
1838// is optional.
1839function isDatabaseClient(value, mode) {
1840  return (
1841    value &&
1842    (typeof value.sql === "function" ||
1843      (typeof value.queryTag === "function" &&
1844        (typeof value.query === "function" ||
1845          typeof value.queryStream === "function"))) &&
1846    (mode !== "table" || typeof value.describeColumns === "function") &&
1847    value !== __query // don’t match our internal helper
1848  );
1849}
1850
1851// Returns true if the value is a typed array (for a single-column table), or if
1852// it’s an array. In the latter case, the elements of the array must be
1853// consistently typed: either plain objects or primitives or dates.
1854function isDataArray(value) {
1855  return (
1856    (Array.isArray(value) &&
1857      (isQueryResultSetSchema(value.schema) ||
1858        isQueryResultSetColumns(value.columns) ||
1859        arrayContainsObjects(value) ||
1860        arrayContainsPrimitives(value) ||
1861        arrayContainsDates(value))) ||
1862    isTypedArray(value)
1863  );
1864}
1865
1866// Given an array, checks that the given value is an array that does not contain
1867// any primitive values (at least for the first few values that we check), and
1868// that the first object contains enumerable keys (see computeSchema for how we
1869// infer the columns). We assume that the contents of the table are homogenous,
1870// but we don’t currently enforce this.
1871// https://observablehq.com/@observablehq/database-client-specification#§1
1872function arrayContainsObjects(value) {
1873  const n = Math.min(nChecks, value.length);
1874  for (let i = 0; i < n; ++i) {
1875    const v = value[i];
1876    if (v === null || typeof v !== "object") return false;
1877  }
1878  return n > 0 && objectHasEnumerableKeys(value[0]);
1879}
1880
1881// Using a for-in loop here means that we can abort after finding at least one
1882// enumerable key (whereas Object.keys would require materializing the array of
1883// all keys, which would be considerably slower if the value has many keys!).
1884// This function assumes that value is an object; see arrayContainsObjects.
1885function objectHasEnumerableKeys(value) {
1886  for (const _ in value) return true;
1887  return false;
1888}
1889
1890function isQueryResultSetSchema(schemas) {
1891  return (Array.isArray(schemas) && schemas.every((s) => s && typeof s.name === "string"));
1892}
1893
1894function isQueryResultSetColumns(columns) {
1895  return (Array.isArray(columns) && columns.every((name) => typeof name === "string"));
1896}
1897
1898// Returns true if the value represents an array of primitives (i.e., a
1899// single-column table). This should only be passed values for which
1900// isDataArray returns true.
1901function arrayIsPrimitive(value) {
1902  return (
1903    isTypedArray(value) ||
1904    arrayContainsPrimitives(value) ||
1905    arrayContainsDates(value)
1906  );
1907}
1908
1909// Given an array, checks that the first n elements are primitives (number,
1910// string, boolean, bigint) of a consistent type.
1911function arrayContainsPrimitives(value) {
1912  const n = Math.min(nChecks, value.length);
1913  if (!(n > 0)) return false;
1914  let type;
1915  let hasPrimitive = false; // ensure we encounter 1+ primitives
1916  for (let i = 0; i < n; ++i) {
1917    const v = value[i];
1918    if (v == null) continue; // ignore null and undefined
1919    const t = typeof v;
1920    if (type === undefined) {
1921      switch (t) {
1922        case "number":
1923        case "boolean":
1924        case "string":
1925        case "bigint":
1926          type = t;
1927          break;
1928        default:
1929          return false;
1930      }
1931    } else if (t !== type) {
1932      return false;
1933    }
1934    hasPrimitive = true;
1935  }
1936  return hasPrimitive;
1937}
1938
1939// Given an array, checks that the first n elements are dates.
1940function arrayContainsDates(value) {
1941  const n = Math.min(nChecks, value.length);
1942  if (!(n > 0)) return false;
1943  let hasDate = false; // ensure we encounter 1+ dates
1944  for (let i = 0; i < n; ++i) {
1945    const v = value[i];
1946    if (v == null) continue; // ignore null and undefined
1947    if (!(v instanceof Date)) return false;
1948    hasDate = true;
1949  }
1950  return hasDate;
1951}
1952
1953function isTypedArray(value) {
1954  return (
1955    value instanceof Int8Array ||
1956    value instanceof Int16Array ||
1957    value instanceof Int32Array ||
1958    value instanceof Uint8Array ||
1959    value instanceof Uint8ClampedArray ||
1960    value instanceof Uint16Array ||
1961    value instanceof Uint32Array ||
1962    value instanceof Float32Array ||
1963    value instanceof Float64Array
1964  );
1965}
1966
1967// __query is used by table cells; __query.sql is used by SQL cells.
1968const __query = Object.assign(
1969  async (source, operations, invalidation) => {

1970    source = await loadDataSource(await source, "table");
1971    if (isDatabaseClient(source)) return evaluateQuery(source, makeQueryTemplate(operations, source), invalidation);
1972    if (isDataArray(source)) return __table(source, operations);
1973    if (!source) throw new Error("missing data source");
1974    throw new Error("invalid data source");
1975  },
1976  {
1977    sql(source, invalidation) {
1978      return async function () {
1979        return evaluateQuery(await loadDataSource(await source, "sql"), arguments, invalidation);
1980      };
1981    }
1982  }
1983);
1984
1985async function loadDataSource(source, mode) {
1986  if (source instanceof FileAttachment) {
1987    if (mode === "table") {
1988      switch (source.mimeType) {
1989        case "text/csv": return source.csv({typed: true});
1990        case "text/tab-separated-values": return source.tsv({typed: true});
1991        case "application/json": return source.json();
1992      }
1993    }
1994    if (mode === "table" || mode === "sql") {
1995      switch (source.mimeType) {
1996        case "application/x-sqlite3": return source.sqlite();
1997      }
1998      if (/\.arrow$/i.test(source.name)) return DuckDBClient.of({__table: await source.arrow({version: 9})});
1999    }
2000    throw new Error(`unsupported file type: ${source.mimeType}`);
2001  }
2002  if ((mode === "table" || mode === "sql") && isArrowTable(source)) {
2003    return DuckDBClient.of({__table: source});
2004  }
2005  return source;
2006}
2007
2008async function evaluateQuery(source, args, invalidation) {
2009  if (!source) throw new Error("missing data source");
2010
2011  // If this DatabaseClient supports abort and streaming, use that.
2012  if (typeof source.queryTag === "function") {
2013    const abortController = new AbortController();
2014    const options = {signal: abortController.signal};
2015    invalidation.then(() => abortController.abort("invalidated"));
2016    if (typeof source.queryStream === "function") {
2017      return accumulateQuery(
2018        source.queryStream(...source.queryTag.apply(source, args), options)
2019      );
2020    }
2021    if (typeof source.query === "function") {
2022      return source.query(...source.queryTag.apply(source, args), options);
2023    }
2024  }
2025
2026  // Otherwise, fallback to the basic sql tagged template literal.
2027  if (typeof source.sql === "function") {
2028    return source.sql.apply(source, args);
2029  }
2030
2031  // TODO: test if source is a file attachment, and support CSV etc.
2032  throw new Error("source does not implement query, queryStream, or sql");
2033}
2034
2035// Generator function that yields accumulated query results client.queryStream
2036async function* accumulateQuery(queryRequest) {
2037  let then = performance.now();
2038  const queryResponse = await queryRequest;
2039  const values = [];
2040  values.done = false;
2041  values.error = null;
2042  values.schema = queryResponse.schema;
2043  try {
2044    for await (const rows of queryResponse.readRows()) {
2045      if (performance.now() - then > 10 && values.length > 0) {
2046        yield values;
2047        then = performance.now();
2048      }
2049      for (const value of rows) {
2050        values.push(value);
2051      }
2052    }
2053    values.done = true;
2054    yield values;
2055  } catch (error) {
2056    values.error = error;
2057    yield values;
2058  }
2059}
2060
2061/**
2062 * Returns a SQL query in the form [[parts], ...params] where parts is an array
2063 * of sub-strings and params are the parameter values to be inserted between each
2064 * sub-string.
2065 */
2066function makeQueryTemplate(operations, source) {
2067  const escaper =
2068    typeof source.escape === "function" ? source.escape : (i) => i;
2069  const {select, from, filter, sort, slice} = operations;
2070  if (!from.table)
2071    throw new Error("missing from table");
2072  if (select.columns && select.columns.length === 0)
2073    throw new Error("at least one column must be selected");
2074  const columns = select.columns ? select.columns.map((c) => `t.${escaper(c)}`) : "*";
2075  const args = [
2076    [`SELECT ${columns} FROM ${formatTable(from.table, escaper)} t`]
2077  ];
2078  for (let i = 0; i < filter.length; ++i) {
2079    appendSql(i ? `\nAND ` : `\nWHERE `, args);
2080    appendWhereEntry(filter[i], args, escaper);
2081  }
2082  for (let i = 0; i < sort.length; ++i) {
2083    appendSql(i ? `, ` : `\nORDER BY `, args);
2084    appendOrderBy(sort[i], args, escaper);
2085  }
2086  if (source.dialect === "mssql") {
2087    if (slice.to !== null || slice.from !== null) {
2088      if (!sort.length) {
2089        if (!select.columns)
2090          throw new Error(
2091              "at least one column must be explicitly specified. Received '*'."
2092          );

2093        appendSql(`\nORDER BY `, args);
2094        appendOrderBy(
2095          {column: select.columns[0], direction: "ASC"},
2096          args,
2097          escaper
2098        );
2099      }
2100      appendSql(`\nOFFSET ${slice.from || 0} ROWS`, args);
2101      appendSql(
2102        `\nFETCH NEXT ${
2103          slice.to !== null ? slice.to - (slice.from || 0) : 1e9
2104        } ROWS ONLY`,
2105        args
2106      );
2107    }
2108  } else {
2109    if (slice.to !== null || slice.from !== null) {
2110      appendSql(
2111        `\nLIMIT ${slice.to !== null ? slice.to - (slice.from || 0) : 1e9}`,
2112        args
2113      );
2114    }
2115    if (slice.from !== null) {
2116      appendSql(` OFFSET ${slice.from}`, args);
2117    }
2118  }
2119  return args;
2120}
2121
2122function formatTable(table, escaper) {
2123  if (typeof table === "object") { // i.e., not a bare string specifier
2124    let from = "";
2125    if (table.database != null) from += escaper(table.database) + ".";
2126    if (table.schema != null) from += escaper(table.schema) + ".";
2127    from += escaper(table.table);
2128    return from;
2129  }
2130  return table;
2131}
2132
2133function appendSql(sql, args) {
2134  const strings = args[0];
2135  strings[strings.length - 1] += sql;
2136}
2137
2138function appendOrderBy({column, direction}, args, escaper) {
2139  appendSql(`t.${escaper(column)} ${direction.toUpperCase()}`, args);
2140}
2141
2142function appendWhereEntry({type, operands}, args, escaper) {
2143  if (operands.length < 1) throw new Error("Invalid operand length");
2144
2145  // Unary operations
2146  if (operands.length === 1) {
2147    appendOperand(operands[0], args, escaper);
2148    switch (type) {
2149      case "n":
2150        appendSql(` IS NULL`, args);
2151        return;
2152      case "nn":
2153        appendSql(` IS NOT NULL`, args);
2154        return;
2155      default:
2156        throw new Error("Invalid filter operation");
2157    }
2158  }
2159
2160  // Binary operations
2161  if (operands.length === 2) {
2162    if (["in", "nin"].includes(type)) ; else if (["c", "nc"].includes(type)) {
2163      // TODO: Case (in)sensitive?
2164      appendOperand(operands[0], args, escaper);
2165      switch (type) {
2166        case "c":
2167          appendSql(` LIKE `, args);
2168          break;
2169        case "nc":
2170          appendSql(` NOT LIKE `, args);
2171          break;
2172      }
2173      appendOperand(likeOperand(operands[1]), args, escaper);
2174      return;
2175    } else {
2176      appendOperand(operands[0], args, escaper);
2177      switch (type) {
2178        case "eq":
2179          appendSql(` = `, args);
2180          break;
2181        case "ne":
2182          appendSql(` <> `, args);
2183          break;
2184        case "gt":
2185          appendSql(` > `, args);
2186          break;
2187        case "lt":
2188          appendSql(` < `, args);
2189          break;
2190        case "gte":
2191          appendSql(` >= `, args);
2192          break;
2193        case "lte":
2194          appendSql(` <= `, args);
2195          break;
2196        default:
2197          throw new Error("Invalid filter operation");
2198      }
2199      appendOperand(operands[1], args, escaper);
2200      return;
2201    }
2202  }
2203
2204  // List operations
2205  appendOperand(operands[0], args, escaper);
2206  switch (type) {
2207    case "in":
2208      appendSql(` IN (`, args);
2209      break;
2210    case "nin":
2211      appendSql(` NOT IN (`, args);
2212      break;
2213    default:
2214      throw new Error("Invalid filter operation");
2215  }
2216  appendListOperands(operands.slice(1), args);
2217  appendSql(")", args);
2218}
2219
2220function appendOperand(o, args, escaper) {
2221  if (o.type === "column") {
2222    appendSql(`t.${escaper(o.value)}`, args);
2223  } else {
2224    args.push(o.value);
2225    args[0].push("");
2226  }
2227}
2228
2229// TODO: Support column operands here?
2230function appendListOperands(ops, args) {
2231  let first = true;
2232  for (const op of ops) {
2233    if (first) first = false;
2234    else appendSql(",", args);
2235    args.push(op.value);
2236    args[0].push("");
2237  }
2238}
2239
2240function likeOperand(operand) {
2241  return {...operand, value: `%${operand.value}%`};
2242}
2243
2244// This function applies table cell operations to an in-memory table (array of
2245// objects); it should be equivalent to the corresponding SQL query.
2246function __table(source, operations) {
2247  const input = source;
2248  let {schema, columns} = source;
2249  let primitive = arrayIsPrimitive(source);
2250  if (primitive) source = Array.from(source, (value) => ({value}));
2251  for (const {type, operands} of operations.filter) {
2252    const [{value: column}] = operands;
2253    const values = operands.slice(1).map(({value}) => value);
2254    switch (type) {
2255      case "eq": {
2256        const [value] = values;
2257        if (value instanceof Date) {
2258          const time = +value; // compare as primitive
2259          source = source.filter((d) => +d[column] === time);
2260        } else {
2261          source = source.filter((d) => d[column] === value);
2262        }
2263        break;
2264      }
2265      case "ne": {
2266        const [value] = values;
2267        source = source.filter((d) => d[column] !== value);
2268        break;
2269      }
2270      case "c": {
2271        const [value] = values;
2272        source = source.filter(
2273          (d) => typeof d[column] === "string" && d[column].includes(value)
2274        );
2275        break;
2276      }
2277      case "nc": {
2278        const [value] = values;
2279        source = source.filter(
2280          (d) => typeof d[column] === "string" && !d[column].includes(value)
2281        );
2282        break;
2283      }
2284      case "in": {
2285        const set = new Set(values); // TODO support dates?
2286        source = source.filter((d) => set.has(d[column]));
2287        break;
2288      }
2289      case "nin": {
2290        const set = new Set(values); // TODO support dates?
2291        source = source.filter((d) => !set.has(d[column]));
2292        break;
2293      }
2294      case "n": {
2295        source = source.filter((d) => d[column] == null);
2296        break;
2297      }
2298      case "nn": {
2299        source = source.filter((d) => d[column] != null);
2300        break;
2301      }
2302      case "lt": {
2303        const [value] = values;
2304        source = source.filter((d) => d[column] < value);
2305        break;
2306      }
2307      case "lte": {
2308        const [value] = values;
2309        source = source.filter((d) => d[column] <= value);
2310        break;
2311      }
2312      case "gt": {
2313        const [value] = values;
2314        source = source.filter((d) => d[column] > value);
2315        break;
2316      }
2317      case "gte": {
2318        const [value] = values;
2319        source = source.filter((d) => d[column] >= value);
2320        break;
2321      }
2322      default:
2323        throw new Error(`unknown filter type: ${type}`);
2324    }
2325  }
2326  for (const {column, direction} of reverse(operations.sort)) {
2327    const compare = direction === "desc" ? descending : ascending;
2328    if (source === input) source = source.slice(); // defensive copy
2329    source.sort((a, b) => compare(a[column], b[column]));
2330  }
2331  let {from, to} = operations.slice;
2332  from = from == null ? 0 : Math.max(0, from);

2333  to = to == null ? Infinity : Math.max(0, to);
2334  if (from > 0 || to < Infinity) {
2335    source = source.slice(Math.max(0, from), Math.max(0, to));
2336  }
2337  if (operations.select.columns) {
2338    if (schema) {
2339      const schemaByName = new Map(schema.map((s) => [s.name, s]));
2340      schema = operations.select.columns.map((c) => schemaByName.get(c));
2341    }
2342    if (columns) {
2343      columns = operations.select.columns;
2344    }
2345    source = source.map((d) =>
2346      Object.fromEntries(operations.select.columns.map((c) => [c, d[c]]))
2347    );
2348  }
2349  if (primitive) source = source.map((d) => d.value);
2350  if (source !== input) {
2351    if (schema) source.schema = schema;
2352    if (columns) source.columns = columns;
2353  }
2354  return source;
2355}
2356
2357const Library = Object.assign(Object.defineProperties(function Library(resolver) {
2358  const require = requirer(resolver);
2359  Object.defineProperties(this, properties({
2360    FileAttachment: () => NoFileAttachments,
2361    Mutable: () => Mutable,
2362    now,
2363    width,
2364
2365    // Tagged template literals
2366    dot: () => require(graphviz.resolve()),
2367    htl: () => require(htl.resolve()),
2368    html: () => html$1,
2369    md: () => md(require),
2370    svg: () => svg,
2371    tex: () => tex(require),
2372
2373    // Recommended libraries
2374    // https://observablehq.com/@observablehq/recommended-libraries
2375    _: () => require(lodash.resolve()),
2376    aq: () => require.alias({"apache-arrow": arrow4.resolve()})(arquero.resolve()), // TODO upgrade to apache-arrow@9
2377    Arrow: () => require(arrow4.resolve()), // TODO upgrade to apache-arrow@9
2378    d3: () => require(d3.resolve()),
2379    DuckDBClient: () => DuckDBClient,
2380    Inputs: () => require(inputs.resolve()).then(Inputs => ({...Inputs, file: Inputs.fileOf(AbstractFile)})),
2381    L: () => leaflet(require),
2382    mermaid: () => mermaid(require),
2383    Plot: () => require(plot.resolve()),
2384    __query: () => __query,
2385    require: () => require,
2386    resolve: () => resolve, // deprecated; use async require.resolve instead
2387    SQLite: () => SQLite(require),
2388    SQLiteDatabaseClient: () => SQLiteDatabaseClient,
2389    topojson: () => require(topojson.resolve()),
2390    vl: () => vl(require),
2391
2392    // Sample datasets
2393    // https://observablehq.com/@observablehq/datasets
2394    aapl: () => new FileAttachment("https://static.observableusercontent.com/files/3ccff97fd2d93da734e76829b2b066eafdaac6a1fafdec0faf6ebc443271cfc109d29e80dd217468fcb2aff1e6bffdc73f356cc48feb657f35378e6abbbb63b9").csv({typed: true}),
2395    alphabet: () => new FileAttachment("https://static.observableusercontent.com/files/75d52e6c3130b1cae83cda89305e17b50f33e7420ef205587a135e8562bcfd22e483cf4fa2fb5df6dff66f9c5d19740be1cfaf47406286e2eb6574b49ffc685d").csv({typed: true}),
2396    cars: () => new FileAttachment("https://static.observableusercontent.com/files/048ec3dfd528110c0665dfa363dd28bc516ffb7247231f3ab25005036717f5c4c232a5efc7bb74bc03037155cb72b1abe85a33d86eb9f1a336196030443be4f6").csv({typed: true}),
2397    citywages: () => new FileAttachment("https://static.observableusercontent.com/files/39837ec5121fcc163131dbc2fe8c1a2e0b3423a5d1e96b5ce371e2ac2e20a290d78b71a4fb08b9fa6a0107776e17fb78af313b8ea70f4cc6648fad68ddf06f7a").csv({typed: true}),
2398    diamonds: () => new FileAttachment("https://static.observableusercontent.com/files/87942b1f5d061a21fa4bb8f2162db44e3ef0f7391301f867ab5ba718b225a63091af20675f0bfe7f922db097b217b377135203a7eab34651e21a8d09f4e37252").csv({typed: true}),
2399    flare: () => new FileAttachment("https://static.observableusercontent.com/files/a6b0d94a7f5828fd133765a934f4c9746d2010e2f342d335923991f31b14120de96b5cb4f160d509d8dc627f0107d7f5b5070d2516f01e4c862b5b4867533000").csv({typed: true}),
2400    industries: () => new FileAttachment("https://static.observableusercontent.com/files/76f13741128340cc88798c0a0b7fa5a2df8370f57554000774ab8ee9ae785ffa2903010cad670d4939af3e9c17e5e18e7e05ed2b38b848ac2fc1a0066aa0005f").csv({typed: true}),
2401    miserables: () => new FileAttachment("https://static.observableusercontent.com/files/31d904f6e21d42d4963ece9c8cc4fbd75efcbdc404bf511bc79906f0a1be68b5a01e935f65123670ed04e35ca8cae3c2b943f82bf8db49c5a67c85cbb58db052").json(),
2402    olympians: () => new FileAttachment("https://static.observableusercontent.com/files/31ca24545a0603dce099d10ee89ee5ae72d29fa55e8fc7c9ffb5ded87ac83060d80f1d9e21f4ae8eb04c1e8940b7287d179fe8060d887fb1f055f430e210007c").csv({typed: true}),
2403    penguins: () => new FileAttachment("https://static.observableusercontent.com/files/715db1223e067f00500780077febc6cebbdd90c151d3d78317c802732252052ab0e367039872ab9c77d6ef99e5f55a0724b35ddc898a1c99cb14c31a379af80a").csv({typed: true}),
2404    weather: () => new FileAttachment("https://static.observableusercontent.com/files/693a46b22b33db0f042728700e0c73e836fa13d55446df89120682d55339c6db7cc9e574d3d73f24ecc9bc7eb9ac9a1e7e104a1ee52c00aab1e77eb102913c1f").csv({typed: true}),
2405
2406    // Note: these are namespace objects, and thus exposed directly rather than
2407    // being wrapped in a function. This allows library.Generators to resolve,
2408    // rather than needing module.value.
2409    DOM,
2410    Files,
2411    Generators: Generators$1,
2412    Promises
2413  }));
2414}, {
2415  resolve: {
2416    get: () => requireDefault.resolve,
2417    enumerable: true,
2418    configurable: true
2419  },
2420  require: {
2421    get: () => requireDefault,
2422    set: setDefaultRequire,
2423    enumerable: true,
2424    configurable: true
2425  }
2426}), {
2427  resolveFrom,
2428  requireFrom
2429});
2430
2431function properties(values) {
2432  return Object.fromEntries(Object.entries(values).map(property));
2433}
2434
2435function property([key, value]) {
2436  return [key, ({value, writable: true, enumerable: true})];
2437}
2438
2439// src/main.js
2440class PandocCodeDecorator {
2441  constructor(node) {
2442    this._node = node;
2443    this._spans = [];
2444    this.normalizeCodeRange();
2445    this.initializeEntryPoints();
2446  }
2447  normalizeCodeRange() {
2448    const n = this._node;
2449    const lines = n.querySelectorAll("code > span");
2450    for (const line of lines) {
2451      Array.from(line.childNodes).filter((n2) =>

2451 n2.nodeType === n2.TEXT_NODE).forEach((n2) => {
2452        const newSpan = document.createElement("span");
2453        newSpan.textContent = n2.wholeText;
2454        n2.replaceWith(newSpan);
2455      });
2456    }
2457  }
2458  initializeEntryPoints() {
2459    const lines = this._node.querySelectorAll("code > span");
2460    let result = [];
2461    let offset = this._node.parentElement.dataset.sourceOffset && -Number(this._node.parentElement.dataset.sourceOffset) || 0;
2462    for (const line of lines) {
2463      let lineNumber = Number(line.id.split("-").pop());
2464      let column = 1;
2465      Array.from(line.childNodes).filter((n) => n.nodeType === n.ELEMENT_NODE && n.nodeName === "SPAN").forEach((n) => {
2466        result.push({
2467          offset,
2468          line: lineNumber,
2469          column,
2470          node: n
2471        });
2472        offset += n.textContent.length;
2473        column += n.textContent.length;
2474      });
2475      offset += 1;
2476    }
2477    this._elementEntryPoints = result;
2478  }
2479  locateEntry(offset) {
2480    let candidate;
2481    if (offset === Infinity)
2482      return void 0;
2483    for (let i = 0; i < this._elementEntryPoints.length; ++i) {
2484      const entry = this._elementEntryPoints[i];
2485      if (entry.offset > offset) {
2486        return { entry: candidate, index: i - 1 };
2487      }
2488      candidate = entry;
2489    }
2490    if (offset < candidate.offset + candidate.node.textContent.length) {
2491      return { entry: candidate, index: this._elementEntryPoints.length - 1 };
2492    } else {
2493      return void 0;
2494    }
2495  }
2496  offsetToLineColumn(offset) {
2497    let entry = this.locateEntry(offset);
2498    if (entry === void 0) {
2499      const entries = this._elementEntryPoints;
2500      const last = entries[entries.length - 1];
2501      return {
2502        line: last.line,
2503        column: last.column + Math.min(last.node.textContent.length, offset - last.offset)
2504      };
2505    }
2506    return {
2507      line: entry.entry.line,
2508      column: entry.entry.column + offset - entry.entry.offset
2509    };
2510  }
2511  *spanSelection(start, end) {
2512    this.ensureExactSpan(start, end);
2513    const startEntry = this.locateEntry(start);
2514    const endEntry = this.locateEntry(end);
2515    if (startEntry === void 0) {
2516      return;
2517    }
2518    const startIndex = startEntry.index;
2519    const endIndex = endEntry && endEntry.index || this._elementEntryPoints.length;
2520    for (let i = startIndex; i < endIndex; ++i) {
2521      if (this._elementEntryPoints[i] !== void 0) {
2522        yield this._elementEntryPoints[i];
2523      }
2524    }
2525  }
2526  decorateSpan(start, end, classes) {
2527    for (const entryPoint of this.spanSelection(start, end)) {
2528      for (const cssClass of classes) {
2529        entryPoint.node.classList.add(cssClass);
2530      }
2531    }
2532  }
2533  clearSpan(start, end, classes) {
2534    for (const entryPoint of this.spanSelection(start, end)) {
2535      for (const cssClass of classes) {
2536        entryPoint.node.classList.remove(cssClass);
2537      }
2538    }
2539  }
2540  ensureExactSpan(start, end) {
2541    const splitEntry = (entry, offset) => {
2542      const newSpan = document.createElement("span");
2543      for (const cssClass of entry.node.classList) {
2544        newSpan.classList.add(cssClass);
2545      }
2546      const beforeText = entry.node.textContent.slice(0, offset - entry.offset);
2547      const afterText = entry.node.textContent.slice(offset - entry.offset);
2548      entry.node.textContent = beforeText;
2549      newSpan.textContent = afterText;
2550      entry.node.after(newSpan);
2551      this._elementEntryPoints.push({
2552        column: entry.column + offset - entry.offset,
2553        line: entry.line,
2554        node: newSpan,
2555        offset
2556      });
2557      this._elementEntryPoints.sort((a, b) => a.offset - b.offset);
2558    };
2559    const startEntry = this.locateEntry(start);
2560    if (startEntry !== void 0 && startEntry.entry !== void 0 && startEntry.entry.offset != start) {
2561      splitEntry(startEntry.entry, start);
2562    }
2563    const endEntry = this.locateEntry(end);
2564    if (endEntry !== void 0 && startEntry.entry !== void 0 && endEntry.entry.offset !== end) {
2565      splitEntry(endEntry.entry, end);
2566    }
2567  }
2568  clearSpan(start, end, classes) {
2569    this.ensureExactSpan(start, end);
2570    const startEntry = this.locateEntry(start);
2571    const endEntry = this.locateEntry(end);
2572    if (startEntry === void 0) {
2573      return;
2574    }
2575    const startIndex = startEntry.index;
2576    const endIndex = endEntry && endEntry.index || this._elementEntryPoints.length;
2577    for (let i = startIndex; i < endIndex; ++i) {
2578      for (const cssClass of classes) {
2579        this._elementEntryPoints[i].node.classList.remove(cssClass);
2580      }
2581    }
2582  }
2583}
2584
2585function dispatch(node, type, detail) {
2586  detail = detail || {};
2587  var document = node.ownerDocument, event = document.defaultView.CustomEvent;
2588  if (typeof event === "function") {
2589    event = new event(type, {detail: detail});
2590  } else {
2591    event = document.createEvent("Event");
2592    event.initEvent(type, false, false);
2593    event.detail = detail;
2594  }
2595  node.dispatchEvent(event);
2596}
2597
2598// TODO https://twitter.com/mbostock/status/702737065121742848
2599function isarray(value) {
2600  return Array.isArray(value)
2601      || value instanceof Int8Array
2602      || value instanceof Int16Array
2603      || value instanceof Int32Array
2604      || value instanceof Uint8Array
2605      || value instanceof Uint8ClampedArray
2606      || value instanceof Uint16Array
2607      || value instanceof Uint32Array
2608      || value instanceof Float32Array
2609      || value instanceof Float64Array;
2610}
2611
2612// Non-integer keys in arrays, e.g. [1, 2, 0.5: "value"].
2613function isindex(key) {
2614  return key === (key | 0) + "";
2615}
2616
2617function inspectName(name) {
2618  const n = document.createElement("span");
2619  n.className = "observablehq--cellname";
2620  n.textContent = `${name} = `;
2621  return n;
2622}
2623
2624const symbolToString = Symbol.prototype.toString;
2625
2626// Symbols do not coerce to strings; they must be explicitly converted.
2627function formatSymbol(symbol) {
2628  return symbolToString.call(symbol);
2629}
2630
2631const {getOwnPropertySymbols, prototype: {hasOwnProperty: hasOwnProperty$1}} = Object;
2632const {toStringTag} = Symbol;
2633
2634const FORBIDDEN = {};
2635
2636const symbolsof = getOwnPropertySymbols;
2637
2638function isown(object, key) {
2639  return hasOwnProperty$1.call(object, key);
2640}
2641
2642function tagof(object) {
2643  return object[toStringTag]
2644      || (object.constructor && object.constructor.name)
2645      || "Object";
2646}
2647
2648function valueof(object, key) {
2649  try {
2650    const value = object[key];
2651    if (value) value.constructor; // Test for SecurityError.
2652    return value;
2653  } catch (ignore) {
2654    return FORBIDDEN;
2655  }
2656}
2657
2658const SYMBOLS = [
2659  { symbol: "@@__IMMUTABLE_INDEXED__@@", name: "Indexed", modifier: true },
2660  { symbol: "@@__IMMUTABLE_KEYED__@@", name: "Keyed", modifier: true },