chartist 0.11.4 → 1.0.0

package/dist/interpolation/cardinal.d.ts

@@ -0,0 +1,28 @@
+import type { SegmentData } from '../core';
+import { SvgPath } from '../svg';
+export interface CardinalInterpolationOptions {
+    tension?: number;
+    fillHoles?: boolean;
+}
+/**
+ * Cardinal / Catmull-Rome spline interpolation is the default smoothing function in Chartist. It produces nice results where the splines will always meet the points. It produces some artifacts though when data values are increased or decreased rapidly. The line may not follow a very accurate path and if the line should be accurate this smoothing function does not produce the best results.
+ *
+ * Cardinal splines can only be created if there are more than two data points. If this is not the case this smoothing will fallback to `Chartist.Smoothing.none`.
+ *
+ * All smoothing functions within Chartist are factory functions that accept an options parameter. The cardinal interpolation function accepts one configuration parameter `tension`, between 0 and 1, which controls the smoothing intensity.
+ *
+ * @example
+ * const chart = new LineChart('.ct-chart', {
+ *   labels: [1, 2, 3, 4, 5],
+ *   series: [[1, 2, 8, 1, 7]]
+ * }, {
+ *   lineSmooth: Interpolation.cardinal({
+ *     tension: 1,
+ *     fillHoles: false
+ *   })
+ * });
+ *
+ * @param options The options of the cardinal factory function.
+ */
+export declare function cardinal(options?: CardinalInterpolationOptions): (pathCoordinates: number[], valueData: SegmentData[]) => SvgPath;
+//# sourceMappingURL=cardinal.d.ts.map

package/dist/interpolation/cardinal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardinal.d.ts","sourceRoot":"","sources":["../../src/interpolation/cardinal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGjC,MAAM,WAAW,4BAA4B;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,OAAO,CAAC,EAAE,4BAA4B,qBAW1C,MAAM,EAAE,aACd,WAAW,EAAE,KACvB,OAAO,CAsFX"}

package/dist/interpolation/index.d.ts

@@ -0,0 +1,6 @@
+export * from './none';
+export * from './simple';
+export * from './step';
+export * from './cardinal';
+export * from './monotoneCubic';
+//# sourceMappingURL=index.d.ts.map

package/dist/interpolation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interpolation/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/dist/interpolation/monotoneCubic.d.ts

@@ -0,0 +1,28 @@
+import type { SegmentData } from '../core';
+import { SvgPath } from '../svg';
+export interface MonotoneCubicInterpolationOptions {
+    fillHoles?: boolean;
+}
+/**
+ * Monotone Cubic spline interpolation produces a smooth curve which preserves monotonicity. Unlike cardinal splines, the curve will not extend beyond the range of y-values of the original data points.
+ *
+ * Monotone Cubic splines can only be created if there are more than two data points. If this is not the case this smoothing will fallback to `Chartist.Smoothing.none`.
+ *
+ * The x-values of subsequent points must be increasing to fit a Monotone Cubic spline. If this condition is not met for a pair of adjacent points, then there will be a break in the curve between those data points.
+ *
+ * All smoothing functions within Chartist are factory functions that accept an options parameter.
+ *
+ * @example
+ * const chart = new LineChart('.ct-chart', {
+ *   labels: [1, 2, 3, 4, 5],
+ *   series: [[1, 2, 8, 1, 7]]
+ * }, {
+ *   lineSmooth: Interpolation.monotoneCubic({
+ *     fillHoles: false
+ *   })
+ * });
+ *
+ * @param options The options of the monotoneCubic factory function.
+ */
+export declare function monotoneCubic(options?: MonotoneCubicInterpolationOptions): (pathCoordinates: number[], valueData: SegmentData[]) => SvgPath;
+//# sourceMappingURL=monotoneCubic.d.ts.map

package/dist/interpolation/monotoneCubic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monotoneCubic.d.ts","sourceRoot":"","sources":["../../src/interpolation/monotoneCubic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGjC,MAAM,WAAW,iCAAiC;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,iCAAiC,qBAOpD,MAAM,EAAE,aACd,WAAW,EAAE,KACvB,OAAO,CAgGX"}

package/dist/interpolation/none.d.ts

