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

package/dist/transforms/normalize.js

@@ -0,0 +1,86 @@
+import { mapX, mapY } from './map.js';
+import { min, max, mean, median, sum, deviation, extent } from 'd3-array';
+export function normalizeX(args, basis) {
+    return mapX(args, normalize(basis));
+}
+export function normalizeY(args, basis) {
+    return mapY(args, normalize(basis));
+}
+function normalize(basis) {
+    if (basis === undefined)
+        return normalizeFirst;
+    if (typeof basis === 'function')
+        return normalizeBasis(basis);
+    //   if (/^p\d{2}$/i.test(basis)) return normalizeAccessor(percentile(basis));
+    switch (`${basis}`.toLowerCase()) {
+        case 'deviation':
+            return normalizeDeviation;
+        case 'first':
+            return normalizeFirst;
+        case 'last':
+            return normalizeLast;
+        case 'max':
+            return normalizeMax;
+        case 'mean':
+            return normalizeMean;
+        case 'median':
+            return normalizeMedian;
+        case 'min':
+            return normalizeMin;
+        case 'sum':
+            return normalizeSum;
+        case 'extent':
+            return normalizeExtent;
+    }
+    throw new Error(`invalid basis: ${basis}`);
+}
+function normalizeBasis(basis) {
+    return {
+        mapIndex(I, S, T) {
+            const b = +basis(I, S);
+            for (const i of I) {
+                T[i] = S[i] === null ? NaN : S[i] / b;
+            }
+        }
+    };
+}
+function normalizeAccessor(f) {
+    return normalizeBasis((I, S) => f(I, (i) => S[i]));
+}
+const normalizeExtent = {
+    mapIndex(I, S, T) {
+        const [s1, s2] = extent(I, (i) => S[i]);
+        const d = s2 - s1;
+        for (const i of I) {
+            T[i] = S[i] === null ? NaN : (S[i] - s1) / d;
+        }
+    }
+};
+const normalizeFirst = normalizeBasis((I, S) => {
+    for (let i = 0; i < I.length; ++i) {
+        const s = S[I[i]];
+        if (s != null && isFinite(s))
+            return s;
+    }
+});
+const normalizeLast = normalizeBasis((I, S) => {
+    for (let i = I.length - 1; i >= 0; --i) {
+        const s = S[I[i]];
+        if (s != null && isFinite(s))
+            return s;
+    }
+});
+const normalizeDeviation = {
+    mapIndex(I, S, T) {
+        const m = mean(I, (i) => S[i]);
+        const d = deviation(I, (i) => S[i]);
+        for (const i of I) {
+            T[i] = S[i] === null ? NaN : d ? (S[i] - m) / d : 0;
+        }
+    }
+};
+const normalizeMax = normalizeAccessor(max);
+const normalizeMean = normalizeAccessor(mean);
+const normalizeMedian = normalizeAccessor(median);
+const normalizeMin = normalizeAccessor(min);
+const normalizeSum = normalizeAccessor(sum);

package/dist/transforms/recordize.d.ts

@@ -0,0 +1,15 @@
+import type { TransformArgsRow, TransformArgsRecord } from '../types.js';
+export declare const INDEX: unique symbol;
+export declare const RAW_VALUE: unique symbol;
+export declare function recordizeX({ data, ...channels }: TransformArgsRow, { withIndex }?: {
+    withIndex: boolean;
+}): TransformArgsRecord;
+export declare function recordizeY({ data, ...channels }: TransformArgsRow, { withIndex }?: {
+    withIndex: boolean;
+}): TransformArgsRecord;
+/**
+ * This transform is used to allow users to pass an [[x0, y0], [x1, y1], ...] array
+ * as dataset to marks that support it. It transforms the arrays into records, so
+ * the rest of our code doesn't have to deal with this case anymore.
+ */
+export declare function recordizeXY({ data, ...channels }: TransformArgsRow): TransformArgsRecord;

package/dist/transforms/recordize.js

