react-native-wagmi-charts 2.9.0 → 2.10.0

package/lib/module/charts/line/utils/getPath.js

@@ -9,27 +9,14 @@ export function getPath({
   gutter,
   shape: _shape,
   yDomain,
-  xDomain,
+  xDomain
 }) {
-  const timestamps = data.map(({ timestamp }, i) => (xDomain ? timestamp : i));
-  const scaleX = scaleLinear()
-    .domain(xDomain ?? [Math.min(...timestamps), Math.max(...timestamps)])
-    .range([0, width]);
-  const scaleY = scaleLinear()
-    .domain([yDomain.min, yDomain.max])
-    .range([height - gutter, gutter]);
-  const path = shape
-    .line()
-    .defined((d) =>
-      from || to
-        ? !!data
-            .slice(from, to ? to + 1 : undefined)
-            .find((item) => item.timestamp === d.timestamp)
-        : true
-    )
-    .x((_, i) => scaleX(xDomain ? timestamps[i] ?? i : i))
-    .y((d) => scaleY(d.value))
-    .curve(_shape)(data);
+  const timestamps = data.map(({
+    timestamp
+  }, i) => xDomain ? timestamp : i);
+  const scaleX = scaleLinear().domain(xDomain ?? [Math.min(...timestamps), Math.max(...timestamps)]).range([0, width]);
+  const scaleY = scaleLinear().domain([yDomain.min, yDomain.max]).range([height - gutter, gutter]);
+  const path = shape.line().defined(d => from || to ? !!data.slice(from, to ? to + 1 : undefined).find(item => item.timestamp === d.timestamp) : true).x((_, i) => scaleX(xDomain ? timestamps[i] ?? i : i)).y(d => scaleY(d.value)).curve(_shape)(data);
   return path || '';
 }
-//# sourceMappingURL=getPath.js.map
+//# sourceMappingURL=getPath.js.map

package/lib/module/charts/line/utils/getXPositionForCurve.js

@@ -6,11 +6,8 @@ export function getXPositionForCurve(path, index) {
   }
   const point = path.curves[index - 1];
   if (point === undefined) {
-    throw new Error(
-      `Index out of bounds: ${index}. ` +
-        `Expected an integer in the range [0, ${path.curves.length}]`
-    );
+    throw new Error(`Index out of bounds: ${index}. ` + `Expected an integer in the range [0, ${path.curves.length}]`);
   }
   return point.to.x;
 }
-//# sourceMappingURL=getXPositionForCurve.js.map
+//# sourceMappingURL=getXPositionForCurve.js.map

package/lib/module/charts/line/utils/index.js

@@ -3,4 +3,4 @@ export * from './getDomain';
 export * from './getPath';
 export * from './interpolatePath';
 export * from './lineChartDataPropToArray';
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/lib/module/charts/line/utils/interpolatePath.js

@@ -36,10 +36,7 @@ function decasteljau(points, t) {
         if (i === newPoints.length - 1) {
           right.push(points[i + 1]);
         }
-        newPoints[i] = [
-          (1 - t) * points[i][0] + t * points[i + 1][0],
-          (1 - t) * points[i][1] + t * points[i + 1][1],
-        ];
+        newPoints[i] = [(1 - t) * points[i][0] + t * points[i + 1][0], (1 - t) * points[i][1] + t * points[i + 1][1]];
       }
       decasteljauRecurse(newPoints, t);
     }
@@ -49,7 +46,7 @@ function decasteljau(points, t) {
   }
   return {
     left,
-    right: right.reverse(),
+    right: right.reverse()
   };
 }
 
@@ -166,11 +163,11 @@ const typeMap = {
   Q: ['x1', 'y1', 'x', 'y'],
   T: ['x', 'y'],
   A: ['rx', 'ry', 'xAxisRotation', 'largeArcFlag', 'sweepFlag', 'x', 'y'],
-  Z: [],
+  Z: []
 };
 
 // Add lower case entries too matching uppercase (e.g. 'm' == 'M')