@@ -0,0 +1,20 @@
+import type { SegmentData } from '../core';
+import { SvgPath } from '../svg';
+export interface NoneInterpolationOptions {
+    fillHoles?: boolean;
+}
+/**
+ * This interpolation function does not smooth the path and the result is only containing lines and no curves.
+ *
+ * @example
+ * const chart = new LineChart('.ct-chart', {
+ *   labels: [1, 2, 3, 4, 5],
+ *   series: [[1, 2, 8, 1, 7]]
+ * }, {
+ *   lineSmooth: Interpolation.none({
+ *     fillHoles: false
+ *   })
+ * });
+ */
+export declare function none(options?: NoneInterpolationOptions): (pathCoordinates: number[], valueData: SegmentData[]) => SvgPath;
+//# sourceMappingURL=none.d.ts.map

package/dist/interpolation/none.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"none.d.ts","sourceRoot":"","sources":["../../src/interpolation/none.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,OAAO,CAAC,EAAE,wBAAwB,qBAOlC,MAAM,EAAE,aACd,WAAW,EAAE,aAyB3B"}

package/dist/interpolation/simple.d.ts

@@ -0,0 +1,28 @@
+import type { SegmentData } from '../core/types';
+import { SvgPath } from '../svg';
+export interface SimpleInteractionOptions {
+    divisor?: number;
+    fillHoles?: boolean;
+}
+/**
+ * Simple smoothing creates horizontal handles that are positioned with a fraction of the length between two data points. You can use the divisor option to specify the amount of smoothing.
+ *
+ * Simple smoothing can be used instead of `Chartist.Smoothing.cardinal` if you'd like to get rid of the artifacts it produces sometimes. Simple smoothing produces less flowing lines but is accurate by hitting the points and it also doesn't swing below or above the given data point.
+ *
+ * All smoothing functions within Chartist are factory functions that accept an options parameter. The simple interpolation function accepts one configuration parameter `divisor`, between 1 and ∞, which controls the smoothing characteristics.
+ *
+ * @example
+ * const chart = new LineChart('.ct-chart', {
+ *   labels: [1, 2, 3, 4, 5],
+ *   series: [[1, 2, 8, 1, 7]]
+ * }, {
+ *   lineSmooth: Interpolation.simple({
+ *     divisor: 2,
+ *     fillHoles: false
+ *   })
+ * });
+ *
+ * @param options The options of the simple interpolation factory function.
+ */
+export declare function simple(options?: SimpleInteractionOptions): (pathCoordinates: number[], valueData: SegmentData[]) => SvgPath;
+//# sourceMappingURL=simple.d.ts.map

package/dist/interpolation/simple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.d.ts","sourceRoot":"","sources":["../../src/interpolation/simple.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,MAAM,WAAW,wBAAwB;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,OAAO,CAAC,EAAE,wBAAwB,qBAUpC,MAAM,EAAE,aACd,WAAW,EAAE,aAwC3B"}

package/dist/interpolation/step.d.ts

@@ -0,0 +1,24 @@
+import type { SegmentData } from '../core';
+import { SvgPath } from '../svg';
+export interface StepInterpolationOptions {
+    postpone?: boolean;
+    fillHoles?: boolean;
+}
+/**
+ * Step interpolation will cause the line chart to move in steps rather than diagonal or smoothed lines. This interpolation will create additional points that will also be drawn when the `showPoint` option is enabled.
+ *
+ * All smoothing functions within Chartist are factory functions that accept an options parameter. The step interpolation function accepts one configuration parameter `postpone`, that can be `true` or `false`. The default value is `true` and will cause the step to occur where the value actually changes. If a different behaviour is needed where the step is shifted to the left and happens before the actual value, this option can be set to `false`.
+ *
+ * @example
+ * var chart = new Chartist.Line('.ct-chart', {
+ *   labels: [1, 2, 3, 4, 5],
+ *   series: [[1, 2, 8, 1, 7]]
+ * }, {
+ *   lineSmooth: Interpolation.step({
+ *     postpone: true,
+ *     fillHoles: false
+ *   })
+ * });
+ */
+export declare function step(options?: StepInterpolationOptions): (pathCoordinates: number[], valueData: SegmentData[]) => SvgPath;
+//# sourceMappingURL=step.d.ts.map

package/dist/interpolation/step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/interpolation/step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAEjC,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,OAAO,CAAC,EAAE,wBAAwB,qBAQlC,MAAM,EAAE,aACd,WAAW,EAAE,aAwC3B"}

package/dist/svg/Svg.d.ts

