@compstats/core 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,110 @@
+# Changelog
+
+All notable changes to `@compstats/core`. The R package this ports keeps its
+own history in [`NEWS.md`](https://github.com/compstatslib/compstatslib/blob/main/NEWS.md).
+
+## 0.2.0
+
+The first npm release. It follows the R package's own 0.8.0 release, which
+settled the R public API before that package had users to break. The same
+changes land here, for the same reason: nothing is published yet, so these are
+renames rather than breaking changes with a deprecation cycle.
+
+The number is 0.2.0, not 0.1.0, because 0.1.0 is a git tag that was never
+published. It stays where it is, and the rename below is what moves the minor.
+
+### Breaking changes
+
+* `plotRegr()` is renamed `plotRegression()`, matching R's rename of
+  `plot_regr()` to `plot_regression()`. Every other plot function already
+  carried the name of its interactive counterpart; this was the last one that
+  did not. `PlotRegrOptions` and `regrScale()` are renamed with it, to
+  `PlotRegressionOptions` and `regressionScale()`. There is no shim.
+
+### Added
+
+* `rt()`, `rlnorm()` and `rcauchy()` draw from the Student t, lognormal and
+  Cauchy distributions, with R's parameter names — `df`, `meanlog`/`sdlog`,
+  `location`/`scale`. One departure: `rt()` takes a positive integer `df`
+  only, where R's gamma sampler accepts any positive real. Empirical
+  quantiles are checked against R's `qt` and `qlnorm` over 200000 draws.
+* `mean()`, `median()` and `meanAbsoluteDeviation()`. `median()` is R's own
+  rule, the type-7 quantile at 0.5. `meanAbsoluteDeviation()` is *not* R's
+  `mad()`, which is the median absolute deviation from the median and scaled
+  by 1.4826; the name is written in full because the abbreviation covers both
+  statistics. The sampling demonstration offers the last two as choices of
+  statistic.
+* `kernelDensity()` takes `from` and `to`, R's own arguments, to fix the
+  reported window instead of taking it from the data.
+* `plotSampling()` takes `densityWindow`. The default, `"data"`, is
+  unchanged. `"frozen"` puts the grid of every curve on the drawn window,
+  which a population reaching far outside that window needs: at 512 grid
+  points over a range a thousand times the window, one step is wider than the
+  panel and the curve draws as a straight line.
+* `plotRegression()` takes `xlim` and `ylim`, R's own arguments. Both still
+  default to R's `c(-5, 50)`, and the mean crosshair clamps into a window
+  that does not contain 0.
+* The two options above reach `interactiveRegression()` and
+  `interactiveSampling()` with no work, because each interactive options type
+  extends the plot options type it forwards.
+
+### Bug fixes
+
+* The sampling histogram is bounded by the window it draws in. A statistic
+  outside the shared window is clipped from the picture, so it must not set
+  the width of the histogram's cells either: one sample mean out at 800 made
+  every cell 100 units wide and left a single flat bar in a 124-wide panel.
+  The count in the panel label still reports the whole pile.
+
+* `moderationSurface()` drops rows with missing values before fitting, as
+  R's `lm()` does with `na.action = na.omit`; it fit straight through NaN,
+  so one missing cell made every coefficient and all 225 surface heights
+  NaN. Fitted values and residuals keep input order with NaN marking the
+  dropped rows, a control is held at its finite mean (R's `hold_value()`
+  with `na.rm = TRUE`), and a model with no complete rows throws a
+  `RangeError`. One stated departure: R computes zlim with no `na.rm` and
+  fails on a missing outcome; the port draws what it fits.
+* `moderation3dSpec()` refuses a surface with a non-finite height. A NaN
+  height field crashes WebGL inside plotly.js, and the crash poisons every
+  later 3D surface on the page; the spec now throws a `RangeError` before
+  the engine can see it.
+* `plotMatrixInverse()` titles its axes `x` and `y`. R's `plot(NA, ...)`
+  deparsed its first argument into the titles, so the axes read "Index" and
+  "NA"; the port reproduced that by drawing no titles at all. R fixed it in
+  0.8.0 and this follows.
+* `linearRegression()`, `logisticRegression()`, and `principalComponents()`
+  drop points with a non-finite coordinate before fitting, as R's `na.omit`
+  does and as `moderationSurface()` already did. The first fit straight
+  through NaN, the second refused it with a `RangeError`, and the third
+  answered all-NaN components. Fitted values, linear predictors, and scores
+  keep input order with NaN marking the dropped points; an input with no
+  complete point returns null, the existing "nothing to fit" answer.
+  `logisticRegression()` no longer throws on a non-finite predictor, and its
+  0-or-1 outcome rule now applies to the complete points alone. `logitScale()`
+  ignores a non-finite predictor too, so one missing value no longer poisons
+  the whole window.
+* `scatter3dSpec()` and `moderation3dSpec()` emit scene axis titles in
+  Plotly's object form, `title: { text }`. Plotly v2 silently drops a
+  bare-string title, so no 3D plot ever showed its column names.
+  `PlotlyAxis.title` is typed to the object form for the same reason.
+
+### Other
+
+* Spelling is en-US throughout, as the R package now declares. No exported
+  name and no string a user reads changed — every correction was prose or an
+  internal identifier.
+* The package ships a LICENSE, a README and this changelog.
+* `prepublishOnly` runs the test suite, the type check and the build, so a
+  publish from a fresh clone cannot ship a stale or missing `dist/`.
+* GitHub Actions runs the tests, the type check and the build on every push
+  and pull request.
+
+## 0.1.0
+
+Tagged in git, never published to npm.
+
+The complete TypeScript port of the R package: all nine function families
+across the three layers (`core/` statistics with no DOM, `plot/` renderers,
+`interactive/` components), both bundled datasets exported from R, and a demo
+page per family. The core statistics are asserted against conformance fixtures
+computed in R.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2026 Soumya Ray
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,310 @@
+# @compstats/core
+
+[![CI](https://github.com/compstatslib/compstatslib-ts/actions/workflows/ci.yml/badge.svg)](https://github.com/compstatslib/compstatslib-ts/actions/workflows/ci.yml)
+
+Interactive gadgets and plotting functions for data sets and statistical
+concepts, in two and three dimensions. This is the browser port of the R
+package [`compstatslib`](https://github.com/compstatslib/compstatslib).
+
+Some of it works on **your own data**. Explore any data frame as a rotatable
+3D point cloud. Fit a moderated (interaction) regression and rotate its
+surface to see how the interaction twists it away from a plane. The rest
+**simulates a concept** instead of plotting your data — sampling
+distributions, confidence intervals, t-statistics, matrix inversion. That part
+is built for class demonstrations, homework, and self-study.
+
+The R original runs in RStudio. This port runs in a browser, with no R
+installation and no server. The 2D plots draw on a plain Canvas 2D context.
+The 3D plots draw through Plotly, behind a separate entry point, so a page
+that shows only 2D never loads it.
+
+## Install
+
+```bash
+npm install @compstats/core
+# or
+bun add @compstats/core
+```
+
+Plotly is only needed for the 3D functions. See
+[3D and Plotly](#3d-and-plotly) below.
+
+## Quick start
+
+Give an interactive component a canvas. It draws at once, and it redraws on
+every click.
+
+```html
+<canvas id="plot" width="640" height="480"></canvas>
+
+<script type="module">
+  import { interactiveRegression } from "@compstats/core";
+
+  const handle = interactiveRegression(document.querySelector("#plot"), {
+    onDone: (points) => console.log(points),
+  });
+
+  // Later: read the state, clear it, or stop listening.
+  handle.getPoints();
+  handle.reset();
+  handle.destroy();
+</script>
+```
+
+The plot functions draw the same picture from data you already hold, and
+return what they computed:
+
+```js
+import { plotRegression } from "@compstats/core";
+
+const fit = plotRegression(canvas, [
+  { x: 1, y: 2 },
+  { x: 2, y: 4 },
+  { x: 3, y: 5 },
+]);
+
+console.log(fit.slope, fit.rSquared);
+```
+
+The statistics are separate from the drawing. Import them alone when you want
+the numbers and not the picture:
+
+```js
+import { linearRegression, principalComponents, tTestStats } from "@compstats/core";
+```
+
+Nothing in the `core/` layer touches the DOM, so it also runs under Node or
+Bun.
+
+## Use from a CDN
+
+The main bundle is self-contained browser ESM with no imports of its own. A
+page can load it directly, with no build step:
+
+```html
+<script type="module">
+  import { interactiveTTest } from "https://esm.sh/@compstats/core";
+
+  interactiveTTest(document.querySelector("#demo"));
+</script>
+```
+
+jsDelivr and unpkg serve the same file:
+
+```js
+import { interactiveTTest } from "https://cdn.jsdelivr.net/npm/@compstats/core/dist/index.js";
+```
+
+## 3D and Plotly
+
+The 3D functions live behind the `@compstats/core/3d` entry point:
+
+```js
+import { interactiveScatter3d, moderationData } from "@compstats/core/3d";
+```
+
+That entry does not load Plotly either. It reaches the library through a
+dynamic import the first time it draws. A caller that passes its own engine in
+the `plotly` option never triggers that import:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/plotly.js-dist-min"></script>
+
+<script type="module">
+  import { interactiveScatter3d, moderationData } from "https://esm.sh/@compstats/core/3d";
+
+  const handle = interactiveScatter3d(
+    document.querySelector("#demo"),
+    moderationData,
+    { plotly: window.Plotly },
+  );
+  await handle.rendered();
+</script>
+```
+
+Pass `plotly` when you load the 3D entry from a raw file CDN such as jsDelivr,
+because nothing there resolves the bare `plotly.js-dist-min` specifier. esm.sh
+rewrites bare specifiers, so on esm.sh both ways work.
+
+## How the functions are organized
+
+Every family has three parts, and you can use any one of them alone:
+
+- a **core** function that computes the statistics and touches no DOM,
+- a **plot** function that draws it on a target you give it,
+- an **interactive** component that owns the input and hands each draw to the
+  plot function.
+
+The families are grouped below by what they are *for*, because that varies
+more than the interaction style does.
+
+### Data sets in 3D
+
+These accept any data frame, with control over axes, color mapping, aspect
+ratio, and camera. They come from `@compstats/core/3d`.
+
+| Function | What it does |
+| --- | --- |
+| `interactiveScatter3d(target, data, opts?)` | Rotatable 3D point cloud, with pickers for x / y / z and color, and sliders for aspect, opacity, and marker size. |
+| `plotScatter3d(target, data, opts?)` | The same point cloud from a fixed set of options. |
+| `interactiveModeration3d(target, data, opts)` | Fitted moderation surface as a 3D wireframe, with two rotation sliders. |
+| `plotModeration3d(target, data, opts)` | The same surface at a stated viewing angle. |
+| `moderationSurface(data, opts)` | The fit and the prediction grid behind both, as plain numbers. |
+
+### 2D relationships
+
+These plot x / y points you supply, together with a fitted model. They are
+sized for small data — points clicked in by hand, or a modest table — and not
+for arbitrary data. `plotRegression` draws in a window of -5 to 50 unless you
+give it `xlim` and `ylim`, and the PCA functions expect points with an `x` and
+a `y`.
+
+| Function | What it does |
+| --- | --- |
+| `interactiveRegression(canvas, opts?)` | Click to add points. The line, the mean crosshair, and the statistics update on every click. |
+| `plotRegression(target, points, opts?)` | The same picture from points you hold. Returns the fit. |
+| `interactiveLogit(canvas, opts?)` | Click to add points. A logistic curve and its statistics update with them. |
+| `plotLogit(target, points, opts?)` | The same picture from points you hold. |
+| `interactivePca(canvas, opts?)` | Click to add points. The two component arrows appear from the third point and turn with every point after it. |
+| `plotPca(target, points, opts?)` | The same picture, with optional mean centering. |
+| `linearRegression(points)`, `logisticRegression(points, opts?)`, `principalComponents(points)` | The three fits, without a picture. |
+
+### Simulations and concept demonstrations
+
+These do not plot your data. They simulate a process, or draw a geometric
+object, so that a concept can be watched instead of described.
+
+| Function | What it does |
+| --- | --- |
+| `interactiveTTest(container, opts?)` | Sliders for difference, standard deviation, sample size, and alpha. The null and alternative t distributions, the rejection region, and the power redraw as they move. |
+| `plotTTest(target, opts?)` | The same picture from fixed parameters. Returns the statistics. |
+| `interactiveSampling(container, population, opts?)` | Draw samples from a population and watch the sampling statistic build up across repetitions. |
+| `plotSampling(target, population, opts?)` | One draw of the three-panel picture. |
+| `plotSampleCi(target, opts?)` | Repeated samples from a distribution function, each with its confidence interval, so that coverage becomes visible. |
+| `interactiveMatrixInverse(container, opts?)` | Four sliders for the entries of a 2x2 matrix. The matrix and its inverse are drawn as parallelograms. |
+| `plotMatrixInverse(target, matrix)` | The same picture from one matrix. Returns the determinant and the inverse. |
+| `machinePrecision()` | The smallest number the runtime can add to 1. |
+
+### Statistics without a picture
+
+The R package never had to ship these. `mean()`, `sd()`, `quantile()`, `dt()`,
+`rnorm()`, `density()`, `hist()`, `pretty()`, `solve()` and `lm.fit()` are all
+in base R, and its functions call them. JavaScript has no statistics standard
+library, so the port wrote them — and exports them, because an application
+built on this package needs them for the same reason the package did.
+
+| Group | Functions |
+| --- | --- |
+| Descriptives | `mean`, `median`, `sd`, `quantile`, `quantiles`, `meanAbsoluteDeviation` |
+| Student t distribution | `dt`, `pt`, `qt`, with the `normalCdf`, `incompleteBeta` and `inverseIncompleteBeta` they stand on |
+| Seeded random draws | `seededRng`, `runif`, `rnorm`, `rt`, `rlnorm`, `rcauchy`, `sampleWithoutReplacement` |
+| Binning and density | `histogram`, `nclassSturges`, `kernelDensity`, `bwNrd0` |
+| Axis ticks | `rPretty`, `prettyTicks` |
+| Linear algebra | `leastSquares`, `determinant`, `invertMatrix` |
+
+Each one follows its R counterpart, down to the rule and the argument names:
+`quantile` is type 7, `nclassSturges` is Sturges' rule, `bwNrd0` is R's
+`nrd0` bandwidth, `rPretty` is `pretty()`, and the samplers take R's own
+parameters. The test suite pins them to values computed in R.
+
+The draws take a generator you pass in, so a demonstration repeats exactly:
+
+```js
+import { seededRng, rnorm, quantile } from "@compstats/core";
+
+const rng = seededRng(42);
+const draws = rnorm(rng, 1000, { mean: 100, sd: 15 });
+quantile(draws, 0.975);
+```
+
+### Bundled data
+
+`moderationData` (200 rows of `y`, `x`, `z`, `w`) and `pcaDegenerate` (16 rows
+of `x`, `y`) are the same tables as in the R package, exported from R rather
+than regenerated. Both are defaults, so a call with no data still gives a
+working demonstration.
+
+### Targets
+
+The click-to-add-points components take a `<canvas>`. The components that own
+sliders or menus take a container element and build their controls inside it.
+Each one also accepts an explicit `{ surface, element }` pair when you want to
+place the drawing surface and the controls yourself.
+
+## Reproducing an interactive session
+
+R's gadgets block until you click Done, and then print the `plot_*()` call
+that reproduces the screen. Nothing blocks in a browser. Each component
+returns a handle at once, and the handle carries the same state:
+
+```js
+const handle = interactiveTTest(container);
+
+handle.getValues(); // the state that reproduces the picture
+handle.getStats(); // what the last draw computed
+handle.done(); // hand the state to the onDone callback
+handle.destroy(); // stop listening and remove what was built
+```
+
+`getValues()` returns the options that draw the same picture again. Pass them
+straight back to the matching plot function, or to the component itself. State
+you would not retype has its own accessor: `getFit()` for PCA, `getState()`
+for the accumulated sampling draws, `getSpec()` for the traces and layout of a
+3D draw.
+
+## Differences from the R package
+
+The two packages compute the same statistics and draw the same pictures. The
+R idioms that a browser has no answer for are handled like this:
+
+- **Names.** `snake_case` becomes `camelCase`. `plot_regr()` is
+  `plotRegression()`, as it is in R since 0.8.0.
+- **Signatures.** R's positional arguments and `...` become a data argument
+  and one options object.
+- **Formulas.** `y ~ x * z` has no TypeScript counterpart. Name the columns
+  instead: `{ outcome: "y", iv: "x", mod: "z" }`.
+- **Data frames.** Point sets are arrays of records. Bundled tables are
+  objects of columns.
+- **Random numbers.** Draws take an injectable seeded generator, so a demo
+  repeats exactly. The stream does not match R's Mersenne Twister, and it is
+  not meant to.
+- **Devices.** Every plot function takes an explicit target. There is no
+  current device.
+
+One thing the port adds. It exports the statistical primitives that base R
+hands the R package for free — descriptives, the t distribution, seeded
+samplers, binning, density, axis ticks and small linear algebra, listed under
+[Statistics without a picture](#statistics-without-a-picture). This is an
+addition, not a divergence: each one follows its R counterpart's rule and is
+tested against R's output.
+
+The core statistics are asserted against values computed in R. The fixtures
+live in the R package under `conformance-fixtures/`.
+
+## Development
+
+```bash
+bun install
+bun test
+bun run typecheck
+bun run build
+bun run dev      # demo site on http://localhost:3000
+```
+
+Bun is the toolchain: runtime, package manager, test runner, and bundler. The
+demo site runs one page per function family and is the fastest way to see a
+change.
+
+## Contributors
+
+`@compstats/core` and `compstatslib` are maintained by Soumya Ray.
+
+Daniele Melotti is a co-author of the R package. Several of the plotting and
+interactive functions grew out of work he did as a student under Soumya Ray's
+supervision, and were then folded back into the package.
+
+Issues and pull requests are welcome.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/dist/3d.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The 3D entry point: `@compstats/core/3d`.
+ *
+ * The two 3D families of the R package draw through Plotly.js, which is four
+ * megabytes of browser code. They therefore live behind this entry rather than
+ * the main one, so that a page that draws only 2D plots never loads them.
+ *
+ * Nothing here loads Plotly either. `loadPlotly()` reaches the library through
+ * a dynamic import, which runs the first time a plot is drawn; a caller who
+ * passes its own engine through the `plotly` option never triggers it at all.
+ *
+ * The core statistics and the bundled data of the 3D families are re-exported
+ * here, so that one import covers a 3D page.
+ */
+export { loadPlotly } from "./plot/plotly";
+export type { EyeCamera, PlotlyAxis, PlotlyCamera, PlotlyConfig, PlotlyHTMLElement, PlotlyLayout, PlotlyLike, PlotlyRelayoutEvent, PlotlyRelayoutUpdate, PlotlyScene, PlotlyTrace, Scatter3dMarker, Scatter3dTrace, SurfaceTrace, Vector3, } from "./plot/plotly";
+export { DEFAULT_SCATTER3D_STYLE, plotScatter3d, scatter3dSpec, validateScatter3dStyle, } from "./plot/scatter3d";
+export type { PlotScatter3dOptions, Scatter3dHandle, Scatter3dSpec, Scatter3dSpecOptions, Scatter3dStyle, Scatter3dTitles, } from "./plot/scatter3d";
+export { interactiveScatter3d } from "./interactive/scatter3d";
+export type { InteractiveScatter3dHandle, InteractiveScatter3dOptions, Scatter3dValues, } from "./interactive/scatter3d";
+export { interactiveModeration3d } from "./interactive/moderation3d";
+export type { InteractiveModeration3dHandle, InteractiveModeration3dOptions, Moderation3dValues, } from "./interactive/moderation3d";
+export { resolvePlot3dTarget } from "./interactive/target";
+export type { Plot3dPanel, Plot3dTarget, ResolvedPlot3dPanel, } from "./interactive/target";
+export { cameraFromRotations, moderation3dSpec, plotModeration3d, } from "./plot/moderation3d";
+export type { Moderation3dHandle, Moderation3dSpec, Moderation3dViewOptions, PlotModeration3dOptions, } from "./plot/moderation3d";
+export { moderationSurface } from "./core/moderation";
+export type { ModerationOptions, ModerationSurface, ModerationTerm, } from "./core/moderation";
+export { frameRows, isNumericColumn, numericColumns, requireNumericColumn, requireThreeNumericColumns, } from "./core/frame";
+export type { Column, DataFrame } from "./core/frame";
+export { moderationData } from "./data/moderationData";
+export type { ModerationData } from "./data/moderationData";
+//# sourceMappingURL=3d.d.ts.map

package/dist/3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"3d.d.ts","sourceRoot":"","sources":["../src/3d.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,YAAY,EACV,SAAS,EACT,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,EACX,WAAW,EACX,eAAe,EACf,cAAc,EACd,YAAY,EACZ,OAAO,GACR,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,uBAAuB,EACvB,aAAa,EACb,aAAa,EACb,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,oBAAoB,EACpB,cAAc,EACd,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAC/D,YAAY,EACV,0BAA0B,EAC1B,2BAA2B,EAC3B,eAAe,GAChB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AACrE,YAAY,EACV,6BAA6B,EAC7B,8BAA8B,EAC9B,kBAAkB,GACnB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,YAAY,EACV,WAAW,EACX,YAAY,EACZ,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,SAAS,EACT,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}