svelteplot 0.0.1-alpha.9 → 0.1.3-next.3

package/dist/helpers/curves.js

@@ -0,0 +1,42 @@
+import { curveBasis, curveBasisClosed, curveBasisOpen, curveBundle, curveBumpX, curveBumpY, curveCardinal, curveCardinalClosed, curveCardinalOpen, curveCatmullRom, curveCatmullRomClosed, curveCatmullRomOpen, curveLinear, curveLinearClosed, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore } from 'd3-shape';
+const curves = new Map([
+    ['basis', curveBasis],
+    ['basis-closed', curveBasisClosed],
+    ['basis-open', curveBasisOpen],
+    ['bundle', curveBundle],
+    ['bump-x', curveBumpX],
+    ['bump-y', curveBumpY],
+    ['cardinal', curveCardinal],
+    ['cardinal-closed', curveCardinalClosed],
+    ['cardinal-open', curveCardinalOpen],
+    ['catmull-rom', curveCatmullRom],
+    ['catmull-rom-closed', curveCatmullRomClosed],
+    ['catmull-rom-open', curveCatmullRomOpen],
+    ['linear', curveLinear],
+    ['linear-closed', curveLinearClosed],
+    ['monotone-x', curveMonotoneX],
+    ['monotone-y', curveMonotoneY],
+    ['natural', curveNatural],
+    ['step', curveStep],
+    ['step-after', curveStepAfter],
+    ['step-before', curveStepBefore]
+]);
+export function maybeCurve(curve = curveLinear, tension) {
+    if (typeof curve === 'function')
+        return curve; // custom curve
+    const c = curves.get(`${curve}`.toLowerCase());
+    if (!c)
+        throw new Error(`unknown curve: ${curve}`);
+    if (tension !== undefined) {
+        if ('beta' in c) {
+            return c.beta(tension);
+        }
+        else if ('tension' in c) {
+            return c.tension(tension);
+        }
+        else if ('alpha' in c) {
+            return c.alpha(tension);
+        }
+    }
+    return c;
+}

package/dist/helpers/data.d.ts

@@ -0,0 +1,9 @@
+type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+export declare function loadJSON(fetch: Fetch, dataset: string): Promise<any>;
+/**
+ * helper function used in the SveltePlot docs to load example datasets
+ */
+export declare function loadDatasets(ids: string[], fetch: Fetch): Promise<{
+    [key: string]: any[];
+}>;
+export {};

package/dist/helpers/data.js

@@ -0,0 +1,16 @@
+import { csvParse, autoType } from 'd3-dsv';
+async function loadCSV(fetch, dataset) {
+    const res = await fetch(`/data/${dataset}.csv`);
+    const text = await res.text();
+    return csvParse(text, autoType);
+}
+export async function loadJSON(fetch, dataset) {
+    const res = await fetch(`/data/${dataset}.json`);
+    return await res.json();
+}
+/**
+ * helper function used in the SveltePlot docs to load example datasets
+ */
+export async function loadDatasets(ids, fetch) {
+    return Object.fromEntries((await Promise.all(ids.map((id) => loadCSV(fetch, id)))).map((data, i) => [ids[i], data]));
+}

package/dist/helpers/facets.d.ts

@@ -0,0 +1,12 @@
+import type { GenericMarkOptions, Mark, RawValue } from '../types.js';
+/**
+ * This function tracks which facets are "empty", meaning that they don't contain
+ * any "facetted" data points. This can happen when fx and fy are combined and
+ * certain combinations don't yield results.
+ *
+ * @param marks
+ * @param fxValues x facet domain
+ * @param fyValues y facet domain
+ * @returns
+ */
+export declare function getEmptyFacets(marks: Mark<GenericMarkOptions>[], fxValues: RawValue[], fyValues: RawValue[]): Map<RawValue, Map<RawValue, boolean>>;

package/dist/helpers/facets.js