@@ -0,0 +1,201 @@
+import type { EventEmitter } from '../event';
+import type { Attributes, AnimationDefinition } from './types';
+import { SvgList } from './SvgList';
+/**
+ * Svg creates a new SVG object wrapper with a starting element. You can use the wrapper to fluently create sub-elements and modify them.
+ */
+export declare class Svg {
+    /**
+     * @todo Only there for chartist <1 compatibility. Remove after deprecation warining.
+     * @deprecated Use the animation module export `easings` directly.
+     */
+    static readonly Easing: {
+        easeInSine: number[];
+        easeOutSine: number[];
+        easeInOutSine: number[];
+        easeInQuad: number[];
+        easeOutQuad: number[];
+        easeInOutQuad: number[];
+        easeInCubic: number[];
+        easeOutCubic: number[];
+        easeInOutCubic: number[];
+        easeInQuart: number[];
+        easeOutQuart: number[];
+        easeInOutQuart: number[];
+        easeInQuint: number[];
+        easeOutQuint: number[];
+        easeInOutQuint: number[];
+        easeInExpo: number[];
+        easeOutExpo: number[];
+        easeInOutExpo: number[];
+        easeInCirc: number[];
+        easeOutCirc: number[];
+        easeInOutCirc: number[];
+        easeInBack: number[];
+        easeOutBack: number[];
+        easeInOutBack: number[];
+    };
+    private _node;
+    /**
+     * @param name The name of the SVG element to create or an SVG dom element which should be wrapped into Svg
+     * @param attributes An object with properties that will be added as attributes to the SVG element that is created. Attributes with undefined values will not be added.
+     * @param className This class or class list will be added to the SVG element
+     * @param parent The parent SVG wrapper object where this newly created wrapper and it's element will be attached to as child
+     * @param insertFirst If this param is set to true in conjunction with a parent element the newly created element will be added as first child element in the parent element
+     */
+    constructor(name: string | Element, attributes?: Attributes, className?: string, parent?: Svg, insertFirst?: boolean);
+    /**
+     * Set attributes on the current SVG element of the wrapper you're currently working on.
+     * @param attributes An object with properties that will be added as attributes to the SVG element that is created. Attributes with undefined values will not be added. If this parameter is a String then the function is used as a getter and will return the attribute value.
+     * @param ns If specified, the attribute will be obtained using getAttributeNs. In order to write namepsaced attributes you can use the namespace:attribute notation within the attributes object.
+     * @return The current wrapper object will be returned so it can be used for chaining or the attribute value if used as getter function.
+     */
+    attr(attributes: string, ns?: string): string | null;
+    attr(attributes: Attributes): this;
+    /**
+     * Create a new SVG element whose wrapper object will be selected for further operations. This way you can also create nested groups easily.
+     * @param name The name of the SVG element that should be created as child element of the currently selected element wrapper
+     * @param attributes An object with properties that will be added as attributes to the SVG element that is created. Attributes with undefined values will not be added.
+     * @param className This class or class list will be added to the SVG element
+     * @param insertFirst If this param is set to true in conjunction with a parent element the newly created element will be added as first child element in the parent element
+     * @return Returns a Svg wrapper object that can be used to modify the containing SVG data
+     */
+    elem(name: string, attributes?: Attributes, className?: string, insertFirst?: boolean): Svg;
+    /**
+     * Returns the parent Chartist.SVG wrapper object
+     * @return Returns a Svg wrapper around the parent node of the current node. If the parent node is not existing or it's not an SVG node then this function will return null.
+     */
+    parent(): Svg | null;
+    /**
+     * This method returns a Svg wrapper around the root SVG element of the current tree.
+     * @return The root SVG element wrapped in a Svg element
+     */
+    root(): Svg;
+    /**
+     * Find the first child SVG element of the current element that matches a CSS selector. The returned object is a Svg wrapper.
+     * @param selector A CSS selector that is used to query for child SVG elements
+     * @return The SVG wrapper for the element found or null if no element was found
+     */
+    querySelector(selector: string): Svg | null;
+    /**
+     * Find the all child SVG elements of the current element that match a CSS selector. The returned object is a Svg.List wrapper.
+     * @param selector A CSS selector that is used to query for child SVG elements
+     * @return The SVG wrapper list for the element found or null if no element was found
+     */
+    querySelectorAll(selector: string): SvgList;
+    /**
+     * Returns the underlying SVG node for the current element.
+     */
+    getNode(): Element;
+    /**
+     * This method creates a foreignObject (see https://developer.mozilla.org/en-US/docs/Web/SVG/Element/foreignObject) that allows to embed HTML content into a SVG graphic. With the help of foreignObjects you can enable the usage of regular HTML elements inside of SVG where they are subject for SVG positioning and transformation but the Browser will use the HTML rendering capabilities for the containing DOM.
+     * @param content The DOM Node, or HTML string that will be converted to a DOM Node, that is then placed into and wrapped by the foreignObject
+     * @param attributes An object with properties that will be added as attributes to the foreignObject element that is created. Attributes with undefined values will not be added.
+     * @param className This class or class list will be added to the SVG element
+     * @param insertFirst Specifies if the foreignObject should be inserted as first child
+     * @return New wrapper object that wraps the foreignObject element
+     */
+    foreignObject(content: string | Node, attributes?: Attributes, className?: string, insertFirst?: boolean): Svg;
+    /**
+     * This method adds a new text element to the current Svg wrapper.
+     * @param t The text that should be added to the text element that is created
+     * @return The same wrapper object that was used to add the newly created element
+     */
+    text(t: string): this;
+    /**
+     * This method will clear all child nodes of the current wrapper object.
+     * @return The same wrapper object that got emptied
+     */
+    empty(): this;
+    /**
+     * This method will cause the current wrapper to remove itself from its parent wrapper. Use this method if you'd like to get rid of an element in a given DOM structure.
+     * @return The parent wrapper object of the element that got removed
+     */
+    remove(): Svg | null;
+    /**
+     * This method will replace the element with a new element that can be created outside of the current DOM.
+     * @param newElement The new Svg object that will be used to replace the current wrapper object
+     * @return The wrapper of the new element
+     */
+    replace(newElement: Svg): Svg;
+    /**
+     * This method will append an element to the current element as a child.
+     * @param element The Svg element that should be added as a child
+     * @param insertFirst Specifies if the element should be inserted as first child
+     * @return The wrapper of the appended object
+     */
+    append(element: Svg, insertFirst?: boolean): this;
+    /**
+     * Returns an array of class names that are attached to the current wrapper element. This method can not be chained further.
+     * @return A list of classes or an empty array if there are no classes on the current element
+     */
+    classes(): string[];
+    /**
+     * Adds one or a space separated list of classes to the current element and ensures the classes are only existing once.
+     * @param names A white space separated list of class names
+     * @return The wrapper of the current element
+     */
+    addClass(names: string): this;
+    /**
+     * Removes one or a space separated list of classes from the current element.
+     * @param names A white space separated list of class names
+     * @return The wrapper of the current element
+     */
+    removeClass(names: string): this;
+    /**
+     * Removes all classes from the current element.
+     * @return The wrapper of the current element
+     */
+    removeAllClasses(): this;
+    /**
+     * Get element height using `getBoundingClientRect`
+     * @return The elements height in pixels
+     */
+    height(): number;
+    /**
+     * Get element width using `getBoundingClientRect`
+     * @return The elements width in pixels
+     */
+    width(): number;
+    /**
+     * The animate function lets you animate the current element with SMIL animations. You can add animations for multiple attributes at the same time by using an animation definition object. This object should contain SMIL animation attributes. Please refer to http://www.w3.org/TR/SVG/animate.html for a detailed specification about the available animation attributes. Additionally an easing property can be passed in the animation definition object. This can be a string with a name of an easing function in `Svg.Easing` or an array with four numbers specifying a cubic Bézier curve.
+     * **An animations object could look like this:**
+     * ```javascript
+     * element.animate({
+     *   opacity: {
+     *     dur: 1000,
+     *     from: 0,
+     *     to: 1
+     *   },
+     *   x1: {
+     *     dur: '1000ms',
+     *     from: 100,
+     *     to: 200,
+     *     easing: 'easeOutQuart'
+     *   },
+     *   y1: {
+     *     dur: '2s',
+     *     from: 0,
+     *     to: 100
+     *   }
+     * });
+     * ```
+     * **Automatic unit conversion**
+     * For the `dur` and the `begin` animate attribute you can also omit a unit by passing a number. The number will automatically be converted to milli seconds.
+     * **Guided mode**
+     * The default behavior of SMIL animations with offset using the `begin` attribute is that the attribute will keep it's original value until the animation starts. Mostly this behavior is not desired as you'd like to have your element attributes already initialized with the animation `from` value even before the animation starts. Also if you don't specify `fill="freeze"` on an animate element or if you delete the animation after it's done (which is done in guided mode) the attribute will switch back to the initial value. This behavior is also not desired when performing simple one-time animations. For one-time animations you'd want to trigger animations immediately instead of relative to the document begin time. That's why in guided mode Svg will also use the `begin` property to schedule a timeout and manually start the animation after the timeout. If you're using multiple SMIL definition objects for an attribute (in an array), guided mode will be disabled for this attribute, even if you explicitly enabled it.
+     * If guided mode is enabled the following behavior is added:
+     * - Before the animation starts (even when delayed with `begin`) the animated attribute will be set already to the `from` value of the animation
+     * - `begin` is explicitly set to `indefinite` so it can be started manually without relying on document begin time (creation)
+     * - The animate element will be forced to use `fill="freeze"`
+     * - The animation will be triggered with `beginElement()` in a timeout where `begin` of the definition object is interpreted in milli seconds. If no `begin` was specified the timeout is triggered immediately.
+     * - After the animation the element attribute value will be set to the `to` value of the animation
+     * - The animate element is deleted from the DOM
+     * @param animations An animations object where the property keys are the attributes you'd like to animate. The properties should be objects again that contain the SMIL animation attributes (usually begin, dur, from, and to). The property begin and dur is auto converted (see Automatic unit conversion). You can also schedule multiple animations for the same attribute by passing an Array of SMIL definition objects. Attributes that contain an array of SMIL definition objects will not be executed in guided mode.
+     * @param guided Specify if guided mode should be activated for this animation (see Guided mode). If not otherwise specified, guided mode will be activated.
+     * @param eventEmitter If specified, this event emitter will be notified when an animation starts or ends.
+     * @return The current element where the animation was added
+     */
+    animate(animations: Record<string, AnimationDefinition | AnimationDefinition[]>, guided?: boolean, eventEmitter?: EventEmitter): this;
+}
+//# sourceMappingURL=Svg.d.ts.map

