fabric 5.3.0 → 6.0.0-beta1

package/dist/src/util/misc/projectStroke/StrokeLineCapProjections.d.ts

@@ -0,0 +1,51 @@
+import { IPoint, Point } from '../../../Point';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase';
+import { TProjection, TProjectStrokeOnPointsOptions } from './types';
+/**
+ * class in charge of finding projections for each type of line cap for start/end of an open path
+ * @see {@link [Open path projections at #8344](https://github.com/fabricjs/fabric.js/pull/8344#1-open-path)}
+ *
+ * Reference:
+ * - MDN:
+ *   - https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/lineCap
+ *   - https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap
+ * - Spec: https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-linecap-dev
+ * - Playground to understand how the line joins works: https://hypertolosana.github.io/efficient-webgl-stroking/index.html
+ * - View the calculated projections for each of the control points: https://codesandbox.io/s/project-stroke-points-with-context-to-trace-b8jc4j?file=/src/index.js
+ */
+export declare class StrokeLineCapProjections extends StrokeProjectionsBase {
+    /**
+     * edge point
+     */
+    A: Point;
+    /**
+     * point next to edge point
+     */
+    T: Point;
+    constructor(A: IPoint, T: IPoint, options: TProjectStrokeOnPointsOptions);
+    calcOrthogonalProjection(from: Point, to: Point, magnitude?: number): Point;
+    /**
+     * OPEN PATH START/END - Line cap: Butt
+     * Calculation: to find the projections, just find the points orthogonal to the stroke
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#1-1-butt
+     */
+    projectButt(): Point[];
+    /**
+     * OPEN PATH START/END - Line cap: Round
+     * Calculation: same as stroke line join `round`
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#1-2-round
+     */
+    projectRound(): Point[];
+    /**
+     * OPEN PATH START/END - Line cap: Square
+     * Calculation: project a rectangle of points on the stroke in the opposite direction of the vector `AT`
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#1-3-square
+     */
+    projectSquare(): Point[];
+    protected projectPoints(): Point[];
+    project(): TProjection[];
+}
+//# sourceMappingURL=StrokeLineCapProjections.d.ts.map

package/dist/src/util/misc/projectStroke/StrokeLineJoinProjections.d.ts

@@ -0,0 +1,81 @@
+import { IPoint, Point } from '../../../Point';
+import { getBisector } from '../vectors';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase';
+import { TProjection, TProjectStrokeOnPointsOptions } from './types';
+/**
+ * class in charge of finding projections for each type of line join
+ * @see {@link [Closed path projections at #8344](https://github.com/fabricjs/fabric.js/pull/8344#2-closed-path)}
+ *
+ * - MDN:
+ *   - https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/lineJoin
+ *   - https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin
+ * - Spec: https://svgwg.org/svg2-draft/painting.html#StrokeLinejoinProperty
+ * - Playground to understand how the line joins works: https://hypertolosana.github.io/efficient-webgl-stroking/index.html
+ * - View the calculated projections for each of the control points: https://codesandbox.io/s/project-stroke-points-with-context-to-trace-b8jc4j?file=/src/index.js
+ *
+ */
+export declare class StrokeLineJoinProjections extends StrokeProjectionsBase {
+    /**
+     * The point being projected (the angle ∠BAC)
+     */
+    A: Point;
+    /**
+     * The point before A
+     */
+    B: Point;
+    /**
+     * The point after A
+     */
+    C: Point;
+    /**
+     * The bisector of A (∠BAC)
+     */
+    bisector: ReturnType<typeof getBisector>;
+    constructor(A: IPoint, B: IPoint, C: IPoint, options: TProjectStrokeOnPointsOptions);
+    get bisectorVector(): Point;
+    get bisectorAngle(): import("../../../typedefs").TRadian;
+    calcOrthogonalProjection(from: Point, to: Point, magnitude?: number): Point;
+    /**
+     * BEVEL
+     * Calculation: the projection points are formed by the vector orthogonal to the vertex.
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#2-2-bevel
+     */
+    projectBevel(): Point[];
+    /**
+     * MITER
+     * Calculation: the corner is formed by extending the outer edges of the stroke
+     * at the tangents of the path segments until they intersect.
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#2-1-miter
+     */
+    projectMiter(): Point[];
+    /**
+     * ROUND (without skew)
+     * Calculation: the projections are the two vectors parallel to X and Y axes
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#2-3-1-round-without-skew
+     */
+    private projectRoundNoSkew;
+    /**
+     * ROUND (with skew)
+     * Calculation: the projections are the points furthest from the vertex in
+     * the direction of the X and Y axes after distortion.
+     *
+     * @todo TODO:
+     *  - Consider only projections that are inside the beginning and end of the circle segment
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#2-3-2-round-skew
+     */
+    private projectRoundWithSkew;
+    projectRound(): Point[];
+    /**
+     * Project stroke width on points returning projections for each point as follows:
+     * - `miter`: 1 point corresponding to the outer boundary. If the miter limit is exceeded, it will be 2 points (becomes bevel)
+     * - `bevel`: 2 points corresponding to the bevel possible boundaries, orthogonal to the stroke.
+     * - `round`: same as `bevel` when it has no skew, with skew are 4 points.
+     */
+    protected projectPoints(): Point[];
+    project(): TProjection[];
+}
+//# sourceMappingURL=StrokeLineJoinProjections.d.ts.map