@@ -0,0 +1,78 @@
+import isDataRecord from '../helpers/isDataRecord.js';
+export const INDEX = Symbol('index');
+export const RAW_VALUE = Symbol('originalValue');
+/*
+ * This transform takes an array of raw values as input and returns data records
+ * in which the values are interpreted as x channel and their index as y
+ */
+export function recordizeX({ data, ...channels }, { withIndex } = { withIndex: true }) {
+    const dataIsRawValueArray = !isDataRecord(data[0]) && !Array.isArray(data[0]) && channels.x == null;
+    if (dataIsRawValueArray) {
+        return {
+            data: data.map((value, index) => ({
+                __value: value,
+                ...(withIndex ? { __index: index } : {}),
+                [RAW_VALUE]: value,
+                ___orig___: value
+            })),
+            ...channels,
+            x: '__value',
+            ...(withIndex ? { y: '__index' } : {})
+        };
+    }
+    return { data: data, ...channels };
+}
+/*
+ * This transform takes an array of raw values as input and returns data records
+ * in which the values are interpreted as y channel and their index as yx
+ */
+export function recordizeY({ data, ...channels }, { withIndex } = { withIndex: true }) {
+    if (!data)
+        return { data, ...channels };
+    const dataIsRawValueArray = !isDataRecord(data[0]) && !Array.isArray(data[0]) && channels.y == null;
+    if (dataIsRawValueArray) {
+        return {
+            data: Array.from(data).map((value, index) => ({
+                ...(withIndex ? { __index: index } : {}),
+                [RAW_VALUE]: value,
+                ___orig___: value
+            })),
+            ...channels,
+            ...(withIndex ? { x: '__index' } : {}),
+            y: RAW_VALUE
+        };
+    }
+    return {
+        data: Array.from(data).map((d, index) => ({
+            ...d,
+            ...(withIndex ? { __index: index } : {})
+        })),
+        x: '__index',
+        ...channels
+    };
+}
+/**
+ * This transform is used to allow users to pass an [[x0, y0], [x1, y1], ...] array
+ * as dataset to marks that support it. It transforms the arrays into records, so
+ * the rest of our code doesn't have to deal with this case anymore.
+ */
+export function recordizeXY({ data, ...channels }) {
+    if (!data)
+        return { data, ...channels };
+    if (!isDataRecord(data[0]) &&
+        Array.isArray(data[0]) &&
+        channels.x === undefined &&
+        channels.y === undefined) {
+        return {
+            data: data.map(([x, y, ...rest]) => ({
+                [RAW_VALUE]: [x, y, ...rest],
+                __x: x,
+                __y: y
+            })),
+            ...channels,
+            x: '__x',
+            y: '__y'
+        };
+    }
+    return { data, ...channels };
+}

package/dist/transforms/rename.d.ts

@@ -0,0 +1,14 @@
+import type { DataRecord } from '../types.js';
+import type { ScaledChannelName, TransformArg } from '../types.js';
+type RenameChannelsOptions = Partial<Record<ScaledChannelName, ScaledChannelName>>;
+type ReplaceChannelsOptions = Partial<Record<ScaledChannelName, ScaledChannelName[]>>;
+/**
+ * renames a channel without modifying the data
+ */
+export declare function renameChannels<T>({ data, ...channels }: TransformArg<T, DataRecord>, options: RenameChannelsOptions): TransformArg<T, DataRecord>;
+/**
+ * renames a channel and copy the data
+ */
+export declare function renameChannelsAndData<T>({ data, ...channels }: TransformArg<T, DataRecord>, options: RenameChannelsOptions): TransformArg<T, DataRecord>;
+export declare function replaceChannels<T>({ data, ...channels }: TransformArg<T, DataRecord>, options: ReplaceChannelsOptions): TransformArg<T, DataRecord>;
+export {};

package/dist/transforms/rename.js