package/dist/svg/Svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Svg.d.ts","sourceRoot":"","sources":["../../src/svg/Svg.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC;;GAEG;AACH,qBAAa,GAAG;IACd;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;MAAW;IAEjC,OAAO,CAAC,KAAK,CAAU;IAEvB;;;;;;OAMG;gBAED,IAAI,EAAE,MAAM,GAAG,OAAO,EACtB,UAAU,CAAC,EAAE,UAAU,EACvB,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,GAAG,EACZ,WAAW,UAAQ;IAiCrB;;;;;OAKG;IACH,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IACpD,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IA+BlC;;;;;;;OAOG;IACH,IAAI,CACF,IAAI,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,UAAU,EACvB,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,UAAQ;IAKrB;;;OAGG;IACH,MAAM;IAMN;;;OAGG;IACH,IAAI;IAcJ;;;;OAIG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM;IAK9B;;;;OAIG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM;IAKjC;;OAEG;IACH,OAAO;IAIP;;;;;;;OAOG;IACH,aAAa,CACX,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,UAAU,CAAC,EAAE,UAAU,EACvB,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,UAAQ;IAiCrB;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM;IAKd;;;OAGG;IACH,KAAK;IAQL;;;OAGG;IACH,MAAM;IAKN;;;;OAIG;IACH,OAAO,CAAC,UAAU,EAAE,GAAG;IAKvB;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,GAAG,EAAE,WAAW,UAAQ;IAUxC;;;OAGG;IACH,OAAO;IAMP;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM;IActB;;;;OAIG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM;IAazB;;;OAGG;IACH,gBAAgB;IAKhB;;;OAGG;IACH,MAAM;IAIN;;;OAGG;IACH,KAAK;IAIL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,OAAO,CACL,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,mBAAmB,EAAE,CAAC,EACvE,MAAM,UAAO,EACb,YAAY,CAAC,EAAE,YAAY;CA6B9B"}