package/dist/src/util/misc/projectStroke/StrokeProjectionsBase.d.ts

@@ -0,0 +1,25 @@
+import { IPoint, Point } from '../../../Point';
+import { TProjectStrokeOnPointsOptions, TProjection } from './types';
+/**
+ * @see https://github.com/fabricjs/fabric.js/pull/8344
+ */
+export declare abstract class StrokeProjectionsBase {
+    options: TProjectStrokeOnPointsOptions;
+    scale: Point;
+    strokeUniformScalar: Point;
+    strokeProjectionMagnitude: number;
+    static getAcuteAngleFactor(vector1: Point, vector2?: Point): 1 | -1;
+    constructor(options: TProjectStrokeOnPointsOptions);
+    /**
+     * When the stroke is uniform, scaling affects the arrangement of points. So we must take it into account.
+     */
+    protected createSideVector(from: IPoint, to: IPoint): Point;
+    protected abstract calcOrthogonalProjection(from: Point, to: Point, magnitude?: number): Point;
+    protected projectOrthogonally(from: Point, to: Point, magnitude?: number): Point;
+    protected isSkewed(): boolean;
+    protected applySkew(point: Point): Point;
+    protected scaleUnitVector(unitVector: Point, scalar: number): Point;
+    protected abstract projectPoints(): Point[];
+    abstract project(): TProjection[];
+}
+//# sourceMappingURL=StrokeProjectionsBase.d.ts.map

package/dist/src/util/misc/projectStroke/index.d.ts

@@ -0,0 +1,11 @@
+import { IPoint } from '../../../Point';
+import { TProjection, TProjectStrokeOnPointsOptions } from './types';
+/**
+ *
+ * Used to calculate object's bounding box
+ *
+ * @see https://github.com/fabricjs/fabric.js/pull/8344
+ *
+ */
+export declare const projectStrokeOnPoints: (points: IPoint[], options: TProjectStrokeOnPointsOptions, openPath?: boolean) => TProjection[];
+//# sourceMappingURL=index.d.ts.map

package/dist/src/util/misc/projectStroke/types.d.ts

