diff --git a/node_modules/commarcdiag/README.md b/node_modules/commarcdiag/README.md new file mode 100644 index 0000000..c8ba7bf --- /dev/null +++ b/node_modules/commarcdiag/README.md @@ -0,0 +1,33 @@ +# Commedia: Arc Diagram per marcatura sintattica + +https://observablehq.com/@cesare/commarcdiag@1264 + +View this notebook in your browser by running a web server in this folder. For +example: + +~~~sh +npx http-server +~~~ + +Or, use the [Observable Runtime](https://github.com/observablehq/runtime) to +import this module directly into your application. To npm install: + +~~~sh +npm install @observablehq/runtime@5 +npm install https://api.observablehq.com/d/d019e1db56ab1d8c@1264.tgz?v=3 +~~~ + +Then, import your notebook and the runtime as: + +~~~js +import {Runtime, Inspector} from "@observablehq/runtime"; +import define from "@cesare/commarcdiag"; +~~~ + +To log the value of the cell named “foo”: + +~~~js +const runtime = new Runtime(); +const main = runtime.module(define); +main.value("foo").then(value => console.log(value)); +~~~ diff --git a/node_modules/commarcdiag/a33468b95d0b15b0@808.js b/node_modules/commarcdiag/a33468b95d0b15b0@808.js new file mode 100644 index 0000000..6f74cc4 --- /dev/null +++ b/node_modules/commarcdiag/a33468b95d0b15b0@808.js @@ -0,0 +1,369 @@ +// https://observablehq.com/@d3/color-legend@808 +function _1(md){return( +md`# Color Legend + +A simple legend for a [color scale](/@d3/color-schemes). Supports [continuous](/@d3/continuous-scales), [sequential](/@d3/sequential-scales), [diverging](/@d3/diverging-scales), [quantize, quantile, threshold](/@d3/quantile-quantize-and-threshold-scales) and [ordinal](/@d3/d3-scaleordinal) scales. To use: + +~~~js +import {Legend, Swatches} from "@d3/color-legend" +~~~ + +Then call the legend function as shown below. (For ordinal scales, also consider the swatches function.)` +)} + +function _2(Legend,d3){return( +Legend(d3.scaleSequential([0, 100], d3.interpolateViridis), { + title: "Temperature (°F)" +}) +)} + +function _3(Legend,d3){return( +Legend(d3.scaleSequentialSqrt([0, 1], d3.interpolateTurbo), { + title: "Speed (kts)" +}) +)} + +function _4(Legend,d3){return( +Legend(d3.scaleDiverging([-0.1, 0, 0.1], d3.interpolatePiYG), { + title: "Daily change", + tickFormat: "+%" +}) +)} + +function _5(Legend,d3){return( +Legend(d3.scaleDivergingSqrt([-0.1, 0, 0.1], d3.interpolateRdBu), { + title: "Daily change", + tickFormat: "+%" +}) +)} + +function _6(Legend,d3){return( +Legend(d3.scaleSequentialLog([1, 100], d3.interpolateBlues), { + title: "Energy (joules)", + ticks: 10 +}) +)} + +function _7(Legend,d3){return( +Legend(d3.scaleSequentialQuantile(d3.range(100).map(() => Math.random() ** 2), d3.interpolateBlues), { + title: "Quantile", + tickFormat: ".2f" +}) +)} + +function _8(Legend,d3){return( +Legend(d3.scaleSqrt([-100, 0, 100], ["blue", "white", "red"]), { + title: "Temperature (°C)" +}) +)} + +function _9(Legend,d3){return( +Legend(d3.scaleQuantize([1, 10], d3.schemePurples[9]), { + title: "Unemployment rate (%)" +}) +)} + +function _10(Legend,d3){return( +Legend(d3.scaleQuantile(d3.range(1000).map(d3.randomNormal(100, 20)), d3.schemeSpectral[9]), { + title: "Height (cm)", + tickFormat: ".0f" +}) +)} + +function _11(Legend,d3){return( +Legend(d3.scaleThreshold([2.5, 3.1, 3.5, 3.9, 6, 7, 8, 9.5], d3.schemeRdBu[9]), { + title: "Unemployment rate (%)", + tickSize: 0 +}) +)} + +function _12(Legend,d3){return( +Legend(d3.scaleOrdinal(["<10", "10-19", "20-29", "30-39", "40-49", "50-59", "60-69", "70-79", "≥80"], d3.schemeSpectral[10]), { + title: "Age (years)", + tickSize: 0 +}) +)} + +function _13(md){return( +md`But wait, there’s more! + +How about swatches for ordinal color scales? Both variable-width swatches and [column layout](https://developer.mozilla.org/en-US/docs/Web/CSS/columns) are supported.` +)} + +function _14(Swatches,d3){return( +Swatches(d3.scaleOrdinal(["blueberries", "oranges", "apples"], d3.schemeCategory10)) +)} + +function _15(Swatches,d3){return( +Swatches(d3.scaleOrdinal(["Wholesale and Retail Trade", "Manufacturing", "Leisure and hospitality", "Business services", "Construction", "Education and Health", "Government", "Finance", "Self-employed", "Other"], d3.schemeTableau10), { + columns: "180px" +}) +)} + +function _16(md){return( +md`--- + +## Implementation` +)} + +function _Legend(d3){return( +function Legend(color, { + title, + tickSize = 6, + width = 320, + height = 44 + tickSize, + marginTop = 18, + marginRight = 0, + marginBottom = 16 + tickSize, + marginLeft = 0, + ticks = width / 64, + tickFormat, + tickValues +} = {}) { + + function ramp(color, n = 256) { + const canvas = document.createElement("canvas"); + canvas.width = n; + canvas.height = 1; + const context = canvas.getContext("2d"); + for (let i = 0; i < n; ++i) { + context.fillStyle = color(i / (n - 1)); + context.fillRect(i, 0, 1, 1); + } + return canvas; + } + + const svg = d3.create("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", [0, 0, width, height]) + .style("overflow", "visible") + .style("display", "block"); + + let tickAdjust = g => g.selectAll(".tick line").attr("y1", marginTop + marginBottom - height); + let x; + + // Continuous + if (color.interpolate) { + const n = Math.min(color.domain().length, color.range().length); + + x = color.copy().rangeRound(d3.quantize(d3.interpolate(marginLeft, width - marginRight), n)); + + svg.append("image") + .attr("x", marginLeft) + .attr("y", marginTop) + .attr("width", width - marginLeft - marginRight) + .attr("height", height - marginTop - marginBottom) + .attr("preserveAspectRatio", "none") + .attr("xlink:href", ramp(color.copy().domain(d3.quantize(d3.interpolate(0, 1), n))).toDataURL()); + } + + // Sequential + else if (color.interpolator) { + x = Object.assign(color.copy() + .interpolator(d3.interpolateRound(marginLeft, width - marginRight)), + {range() { return [marginLeft, width - marginRight]; }}); + + svg.append("image") + .attr("x", marginLeft) + .attr("y", marginTop) + .attr("width", width - marginLeft - marginRight) + .attr("height", height - marginTop - marginBottom) + .attr("preserveAspectRatio", "none") + .attr("xlink:href", ramp(color.interpolator()).toDataURL()); + + // scaleSequentialQuantile doesn’t implement ticks or tickFormat. + if (!x.ticks) { + if (tickValues === undefined) { + const n = Math.round(ticks + 1); + tickValues = d3.range(n).map(i => d3.quantile(color.domain(), i / (n - 1))); + } + if (typeof tickFormat !== "function") { + tickFormat = d3.format(tickFormat === undefined ? ",f" : tickFormat); + } + } + } + + // Threshold + else if (color.invertExtent) { + const thresholds + = color.thresholds ? color.thresholds() // scaleQuantize + : color.quantiles ? color.quantiles() // scaleQuantile + : color.domain(); // scaleThreshold + + const thresholdFormat + = tickFormat === undefined ? d => d + : typeof tickFormat === "string" ? d3.format(tickFormat) + : tickFormat; + + x = d3.scaleLinear() + .domain([-1, color.range().length - 1]) + .rangeRound([marginLeft, width - marginRight]); + + svg.append("g") + .selectAll("rect") + .data(color.range()) + .join("rect") + .attr("x", (d, i) => x(i - 1)) + .attr("y", marginTop) + .attr("width", (d, i) => x(i) - x(i - 1)) + .attr("height", height - marginTop - marginBottom) + .attr("fill", d => d); + + tickValues = d3.range(thresholds.length); + tickFormat = i => thresholdFormat(thresholds[i], i); + } + + // Ordinal + else { + x = d3.scaleBand() + .domain(color.domain()) + .rangeRound([marginLeft, width - marginRight]); + + svg.append("g") + .selectAll("rect") + .data(color.domain()) + .join("rect") + .attr("x", x) + .attr("y", marginTop) + .attr("width", Math.max(0, x.bandwidth() - 1)) + .attr("height", height - marginTop - marginBottom) + .attr("fill", color); + + tickAdjust = () => {}; + } + + svg.append("g") + .attr("transform", `translate(0,${height - marginBottom})`) + .call(d3.axisBottom(x) + .ticks(ticks, typeof tickFormat === "string" ? tickFormat : undefined) + .tickFormat(typeof tickFormat === "function" ? tickFormat : undefined) + .tickSize(tickSize) + .tickValues(tickValues)) + .call(tickAdjust) + .call(g => g.select(".domain").remove()) + .call(g => g.append("text") + .attr("x", marginLeft) + .attr("y", marginTop + marginBottom - height - 6) + .attr("fill", "currentColor") + .attr("text-anchor", "start") + .attr("font-weight", "bold") + .attr("class", "title") + .text(title)); + + return svg.node(); +} +)} + +function _legend(Legend){return( +function legend({color, ...options}) { + return Legend(color, options); +} +)} + +function _Swatches(d3,htl){return( +function Swatches(color, { + columns = null, + format, + unknown: formatUnknown, + swatchSize = 15, + swatchWidth = swatchSize, + swatchHeight = swatchSize, + marginLeft = 0 +} = {}) { + const id = `-swatches-${Math.random().toString(16).slice(2)}`; + const unknown = formatUnknown == null ? undefined : color.unknown(); + const unknowns = unknown == null || unknown === d3.scaleImplicit ? [] : [unknown]; + const domain = color.domain().concat(unknowns); + if (format === undefined) format = x => x === unknown ? formatUnknown : x; + + function entity(character) { + return `&#${character.charCodeAt(0).toString()};`; + } + + if (columns !== null) return htl.html`
+ +
${domain.map(value => { + const label = `${format(value)}`; + return htl.html`
+
+
${label}
+
`; + })} +
+
`; + + return htl.html`
+ +
${domain.map(value => htl.html`${format(value)}`)}
`; +} +)} + +function _swatches(Swatches){return( +function swatches({color, ...options}) { + return Swatches(color, options); +} +)} + +export default function define(runtime, observer) { + const main = runtime.module(); + main.variable(observer()).define(["md"], _1); + main.variable(observer()).define(["Legend","d3"], _2); + main.variable(observer()).define(["Legend","d3"], _3); + main.variable(observer()).define(["Legend","d3"], _4); + main.variable(observer()).define(["Legend","d3"], _5); + main.variable(observer()).define(["Legend","d3"], _6); + main.variable(observer()).define(["Legend","d3"], _7); + main.variable(observer()).define(["Legend","d3"], _8); + main.variable(observer()).define(["Legend","d3"], _9); + main.variable(observer()).define(["Legend","d3"], _10); + main.variable(observer()).define(["Legend","d3"], _11); + main.variable(observer()).define(["Legend","d3"], _12); + main.variable(observer()).define(["md"], _13); + main.variable(observer()).define(["Swatches","d3"], _14); + main.variable(observer()).define(["Swatches","d3"], _15); + main.variable(observer()).define(["md"], _16); + main.variable(observer("Legend")).define("Legend", ["d3"], _Legend); + main.variable(observer("legend")).define("legend", ["Legend"], _legend); + main.variable(observer("Swatches")).define("Swatches", ["d3","htl"], _Swatches); + main.variable(observer("swatches")).define("swatches", ["Swatches"], _swatches); + return main; +} diff --git a/node_modules/commarcdiag/d019e1db56ab1d8c@1264.js b/node_modules/commarcdiag/d019e1db56ab1d8c@1264.js new file mode 100644 index 0000000..eb4df66 --- /dev/null +++ b/node_modules/commarcdiag/d019e1db56ab1d8c@1264.js @@ -0,0 +1,1198 @@ +import define1 from "./a33468b95d0b15b0@808.js"; + +function _1(md){return( +md`# Commedia: Arc Diagram per marcatura sintattica +Visualizzazione delle annotazione sintattiche della Commedia come grafi.` +)} + +function _d3(require){return( +require("d3@^6.0") +)} + +function _3(md){return( +md`### Import Data` +)} + +function _links(FileAttachment){return( +FileAttachment("parsint_mod_completo_pre_new_4@2.csv").csv({typed: true}) +)} + +function _5(md){return( +md`### Create Dataset` +)} + +function _types(links){return( +Array.from(new Set(links.map(d => d.type))) +)} + +function _getFrasi(links){return( +function getFrasi(nfrase){ + const mnode= [] + const mlinks=[] + const usednodes=[] + //const ns=Array.from(new Set(links.flatMap(l => [l.source, l.target])), id => ({id})) + links.map(function(item) { + var mysrc=item.source + var mytgt=item.target + var frase=item.frase + var myval=''; + if (!usednodes.includes(mysrc.replace(/\s/g, '')) && nfrase.includes(frase)){ + mnode.push({ + "id" : mysrc, + "type" : item.type, + "rif" : item.frase, + "visible": item.visibile.trim(), + "s_type" : item.tipo + }); + usednodes.push(mysrc.replace(/\s/g, '')) + } + if (!usednodes.includes(mytgt.replace(/\s/g, '')) && nfrase.includes(frase)){ + mnode.push({ + "id" : mytgt, + "type" : item.type, + "rif" : item.frase, + "visible": item.visibile.trim(), + "s_type" : item.tipo + }); + usednodes.push(mytgt.replace(/\s/g, '')) + + } + + }) + links.map(function(item) { + var mysrc=item.source + var mytgt=item.target + var frase=item.frase + if (nfrase.includes(frase)){ + mlinks.push({ + "source" : mysrc, + "target" : mytgt, + "type" : item.type + }); + } + }) + + var data_frase=({nodes: mnode, links: mlinks}) + return data_frase; +} +)} + +function _getSid(){return( +function getSid(ids){ + ids= ids.replace(/\s/g,'') + var setids= ids.split(",") + return setids +} +)} + +function _listafrasi(getSid,lisid){return( +getSid(lisid) +)} + +function _getColor(sentenceFunctionsColor2){return( +function getColor(st){ + return sentenceFunctionsColor2(st) +} +)} + +function _clauseType(){return( +'subord I' +)} + +function _col(getColor,clauseType){return( +getColor(clauseType) +)} + +function _data_frasi(getFrasi,listafrasi){return( +getFrasi(listafrasi) +)} + +function _sentenceTypes(data_frasi){return( +data_frasi.nodes.slice(1).map(function(d){return d.s_type}) +)} + +function _sentenceNodeNames(data_frasi){return( +data_frasi.nodes.slice(1).map(function(d){return d.visible}) +)} + +function _idToNode(data_frasi) +{ + let dict = {}; + data_frasi.nodes.slice(0).forEach(function(n) { + dict[n.id] = n; + }); + return dict; +} + + +function _idToTargetNodes(data_frasi) +{ + let dict = {}; + data_frasi.nodes.slice(1).forEach(function (n) { + dict[n.id] = []; + data_frasi.links.slice(1).forEach(function (l) { + if (l.source === n.id) { + dict[n.id].push(l.target); + } + }); + }); + return dict; +} + + +function _syntactic_macrotypes(){return( +{ + "avv": "Avversativa", + "caus": "Causale", + "compar": "Comparativa", + "conces": "Concessiva", + "consec": "Consecutiva", + "dich": "Dichiarativa", + "eccettu": "Eccettuativa", + "epesege": "Epesegetica", + "escl": "Esclamativa", + "esclu": "Esclusiva", + "finale": "Finale", + "inter": "Interrogativa", + "ipotet": "Ipotetica", + "iussi": "Iussiva", + "limitat": "Limitativa", + "maniera": "Di Maniera", + "modale": "Modale", + "obliqua": "Obliqua", + "oggettiva": "Oggettiva", + "otta": "Ottativa", + "pare mod": "ParenteticaModalizzante", + "pare sub": "ParenteticaCon ValoreDiSubordinata", + "pred": "Predicativa", + "pseudo": "Pseudocoordinata", + "rel": "Relativa", + "sog": "Soggettiva", + "strum": "Strumentale", + "sub": "SubordinataConFunzioneDiRipresa", + "temp": "Temporale", +} +)} + +function _syntactic_types(){return( +{"avv caus": "Coordinata Avversativa Causale", + "avv comp ug": "Coordinata Avversativa Comparativa Di Uguaglianza", + "avv cons antec": "Coordinata Avversativa ConsecutivaCon Antecedente", + "avv dich": "Coordinata Avversativa Dichiarativa", + "avv fin": "Coordinata AvversativaFinale", + "avv int x": "Coordinata Avversativa Interrogativa Di TipoX", + "avv int x ret": "Coordinata Avversativa Interrogativa Di TipoX Retorica", + "avv ipo caus": "Coordinata Avversativa Ipotetica Con Valore Causale", + "avv iuss dir": "Coordinata AvversativaIussivaDiretta", + "avv iuss indir": "Coordinata AvversativaIussivaIndiretta", + "avv modaliz ott intr": "Coordinata Avversativa Modalizzante Ottativa Con Introduttore", + "avv ogg": "Coordinata Avversativa Oggettiva", + "avv ogg perc": "Coordinata Avversativa Oggettiva", + "avv rel app": "Coordinata Avversativa Relativa Appositiva", + "avv rel app comp ug": "Coordinata Avversativa Relativa Appositiva In Construtto Comparativo", + "avv rel app cons antec": "Coordinata Avversativa Relativa Appositiva Con Valore Consecutivo", + "avv rel giust": "Coordinata Avversativa Relativa Giustapposta", + "avv rel ind": "Coordinata Avversativa Relativa Indipendente", + "avv rel ind temp": "Coordinata Avversativa Relativa Indipendente Temporale", + "avv rel restr": "Coordinata Avversativa Relativa Restrittiva", + "avv rel restr comp ug": "Coordinata Avversativa Relativa Restrittiva In Costrutto Comparativo", + "avv sogg": "Coordinata Avversativa Soggettiva", + "avv temp": "Coordinata Avversativa Temporale", + "comp disug": "Comparativa Di Disuguaglianza", + "comp disug ipo": "Comparativa Di Disuguaglianza Con Valore Ipotetico", + "comp fin": "Comparativa Con Valore Finale", + "comp ipo": "Comparativa Con Valore Ipotetico", + "comp lim": "Comparativa Con Valore Limitativo", + "comp mod": "Comparativa Con Valore Modale", + "comp temp": "Comparativa Con Valore Temporale", + "comp ug": "Comparativa Di Uguaglianza", + "comp ug rel ind temp": "Comparativa Di Uguaglianza Con Valore Di Relativa Indipendente Temporale", + "conc acond": "Concessiva Acondizionale", + "conc cond": "Concessiva Condizionale", + "conc fatt": "Concessiva Fattuale", + "cong asind comp ug": "Coordinata Asindetica Comparativa Di Uguaglianza", + "cong asind cons antec": "Coordinata Asindetica Consecutiva Con Antecedente", + "cong asind dich": "Coordinata Asindetica Dichiarativa", + "cong asind epes": "Coordinata Asindetica Epesegetica", + "cong asind esclam": "Coordinata Asindetica Esclamativa", + "cong asind fin": "Coordinata Asindetica Finale", + "cong asind int altern": "Coordinata Asindetica Interrogativa Alternativa", + "cong asind int altern ret": "Coordinata Asindetica Interrogativa Alternativa Retorica", + "cong asind int disg": "Coordinata Asindetica Interrogativa Disgiuntiva", + "cong asind int x": "Coordinata Asindetica Interrogativa Di TipoX", + "cong asind int x ret": "Coordinata Asindetica Interrogativa Di TipoX Retorica", + "cong asind ipo": "Coordinata Asindetica Ipotetica", + "cong asind iuss dir": "Coordinata Asindetica IussivaDiretta", + "cong asind iuss indir": "Coordinata Asindetica IussivaIndiretta", + "cong asind man": "Coordinata Asindetica Di Maniera", + "cong asind ogg": "Coordinata Asindetica Oggettiva", + "cong asind ogg perc": "Coordinata Asindetica Oggettiva", + "cong asind ott intr": "Coordinata Asindetica Ottativa Con Introduttore", + "cong asind ott libera": "Coordinata Asindetica OttativaLibera", + "cong asind rel app": "Coordinata Asindetica Relativa Appositiva", + "cong asind rel app comp disug": "Coordinata Asindetica Relativa Appositiva In Construtto Comparativo", + "cong asind rel app giust": "Coordinata Asindetica Relativa Giustapposta", + "cong asind rel ind": "Coordinata Asindetica Relativa Indipendente", + "cong asind rel ind temp caus": "Coordinata Asindetica Relativa IndipendenteCon Valore Temporale Causale", + "cong asind rel restr": "Coordinata Asindetica Relativa Restrittiva", + "cong asind rel restr comp ug": "Coordinata Asindetica Relativa Restrittiva In Construtto Comparativo", + "cong asind sogg soll": "Coordinata Asindetica SoggettivaASollevamento", + "cong asind subord": "Coordinata Asindetica Subordinata", + "cong asind temp": "Coordinata Asindetica Temporale", + "cong caus": "Coordinata Congiuntiva Causale", + "cong comp disug": "Coordinata Congiuntiva Comparativa Di Disuguaglianza", + "cong comp ipo": "Coordinata Congiuntiva Comparativa Con Valore Ipotetico", + "cong comp lim": "Coordinata Congiuntiva Comparativa Con Valore Limitativo", + "cong comp mod": "Coordinata Congiuntiva Comparativa Con Valore Modale", + "cong comp ug": "Coordinata Congiuntiva Comparativa Di Uguaglianza", + "cong conc cond": "Coordinata Congiuntiva Concessiva Condizionale", + "cong conc fatt": "Coordinata Congiuntiva Concessiva Fattuale", + "cong concl cons antec": "Coordinata Conclusiva Consecutiva Con Antecedente", + "cong concl dich": "Coordinata Conclusiva Dichiarativa", + "cong concl dich ill": "Coordinata Conclusiva Dichiarativa Illocutiva", + "cong concl iuss dir": "Coordinata Conclusiva Iussiva Diretta", + "cong concl iuss dir perifr": "Coordinata Conclusiva Iussiva Diretta Perifrastica", + "cong concl iuss indir": "Coordinata Conclusiva Iussiva Indiretta", + "cong cons antec": "Coordinata Congiuntiva Consecutiva Con Antecedente", + "cong cons antec epes": "Coordinata Congiuntiva Consecutiva Con Antecedente Episegetica", + "cong cons antec fin": "Coordinata Congiuntiva Consecutiva Con Antecedente Con Valore Finale", + "cong cons caus": "Coordinata Consecutiva Causale", + "cong cons dich": "Coordinata Consecutiva Dichiarativa", + "cong cons ell": "Coordinata Congiuntiva Consecutiva Ellittica", + "cong cons libera": "Coordinata Congiuntiva Consecutiva Libera", + "cong cons libera fin": "Coordinata Congiuntiva Consecutiva Libera Con Valore Finale", + "cong cons post": "Coordinata Congiuntiva Consecutiva Posposta", + "cong corr dich": "CoordinataCorRelativa Dichiarativa", + "cong corr fin": "CoordinataCorRelativa Finale", + "cong corr lim": "CoordinataCorRelativa Limitativa", + "cong corr sogg infinitoprep": "CoordinataCorRelativa Soggettiva A Infinito Preposizionale", + "cong dich": "Coordinata Congiuntiva Dichiarativa", + "cong dich ill": "Coordinata Congiuntiva Dichiarativa Illocutiva", + "cong eccett": "Coordinata Congiuntiva Eccettuativa", + "cong epes": "Coordinata Congiuntiva Epesegetica", + "cong esclam": "Coordinata Congiuntiva Esclamativa", + "cong esclus": "Coordinata Congiuntiva Esclusiva", + "cong espl dich": "CoordinataEsplicativa Dichiarativa", + "cong espl obl": "Coordinata Esplicativa Obliqua", + "cong espl ogg": "Coordinata Esplicativa Oggettiva", + "cong espl rel app antec": "Coordinata Esplicativa Relativa Appositiva Con Antecedente", + "cong espl rel ind mod": "Coordinata Esplicativa Relativa Indipendente Con Valore Modale", + "cong fin": "Coordinata Congiuntiva Finale", + "cong int altern": "Coordinata Congiuntiva Interrogativa Alternativa", + "cong int x": "Coordinata Congiuntiva InterrogativaDi TipoX", + "cong int x ret": "Coordinata Congiuntiva InterrogativaDi TipoX Retorica", + "cong ipo": "Coordinata Congiuntiva Ipotetica", + "cong ipo caus": "Coordinata Congiuntiva IpoteticaCon Valore Causale", + "cong ipo sogg": "Coordinata Congiuntiva Ipotetica Soggettiva", + "cong iuss dir": "Coordinata Congiuntiva Iussiva Diretta", + "cong iuss indir": "Coordinata Congiuntiva Iussiva Indiretta", + "cong lim": "Coordinata Congiuntiva Limitativa", + "cong man": "Coordinata Congiuntiva Di Maniera", + "cong modaliz ott intr": "Coordinata Congiuntiva Modalizzante Ottativa Con Introduttore", + "cong obl": "Coordinata CongiuntivaObliqua", + "cong ogg": "Coordinata Congiuntiva Oggettiva", + "cong ogg perc": "Coordinata Congiuntiva Oggettiva", + "cong ott libera": "Coordinata Congiuntiva Libera", + "cong rel app": "Coordinata Congiuntiva Relativa Appositiva", + "cong rel app comp disug": "Coordinata Congiuntiva Relativa Appositiva In Costrutto Comparativo Di Disuguaglianza", + "cong rel app comp ug": "Coordinata Congiuntiva Relativa Appositiva In Costrutto Comparativo Di Uguaglianza", + "cong rel app cons": "Coordinata Congiuntiva Relativa Appositiva Con Valore Consecutivo", + "cong rel app epes": "Coordinata Congiuntiva Relativa Appositiva Con Valore Di Episegetica", + "cong rel app fin": "Coordinata Congiuntiva Relativa Appositiva Con Valore Finale", + "cong rel app giust": "Coordinata Congiuntiva Relativa Giustapposta", + "cong rel app giust caus": "Coordinata Congiuntiva Relativa Giustapposta Con Valore Causale", + "cong rel app temp": "Coordinata Congiuntiva Relativa Appositiva Con Valore Temporale", + "cong rel impl": "Coordinata Congiuntiva Relativa Implicita", + "cong rel impl lim": "Coordinata Congiuntiva Relativa ImplicitaCon Valore Limitativo", + "cong rel ind": "Coordinata Congiuntiva Relativa Indipendente", + "cong rel ind acond": "Coordinata Congiuntiva Relativa Indipendente Acondizionale", + "cong rel ind ipo": "Coordinata Congiuntiva Relativa IndipendenteCon Valore Ipotetico", + "cong rel ind mod": "Coordinata Congiuntiva Relativa IndipendenteCon Valore Modale", + "cong rel ind mod comp ug": "Coordinata Congiuntiva Relativa Indipendente In Costrutto ComparativoModale", + "cong rel ind temp": "Coordinata Congiuntiva Relativa Indipendente Temporale", + "cong rel pseudo": "Coordinata Congiuntiva Pseudo Relativa ", + "cong rel restr": "Coordinata Congiuntiva Relativa Restrittiva", + "cong rel restr caus": "Coordinata Congiuntiva Relativa RestrittivaCon Valore Causale", + "cong rel restr comp": "Coordinata Congiuntiva Relativa RestrittivaIn Costrutto Comparativo", + "cong rel restr comp ug": "Coordinata Congiuntiva Relativa RestrittivaIn Costrutto Comparativo Di Uguaglianza", + "cong rel restr cons": "Coordinata Congiuntiva Relativa RestrittivaCon Valore Consecutivo", + "cong rel restr temp": "Coordinata Congiuntiva Relativa RestrittivaTemporale", + "cong rip": "Coordinata CongiuntivaConFunzioneDiRipresa", + "cong sogg": "Coordinata Congiuntiva Soggettiva", + "cong spec": "Coordinata Congiuntiva Specificativa", + "cong strum": "Coordinata Congiuntiva Strumentale", + "cong subord": "Coordinata Congiuntiva Subordinata", + "cong temp": "Coordinata Congiuntiva Temporale", + "cong temp caus": "Coordinata Congiuntiva TemporaleCon Valore Causale", + "cons antec": "Consecutiva Con Antecedente", + "cons antec epes": "Consecutiva Con Antecedente Epesegetica", + "cons antec fin": "Consecutiva Con Antecedente Con Valore Finale", + "cons antec temp": "Consecutiva Con Antecedente Con ValoreTemporale", + "cons ell": "Consecutiva Ellittica", + "cons libera": "Consecutiva Libera", + "cons libera fin": "Consecutiva Libera Con Valore Finale", + "cons post": "Consecutiva Posposta", + "dich": "Dichiarativa", + "dich ill": "Dichiarativa Illocutiva", + "disg comp disug temp": "Coordinata Disgiuntiva Comparativa Di Disuguaglianza Con Valore Temporale", + "disg conc acond": "Coordinata Disgiuntiva Concessiva Acondizionale", + "disg conc cond": "Coordinata Disgiuntiva Concessiva Condizionale", + "disg cons libera": "Coordinata Disgiuntiva Consecutiva Libera", + "disg corr dich": "Coordinata Disgiuntiva CorRelativa Dichiarativa", + "disg dich": "Coordinata Disgiuntiva Dichiarativa", + "disg epes": "Coordinata Disgiuntiva Epesegetica", + "disg esclus": "Coordinata Disgiuntiva Esclusiva", + "disg int altern": "Coordinata Disgiuntiva Interrogativa Alternativa", + "disg int disg": "Coordinata Disgiuntiva Interrogativa Disgiuntiva", + "disg int x": "Coordinata Disgiuntiva Interrogativa Di TipoX", + "disg ipo": "Coordinata Disgiuntiva Ipotetica", + "disg lim": "Coordinata Disgiuntiva Limitativa", + "disg man": "Coordinata Disgiuntiva Di Maniera", + "disg obl": "Coordinata Disgiuntiva Obliqua", + "disg ogg": "Coordinata Disgiuntiva Oggettiva", + "disg rel ind": "Coordinata Disgiuntiva Relativa Indipendente", + "disg rel ind acond": "Coordinata Disgiuntiva Relativa Indipendente Acondizionale", + "disg rel ind temp": "Coordinata Disgiuntiva Relativa Indipendente Temporale", + "disg rel restr": "Coordinata Disgiuntiva Restrittiva", + "disg rel restr cons": "Coordinata Disgiuntiva Restrittiva Con Valore Consecutivo", + "disg sogg": "Coordinata Disgiuntiva Soggettiva", + "disg temp": "Coordinata Disgiuntiva Temporale", + "eccett": "Eccettuativa", + "eccett comp ug": "EccettuativaCon Valore Di Comparativa Di Uguaglianza", + "epes": "Epesegetica", + "esclam": "Esclamativa", + "esclus": "Esclusiva", + "faltern": "FalsaAlternativa", + "fcong": "FalsaCongiuntiva", + "fin": "Finale", + "fin ipo": "FinaleCon Valore Ipotetico", + "fin rel giust": "Concorrenza Del Relativo In Frase Finale", + "int altern": "Interrogativa Alternativa", + "int altern ret": "Interrogativa Alternativa Retorica", + "int disg": "Interrogativa Disgiuntiva", + "int disg ret": "Interrogativa Disgiuntiva Retorica", + "int x": "Interrogativa Di TipoX", + "int x ret": "Interrogativa Di TipoX Retorica", + "ipo": "Ipotetica", + "ipo biaff": "Ipotetica Biaffermativa", + "ipo caus": "Ipotetica Con Valore Causale", + "ipo eccett": "Ipotetica Con Valore Eccettuativo", + "ipo obl": "Ipotetica Obliqua", + "ipo rel giust": "Ipotetica Relativa Giustapposta", + "ipo sogg": "Ipotetica Soggettiva", + "iuss aug": "Iussiva Augurativa", + "iuss dir": "Iussiva Diretta", + "iuss dir perifr": "Iussiva Diretta Perifrastica", + "iuss indir": "Iussiva Indiretta", + "lim": "Limitativa", + "lim caus": "Limitativa Con Valore Causale", + "lim caus eccett": "Limitativa Con Valore Causale Eccettuativo", + "lim eccett": "Limitativa Con Valore Eccettuativo", + "man": "Di Maniera", + "man gerundioprep": "Di Maniera A Gerundio Preposizionale", + "man rel giust": "Concorrenza Del Relativo In Frase Di Maniera", + "mod": "Modale", + "modaliz": "Modalizzante", + "modaliz ott intr": "Modalizzante Ottativa Con Introduttore", + "modalizz ott libera": "Modalizzante OttativaLibera", + "obl": "Obliqua", + "ogg": "Oggettiva", + "ogg aci": "Oggettiva", + "ogg perc": "Oggettiva", + "ott intr": "Ottativa Con Introduttore", + "ott libera": "OttativaLibera", + "pred": "Predicativa", + "rel app antec": "Relativa Appositiva Con Antecedente", + "rel app antec caus": "Relativa Appositiva Con Antecedente Con Valore Causale", + "rel app antec comp disug": "Relativa Appositiva Con AntecedenteIn Costrutto Comparativo Di Disuguaglianza", + "rel app antec comp ug": "Relativa Appositiva Con Antecedente In Costrutto Comparativo Di Uguaglianza", + "rel app antec comp ug": "Relativa Con Antecedente In Costrutto Comparativo Di Uguaglianza", + "rel app antec cons": "Relativa Appositiva Con Antecedente Con Valore Consecutivo", + "rel app antec eccett": "Relativa Appositiva Con Antecedente In Costrutto Eccettuativo", + "rel app antec fin": "Relativa Appositiva Con Antecedente Con Valore Finale", + "rel app antec fin cons": "Relativa Appositiva Con Antecedente Con Valore Consecutivo Finale", + "rel app antec giust": "Relativa Appositiva Con Antecedente Giustapposta", + "rel app antec giust cons": "Relativa Appositiva Giustapposta Con Valore Consecutivo", + "rel app antec giust ipo": "Relativa Appositiva Giustapposta Con Valore Ipotetico", + "rel app antec giust man": "Relativa Appositiva Giustapposta Con Valore Di Maniera", + "rel app antec strum": "Relativa Appositiva Con Antecedente Con Valore Strumentale", + "rel giust": "Relativa Giustapposta", + "rel impl": "Relativa Implicita", + "rel impl cons": "Relativa Implicita Con Valore Consecutivo", + "rel impl deon": "Relativa Implicita Deontica", + "rel impl fin": "Relativa Implicita Con Valore Finale", + "rel impl lim": "Relativa Implicita Con Valore Limitativo", + "rel ind": "Relativa Indipendente", + "rel ind acond": "Relativa Indipendente Acondizionale", + "rel ind caus": "Relativa Indipendente In Costrutto Causale", + "rel ind comp": "Relativa Indipendente In Costrutto Comparativo", + "rel ind ipo": "Relativa Indipendente Con Valore Ipotetico", + "rel ind mod": "Relativa Indipendente Con Valor eModale", + "rel ind mod comp ug": "Relativa Indipendente In Costrutto Comparativo Modale", + "rel ind temp": "Relativa Indipendente Con Valore Temporale", + "rel ind temp acond": "Relativa Indipendente Con Valore Temporale Acondizionale", + "rel ind temp caus": "Relativa Indipendente Con Valore Temporale Causale", + "rel ind temp comp ug": "Relativa Indipendente In Costrutto Comparativo Di Uguaglianza", + "rel pseudo": "Pseudo Relativa", + "rel pseudo fin": "Pseudo Relativa Con Valore Finale", + "rel pseudo scissa": "Pseudo Relativa Scissa", + "rel pseudo scissa temp": "Pseudo Relativa ScissaC on ValoreTemporale", + "rel restr antec": "Relativa Restrittiva Con Antecedente", + "rel restr antec caus": "Relativa Restrittiva Con Antecedente Con Valore Causale", + "rel restr antec comp disug": "Relativa Restrittiva Con Antecedente In Costrutto Comparativo Di Disuguaglianza", + "rel restr antec comp mod": "Relativa Restrittiva Con Antecedente In Costrutto Comparativo Modale", + "rel restr antec comp ug": "Relativa Restrittiva Con Antecedente In Costrutto Comparativo Di Uguaglianza", + "rel restr antec conc cond": "Relativa Restrittiva Con Antecedente Con Valore Di Concessiva Condizionale", + "rel restr antec conc fatt": "Relativa Restrittiva Con Antecedente Con Valore Di Concessiva Fattuale", + "rel restr antec cons": "Relativa Restrittiva Con Antecedente Con Valore Consecutivo", + "rel restr antec eccett": "Relativa Restrittiva Con Antecedente In Costrutto Eccettuativo", + "rel restr antec fin": "Relativa Restrittiva Con Antecedente Con Valore Finale", + "rel restr antec ipo": "Relativa Restrittiva Con Antecedente Con Valore Ipotetico", + "rel restr antec lim": "Relativa Restrittiva Con Antecedente In Costrutto Limitativo", + "rel restr antec temp": "Relativa Restrittiva Con Antecedente Con Valore Temporale", + "rip": "Funzione Di Ripresa", + "sogg": "Soggettiva", + "sogg aci": "Soggettiva", + "sogg id": "Soggettiva", + "sogg infinitoprep": "Soggettiva", + "sogg scissa": "Soggettiva Scissa", + "sogg soll": "Soggettiva A Sollevamento", + "spec": "Specificativa", + "spec aci": "Specificativa", + "spec infinitoprep": "Specificativa", + "strum": "Strumentale", + "subord": "Subordinata", + "temp": "Temporale", + "temp comp ug": "TemporaleCon Valore Comparativo", + "temp ipo": "TemporaleCon Valore Ipotetico", +} +)} + +function _getTypes(syntactic_macrotypes,syntactic_types){return( +function name(mtype) { + if(syntactic_macrotypes[mtype]) + return syntactic_macrotypes[mtype] + if(syntactic_types[mtype]) + return syntactic_types[mtype] + return mtype +} +)} + +function _clauseFunctions(){return( +{ + "princ": "Principale", + "coord": "Coordinata", + "coord I": "Coordinata I grado", + "coord II": "Coordinata II grado", + "coord III": "Coordinata III grado", + "coord IV": "Coordinata IV grado", + "coord V": "Coordinata V grado", + "subord": "Subordinata", + "subord I": "Subordinata I grado", + "subord II": "Subordinata II grado", + "subord III": "Subordinata III grado", + "subord IV": "Subordinata IV grado", + "subord V": "Subordinata V grado", + "subord VI": "Subordinata VI grado", + "subord VII": "Subordinata VII grado", + "parent": "Parentetica", + "pcoord": "Coordinata alla parentetica", + "pcoord I": "Coordinata alla parentetica I grado", + "coord 0": "Pseudo-coordinata" +} +)} + +function _22(md){return( +md`#### Creating SVG` +)} + +function _margin(){return( +{top: 20, bottom: 30, left: 5, right: 30} +)} + +function _height(margin){return( +360 - margin.top - margin.bottom +)} + +function _sentenceheight(sentenceNodeNames){return( +(sentenceNodeNames.length+1) * 33 +)} + +function _width(){return( +760 +)} + +function _27(md){return( +md`#### Create y scale function` +)} + +function _yScale(d3,sentenceNodeNames,sentenceheight){return( +d3.scalePoint() + .domain(sentenceNodeNames) + .range([0,sentenceheight]) +)} + +function _syntfunction(data_frasi){return( +new Set(data_frasi["links"].slice(1), d => d.type) +)} + +function _sentenceFunctionsColor(d3,types) +{return d3.scaleOrdinal(d3.schemePastel1).domain(types.values());} + + +function _sentenceFunctionsColor2(d3,types) +{return d3.scaleOrdinal(d3.schemeSet1).domain(types.values());} + + +function _synttype(data_frasi){return( +new Set(data_frasi["nodes"].slice(1), d=> d.s_type) +)} + +function _sentenceSynttypeColor(d3,synttype) +{return d3.scaleOrdinal(d3.schemePastel1).domain(synttype.values()); + } + + +function _colorssp(d3){return( +d3.scaleQuantize() + .domain([0,17]) + .range(["#1f78b4", "#a6cee3", "#b2df8a", "#33a02c", "#fb9a99", "#e31a1c", "#fdbf6f", "#ff7f00", + "#cab2d6", "#6a3d9a", "#ffff99", "#b15928", "#F46D43", + "#D53E4F", "#9E0142", "#e377c2", "#7f7f7f", "#bcbd22"]) +)} + +function _colorssp1(d3){return( +d3.scaleQuantize() + .domain([0,17]) + .range(["#3288bd", "#66c2a5", "#e41a1c", "#4daf4a", "#984ea3", "#d53e4f", "#f46d43", "#ABDDA4", + "#E6F598", "#FFFFBF", "#FEE08B", "#FDAE61", "#F46D43", + "#D53E4F", "#9E0142", "#e377c2", "#7f7f7f", "#bcbd22"]) +)} + +function _maptypestopalette(){return( +{"princ": 0, "subord I": 1, "subord II": 3, "subord III": 4, "coord": 5, + "coord I": 9, "coord II": 10, "subord IV": 5, "subord V": 6, "parent": 17, + "coord III": 11, "pcoord":14, "coord 0": 16, "subord VI": 7 , "coord IV": 12, + "coord V": 13, "pcoord I": 15, "subord VII": 8} +)} + +function _37(md){return( +md`## Struttura del periodo` +)} + +function _lisid(){return( +'1_22_1' +)} + +function* _periodoscritto(html,periodo) +{ + // for Observable Cell + const wrapper = html`
`; + const container = html`
` + + + + const descriptionDiv = document.createElement('div'); + + descriptionDiv.setAttribute("style", "font-size:1em; text-align:justify; font-style: oblique; text-anchor:start width: 100px;") + if (periodo==null) + descriptionDiv.innerHTML =''; + else + descriptionDiv.innerHTML =periodo; + + container.setAttribute("style", "font-size:1.0em; text-align:justify;") + wrapper.appendChild(descriptionDiv); + wrapper.appendChild(container); + yield wrapper; +} + + +function _41(swatches,sentenceFunctionsColor){return( +swatches({ + color: sentenceFunctionsColor +}) +)} + +function _periodo(data_frasi){return( +data_frasi.nodes[0].visible +)} + +function _sentenceStructArcs2(d3,DOM,width,margin,height,data_frasi,yScale,sentenceFunctionsColor,idToNode,sentenceFunctionsColor2,wrap_text_nchar) +{ + const radius = 5 + const container = d3.select(DOM.svg(width+margin.left+margin.right, + height+margin.top+margin.bottom)) + const arcGroup = container + .append("g") + .attr("transform", "translate(" + margin.left + "," + margin.top + ")") + + // create the nodes + const nodes = arcGroup.selectAll("nodes") + .data(data_frasi.nodes.slice(1)) + .enter().append("circle") + .attr("cx", margin.left+400) + .attr("cy", d => yScale(d.visible)) + .attr("r", radius) + .attr("fill", d=> sentenceFunctionsColor(d.type)) + .attr("id", d => d.visible) + + // create the node labels + const nodeLabels = arcGroup.selectAll("nodeLabels") + .data(data_frasi.nodes.slice(1)) + .enter().append("text") + .attr("x", margin.left+170) + .attr("y", d => yScale(d.visible)+5) + .attr("fill", "black") + .style("font-size", "10") + .style("font-style", "italic") + .style("text-anchor", "start") + .text(d => d.visible) + + + // the synctatic function + const syntfun = arcGroup.selectAll("syntfun") + .data(data_frasi.nodes.slice(1)) + .enter().append("text") + .attr("x", margin.left-10) + .attr("y", d => yScale(d.visible)+5) + .attr("fill", "black") + .style("font-size", "10") + .style("text-anchor", "start") + .text(d=> d.type+", "+d.s_type) + + // This code builds up the SVG path element; see nodesAndArcs for details + function buildArc(d) { + + let start = yScale(idToNode[d.source].visible); + let end = yScale(idToNode[d.target].visible); + //console.log(start+' '+end) + if (start==null) + return + const arcPath = ['M', margin.left+405, start, 'A', Math.abs(start - end)/2, ',', Math.abs(start-end)/2, 0,0,",", + start < end ? 1: 0, margin.left+405, end].join(' '); + return arcPath; + } + + // create the arcs + const arcs = arcGroup.selectAll("arcs") + .data(data_frasi.links.slice(1)) + .enter().append("path") + .attr("d", d => buildArc(d)) + .style("fill", "none") + .style('stroke-width', 0.5) + .attr("stroke", 'lightgray');//d => sentenceFunctionsColor(d.type)); + + // mouseover animations + nodes.on('mouseover', function(d) { + // Highlight selected node + d3.select(this).style("fill", d=>sentenceFunctionsColor2(d.type)); + + var targetids=[] + // Highlight arcs + arcs + .style('stroke', function (arcd) { + if (arcd.source === d.id) { targetids.push(arcd.target)}; if (arcd.target === d.id) { targetids.push(arcd.source)}; + return arcd.source === d.id || arcd.target === d.id ? d=> sentenceFunctionsColor2(d.type) : 'lightgray';})//d=> sentenceFunctionsColor(d.type);}) + .style('stroke-width', function (arcd) { + return arcd.source === d.id || arcd.target === d.id ? 2 : 0.5;}) + + // Show syntactic types + syntfun + .style('fill', function (syntfund) { + //return syntfund.visible+syntfund.s_type === d.visible+d.s_type ? 'steelblue' : 'black' ;}); + return (syntfund.visible+syntfund.s_type === d.visible+d.s_type || targetids.includes(syntfund.id)) ? 'steelblue' : 'black' ;}) + .style('font-weight', function (syntfund) { + //return syntfund.visible+syntfund.s_type === d.visible+d.s_type ? 'steelblue' : 'black' ;}); + return (syntfund.visible+syntfund.s_type === d.visible+d.s_type || targetids.includes(syntfund.id)) ? 'bold' : 'normal' ;}); + + // Highlight node labels + nodeLabels + .style("fill", function (nodeLabeld){ + return nodeLabeld.id == d.id || targetids.includes(nodeLabeld.id) ? 'black' : 'black';}) + .style('font-weight', function (nodeLabeld) { + return nodeLabeld.id == d.id || targetids.includes(nodeLabeld.id) ? 'bold' : 'normal';}) + }); + + // remove highlighting when user mouse moves out of node by restoring default colors and thickness + nodes.on('mouseout', function (d) { + nodes.style("fill", d=> sentenceFunctionsColor(d.type)); + arcs.style('stroke', 'lightgray')//d=>sentenceFunctionsColor(d.type)); + arcs.style('stroke-width', 0.5); + syntfun.style('fill','black'); + syntfun.style('font-weight','normal'); + nodeLabels.style('fill','black'); + nodeLabels.style('font-weight','normal'); + }); + + container.selectAll("text") + .each(function(d, i) { wrap_text_nchar(d3.select(this), 40) }); + return container.node(); + } + + +function _sentenceStructArcs(d3,DOM,width,margin,sentenceheight,lisid,data_frasi,yScale,colorssp,maptypestopalette,wrap_text_array,clauseFunctions,getTypes,idToNode,sentenceFunctionsColor2,wrap_text_nchar) +{ + + + const radius = 6 + const nodehpos=460 + const labelhpos=nodehpos-300 + const maxlabelwidth=40 + const container = d3.select(DOM.svg(width+margin.left+margin.right, + sentenceheight+margin.top+margin.bottom)) + + container.append("style").text(` + .synt__info{ + font-size: 12px; + font-weight: normal; + font-style: italic; + font-family: -apple-system, BlinkMacSystemFont, “Helvetica Neue”, + “Segoe UI”, “Roboto”, “Oxygen”, “Ubuntu”, “Cantarell”, + “Fira Sans”, “Droid Sans”, + sans-serif; + } + `) + + const arcGroup = container + .attr ("id", "periodograph") + .attr("width",null) + .attr("height",null) + .attr("name", lisid) + .append("g") + .style('pointer-events', 'all') + .attr("transform", "translate(" + margin.left + "," + margin.top + ")") + + // create the nodes + const nodes = arcGroup.selectAll("nodes") + .data(data_frasi.nodes.slice(1)) + .enter().append("circle") + .attr("cx", margin.left+nodehpos) + .attr("cy", d => yScale(d.visible)) + .attr("r", radius) + //.attr("fill", d=> sentenceFunctionsColor(d.type)) + .attr("fill", d => colorssp(maptypestopalette[d.type])) + .attr("id", d => d.visible) + + // create the node labels + const nodeLabels = arcGroup.selectAll("nodeLabels") + .data(data_frasi.nodes.slice(1)) + .enter().append("text") + .attr("x", margin.left+labelhpos) + .attr("y", d => yScale(d.visible)) + .attr("dominant-baseline", "middle") + //.attr("y", d=>ypostxt(d.visible)) + .attr("class","synt__info") + //.style("font-style", "italic") + .style("text-anchor", "start") + .text(d => d.visible) + + function ypostxt(label){ + //delta = (_fontsize * textarea.split("\n").length) / 2; + const label_array = wrap_text_array(label, maxlabelwidth); + return yScale(label)+ -(8 * label_array.length)/2 + //return label_array.length<3? yScale(label)+3: yScale(label)-(5*(label_array.length-1)) + } + + // the synctatic function and types + const syntfun = arcGroup.selectAll("syntfun") + .data(data_frasi.nodes.slice(1)) + .enter().append("text") + .attr("x", margin.left-10) + .attr("y", d => yScale(d.visible))//+syntfunctype(clauseFunctions[d.type]+", "+getTypes(d.s_type))) + .attr("dominant-baseline", "middle") + .attr("class","f6 text-muted text-nowrap font-weight-normal") + .style("font-size", "10") + .style("text-anchor", "start") + .style("letter-spacing", 0) + .text(d=> clauseFunctions[d.type]+", "+getTypes(d.s_type)) + + function syntfunctype(funty){ + const funty_array = wrap_text_array(funty, maxlabelwidth); + return (funty_array.length<3? 0: -10) + } + // This code builds up the SVG path element; see nodesAndArcs for details + function buildArc(d) { + + let start = yScale(idToNode[d.source].visible); + let end = yScale(idToNode[d.target].visible); + //console.log(start+' '+end) + if (start==null) + return + const arcPath = ['M', margin.left+nodehpos+6, start, 'A', Math.abs(start - end)/2, ',', Math.abs(start-end)/2, 0,0,",", + start < end ? 1: 0, margin.left+nodehpos+6, end].join(' '); + return arcPath; + } + + // create the arcs + const arcs = arcGroup.selectAll("arcs") + .data(data_frasi.links.slice(1)) + .enter().append("path") + .attr("d", d => buildArc(d)) + .style("fill", "none") + .style('stroke-width', 0.5) + .attr("stroke", 'lightgray');//d => sentenceFunctionsColor(d.type)); + + // mouseover animations + nodes.on('mouseover', function(event, d) { + // Highlight selected node + d3.select(this).style("fill", d=>colorssp(maptypestopalette[d.type]));//sentenceFunctionsColor2(d.type)); + + var targetids=[] + // Highlight arcs + arcs + .style('stroke', function (arcd) { + if (arcd.source === d.id) { targetids.push(arcd.target)}; if (arcd.target === d.id) { targetids.push(arcd.source)}; + return arcd.source === d.id || arcd.target === d.id ? d=> sentenceFunctionsColor2(d.type) : 'lightgray';})//d=> sentenceFunctionsColor(d.type);}) + .style('stroke-width', function (arcd) { + return arcd.source === d.id || arcd.target === d.id ? 2 : 0.5;}) + + // Highlight syntactic types + syntfun + .style('fill', function (syntfund) { + //return syntfund.visible+syntfund.s_type === d.visible+d.s_type ? 'steelblue' : 'black' ;}); + return (syntfund.visible+syntfund.s_type === d.visible+d.s_type || targetids.includes(syntfund.id)) ? 'steelblue' : 'black' ;}) + .style('font-weight', function (syntfund) { + //return syntfund.visible+syntfund.s_type === d.visible+d.s_type ? 'steelblue' : 'black' ;}); + return (syntfund.visible+syntfund.s_type === d.visible+d.s_type || targetids.includes(syntfund.id)) ? 'bold' : 'normal' ;}); + + // Highlight node labels + nodeLabels + .style("fill", function (nodeLabeld){ + return nodeLabeld.id == d.id || targetids.includes(nodeLabeld.id) ? 'black' : 'black';}) + .style('font-weight', function (nodeLabeld) { + return nodeLabeld.id == d.id || targetids.includes(nodeLabeld.id) ? 'bold' : 'normal';}) + }); + + // remove highlighting when user mouse moves out of node by restoring default colors and thickness + nodes.on('mouseout', function (event, d) { + nodes.style("fill", d=> colorssp(maptypestopalette[d.type]));//sentenceFunctionsColor(d.type)); + arcs.style('stroke', 'lightgray')//d=>sentenceFunctionsColor(d.type)); + arcs.style('stroke-width', 0.5); + syntfun.style('fill','black'); + syntfun.style('font-weight','normal'); + //nodeLabels.style('fill','black'); + nodeLabels.style('font-weight','normal'); + nodeLabels.attr("class","synt__info") + }); + + container.selectAll("text") + .each(function(d, i) { wrap_text_nchar(d3.select(this), 50) }); + return container.node(); + } + + +function _sentenceStructArcs_new(d3,DOM,width,margin,sentenceheight,lisid,data_frasi,yScale,colorssp,maptypestopalette,wrap_text_array,clauseFunctions,getTypes,idToNode,sentenceFunctionsColor2,darken,wrap_text_nchar) +{ + + + const radius = 4 + const nodehpos=460 + const labelhpos=nodehpos-300 + const maxlabelwidth=40 + const container = d3.select(DOM.svg(width+margin.left+margin.right, + sentenceheight+margin.top+margin.bottom)) + + /*container.append("style").text(` + .synt__info{ + font-size: 13px; + font-weight: normal; + font-style: italic; + font-family: Palatino; + + } + .synt__categ{ + font-size: 10px; + font-weight: normal; + font-family: Palatino; + } + + `) + */ + const arcGroup = container + .attr ("id", "periodograph") + .attr("width",null) + .attr("height",null) + .attr("name", lisid) + .append("g") + //.style('pointer-events', 'all') + .attr("transform", "translate(" + margin.left + "," + margin.top + ")") + + // create the nodes + const nodes = arcGroup.selectAll("nodes") + .data(data_frasi.nodes.slice(1)) + .enter().append("circle") + .attr("cx", margin.left+nodehpos) + .attr("cy", d => yScale(d.visible)) + .attr("r", radius) + //.attr("fill", d=> sentenceFunctionsColor(d.type)) + .attr("fill", d => colorssp(maptypestopalette[d.type])) + .attr("id", d => d.visible) + + // create the node labels + const nodeLabels = arcGroup.selectAll("nodeLabels") + .data(data_frasi.nodes.slice(1)) + .enter().append("text") + .attr("x", margin.left+labelhpos) + //.attr("y", d => yScale(d.visible)) + .attr("dominant-baseline", "middle") + .attr("y", d=>yScale(d.visible)+syntfunctype(d.visible)) + .attr("class","synt__info") + //.style("font-style", "italic") + .style("text-anchor", "start") + .text(d => d.visible) + + function ypostxt(label){ + //delta = (_fontsize * textarea.split("\n").length) / 2; + const label_array = wrap_text_array(label, maxlabelwidth); + return yScale(label)+ -(8 * label_array.length)/2 + //return label_array.length<3? yScale(label)+3: yScale(label)-(5*(label_array.length-1)) + } + + // the synctatic function and types + const syntfun = arcGroup.selectAll("syntfun") + .data(data_frasi.nodes.slice(1)) + .enter().append("text") + .attr("x", margin.left-10) + .attr("y", d => yScale(d.visible)+syntfunctype(clauseFunctions[d.type]+", "+getTypes(d.s_type))) + //.attr("y", d=>ypostxt(d.visible)) + .attr("dominant-baseline", "middle") + .attr("class","synt__categ") + .style("text-anchor", "start") + .style("letter-spacing", 0) + .text(d=> clauseFunctions[d.type]+", "+getTypes(d.s_type)) + + function syntfunctype(funty){ + const funty_array = wrap_text_array(funty, maxlabelwidth); + return (funty_array.length<2? 0: -(2.5 * funty_array.length)) + } + // This code builds up the SVG path element; see nodesAndArcs for details + function buildArc(d) { + + let start = yScale(idToNode[d.source].visible); + let end = yScale(idToNode[d.target].visible); + //console.log(start+' '+end) + if (start==null) + return + const arcPath = ['M', margin.left+nodehpos+4, start, 'A', Math.abs(start - end)/2, ',', Math.abs(start-end)/2, 0,0,",", + start < end ? 1: 0, margin.left+nodehpos+4, end].join(' '); + return arcPath; + } + + // create the arcs + const arcs = arcGroup.selectAll("arcs") + .data(data_frasi.links.slice(1)) + .enter().append("path") + .attr("d", d => buildArc(d)) + .style("fill", "none") + .style('stroke-width', 0.5) + .attr("stroke", 'lightgray');//d => sentenceFunctionsColor(d.type)); + + // mouseover animations + nodes.on('mouseover', function(event, d) { + // Highlight selected node + d3.select(this).style("fill", d=>colorssp(maptypestopalette[d.type]));//sentenceFunctionsColor2(d.type)); + + var targetids=[] + // Highlight arcs + arcs + .style('stroke', function (arcd) { + if (arcd.source === d.id) { targetids.push(arcd.target)}; if (arcd.target === d.id) { targetids.push(arcd.source)}; + return arcd.source === d.id || arcd.target === d.id ? d=> sentenceFunctionsColor2(d.type) : 'lightgray';})//d=> sentenceFunctionsColor(d.type);}) + .style('stroke-width', function (arcd) { + return arcd.source === d.id || arcd.target === d.id ? 2 : 0.5;}) + + // Highlight syntactic types + syntfun + .style('fill', function (syntfund) { + //return syntfund.visible+syntfund.s_type === d.visible+d.s_type ? 'steelblue' : 'black' ;}); + return (syntfund.visible+syntfund.s_type === d.visible+d.s_type || targetids.includes(syntfund.id)) ? darken('steelblue') : 'black' ;}) + .style('font-weight', function (syntfund) { + //return syntfund.visible+syntfund.s_type === d.visible+d.s_type ? 'steelblue' : 'black' ;}); + return (syntfund.visible+syntfund.s_type === d.visible+d.s_type || targetids.includes(syntfund.id)) ? 'bold' : 'normal' ;}); + + // Highlight node labels + nodeLabels + .style("fill", function (nodeLabeld){ + return nodeLabeld.id == d.id || targetids.includes(nodeLabeld.id) ? 'black' : 'black';}) + .style('font-weight', function (nodeLabeld) { + return nodeLabeld.id == d.id || targetids.includes(nodeLabeld.id) ? 'bold' : 'normal';}) + }); + + // remove highlighting when user mouse moves out of node by restoring default colors and thickness + nodes.on('mouseout', function (event, d) { + nodes.style("fill", d=> colorssp(maptypestopalette[d.type]));//sentenceFunctionsColor(d.type)); + arcs.style('stroke', 'lightgray')//d=>sentenceFunctionsColor(d.type)); + arcs.style('stroke-width', 0.5); + syntfun.style('fill','black'); + syntfun.style('font-weight','normal'); + //nodeLabels.style('fill','black'); + nodeLabels.style('font-weight','normal'); + nodeLabels.attr("class","synt__info") + }); + + container.selectAll("text") + .each(function(d, i) { wrap_text_nchar(d3.select(this), 50) }); + return container.node(); + } + + +function _46(md){return( +md`### Utility` +)} + +function _darken(d3){return( +function darken(color, k = 1) { + const {l, c, h} = d3.lch(color); + return d3.lch(l - 18 * k, c, h); +} +)} + +function _wrap_text_nchar(wrap_text_array){return( +(text_element, max_width, line_height, unit = "em") => { + //console.log('te' +text_element) + // use a default line_height if not provided + if (!line_height) line_height = 1.0; + if (text_element.text().length>150) + line_height = 0.8 + if (text_element.text().includes("ordinata") || text_element.text().includes("parentetica") || + text_element.text().includes("principale")){ + max_width=30 + if (text_element.text().length>90) + line_height = 0.9 + } + + // wrap the text based on how many characters per line + const text_array = wrap_text_array(text_element.text(), max_width); + + // append a tspan element for each line of text_array + text_element.text(null) + .selectAll("tspan") + .data(text_array).enter() + .append("tspan") + .attr("x", text_element.attr("x")) + .attr("y", text_element.attr("y")) + .attr("dy", (d, i) => `${(i * line_height)}${unit}`) + .text(d => d); +} +)} + +function _wrap_text_array(){return( +(text, max_width) => { + // split the text around spaces (to get individual words) + const words = text.split(/\s+/).reverse(); + + // define vars to hold individual words, lines, and all lines + let word, + lines = [ ], + line = [ ]; + + // add words to a line until we exceed the max_width (in characters) + // when we reach width, add the line to lines and start a new line + while (word = words.pop()) { + line.push(word); + if (line.join(" ").length > max_width || word[0]=='(') { + line.pop() + lines.push(line.join(" ")); + line = [word]; + } + } + lines.push(line.join(" ")); + + return lines; +} +)} + +function _wrap_node_text(){return( +(text, width) => { + // split the text around spaces (to get individual words) + + + if (text==null) + text=='' + const words = text.split(/\s+/).reverse(); + + // define vars to hold individual words, lines, and all lines + let word, + lines = [ ], + line = [ ]; + + // add words to a line until we exceed the max_width (in characters) + // when we reach width, add the line to lines and start a new line + while (word = words.pop()) { + line.push(word); + + if (line.join(" ").length > width) { + line.pop() + lines.push(line.join(" ")); + lines.push('\n
'); + line = [word.trim()]; + + } + } + lines.push(line.join(" ")); + var htmllines=lines.join("") + console.log(htmllines) + return htmllines; +} +)} + +export default function define(runtime, observer) { + const main = runtime.module(); + function toString() { return this.url; } + const fileAttachments = new Map([ + ["parsint_mod_completo_pre_new_4@2.csv", {url: new URL("./files/5188a44018bc82e735a769984523074724098d9cf0ddeb43cf179e12506e69e68b6dc3821dfd807e45e9756d3ace123c809f1b9d0ca8486b5a347bdca65da57c.csv", import.meta.url), mimeType: "text/csv", toString}] + ]); + main.builtin("FileAttachment", runtime.fileAttachments(name => fileAttachments.get(name))); + main.variable(observer()).define(["md"], _1); + main.variable(observer("d3")).define("d3", ["require"], _d3); + main.variable(observer()).define(["md"], _3); + main.variable(observer("links")).define("links", ["FileAttachment"], _links); + main.variable(observer()).define(["md"], _5); + main.variable(observer("types")).define("types", ["links"], _types); + main.variable(observer("getFrasi")).define("getFrasi", ["links"], _getFrasi); + main.variable(observer("getSid")).define("getSid", _getSid); + main.variable(observer("listafrasi")).define("listafrasi", ["getSid","lisid"], _listafrasi); + main.variable(observer("getColor")).define("getColor", ["sentenceFunctionsColor2"], _getColor); + main.variable(observer("clauseType")).define("clauseType", _clauseType); + main.variable(observer("col")).define("col", ["getColor","clauseType"], _col); + main.variable(observer("data_frasi")).define("data_frasi", ["getFrasi","listafrasi"], _data_frasi); + main.variable(observer("sentenceTypes")).define("sentenceTypes", ["data_frasi"], _sentenceTypes); + main.variable(observer("sentenceNodeNames")).define("sentenceNodeNames", ["data_frasi"], _sentenceNodeNames); + main.variable(observer("idToNode")).define("idToNode", ["data_frasi"], _idToNode); + main.variable(observer("idToTargetNodes")).define("idToTargetNodes", ["data_frasi"], _idToTargetNodes); + main.variable(observer("syntactic_macrotypes")).define("syntactic_macrotypes", _syntactic_macrotypes); + main.variable(observer("syntactic_types")).define("syntactic_types", _syntactic_types); + main.variable(observer("getTypes")).define("getTypes", ["syntactic_macrotypes","syntactic_types"], _getTypes); + main.variable(observer("clauseFunctions")).define("clauseFunctions", _clauseFunctions); + main.variable(observer()).define(["md"], _22); + main.variable(observer("margin")).define("margin", _margin); + main.variable(observer("height")).define("height", ["margin"], _height); + main.variable(observer("sentenceheight")).define("sentenceheight", ["sentenceNodeNames"], _sentenceheight); + main.variable(observer("width")).define("width", _width); + main.variable(observer()).define(["md"], _27); + main.variable(observer("yScale")).define("yScale", ["d3","sentenceNodeNames","sentenceheight"], _yScale); + main.variable(observer("syntfunction")).define("syntfunction", ["data_frasi"], _syntfunction); + main.variable(observer("sentenceFunctionsColor")).define("sentenceFunctionsColor", ["d3","types"], _sentenceFunctionsColor); + main.variable(observer("sentenceFunctionsColor2")).define("sentenceFunctionsColor2", ["d3","types"], _sentenceFunctionsColor2); + main.variable(observer("synttype")).define("synttype", ["data_frasi"], _synttype); + main.variable(observer("sentenceSynttypeColor")).define("sentenceSynttypeColor", ["d3","synttype"], _sentenceSynttypeColor); + main.variable(observer("colorssp")).define("colorssp", ["d3"], _colorssp); + main.variable(observer("colorssp1")).define("colorssp1", ["d3"], _colorssp1); + main.variable(observer("maptypestopalette")).define("maptypestopalette", _maptypestopalette); + main.variable(observer()).define(["md"], _37); + main.variable(observer("lisid")).define("lisid", _lisid); + const child1 = runtime.module(define1); + main.import("swatches", child1); + main.variable(observer("periodoscritto")).define("periodoscritto", ["html","periodo"], _periodoscritto); + main.variable(observer()).define(["swatches","sentenceFunctionsColor"], _41); + main.variable(observer("periodo")).define("periodo", ["data_frasi"], _periodo); + main.variable(observer("sentenceStructArcs2")).define("sentenceStructArcs2", ["d3","DOM","width","margin","height","data_frasi","yScale","sentenceFunctionsColor","idToNode","sentenceFunctionsColor2","wrap_text_nchar"], _sentenceStructArcs2); + main.variable(observer("sentenceStructArcs")).define("sentenceStructArcs", ["d3","DOM","width","margin","sentenceheight","lisid","data_frasi","yScale","colorssp","maptypestopalette","wrap_text_array","clauseFunctions","getTypes","idToNode","sentenceFunctionsColor2","wrap_text_nchar"], _sentenceStructArcs); + main.variable(observer("sentenceStructArcs_new")).define("sentenceStructArcs_new", ["d3","DOM","width","margin","sentenceheight","lisid","data_frasi","yScale","colorssp","maptypestopalette","wrap_text_array","clauseFunctions","getTypes","idToNode","sentenceFunctionsColor2","darken","wrap_text_nchar"], _sentenceStructArcs_new); + main.variable(observer()).define(["md"], _46); + main.variable(observer("darken")).define("darken", ["d3"], _darken); + main.variable(observer("wrap_text_nchar")).define("wrap_text_nchar", ["wrap_text_array"], _wrap_text_nchar); + main.variable(observer("wrap_text_array")).define("wrap_text_array", _wrap_text_array); + main.variable(observer("wrap_node_text")).define("wrap_node_text", _wrap_node_text); + return main; +} diff --git a/node_modules/commarcdiag/index.html b/node_modules/commarcdiag/index.html new file mode 100644 index 0000000..ffa7419 --- /dev/null +++ b/node_modules/commarcdiag/index.html @@ -0,0 +1,14 @@ + + +Commedia: Arc Diagram per marcatura sintattica + + + diff --git a/node_modules/commarcdiag/index.js b/node_modules/commarcdiag/index.js new file mode 100644 index 0000000..250b505 --- /dev/null +++ b/node_modules/commarcdiag/index.js @@ -0,0 +1 @@ +export {default} from "./d019e1db56ab1d8c@1264.js"; diff --git a/node_modules/commarcdiag/inspector.css b/node_modules/commarcdiag/inspector.css new file mode 100644 index 0000000..278bfae --- /dev/null +++ b/node_modules/commarcdiag/inspector.css @@ -0,0 +1 @@ +:root{--syntax_normal:#1b1e23;--syntax_comment:#a9b0bc;--syntax_number:#20a5ba;--syntax_keyword:#c30771;--syntax_atom:#10a778;--syntax_string:#008ec4;--syntax_error:#ffbedc;--syntax_unknown_variable:#838383;--syntax_known_variable:#005f87;--syntax_matchbracket:#20bbfc;--syntax_key:#6636b4;--mono_fonts:82%/1.5 Menlo,Consolas,monospace}.observablehq--collapsed,.observablehq--expanded,.observablehq--function,.observablehq--gray,.observablehq--import,.observablehq--string:after,.observablehq--string:before{color:var(--syntax_normal)}.observablehq--collapsed,.observablehq--inspect a{cursor:pointer}.observablehq--field{text-indent:-1em;margin-left:1em}.observablehq--empty{color:var(--syntax_comment)}.observablehq--blue,.observablehq--keyword{color:#3182bd}.observablehq--forbidden,.observablehq--pink{color:#e377c2}.observablehq--orange{color:#e6550d}.observablehq--boolean,.observablehq--null,.observablehq--undefined{color:var(--syntax_atom)}.observablehq--bigint,.observablehq--date,.observablehq--green,.observablehq--number,.observablehq--regexp,.observablehq--symbol{color:var(--syntax_number)}.observablehq--index,.observablehq--key{color:var(--syntax_key)}.observablehq--prototype-key{color:#aaa}.observablehq--empty{font-style:oblique}.observablehq--purple,.observablehq--string{color:var(--syntax_string)}.observablehq--error,.observablehq--red{color:#e7040f}.observablehq--inspect{font:var(--mono_fonts);overflow-x:auto;display:block;white-space:pre}.observablehq--error .observablehq--inspect{word-break:break-all;white-space:pre-wrap} \ No newline at end of file diff --git a/node_modules/commarcdiag/package.json b/node_modules/commarcdiag/package.json new file mode 100644 index 0000000..768bc53 --- /dev/null +++ b/node_modules/commarcdiag/package.json @@ -0,0 +1,14 @@ +{ + "name": "@cesare/commarcdiag", + "main": "d019e1db56ab1d8c@1264.js", + "version": "1264.0.0", + "homepage": "https://observablehq.com/@cesare/commarcdiag", + "author": { + "name": "cesare concordia", + "url": "https://observablehq.com/@cesare" + }, + "type": "module", + "peerDependencies": { + "@observablehq/runtime": "4 - 5" + } +} \ No newline at end of file diff --git a/node_modules/commarcdiag/runtime.js b/node_modules/commarcdiag/runtime.js new file mode 100644 index 0000000..49d7def --- /dev/null +++ b/node_modules/commarcdiag/runtime.js @@ -0,0 +1,2 @@ +// @observablehq/runtime v5.4.3 Copyright 2023 Observable, Inc. +function e(e,t,n){n=n||{};var r=e.ownerDocument,a=r.defaultView.CustomEvent;"function"==typeof a?a=new a(t,{detail:n}):((a=r.createEvent("Event")).initEvent(t,!1,!1),a.detail=n),e.dispatchEvent(a)}function t(e){return Array.isArray(e)||e instanceof Int8Array||e instanceof Int16Array||e instanceof Int32Array||e instanceof Uint8Array||e instanceof Uint8ClampedArray||e instanceof Uint16Array||e instanceof Uint32Array||e instanceof Float32Array||e instanceof Float64Array}function n(e){return e===(0|e)+""}function r(e){const t=document.createElement("span");return t.className="observablehq--cellname",t.textContent=`${e} = `,t}const a=Symbol.prototype.toString;function o(e){return a.call(e)}const{getOwnPropertySymbols:i,prototype:{hasOwnProperty:s}}=Object,{toStringTag:c}=Symbol,l={},u=i;function f(e,t){return s.call(e,t)}function d(e){return e[c]||e.constructor&&e.constructor.name||"Object"}function p(e,t){try{const n=e[t];return n&&n.constructor,n}catch(e){return l}}const m=[{symbol:"@@__IMMUTABLE_INDEXED__@@",name:"Indexed",modifier:!0},{symbol:"@@__IMMUTABLE_KEYED__@@",name:"Keyed",modifier:!0},{symbol:"@@__IMMUTABLE_LIST__@@",name:"List",arrayish:!0},{symbol:"@@__IMMUTABLE_MAP__@@",name:"Map"},{symbol:"@@__IMMUTABLE_ORDERED__@@",name:"Ordered",modifier:!0,prefix:!0},{symbol:"@@__IMMUTABLE_RECORD__@@",name:"Record"},{symbol:"@@__IMMUTABLE_SET__@@",name:"Set",arrayish:!0,setish:!0},{symbol:"@@__IMMUTABLE_STACK__@@",name:"Stack",arrayish:!0}];function h(e){try{let t=m.filter((({symbol:t})=>!0===e[t]));if(!t.length)return;const n=t.find((e=>!e.modifier)),r="Map"===n.name&&t.find((e=>e.modifier&&e.prefix)),a=t.some((e=>e.arrayish)),o=t.some((e=>e.setish));return{name:`${r?r.name:""}${n.name}`,symbols:t,arrayish:a&&!o,setish:o}}catch(e){return null}}const{getPrototypeOf:b,getOwnPropertyDescriptors:w}=Object,y=b({});function v(n,a,o,i){let s,c,l,u,f=t(n);n instanceof Map?n instanceof n.constructor?(s=`Map(${n.size})`,c=_):(s="Map()",c=T):n instanceof Set?n instanceof n.constructor?(s=`Set(${n.size})`,c=g):(s="Set()",c=T):f?(s=`${n.constructor.name}(${n.length})`,c=C):(u=h(n))?(s=`Immutable.${u.name}${"Record"===u.name?"":`(${n.size})`}`,f=u.arrayish,c=u.arrayish?N:u.setish?E:A):i?(s=d(n),c=x):(s=d(n),c=T);const p=document.createElement("span");p.className="observablehq--expanded",o&&p.appendChild(r(o));const m=p.appendChild(document.createElement("a"));m.innerHTML="\n \n ",m.appendChild(document.createTextNode(`${s}${f?" [":" {"}`)),m.addEventListener("mouseup",(function(e){e.stopPropagation(),ie(p,L(n,null,o,i))})),c=c(n);for(let e=0;!(l=c.next()).done&&e<20;++e)p.appendChild(l.value);if(!l.done){const t=p.appendChild(document.createElement("a"));t.className="observablehq--field",t.style.display="block",t.appendChild(document.createTextNode(" … more")),t.addEventListener("mouseup",(function(t){t.stopPropagation(),p.insertBefore(l.value,p.lastChild.previousSibling);for(let e=0;!(l=c.next()).done&&e<19;++e)p.insertBefore(l.value,p.lastChild.previousSibling);l.done&&p.removeChild(p.lastChild.previousSibling),e(p,"load")}))}return p.appendChild(document.createTextNode(f?"]":"}")),p}function*_(e){for(const[t,n]of e)yield S(t,n);yield*T(e)}function*g(e){for(const t of e)yield q(t);yield*T(e)}function*E(e){for(const t of e)yield q(t)}function*C(e){for(let t=0,n=e.length;t ")),n.appendChild(oe(t)),n}function q(e){const t=document.createElement("div");return t.className="observablehq--field",t.appendChild(document.createTextNode(" ")),t.appendChild(oe(e)),t}function O(e){const t=window.getSelection();return"Range"===t.type&&(t.containsNode(e,!0)||t.anchorNode.isSelfOrDescendant(e)||t.focusNode.isSelfOrDescendant(e))}function L(e,n,a,o){let i,s,c,l,u=t(e);if(e instanceof Map?e instanceof e.constructor?(i=`Map(${e.size})`,s=k):(i="Map()",s=U):e instanceof Set?e instanceof e.constructor?(i=`Set(${e.size})`,s=M):(i="Set()",s=U):u?(i=`${e.constructor.name}(${e.length})`,s=P):(l=h(e))?(i=`Immutable.${l.name}${"Record"===l.name?"":`(${e.size})`}`,u=l.arrayish,s=l.arrayish?R:l.setish?I:D):(i=d(e),s=U),n){const t=document.createElement("span");return t.className="observablehq--shallow",a&&t.appendChild(r(a)),t.appendChild(document.createTextNode(i)),t.addEventListener("mouseup",(function(n){O(t)||(n.stopPropagation(),ie(t,L(e)))})),t}const f=document.createElement("span");f.className="observablehq--collapsed",a&&f.appendChild(r(a));const p=f.appendChild(document.createElement("a"));p.innerHTML="\n \n ",p.appendChild(document.createTextNode(`${i}${u?" [":" {"}`)),f.addEventListener("mouseup",(function(t){O(f)||(t.stopPropagation(),ie(f,v(e,0,a,o)))}),!0),s=s(e);for(let e=0;!(c=s.next()).done&&e<20;++e)e>0&&f.appendChild(document.createTextNode(", ")),f.appendChild(c.value);return c.done||f.appendChild(document.createTextNode(", …")),f.appendChild(document.createTextNode(u?"]":"}")),f}function*k(e){for(const[t,n]of e)yield z(t,n);yield*U(e)}function*M(e){for(const t of e)yield oe(t,!0);yield*U(e)}function*I(e){for(const t of e)yield oe(t,!0)}function*R(e){let t=-1,n=0;for(const r=e.size;nt+1&&(yield F(n-t-1)),yield oe(e.get(n),!0),t=n;n>t+1&&(yield F(n-t-1))}function*P(e){let t=-1,r=0;for(const n=e.length;rt+1&&(yield F(r-t-1)),yield oe(p(e,r),!0),t=r);r>t+1&&(yield F(r-t-1));for(const t in e)!n(t)&&f(e,t)&&(yield B(t,p(e,t),"observablehq--key"));for(const t of u(e))yield B(o(t),p(e,t),"observablehq--symbol")}function*U(e){for(const t in e)f(e,t)&&(yield B(t,p(e,t),"observablehq--key"));for(const t of u(e))yield B(o(t),p(e,t),"observablehq--symbol")}function*D(e){for(const[t,n]of e)yield B(t,n,"observablehq--key")}function F(e){const t=document.createElement("span");return t.className="observablehq--empty",t.textContent=1===e?"empty":`empty × ${e}`,t}function B(e,t,n){const r=document.createDocumentFragment(),a=r.appendChild(document.createElement("span"));return a.className=n,a.textContent=e,r.appendChild(document.createTextNode(": ")),r.appendChild(oe(t,!0)),r}function z(e,t){const n=document.createDocumentFragment();return n.appendChild(oe(e,!0)),n.appendChild(document.createTextNode(" => ")),n.appendChild(oe(t,!0)),n}function W(e,t){if(e instanceof Date||(e=new Date(+e)),isNaN(e))return"function"==typeof t?t(e):t;const n=e.getUTCHours(),r=e.getUTCMinutes(),a=e.getUTCSeconds(),o=e.getUTCMilliseconds();return`${i=e.getUTCFullYear(),i<0?`-${H(-i,6)}`:i>9999?`+${H(i,6)}`:H(i,4)}-${H(e.getUTCMonth()+1,2)}-${H(e.getUTCDate(),2)}${n||r||a||o?`T${H(n,2)}:${H(r,2)}${a||o?`:${H(a,2)}${o?`.${H(o,3)}`:""}`:""}Z`:""}`;var i}function H(e,t){return`${e}`.padStart(t,"0")}var V=Error.prototype.toString;var G=RegExp.prototype.toString;function Y(e){return e.replace(/[\\`\x00-\x09\x0b-\x19]|\${/g,Z)}function Z(e){var t=e.charCodeAt(0);switch(t){case 8:return"\\b";case 9:return"\\t";case 11:return"\\v";case 12:return"\\f";case 13:return"\\r"}return t<16?"\\x0"+t.toString(16):t<32?"\\x"+t.toString(16):"\\"+e}function J(e,t){for(var n=0;t.exec(e);)++n;return n}var K=Function.prototype.toString,X={prefix:"async ƒ"},Q={prefix:"async ƒ*"},ee={prefix:"class"},te={prefix:"ƒ"},ne={prefix:"ƒ*"};function re(e,t,n){var a=document.createElement("span");a.className="observablehq--function",n&&a.appendChild(r(n));var o=a.appendChild(document.createElement("span"));return o.className="observablehq--keyword",o.textContent=e.prefix,a.appendChild(document.createTextNode(t)),a}const{prototype:{toString:ae}}=Object;function oe(e,t,n,a,i){let s=typeof e;switch(s){case"boolean":case"undefined":e+="";break;case"number":e=0===e&&1/e<0?"-0":e+"";break;case"bigint":e+="n";break;case"symbol":e=o(e);break;case"function":return function(e,t){var n,r,a=K.call(e);switch(e.constructor&&e.constructor.name){case"AsyncFunction":n=X;break;case"AsyncGeneratorFunction":n=Q;break;case"GeneratorFunction":n=ne;break;default:n=/^class\b/.test(a)?ee:te}return n===ee?re(n,"",t):(r=/^(?:async\s*)?(\w+)\s*=>/.exec(a))?re(n,"("+r[1]+")",t):(r=/^(?:async\s*)?\(\s*(\w+(?:\s*,\s*\w+)*)?\s*\)/.exec(a))||(r=/^(?:async\s*)?function(?:\s*\*)?(?:\s*\w+)?\s*\(\s*(\w+(?:\s*,\s*\w+)*)?\s*\)/.exec(a))?re(n,r[1]?"("+r[1].replace(/\s*,\s*/g,", ")+")":"()",t):re(n,"(…)",t)}(e,a);case"string":return function(e,t,n,a){if(!1===t){if(J(e,/["\n]/g)<=J(e,/`|\${/g)){const t=document.createElement("span");a&&t.appendChild(r(a));const n=t.appendChild(document.createElement("span"));return n.className="observablehq--string",n.textContent=JSON.stringify(e),t}const o=e.split("\n");if(o.length>20&&!n){const n=document.createElement("div");a&&n.appendChild(r(a));const i=n.appendChild(document.createElement("span"));i.className="observablehq--string",i.textContent="`"+Y(o.slice(0,20).join("\n"));const s=n.appendChild(document.createElement("span")),c=o.length-20;return s.textContent=`Show ${c} truncated line${c>1?"s":""}`,s.className="observablehq--string-expand",s.addEventListener("mouseup",(function(r){r.stopPropagation(),ie(n,oe(e,t,!0,a))})),n}const i=document.createElement("span");a&&i.appendChild(r(a));const s=i.appendChild(document.createElement("span"));return s.className="observablehq--string"+(n?" observablehq--expanded":""),s.textContent="`"+Y(e)+"`",i}const o=document.createElement("span");a&&o.appendChild(r(a));const i=o.appendChild(document.createElement("span"));return i.className="observablehq--string",i.textContent=JSON.stringify(e.length>100?`${e.slice(0,50)}…${e.slice(-49)}`:e),o}(e,t,n,a);default:if(null===e){s=null,e="null";break}if(e instanceof Date){s="date",e=W(e,"Invalid Date");break}if(e===l){s="forbidden",e="[forbidden]";break}switch(ae.call(e)){case"[object RegExp]":s="regexp",e=function(e){return G.call(e)}(e);break;case"[object Error]":case"[object DOMException]":s="error",e=function(e){return e.stack||V.call(e)}(e);break;default:return(n?v:L)(e,t,a,i)}}const c=document.createElement("span");a&&c.appendChild(r(a));const u=c.appendChild(document.createElement("span"));return u.className=`observablehq--${s}`,u.textContent=e,c}function ie(t,n){t.classList.contains("observablehq--inspect")&&n.classList.add("observablehq--inspect"),t.parentNode.replaceChild(n,t),e(n,"load")}const se=/\s+\(\d+:\d+\)$/m;class Inspector{constructor(e){if(!e)throw new Error("invalid node");this._node=e,e.classList.add("observablehq")}pending(){const{_node:e}=this;e.classList.remove("observablehq--error"),e.classList.add("observablehq--running")}fulfilled(t,n){const{_node:r}=this;if((!function(e){return(e instanceof Element||e instanceof Text)&&e instanceof e.constructor}(t)||t.parentNode&&t.parentNode!==r)&&(t=oe(t,!1,r.firstChild&&r.firstChild.classList&&r.firstChild.classList.contains("observablehq--expanded"),n)).classList.add("observablehq--inspect"),r.classList.remove("observablehq--running","observablehq--error"),r.firstChild!==t)if(r.firstChild){for(;r.lastChild!==r.firstChild;)r.removeChild(r.lastChild);r.replaceChild(t,r.firstChild)}else r.appendChild(t);e(r,"update")}rejected(t,n){const{_node:a}=this;for(a.classList.remove("observablehq--running"),a.classList.add("observablehq--error");a.lastChild;)a.removeChild(a.lastChild);var o=document.createElement("div");o.className="observablehq--inspect",n&&o.appendChild(r(n)),o.appendChild(document.createTextNode((t+"").replace(se,""))),a.appendChild(o),e(a,"error",{error:t})}}Inspector.into=function(e){if("string"==typeof e&&null==(e=document.querySelector(e)))throw new Error("container not found");return function(){return new Inspector(e.appendChild(document.createElement("div")))}};var ce={},le={};function ue(e){return new Function("d","return {"+e.map((function(e,t){return JSON.stringify(e)+": d["+t+'] || ""'})).join(",")+"}")}function fe(e){var t=Object.create(null),n=[];return e.forEach((function(e){for(var r in e)r in t||n.push(t[r]=r)})),n}function de(e,t){var n=e+"",r=n.length;return r9999?"+"+de(t,6):de(t,4))+"-"+de(e.getUTCMonth()+1,2)+"-"+de(e.getUTCDate(),2)+(o?"T"+de(n,2)+":"+de(r,2)+":"+de(a,2)+"."+de(o,3)+"Z":a?"T"+de(n,2)+":"+de(r,2)+":"+de(a,2)+"Z":r||n?"T"+de(n,2)+":"+de(r,2)+"Z":"")}function me(e){var t=new RegExp('["'+e+"\n\r]"),n=e.charCodeAt(0);function r(e,t){var r,a=[],o=e.length,i=0,s=0,c=o<=0,l=!1;function u(){if(c)return le;if(l)return l=!1,ce;var t,r,a=i;if(34===e.charCodeAt(a)){for(;i++=o?c=!0:10===(r=e.charCodeAt(i++))?l=!0:13===r&&(l=!0,10===e.charCodeAt(i)&&++i),e.slice(a+1,t-1).replace(/""/g,'"')}for(;i`${e}@${t}/${r}`}}const Ne=Ce("d3","7.8.2","dist/d3.min.js"),xe=Ce("@observablehq/inputs","0.10.4","dist/inputs.min.js"),Te=Ce("@observablehq/plot","0.6.3","dist/plot.umd.min.js"),Ae=Ce("@observablehq/graphviz","0.2.1","dist/graphviz.min.js"),je=Ce("@observablehq/highlight.js","2.0.0","highlight.min.js"),$e=Ce("@observablehq/katex","0.11.1","dist/katex.min.js"),Se=Ce("lodash","4.17.21","lodash.min.js"),qe=Ce("htl","0.3.1","dist/htl.min.js"),Oe=Ce("jszip","3.10.1","dist/jszip.min.js"),Le=Ce("marked","0.3.12","marked.min.js"),ke=Ce("sql.js","1.8.0","dist/sql-wasm.js"),Me=Ce("vega","5.22.1","build/vega.min.js"),Ie=Ce("vega-lite","5.6.0","build/vega-lite.min.js"),Re=Ce("vega-lite-api","5.0.0","build/vega-lite-api.min.js"),Pe=Ce("apache-arrow","4.0.1","Arrow.es2015.min.js"),Ue=Ce("apache-arrow","9.0.0","+esm"),De=Ce("arquero","4.8.8","dist/arquero.min.js"),Fe=Ce("topojson-client","3.1.0","dist/topojson-client.min.js"),Be=Ce("exceljs","4.3.0","dist/exceljs.min.js"),ze=Ce("mermaid","9.2.2","dist/mermaid.min.js"),We=Ce("leaflet","1.9.3","dist/leaflet.js"),He=Ce("@duckdb/duckdb-wasm","1.17.0","+esm"),Ve=new Map,Ge=[],Ye=Ge.map,Ze=Ge.some,Je=Ge.hasOwnProperty,Ke=/^((?:@[^/@]+\/)?[^/@]+)(?:@([^/]+))?(?:\/(.*))?$/,Xe=/^\d+\.\d+\.\d+(-[\w-.+]+)?$/,Qe=/(?:\.[^/]*|\/)$/;class RequireError extends Error{constructor(e){super(e)}}function et(e){const t=Ke.exec(e);return t&&{name:t[1],version:t[2],path:t[3]}}function tt(e="https://cdn.jsdelivr.net/npm/",t=["unpkg","jsdelivr","browser","main"]){if(!/\/$/.test(e))throw new Error("origin lacks trailing slash");function n(t){const n=`${e}${t.name}${t.version?`@${t.version}`:""}/package.json`;let r=Ve.get(n);return r||Ve.set(n,r=fetch(n).then((e=>{if(!e.ok)throw new RequireError("unable to load package.json");return e.redirected&&!Ve.has(e.url)&&Ve.set(e.url,r),e.json()}))),r}return async function(r,a){if(r.startsWith(e)&&(r=r.substring(e.length)),/^(\w+:)|\/\//i.test(r))return r;if(/^[.]{0,2}\//i.test(r))return new URL(r,null==a?location:a).href;if(!r.length||/^[\s._]/.test(r)||/\s$/.test(r))throw new RequireError("illegal name");const o=et(r);if(!o)return`${e}${r}`;if(!o.version&&null!=a&&a.startsWith(e)){const t=await n(et(a.substring(e.length)));o.version=t.dependencies&&t.dependencies[o.name]||t.peerDependencies&&t.peerDependencies[o.name]}if(o.path&&!Qe.test(o.path)&&(o.path+=".js"),o.path&&o.version&&Xe.test(o.version))return`${e}${o.name}@${o.version}/${o.path}`;const i=await n(o);return`${e}${i.name}@${i.version}/${o.path||function(e){for(const n of t){let t=e[n];if("string"==typeof t)return t.startsWith("./")&&(t=t.slice(2)),Qe.test(t)?t:`${t}.js`}}(i)||"index.js"}`}}RequireError.prototype.name=RequireError.name;var nt=rt(tt());function rt(e){const t=new Map,n=a(null);function r(e){if("string"!=typeof e)return e;let n=t.get(e);return n||t.set(e,n=new Promise(((t,n)=>{const r=document.createElement("script");r.onload=()=>{try{t(Ge.pop()(a(e)))}catch(e){n(new RequireError("invalid module"))}r.remove()},r.onerror=()=>{n(new RequireError("unable to load module")),r.remove()},r.async=!0,r.src=e,window.define=st,document.head.appendChild(r)}))),n}function a(t){return n=>Promise.resolve(e(n,t)).then(r)}function o(e){return arguments.length>1?Promise.all(Ye.call(arguments,n)).then(at):n(e)}return o.alias=function(t){return rt(((n,r)=>n in t&&(r=null,"string"!=typeof(n=t[n]))?n:e(n,r)))},o.resolve=e,o}function at(e){const t={};for(const n of e)for(const e in n)Je.call(n,e)&&(null==n[e]?Object.defineProperty(t,e,{get:ot(n,e)}):t[e]=n[e]);return t}function ot(e,t){return()=>e[t]}function it(e){return"exports"===(e+="")||"module"===e}function st(e,t,n){const r=arguments.length;r<2?(n=e,t=[]):r<3&&(n=t,t="string"==typeof e?[]:e),Ge.push(Ze.call(t,it)?e=>{const r={},a={exports:r};return Promise.all(Ye.call(t,(t=>"exports"===(t+="")?r:"module"===t?a:e(t)))).then((e=>(n.apply(null,e),a.exports)))}:e=>Promise.all(Ye.call(t,e)).then((e=>"function"==typeof n?n.apply(null,e):n)))}st.amd={};const ct="https://cdn.observableusercontent.com/npm/";let lt=nt;async function ut(e){const[t,n]=await Promise.all([e(ke.resolve()),e.resolve(ke.resolve("dist/"))]);return t({locateFile:e=>`${n}${e}`})}class SQLiteDatabaseClient{constructor(e){Object.defineProperties(this,{_db:{value:e}})}static async open(e){const[t,n]=await Promise.all([ut(lt),Promise.resolve(e).then(dt)]);return new SQLiteDatabaseClient(new t.Database(n))}async query(e,t){return await async function(e,t,n){const[r]=await e.exec(t,n);if(!r)return[];const{columns:a,values:o}=r,i=o.map((e=>Object.fromEntries(e.map(((e,t)=>[a[t],e])))));return i.columns=a,i}(this._db,e,t)}async queryRow(e,t){return(await this.query(e,t))[0]||null}async explain(e,t){return pt("pre",{className:"observablehq--inspect"},[mt((await this.query(`EXPLAIN QUERY PLAN ${e}`,t)).map((e=>e.detail)).join("\n"))])}async describeTables({schema:e}={}){return this.query(`SELECT NULLIF(schema, 'main') AS schema, name FROM pragma_table_list() WHERE type = 'table'${null==e?"":" AND schema = ?"} AND name NOT LIKE 'sqlite_%' ORDER BY schema, name`,null==e?[]:[e])}async describeColumns({schema:e,table:t}={}){if(null==t)throw new Error("missing table");const n=await this.query(`SELECT name, type, "notnull" FROM pragma_table_info(?${null==e?"":", ?"}) ORDER BY cid`,null==e?[t]:[t,e]);if(!n.length)throw new Error(`table not found: ${t}`);return n.map((({name:e,type:t,notnull:n})=>({name:e,type:ft(t),databaseType:t,nullable:!n})))}async describe(e){const t=await(void 0===e?this.query("SELECT name FROM sqlite_master WHERE type = 'table'"):this.query("SELECT * FROM pragma_table_info(?)",[e]));if(!t.length)throw new Error("Not found");const{columns:n}=t;return pt("table",{value:t},[pt("thead",[pt("tr",n.map((e=>pt("th",[mt(e)]))))]),pt("tbody",t.map((e=>pt("tr",n.map((t=>pt("td",[mt(e[t])])))))))])}async sql(){return this.query(...this.queryTag.apply(this,arguments))}queryTag(e,...t){return[e.join("?"),t]}}function ft(e){switch(e){case"NULL":return"null";case"INT":case"INTEGER":case"TINYINT":case"SMALLINT":case"MEDIUMINT":case"BIGINT":case"UNSIGNED BIG INT":case"INT2":case"INT8":return"integer";case"TEXT":case"CLOB":case"DATE":case"DATETIME":return"string";case"REAL":case"DOUBLE":case"DOUBLE PRECISION":case"FLOAT":case"NUMERIC":return"number";case"BLOB":return"buffer";default:return/^(?:(?:(?:VARYING|NATIVE) )?CHARACTER|(?:N|VAR|NVAR)CHAR)\(/.test(e)?"string":/^(?:DECIMAL|NUMERIC)\(/.test(e)?"number":"other"}}function dt(e){return"string"==typeof e?fetch(e).then(dt):e instanceof Response||e instanceof Blob?e.arrayBuffer().then(dt):e instanceof ArrayBuffer?new Uint8Array(e):e}function pt(e,t,n){2===arguments.length&&(n=t,t=void 0);const r=document.createElement(e);if(void 0!==t)for(const e in t)r[e]=t[e];if(void 0!==n)for(const e of n)r.appendChild(e);return r}function mt(e){return document.createTextNode(e)}Object.defineProperty(SQLiteDatabaseClient.prototype,"dialect",{value:"sqlite"});class Workbook{constructor(e){Object.defineProperties(this,{_:{value:e},sheetNames:{value:e.worksheets.map((e=>e.name)),enumerable:!0}})}sheet(e,t){const n="number"==typeof e?this.sheetNames[e]:this.sheetNames.includes(e+="")?e:null;if(null==n)throw new Error(`Sheet not found: ${e}`);return function(e,{range:t,headers:n}={}){let[[r,a],[o,i]]=function(e=":",{columnCount:t,rowCount:n}){if(!(e+="").match(/^[A-Z]*\d*:[A-Z]*\d*$/))throw new Error("Malformed range specifier");const[[r=0,a=0],[o=t-1,i=n-1]]=e.split(":").map(yt);return[[r,a],[o,i]]}(t,e);const s=n?e._rows[a++]:null;let c=new Set(["#"]);for(let e=r;e<=o;e++){const t=s?ht(s.findCell(e+1)):null;let n=t&&t+""||wt(e);for(;c.has(n);)n+="_";c.add(n)}c=new Array(r).concat(Array.from(c));const l=new Array(i-a+1);for(let t=a;t<=i;t++){const n=l[t-a]=Object.create(null,{"#":{value:t+1}}),i=e.getRow(t+1);if(i.hasValues)for(let e=r;e<=o;e++){const t=ht(i.findCell(e+1));null!=t&&(n[c[e+1]]=t)}}return l.columns=c.filter((()=>!0)),l}(this._.getWorksheet(n),t)}}function ht(e){if(!e)return;const{value:t}=e;if(t&&"object"==typeof t&&!(t instanceof Date)){if(t.formula||t.sharedFormula)return t.result&&t.result.error?NaN:t.result;if(t.richText)return bt(t);if(t.text){let{text:e}=t;return e.richText&&(e=bt(e)),t.hyperlink&&t.hyperlink!==e?`${t.hyperlink} ${e}`:e}return t}return t}function bt(e){return e.richText.map((e=>e.text)).join("")}function wt(e){let t="";e++;do{t=String.fromCharCode(64+(e%26||26))+t}while(e=Math.floor((e-1)/26));return t}function yt(e){const[,t,n]=e.match(/^([A-Z]*)(\d*)$/);let r=0;if(t)for(let e=0;e{const a=new Image;new URL(t,document.baseURI).origin!==new URL(location).origin&&(a.crossOrigin="anonymous"),Object.assign(a,e),a.onload=()=>n(a),a.onerror=()=>r(new Error(`Unable to load file: ${this.name}`)),a.src=t}))}async arrow({version:e=4}={}){switch(e){case 4:{const[e,t]=await Promise.all([lt(Pe.resolve()),vt(this)]);return e.Table.from(t)}case 9:{const[e,t]=await Promise.all([import(`${ct}${Ue.resolve()}`),vt(this)]);return e.tableFromIPC(t)}default:throw new Error(`unsupported arrow version: ${e}`)}}async sqlite(){return SQLiteDatabaseClient.open(vt(this))}async zip(){const[e,t]=await Promise.all([lt(Oe.resolve()),this.arrayBuffer()]);return new ZipArchive(await e.loadAsync(t))}async xml(e="application/xml"){return(new DOMParser).parseFromString(await this.text(),e)}async html(){return this.xml("text/html")}async xlsx(){const[e,t]=await Promise.all([lt(Be.resolve()),this.arrayBuffer()]);return new Workbook(await(new e.Workbook).xlsx.load(t))}}class FileAttachment extends gt{constructor(e,t,n){super(t,n),Object.defineProperty(this,"_url",{value:e})}async url(){return await this._url+""}}function Et(e){throw new Error(`File not found: ${e}`)}class ZipArchive{constructor(e){Object.defineProperty(this,"_",{value:e}),this.filenames=Object.keys(e.files).filter((t=>!e.files[t].dir))}file(e){const t=this._.file(e+="");if(!t||t.dir)throw new Error(`file not found: ${e}`);return new ZipArchiveEntry(t)}}class ZipArchiveEntry extends gt{constructor(e){super(e.name),Object.defineProperty(this,"_",{value:e}),Object.defineProperty(this,"_url",{writable:!0})}async url(){return this._url||(this._url=this.blob().then(URL.createObjectURL))}async blob(){return this._.async("blob")}async arrayBuffer(){return this._.async("arraybuffer")}async text(){return this._.async("text")}async json(){return JSON.parse(await this.text())}}var Ct={math:"http://www.w3.org/1998/Math/MathML",svg:"http://www.w3.org/2000/svg",xhtml:"http://www.w3.org/1999/xhtml",xlink:"http://www.w3.org/1999/xlink",xml:"http://www.w3.org/XML/1998/namespace",xmlns:"http://www.w3.org/2000/xmlns/"};var Nt=0;function xt(e){return new Tt("O-"+(null==e?"":e+"-")+ ++Nt)}function Tt(e){this.id=e,this.href=new URL(`#${e}`,location)+""}Tt.prototype.toString=function(){return"url("+this.href+")"};var At=Object.freeze({__proto__:null,canvas:function(e,t){var n=document.createElement("canvas");return n.width=e,n.height=t,n},context2d:function(e,t,n){null==n&&(n=devicePixelRatio);var r=document.createElement("canvas");r.width=e*n,r.height=t*n,r.style.width=e+"px";var a=r.getContext("2d");return a.scale(n,n),a},download:function(e,t="untitled",n="Save"){const r=document.createElement("a"),a=r.appendChild(document.createElement("button"));async function o(){await new Promise(requestAnimationFrame),URL.revokeObjectURL(r.href),r.removeAttribute("href"),a.textContent=n,a.disabled=!1}return a.textContent=n,r.download=t,r.onclick=async t=>{if(a.disabled=!0,r.href)return o();a.textContent="Saving…";try{const t=await("function"==typeof e?e():e);a.textContent="Download",r.href=URL.createObjectURL(t)}catch(e){a.textContent=n}if(t.eventPhase)return o();a.disabled=!1},r},element:function(e,t){var n,r=e+="",a=r.indexOf(":");a>=0&&"xmlns"!==(r=e.slice(0,a))&&(e=e.slice(a+1));var o=Ct.hasOwnProperty(r)?document.createElementNS(Ct[r],e):document.createElement(e);if(t)for(var i in t)a=(r=i).indexOf(":"),n=t[i],a>=0&&"xmlns"!==(r=i.slice(0,a))&&(i=i.slice(a+1)),Ct.hasOwnProperty(r)?o.setAttributeNS(Ct[r],i,n):o.setAttribute(i,n);return o},input:function(e){var t=document.createElement("input");return null!=e&&(t.type=e),t},range:function(e,t,n){1===arguments.length&&(t=e,e=null);var r=document.createElement("input");return r.min=e=null==e?0:+e,r.max=t=null==t?1:+t,r.step=null==n?"any":n=+n,r.type="range",r},select:function(e){var t=document.createElement("select");return Array.prototype.forEach.call(e,(function(e){var n=document.createElement("option");n.value=n.textContent=e,t.appendChild(n)})),t},svg:function(e,t){var n=document.createElementNS("http://www.w3.org/2000/svg","svg");return n.setAttribute("viewBox",[0,0,e,t]),n.setAttribute("width",e),n.setAttribute("height",t),n},text:function(e){return document.createTextNode(e)},uid:xt});var jt=Object.freeze({__proto__:null,buffer:function(e){return new Promise((function(t,n){var r=new FileReader;r.onload=function(){t(r.result)},r.onerror=n,r.readAsArrayBuffer(e)}))},text:function(e){return new Promise((function(t,n){var r=new FileReader;r.onload=function(){t(r.result)},r.onerror=n,r.readAsText(e)}))},url:function(e){return new Promise((function(t,n){var r=new FileReader;r.onload=function(){t(r.result)},r.onerror=n,r.readAsDataURL(e)}))}});function $t(){return this}function St(e,t){let n=!1;if("function"!=typeof t)throw new Error("dispose is not a function");return{[Symbol.iterator]:$t,next:()=>n?{done:!0}:(n=!0,{done:!1,value:e}),return:()=>(n=!0,t(e),{done:!0}),throw:()=>({done:n=!0})}}function qt(e){let t,n,r=!1;const a=e((function(e){n?(n(e),n=null):r=!0;return t=e}));if(null!=a&&"function"!=typeof a)throw new Error("function"==typeof a.then?"async initializers are not supported":"initializer returned something, but not a dispose function");return{[Symbol.iterator]:$t,throw:()=>({done:!0}),return:()=>(null!=a&&a(),{done:!0}),next:function(){return{done:!1,value:r?(r=!1,Promise.resolve(t)):new Promise((e=>n=e))}}}}function Ot(e){switch(e.type){case"range":case"number":return e.valueAsNumber;case"date":return e.valueAsDate;case"checkbox":return e.checked;case"file":return e.multiple?e.files:e.files[0];case"select-multiple":return Array.from(e.selectedOptions,(e=>e.value));default:return e.value}}var Lt=Object.freeze({__proto__:null,disposable:St,filter:function*(e,t){for(var n,r=-1;!(n=e.next()).done;)t(n.value,++r)&&(yield n.value)},input:function(e){return qt((function(t){var n=function(e){switch(e.type){case"button":case"submit":case"checkbox":return"click";case"file":return"change";default:return"input"}}(e),r=Ot(e);function a(){t(Ot(e))}return e.addEventListener(n,a),void 0!==r&&t(r),function(){e.removeEventListener(n,a)}}))},map:function*(e,t){for(var n,r=-1;!(n=e.next()).done;)yield t(n.value,++r)},observe:qt,queue:function(e){let t;const n=[],r=e((function(e){n.push(e),t&&(t(n.shift()),t=null);return e}));if(null!=r&&"function"!=typeof r)throw new Error("function"==typeof r.then?"async initializers are not supported":"initializer returned something, but not a dispose function");return{[Symbol.iterator]:$t,throw:()=>({done:!0}),return:()=>(null!=r&&r(),{done:!0}),next:function(){return{done:!1,value:n.length?Promise.resolve(n.shift()):new Promise((e=>t=e))}}}},range:function*(e,t,n){e=+e,t=+t,n=(a=arguments.length)<2?(t=e,e=0,1):a<3?1:+n;for(var r=-1,a=0|Math.max(0,Math.ceil((t-e)/n));++r{n.terminate(),URL.revokeObjectURL(t)}))}});function kt(e){return e&&"function"==typeof e.toArrowBuffer}function Mt(e){return e&&"function"==typeof e.getChild&&"function"==typeof e.toArray&&e.schema&&Array.isArray(e.schema.fields)}function It(e){return{name:e.name,type:Rt(e.type),nullable:e.nullable,databaseType:String(e.type)}}function Rt(e){switch(e.typeId){case 2:return"integer";case 3:case 7:return"number";case 4:case 15:return"buffer";case 5:return"string";case 6:return"boolean";case 8:case 9:case 10:return"date";case 12:case 16:return"array";case 13:case 14:return"object";default:return"other"}}async function Pt(){return await import(`${ct}${Ue.resolve()}`)}class DuckDBClient{constructor(e){Object.defineProperties(this,{_db:{value:e}})}async queryStream(e,t){const n=await this._db.connect();let r,a;try{if(t?.length>0){const a=await n.prepare(e);r=await a.send(...t)}else r=await n.send(e);if(a=await r.next(),a.done)throw new Error("missing first batch")}catch(e){throw await n.close(),e}return{schema:(o=a.value,o.schema.fields.map(It)),async*readRows(){try{for(;!a.done;)yield a.value.toArray(),a=await r.next()}finally{await n.close()}}};var o}async query(e,t){const n=await this.queryStream(e,t),r=[];for await(const e of n.readRows())for(const t of e)r.push(t);return r.schema=n.schema,r}async queryRow(e,t){const n=(await this.queryStream(e,t)).readRows();try{const{done:e,value:t}=await n.next();return e||!t.length?null:t[0]}finally{await n.return()}}async sql(e,...t){return await this.query(e.join("?"),t)}queryTag(e,...t){return[e.join("?"),t]}escape(e){return`"${e}"`}async describeTables(){return(await this.query("SHOW TABLES")).map((({name:e})=>({name:e})))}async describeColumns({table:e}={}){return(await this.query(`DESCRIBE ${this.escape(e)}`)).map((({column_name:e,column_type:t,null:n})=>({name:e,type:Bt(t),nullable:"NO"!==n,databaseType:t})))}static async of(e={},t={}){const n=await async function(){const e=await import(`${ct}${He.resolve()}`),t=await e.selectBundle({mvp:{mainModule:`${ct}${He.resolve("dist/duckdb-mvp.wasm")}`,mainWorker:`${ct}${He.resolve("dist/duckdb-browser-mvp.worker.js")}`},eh:{mainModule:`${ct}${He.resolve("dist/duckdb-eh.wasm")}`,mainWorker:`${ct}${He.resolve("dist/duckdb-browser-eh.worker.js")}`}}),n=new e.ConsoleLogger,r=await e.createWorker(t.mainWorker),a=new e.AsyncDuckDB(n,r);return await a.instantiate(t.mainModule),a}();return void 0===t.query?.castTimestampToDate&&(t={...t,query:{...t.query,castTimestampToDate:!0}}),await n.open(t),await Promise.all(Object.entries(e).map((async([e,t])=>{if(t instanceof FileAttachment)await Ut(n,e,t);else if(Mt(t))await Dt(n,e,t);else if(Array.isArray(t))await Ft(n,e,t);else if(kt(t))await async function(e,t,n){const r=(await Pt()).tableFromIPC(n.toArrowBuffer());return await Dt(e,t,r)}(n,e,t);else if("data"in t){const{data:r,...a}=t;Mt(r)?await Dt(n,e,r,a):await Ft(n,e,r,a)}else{if(!("file"in t))throw new Error(`invalid source: ${t}`);{const{file:r,...a}=t;await Ut(n,e,r,a)}}}))),new DuckDBClient(n)}}async function Ut(e,t,n,r){const a=await n.url();if(a.startsWith("blob:")){const t=await n.arrayBuffer();await e.registerFileBuffer(n.name,new Uint8Array(t))}else await e.registerFileURL(n.name,a);const o=await e.connect();try{switch(n.mimeType){case"text/csv":case"text/tab-separated-values":return await o.insertCSVFromPath(n.name,{name:t,schema:"main",...r}).catch((async e=>{if(e.toString().includes("Could not convert"))return await async function(e,t,n){const r=await e.prepare(`CREATE TABLE '${n}' AS SELECT * FROM read_csv_auto(?, ALL_VARCHAR=TRUE)`);return await r.send(t.name)}(o,n,t)}));case"application/json":return await o.insertJSONFromPath(n.name,{name:t,schema:"main",...r});default:if(/\.arrow$/i.test(n.name)){const e=new Uint8Array(await n.arrayBuffer());return await o.insertArrowFromIPCStream(e,{name:t,schema:"main",...r})}if(/\.parquet$/i.test(n.name))return await o.query(`CREATE VIEW '${t}' AS SELECT * FROM parquet_scan('${n.name}')`);throw new Error(`unknown file type: ${n.mimeType}`)}}finally{await o.close()}}async function Dt(e,t,n,r){const a=await e.connect();try{await a.insertArrowTable(n,{name:t,schema:"main",...r})}finally{await a.close()}}async function Ft(e,t,n,r){const a=(await Pt()).tableFromJSON(n);return await Dt(e,t,a,r)}function Bt(e){switch(e){case"BIGINT":case"HUGEINT":case"UBIGINT":return"bigint";case"DOUBLE":case"REAL":case"FLOAT":return"number";case"INTEGER":case"SMALLINT":case"TINYINT":case"USMALLINT":case"UINTEGER":case"UTINYINT":return"integer";case"BOOLEAN":return"boolean";case"DATE":case"TIMESTAMP":case"TIMESTAMP WITH TIME ZONE":return"date";case"VARCHAR":case"UUID":return"string";default:return/^DECIMAL\(/.test(e)?"integer":"other"}}function zt(e,t){return function(n){var r,a,o,i,s,c,l,u,f=n[0],d=[],p=null,m=-1;for(s=1,c=arguments.length;s0){for(o=new Array(m),i=document.createTreeWalker(p,NodeFilter.SHOW_COMMENT,null,!1);i.nextNode();)a=i.currentNode,/^o:/.test(a.nodeValue)&&(o[+a.nodeValue.slice(2)]=a);for(s=0;s{t=e}))},value:{get:()=>e,set:n=>t(e=n)}}),void 0!==e&&t(e)}function*Vt(){for(;;)yield Date.now()}var Gt=new Map;function Yt(e,t){var n;return(n=Gt.get(e=+e))?n.then((()=>t)):(n=Date.now())>=e?Promise.resolve(t):function(e,t){var n=new Promise((function(n){Gt.delete(t);var r=t-e;if(!(r>0))throw new Error("invalid time");if(r>2147483647)throw new Error("too long to wait");setTimeout(n,r)}));return Gt.set(t,n),n}(n,e).then((()=>t))}var Zt=Object.freeze({__proto__:null,delay:function(e,t){return new Promise((function(n){setTimeout((function(){n(t)}),e)}))},tick:function(e,t){return Yt(Math.ceil((Date.now()+1)/e)*e,t)},when:Yt});function Jt(e,t){if(/^(\w+:)|\/\//i.test(e))return e;if(/^[.]{0,2}\//i.test(e))return new URL(e,null==t?location:t).href;if(!e.length||/^[\s._]/.test(e)||/\s$/.test(e))throw new Error("illegal name");return"https://unpkg.com/"+e}const Kt=zt((function(e){var t=document.createElementNS("http://www.w3.org/2000/svg","g");return t.innerHTML=e.trim(),t}),(function(){return document.createElementNS("http://www.w3.org/2000/svg","g")}));var Xt=String.raw;function Qt(e){return new Promise((function(t,n){var r=document.createElement("link");r.rel="stylesheet",r.href=e,r.onerror=n,r.onload=t,document.head.appendChild(r)}))}function en(){return qt((function(e){var t=e(document.body.clientWidth);function n(){var n=document.body.clientWidth;n!==t&&e(t=n)}return window.addEventListener("resize",n),function(){window.removeEventListener("resize",n)}}))}function tn(e,t){return null==e||null==t?NaN:et?1:e>=t?0:NaN}function nn(e,t=tn){let n,r=!1;if(1===t.length){let a;for(const o of e){const e=t(o);(r?tn(e,a)>0:0===tn(e,e))&&(n=o,a=e,r=!0)}}else for(const a of e)(r?t(a,n)>0:0===t(a,a))&&(n=a,r=!0);return n}function rn(e){return Array.isArray(e)&&(an(e.schema)||(t=e.columns,Array.isArray(t)&&t.every((e=>"string"==typeof e)))||function(e){const t=Math.min(20,e.length);for(let n=0;n0&&function(e){for(const t in e)return!0;return!1}(e[0])}(e)||cn(e)||ln(e))||un(e);var t}function an(e){return Array.isArray(e)&&e.every(on)}function on(e){return e&&"string"==typeof e.name&&"string"==typeof e.type}function sn(e){return un(e)||cn(e)||ln(e)}function cn(e){const t=Math.min(20,e.length);if(!(t>0))return!1;let n,r=!1;for(let a=0;a0))return!1;let n=!1;for(let r=0;r{if(e=await pn(await e,r),(a=e)&&("function"==typeof a.sql||"function"==typeof a.queryTag&&("function"==typeof a.query||"function"==typeof a.queryStream))&&("table"!==o||"function"==typeof a.describeColumns)&&a!==fn)return bn(e,function(e,t){const n="function"==typeof t.escape?t.escape:e=>e,{select:r,from:a,filter:o,sort:i,slice:s}=e;if(!a.table)throw new Error("missing from table");if(r.columns&&0===r.columns.length)throw new Error("at least one column must be selected");const c=new Map(e.names?.map((({column:e,name:t})=>[e,t]))),l=[[`SELECT ${r.columns?r.columns.map((e=>{const t=c.get(e);return t?`${n(e)} AS ${n(t)}`:n(e)})).join(", "):"*"} FROM ${wn(a.table,n)}`]];for(let e=0;e[e,t])));if(t.types){for(const{name:e,type:a}of t.types){i.set(e,a),r===n.schema&&(r=r.slice());const t=r.findIndex((t=>t.name===e));t>-1&&(r[t]={...r[t],type:a})}e=e.map((e=>Pn(e,i,r)))}else o&&(e=e.map((e=>Pn(e,i,r))));for(const{type:n,operands:r}of t.filter){const[{value:t}]=r,a=r.slice(1).map((({value:e})=>e));switch(n){case"v":{const[n]=a,r=Mn(n);e=e.filter((e=>r(e[t])));break}case"nv":{const[n]=a,r=Mn(n);e=e.filter((e=>!r(e[t])));break}case"eq":{const[n]=a;if(n instanceof Date){const r=+n;e=e.filter((e=>+e[t]===r))}else e=e.filter((e=>e[t]===n));break}case"ne":{const[n]=a;e=e.filter((e=>e[t]!==n));break}case"c":{const[n]=a;e=e.filter((e=>"string"==typeof e[t]&&e[t].includes(n)));break}case"nc":{const[n]=a;e=e.filter((e=>"string"==typeof e[t]&&!e[t].includes(n)));break}case"in":{const n=new Set(a);e=e.filter((e=>n.has(e[t])));break}case"nin":{const n=new Set(a);e=e.filter((e=>!n.has(e[t])));break}case"n":e=e.filter((e=>null==e[t]));break;case"nn":e=e.filter((e=>null!=e[t]));break;case"lt":{const[n]=a;e=e.filter((e=>e[t]e[t]<=n));break}case"gt":{const[n]=a;e=e.filter((e=>e[t]>n));break}case"gte":{const[n]=a;e=e.filter((e=>e[t]>=n));break}default:throw new Error(`unknown filter type: ${n}`)}}for(const{column:r,direction:a}of function(e){if("function"!=typeof e[Symbol.iterator])throw new TypeError("values is not iterable");return Array.from(e).reverse()}(t.sort)){const t="desc"===a?Nn:Cn;e===n&&(e=e.slice()),e.sort(((e,n)=>t(e[r],n[r])))}let{from:s,to:c}=t.slice;s=null==s?0:Math.max(0,s),c=null==c?1/0:Math.max(0,c),(s>0||c<1/0)&&(e=e.slice(Math.max(0,s),Math.max(0,c)));if(t.select.columns){if(r){const e=new Map(r.map((e=>[e.name,e])));r=t.select.columns.map((t=>e.get(t)))}a&&(a=t.select.columns),e=e.map((e=>Object.fromEntries(t.select.columns.map((t=>[t,e[t]])))))}if(t.names){const n=new Map(t.names.map((e=>[e.column,e])));r&&(r=r.map((e=>{const t=n.get(e.name);return{...e,...t?{name:t.name}:null}}))),a&&(a=a.map((e=>n.get(e)?.name??e))),e=e.map((e=>Object.fromEntries(Object.keys(e).map((t=>[n.get(t)?.name??t,e[t]])))))}e!==n&&(r&&(e.schema=r),a&&(e.columns=a));return e}(e,t);if(!e)throw new Error("missing data source");throw new Error("invalid data source")}),{sql:(e,t,n)=>async function(){return bn(await mn(await e,n),arguments,t)}});function dn(e){const t=new WeakMap;return(n,r)=>{if(!n)throw new Error("data source not found");let a=t.get(n);return(!a||rn(n)&&n.length!==a._numRows)&&(a=e(n,r),a._numRows=n.length,t.set(n,a)),a}}const pn=dn((async(e,t)=>{if(e instanceof FileAttachment){switch(e.mimeType){case"text/csv":return e.csv();case"text/tab-separated-values":return e.tsv();case"application/json":return e.json();case"application/x-sqlite3":return e.sqlite()}if(/\.(arrow|parquet)$/i.test(e.name))return hn(e,t);throw new Error(`unsupported file type: ${e.mimeType}`)}return Mt(e)||kt(e)?hn(e,t):rn(e)&&sn(e)?Array.from(e,(e=>({value:e}))):e})),mn=dn((async(e,t)=>{if(e instanceof FileAttachment){switch(e.mimeType){case"text/csv":case"text/tab-separated-values":case"application/json":return hn(e,t);case"application/x-sqlite3":return e.sqlite()}if(/\.(arrow|parquet)$/i.test(e.name))return hn(e,t);throw new Error(`unsupported file type: ${e.mimeType}`)}return rn(e)?hn(await async function(e,t){const n=await Pt();return sn(e)?n.tableFromArrays({[t]:e}):n.tableFromJSON(e)}(e,t),t):Mt(e)||kt(e)?hn(e,t):e}));function hn(e,t=(e instanceof FileAttachment?function(e){return e.name.replace(/@\d+(?=\.|$)/,"").replace(/\.\w+$/,"")}(e):"__table")){return DuckDBClient.of({[t]:e})}async function bn(e,t,n){if(!e)throw new Error("missing data source");if("function"==typeof e.queryTag){const r=new AbortController,a={signal:r.signal};if(n.then((()=>r.abort("invalidated"))),"function"==typeof e.queryStream)return async function*(e){let t=performance.now();const n=await e,r=[];r.done=!1,r.error=null,r.schema=n.schema;try{for await(const e of n.readRows()){performance.now()-t>150&&r.length>0&&(yield r,t=performance.now());for(const t of e)r.push(t)}r.done=!0,yield r}catch(e){r.error=e,yield r}}(e.queryStream(...e.queryTag.apply(e,t),a));if("function"==typeof e.query)return e.query(...e.queryTag.apply(e,t),a)}if("function"==typeof e.sql)return e.sql.apply(e,t);throw new Error("source does not implement query, queryStream, or sql")}function wn(e,t){if("object"==typeof e){let n="";return null!=e.database&&(n+=t(e.database)+"."),null!=e.schema&&(n+=t(e.schema)+"."),n+=t(e.table),n}return t(e)}function yn(e,t){const n=t[0];n[n.length-1]+=e}function vn({column:e,direction:t},n,r){yn(`${r(e)} ${t.toUpperCase()}`,n)}function _n({type:e,operands:t},n,r){if(t.length<1)throw new Error("Invalid operand length");if(1===t.length||"v"===e||"nv"===e)switch(gn(t[0],n,r),e){case"n":case"nv":return void yn(" IS NULL",n);case"nn":case"v":return void yn(" IS NOT NULL",n);default:throw new Error("Invalid filter operation")}if(2!==t.length||["in","nin"].includes(e)){var a;switch(gn(t[0],n,r),e){case"in":yn(" IN (",n);break;case"nin":yn(" NOT IN (",n);break;default:throw new Error("Invalid filter operation")}!function(e,t){let n=!0;for(const r of e)n?n=!1:yn(",",t),t.push(r.value),t[0].push("")}(t.slice(1),n),yn(")",n)}else{if(["c","nc"].includes(e)){switch(gn(t[0],n,r),e){case"c":yn(" LIKE ",n);break;case"nc":yn(" NOT LIKE ",n)}return void gn((a=t[1],{...a,value:`%${a.value}%`}),n,r)}switch(gn(t[0],n,r),e){case"eq":yn(" = ",n);break;case"ne":yn(" <> ",n);break;case"gt":yn(" > ",n);break;case"lt":yn(" < ",n);break;case"gte":yn(" >= ",n);break;case"lte":yn(" <= ",n);break;default:throw new Error("Invalid filter operation")}gn(t[1],n,r)}}function gn(e,t,n){"column"===e.type?yn(n(e.value),t):(t.push(e.value),t[0].push(""))}function En(e,t){return(null==e||!(e>=e))-(null==t||!(t>=t))}function Cn(e,t){return En(e,t)||(et?1:0)}function Nn(e,t){return En(e,t)||(e>t?-1:e"number"==typeof e&&!Number.isNaN(e),Tn=e=>Number.isInteger(e)&&!Number.isNaN(e),An=e=>"string"==typeof e,jn=e=>"boolean"==typeof e,$n=e=>"bigint"==typeof e,Sn=e=>e instanceof Date&&!isNaN(e),qn=e=>e instanceof ArrayBuffer,On=e=>Array.isArray(e),Ln=e=>"object"==typeof e&&null!==e,kn=e=>null!=e;function Mn(e){switch(e){case"string":return An;case"bigint":return $n;case"boolean":return jn;case"number":return xn;case"integer":return Tn;case"date":return Sn;case"buffer":return qn;case"array":return On;case"object":return Ln;default:return kn}}const In=/^(([-+]\d{2})?\d{4}(-\d{2}(-\d{2}))|(\d{1,2})\/(\d{1,2})\/(\d{2,4}))([T ]\d{2}:\d{2}(:\d{2}(\.\d{3})?)?(Z|[-+]\d{2}:\d{2})?)?$/;function Rn(e,t){switch(t){case"string":return"string"==typeof e||null==e?e:String(e);case"boolean":if("string"==typeof e){const t=e.trim().toLowerCase();return"true"===t||"false"!==t&&null}return"boolean"==typeof e||null==e?e:Boolean(e);case"bigint":return"bigint"==typeof e||null==e?e:Number.isInteger("string"!=typeof e||e.trim()?+e:NaN)?BigInt(e):void 0;case"integer":case"number":return"number"==typeof e?e:null==e||"string"==typeof e&&!e.trim()?NaN:Number(e);case"date":{if(e instanceof Date||null==e)return e;if("number"==typeof e)return new Date(e);const t=String(e).trim();return"string"!=typeof e||t?new Date(In.test(t)?t:NaN):null}case"array":case"object":case"buffer":case"other":return e;default:throw new Error(`Unable to coerce to type: ${t}`)}}function Pn(e,t,n){const r={};for(const a of n){const n=t.get(a.name),o=e[a.name];r[a.name]="raw"===n?o:Rn(o,n)}return r}const Un=["boolean","integer","number","date","bigint","array","object","buffer"];function Dn(e,t=function(e){const t=new Set;for(const n of e)if(n)for(const e in n)Object.prototype.hasOwnProperty.call(n,e)&&t.add(e);return Array.from(t)}(e)){const n=[],r=e.slice(0,100);for(const e of t){const t={boolean:0,integer:0,number:0,date:0,string:0,array:0,object:0,bigint:0,buffer:0,defined:0};for(const n of r){let r=n[e];if(null==r)continue;const a=typeof r;if("string"!==a)++t.defined,Array.isArray(r)?++t.array:r instanceof Date?++t.date:r instanceof ArrayBuffer?++t.buffer:"number"===a?(++t.number,Number.isInteger(r)&&++t.integer):a in t&&++t[a];else{if(r=r.trim(),!r)continue;++t.defined,++t.string,/^(true|false)$/i.test(r)?++t.boolean:r&&!isNaN(r)?(++t.number,Number.isInteger(+r)&&++t.integer):In.test(r)&&++t.date}}const a=Math.max(1,.9*t.defined),o=nn(Un,(e=>t[e]>=a?t[e]:NaN))??(t.string>=a?"string":"other");n.push({name:e,type:o,inferred:o})}return n}const Library=Object.assign(Object.defineProperties((function(e){const t=function(e){return null==e?lt:rt(e)}(e);var n;Object.defineProperties(this,(n={FileAttachment:()=>Et,Mutable:()=>Ht,now:Vt,width:en,dot:()=>t(Ae.resolve()),htl:()=>t(qe.resolve()),html:()=>Wt,md:()=>function(e){return e(Le.resolve()).then((function(t){return zt((function(n){var r=document.createElement("div");r.innerHTML=t(n,{langPrefix:""}).trim();var a=r.querySelectorAll("pre code[class]");return a.length>0&&e(je.resolve()).then((function(t){a.forEach((function(n){function r(){t.highlightBlock(n),n.parentNode.classList.add("observablehq--md-pre")}t.getLanguage(n.className)?r():e(je.resolve("async-languages/index.js")).then((r=>{if(r.has(n.className))return e(je.resolve("async-languages/"+r.get(n.className))).then((e=>{t.registerLanguage(n.className,e)}))})).then(r,r)}))})),r}),(function(){return document.createElement("div")}))}))}(t),svg:()=>Kt,tex:()=>function(e){return Promise.all([e($e.resolve()),e.resolve($e.resolve("dist/katex.min.css")).then(Qt)]).then((function(e){var t=e[0],n=r();function r(e){return function(){var n=document.createElement("div");return t.render(Xt.apply(String,arguments),n,e),n.removeChild(n.firstChild)}}return n.options=r,n.block=r({displayMode:!0}),n}))}(t),_:()=>t(Se.resolve()),aq:()=>t.alias({"apache-arrow":Pe.resolve()})(De.resolve()),Arrow:()=>t(Pe.resolve()),d3:()=>t(Ne.resolve()),DuckDBClient:()=>DuckDBClient,Inputs:()=>t(xe.resolve()).then((e=>({...e,file:e.fileOf(gt)}))),L:()=>async function(e){const t=await e(We.resolve());if(!t._style){const n=document.createElement("link");n.rel="stylesheet",n.href=await e.resolve(We.resolve("dist/leaflet.css")),t._style=document.head.appendChild(n)}return t}(t),mermaid:()=>async function(e){const t=await e(ze.resolve());return t.initialize({securityLevel:"loose",theme:"neutral"}),function(){const e=document.createElement("div");return e.innerHTML=t.render(xt().id,String.raw.apply(String,arguments)),e.removeChild(e.firstChild)}}(t),Plot:()=>t(Te.resolve()),__query:()=>fn,require:()=>t,resolve:()=>Jt,SQLite:()=>ut(t),SQLiteDatabaseClient:()=>SQLiteDatabaseClient,topojson:()=>t(Fe.resolve()),vl:()=>async function(e){const[t,n,r]=await Promise.all([Me,Ie,Re].map((t=>e(t.resolve()))));return r.register(t,n)}(t),aapl:()=>new FileAttachment("https://static.observableusercontent.com/files/3ccff97fd2d93da734e76829b2b066eafdaac6a1fafdec0faf6ebc443271cfc109d29e80dd217468fcb2aff1e6bffdc73f356cc48feb657f35378e6abbbb63b9").csv({typed:!0}),alphabet:()=>new FileAttachment("https://static.observableusercontent.com/files/75d52e6c3130b1cae83cda89305e17b50f33e7420ef205587a135e8562bcfd22e483cf4fa2fb5df6dff66f9c5d19740be1cfaf47406286e2eb6574b49ffc685d").csv({typed:!0}),cars:()=>new FileAttachment("https://static.observableusercontent.com/files/048ec3dfd528110c0665dfa363dd28bc516ffb7247231f3ab25005036717f5c4c232a5efc7bb74bc03037155cb72b1abe85a33d86eb9f1a336196030443be4f6").csv({typed:!0}),citywages:()=>new FileAttachment("https://static.observableusercontent.com/files/39837ec5121fcc163131dbc2fe8c1a2e0b3423a5d1e96b5ce371e2ac2e20a290d78b71a4fb08b9fa6a0107776e17fb78af313b8ea70f4cc6648fad68ddf06f7a").csv({typed:!0}),diamonds:()=>new FileAttachment("https://static.observableusercontent.com/files/87942b1f5d061a21fa4bb8f2162db44e3ef0f7391301f867ab5ba718b225a63091af20675f0bfe7f922db097b217b377135203a7eab34651e21a8d09f4e37252").csv({typed:!0}),flare:()=>new FileAttachment("https://static.observableusercontent.com/files/a6b0d94a7f5828fd133765a934f4c9746d2010e2f342d335923991f31b14120de96b5cb4f160d509d8dc627f0107d7f5b5070d2516f01e4c862b5b4867533000").csv({typed:!0}),industries:()=>new FileAttachment("https://static.observableusercontent.com/files/76f13741128340cc88798c0a0b7fa5a2df8370f57554000774ab8ee9ae785ffa2903010cad670d4939af3e9c17e5e18e7e05ed2b38b848ac2fc1a0066aa0005f").csv({typed:!0}),miserables:()=>new FileAttachment("https://static.observableusercontent.com/files/31d904f6e21d42d4963ece9c8cc4fbd75efcbdc404bf511bc79906f0a1be68b5a01e935f65123670ed04e35ca8cae3c2b943f82bf8db49c5a67c85cbb58db052").json(),olympians:()=>new FileAttachment("https://static.observableusercontent.com/files/31ca24545a0603dce099d10ee89ee5ae72d29fa55e8fc7c9ffb5ded87ac83060d80f1d9e21f4ae8eb04c1e8940b7287d179fe8060d887fb1f055f430e210007c").csv({typed:!0}),penguins:()=>new FileAttachment("https://static.observableusercontent.com/files/715db1223e067f00500780077febc6cebbdd90c151d3d78317c802732252052ab0e367039872ab9c77d6ef99e5f55a0724b35ddc898a1c99cb14c31a379af80a").csv({typed:!0}),weather:()=>new FileAttachment("https://static.observableusercontent.com/files/693a46b22b33db0f042728700e0c73e836fa13d55446df89120682d55339c6db7cc9e574d3d73f24ecc9bc7eb9ac9a1e7e104a1ee52c00aab1e77eb102913c1f").csv({typed:!0}),DOM:At,Files:jt,Generators:Lt,Promises:Zt},Object.fromEntries(Object.entries(n).map(Fn))))}),{resolve:{get:()=>lt.resolve,enumerable:!0,configurable:!0},require:{get:()=>lt,set:function(e){lt=e},enumerable:!0,configurable:!0}}),{resolveFrom:tt,requireFrom:rt});function Fn([e,t]){return[e,{value:t,writable:!0,enumerable:!0}]}class RuntimeError extends Error{constructor(e,t){super(e),this.input=t}}function Bn(e){return()=>e}function zn(e){return e}RuntimeError.prototype.name="RuntimeError";const Wn=Array.prototype.map;function Hn(){}const Vn=Symbol("no-observer");function Variable(e,t,n){var r;n||(n=Vn),Object.defineProperties(this,{_observer:{value:n,writable:!0},_definition:{value:Zn,writable:!0},_duplicate:{value:void 0,writable:!0},_duplicates:{value:void 0,writable:!0},_indegree:{value:NaN,writable:!0},_inputs:{value:[],writable:!0},_invalidate:{value:Hn,writable:!0},_module:{value:t},_name:{value:null,writable:!0},_outputs:{value:new Set,writable:!0},_promise:{value:Promise.resolve(void 0),writable:!0},_reachable:{value:n!==Vn,writable:!0},_rejector:{value:(r=this,e=>{if(e===Jn)throw e;if(e===Zn)throw new RuntimeError(`${r._name} is not defined`,r._name);if(e instanceof Error&&e.message)throw new RuntimeError(e.message,r._name);throw new RuntimeError(`${r._name} could not be resolved`,r._name)})},_type:{value:e},_value:{value:void 0,writable:!0},_version:{value:0,writable:!0}})}function Gn(e){e._module._runtime._dirty.add(e),e._outputs.add(this)}function Yn(e){e._module._runtime._dirty.add(e),e._outputs.delete(this)}function Zn(){throw Zn}function Jn(){throw Jn}function Kn(e){return()=>{throw new RuntimeError(`${e} is defined more than once`)}}function Xn(e,t,n){const r=this._module._scope,a=this._module._runtime;if(this._inputs.forEach(Yn,this),t.forEach(Gn,this),this._inputs=t,this._definition=n,this._value=void 0,n===Hn?a._variables.delete(this):a._variables.add(this),e!==this._name||r.get(e)!==this){let t,o;if(this._name)if(this._outputs.size)r.delete(this._name),o=this._module._resolve(this._name),o._outputs=this._outputs,this._outputs=new Set,o._outputs.forEach((function(e){e._inputs[e._inputs.indexOf(this)]=o}),this),o._outputs.forEach(a._updates.add,a._updates),a._dirty.add(o).add(this),r.set(this._name,o);else if((o=r.get(this._name))===this)r.delete(this._name);else{if(3!==o._type)throw new Error;o._duplicates.delete(this),this._duplicate=void 0,1===o._duplicates.size&&(o=o._duplicates.keys().next().value,t=r.get(this._name),o._outputs=t._outputs,t._outputs=new Set,o._outputs.forEach((function(e){e._inputs[e._inputs.indexOf(t)]=o})),o._definition=o._duplicate,o._duplicate=void 0,a._dirty.add(t).add(o),a._updates.add(o),r.set(this._name,o))}if(this._outputs.size)throw new Error;e&&((o=r.get(e))?3===o._type?(this._definition=Kn(e),this._duplicate=n,o._duplicates.add(this)):2===o._type?(this._outputs=o._outputs,o._outputs=new Set,this._outputs.forEach((function(e){e._inputs[e._inputs.indexOf(o)]=this}),this),a._dirty.add(o).add(this),r.set(e,this)):(o._duplicate=o._definition,this._duplicate=n,t=new Variable(3,this._module),t._name=e,t._definition=this._definition=o._definition=Kn(e),t._outputs=o._outputs,o._outputs=new Set,t._outputs.forEach((function(e){e._inputs[e._inputs.indexOf(o)]=t})),t._duplicates=new Set([this,o]),a._dirty.add(o).add(t),a._updates.add(o).add(t),r.set(e,t)):r.set(e,this)),this._name=e}return this._version>0&&++this._version,a._updates.add(this),a._compute(),this}Object.defineProperties(Variable.prototype,{_pending:{value:function(){this._observer.pending&&this._observer.pending()},writable:!0,configurable:!0},_fulfilled:{value:function(e){this._observer.fulfilled&&this._observer.fulfilled(e,this._name)},writable:!0,configurable:!0},_rejected:{value:function(e){this._observer.rejected&&this._observer.rejected(e,this._name)},writable:!0,configurable:!0},define:{value:function(e,t,n){switch(arguments.length){case 1:n=e,e=t=null;break;case 2:n=t,"string"==typeof e?t=null:(t=e,e=null)}return Xn.call(this,null==e?null:String(e),null==t?[]:Wn.call(t,this._module._resolve,this._module),"function"==typeof n?n:Bn(n))},writable:!0,configurable:!0},delete:{value:function(){return Xn.call(this,null,[],Hn)},writable:!0,configurable:!0},import:{value:function(e,t,n){arguments.length<3&&(n=t,t=e);return Xn.call(this,String(t),[n._resolve(String(e))],zn)},writable:!0,configurable:!0}});const Qn=Symbol("variable"),er=Symbol("invalidation"),tr=Symbol("visibility");function Module(e,t=[]){Object.defineProperties(this,{_runtime:{value:e},_scope:{value:new Map},_builtins:{value:new Map([["@variable",Qn],["invalidation",er],["visibility",tr],...t])},_source:{value:null,writable:!0}})}async function nr(e,t){await e._compute();try{return await t._promise}catch(n){if(n===Jn)return nr(e,t);throw n}}function rr(e){return e._name}Object.defineProperties(Module.prototype,{_resolve:{value:function(e){let t,n=this._scope.get(e);if(!n)if(n=new Variable(2,this),this._builtins.has(e))n.define(e,Bn(this._builtins.get(e)));else if(this._runtime._builtin._scope.has(e))n.import(e,this._runtime._builtin);else{try{t=this._runtime._global(e)}catch(t){return n.define(e,function(e){return()=>{throw e}}(t))}void 0===t?this._scope.set(n._name=e,n):n.define(e,Bn(t))}return n},writable:!0,configurable:!0},redefine:{value:function(e){const t=this._scope.get(e);if(!t)throw new RuntimeError(`${e} is not defined`);if(3===t._type)throw new RuntimeError(`${e} is defined more than once`);return t.define.apply(t,arguments)},writable:!0,configurable:!0},define:{value:function(){const e=new Variable(1,this);return e.define.apply(e,arguments)},writable:!0,configurable:!0},derive:{value:function(e,t){const n=new Map,r=new Set,a=[];function o(e){let t=n.get(e);return t||(t=new Module(e._runtime,e._builtins),t._source=e,n.set(e,t),a.push([t,e]),r.add(e),t)}const i=o(this);for(const n of e){const{alias:e,name:r}="object"==typeof n?n:{name:n};i.import(r,null==e?r:e,t)}for(const e of r)for(const[t,n]of e._scope)if(n._definition===zn){if(e===this&&i._scope.has(t))continue;const r=n._inputs[0]._module;r._source&&o(r)}for(const[e,t]of a)for(const[r,a]of t._scope){const t=e._scope.get(r);if(!t||2===t._type)if(a._definition===zn){const t=a._inputs[0],o=t._module;e.import(t._name,r,n.get(o)||o)}else e.define(r,a._inputs.map(rr),a._definition)}return i},writable:!0,configurable:!0},import:{value:function(){const e=new Variable(1,this);return e.import.apply(e,arguments)},writable:!0,configurable:!0},value:{value:async function(e){let t=this._scope.get(e);if(!t)throw new RuntimeError(`${e} is not defined`);if(t._observer!==Vn)return nr(this._runtime,t);t=this.variable(!0).define([e],zn);try{return await nr(this._runtime,t)}finally{t.delete()}},writable:!0,configurable:!0},variable:{value:function(e){return new Variable(1,this,e)},writable:!0,configurable:!0},builtin:{value:function(e,t){this._builtins.set(e,t)},writable:!0,configurable:!0}});const ar="function"==typeof requestAnimationFrame?requestAnimationFrame:"function"==typeof setImmediate?setImmediate:e=>setTimeout(e,0);function Runtime(e=new Library,t=pr){const n=this.module();if(Object.defineProperties(this,{_dirty:{value:new Set},_updates:{value:new Set},_precomputes:{value:[],writable:!0},_computing:{value:null,writable:!0},_init:{value:null,writable:!0},_modules:{value:new Map},_variables:{value:new Set},_disposed:{value:!1,writable:!0},_builtin:{value:n},_global:{value:t}}),e)for(const t in e)new Variable(2,n).define(t,[],e[t])}function or(e){const t=new Set(e._inputs);for(const n of t){if(n===e)return!0;n._inputs.forEach(t.add,t)}return!1}function ir(e){++e._indegree}function sr(e){--e._indegree}function cr(e){return e._promise.catch(e._rejector)}function lr(e){return new Promise((function(t){e._invalidate=t}))}function ur(e,t){let n,r,a="function"==typeof IntersectionObserver&&t._observer&&t._observer._node,o=!a,i=Hn,s=Hn;return a&&(r=new IntersectionObserver((([e])=>(o=e.isIntersecting)&&(n=null,i()))),r.observe(a),e.then((()=>(r.disconnect(),r=null,s())))),function(e){return o?Promise.resolve(e):r?(n||(n=new Promise(((e,t)=>(i=e,s=t)))),n.then((()=>e))):Promise.reject()}}function fr(e){e._invalidate(),e._invalidate=Hn,e._pending();const t=e._value,n=++e._version;let r=null;const a=e._promise=(e._inputs.length?Promise.all(e._inputs.map(cr)).then((function(a){if(e._version!==n)throw Jn;for(let t=0,n=a.length;tn(e._definition.call(t))))).then((function(t){if(e._version!==n)throw Jn;if(function(e){return e&&"function"==typeof e.next&&"function"==typeof e.return}(t))return(r||lr(e)).then((a=t,function(){a.return()})),function(e,t,n){const r=e._module._runtime;let a;function o(e){return new Promise((e=>e(n.next(a)))).then((({done:t,value:n})=>t?void 0:Promise.resolve(n).then(e)))}function i(){const n=o((o=>{if(e._version!==t)throw Jn;return a=o,s(o,n).then((()=>r._precompute(i))),e._fulfilled(o),o}));n.catch((r=>{r!==Jn&&e._version===t&&(s(void 0,n),e._rejected(r))}))}function s(t,n){return e._value=t,e._promise=n,e._outputs.forEach(r._updates.add,r._updates),r._compute()}return o((n=>{if(e._version!==t)throw Jn;return a=n,r._precompute(i),n}))}(e,n,t);var a;return t}));a.then((t=>{e._value=t,e._fulfilled(t)}),(t=>{t!==Jn&&(e._value=void 0,e._rejected(t))}))}function dr(e,t){e._invalidate(),e._invalidate=Hn,e._pending(),++e._version,e._indegree=NaN,(e._promise=Promise.reject(t)).catch(Hn),e._value=void 0,e._rejected(t)}function pr(e){return globalThis[e]}Object.defineProperties(Runtime.prototype,{_precompute:{value:function(e){this._precomputes.push(e),this._compute()},writable:!0,configurable:!0},_compute:{value:function(){return this._computing||(this._computing=this._computeSoon())},writable:!0,configurable:!0},_computeSoon:{value:function(){return new Promise(ar).then((()=>this._disposed?void 0:this._computeNow()))},writable:!0,configurable:!0},_computeNow:{value:async function(){let e,t,n=[],r=this._precomputes;if(r.length){this._precomputes=[];for(const e of r)e();await function(e=0){let t=Promise.resolve();for(let n=0;n{}));return t}(3)}e=new Set(this._dirty),e.forEach((function(t){t._inputs.forEach(e.add,e);const n=function(e){if(e._observer!==Vn)return!0;const t=new Set(e._outputs);for(const e of t){if(e._observer!==Vn)return!0;e._outputs.forEach(t.add,t)}return!1}(t);n>t._reachable?this._updates.add(t):n{e._invalidate(),e._version=NaN}))},writable:!0,configurable:!0},module:{value:function(e,t=Hn){let n;if(void 0===e)return(n=this._init)?(this._init=null,n):new Module(this);if(n=this._modules.get(e),n)return n;this._init=n=new Module(this),this._modules.set(e,n);try{e(this,t)}finally{this._init=null}return n},writable:!0,configurable:!0},fileAttachments:{value:function(e){return Object.assign((t=>{const n=e(t+="");if(null==n)throw new Error(`File not found: ${t}`);if("object"==typeof n&&"url"in n){const{url:e,mimeType:r}=n;return new FileAttachment(e,t,r)}return new FileAttachment(n,t)}),{prototype:FileAttachment.prototype})},writable:!0,configurable:!0}});export{Inspector,Library,Runtime,RuntimeError};