package/dist/svg/SvgList.d.ts

@@ -0,0 +1,31 @@
+import { Svg } from './Svg';
+declare type SvgMethods = Exclude<keyof Svg, 'constructor' | 'parent' | 'querySelector' | 'querySelectorAll' | 'replace' | 'append' | 'classes' | 'height' | 'width'>;
+declare type SvgListMethods = {
+    [method in SvgMethods]: (...args: Parameters<Svg[method]>) => SvgList;
+};
+/**
+ * This helper class is to wrap multiple `Svg` elements into a list where you can call the `Svg` functions on all elements in the list with one call. This is helpful when you'd like to perform calls with `Svg` on multiple elements.
+ * An instance of this class is also returned by `Svg.querySelectorAll`.
+ */
+export declare class SvgList implements SvgListMethods {
+    private svgElements;
+    /**
+     * @param nodeList An Array of SVG DOM nodes or a SVG DOM NodeList (as returned by document.querySelectorAll)
+     */
+    constructor(nodeList: ArrayLike<Element>);
+    private call;
+    attr(...args: Parameters<Svg['attr']>): this;
+    elem(...args: Parameters<Svg['elem']>): this;
+    root(...args: Parameters<Svg['root']>): this;
+    getNode(...args: Parameters<Svg['getNode']>): this;
+    foreignObject(...args: Parameters<Svg['foreignObject']>): this;
+    text(...args: Parameters<Svg['text']>): this;
+    empty(...args: Parameters<Svg['empty']>): this;
+    remove(...args: Parameters<Svg['remove']>): this;
+    addClass(...args: Parameters<Svg['addClass']>): this;
+    removeClass(...args: Parameters<Svg['removeClass']>): this;
+    removeAllClasses(...args: Parameters<Svg['removeAllClasses']>): this;
+    animate(...args: Parameters<Svg['animate']>): this;
+}
+export {};
+//# sourceMappingURL=SvgList.d.ts.map

