@martinomagnifico/tablechart 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,73 @@
+# Changelog
+
+## [0.1.0]
+
+### Added
+
+
+- The legend of an area chart has a square in front of each name.
+- Each line of a chart with several lines has its own point: a filled circle, an open circle, a filled square, an open square, a filled diamond and an open diamond, then from the start again. `data-marker` on a column header sets another, such as `square` or `diamond open`. The legend shows the same points. Points have `data-marker` with their shape, and `data-open` when they are open.
+- `data-line="dashed"` or `data-line="dotted"` on a column header makes a dashed or dotted line. It is shown from left to right when the chart builds. The legend shows the same line. `--tablechart-dash` and `--tablechart-dot` set the pattern.
+
+
+## [0.0.8]
+
+### Changed
+- The figure and the table of a chart get the chart's title as their name, with `aria-labelledby`, so a screen reader that jumps to the table reads the title and the unit too. A figure or table with a name of its own keeps it.
+- If a donut has no total row, a hidden row with the sum is added to the bottom of its table, so screen readers read the total with a name. The `totallabel` option sets the name, "Total" by default.
+- All text in the drawing is `inert`, so Safari with VoiceOver does not read it.
+- A full stop, hidden from sight, is put before each line break in the title, so a screen reader pauses between the title and the subtitle.
+- The drawing, its names and its legend have `aria-hidden="true"`. The names and the legend are also `inert`, because Safari with VoiceOver read them otherwise. Screen readers read the table, which has the same names and numbers, so they no longer read everything twice.
+
+## [0.0.7]
+
+### Added
+
+- If JavaScript does not run, the table is shown instead of the chart, with `@media (scripting: none)`.
+- The names beside the bars of a bar chart wrap if they are wider than `--tablechart-name-max`, 40% of the chart by default. The chart gets taller if a wrapped name needs it.
+- A bar chart keeps room after its bars only for the numbers that stand there: the totals of a stacked chart, the numbers of a grouped one, or numbers that do not fit inside their bar. If every number fits inside, the bars use the whole width.
+- `--tablechart-type: bar` on a column chart shows it as a bar chart, and `--tablechart-type: column` does the opposite. Set it in a container query or a media query, and the chart is built again as the other kind when the query applies.
+- The names under the bars are larger by default: `--tablechart-category-size` is 0.95em. The numbers are 1.3 times the names, so they stay the same size.
+- The build makes four files: `tablechart.mjs` (one ES module), `tablechart.js` (for a script tag), `tablechart.css` and `tablechart.d.ts` (all types in one file).
+- `@martinomagnifico/tablechart/core` has the building blocks under `init()` and `create()`: `prepare`, `build`, `layout`, `setShown`, `relabel` and `unbuild`, for a script or plugin that decides itself when a chart is built and shown.
+- `create(element, options)` makes a chart of one element, and returns it. Each chart is also on its element as `element.tablechart`, with `refresh()` and `destroy()`. `init()` returns these charts in `charts`.
+- `init()` returns `refresh()`, which lays out every chart again, for example after a script has changed the text of a chart.
+- If the `lang` attribute of the page changes, the charts are laid out again a moment later, so new text that is longer or shorter fits.
+- The `langattribute` option is used everywhere: to read keys from the table and to put them on the names in the chart, not only to write them on the table. `false` turns translation keys off.
+- `data-chart-keys` on a figure adds translation keys to its names, starting with its value: `harvest-row1` for a row, `harvest-col1` for a column header. It replaces `data-chart-prefix`. An `id` on a figure no longer adds keys.
+- With more than three lines, the colour steps between lines are smaller, so the last line is still `--tablechart-series-min` of its colour, now 40% by default.
+- If a chart has numbers that were left out because there is no room for them, pointing at a row, or tapping it, shows the numbers of that row, with a faint band behind the row. The other numbers are hidden for that time. The `hover` option, or `data-chart-hover="false"` on a figure, turns it off. `--tablechart-pointer-color` sets the colour of the band. In a chart that can be pointed at, the numbers in the plot cannot be selected.
+
+
+## [0.0.6]
+
+### Added
+
+- Area chart, `data-chart="area"`: a line chart with the space between each line and zero filled. `--tablechart-area-opacity` and `--tablechart-area-color` set the fill.
+- `data-chart-stack` on a column, bar, line or area chart with several value columns: the values of a row are on top of each other. Columns and bars show the total of the row. A number is shown inside its part if it fits.
+- `data-chart-shape="step"` on a line or area chart: each value is flat across its row. A step chart has no points and shows a number only where the value changes. A number wider than its rows is left out.
+
+
+
+## [0.0.5]
+
+### Added
+
+- First version: column, bar, line, waterfall and donut charts, with annotations, legends and CSS variables.
+- A chart builds when it scrolls into view. `threshold` sets how much of it must be in view, and `replay` builds it again each time it comes back into view.
+- If a chart is inside something that animates in, it builds when that animation is halfway. If that element is still invisible (opacity 0) when the chart scrolls into view, the chart waits until the element starts to animate in, or becomes visible.
+- `--tablechart-bar-max` sets the widest a column, step or bar may be: 60px by default, in `px`, `%`, `em` or `rem`, or `none` for no maximum.
+- Row and line numbers in the markup start at 1: a bracket's `data-from` and `data-to`, an annotation's `data-series`, and the `data-series` and `data-slice` attributes on lines, points, names and slices.
+- A break in the scale is cut out of the bars with a mask, so the background behind the chart shows through the gap, whatever it is.
+- The gaps between donut slices are cut out of the ring with a mask, so the background shows through. `--tablechart-slice-gap` sets their width. `--tablechart-slice-gap-color` is gone.
+- A class on a table row is copied to its bar, slice, number and name, so one class styles everything drawn for that row. Bars have `data-row`, counted from 1.
+- A number inside a bar is dark or light, whichever reads on the colour of the bar. The ink variables still set it.
+- `--tablechart-surface` is the browser's page background by default (`Canvas`), so it follows `color-scheme`: white in light mode and dark in dark mode. Only the lighter colours of lines and slices are mixed with it.
+- Open points on a line and the callout of a bracket or trend arrow are cut out of the marks under them with a mask, so the background behind the chart shows through. `--tablechart-badge-surface` has no default.
+- Grouped column and bar charts: if the table has more than one value column, each row is a group with one bar per column, and the names are in a legend.
+- A bar chart is at least tall enough for a number beside every bar, so it gets taller on a narrow screen instead of hiding its numbers.
+- `--tablechart-min-height`: on a narrow screen, a chart is never less high than this, 200px by default. Below that width, the height stays the same.
+- In a waterfall, and a column chart with numbers inside, a number only goes inside its bar if it fits in the width too. If one number does not fit, all numbers go outside.
+- The numbers of a grouped chart get smaller together to fit, down to 70% of their size. If they still do not fit, none of them are shown, so they never disappear one by one while the chart gets narrower.
+- The names under the bars get smaller together if one does not fit its column, down to 70%. They stay centred under their bars.
+- The rules for labels are in one place (`functions/labels.ts`), so every chart type uses the same ones.