@@ -0,0 +1,49 @@
+import { resolveChannel } from './resolve.js';
+/**
+ * This function tracks which facets are "empty", meaning that they don't contain
+ * any "facetted" data points. This can happen when fx and fy are combined and
+ * certain combinations don't yield results.
+ *
+ * @param marks
+ * @param fxValues x facet domain
+ * @param fyValues y facet domain
+ * @returns
+ */
+export function getEmptyFacets(marks, fxValues, fyValues) {
+    const facettedMarks = marks.filter((mark) => {
+        return (mark.options.__firstFacet &&
+            mark.data.length > 0 && // has data
+            !mark.options.automatic && // not an automatic mark
+            (fxValues.length === 1 || mark.options.fx != null) && // uses x faceting
+            (fyValues.length === 1 || mark.options.fy != null) // uses y faceting
+        );
+    });
+    const facettedData = facettedMarks
+        .map((mark) => mark.data.map((datum) => {
+        const fx = resolveChannel('fx', datum, mark.options);
+        const fy = resolveChannel('fy', datum, mark.options);
+        return {
+            fx,
+            fy
+        };
+    }))
+        .flat(1);
+    const out = new Map();
+    for (const fx of fxValues) {
+        out.set(fx, new Map());
+        for (const fy of fyValues) {
+            // we need to loop over all facetted marks to see if there's any which has
+            // no data for the current fx,fy combination
+            let hasFacettedData = fxValues.length === 1 || fyValues.length === 1;
+            for (const datum of facettedData) {
+                if (datum.fx === fx && datum.fy === fy) {
+                    hasFacettedData = true;
+                    break;
+                }
+            }
+            out.get(fx)?.set(fy, !hasFacettedData);
+        }
+    }
+    return out;
+}
+// TODO: write unit tests

package/dist/helpers/formats.d.ts

@@ -0,0 +1,3 @@
+type MonthFormatOption = 'numeric' | '2-digit' | 'narrow' | 'short' | 'long';
+export declare function formatMonth(locale: string, format?: MonthFormatOption): (month: number) => string;
+export {};

package/dist/helpers/formats.js

@@ -0,0 +1,3 @@
+export function formatMonth(locale, format = 'long') {
+    return (month) => new Intl.DateTimeFormat(locale, { month: format }).format(new Date(2000, month, 1));
+}

package/dist/helpers/getBaseStyles.d.ts

@@ -1,2 +1,7 @@
-import type { ChannelAccessor, MarkStyleProps, DataRow } from '../types.js';
-export default function (datum: DataRow, props: Partial<Record<MarkStyleProps, ChannelAccessor>>): string;
+import type { Channels } from '../types.js';
+import type { DataRow } from '../types.js';
+export declare function getBaseStylesObject(datum: DataRow, props: Partial<Channels>): {
+    [k: string]: string | number;
+};
+export default function (datum: DataRow, props: Partial<Channels>): string;
+export declare function maybeToPixel(cssKey: string, value: string | number): string | number;

package/dist/helpers/getBaseStyles.js

@@ -1,18 +1,42 @@
-import { MARK_PROP_CHANNEL } from '../contants.js';
-import resolveChannel from './resolveChannel.js';
+import { resolveProp } from './resolve.js';
+/**
+ * all style props that can be applied via channels but
+ * are not scaled
+ */
 const styleProps = {
-    fill: 'fill',
-    stroke: 'stroke',
     strokeWidth: 'stroke-width',
     strokeDasharray: 'stroke-dasharray',
-    fillOpacity: 'fill-opacity',
-    strokeOpacity: 'stroke-opacity',
+    strokeLinejoin: 'stroke-linejoin',
+    strokeLinecap: 'stroke-linecap',
+    blend: 'mix-blend-mode',
+    clipPath: 'clip-path',
+    mask: 'mask',
     fontSize: 'font-size',
-    opacity: 'opacity'
+    fontWeight: 'font-weight',
+    fontStyle: 'font-style',
+    textAnchor: 'text-anchor',
+    cursor: 'cursor',
+    pointerEvents: 'pointer-events'
 };