@@ -0,0 +1,42 @@
+/**
+ * renames a channel without modifying the data
+ */
+export function renameChannels({ data, ...channels }, options) {
+    const newChannels = channels;
+    for (const [from, to] of Object.entries(options)) {
+        if (newChannels[from] !== undefined) {
+            newChannels[to] = newChannels[from];
+            delete newChannels[from];
+        }
+    }
+    return { data, ...newChannels };
+}
+/**
+ * renames a channel and copy the data
+ */
+export function renameChannelsAndData({ data, ...channels }, options) {
+    const newData = [];
+    for (const datum of data) {
+        const newDatum = { ...datum };
+        for (const [from, to] of Object.entries(options)) {
+            if (channels[from] !== undefined) {
+                newDatum[to] = newDatum[from];
+                delete newDatum[from];
+            }
+        }
+        newData.push(newDatum);
+    }
+    return renameChannels({ data: newData, ...channels }, options);
+}
+export function replaceChannels({ data, ...channels }, options) {
+    const newChannels = { ...channels };
+    for (const [from, to] of Object.entries(options)) {
+        if (newChannels[from] !== undefined) {
+            for (const t of to) {
+                newChannels[t] = newChannels[from];
+            }
+            delete newChannels[from];
+        }
+    }
+    return { data, ...newChannels };
+}

package/dist/transforms/select.d.ts