@@ -0,0 +1,23 @@
+import { Point } from '../../../Point';
+import { TDegree } from '../../../typedefs';
+import { getBisector } from '../vectors';
+export type TProjectStrokeOnPointsOptions = {
+    strokeWidth: number;
+    strokeLineCap: CanvasLineCap;
+    strokeLineJoin: CanvasLineJoin;
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit
+     */
+    strokeMiterLimit: number;
+    strokeUniform: boolean;
+    scaleX: number;
+    scaleY: number;
+    skewX: TDegree;
+    skewY: TDegree;
+};
+export type TProjection = {
+    projectedPoint: Point;
+    originPoint: Point;
+    bisector?: ReturnType<typeof getBisector>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/util/misc/radiansDegreesConversion.d.ts

@@ -0,0 +1,14 @@
+import type { TRadian, TDegree } from '../../typedefs';
+/**
+ * Transforms degrees to radians.
+ * @param {TDegree} degrees value in degrees
+ * @return {TRadian} value in radians
+ */
+export declare const degreesToRadians: (degrees: TDegree) => TRadian;
+/**
+ * Transforms radians to degrees.
+ * @param {TRadian} radians value in radians
+ * @return {TDegree} value in degrees
+ */
+export declare const radiansToDegrees: (radians: TRadian) => TDegree;
+//# sourceMappingURL=radiansDegreesConversion.d.ts.map

package/dist/src/util/misc/resolveOrigin.d.ts

@@ -0,0 +1,9 @@
+import { TOriginX, TOriginY } from '../../typedefs';
+/**
+ * Resolves origin value relative to center
+ * @private
+ * @param {TOriginX | TOriginY} originValue originX / originY
+ * @returns number
+ */
+export declare const resolveOrigin: (originValue: TOriginX | TOriginY | number) => number;
+//# sourceMappingURL=resolveOrigin.d.ts.map

package/dist/src/util/misc/rotatePoint.d.ts

@@ -0,0 +1,12 @@
+import type { Point } from '../../Point';
+import type { TRadian } from '../../typedefs';
+/**
+ * Rotates `point` around `origin` with `radians`
+ * @deprecated use the Point.rotate
+ * @param {Point} origin The origin of the rotation
+ * @param {Point} origin The origin of the rotation
+ * @param {TRadian} radians The radians of the angle for the rotation
+ * @return {Point} The new rotated point
+ */
+export declare const rotatePoint: (point: Point, origin: Point, radians: TRadian) => Point;
+//# sourceMappingURL=rotatePoint.d.ts.map

package/dist/src/util/misc/sin.d.ts

@@ -0,0 +1,10 @@
+import type { TRadian } from '../../typedefs';
+/**
+ * Calculate the cos of an angle, avoiding returning floats for known results
+ * This function is here just to avoid getting 0.999999999999999 when dealing
+ * with numbers that are really 1 or 0.
+ * @param {TRadian} angle the angle
+ * @return {Number} the sin value for angle.
+ */
+export declare const sin: (angle: TRadian) => number;
+//# sourceMappingURL=sin.d.ts.map

package/dist/src/util/misc/svgParsing.d.ts

@@ -0,0 +1,53 @@
+import { SVGElementName, TBBox, TMat2D } from '../../typedefs';
+/**
+ * Returns array of attributes for given svg that fabric parses
+ * @param {SVGElementName} type Type of svg element (eg. 'circle')
+ * @return {Array} string names of supported attributes
+ */
+export declare const getSvgAttributes: (type: SVGElementName) => string[];
+/**
+ * Converts from attribute value to pixel value if applicable.
+ * Returns converted pixels or original value not converted.
+ * @param {string} value number to operate on
+ * @param {number} fontSize
+ * @return {number}
+ */
+export declare const parseUnit: (value: string, fontSize: number) => number;
+export declare const enum MeetOrSlice {
+    meet = "meet",
+    slice = "slice"
+}
+export declare const enum MinMidMax {
+    min = "Min",
+    mid = "Mid",
+    max = "Max",
+    none = "none"
+}
+export type TPreserveArParsed = {
+    meetOrSlice: MeetOrSlice;
+    alignX: MinMidMax;
+    alignY: MinMidMax;
+};
+/**
+ * Parse preserveAspectRatio attribute from element
+ * https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/preserveAspectRatio
+ * @param {string} attribute to be parsed
+ * @return {Object} an object containing align and meetOrSlice attribute
+ */
+export declare const parsePreserveAspectRatioAttribute: (attribute: string) => TPreserveArParsed;
+/**
+ * given an array of 6 number returns something like `"matrix(...numbers)"`
+ * @param {TMat2D} transform an array with 6 numbers
+ * @return {String} transform matrix for svg
+ */
+export declare const matrixToSVG: (transform: TMat2D) => string;
+/**
+ * Adobe Illustrator (at least CS5) is unable to render rgba()-based fill values
+ * we work around it by "moving" alpha channel into opacity attribute and setting fill's alpha to 1
+ * @param prop
+ * @param value
+ * @returns
+ */
+export declare const colorPropToSVG: (prop: string, value?: any) => string;
+export declare const createSVGRect: (color: string, { left, top, width, height }: TBBox, precision?: number) => string;
+//# sourceMappingURL=svgParsing.d.ts.map

package/dist/src/util/misc/textStyles.d.ts

@@ -0,0 +1,32 @@
+import type { TextStyle, TextStyleDeclaration } from '../../shapes/Text/StyledText';
+export type TextStyleArray = {
+    start: number;
+    end: number;
+    style: TextStyleDeclaration;
+}[];
+/**
+ * @param {Object} prevStyle first style to compare
+ * @param {Object} thisStyle second style to compare
+ * @param {boolean} forTextSpans whether to check overline, underline, and line-through properties
+ * @return {boolean} true if the style changed
+ */
+export declare const hasStyleChanged: (prevStyle: TextStyleDeclaration, thisStyle: TextStyleDeclaration, forTextSpans?: boolean) => boolean;
+/**
+ * Returns the array form of a text object's inline styles property with styles grouped in ranges
+ * rather than per character. This format is less verbose, and is better suited for storage
+ * so it is used in serialization (not during runtime).
+ * @param {object} styles per character styles for a text object
+ * @param {String} text the text string that the styles are applied to
+ * @return {{start: number, end: number, style: object}[]}
+ */
+export declare const stylesToArray: (styles: TextStyle, text: string) => TextStyleArray;
+/**
+ * Returns the object form of the styles property with styles that are assigned per
+ * character rather than grouped by range. This format is more verbose, and is
+ * only used during runtime (not for serialization/storage)
+ * @param {Array} styles the serialized form of a text object's styles
+ * @param {String} text the text string that the styles are applied to
+ * @return {Object}
+ */
+export declare const stylesFromArray: (styles: TextStyleArray | TextStyle, text: string) => TextStyle;
+//# sourceMappingURL=textStyles.d.ts.map

package/dist/src/util/misc/toFixed.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A wrapper around Number#toFixed, which contrary to native method returns number, not string.
+ * @param {number|string} number number to operate on
+ * @param {number} fractionDigits number of fraction digits to "leave"
+ * @return {number}
+ */
+export declare const toFixed: (number: number | string, fractionDigits: number) => number;
+//# sourceMappingURL=toFixed.d.ts.map

package/dist/src/util/misc/vectors.d.ts

@@ -0,0 +1,57 @@
+import { IPoint, Point } from '../../Point';
+import { TRadian } from '../../typedefs';
+/**
+ * Rotates `vector` with `radians`
+ * @param {Point} vector The vector to rotate (x and y)
+ * @param {Number} radians The radians of the angle for the rotation
+ * @return {Point} The new rotated point
+ */
+export declare const rotateVector: (vector: Point, radians: TRadian) => Point;
+/**
+ * Creates a vector from points represented as a point
+ *
+ * @param {Point} from
+ * @param {Point} to
+ * @returns {Point} vector
+ */
+export declare const createVector: (from: IPoint, to: IPoint) => Point;
+/**
+ * return the magnitude of a vector
+ * @return {number}
+ */
+export declare const magnitude: (point: Point) => number;
+/**
+ * Calculates the angle between 2 vectors
+ * @param {Point} a
+ * @param {Point} b
+ * @returns the angle in radians from `a` to `b`
+ */
+export declare const calcAngleBetweenVectors: (a: Point, b: Point) => TRadian;
+/**
+ * Calculates the angle between the x axis and the vector
+ * @param {Point} v
+ * @returns the angle in radians of `v`
+ */
+export declare const calcVectorRotation: (v: Point) => TRadian;
+/**
+ * @param {Point} v
+ * @returns {Point} vector representing the unit vector pointing to the direction of `v`
+ */
+export declare const getUnitVector: (v: Point) => Point;
+/**
+ * @param {Point} A
+ * @param {Point} B
+ * @param {Point} C
+ * @returns {{ vector: Point, angle: TRadian}} vector representing the bisector of A and A's angle
+ */
+export declare const getBisector: (A: Point, B: Point, C: Point) => {
+    vector: Point;
+    angle: TRadian;
+};
+/**
+ * @param {Point} v
+ * @param {Boolean} [counterClockwise] the direction of the orthogonal vector, defaults to `true`
+ * @returns {Point} the unit orthogonal vector
+ */
+export declare const getOrthonormalVector: (v: Point, counterClockwise?: boolean) => Point;
+//# sourceMappingURL=vectors.d.ts.map

package/dist/src/util/path.d.ts

@@ -0,0 +1,108 @@
+import { Point } from '../Point';
+import type { PathData, TMat2D } from '../typedefs';
+type PathSegmentInfoCommon = {
+    x: number;
+    y: number;
+    command: string;
+    length: number;
+};
+type CurveInfo = PathSegmentInfoCommon & {
+    iterator: (pct: number) => Point;
+    angleFinder: (pct: number) => number;
+    length: number;
+};
+export type PathSegmentInfo = {
+    M: PathSegmentInfoCommon;
+    L: PathSegmentInfoCommon;
+    C: CurveInfo;
+    Q: CurveInfo;
+    Z: PathSegmentInfoCommon & {
+        destX: number;
+        destY: number;
+    };
+};
+export type TPathSegmentsInfo = PathSegmentInfo[keyof PathSegmentInfo];
+/**
+ * Calculate bounding box of a beziercurve
+ * @param {Number} x0 starting point
+ * @param {Number} y0
+ * @param {Number} x1 first control point
+ * @param {Number} y1
+ * @param {Number} x2 secondo control point
+ * @param {Number} y2
+ * @param {Number} x3 end of bezier
+ * @param {Number} y3
+ */
+export declare function getBoundsOfCurve(x0: any, y0: any, x1: any, y1: any, x2: any, y2: any, x3: any, y3: any): any;
+/**
+ * Converts arc to a bunch of bezier curves
+ * @param {Number} fx starting point x
+ * @param {Number} fy starting point y
+ * @param {Array} coords Arc command
+ */
+export declare const fromArcToBeziers: (fx: any, fy: any, [_, rx, ry, rot, large, sweep, tx, ty]?: [any?, any?, any?, any?, any?, any?, any?, any?]) => any[];
+/**
+ * This function take a parsed SVG path and make it simpler for fabricJS logic.
+ * simplification consist of: only UPPERCASE absolute commands ( relative converted to absolute )
+ * S converted in C, T converted in Q, A converted in C.
+ * @param {PathData} path the array of commands of a parsed svg path for `Path`
+ * @return {PathData} the simplified array of commands of a parsed svg path for `Path`
+ */
+export declare const makePathSimpler: (path: PathData) => PathData;
+/**
+ * Run over a parsed and simplified path and extract some information (length of each command and starting point)
+ * @param {PathData} path parsed path commands
+ * @return {Array} path commands information
+ */
+export declare const getPathSegmentsInfo: (path: PathData) => TPathSegmentsInfo[];
+export declare const getPointOnPath: (path: PathData, distance: number, infos?: ReturnType<typeof getPathSegmentsInfo>) => Point | {
+    x: number;
+    y: number;
+    angle: number;
+} | undefined;
+/**
+ *
+ * @param {string} pathString
+ * @return {(string|number)[][]} An array of SVG path commands
+ * @example <caption>Usage</caption>
+ * parsePath('M 3 4 Q 3 5 2 1 4 0 Q 9 12 2 1 4 0') === [
+ *   ['M', 3, 4],
+ *   ['Q', 3, 5, 2, 1, 4, 0],
+ *   ['Q', 9, 12, 2, 1, 4, 0],
+ * ];
+ *
+ */
+export declare const parsePath: (pathString: any) => any[];
+/**
+ *
+ * Converts points to a smooth SVG path
+ * @param {{ x: number,y: number }[]} points Array of points
+ * @param {number} [correction] Apply a correction to the path (usually we use `width / 1000`). If value is undefined 0 is used as the correction value.
+ * @return {(string|number)[][]} An array of SVG path commands
+ */
+export declare const getSmoothPathFromPoints: (points: any, correction?: number) => (string | number)[][];
+/**
+ * Transform a path by transforming each segment.
+ * it has to be a simplified path or it won't work.
+ * WARNING: this depends from pathOffset for correct operation
+ * @param {PathData} path fabricJS parsed and simplified path commands
+ * @param {TMat2D} transform matrix that represent the transformation
+ * @param {Point} [pathOffset] `Path.pathOffset`
+ * @returns {Array} the transformed path
+ */
+export declare const transformPath: (path: PathData, transform: TMat2D, pathOffset: Point) => (string | number)[][];
+/**
+ * Returns an array of path commands to create a regular polygon
+ * @param {number} radius
+ * @param {number} numVertexes
+ * @returns {(string|number)[][]} An array of SVG path commands
+ */
+export declare const getRegularPolygonPath: (numVertexes: any, radius: any) => any[];
+/**
+ * Join path commands to go back to svg format
+ * @param {Array} pathData fabricJS parsed path commands
+ * @return {String} joined path 'M 0 0 L 20 30'
+ */
+export declare const joinPath: (pathData: any) => any;
+export {};
+//# sourceMappingURL=path.d.ts.map

package/dist/src/util/transform_matrix_removal.d.ts

@@ -0,0 +1,14 @@
+import type { FabricObject } from '../shapes/Object/FabricObject';
+import { TMat2D } from '../typedefs';
+type FabricObjectWithTransformMatrix = FabricObject & {
+    transformMatrix?: TMat2D;
+};
+/**
+ * This function is an helper for svg import. it removes the transform matrix
+ * and set to object properties that fabricjs can handle
+ * @private
+ * @param {Object} preserveAspectRatioOptions
+ */
+export declare const removeTransformMatrixForSvgParsing: (object: FabricObjectWithTransformMatrix, preserveAspectRatioOptions?: any) => void;
+export {};
+//# sourceMappingURL=transform_matrix_removal.d.ts.map

package/dist/src/util/types.d.ts

@@ -0,0 +1,19 @@
+import type { ActiveSelection } from '../shapes/ActiveSelection';
+import type { Group } from '../shapes/Group';
+import type { FabricObject, TCachedFabricObject } from '../shapes/Object/Object';
+import type { FabricObjectWithDragSupport } from '../shapes/Object/InteractiveObject';
+import type { TFiller } from '../typedefs';
+import type { Text } from '../shapes/Text/Text';
+import type { Pattern } from '../Pattern';
+import type { IText } from '../shapes/IText/IText';
+import type { Textbox } from '../shapes/Textbox';
+export declare const isFiller: (filler: TFiller | string | null) => filler is TFiller;
+export declare const isSerializableFiller: (filler: TFiller | string | null) => filler is TFiller;
+export declare const isPattern: (filler: TFiller) => filler is Pattern;
+export declare const isCollection: (fabricObject?: FabricObject) => fabricObject is Group | ActiveSelection;
+export declare const isActiveSelection: (fabricObject?: FabricObject) => fabricObject is ActiveSelection;
+export declare const isTextObject: (fabricObject?: FabricObject) => fabricObject is Text<import("../EventTypeDefs").ObjectEvents>;
+export declare const isInteractiveTextObject: (fabricObject?: FabricObject) => fabricObject is IText<import("../shapes/IText/ITextBehavior").ITextEvents> | Textbox;
+export declare const isFabricObjectCached: (fabricObject: FabricObject) => fabricObject is TCachedFabricObject;
+export declare const isFabricObjectWithDragSupport: (fabricObject?: FabricObject) => fabricObject is FabricObjectWithDragSupport;
+//# sourceMappingURL=types.d.ts.map