-export default function (datum, props) {
-    return Object.entries(styleProps)
+const styleDefaults = {
+    fontWeight: 'normal'
+};
+export function getBaseStylesObject(datum, props) {
+    return Object.fromEntries(Object.entries(styleProps)
         .filter(([key, cssKey]) => cssKey && props[key] != null)
-        .map(([key, cssKey]) => `${cssKey}: ${resolveChannel(MARK_PROP_CHANNEL[key], datum, props[key])}`)
+        .map(([key, cssKey]) => [
+        cssKey,
+        maybeToPixel(cssKey, resolveProp(props[key], datum, styleDefaults[key] || null))
+    ]));
+}
+export default function (datum, props) {
+    return Object.entries(getBaseStylesObject(datum, props))
+        .map(([key, value]) => `${key}: ${value}`)
         .join(';');
 }
+export function maybeToPixel(cssKey, value) {
+    if (cssKey === 'font-size' || cssKey === 'stroke-width') {
+        return typeof value === 'number' ? `${value}px` : value;
+    }
+    return value;
+}

package/dist/helpers/getLogTicks.js

@@ -10,7 +10,7 @@ export function getLogTicks(domain, count = 6) {
         return [];
     if (domain[0] === 0)
         return ticksArray(domain[0], domain[1], count - 2);
-    let mult = Math.pow(10, Math.floor(Math.log10(Math.abs(domain[1] - domain[0]))) - 1);
+    let mult = 1; //Math.pow(10, Math.floor(Math.log10(Math.abs(domain[1] - domain[0]))) - 1);
     count += 2;
     let candidates = getTickCandidates(domain, mult);
     if (candidates[0].num > count) {
@@ -46,12 +46,12 @@ function getTickCandidates(domain, mult = 1) {
     return logSeries.map((factors) => {
         let i = Math.pow(10, Math.floor(Math.log10(domain[0])));
         let f = 0;
-        const r = [i];
-        while (i < domain[1] && r.length < 50) {
+        const ticks = [i];
+        while (i < domain[1] && ticks.length < 50) {
             i *= factors[f] * mult;
-            r.push(i);
+            ticks.push(i);
             f = (f + 1) % factors.length;
         }
-        return { ticks: r, num: r.length };
+        return { ticks, num: ticks.length };
     });
 }

package/dist/helpers/group.d.ts

@@ -0,0 +1,6 @@
+import type { Channels, DataRecord } from '../types.js';
+/**
+ * Groups the data by the fx, fy and z channels and calls the reduce function
+ * for each group. Returns the new channels to be added in the transform.
+ */
+export declare function groupFacetsAndZ(items: DataRecord[], channels: Channels, reduce: (items: DataRecord[]) => any): any;

package/dist/helpers/group.js

@@ -0,0 +1,53 @@
+import { resolveChannel } from './resolve.js';
+import { groups as d3Groups } from 'd3-array';
+/**
+ * Groups the data by the fx, fy and z channels and calls the reduce function
+ * for each group. Returns the new channels to be added in the transform.
+ */
+export function groupFacetsAndZ(items, channels, reduce) {
+    const groupBy = ['fx', 'fy', 'z'].map((groupChannel) => {
+        const groupByChannel = groupChannel === 'z'
+            ? channels.z
+                ? 'z'
+                : channels.fill
+                    ? 'fill'
+                    : channels.stroke
+                        ? 'stroke'
+                        : false
+            : channels[groupChannel]
+                ? groupChannel
+                : false;
+        if (groupByChannel) {
+            const groupByPropName = typeof channels[groupByChannel] === 'string'
+                ? channels[groupByChannel]
+                : `__group_${groupByChannel}`;
+            return [
+                groupByChannel,
+                groupByPropName,
+                (d) => resolveChannel(groupByChannel, d, channels)
+            ];
+        }
+        else {
+            return [null, null, () => true];
+        }
+    });
+    const groups = d3Groups(items, ...groupBy.map((d) => d[2]));
+    for (const [fxKey, fxGroups] of groups) {
+        const newItemGroupProps = {};
+        if (groupBy[0][0] !== null)
+            newItemGroupProps[groupBy[0][1]] = fxKey;
+        for (const [fyKey, fyGroups] of fxGroups) {
+            if (groupBy[1][0] !== null)
+                newItemGroupProps[groupBy[1][1]] = fyKey;
+            for (const [zKey, zGroups] of fyGroups) {
+                if (groupBy[2][0] !== null)
+                    newItemGroupProps[groupBy[2][1]] = zKey;
+                reduce(zGroups, newItemGroupProps);
+            }
+        }
+    }
+    // return the new channel accessors to be added in the transform
+    return Object.fromEntries(groupBy
+        .filter(([groupByChannel]) => groupByChannel !== null)
+        .map(([groupByChannel, groupByProp]) => [groupByChannel, groupByProp]));
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1,18 @@
+import type { ChannelAccessor, ChannelName, DataRecord, RawValue } from '../types.js';
+import type { Snippet } from 'svelte';
+/**
+ * Returns first argument that is not null or undefined
+ */
+export declare function coalesce(...args: (RawValue | undefined | null)[]): RawValue | null;
+export declare function testFilter(datum: DataRecord, options: Record<ChannelName, ChannelAccessor>): string | number | boolean | Date | null;
+export declare function randomId(): string;
+export declare function isSnippet(value: unknown): value is Snippet;
+export declare function isValid(value: RawValue | undefined): value is number | Date | string;
+export declare function maybeData(data: DataRecord[]): DataRecord[];
+export declare function isObject(option: object | RawValue): option is object;
+export declare function maybeNumber(value: RawValue | null): number | null;
+export declare const constant: <T>(x: T) => () => T;
+export declare const POSITION_CHANNELS: Set<ChannelName>;
+export declare function parseInset(inset: number | string, width: number): number;
+export declare function omit<T extends {}, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;
+export declare function identity<T>(x: T): T;

package/dist/helpers/index.js

@@ -0,0 +1,53 @@
+import { resolveProp } from './resolve.js';
+import { isDate } from './typeChecks';
+/**
+ * Returns first argument that is not null or undefined
+ */
+export function coalesce(...args) {
+    for (const arg of args) {
+        if (arg !== null && arg !== undefined) {
+            return arg;
+        }
+    }
+    return null; // Return null if all arguments are null or undefined
+}
+export function testFilter(datum, options) {
+    return options.filter == null || resolveProp(options.filter, datum);
+}
+export function randomId() {
+    return Math.ceil(1e9 + Math.random() * 1e9).toString(36);
+}
+export function isSnippet(value) {
+    return typeof value === 'function' && value.length === 1;
+}
+export function isValid(value) {
+    return value !== null && value !== undefined && !Number.isNaN(value);
+}
+export function maybeData(data) {
+    // if (data.type === 'FeatureCollection') return data.features;
+    return data;
+}
+export function isObject(option) {
+    // doesn't work with Proxies
+    return (typeof option === 'object' && !isDate(option) && !Array.isArray(option) && option !== null);
+}
+export function maybeNumber(value) {
+    return value != null ? +value : null;
+}
+export const constant = (x) => () => x;
+export const POSITION_CHANNELS = new Set(['x', 'x1', 'x2', 'y', 'y1', 'y2']);
+export function parseInset(inset, width) {
+    if (typeof inset === 'number') {
+        return inset;
+    }
+    if (inset.endsWith('%')) {
+        return (width * +inset.slice(0, -1)) / 100;
+    }
+    return +inset;
+}
+export function omit(obj, ...keys) {
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
+}
+export function identity(x) {
+    return x;
+}

package/dist/helpers/isRawValue.d.ts

@@ -0,0 +1,2 @@
+import type { RawValue } from '../types.js';
+export default function (value: any): value is RawValue;

package/dist/helpers/isRawValue.js

@@ -0,0 +1,5 @@
+import { isDate } from './typeChecks';
+export default function (value) {
+    const t = typeof value;
+    return t === 'string' || t === 'number' || t === 'boolean' || isDate(value) || t === null;
+}

package/dist/helpers/isValid.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated import from helpers/index.ts instead!
+ * @param value
+ * @returns
+ */
+export { isValid } from './index.js';

package/dist/helpers/isValid.js

@@ -0,0 +1,6 @@
+/**
+ * @deprecated import from helpers/index.ts instead!
+ * @param value
+ * @returns
+ */
+export { isValid } from './index.js';

package/dist/helpers/math.d.ts

@@ -0,0 +1,19 @@
+/**
+Returns the normal deviate Z corresponding to a given lower tail area of P; Z is accurate to about 1 part in 10**16.
+
+Wichura, M. J. (1988) Algorithm AS 241: The percentage points of the normal distribution. Applied Statistics, 37, 477–484.
+
+extension of:
+Beasley, J. D./ Springer, S. G. (1977), The percentage points of the NormalDistribution, Applied Statistics. 26, 118–121.
+
+Excel: STANDNORMINV(); R: qnorm()
+**/
+export declare function normdev(p: number): number | false;
+export declare function confidenceInterval(data: {
+    x: number;
+    y: number;
+}[], predict: any, confidenceLevel: number): (x: any) => {
+    x: any;
+    left: number;
+    right: any;
+};

package/dist/helpers/math.js

@@ -0,0 +1,116 @@
+import { sum } from 'd3-array';
+/**
+Returns the normal deviate Z corresponding to a given lower tail area of P; Z is accurate to about 1 part in 10**16.
+
+Wichura, M. J. (1988) Algorithm AS 241: The percentage points of the normal distribution. Applied Statistics, 37, 477–484.
+
+extension of:
+Beasley, J. D./ Springer, S. G. (1977), The percentage points of the NormalDistribution, Applied Statistics. 26, 118–121.
+
+Excel: STANDNORMINV(); R: qnorm()
+**/
+export function normdev(p) {
+    if (p < 0 || p > 1)
+        return false;
+    if (p == 0)
+        return -Infinity;
+    if (p == 1)
+        return Infinity;
+    const a0 = 3.387132872796366608, a1 = 1.3314166789178437745e2, a2 = 1.9715909503065514427e3, a3 = 1.3731693765509461125e4, a4 = 4.5921953931549871457e4, a5 = 6.7265770927008700853e4, a6 = 3.3430575583588128105e4, a7 = 2.5090809287301226727e3, b1 = 4.2313330701600911252e1, b2 = 6.871870074920579083e2, b3 = 5.3941960214247511077e3, b4 = 2.1213794301586595867e4, b5 = 3.930789580009271061e4, b6 = 2.8729085735721942674e4, b7 = 5.226495278852854561e3, c0 = 1.42343711074968357734, c1 = 4.6303378461565452959, c2 = 5.7694972214606914055, c3 = 3.64784832476320460504, c4 = 1.27045825245236838258, c5 = 2.4178072517745061177e-1, c6 = 2.27238449892691845833e-2, c7 = 7.7454501427834140764e-4, d1 = 2.05319162663775882187, d2 = 1.6763848301838038494, d3 = 6.8976733498510000455e-1, d4 = 1.4810397642748007459e-1, d5 = 1.51986665636164571966e-2, d6 = 5.475938084995344946e-4, d7 = 1.05075007164441684324e-9, e0 = 6.6579046435011037772, e1 = 5.4637849111641143699, e2 = 1.7848265399172913358, e3 = 2.9656057182850489123e-1, e4 = 2.6532189526576123093e-2, e5 = 1.2426609473880784386e-3, e6 = 2.71155556874348757815e-5, e7 = 2.01033439929228813265e-7, f1 = 5.9983220655588793769e-1, f2 = 1.3692988092273580531e-1, f3 = 1.48753612908506148525e-2, f4 = 7.868691311456132591e-4, f5 = 1.8463183175100546818e-5, f6 = 1.4215117583164458887e-7, f7 = 2.04426310338993978564e-15;
+    const q = p - 0.5;
+    let r, z;
+    // p close to 0.5
+    if (Math.abs(q) <= 0.425) {
+        r = 0.180625 - q * q;
+        z =
+            (q * (((((((a7 * r + a6) * r + a5) * r + a4) * r + a3) * r + a2) * r + a1) * r + a0)) /
+                (((((((b7 * r + b6) * r + b5) * r + b4) * r + b3) * r + b2) * r + b1) * r + 1);
+        return z;
+    }
+    if (q > 0)
+        r = 1 - p;
+    else
+        r = p;
+    r = Math.sqrt(-Math.log(r));
+    // p neither close to 0.5 nor 0 or 1
+    if (r <= 5) {
+        r += -1.6;
+        z =
+            (((((((c7 * r + c6) * r + c5) * r + c4) * r + c3) * r + c2) * r + c1) * r + c0) /
+                (((((((d7 * r + d6) * r + d5) * r + d4) * r + d3) * r + d2) * r + d1) * r + 1);
+    }
+    // p near 0 or 1
+    else {
+        r += -5;
+        z =
+            (((((((e7 * r + e6) * r + e5) * r + e4) * r + e3) * r + e2) * r + e1) * r + e0) /
+                (((((((f7 * r + f6) * r + f5) * r + f4) * r + f3) * r + f2) * r + f1) * r + 1);
+    }
+    if (q < 0.0)
+        z = -z;
+    return z;
+}
+/*
+Hill's approximated inverse t-distribution calculates t given df and two-tail probability:
+Hill, G. W. (1970), Algorithm 396: Student's t-quantiles. Communications of the ACM, 13(10), 619–620.
+
+Result should be "correct to at least 6 significant digits even for the analytic continuation through noninteger values of n > 5". For higher precision (used in R, ...) see:
+Hill, G. W. (1981) Remark on Algorithm 396, ACM Transactions on Mathematical Software, 7, 250–1.
+
+Excel: TINV(); R: qt()
+*/
+function inverseT(p, df) {
+    const { sin, cos, sqrt, pow, exp, PI } = Math;
+    //   let a, b, c, d, t, x, y;
+    if (df == 1)
+        return cos((p * PI) / 2) / sin((p * PI) / 2);
+    if (df == 2)
+        return sqrt(2 / (p * (2 - p)) - 2);
+    const a = 1 / (df - 0.5);
+    const b = 48 / (a * a);
+    let c = (((20700 * a) / b - 98) * a - 16) * a + 96.36;
+    const d = ((94.5 / (b + c) - 3) / b + 1) * sqrt(a * PI * 0.5) * df;
+    let x = d * p;
+    let y = pow(x, 2 / df);
+    if (y > 0.05 + a) {
+        // The procedure normdev(p) is assumed to return a negative normal
+        // deviate at the lower tail probability level p, e.g. -2.32 for p = 0.01.
+        x = normdev(p / 2);
+        y = x * x;
+        if (df < 5)
+            c = c + 0.3 * (df - 4.5) * (x + 0.6);
+        c = (((0.05 * d * x - 5) * x - 7) * x - 2) * x + b + c;
+        y = (((((0.4 * y + 6.3) * y + 36) * y + 94.5) / c - y - 3) / b + 1) * x;
+        y = a * y * y;
+        if (y > 0.002)
+            y = exp(y) - 1;
+        else
+            y = 0.5 * y * y + y;
+    }
+    else {
+        y =
+            (((1 / (((df + 6) / (df * y) - 0.089 * d - 0.822) * (df + 2) * 3) + 0.5 / (df + 4)) *
+                y -
+                1) *
+                (df + 1)) /
+                (df + 2) +
+                1 / y;
+    }
+    return sqrt(df * y);
+}
+// https://stats.stackexchange.com/questions/101318/understanding-shape-and-calculation-of-confidence-bands-in-linear-regression
+export function confidenceInterval(data, predict, confidenceLevel) {
+    const mean = sum(data, (d) => d.x) / data.length;
+    let a = 0, b = 0;
+    for (let i = 0; i < data.length; ++i) {
+        a += Math.pow(data[i].x - mean, 2);
+        b += Math.pow(data[i].y - predict(data[i].x), 2);
+    }
+    const sy = Math.sqrt(b / (data.length - 2));
+    const t = inverseT(+confidenceLevel, data.length - 2);
+    return function (x) {
+        const Y = predict(x);
+        const se = sy * Math.sqrt(1 / data.length + Math.pow(x - mean, 2) / a);
+        return { x, left: Y - t * se, right: Y + t * se };
+    };
+}

package/dist/helpers/mergeDeep.d.ts

@@ -1,5 +1,5 @@
 type ObjectType = {
     [key: string]: any;
 };
-export default function mergeDeep(target: ObjectType, ...sources: ObjectType[]): ObjectType;
+export default function mergeDeep<T extends ObjectType>(target: Partial<T>, ...sources: Partial<T>[]): T;
 export {};

package/dist/helpers/noise.d.ts

@@ -0,0 +1 @@
+export declare function noise(x: number, y?: number, z?: number): number;

package/dist/helpers/noise.js

@@ -0,0 +1,72 @@
+const PERLIN_YWRAPB = 4;
+const PERLIN_YWRAP = 1 << PERLIN_YWRAPB;
+const PERLIN_ZWRAPB = 8;
+const PERLIN_ZWRAP = 1 << PERLIN_ZWRAPB;
+const PERLIN_SIZE = 4095;
+let perlin_octaves = 4; // default to medium smooth
+let perlin_amp_falloff = 0.5; // 50% reduction/octave
+const scaled_cosine = (i) => 0.5 * (1.0 - Math.cos(i * Math.PI));
+let perlin; // will be initialized lazily by noise() or noiseSeed()
+export function noise(x, y = 0, z = 0) {
+    if (perlin == null) {
+        perlin = new Array(PERLIN_SIZE + 1);
+        for (let i = 0; i < PERLIN_SIZE + 1; i++) {
+            perlin[i] = Math.random();
+        }
+    }
+    if (x < 0) {
+        x = -x;
+    }
+    if (y < 0) {
+        y = -y;
+    }
+    if (z < 0) {
+        z = -z;
+    }
+    let xi = Math.floor(x), yi = Math.floor(y), zi = Math.floor(z);
+    let xf = x - xi;
+    let yf = y - yi;
+    let zf = z - zi;
+    let rxf, ryf;
+    let r = 0;
+    let ampl = 0.5;
+    let n1, n2, n3;
+    for (let o = 0; o < perlin_octaves; o++) {
+        let of = xi + (yi << PERLIN_YWRAPB) + (zi << PERLIN_ZWRAPB);
+        rxf = scaled_cosine(xf);
+        ryf = scaled_cosine(yf);
+        n1 = perlin[of & PERLIN_SIZE];
+        n1 += rxf * (perlin[(of + 1) & PERLIN_SIZE] - n1);
+        n2 = perlin[(of + PERLIN_YWRAP) & PERLIN_SIZE];
+        n2 += rxf * (perlin[(of + PERLIN_YWRAP + 1) & PERLIN_SIZE] - n2);
+        n1 += ryf * (n2 - n1);
+        of += PERLIN_ZWRAP;
+        n2 = perlin[of & PERLIN_SIZE];
+        n2 += rxf * (perlin[(of + 1) & PERLIN_SIZE] - n2);
+        n3 = perlin[(of + PERLIN_YWRAP) & PERLIN_SIZE];
+        n3 += rxf * (perlin[(of + PERLIN_YWRAP + 1) & PERLIN_SIZE] - n3);
+        n2 += ryf * (n3 - n2);
+        n1 += scaled_cosine(zf) * (n2 - n1);
+        r += n1 * ampl;
+        ampl *= perlin_amp_falloff;
+        xi <<= 1;
+        xf *= 2;
+        yi <<= 1;
+        yf *= 2;
+        zi <<= 1;
+        zf *= 2;
+        if (xf >= 1.0) {
+            xi++;
+            xf--;
+        }
+        if (yf >= 1.0) {
+            yi++;
+            yf--;
+        }
+        if (zf >= 1.0) {
+            zi++;
+            zf--;
+        }
+    }
+    return r;
+}

package/dist/helpers/projection.d.ts

@@ -0,0 +1,33 @@
+type Clip = boolean | null | number | 'frame';
+type ProjectionOptions = {
+    type: string;
+    domain: number[];
+    inset: number;
+    insetTop: number;
+    insetBottom: number;
+    insetLeft: number;
+    insetRight: number;
+    clip: Clip;
+    stream: (a: number, b: number) => [number, number];
+};
+type Dimensions = {
+    width: number;
+    height: number;
+    marginTop: number;
+    marginBottom: number;
+    marginLeft: number;
+    marginRight: number;
+};
+export declare function createProjection({ projOptions, inset: globalInset, insetTop, insetRight, insetBottom, insetLeft }: {
+    projOptions?: ProjectionOptions | string;
+    inset?: number;
+    insetTop?: number;
+    insetRight?: number;
+    insetBottom?: number;
+    insetLeft?: number;
+} | undefined, dimensions: Dimensions): string | ProjectionOptions | {
+    aspectRatio: number;
+    invert([x, y]: [any, any]): any;
+    stream: (s: any) => any;
+} | undefined;
+export {};