package/dist/svg/SvgList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SvgList.d.ts","sourceRoot":"","sources":["../../src/svg/SvgList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAE5B,aAAK,UAAU,GAAG,OAAO,CACvB,MAAM,GAAG,EACP,aAAa,GACb,QAAQ,GACR,eAAe,GACf,kBAAkB,GAClB,SAAS,GACT,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,OAAO,CACV,CAAC;AAEF,aAAK,cAAc,GAAG;KACnB,MAAM,IAAI,UAAU,GAAG,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,OAAO;CACtE,CAAC;AAEF;;;GAGG;AACH,qBAAa,OAAQ,YAAW,cAAc;IAC5C,OAAO,CAAC,WAAW,CAAa;IAEhC;;OAEG;gBACS,QAAQ,EAAE,SAAS,CAAC,OAAO,CAAC;IAMxC,OAAO,CAAC,IAAI;IAOZ,IAAI,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAIrC,IAAI,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAIrC,IAAI,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAIrC,OAAO,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAI3C,aAAa,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IAIvD,IAAI,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAIrC,KAAK,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAIvC,MAAM,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAIzC,QAAQ,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAI7C,WAAW,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IAInD,gBAAgB,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;IAI7D,OAAO,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;CAG5C"}

package/dist/svg/SvgPath.d.ts

