svelteplot 0.4.6 → 0.4.7-pr-216.0

package/dist/marks/DifferenceY.svelte.d.ts

@@ -1,83 +1,23 @@
 import type { ChannelAccessor, CurveName, DataRecord } from '../types/index.js';
 import type { CurveFactory } from 'd3-shape';
 declare class __sveltets_Render<Datum extends DataRecord> {
-    props(): Omit<Partial<{
-        filter?: import("../types/index.js").ConstantAccessor<boolean, Datum>;
-        facet?: "auto" | "include" | "exclude";
-        fx: ChannelAccessor<Datum>;
-        fy: ChannelAccessor<Datum>;
-        dx: import("../types/index.js").ConstantAccessor<number, Datum>;
-        dy: import("../types/index.js").ConstantAccessor<number, Datum>;
-        fill: ChannelAccessor<Datum>;
-        fillOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
-        sort: {
-            channel: string;
-            order?: "ascending" | "descending";
-        } | ((a: import("../types/index.js").RawValue, b: import("../types/index.js").RawValue) => number) | import("../types/index.js").ConstantAccessor<import("../types/index.js").RawValue, Datum>;
-        stroke: ChannelAccessor<Datum>;
-        strokeWidth: import("../types/index.js").ConstantAccessor<number, Datum>;
-        strokeOpacity: import("../types/index.js").ConstantAccessor<number, Datum>;
-        strokeLinejoin: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
-        strokeLinecap: import("../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
-        strokeMiterlimit: import("../types/index.js").ConstantAccessor<number, Datum>;
-        opacity: ChannelAccessor<Datum>;
-        strokeDasharray: import("../types/index.js").ConstantAccessor<string, Datum>;
-        strokeDashoffset: import("../types/index.js").ConstantAccessor<number, Datum>;
-        mixBlendMode: import("../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Datum>;
-        clipPath: string;
-        imageFilter: import("../types/index.js").ConstantAccessor<string, Datum>;
-        shapeRendering: import("../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
-        paintOrder: import("../types/index.js").ConstantAccessor<string, Datum>;
-        onclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondblclick?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseup?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmousedown?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmousemove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseout?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onmouseover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointercancel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerdown?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerup?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointermove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onpointerout?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondrag?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondrop?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragstart?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragenter?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragleave?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragover?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ondragend?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchstart?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchmove?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchend?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        ontouchcancel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        oncontextmenu?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        onwheel?: import("svelte/elements").MouseEventHandler<SVGPathElement>;
-        class?: string;
-        style?: string;
-        cursor: import("../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Datum>;
-    }>, "fill" | "fillOpacity"> & {
+    props(): Omit<BaseMarkProps<Datum_1>, "fill" | "fillOpacity"> & {
         data: Datum[];
-        x1: ChannelAccessor<Datum>;
+        x1: ChannelAccessor<Datum_1>;
         /**
          * the horizontal position of the metric; bound to the x scale
          */
-        x2: ChannelAccessor<Datum>;
-        x: ChannelAccessor<Datum>;
+        x2: ChannelAccessor<Datum_1>;
+        x: ChannelAccessor<Datum_1>;
         /**
          * the vertical position of the comparison; bound to the y scale
          */
-        y1: ChannelAccessor<Datum>;
+        y1: ChannelAccessor<Datum_1>;
         /**
          * the vertical position of the metric; bound to the y scale
          */
-        y2: ChannelAccessor<Datum>;
-        y: ChannelAccessor<Datum>;
+        y2: ChannelAccessor<Datum_1>;
+        y: ChannelAccessor<Datum_1>;
         fillOpacity?: number;
         /**
          * the stroke color of the "positive" area; defaults to 'blue'

package/dist/marks/Line.svelte.d.ts

@@ -14,7 +14,7 @@ declare class __sveltets_Render<Datum extends DataRecord> {
         sort: {
             channel: string;
             order?: "ascending" | "descending";
-        } | ((a: RawValue, b: RawValue) => number) | ConstantAccessor<RawValue, Datum>;
+        } | ((a: import("../types/data.js").RawValue, b: import("../types/data.js").RawValue) => number) | ConstantAccessor<import("../types/data.js").RawValue, Datum>;
         stroke: ChannelAccessor<Datum>;
         strokeWidth: ConstantAccessor<number, Datum>;
         strokeOpacity: ConstantAccessor<number, Datum>;
@@ -72,7 +72,7 @@ declare class __sveltets_Render<Datum extends DataRecord> {
         outlineStrokeOpacity?: number;
         curve?: CurveName | CurveFactory | "auto";
         tension?: number;
-        sort?: ConstantAccessor<RawValue, Datum> | {
+        sort?: ConstantAccessor<RawValue, Datum_1> | {
             channel: "stroke" | "fill";
         };
         text?: ConstantAccessor<string, Datum>;

package/dist/marks/LineX.svelte.d.ts

@@ -1,3 +1,4 @@
+import { recordizeX } from '../index.js';
 import type { DataRow } from '../index.js';
 declare class __sveltets_Render<Datum extends DataRow> {
     props(): Omit<import("../types").MarkerOptions & Partial<{
@@ -70,7 +71,7 @@ declare class __sveltets_Render<Datum extends DataRow> {
         outlineStrokeOpacity?: number;
         curve?: import("../types").CurveName | import("d3-shape").CurveFactory | "auto";
         tension?: number;
-        sort?: import("../types").ConstantAccessor<import("../types").RawValue, Record<string | symbol, import("../types").RawValue>> | {
+        sort?: import("../types").ConstantAccessor<recordizeX, Datum_1> | {
             channel: "stroke" | "fill";
         };
         text?: import("../types").ConstantAccessor<string, Record<string | symbol, import("../types").RawValue>>;

package/dist/marks/LineY.svelte.d.ts

@@ -1,3 +1,4 @@
+import { recordizeY } from '../index.js';
 import type { DataRow } from '../index.js';
 declare class __sveltets_Render<Datum extends DataRow> {
     props(): Omit<import("../types").MarkerOptions & Partial<{
@@ -70,7 +71,7 @@ declare class __sveltets_Render<Datum extends DataRow> {
         outlineStrokeOpacity?: number;
         curve?: import("../types").CurveName | import("d3-shape").CurveFactory | "auto";
         tension?: number;
-        sort?: import("../types").ConstantAccessor<import("../types").RawValue, Record<string | symbol, import("../types").RawValue>> | {
+        sort?: import("../types").ConstantAccessor<recordizeY, Datum_1> | {
             channel: "stroke" | "fill";
         };
         text?: import("../types").ConstantAccessor<string, Record<string | symbol, import("../types").RawValue>>;

package/dist/marks/helpers/CanvasLayer.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
     import { getContext } from 'svelte';
-    import type { PlotContext } from '../../index.js';
+    import type { PlotContext } from '../../types/plot';
     import { devicePixelRatio } from 'svelte/reactivity/window';
     import { MediaQuery } from 'svelte/reactivity';
     import type { Attachment } from 'svelte/attachments';

package/dist/marks/helpers/RectPath.svelte.d.ts

@@ -1,75 +1,15 @@
-import type { BaseRectMarkProps } from '../../types/mark.js';
+import type { BaseMarkProps, BaseRectMarkProps } from '../../types/mark.js';
 import type { DataRecord, ScaledDataRecord } from '../../types/data.js';
 import type { UsedScales } from '../../types/index.js';
 declare class __sveltets_Render<Datum extends DataRecord> {
     props(): {
-        datum: ScaledDataRecord<Datum>;
+        datum: ScaledDataRecord<Datum_1>;
         class: string | null;
         x: number;
         y: number;
         width: number;
         height: number;
-        options: BaseRectMarkProps<Datum> & Partial<{
-            filter?: import("../../types/index.js").ConstantAccessor<boolean, Datum>;
-            facet?: "auto" | "include" | "exclude";
-            fx: import("../../types/index.js").ChannelAccessor<Datum>;
-            fy: import("../../types/index.js").ChannelAccessor<Datum>;
-            dx: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            dy: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            fill: import("../../types/index.js").ChannelAccessor<Datum>;
-            fillOpacity: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            sort: {
-                channel: string;
-                order?: "ascending" | "descending";
-            } | ((a: import("../../types/data.js").RawValue, b: import("../../types/data.js").RawValue) => number) | import("../../types/index.js").ConstantAccessor<import("../../types/data.js").RawValue, Datum>;
-            stroke: import("../../types/index.js").ChannelAccessor<Datum>;
-            strokeWidth: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            strokeOpacity: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            strokeLinejoin: import("../../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinejoin, Datum>;
-            strokeLinecap: import("../../types/index.js").ConstantAccessor<import("csstype").Property.StrokeLinecap, Datum>;
-            strokeMiterlimit: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            opacity: import("../../types/index.js").ChannelAccessor<Datum>;
-            strokeDasharray: import("../../types/index.js").ConstantAccessor<string, Datum>;
-            strokeDashoffset: import("../../types/index.js").ConstantAccessor<number, Datum>;
-            mixBlendMode: import("../../types/index.js").ConstantAccessor<import("csstype").Property.MixBlendMode, Datum>;
-            clipPath: string;
-            imageFilter: import("../../types/index.js").ConstantAccessor<string, Datum>;
-            shapeRendering: import("../../types/index.js").ConstantAccessor<import("csstype").Property.ShapeRendering, Datum>;
-            paintOrder: import("../../types/index.js").ConstantAccessor<string, Datum>;
-            onclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondblclick?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmousedown?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmousemove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseout?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onmouseover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointercancel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerdown?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerup?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointermove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onpointerout?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondrag?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondrop?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragstart?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragenter?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragleave?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragover?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ondragend?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ontouchstart?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ontouchmove?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ontouchend?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            ontouchcancel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            oncontextmenu?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            onwheel?: import("svelte/elements.js").MouseEventHandler<SVGPathElement>;
-            class?: string;
-            style?: string;
-            cursor: import("../../types/index.js").ConstantAccessor<import("csstype").Property.Cursor, Datum>;
-        }>;
+        options: BaseRectMarkProps<Datum_1> & BaseMarkProps<Datum_1>;
         /**
          * By default, the `inset` property is applied to all four insets. Mark components
          * can tweak this behavior for insetTop and insetBottom by setting the

package/dist/marks/helpers/Regression.svelte

@@ -43,7 +43,7 @@
         regressionLog,
         regressionPow,
         regressionLoess
-    } from '@gka/d3-regression';
+    } from '../../regression/index.js';
     import { resolveChannel } from '../../helpers/resolve.js';
     import { confidenceInterval } from '../../helpers/math.js';
     import callWithProps from '../../helpers/callWithProps.js';

package/dist/regression/exponential.d.ts

@@ -0,0 +1,17 @@
+import type { PredictFunction, Domain, DataPoint, Accessor } from './types.js';
+export type ExponentialOutput = [DataPoint, DataPoint] & {
+    a: number;
+    b: number;
+    predict: PredictFunction;
+    rSquared: number;
+};
+export interface ExponentialRegression<T> {
+    (data: T[]): ExponentialOutput;
+    domain(): Domain;
+    domain(arr: Domain): this;
+    x(): Accessor<T>;
+    x(fn: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(fn: Accessor<T>): this;
+}
+export default function exponential<T = DataPoint>(): ExponentialRegression<T>;

package/dist/regression/exponential.js

@@ -0,0 +1,56 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import { determination } from './utils/determination.js';
+import { interpose } from './utils/interpose.js';
+import { ols } from './utils/ols.js';
+import { visitPoints } from './utils/points.js';
+export default function exponential() {
+    let y = (d) => d[1], x = (d) => d[0], domain;
+    const exponentialRegression = function (data) {
+        let n = 0, Y = 0, YL = 0, XY = 0, XYL = 0, X2Y = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
+        visitPoints(data, x, y, (dx, dy) => {
+            const ly = Math.log(dy), xy = dx * dy;
+            ++n;
+            Y += (dy - Y) / n;
+            XY += (xy - XY) / n;
+            X2Y += (dx * xy - X2Y) / n;
+            YL += (dy * ly - YL) / n;
+            XYL += (xy * ly - XYL) / n;
+            if (!domain) {
+                if (dx < xmin)
+                    xmin = dx;
+                if (dx > xmax)
+                    xmax = dx;
+            }
+        });
+        let [a, b] = ols(XY / Y, YL / Y, XYL / Y, X2Y / Y);
+        a = Math.exp(a);
+        const fn = (xx) => a * Math.exp(b * xx);
+        const out = interpose(xmin, xmax, fn);
+        out.a = a;
+        out.b = b;
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, Y, fn);
+        return out;
+    };
+    exponentialRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return exponentialRegression;
+    };
+    exponentialRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return exponentialRegression;
+    };
+    exponentialRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return exponentialRegression;
+    };
+    return exponentialRegression;
+}

package/dist/regression/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+export { default as regressionLinear } from './linear.js';
+export { default as regressionPoly } from './polynomial.js';
+export { default as regressionExp } from './exponential.js';
+export { default as regressionLog } from './logarithmic.js';
+export { default as regressionPow } from './power.js';
+export { default as regressionQuad } from './quadratic.js';
+export { default as regressionLoess } from './loess.js';

package/dist/regression/index.js

@@ -0,0 +1,10 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+export { default as regressionLinear } from './linear.js';
+export { default as regressionPoly } from './polynomial.js';
+export { default as regressionExp } from './exponential.js';
+export { default as regressionLog } from './logarithmic.js';
+export { default as regressionPow } from './power.js';
+export { default as regressionQuad } from './quadratic.js';
+export { default as regressionLoess } from './loess.js';

package/dist/regression/linear.d.ts

@@ -0,0 +1,17 @@
+import type { PredictFunction, Accessor, DataPoint, Domain } from './types.js';
+export type LinearOutput = [DataPoint, DataPoint] & {
+    a: number;
+    b: number;
+    predict: PredictFunction;
+    rSquared: number;
+};
+export interface LinearRegression<T> {
+    (data: T[]): LinearOutput;
+    domain(): Domain;
+    domain(arr: Domain): this;
+    x(): Accessor<T>;
+    x(fn: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(fn: Accessor<T>): this;
+}
+export default function linear<T = DataPoint>(): LinearRegression<T>;

package/dist/regression/linear.js

@@ -0,0 +1,59 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import { determination } from './utils/determination.js';
+import { ols } from './utils/ols.js';
+import { visitPoints } from './utils/points.js';
+export default function linear() {
+    let x = (d) => d[0], y = (d) => d[1], domain;
+    const linearRegression = function (data) {
+        let n = 0, X = 0, // sum of x
+        Y = 0, // sum of y
+        XY = 0, // sum of x*y
+        X2 = 0, // sum of x*x
+        xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity;
+        visitPoints(data, x, y, (dx, dy) => {
+            ++n;
+            X += (dx - X) / n;
+            Y += (dy - Y) / n;
+            XY += (dx * dy - XY) / n;
+            X2 += (dx * dx - X2) / n;
+            if (!domain) {
+                if (dx < xmin)
+                    xmin = dx;
+                if (dx > xmax)
+                    xmax = dx;
+            }
+        });
+        const [intercept, slope] = ols(X, Y, XY, X2);
+        const fn = (xx) => slope * xx + intercept;
+        const out = [
+            [xmin, fn(xmin)],
+            [xmax, fn(xmax)]
+        ];
+        out.a = slope;
+        out.b = intercept;
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, Y, fn);
+        return out;
+    };
+    linearRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return linearRegression;
+    };
+    linearRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return linearRegression;
+    };
+    linearRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return linearRegression;
+    };
+    return linearRegression;
+}

package/dist/regression/loess.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import type { Accessor, DataPoint } from './types.js';
+export interface LoessRegression<T> {
+    (data: T[]): DataPoint[];
+    bandwidth(): number;
+    bandwidth(bw: number): this;
+    x(): Accessor<T>;
+    x(fn: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(fn: Accessor<T>): this;
+}
+export default function loess<T = DataPoint>(): LoessRegression<T>;

package/dist/regression/loess.js

@@ -0,0 +1,122 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+// Adapted from science.js by Jason Davies
+// License: https://github.com/jasondavies/science.js/blob/master/LICENSE
+// Source: https://github.com/jasondavies/science.js/blob/master/src/stats/loess.js
+// Adapted from vega-statistics by Jeffrey Heer
+// License: https://github.com/vega/vega/blob/f058b099decad9db78301405dd0d2e9d8ba3d51a/LICENSE
+// Source: https://github.com/vega/vega/blob/f21cb8792b4e0cbe2b1a3fd44b0f5db370dbaadb/packages/vega-statistics/src/regression/loess.js
+import { median } from './utils/median.js';
+import { ols } from './utils/ols.js';
+import { points } from './utils/points.js';
+const maxiters = 2, epsilon = 1e-12;
+export default function loess() {
+    let x = (d) => d[0], y = (d) => d[1], bandwidth = 0.3;
+    const loessRegression = function loessRegression(data) {
+        const [xv, yv, ux, uy] = points(data, (dd) => x(dd), (dd) => y(dd), true);
+        const n = xv.length;
+        const bw = Math.max(2, ~~(bandwidth * n)); // # of nearest neighbors
+        const yhat = new Float64Array(n);
+        const residuals = new Float64Array(n);
+        const robustWeights = new Float64Array(n).fill(1);
+        for (let iter = -1; ++iter <= maxiters;) {
+            const interval = [0, bw - 1];
+            for (let i = 0; i < n; ++i) {
+                const dx = xv[i];
+                const i0 = interval[0];
+                const i1 = interval[1];
+                const edge = dx - xv[i0] > xv[i1] - dx ? i0 : i1;
+                let W = 0, X = 0, Y = 0, XY = 0, X2 = 0;
+                const denom = 1 / Math.abs(xv[edge] - dx || 1);
+                for (let k = i0; k <= i1; ++k) {
+                    const xk = xv[k];
+                    const yk = yv[k];
+                    const w = tricube(Math.abs(dx - xk) * denom) * robustWeights[k];
+                    const xkw = xk * w;
+                    W += w;
+                    X += xkw;
+                    Y += yk * w;
+                    XY += yk * xkw;
+                    X2 += xk * xkw;
+                }
+                // Linear regression fit
+                const [a, b] = ols(X / W, Y / W, XY / W, X2 / W);
+                yhat[i] = a + b * dx;
+                residuals[i] = Math.abs(yv[i] - yhat[i]);
+                updateInterval(xv, i + 1, interval);
+            }
+            if (iter === maxiters) {
+                break;
+            }
+            const medianResidual = median(residuals);
+            if (Math.abs(medianResidual) < epsilon)
+                break;
+            for (let i = 0, arg, w; i < n; ++i) {
+                arg = residuals[i] / (6 * medianResidual);
+                // Default to epsilon (rather than zero) for large deviations
+                // Keeping weights tiny but non-zero prevents singularites
+                robustWeights[i] = arg >= 1 ? epsilon : (w = 1 - arg * arg) * w;
+            }
+        }
+        return output(xv, yhat, ux, uy);
+    };
+    loessRegression.bandwidth = function (bw) {
+        if (!arguments.length)
+            return bandwidth;
+        bandwidth = bw;
+        return loessRegression;
+    };
+    loessRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return loessRegression;
+    };
+    loessRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return loessRegression;
+    };
+    return loessRegression;
+}
+// Weighting kernel for local regression
+function tricube(x) {
+    return (x = 1 - x * x * x) * x * x;
+}
+// Advance sliding window interval of nearest neighbors
+function updateInterval(xv, i, interval) {
+    let val = xv[i], left = interval[0], right = interval[1] + 1;
+    if (right >= xv.length)
+        return;
+    // Step right if distance to new right edge is <= distance to old left edge
+    // Step when distance is equal to ensure movement over duplicate x values
+    while (i > left && xv[right] - val <= val - xv[left]) {
+        interval[0] = ++left;
+        interval[1] = right;
+        ++right;
+    }
+}
+// Generate smoothed output points
+// Average points with repeated x values
+function output(xv, yhat, ux, uy) {
+    const n = xv.length, out = [];
+    let i = 0, cnt = 0, prev = [], v;
+    for (; i < n; ++i) {
+        v = xv[i] + ux;
+        if (prev[0] === v) {
+            // Average output values via online update
+            prev[1] += (yhat[i] - prev[1]) / ++cnt;
+        }
+        else {
+            // Add new output point
+            cnt = 0;
+            prev[1] += uy;
+            prev = [v, yhat[i]];
+            out.push(prev);
+        }
+    }
+    prev[1] += uy;
+    return out;
+}

package/dist/regression/logarithmic.d.ts

@@ -0,0 +1,20 @@
+import type { PredictFunction, DataPoint, Accessor, Domain } from './types.js';
+type LogarithmicOutput = [DataPoint, DataPoint] & {
+    a: number;
+    b: number;
+    predict: PredictFunction;
+    rSquared: number;
+};
+export interface LogarithmicRegression<T> {
+    (data: T[]): LogarithmicOutput;
+    domain(): Domain;
+    domain(arr: Domain): this;
+    x(): Accessor<T>;
+    x(fn: Accessor<T>): this;
+    y(): Accessor<T>;
+    y(fn: Accessor<T>): this;
+    base(): number;
+    base(b: number): this;
+}
+export default function logarithmic<T = DataPoint>(): LogarithmicRegression<T>;
+export {};

package/dist/regression/logarithmic.js

@@ -0,0 +1,60 @@
+/**
+ * Adapted from https://github.com/HarryStevens/d3-regression
+ */
+import { determination } from './utils/determination.js';
+import { interpose } from './utils/interpose.js';
+import { ols } from './utils/ols.js';
+import { visitPoints } from './utils/points.js';
+export default function logarithmic() {
+    let x = (d) => d[0], y = (d) => d[1], base = Math.E, domain;
+    const logarithmicRegression = function (data) {
+        let n = 0, X = 0, Y = 0, XY = 0, X2 = 0, xmin = domain ? +domain[0] : Infinity, xmax = domain ? +domain[1] : -Infinity, lb = Math.log(base);
+        visitPoints(data, x, y, (dx, dy) => {
+            const lx = Math.log(dx) / lb;
+            ++n;
+            X += (lx - X) / n;
+            Y += (dy - Y) / n;
+            XY += (lx * dy - XY) / n;
+            X2 += (lx * lx - X2) / n;
+            if (!domain) {
+                if (dx < xmin)
+                    xmin = dx;
+                if (dx > xmax)
+                    xmax = dx;
+            }
+        });
+        const [intercept, slope] = ols(X, Y, XY, X2);
+        const fn = (xx) => (slope * Math.log(xx)) / lb + intercept;
+        const out = interpose(xmin, xmax, fn);
+        out.a = slope;
+        out.b = intercept;
+        out.predict = fn;
+        out.rSquared = determination(data, x, y, Y, fn);
+        return out;
+    };
+    logarithmicRegression.domain = function (arr) {
+        if (!arguments.length)
+            return domain;
+        domain = arr;
+        return logarithmicRegression;
+    };
+    logarithmicRegression.x = function (fn) {
+        if (!arguments.length)
+            return x;
+        x = fn;
+        return logarithmicRegression;
+    };
+    logarithmicRegression.y = function (fn) {
+        if (!arguments.length)
+            return y;
+        y = fn;
+        return logarithmicRegression;
+    };
+    logarithmicRegression.base = function (b) {
+        if (!arguments.length)
+            return base;
+        base = b;
+        return logarithmicRegression;
+    };
+    return logarithmicRegression;
+}