package/README.md

@@ -0,0 +1,92 @@
+# Tablechart
+
+Simple charts from an HTML or Markdown table: column, bar, line, area,
+waterfall and donut, with annotations. A chart builds when it scrolls into
+view. Charts are SVG and use the colours of the page, which you can change with
+CSS variables.
+
+> Work in progress. The documentation site is in `docs/`.
+
+## Install
+
+```sh
+npm install @martinomagnifico/tablechart
+```
+
+```js
+import { init } from "@martinomagnifico/tablechart";
+import "@martinomagnifico/tablechart/style.css";
+
+init();
+```
+
+Or with a script tag:
+
+```html
+<link rel="stylesheet" href="tablechart.css">
+<script src="tablechart.js"></script>
+<script>
+    Tablechart.init();
+</script>
+```
+
+## Markup
+
+A chart is an element with `data-chart` and a table in it. The first cell of a
+row is the label, the second the value.
+
+```html
+<figure data-chart="column">
+    <figcaption><b>Apples picked</b><br><span>thousands</span></figcaption>
+    <table>
+        <tbody>
+            <tr><th>Spring</th><td>58</td></tr>
+            <tr><th>Summer</th><td>72</td></tr>
+            <tr><th>Autumn</th><td>70</td></tr>
+        </tbody>
+    </table>
+</figure>
+```
+
+## Options
+
+```js
+init({
+    selector: "[data-chart]", // The elements to make charts of
+    threshold: 0.5,           // How much of a chart must be in view before it builds
+    replay: false,            // Build again each time a chart scrolls back into view
+    animate: true,            // Animate the chart when it builds
+    langattribute: "data-i18n", // The attribute for translation keys, or false for none
+    debug: false
+});
+```
+
+`init` returns `{ charts, refresh, destroy }`. `refresh()` lays out every chart
+again. `destroy()` stops watching scroll, size and language changes.
+
+To make a chart of one element, use `create`. Each chart is also on its element,
+as `element.tablechart`:
+
+```js
+import { create } from "@martinomagnifico/tablechart";
+
+const chart = await create(document.querySelector("#sales"));
+chart.refresh();
+```
+
+## Bar width
+
+A column, a waterfall step or a bar is never wider than `--tablechart-bar-max`,
+60px by default. Use any of `px`, `%` (of the chart's width), `em` or `rem`. In a
+narrow chart, bars are 58% of their space. Set `--tablechart-bar-max: none` for
+no maximum.
+
+## Height
+
+The height of a chart is a share of its width: `data-chart-aspect`, 0.38 by
+default. On a narrow screen it is never less than `--tablechart-min-height`,
+200px by default. Use `px`, `em` or `rem`, or `none` for no minimum.
+
+## Licence
+
+MIT

package/dist/tablechart-core.d.ts

@@ -0,0 +1,387 @@
+/**
+ * Some Markdown tools put attributes on the table itself, so the table matches
+ * the selector, such as `{data-chart=column}` with markdown-it-attrs. A chart draws into its
+ * figure, and a table cannot hold a plot, so the table is wrapped in a `div` that
+ * takes over its chart attributes and classes.
+ *
+ * Markdown has no way to put anything inside it, so what belongs to the chart is
+ * taken in from beside the table: a caption paragraph just before or after it, and
+ * after that a list of annotations or a `.chart-annotations` block.
+ *
+ * A chart that reads its rows from a file has no table, so the attributes go on
+ * its caption instead. If they end up on the bold title inside the caption, the
+ * caption is taken to be the chart.
+ */
+export declare const adoptTables: (figures: HTMLElement[]) => HTMLElement[];
+
+/**
+ * An annotation in two halves, because the two need different moments.
+ * `create` runs before anything is laid out, so anything translatable exists in the DOM
+ * by the time a translation plugin takes its one sweep of the page. `draw` runs
+ * once the figure has a width, and only ever places what `create` already made.
+ */
+declare interface AnnotationType {
+    create: (spec: HTMLElement, plot: HTMLElement) => HTMLElement | null;
+    draw: (spec: HTMLElement, badge: HTMLElement | null, geo: Geometry) => void;
+}
+
+/**
+ * Translation keys, written onto the source table before anything is drawn, for
+ * a figure with `data-chart-keys`. Its value starts each key: `harvest-row1` for
+ * the name of the first row, `harvest-col1` for the header of the first value
+ * column. A cell that has a key already keeps it.
+ *
+ * The value has to be unique on the page. If two figures use
+ * the same value, the second one gets a number added, and a warning says so.
+ *
+ * Keys are written here, in a pass of its own, so that extraction never depends
+ * on whether a chart has been drawn yet.
+ */
+export declare const assignKeys: (figures: HTMLElement[], langattribute: string | false) => void;
+
+/**
+ * Pass 2. Everything a reader will read, before a translation script looks.
+ *
+ */
+export declare const build: (figure: HTMLElement, config: Config, asKind?: string | null) => ChartState | null;
+
+/** One value cell of the source table. */
+declare interface Cell {
+    /** The cell exactly as written. */
+    raw: string;
+    /** The number in the cell as written, so its decimal places survive. Empty
+     * when the cell holds no number. */
+    number: string;
+    /** Whatever the cell says around its number, such as a % or the * of a
+     * footnote. It is kept on the label, either side of the formatted number. */
+    prefix: string;
+    suffix: string;
+    /** The cell holds no number, such as "n/a": the row has no mark, and its label
+     * says what the cell does. Its value counts as zero wherever one is needed. */
+    missing: boolean;
+    value: number;
+}
+
+export declare interface ChartState {
+    figure: HTMLElement;
+    plot: HTMLElement;
+    svg: SVGSVGElement;
+    rows: Row[];
+    decimals: number;
+    type: ChartType;
+    values: HTMLElement[];
+    series: Series[];
+    seriesValues: HTMLElement[][];
+    names: HTMLElement[];
+    categories: HTMLElement[];
+    /** The number in the middle of a donut. Null for a chart that has no middle. */
+    centre: HTMLElement | null;
+    stacked: boolean;
+    totals: HTMLElement[];
+    /** The cell of the total row Tablechart adds to a donut's table, if it adds one. */
+    totalCell: HTMLElement | null;
+    /** The row at a point in the plot, in screen pixels from its corner, or null.
+     * Set by the layout; null for a chart whose rows are not side by side. */
+    rowAt: ((x: number, y: number) => number | null) | null;
+    /** Where a row is in the plot, as percentages: left, top, width and height. */
+    rowBox: ((index: number) => [number, number, number, number]) | null;
+    annotations: {
+        spec: HTMLElement;
+        type: AnnotationType;
+        badge: HTMLElement | null;
+        /** The line it reads, as a position from 0. `data-series` counts from 1; the first line when left out. */
+        series: number;
+        /** How many stagger steps it waits, so it lands after the data. */
+        after: number;
+    }[];
+    checks: Check[];
+}
+
+/** A chart kind: it reserves room for its text, then draws its own marks. */
+declare interface ChartType {
+    /** Height as a share of width, when the page's own aspect does not suit. A
+     * donut needs a squarer box than a row of columns does. */
+    aspect?: number;
+    /** This kind has a middle, so a row marked as a total belongs in it rather
+     * than among the marks. */
+    centre?: boolean;
+    /** A break in the scale means something here: its bars stand on the baseline,
+     * or, for a waterfall, its totals do and its floating steps keep clear of the
+     * break, which the scale checks for. */
+    breakable?: boolean;
+    /** `data-chart-stack` works for this kind. */
+    stackable?: boolean;
+    /** A stacked chart of this kind shows the total of each row. */
+    totals?: boolean;
+    /** The sample in front of a name in the legend, when it is not a line. A kind
+     * with `legend` always has a legend; one with only `swatch` has one when asked. */
+    swatch?: "box";
+    /** Where the category names go: in a row under the plot, or beside the marks,
+     * which is what a chart whose bars run sideways needs. */
+    categories?: "under" | "beside";
+    /** This kind draws every value column, not only the first. */
+    series?: boolean;
+    /** With several series, the names go in a legend whatever the options say, with
+     * a sample of this shape: a square for bars. */
+    legend?: "box";
+    /** Extra headroom above the tallest bar, in viewBox units. */
+    headroom?: (geo: HeadroomInput) => number;
+    /** The least height this kind needs, in viewBox units, whatever its shape. */
+    minHeight?: (input: {
+        labelHeight: number;
+        /** The height of the tallest category name, which can wrap onto several lines. */
+        nameHeight: number;
+        unit: number;
+        rows: number;
+        series: number;
+        stacked: boolean;
+    }) => number;
+    /** Room under the baseline, for numbers that hang below a mark near it. */
+    footroom?: (geo: HeadroomInput) => number;
+    /** Lay out the rows. Default is one bar per row from the baseline. */
+    segments?: (rows: Row[]) => Segment[];
+    draw: (geo: Geometry) => void;
+}
+
+/** An authored figure next to the one the data implies. */
+declare interface Check {
+    label: string;
+    computed: number;
+    stated: number;
+    agrees: boolean;
+}
+
+export declare interface Config {
+    /** Which elements Tablechart turns into charts. */
+    selector: string;
+    /** Height of the plot as a share of its width. */
+    aspect: number;
+    /** Share of a band that a bar fills. */
+    barfill: number;
+    /** Share of a donut's radius that the ring itself takes. */
+    ringfill: number;
+    /**
+     * Locale for number formatting. Left unset, the document's own language is
+     * used and followed when it changes, so a translated page reformats itself.
+     */
+    locale?: string;
+    /** Animate a chart when it builds. */
+    animate: boolean;
+    /**
+     * Where a column's number goes: `outside`, standing on the bar, or `inside`,
+     * in the middle of it, in the bar's own ink. A bar too short to hold its
+     * number keeps it outside. A figure says otherwise with `data-chart-labels`.
+     */
+    labels: "outside" | "inside";
+    /**
+     * Where the names of the lines go, in a chart with several lines: `false` puts
+     * each name at the end of its line, `true` puts them all in a legend under the
+     * chart. A figure says otherwise with `data-chart-legend`, or
+     * `data-chart-legend="false"`.
+     */
+    legend: boolean;
+    /**
+     * If a chart has numbers that were left out because there is no room for them,
+     * pointing at a row, or tapping it, shows the numbers of that row. The other
+     * numbers are hidden for that time. A figure turns it off with
+     * `data-chart-hover="false"`.
+     */
+    hover: boolean;
+    /** The name of the total that a donut without a total row works out, for screen readers. */
+    totallabel: string;
+    /** How much of a chart must be in view before it builds, from 0 to 1. */
+    threshold: number;
+    /** Build again each time a chart scrolls back into view, not only the first time. */
+    replay: boolean;
+    /**
+     * The attribute that holds translation keys, for a translation script. A figure
+     * with `data-chart-keys` gets translation keys on its names. `false` turns them off.
+     */
+    langattribute: string | false;
+    /** Show messages in the console for whoever is working on the page. */
+    debug?: boolean;
+}
+
+export declare const defaultConfig: Config;
+
+/**
+ * What a chart hands to the drawing pass, and to any annotation on it. Scales
+ * only, no pixel positions, so an annotation follows the data.
+ */
+declare interface Geometry {
+    rows: Row[];
+    segments: Segment[];
+    /** Centre of a band, in viewBox units. */
+    cx: (index: number) => number;
+    /** A value's height, in viewBox units. */
+    y: (value: number) => number;
+    /** Bar width, in viewBox units. */
+    barWidth: number;
+    /** The widest a bar may be, in viewBox units, from `--tablechart-bar-max`. */
+    barMax: number;
+    /** viewBox height. */
+    height: number;
+    /** viewBox units per screen pixel, for anything that should look the same at any size. */
+    unit: number;
+    /** Measured height of a value label, in viewBox units. */
+    labelHeight: number;
+    /** Measured height of a badge, in viewBox units. Zero when the chart has none. */
+    badgeHeight: number;
+    /** How many stagger steps the data itself takes, so commentary can land after it. */
+    after: number;
+    /** For an annotation: its number in the figure, counted from 1. Each of its
+     * marks gets it as `data-note`. Zero for the chart itself. */
+    note: number;
+    /** Where the break's mark goes, as a value: the scale jumps just above it. Null
+     * when the scale runs straight through. */
+    breakAt: number | null;
+    /** Where the numbers on the marks go, by the figure's say or the page's. */
+    labels: "outside" | "inside";
+    /** `data-chart-stack` on the figure: the series of a row are drawn on top of
+     * each other, the first at the bottom. */
+    stacked: boolean;
+    /** `data-chart-shape` on the figure: "step" holds each value until the next
+     * point. For line and area charts. */
+    shape: "straight" | "step";
+    /** The total of each row of a stacked chart, in row order. Empty when the chart
+     * is not stacked or its kind shows no totals. */
+    totals: HTMLElement[];
+    svg: SVGSVGElement;
+    plot: HTMLElement;
+    /** The value labels, in row order. Created earlier; a chart only places them. */
+    values: HTMLElement[];
+    /** The value columns. A chart kind that draws only one is given only one. */
+    series: Series[];
+    /** The value labels of each series, in row order. The first is `values`. */
+    seriesValues: HTMLElement[][];
+    /** The name of each series, to be placed by its marks. Empty with one series. */
+    names: HTMLElement[];
+    /** The category names, in row order. A chart that keeps them beside its marks
+     * places these too; one that keeps them under the plot never touches them. */
+    categories: HTMLElement[];
+    /** The number in the middle, for a chart kind that has one. */
+    centre: HTMLElement | null;
+    config: Config;
+    /** Numbers an annotation worked out, against the numbers the author wrote. */
+    checks: Check[];
+}
+
+declare interface HeadroomInput {
+    labelHeight: number;
+    badgeHeight: number;
+    hasAnnotations: boolean;
+    unit: number;
+    /** How many series the chart draws, and whether one of them is in focus. */
+    series: number;
+    focused: boolean;
+    stacked: boolean;
+}
+
+/** Pass 3. Needs layout; makes no text, only places it. */
+export declare const layout: (state: ChartState, config: Config) => boolean;
+
+/**
+ * `data-chart-src` names a JSON file that holds the chart's rows. The file is the
+ * whole of the data: a table written inside the figure is removed, so there is
+ * never a question of which of the two is drawn. The file is either an array of
+ * rows or an object with a `rows` array.
+ *
+ * The file becomes an ordinary table before anything else happens, so a screen
+ * reader, a translation plugin and print all get the same table they would from
+ * HTML. A file that cannot be read leaves its chart empty and says why; the rest
+ * of the page goes on.
+ */
+export declare const loadSources: (figures: HTMLElement[]) => Promise<void>;
+
+export declare const PLACED_CLASS = "is-placed";
+
+export declare const PLOT_CLASS = "tablechart-plot";
+
+/**
+ * Turns elements into figures with a table, ready to build: a table from Markdown
+ * is wrapped, a JSON file becomes a table, and translation keys are added. All at
+ * once, so two charts with the same `data-chart-keys` are found.
+ */
+export declare const prepare: (found: HTMLElement[], config: Config) => Promise<HTMLElement[]>;
+
+export declare const QUEUED_CLASS = "tablechart-queued";
+
+/**
+ * A Markdown table has no header cells in its body and no attributes on its rows,
+ * so it says the same things differently. The first cell of a row is its label,
+ * and a label in **bold**, or in a `.total` span, makes the row a total, like
+ * `data-kind="total"` in HTML. A total is set in bold in most tables of figures
+ * already. The bold is taken off once read, so the label is plain text again.
+ * Rows written in HTML already have their `th` and are left as they are.
+ *
+ * The header over the value columns names the series. A name in bold is the
+ * series in focus, like `data-kind="focus"`.
+ */
+export declare const readMarkdownRows: (figures: HTMLElement[]) => void;
+
+/** Numbers are reformatted in place, so a language change costs no redraw. */
+export declare const relabel: (state: ChartState, config: Config) => void;
+
+/** One row of the source table. Its own value is its first cell's. */
+export declare interface Row extends Cell {
+    /** The category label, as authored. */
+    label: string;
+    /** Its translation key, authored or generated. */
+    key: string | null;
+    /** Every value cell in the row, one per series. The first is the row's own. */
+    cells: Cell[];
+    /** The classes on the row in the table. They are copied to its bar, slice,
+     * number and name, so one class styles everything drawn for the row. */
+    classes: string[];
+    /** A row marked `data-kind="total"` is a total. */
+    isTotal: boolean;
+    /** Where it is in the run that animates with it: the stagger counts from here. */
+    slot: number;
+}
+
+/** A row once a chart has worked out where it goes. */
+declare interface Segment extends Row {
+    from: number;
+    to: number;
+    kind: "bar" | "up" | "down" | "total";
+}
+
+/**
+ * A value column of the source table. A table with one is a chart with one series,
+ * and its header is not read; with more, the header names each one.
+ */
+export declare interface Series {
+    /** The column's header, as authored. Empty when the table has no header. */
+    name: string;
+    /** Its translation key, authored or generated. */
+    key: string | null;
+    /** `data-kind="focus"` on the header, or a bold one in Markdown: the series the
+     * chart is about. The others are shown fainter. */
+    focus: boolean;
+    /** `data-marker` on the header: the point of its line, such as `square` or
+     * `diamond open`. Null for the point its place gives it. */
+    marker: string | null;
+    /** `data-line` on the header: a dashed or dotted line. Null for a solid one. */
+    line: "dashed" | "dotted" | null;
+}
+
+/** One class, `is-shown`, starts the whole build. */
+export declare const setShown: (state: ChartState, shown: boolean) => void;
+
+export declare const SHOWN_CLASS = "is-shown";
+
+/**
+ * Removes what `build` added to the figure, so it can be built again. The table
+ * and the figure's own attributes stay.
+ */
+export declare const unbuild: (state: ChartState) => void;
+
+export { }
+
+
+declare global {
+    interface HTMLElement {
+        /** The chart made of this element, by `init` or `create`. */
+        tablechart?: TablechartChart;
+    }
+}

package/dist/tablechart-core.mjs

@@ -0,0 +1,2 @@
+import { _ as e, a as t, c as n, d as r, f as i, g as a, h as o, i as s, l as c, m as l, o as u, p as d, r as f, s as p, u as m } from "./tablechart-shared.mjs";
+export { d as PLACED_CLASS, l as PLOT_CLASS, o as QUEUED_CLASS, a as SHOWN_CLASS, s as adoptTables, i as assignKeys, p as build, e as defaultConfig, n as layout, t as loadSources, f as prepare, u as readMarkdownRows, c as relabel, m as setShown, r as unbuild };