@@ -0,0 +1,125 @@
+import type { SegmentData } from '../core';
+import type { SvgPathOptions, PathCommand, PathParams } from './types';
+export declare class SvgPath {
+    private readonly close;
+    /**
+     * This static function on `SvgPath` is joining multiple paths together into one paths.
+     * @param paths A list of paths to be joined together. The order is important.
+     * @param close If the newly created path should be a closed path
+     * @param options Path options for the newly created path.
+     */
+    static join(paths: SvgPath[], close?: boolean, options?: SvgPathOptions): SvgPath;
+    pathElements: PathCommand[];
+    private pos;
+    private options;
+    /**
+     * Used to construct a new path object.
+     * @param close If set to true then this path will be closed when stringified (with a Z at the end)
+     * @param options Options object that overrides the default objects. See default options for more details.
+     */
+    constructor(close?: boolean, options?: SvgPathOptions);
+    /**
+     * Gets or sets the current position (cursor) inside of the path. You can move around the cursor freely but limited to 0 or the count of existing elements. All modifications with element functions will insert new elements at the position of this cursor.
+     * @param pos If a number is passed then the cursor is set to this position in the path element array.
+     * @return If the position parameter was passed then the return value will be the path object for easy call chaining. If no position parameter was passed then the current position is returned.
+     */
+    position(pos: number): this;
+    position(): number;
+    /**
+     * Removes elements from the path starting at the current position.
+     * @param count Number of path elements that should be removed from the current position.
+     * @return The current path object for easy call chaining.
+     */
+    remove(count: number): this;
+    /**
+     * Use this function to add a new move SVG path element.
+     * @param x The x coordinate for the move element.
+     * @param y The y coordinate for the move element.
+     * @param relative If set to true the move element will be created with relative coordinates (lowercase letter)
+     * @param data Any data that should be stored with the element object that will be accessible in pathElement
+     * @return The current path object for easy call chaining.
+     */
+    move(x: number, y: number, relative?: boolean, data?: SegmentData): this;
+    /**
+     * Use this function to add a new line SVG path element.
+     * @param x The x coordinate for the line element.
+     * @param y The y coordinate for the line element.
+     * @param relative If set to true the line element will be created with relative coordinates (lowercase letter)
+     * @param data Any data that should be stored with the element object that will be accessible in pathElement
+     * @return The current path object for easy call chaining.
+     */
+    line(x: number, y: number, relative?: boolean, data?: SegmentData): this;
+    /**
+     * Use this function to add a new curve SVG path element.
+     * @param x1 The x coordinate for the first control point of the bezier curve.
+     * @param y1 The y coordinate for the first control point of the bezier curve.
+     * @param x2 The x coordinate for the second control point of the bezier curve.
+     * @param y2 The y coordinate for the second control point of the bezier curve.
+     * @param x The x coordinate for the target point of the curve element.
+     * @param y The y coordinate for the target point of the curve element.
+     * @param relative If set to true the curve element will be created with relative coordinates (lowercase letter)
+     * @param data Any data that should be stored with the element object that will be accessible in pathElement
+     * @return The current path object for easy call chaining.
+     */
+    curve(x1: number, y1: number, x2: number, y2: number, x: number, y: number, relative?: boolean, data?: SegmentData): this;
+    /**
+     * Use this function to add a new non-bezier curve SVG path element.
+     * @param rx The radius to be used for the x-axis of the arc.
+     * @param ry The radius to be used for the y-axis of the arc.
+     * @param xAr Defines the orientation of the arc
+     * @param lAf Large arc flag
+     * @param sf Sweep flag
+     * @param x The x coordinate for the target point of the curve element.
+     * @param y The y coordinate for the target point of the curve element.
+     * @param relative If set to true the curve element will be created with relative coordinates (lowercase letter)
+     * @param data Any data that should be stored with the element object that will be accessible in pathElement
+     * @return The current path object for easy call chaining.
+     */
+    arc(rx: number, ry: number, xAr: number, lAf: number, sf: number, x: number, y: number, relative?: boolean, data?: SegmentData): this;
+    /**
+     * Parses an SVG path seen in the d attribute of path elements, and inserts the parsed elements into the existing path object at the current cursor position. Any closing path indicators (Z at the end of the path) will be ignored by the parser as this is provided by the close option in the options of the path object.
+     * @param path Any SVG path that contains move (m), line (l) or curve (c) components.
+     * @return The current path object for easy call chaining.
+     */
+    parse(path: string): this;
+    /**
+     * This function renders to current SVG path object into a final SVG string that can be used in the d attribute of SVG path elements. It uses the accuracy option to round big decimals. If the close parameter was set in the constructor of this path object then a path closing Z will be appended to the output string.
+     */
+    stringify(): string;
+    /**
+     * Scales all elements in the current SVG path object. There is an individual parameter for each coordinate. Scaling will also be done for control points of curves, affecting the given coordinate.
+     * @param x The number which will be used to scale the x, x1 and x2 of all path elements.
+     * @param y The number which will be used to scale the y, y1 and y2 of all path elements.
+     * @return The current path object for easy call chaining.
+     */
+    scale(x: number, y: number): this;
+    /**
+     * Translates all elements in the current SVG path object. The translation is relative and there is an individual parameter for each coordinate. Translation will also be done for control points of curves, affecting the given coordinate.
+     * @param x The number which will be used to translate the x, x1 and x2 of all path elements.
+     * @param y The number which will be used to translate the y, y1 and y2 of all path elements.
+     * @return The current path object for easy call chaining.
+     */
+    translate(x: number, y: number): this;
+    /**
+     * This function will run over all existing path elements and then loop over their attributes. The callback function will be called for every path element attribute that exists in the current path.
+     * The method signature of the callback function looks like this:
+     * ```javascript
+     * function(pathElement, paramName, pathElementIndex, paramIndex, pathElements)
+     * ```
+     * If something else than undefined is returned by the callback function, this value will be used to replace the old value. This allows you to build custom transformations of path objects that can't be achieved using the basic transformation functions scale and translate.
+     * @param transformFnc The callback function for the transformation. Check the signature in the function description.
+     * @return The current path object for easy call chaining.
+     */
+    transform(transformFnc: <T extends PathParams = PathParams>(cmd: PathCommand<T>, param: keyof T, cmdIndex: number, paramIndex: number, cmds: PathCommand<T>[]) => number | void): this;
+    /**
+     * This function clones a whole path object with all its properties. This is a deep clone and path element objects will also be cloned.
+     * @param close Optional option to set the new cloned path to closed. If not specified or false, the original path close option will be used.
+     */
+    clone(close?: boolean): SvgPath;
+    /**
+     * Split a Svg.Path object by a specific command in the path chain. The path chain will be split and an array of newly created paths objects will be returned. This is useful if you'd like to split an SVG path by it's move commands, for example, in order to isolate chunks of drawings.
+     * @param command The command you'd like to use to split the path
+     */
+    splitByCommand(command: string): SvgPath[];
+}
+//# sourceMappingURL=SvgPath.d.ts.map