-Object.keys(typeMap).forEach((key) => {
+Object.keys(typeMap).forEach(key => {
   typeMap[key.toLowerCase()] = typeMap[key];
 });
 function arrayOfLength(length, value) {
@@ -191,9 +188,7 @@ function arrayOfLength(length, value) {
 function commandToString(command) {
   'worklet';
 
-  return `${command.type}${typeMap[command.type]
-    .map((p) => command[p])
-    .join(',')}`;
+  return `${command.type}${typeMap[command.type].map(p => command[p]).join(',')}`;
 }
 
 /**
@@ -223,14 +218,14 @@ function convertToSameType(aCommand, bCommand) {
     x1: 'x',
     y1: 'y',
     x2: 'x',
-    y2: 'y',
+    y2: 'y'
   };
   const readFromBKeys = ['xAxisRotation', 'largeArcFlag', 'sweepFlag'];
 
   // convert (but ignore M types)
   if (aCommand.type !== bCommand.type && bCommand.type.toUpperCase() !== 'M') {
     const aConverted = {};
-    Object.keys(bCommand).forEach((bKey) => {
+    Object.keys(bCommand).forEach(bKey => {
       const bValue = bCommand[bKey];
       // first read from the A command
       let aValue = aCommand[bKey];
@@ -279,14 +274,8 @@ function splitSegment(commandStart, commandEnd, segmentCount) {
   let segments = [];
 
   // line, quadratic bezier, or cubic bezier
-  if (
-    commandEnd.type === 'L' ||
-    commandEnd.type === 'Q' ||
-    commandEnd.type === 'C'
-  ) {
-    segments = segments.concat(
-      splitCurve(commandStart, commandEnd, segmentCount)
-    );
+  if (commandEnd.type === 'L' || commandEnd.type === 'Q' || commandEnd.type === 'C') {
+    segments = segments.concat(splitCurve(commandStart, commandEnd, segmentCount));
 
     // general case - just copy the same point
   } else {
@@ -296,9 +285,7 @@ function splitSegment(commandStart, commandEnd, segmentCount) {
     if (copyCommand.type === 'M') {
       copyCommand.type = 'L';
     }
-    segments = segments.concat(
-      arrayOfLength(segmentCount - 1).map(() => copyCommand)
-    );
+    segments = segments.concat(arrayOfLength(segmentCount - 1).map(() => copyCommand));
     segments.push(commandEnd);
   }
   return segments;
@@ -331,69 +318,56 @@ function extend(commandsToExtend, referenceCommands, excludeSegment) {
   // should be added in that segment (should always be >= 1 since we need each
   // point itself).
   // 0 = segment 0-1, 1 = segment 1-2, n-1 = last vertex
-  const countPointsPerSegment = arrayOfLength(numReferenceSegments).reduce(
-    (accum, d, i) => {
-      let insertIndex = Math.floor(segmentRatio * i);
-
-      // handle excluding segments
-      if (
-        excludeSegment &&
-        insertIndex < commandsToExtend.length - 1 &&
-        excludeSegment(
-          commandsToExtend[insertIndex],
-          commandsToExtend[insertIndex + 1]
-        )
-      ) {
-        // set the insertIndex to the segment that this point should be added to:
-
-        // round the insertIndex essentially so we split half and half on
-        // neighbouring segments. hence the segmentRatio * i < 0.5
-        const addToPriorSegment = (segmentRatio * i) % 1 < 0.5;
-
-        // only skip segment if we already have 1 point in it (can't entirely remove a segment)
-        if (accum[insertIndex]) {
-          // TODO - Note this is a naive algorithm that should work for most d3-area use cases
-          // but if two adjacent segments are supposed to be skipped, this will not perform as
-          // expected. Could be updated to search for nearest segment to place the point in, but
-          // will only do that if necessary.
-
-          // add to the prior segment
-          if (addToPriorSegment) {
-            if (insertIndex > 0) {
-              insertIndex -= 1;
-
-              // not possible to add to previous so adding to next
-            } else if (insertIndex < commandsToExtend.length - 1) {
-              insertIndex += 1;
-            }
-            // add to next segment
+  const countPointsPerSegment = arrayOfLength(numReferenceSegments).reduce((accum, d, i) => {
+    let insertIndex = Math.floor(segmentRatio * i);
+
+    // handle excluding segments
+    if (excludeSegment && insertIndex < commandsToExtend.length - 1 && excludeSegment(commandsToExtend[insertIndex], commandsToExtend[insertIndex + 1])) {
+      // set the insertIndex to the segment that this point should be added to:
+
+      // round the insertIndex essentially so we split half and half on
+      // neighbouring segments. hence the segmentRatio * i < 0.5
+      const addToPriorSegment = segmentRatio * i % 1 < 0.5;
+
+      // only skip segment if we already have 1 point in it (can't entirely remove a segment)
+      if (accum[insertIndex]) {
+        // TODO - Note this is a naive algorithm that should work for most d3-area use cases
+        // but if two adjacent segments are supposed to be skipped, this will not perform as
+        // expected. Could be updated to search for nearest segment to place the point in, but
+        // will only do that if necessary.
+
+        // add to the prior segment
+        if (addToPriorSegment) {
+          if (insertIndex > 0) {
+            insertIndex -= 1;
+
+            // not possible to add to previous so adding to next
           } else if (insertIndex < commandsToExtend.length - 1) {
             insertIndex += 1;
-
-            // not possible to add to next so adding to previous
-          } else if (insertIndex > 0) {
-            insertIndex -= 1;
           }
+          // add to next segment
+        } else if (insertIndex < commandsToExtend.length - 1) {
+          insertIndex += 1;
+
+          // not possible to add to next so adding to previous
+        } else if (insertIndex > 0) {
+          insertIndex -= 1;
         }
       }
-      accum[insertIndex] = (accum[insertIndex] || 0) + 1;
-      return accum;
-    },
-    []
-  );
+    }
+    accum[insertIndex] = (accum[insertIndex] || 0) + 1;
+    return accum;
+  }, []);
 
   // extend each segment to have the correct number of points for a smooth interpolation
   const extended = countPointsPerSegment.reduce((extended, segmentCount, i) => {
     // if last command, just add `segmentCount` number of times
     if (i === commandsToExtend.length - 1) {
-      const lastCommandCopies = arrayOfLength(
-        segmentCount,
-        Object.assign({}, commandsToExtend[commandsToExtend.length - 1])
-      );
+      const lastCommandCopies = arrayOfLength(segmentCount, Object.assign({}, commandsToExtend[commandsToExtend.length - 1]));
 
       // convert M to L
       if (lastCommandCopies[0].type === 'M') {
-        lastCommandCopies.forEach((d) => {
+        lastCommandCopies.forEach(d => {
           d.type = 'L';
         });
       }
@@ -401,9 +375,7 @@ function extend(commandsToExtend, referenceCommands, excludeSegment) {
     }
 
     // otherwise, split the segment segmentCount times.
-    return extended.concat(
-      splitSegment(commandsToExtend[i], commandsToExtend[i + 1], segmentCount)
-    );
+    return extended.concat(splitSegment(commandsToExtend[i], commandsToExtend[i + 1], segmentCount));
   }, []);
 
   // add in the very first point since splitSegment only adds in the ones after it
@@ -434,7 +406,7 @@ export function pathCommandsFromString(d) {
     // new command found:
     if (commandArgs) {
       command = {
-        type: tokens[i],
+        type: tokens[i]
       };
 
       // add each of the expected args for this command:
@@ -467,11 +439,7 @@ export function pathCommandsFromString(d) {
  *   end command object and returns true if the segment should be excluded from splitting.
  * @returns {Function} Interpolation function that maps t ([0, 1]) to an array of path commands.
  */
-export function interpolatePathCommands(
-  aCommandsInput,
-  bCommandsInput,
-  excludeSegment
-) {
+export function interpolatePathCommands(aCommandsInput, bCommandsInput, excludeSegment) {
   'worklet';
 
   // make a copy so we don't mess with the input arrays
@@ -488,9 +456,7 @@ export function interpolatePathCommands(
   }
 
   // do we add Z during interpolation? yes if both have it. (we'd expect both to have it or not)
-  const addZ =
-    (aCommands.length === 0 || aCommands[aCommands.length - 1].type === 'Z') &&
-    (bCommands.length === 0 || bCommands[bCommands.length - 1].type === 'Z');
+  const addZ = (aCommands.length === 0 || aCommands[aCommands.length - 1].type === 'Z') && (bCommands.length === 0 || bCommands[bCommands.length - 1].type === 'Z');
 
   // we temporarily remove Z
   if (aCommands.length > 0 && aCommands[aCommands.length - 1].type === 'Z') {
@@ -526,18 +492,16 @@ export function interpolatePathCommands(
 
   // commands have same length now.
   // convert commands in A to the same type as those in B
-  aCommands = aCommands.map((aCommand, i) =>
-    convertToSameType(aCommand, bCommands[i])
-  );
+  aCommands = aCommands.map((aCommand, i) => convertToSameType(aCommand, bCommands[i]));
 
   // create mutable interpolated command objects
-  const interpolatedCommands = aCommands.map((aCommand) => aCommand);
+  const interpolatedCommands = aCommands.map(aCommand => aCommand);
   if (addZ) {
     interpolatedCommands.push({
-      type: 'Z',
+      type: 'Z'
     });
     aCommands.push({
-      type: 'Z',
+      type: 'Z'
     }); // required for when returning at t == 0
   }
   return function pathCommandInterpolator(t) {
@@ -599,11 +563,7 @@ export function interpolatePath(a, b, excludeSegment) {
       return '';
     };
   }
-  const commandInterpolator = interpolatePathCommands(
-    aCommands,
-    bCommands,
-    excludeSegment
-  );
+  const commandInterpolator = interpolatePathCommands(aCommands, bCommands, excludeSegment);
   return function pathStringInterpolator(t) {
     'worklet';
 
@@ -622,4 +582,4 @@ export function interpolatePath(a, b, excludeSegment) {
     return interpolatedString;
   };
 }
-//# sourceMappingURL=interpolatePath.js.map
+//# sourceMappingURL=interpolatePath.js.map

package/lib/module/charts/line/utils/lineChartDataPropToArray.js

@@ -8,11 +8,11 @@ export function lineChartDataPropToArray(dataProp) {
     return dataProp;
   }
   const data = [];
-  Object.values(dataProp).forEach((dataSet) => {
+  Object.values(dataProp).forEach(dataSet => {
     if (dataSet) {
       data.push(...dataSet);
     }
   });
   return data;
 }
-//# sourceMappingURL=lineChartDataPropToArray.js.map
+//# sourceMappingURL=lineChartDataPropToArray.js.map

package/lib/module/components/AnimatedText.js

@@ -3,46 +3,42 @@
 import React from 'react';
 import { Platform, StyleSheet } from 'react-native';
 import { TextInput } from 'react-native';
-import Animated, {
-  useAnimatedProps,
-  useAnimatedReaction,
-} from 'react-native-reanimated';
+import Animated, { useAnimatedProps, useAnimatedReaction } from 'react-native-reanimated';
 Animated.addWhitelistedNativeProps({
-  text: true,
+  text: true
 });
 const AnimatedTextInput = Animated.createAnimatedComponent(TextInput);
-export const AnimatedText = ({ text, style }) => {
+export const AnimatedText = ({
+  text,
+  style
+}) => {
   const inputRef = React.useRef(null);
-  useAnimatedReaction(
-    () => text.value,
-    (data, prevData) => {
-      // Only execute for web platform
-      if (Platform.OS === 'web' && data !== prevData && inputRef.current) {
-        // @ts-expect-error - web TextInput has value property
-        inputRef.current.value = data;
-      }
-    },
-    [text]
-  );
+  useAnimatedReaction(() => text.value, (data, prevData) => {
+    // Only execute for web platform
+    if (Platform.OS === 'web' && data !== prevData && inputRef.current) {
+      // @ts-expect-error - web TextInput has value property
+      inputRef.current.value = data;
+    }
+  }, [text]);
   const animatedProps = useAnimatedProps(() => {
     return {
-      text: text.value,
+      text: text.value
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     };
   });
-  return /*#__PURE__*/ React.createElement(AnimatedTextInput, {
-    underlineColorAndroid: 'transparent',
+  return /*#__PURE__*/React.createElement(AnimatedTextInput, {
+    underlineColorAndroid: "transparent",
     editable: false,
     ref: Platform.select({
-      web: inputRef,
+      web: inputRef
     }),
     style: [styles.text, style],
-    animatedProps: animatedProps,
+    animatedProps: animatedProps
   });
 };
 const styles = StyleSheet.create({
   text: {
-    color: 'black',
-  },
+    color: 'black'
+  }
 });
-//# sourceMappingURL=AnimatedText.js.map
+//# sourceMappingURL=AnimatedText.js.map

package/lib/module/index.js

@@ -3,4 +3,4 @@ export * from './charts/line';
 export * from './components/AnimatedText';
 export * from './utils';
 export * from './types';
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/lib/module/types.js

@@ -1 +1,2 @@
-//# sourceMappingURL=types.js.map
+
+//# sourceMappingURL=types.js.map

package/lib/module/utils/formatDatetime.js

@@ -1,10 +1,14 @@
 /**
  * @worklet
  */
-export function formatDatetime({ value, locale = 'en-US', options = {} }) {
+export function formatDatetime({
+  value,
+  locale = 'en-US',
+  options = {}
+}) {
   'worklet';
 
   const d = new Date(value);
   return d.toLocaleString(locale, options);
 }
-//# sourceMappingURL=formatDatetime.js.map
+//# sourceMappingURL=formatDatetime.js.map

package/lib/module/utils/formatPrice.js

@@ -4,7 +4,7 @@
 export function formatPrice({
   value: _value,
   defaultPrice: _defaultPrice = '',
-  precision,
+  precision
 }) {
   'worklet';
 
@@ -16,11 +16,7 @@ export function formatPrice({
   if (!value) {
     return `0.00`;
   }
-  const decimals =
-    precision ??
-    (Number(value) < 1
-      ? Math.min(8, value.toString().slice(2).search(/[^0]/g) + 3)
-      : 2);
+  const decimals = precision ?? (Number(value) < 1 ? Math.min(8, value.toString().slice(2).search(/[^0]/g) + 3) : 2);
   let res = `${Number(value).toFixed(decimals)}`;
   const vals = res.split('.');
   if (vals.length > 0 && vals[0]) {
@@ -31,4 +27,4 @@ export function formatPrice({
   }
   return res;
 }
-//# sourceMappingURL=formatPrice.js.map
+//# sourceMappingURL=formatPrice.js.map

package/lib/module/utils/index.js

@@ -1,4 +1,4 @@
 export * from './formatDatetime';
 export * from './formatPrice';
 export * from './usePrevious';
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/lib/module/utils/usePrevious.js

@@ -10,4 +10,4 @@ export function usePrevious(value) {
   // Return previous value (happens before update in useEffect above)
   return ref.current;
 }
-//# sourceMappingURL=usePrevious.js.map
+//# sourceMappingURL=usePrevious.js.map

package/lib/typescript/src/charts/candle/Candle.d.ts

@@ -3,50 +3,36 @@ import { ColorValue } from 'react-native';
 import { LineProps, NumberProp, RectProps } from 'react-native-svg';
 import type { TCandle, TDomain } from './types';
 export type CandlestickChartCandleProps = {
-  candle: TCandle;
-  domain: TDomain;
-  maxHeight: number;
-  margin?: number;
-  positiveColor?: string;
-  negativeColor?: string;
-  index: number;
-  width: number;
-  rectProps?: RectProps;
-  lineProps?: LineProps;
-  useAnimations?: boolean;
-  renderRect?: (renderRectOptions: {
-    x: NumberProp;
-    y: NumberProp;
-    width: NumberProp;
-    height: NumberProp;
-    fill: ColorValue;
-    useAnimations: boolean;
     candle: TCandle;
-  }) => React.ReactNode;
-  renderLine?: (renderLineOptions: {
-    x1: NumberProp;
-    y1: NumberProp;
-    x2: NumberProp;
-    y2: NumberProp;
-    stroke: ColorValue;
-    strokeWidth: NumberProp;
-    useAnimations: boolean;
-    candle: TCandle;
-  }) => React.ReactNode;
+    domain: TDomain;
+    maxHeight: number;
+    margin?: number;
+    positiveColor?: string;
+    negativeColor?: string;
+    index: number;
+    width: number;
+    rectProps?: RectProps;
+    lineProps?: LineProps;
+    useAnimations?: boolean;
+    renderRect?: (renderRectOptions: {
+        x: NumberProp;
+        y: NumberProp;
+        width: NumberProp;
+        height: NumberProp;
+        fill: ColorValue;
+        useAnimations: boolean;
+        candle: TCandle;
+    }) => React.ReactNode;
+    renderLine?: (renderLineOptions: {
+        x1: NumberProp;
+        y1: NumberProp;
+        x2: NumberProp;
+        y2: NumberProp;
+        stroke: ColorValue;
+        strokeWidth: NumberProp;
+        useAnimations: boolean;
+        candle: TCandle;
+    }) => React.ReactNode;
 };
-export declare const CandlestickChartCandle: ({
-  candle,
-  maxHeight,
-  domain,
-  margin,
-  positiveColor,
-  negativeColor,
-  rectProps: overrideRectProps,
-  lineProps: overrideLineProps,
-  index,
-  width,
-  useAnimations,
-  renderLine,
-  renderRect,
-}: CandlestickChartCandleProps) => React.JSX.Element;
-//# sourceMappingURL=Candle.d.ts.map
+export declare const CandlestickChartCandle: ({ candle, maxHeight, domain, margin, positiveColor, negativeColor, rectProps: overrideRectProps, lineProps: overrideLineProps, index, width, useAnimations, renderLine, renderRect, }: CandlestickChartCandleProps) => React.JSX.Element;
+//# sourceMappingURL=Candle.d.ts.map

package/lib/typescript/src/charts/candle/Candles.d.ts

@@ -2,29 +2,18 @@ import React from 'react';
 import { SvgProps } from 'react-native-svg';
 import { CandlestickChartCandleProps } from './Candle';
 type CandlestickChartCandlesProps = SvgProps & {
-  width?: number;
-  height?: number;
-  margin?: CandlestickChartCandleProps['margin'];
-  positiveColor?: CandlestickChartCandleProps['positiveColor'];
-  negativeColor?: CandlestickChartCandleProps['negativeColor'];
-  renderRect?: CandlestickChartCandleProps['renderRect'];
-  renderLine?: CandlestickChartCandleProps['renderLine'];
-  rectProps?: CandlestickChartCandleProps['rectProps'];
-  lineProps?: CandlestickChartCandleProps['lineProps'];
-  candleProps?: Partial<CandlestickChartCandleProps>;
-  useAnimations?: boolean;
+    width?: number;
+    height?: number;
+    margin?: CandlestickChartCandleProps['margin'];
+    positiveColor?: CandlestickChartCandleProps['positiveColor'];
+    negativeColor?: CandlestickChartCandleProps['negativeColor'];
+    renderRect?: CandlestickChartCandleProps['renderRect'];
+    renderLine?: CandlestickChartCandleProps['renderLine'];
+    rectProps?: CandlestickChartCandleProps['rectProps'];
+    lineProps?: CandlestickChartCandleProps['lineProps'];
+    candleProps?: Partial<CandlestickChartCandleProps>;
+    useAnimations?: boolean;
 };
-export declare function CandlestickChartCandles({
-  positiveColor,
-  negativeColor,
-  rectProps,
-  lineProps,
-  margin,
-  useAnimations,
-  renderRect,
-  renderLine,
-  candleProps,
-  ...props
-}: CandlestickChartCandlesProps): React.JSX.Element;
+export declare function CandlestickChartCandles({ positiveColor, negativeColor, rectProps, lineProps, margin, useAnimations, renderRect, renderLine, candleProps, ...props }: CandlestickChartCandlesProps): React.JSX.Element;
 export {};
-//# sourceMappingURL=Candles.d.ts.map
+//# sourceMappingURL=Candles.d.ts.map

package/lib/typescript/src/charts/candle/Chart.d.ts

@@ -1,19 +1,14 @@
 import React from 'react';
 import { ViewProps } from 'react-native';
 export declare const CandlestickChartDimensionsContext: React.Context<{
-  width: number;
-  height: number;
+    width: number;
+    height: number;
 }>;
 type CandlestickChartProps = ViewProps & {
-  children: React.ReactNode;
-  width?: number;
-  height?: number;
+    children: React.ReactNode;
+    width?: number;
+    height?: number;
 };
-export declare function CandlestickChart({
-  children,
-  width,
-  height,
-  ...props
-}: CandlestickChartProps): React.JSX.Element;
+export declare function CandlestickChart({ children, width, height, ...props }: CandlestickChartProps): React.JSX.Element;
 export {};
-//# sourceMappingURL=Chart.d.ts.map
+//# sourceMappingURL=Chart.d.ts.map