@@ -0,0 +1,35 @@
+import type { ChannelName, DataRecord, TransformArg } from '../types.js';
+type AtLeastOne<T, U = {
+    [K in keyof T]: Pick<T, K>;
+}> = Partial<T> & U[keyof U];
+type SelectOptions = 'first' | 'last' | AtLeastOne<{
+    [k in ChannelName]: 'min' | 'max';
+}>;
+export declare function select({ data, ...channels }: TransformArg<DataRecord>, options: SelectOptions): {
+    data: DataRecord[];
+};
+/**
+ * Keeps only the first item of each group
+ */
+export declare function selectFirst(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+/**
+ * Keeps only the last item of each group
+ */
+export declare function selectLast(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMinX(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMaxX(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMinY(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export declare function selectMaxY(args: TransformArg<DataRecord>): {
+    data: DataRecord[];
+};
+export {};

package/dist/transforms/select.js

@@ -0,0 +1,55 @@
+import { groupFacetsAndZ } from '../helpers/group.js';
+import { resolveChannel } from '../helpers/resolve.js';
+// let o: SelectOptions = { x: 'min'};
+export function select({ data, ...channels }, options) {
+    const newData = [];
+    groupFacetsAndZ(data, channels, (items) => {
+        if (typeof options === 'string') {
+            if (options !== 'first' && options !== 'last')
+                throw new Error('unknown sort option: ' + options);
+            newData.push(options === 'first' ? items[0] : items.at(-1));
+        }
+        else {
+            const sortOptions = Object.entries(options);
+            if (!sortOptions.length)
+                throw new Error('must provide the channel to sort by');
+            if (sortOptions.length > 1)
+                throw new Error('cannot sort by more than one channel');
+            if (sortOptions[0][1] !== 'min' && sortOptions[0][1] !== 'max')
+                throw new Error('unknown sort option: ' + sortOptions[0][1]);
+            const selected = items
+                .map((item) => ({
+                ...item,
+                __sortby: resolveChannel(sortOptions[0][0], item, channels)
+            }))
+                .sort((a, b) => (a.__sortby > b.__sortby ? 1 : a.__sortby < b.__sortby ? -1 : 0))
+                .at(sortOptions[0][1] === 'min' ? 0 : -1);
+            newData.push(selected);
+        }
+    });
+    return { data: newData, ...channels };
+}
+/**
+ * Keeps only the first item of each group
+ */
+export function selectFirst(args) {
+    return select(args, 'first');
+}
+/**
+ * Keeps only the last item of each group
+ */
+export function selectLast(args) {
+    return select(args, 'last');
+}
+export function selectMinX(args) {
+    return select(args, { x: 'min' });
+}
+export function selectMaxX(args) {
+    return select(args, { x: 'max' });
+}
+export function selectMinY(args) {
+    return select(args, { y: 'min' });
+}
+export function selectMaxY(args) {
+    return select(args, { y: 'max' });
+}

package/dist/transforms/shift.d.ts

@@ -0,0 +1,13 @@
+import type { DataRecord, TransformArg } from '../types.js';
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+type ShiftXOptions = {
+    [key in 'x' | 'x1' | 'x2']: string | number;
+};
+export declare function shiftX({ data, ...channels }: TransformArg<DataRecord>, shiftBy: string | number | RequireAtLeastOne<ShiftXOptions>): TransformArg<DataRecord>;
+type ShiftYOptions = {
+    [key in 'y' | 'y1' | 'y2']: string | number;
+};
+export declare function shiftY({ data, ...channels }: TransformArg<DataRecord>, shiftBy: string | number | RequireAtLeastOne<ShiftYOptions>): TransformArg<DataRecord>;
+export {};

package/dist/transforms/shift.js

@@ -0,0 +1,45 @@
+import { resolveChannel } from '../helpers/resolve.js';
+import { maybeTimeInterval } from '../helpers/time.js';
+export function shiftX({ data, ...channels }, shiftBy) {
+    if (typeof shiftBy === 'number' || typeof shiftBy === 'string') {
+        shiftBy = { x: shiftBy };
+    }
+    if (shiftBy) {
+        if (shiftBy)
+            return shiftChannels('x', shiftBy, { data, ...channels });
+    }
+    return { data, ...channels };
+}
+export function shiftY({ data, ...channels }, shiftBy) {
+    if (typeof shiftBy === 'number' || typeof shiftBy === 'string') {
+        shiftBy = { y: shiftBy };
+    }
+    if (shiftBy)
+        return shiftChannels('y', shiftBy, { data, ...channels });
+    return { data, ...channels };
+}
+function shiftChannels(shiftDim, shiftBy, { data, ...channels }) {
+    return {
+        data: data.map((d) => {
+            const newRow = { ...d };
+            for (const [channel, shift] of Object.entries(shiftBy)) {
+                const shiftFrom = (channels[channel] != null ? channel : shiftDim);
+                if (typeof shift === 'number') {
+                    newRow[`__shift_${channel}`] =
+                        resolveChannel(shiftFrom, d, channels) + shift;
+                }
+                else if (typeof shift === 'string') {
+                    const [, sign, value, unit] = shift.match(/^([+-])?(\d+)? ?([a-z]+)$/);
+                    const step = (sign === '-' ? -1 : 1) * (value || 1);
+                    const interval = maybeTimeInterval(unit);
+                    if (!interval)
+                        throw new Error(`Invalid shift interval: ${shift}`);
+                    newRow[`__shift_${channel}`] = interval.offset(resolveChannel(shiftFrom, d, channels), step);
+                }
+            }
+            return newRow;
+        }),
+        ...channels,
+        ...Object.fromEntries(Object.keys(shiftBy).map((key) => [key, `__shift_${key}`]))
+    };
+}

package/dist/transforms/sort.d.ts

@@ -0,0 +1,28 @@
+import type { DataRecord, DataRow, TransformArg } from '../types.js';
+export declare const SORT_KEY: unique symbol;
+export declare function sort({ data, ...channels }: TransformArg<DataRecord>, options?: {
+    reverse?: boolean;
+}): {
+    sort: null;
+    data: {
+        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
+    }[];
+} | {
+    data: DataRecord[];
+};
+/**
+ * reverses the data row order
+ */
+export declare function shuffle({ data, ...channels }: TransformArg<DataRow[]>, options?: {
+    seed?: number;
+}): {
+    sort: null;
+    data: DataRow[][];
+};
+/**
+ * reverses the data row order
+ */
+export declare function reverse({ data, ...channels }: TransformArg<DataRow[]>): {
+    sort: null;
+    data: DataRow[][];
+};

package/dist/transforms/sort.js

@@ -0,0 +1,66 @@
+import isDataRecord from '../helpers/isDataRecord.js';
+import { resolveChannel } from '../helpers/resolve.js';
+import { shuffler } from 'd3-array';
+import { randomLcg } from 'd3-random';
+export const SORT_KEY = Symbol('sortKey');
+export function sort({ data, ...channels }, options = {}) {
+    if (!Array.isArray(data))
+        return { data, ...channels };
+    if (channels.sort) {
+        const { sort } = channels;
+        if (isDataRecord(sort) &&
+            typeof sort.channel === 'string' &&
+            sort.channel.charAt(0) === '-') {
+            sort.channel = sort.channel.substring(1);
+            sort.order = 'descending';
+        }
+        // sort data
+        return {
+            data: data
+                .map((d) => ({
+                ...d,
+                [SORT_KEY]: resolveChannel('sort', d, { ...channels, sort })
+            }))
+                .toSorted((a, b) => (a[SORT_KEY] > b[SORT_KEY] ? 1 : a[SORT_KEY] < b[SORT_KEY] ? -1 : 0) *
+                (options.reverse || (isDataRecord(sort) && sort?.order === 'descending')
+                    ? -1
+                    : 1))
+                .map(({ [SORT_KEY]: a, ...rest }) => rest),
+            ...channels,
+            // set the sort channel to null to disable the implicit alphabetical
+            // ordering of ordinal domains, and also to avoid double sorting in case
+            // this transform is used "outside" a mark
+            sort: null
+        };
+    }
+    return {
+        data,
+        ...channels
+    };
+}
+/**
+ * reverses the data row order
+ */
+export function shuffle({ data, ...channels }, options = {}) {
+    const random = randomLcg(options.seed);
+    const shuffle = shuffler(random);
+    return {
+        data: shuffle([...data]),
+        ...channels,
+        // set the sort channel to null to disable the implicit
+        // alphabetical ordering of ordinal domains
+        sort: null
+    };
+}
+/**
+ * reverses the data row order
+ */
+export function reverse({ data, ...channels }) {
+    return {
+        data: data.toReversed(),
+        ...channels,
+        // set the sort channel to null to disable the implicit
+        // alphabetical ordering of ordinal domains
+        sort: null
+    };
+}

package/dist/transforms/stack.d.ts

@@ -0,0 +1,10 @@
+import type { TransformArg } from '../types.js';
+export type StackOrder = 'none' | 'appearance' | 'inside-out' | 'sum';
+export type StackOffset = 'none' | 'wiggle' | 'center' | 'normalize' | 'diverging';
+export type StackOptions = {
+    offset: null | StackOffset;
+    order: null | StackOrder;
+    reverse: boolean;
+};
+export declare function stackY<T>({ data, ...channels }: T, opts?: Partial<StackOptions>): T;
+export declare function stackX({ data, ...channels }: TransformArg, opts?: Partial<StackOptions>): TransformArg;

package/dist/transforms/stack.js

@@ -0,0 +1,110 @@
+import isDataRecord from '../helpers/isDataRecord.js';
+import { resolveChannel } from '../helpers/resolve.js';
+import { stack, stackOffsetExpand, stackOffsetSilhouette, stackOffsetWiggle, stackOrderAppearance, stackOrderAscending, stackOrderInsideOut, stackOrderNone, stackOffsetDiverging } from 'd3-shape';
+import { index, union, groups as d3Groups } from 'd3-array';
+const DEFAULT_STACK_OPTIONS = {
+    order: null,
+    offset: null,
+    reverse: false
+};
+const STACK_ORDER = {
+    // null
+    // TODO: value: ,
+    none: stackOrderNone,
+    sum: stackOrderAscending,
+    appearance: stackOrderAppearance,
+    'inside-out': stackOrderInsideOut
+};
+const STACK_OFFSET = {
+    none: null,
+    diverging: stackOffsetDiverging,
+    wiggle: stackOffsetWiggle,
+    center: stackOffsetSilhouette,
+    normalize: stackOffsetExpand
+};
+function stackXY(byDim, data, channels, options) {
+    // we need to stack the data for each facet separately
+    const groupFacetsBy = [
+        channels.fx != null ? 'fx' : null,
+        channels.fy != null ? 'fy' : null
+    ].filter((d) => d !== null);
+    const groupBy = channels.z ? 'z' : channels.fill ? 'fill' : channels.stroke ? 'stroke' : true;
+    const secondDim = byDim === 'x' ? (channels.y1 != null ? 'y1' : 'y') : channels.x1 != null ? 'x1' : 'x';
+    const byLow = `${byDim}1`;
+    const byHigh = `${byDim}2`;
+    if (channels[byDim] != null &&
+        channels[`${byLow}`] === undefined &&
+        channels[`${byHigh}`] === undefined) {
+        // resolve all channels for easier computation below
+        const resolvedData = data.map((d) => ({
+            ...(isDataRecord(d) ? d : { __orig: d }),
+            [`__${secondDim}`]: resolveChannel(secondDim, d, channels),
+            __group: groupBy === true ? 'G' : resolveChannel(groupBy, d, channels),
+            __facet: groupFacetsBy.length > 0
+                ? groupFacetsBy
+                    .map((channel) => String(resolveChannel(channel, d, channels)))
+                    .join('---')
+                : 'F',
+            [`__${byDim}`]: resolveChannel(byDim, d, channels)
+        }));
+        // the final data ends up here
+        const out = [];
+        // first we group the dataset by facets to avoid stacking of rows that are
+        // in separate panels
+        const groups = d3Groups(resolvedData, (d) => d.__facet);
+        for (const [, facetData] of groups) {
+            // now we index the data on the second dimension, e.g. over x
+            // when stacking over y
+            const indexed = index(facetData, (d) => d[`__${secondDim}`], (d) => d.__group);
+            const stackOrder = (series) => {
+                const f = STACK_ORDER[options.order || 'none'];
+                return options.reverse ? f(series).reverse() : f(series);
+            };
+            // now stack the values for each index
+            const series = stack()
+                .order(stackOrder)
+                .offset(STACK_OFFSET[options.offset])
+                .keys(union(facetData.map((d) => d.__group)))
+                .value(([, group], key) => (group.get(key) ? group.get(key)[`__${byDim}`] : 0))(indexed);
+            // and combine it all back into a flat array
+            const newData = series
+                .map((values) => {
+                const groupKey = values.key;
+                return values
+                    .filter((d) => d.data[1].get(groupKey))
+                    .map((d) => {
+                    const datum = d.data[1].get(groupKey);
+                    // cleanup our internal keys
+                    delete datum.__group;
+                    delete datum.__facet;
+                    return { ...datum, [`__${byLow}`]: d[0], [`__${byHigh}`]: d[1] };
+                });
+            })
+                .flat(1);
+            // which we then add to the output data
+            out.push(newData);
+        }
+        return {
+            data: out.flat(1),
+            ...channels,
+            [byDim]: undefined,
+            ...(typeof channels[byDim] === 'string' && !channels[`__${byDim}_origField`]
+                ? { [`__${byDim}_origField`]: channels[byDim] }
+                : {}),
+            ...{ [byLow]: `__${byLow}`, [byHigh]: `__${byHigh}` }
+        };
+    }
+    return { data, ...channels };
+}
+export function stackY({ data, ...channels }, opts = {}) {
+    return stackXY('y', data, channels, applyDefaults(opts));
+}
+export function stackX({ data, ...channels }, opts = {}) {
+    return stackXY('x', data, channels, applyDefaults(opts));
+}
+function applyDefaults(opts) {
+    if (opts.offset === 'wiggle' && opts.order === undefined) {
+        return { ...DEFAULT_STACK_OPTIONS, order: 'inside-out', ...opts };
+    }
+    return { ...DEFAULT_STACK_OPTIONS, ...opts };
+}

package/dist/transforms/window.d.ts

@@ -0,0 +1,24 @@
+import { type ReducerName } from '../helpers/reduce.js';
+import type { DataRecord, TransformArg } from '../types.js';
+type WindowOptions = {
+    k: number;
+    interval: string;
+    anchor: 'start' | 'middle' | 'end';
+    reduce: ReducerName;
+    strict: boolean;
+};
+export declare function windowX(args: TransformArg<DataRecord>, options: WindowOptions): {
+    data: {
+        [x: string]: import("../types.js").RawValue;
+        [x: symbol]: import("../types.js").RawValue;
+        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
+    }[];
+};
+export declare function windowY(args: TransformArg<DataRecord>, options: WindowOptions): {
+    data: {
+        [x: string]: import("../types.js").RawValue;
+        [x: symbol]: import("../types.js").RawValue;
+        ___orig___?: import("../types.js").RawValue | [import("../types.js").RawValue, import("../types.js").RawValue];
+    }[];
+};
+export {};