package/dist/svg/SvgPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SvgPath.d.ts","sourceRoot":"","sources":["../../src/svg/SvgPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AA8DvE,qBAAa,OAAO;IA2BN,OAAO,CAAC,QAAQ,CAAC,KAAK;IA1BlC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,UAAQ,EAAE,OAAO,CAAC,EAAE,cAAc;IAWrE,YAAY,EAAE,WAAW,EAAE,CAAM;IACjC,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,OAAO,CAA2B;IAE1C;;;;OAIG;gBAC0B,KAAK,UAAQ,EAAE,OAAO,CAAC,EAAE,cAAc;IAIpE;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAC3B,QAAQ,IAAI,MAAM;IAUlB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IAKpB;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,UAAQ,EAAE,IAAI,CAAC,EAAE,WAAW;IAe/D;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,UAAQ,EAAE,IAAI,CAAC,EAAE,WAAW;IAe/D;;;;;;;;;;;OAWG;IACH,KAAK,CACH,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,UAAQ,EAChB,IAAI,CAAC,EAAE,WAAW;IAoBpB;;;;;;;;;;;;OAYG;IACH,GAAG,CACD,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,QAAQ,UAAQ,EAChB,IAAI,CAAC,EAAE,WAAW;IAqBpB;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM;IA8ClB;;OAEG;IACH,SAAS;IAoBT;;;;;OAKG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAO1B;;;;;OAKG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAO9B;;;;;;;;;OASG;IACH,SAAS,CACP,YAAY,EAAE,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,EAC9C,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,MAAM,CAAC,EACd,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,KACnB,MAAM,GAAG,IAAI;IAoBpB;;;OAGG;IACH,KAAK,CAAC,KAAK,UAAQ;IAUnB;;;OAGG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM;CAgB/B"}

package/dist/svg/animation.d.ts

@@ -0,0 +1,37 @@
+import type { EventEmitter } from '../event';
+import type { AnimationDefinition } from './types';
+import type { Svg } from './Svg';
+/**
+ * This Object contains some standard easing cubic bezier curves.
+ * Then can be used with their name in the `Svg.animate`.
+ * You can also extend the list and use your own name in the `animate` function.
+ * Click the show code button to see the available bezier functions.
+ */
+export declare const easings: {
+    easeInSine: number[];
+    easeOutSine: number[];
+    easeInOutSine: number[];
+    easeInQuad: number[];
+    easeOutQuad: number[];
+    easeInOutQuad: number[];
+    easeInCubic: number[];
+    easeOutCubic: number[];
+    easeInOutCubic: number[];
+    easeInQuart: number[];
+    easeOutQuart: number[];
+    easeInOutQuart: number[];
+    easeInQuint: number[];
+    easeOutQuint: number[];
+    easeInOutQuint: number[];
+    easeInExpo: number[];
+    easeOutExpo: number[];
+    easeInOutExpo: number[];
+    easeInCirc: number[];
+    easeOutCirc: number[];
+    easeInOutCirc: number[];
+    easeInBack: number[];
+    easeOutBack: number[];
+    easeInOutBack: number[];
+};
+export declare function createAnimation(element: Svg, attribute: string, animationDefinition: AnimationDefinition, createGuided?: boolean, eventEmitter?: EventEmitter): void;
+//# sourceMappingURL=animation.d.ts.map

package/dist/svg/animation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation.d.ts","sourceRoot":"","sources":["../../src/svg/animation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,KAAK,EAAc,mBAAmB,EAAkB,MAAM,SAAS,CAAC;AAC/E,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;CAyBnB,CAAC;AAEF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,GAAG,EACZ,SAAS,EAAE,MAAM,EACjB,mBAAmB,EAAE,mBAAmB,EACxC,YAAY,UAAQ,EACpB,YAAY,CAAC,EAAE,YAAY,QA0F5B"}

package/dist/svg/index.d.ts

@@ -0,0 +1,6 @@
+export { easings } from './animation';
+export * from './Svg';
+export * from './SvgPath';
+export * from './SvgList';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/svg/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/svg/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,cAAc,OAAO,CAAC;AACtB,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}