@nasser-sw/fabric 7.0.0-beta1

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

@@ -0,0 +1,64 @@
+import type { Point } from '../../Point';
+import type { FabricObject } from '../../shapes/Object/Object';
+import type { TMat2D } from '../../typedefs';
+/**
+ * We are actually looking for the transformation from the destination plane to the source plane (change of basis matrix)\
+ * The object will exist on the destination plane and we want it to seem unchanged by it so we invert the destination matrix (`to`) and then apply the source matrix (`from`)
+ * @param [from]
+ * @param [to]
+ * @returns
+ */
+export declare const calcPlaneChangeMatrix: (from?: TMat2D, to?: TMat2D) => TMat2D;
+/**
+ * Sends a point from the source coordinate plane to the destination coordinate plane.\
+ * From the canvas/viewer's perspective the point remains unchanged.
+ *
+ * @example <caption>Send point from canvas plane to group plane</caption>
+ * var obj = new Rect({ left: 20, top: 20, width: 60, height: 60, strokeWidth: 0 });
+ * var group = new Group([obj], { strokeWidth: 0 });
+ * var sentPoint1 = sendPointToPlane(new Point(50, 50), undefined, group.calcTransformMatrix());
+ * var sentPoint2 = sendPointToPlane(new Point(50, 50), iMatrix, group.calcTransformMatrix());
+ * console.log(sentPoint1, sentPoint2) //  both points print (0,0) which is the center of group
+ *
+ * @param {Point} point
+ * @param {TMat2D} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `point` exists in the canvas coordinate plane.
+ * @param {TMat2D} [to] destination plane matrix to contain object. Passing `undefined` means `point` should be sent to the canvas coordinate plane.
+ * @returns {Point} transformed point
+ */
+export declare const sendPointToPlane: (point: Point, from?: TMat2D, to?: TMat2D) => Point;
+/**
+ * See {@link sendPointToPlane}
+ */
+export declare const sendVectorToPlane: (point: Point, from?: TMat2D, to?: TMat2D) => Point;
+/**
+ *
+ * A util that abstracts applying transform to objects.\
+ * Sends `object` to the destination coordinate plane by applying the relevant transformations.\
+ * Changes the space/plane where `object` is drawn.\
+ * From the canvas/viewer's perspective `object` remains unchanged.
+ *
+ * @example <caption>Move clip path from one object to another while preserving it's appearance as viewed by canvas/viewer</caption>
+ * let obj, obj2;
+ * let clipPath = new Circle({ radius: 50 });
+ * obj.clipPath = clipPath;
+ * // render
+ * sendObjectToPlane(clipPath, obj.calcTransformMatrix(), obj2.calcTransformMatrix());
+ * obj.clipPath = undefined;
+ * obj2.clipPath = clipPath;
+ * // render, clipPath now clips obj2 but seems unchanged from the eyes of the viewer
+ *
+ * @example <caption>Clip an object's clip path with an existing object</caption>
+ * let obj, existingObj;
+ * let clipPath = new Circle({ radius: 50 });
+ * obj.clipPath = clipPath;
+ * let transformTo = multiplyTransformMatrices(obj.calcTransformMatrix(), clipPath.calcTransformMatrix());
+ * sendObjectToPlane(existingObj, existingObj.group?.calcTransformMatrix(), transformTo);
+ * clipPath.clipPath = existingObj;
+ *
+ * @param {FabricObject} object
+ * @param {Matrix} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `object` is a direct child of canvas.
+ * @param {Matrix} [to] destination plane matrix to contain object. Passing `undefined` means `object` should be sent to the canvas coordinate plane.
+ * @returns {Matrix} the transform matrix that was applied to `object`
+ */
+export declare const sendObjectToPlane: (object: FabricObject, from?: TMat2D, to?: TMat2D) => TMat2D;
+//# sourceMappingURL=planeChange.d.ts.map

package/dist/src/util/misc/planeChange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planeChange.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/planeChange.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI7C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAM,MAAgB,EACtB,KAAI,MAAgB,WACmC,CAAC;AAE1D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,KAAK,EACZ,OAAM,MAAgB,EACtB,KAAI,MAAgB,KACnB,KAAyD,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,KAAK,EACZ,OAAM,MAAgB,EACtB,KAAI,MAAgB,KACnB,KAA+D,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,YAAY,EACpB,OAAO,MAAM,EACb,KAAK,MAAM,KACV,MAOF,CAAC"}

package/dist/src/util/misc/planeChange.min.mjs

@@ -0,0 +1,2 @@
+import{iMatrix as t}from"../../constants.min.mjs";import{multiplyTransformMatrices as n,invertTransform as o}from"./matrix.min.mjs";import{applyTransformToObject as r}from"./objectTransforms.min.mjs";const i=function(){let r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:t;return n(o(arguments.length>1&&void 0!==arguments[1]?arguments[1]:t),r)},m=function(n){let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:t,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:t;return n.transform(i(o,r))},e=function(n){let o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:t,r=arguments.length>2&&void 0!==arguments[2]?arguments[2]:t;return n.transform(i(o,r),!0)},s=(t,o,m)=>{const e=i(o,m);return r(t,n(e,t.calcOwnMatrix())),e};export{i as calcPlaneChangeMatrix,s as sendObjectToPlane,m as sendPointToPlane,e as sendVectorToPlane};
+//# sourceMappingURL=planeChange.min.mjs.map

package/dist/src/util/misc/planeChange.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planeChange.min.mjs","sources":["../../../../src/util/misc/planeChange.ts"],"sourcesContent":["import { iMatrix } from '../../constants';\nimport type { Point } from '../../Point';\nimport type { FabricObject } from '../../shapes/Object/Object';\nimport type { TMat2D } from '../../typedefs';\nimport { invertTransform, multiplyTransformMatrices } from './matrix';\nimport { applyTransformToObject } from './objectTransforms';\n\n/**\n * We are actually looking for the transformation from the destination plane to the source plane (change of basis matrix)\\\n * The object will exist on the destination plane and we want it to seem unchanged by it so we invert the destination matrix (`to`) and then apply the source matrix (`from`)\n * @param [from]\n * @param [to]\n * @returns\n */\nexport const calcPlaneChangeMatrix = (\n  from: TMat2D = iMatrix,\n  to: TMat2D = iMatrix,\n) => multiplyTransformMatrices(invertTransform(to), from);\n\n/**\n * Sends a point from the source coordinate plane to the destination coordinate plane.\\\n * From the canvas/viewer's perspective the point remains unchanged.\n *\n * @example <caption>Send point from canvas plane to group plane</caption>\n * var obj = new Rect({ left: 20, top: 20, width: 60, height: 60, strokeWidth: 0 });\n * var group = new Group([obj], { strokeWidth: 0 });\n * var sentPoint1 = sendPointToPlane(new Point(50, 50), undefined, group.calcTransformMatrix());\n * var sentPoint2 = sendPointToPlane(new Point(50, 50), iMatrix, group.calcTransformMatrix());\n * console.log(sentPoint1, sentPoint2) //  both points print (0,0) which is the center of group\n *\n * @param {Point} point\n * @param {TMat2D} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `point` exists in the canvas coordinate plane.\n * @param {TMat2D} [to] destination plane matrix to contain object. Passing `undefined` means `point` should be sent to the canvas coordinate plane.\n * @returns {Point} transformed point\n */\nexport const sendPointToPlane = (\n  point: Point,\n  from: TMat2D = iMatrix,\n  to: TMat2D = iMatrix,\n): Point => point.transform(calcPlaneChangeMatrix(from, to));\n\n/**\n * See {@link sendPointToPlane}\n */\nexport const sendVectorToPlane = (\n  point: Point,\n  from: TMat2D = iMatrix,\n  to: TMat2D = iMatrix,\n): Point => point.transform(calcPlaneChangeMatrix(from, to), true);\n\n/**\n *\n * A util that abstracts applying transform to objects.\\\n * Sends `object` to the destination coordinate plane by applying the relevant transformations.\\\n * Changes the space/plane where `object` is drawn.\\\n * From the canvas/viewer's perspective `object` remains unchanged.\n *\n * @example <caption>Move clip path from one object to another while preserving it's appearance as viewed by canvas/viewer</caption>\n * let obj, obj2;\n * let clipPath = new Circle({ radius: 50 });\n * obj.clipPath = clipPath;\n * // render\n * sendObjectToPlane(clipPath, obj.calcTransformMatrix(), obj2.calcTransformMatrix());\n * obj.clipPath = undefined;\n * obj2.clipPath = clipPath;\n * // render, clipPath now clips obj2 but seems unchanged from the eyes of the viewer\n *\n * @example <caption>Clip an object's clip path with an existing object</caption>\n * let obj, existingObj;\n * let clipPath = new Circle({ radius: 50 });\n * obj.clipPath = clipPath;\n * let transformTo = multiplyTransformMatrices(obj.calcTransformMatrix(), clipPath.calcTransformMatrix());\n * sendObjectToPlane(existingObj, existingObj.group?.calcTransformMatrix(), transformTo);\n * clipPath.clipPath = existingObj;\n *\n * @param {FabricObject} object\n * @param {Matrix} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `object` is a direct child of canvas.\n * @param {Matrix} [to] destination plane matrix to contain object. Passing `undefined` means `object` should be sent to the canvas coordinate plane.\n * @returns {Matrix} the transform matrix that was applied to `object`\n */\nexport const sendObjectToPlane = (\n  object: FabricObject,\n  from?: TMat2D,\n  to?: TMat2D,\n): TMat2D => {\n  const t = calcPlaneChangeMatrix(from, to);\n  applyTransformToObject(\n    object,\n    multiplyTransformMatrices(t, object.calcOwnMatrix()),\n  );\n  return t;\n};\n"],"names":["calcPlaneChangeMatrix","from","arguments","length","undefined","iMatrix","multiplyTransformMatrices","invertTransform","sendPointToPlane","point","to","transform","sendVectorToPlane","sendObjectToPlane","object","t","applyTransformToObject","calcOwnMatrix"],"mappings":"wMAcO,MAAMA,EAAwB,WAAA,IACnCC,EAAYC,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGG,EACK,OACjBC,EAA0BC,EADnBL,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGG,GACqCJ,EAAK,EAkB5CO,EAAmB,SAC9BC,GAAY,IACZR,EAAYC,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGG,EACfK,EAAUR,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGG,EAAO,OACVI,EAAME,UAAUX,EAAsBC,EAAMS,GAAI,EAK/CE,EAAoB,SAC/BH,GAAY,IACZR,EAAYC,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGG,EACfK,EAAUR,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGG,EAAO,OACVI,EAAME,UAAUX,EAAsBC,EAAMS,IAAK,EAAK,EAgCrDG,EAAoBA,CAC/BC,EACAb,EACAS,KAEA,MAAMK,EAAIf,EAAsBC,EAAMS,GAKtC,OAJAM,EACEF,EACAR,EAA0BS,EAAGD,EAAOG,kBAE/BF"}

package/dist/src/util/misc/planeChange.mjs

@@ -0,0 +1,86 @@
+import { iMatrix } from '../../constants.mjs';
+import { multiplyTransformMatrices, invertTransform } from './matrix.mjs';
+import { applyTransformToObject } from './objectTransforms.mjs';
+
+/**
+ * We are actually looking for the transformation from the destination plane to the source plane (change of basis matrix)\
+ * The object will exist on the destination plane and we want it to seem unchanged by it so we invert the destination matrix (`to`) and then apply the source matrix (`from`)
+ * @param [from]
+ * @param [to]
+ * @returns
+ */
+const calcPlaneChangeMatrix = function () {
+  let from = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : iMatrix;
+  let to = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : iMatrix;
+  return multiplyTransformMatrices(invertTransform(to), from);
+};
+
+/**
+ * Sends a point from the source coordinate plane to the destination coordinate plane.\
+ * From the canvas/viewer's perspective the point remains unchanged.
+ *
+ * @example <caption>Send point from canvas plane to group plane</caption>
+ * var obj = new Rect({ left: 20, top: 20, width: 60, height: 60, strokeWidth: 0 });
+ * var group = new Group([obj], { strokeWidth: 0 });
+ * var sentPoint1 = sendPointToPlane(new Point(50, 50), undefined, group.calcTransformMatrix());
+ * var sentPoint2 = sendPointToPlane(new Point(50, 50), iMatrix, group.calcTransformMatrix());
+ * console.log(sentPoint1, sentPoint2) //  both points print (0,0) which is the center of group
+ *
+ * @param {Point} point
+ * @param {TMat2D} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `point` exists in the canvas coordinate plane.
+ * @param {TMat2D} [to] destination plane matrix to contain object. Passing `undefined` means `point` should be sent to the canvas coordinate plane.
+ * @returns {Point} transformed point
+ */
+const sendPointToPlane = function (point) {
+  let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : iMatrix;
+  let to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : iMatrix;
+  return point.transform(calcPlaneChangeMatrix(from, to));
+};
+
+/**
+ * See {@link sendPointToPlane}
+ */
+const sendVectorToPlane = function (point) {
+  let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : iMatrix;
+  let to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : iMatrix;
+  return point.transform(calcPlaneChangeMatrix(from, to), true);
+};
+
+/**
+ *
+ * A util that abstracts applying transform to objects.\
+ * Sends `object` to the destination coordinate plane by applying the relevant transformations.\
+ * Changes the space/plane where `object` is drawn.\
+ * From the canvas/viewer's perspective `object` remains unchanged.
+ *
+ * @example <caption>Move clip path from one object to another while preserving it's appearance as viewed by canvas/viewer</caption>
+ * let obj, obj2;
+ * let clipPath = new Circle({ radius: 50 });
+ * obj.clipPath = clipPath;
+ * // render
+ * sendObjectToPlane(clipPath, obj.calcTransformMatrix(), obj2.calcTransformMatrix());
+ * obj.clipPath = undefined;
+ * obj2.clipPath = clipPath;
+ * // render, clipPath now clips obj2 but seems unchanged from the eyes of the viewer
+ *
+ * @example <caption>Clip an object's clip path with an existing object</caption>
+ * let obj, existingObj;
+ * let clipPath = new Circle({ radius: 50 });
+ * obj.clipPath = clipPath;
+ * let transformTo = multiplyTransformMatrices(obj.calcTransformMatrix(), clipPath.calcTransformMatrix());
+ * sendObjectToPlane(existingObj, existingObj.group?.calcTransformMatrix(), transformTo);
+ * clipPath.clipPath = existingObj;
+ *
+ * @param {FabricObject} object
+ * @param {Matrix} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `object` is a direct child of canvas.
+ * @param {Matrix} [to] destination plane matrix to contain object. Passing `undefined` means `object` should be sent to the canvas coordinate plane.
+ * @returns {Matrix} the transform matrix that was applied to `object`
+ */
+const sendObjectToPlane = (object, from, to) => {
+  const t = calcPlaneChangeMatrix(from, to);
+  applyTransformToObject(object, multiplyTransformMatrices(t, object.calcOwnMatrix()));
+  return t;
+};
+
+export { calcPlaneChangeMatrix, sendObjectToPlane, sendPointToPlane, sendVectorToPlane };
+//# sourceMappingURL=planeChange.mjs.map

package/dist/src/util/misc/planeChange.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planeChange.mjs","sources":["../../../../src/util/misc/planeChange.ts"],"sourcesContent":["import { iMatrix } from '../../constants';\nimport type { Point } from '../../Point';\nimport type { FabricObject } from '../../shapes/Object/Object';\nimport type { TMat2D } from '../../typedefs';\nimport { invertTransform, multiplyTransformMatrices } from './matrix';\nimport { applyTransformToObject } from './objectTransforms';\n\n/**\n * We are actually looking for the transformation from the destination plane to the source plane (change of basis matrix)\\\n * The object will exist on the destination plane and we want it to seem unchanged by it so we invert the destination matrix (`to`) and then apply the source matrix (`from`)\n * @param [from]\n * @param [to]\n * @returns\n */\nexport const calcPlaneChangeMatrix = (\n  from: TMat2D = iMatrix,\n  to: TMat2D = iMatrix,\n) => multiplyTransformMatrices(invertTransform(to), from);\n\n/**\n * Sends a point from the source coordinate plane to the destination coordinate plane.\\\n * From the canvas/viewer's perspective the point remains unchanged.\n *\n * @example <caption>Send point from canvas plane to group plane</caption>\n * var obj = new Rect({ left: 20, top: 20, width: 60, height: 60, strokeWidth: 0 });\n * var group = new Group([obj], { strokeWidth: 0 });\n * var sentPoint1 = sendPointToPlane(new Point(50, 50), undefined, group.calcTransformMatrix());\n * var sentPoint2 = sendPointToPlane(new Point(50, 50), iMatrix, group.calcTransformMatrix());\n * console.log(sentPoint1, sentPoint2) //  both points print (0,0) which is the center of group\n *\n * @param {Point} point\n * @param {TMat2D} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `point` exists in the canvas coordinate plane.\n * @param {TMat2D} [to] destination plane matrix to contain object. Passing `undefined` means `point` should be sent to the canvas coordinate plane.\n * @returns {Point} transformed point\n */\nexport const sendPointToPlane = (\n  point: Point,\n  from: TMat2D = iMatrix,\n  to: TMat2D = iMatrix,\n): Point => point.transform(calcPlaneChangeMatrix(from, to));\n\n/**\n * See {@link sendPointToPlane}\n */\nexport const sendVectorToPlane = (\n  point: Point,\n  from: TMat2D = iMatrix,\n  to: TMat2D = iMatrix,\n): Point => point.transform(calcPlaneChangeMatrix(from, to), true);\n\n/**\n *\n * A util that abstracts applying transform to objects.\\\n * Sends `object` to the destination coordinate plane by applying the relevant transformations.\\\n * Changes the space/plane where `object` is drawn.\\\n * From the canvas/viewer's perspective `object` remains unchanged.\n *\n * @example <caption>Move clip path from one object to another while preserving it's appearance as viewed by canvas/viewer</caption>\n * let obj, obj2;\n * let clipPath = new Circle({ radius: 50 });\n * obj.clipPath = clipPath;\n * // render\n * sendObjectToPlane(clipPath, obj.calcTransformMatrix(), obj2.calcTransformMatrix());\n * obj.clipPath = undefined;\n * obj2.clipPath = clipPath;\n * // render, clipPath now clips obj2 but seems unchanged from the eyes of the viewer\n *\n * @example <caption>Clip an object's clip path with an existing object</caption>\n * let obj, existingObj;\n * let clipPath = new Circle({ radius: 50 });\n * obj.clipPath = clipPath;\n * let transformTo = multiplyTransformMatrices(obj.calcTransformMatrix(), clipPath.calcTransformMatrix());\n * sendObjectToPlane(existingObj, existingObj.group?.calcTransformMatrix(), transformTo);\n * clipPath.clipPath = existingObj;\n *\n * @param {FabricObject} object\n * @param {Matrix} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `object` is a direct child of canvas.\n * @param {Matrix} [to] destination plane matrix to contain object. Passing `undefined` means `object` should be sent to the canvas coordinate plane.\n * @returns {Matrix} the transform matrix that was applied to `object`\n */\nexport const sendObjectToPlane = (\n  object: FabricObject,\n  from?: TMat2D,\n  to?: TMat2D,\n): TMat2D => {\n  const t = calcPlaneChangeMatrix(from, to);\n  applyTransformToObject(\n    object,\n    multiplyTransformMatrices(t, object.calcOwnMatrix()),\n  );\n  return t;\n};\n"],"names":["calcPlaneChangeMatrix","from","arguments","length","undefined","iMatrix","to","multiplyTransformMatrices","invertTransform","sendPointToPlane","point","transform","sendVectorToPlane","sendObjectToPlane","object","t","applyTransformToObject","calcOwnMatrix"],"mappings":";;;;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,qBAAqB,GAAG,YAAA;AAAA,EAAA,IACnCC,IAAY,GAAAC,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAGG,OAAO;AAAA,EAAA,IACtBC,EAAU,GAAAJ,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAGG,OAAO;EAAA,OACjBE,yBAAyB,CAACC,eAAe,CAACF,EAAE,CAAC,EAAEL,IAAI,CAAC;AAAA;;AAEzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMQ,gBAAgB,GAAG,UAC9BC,KAAY,EAAA;AAAA,EAAA,IACZT,IAAY,GAAAC,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAGG,OAAO;AAAA,EAAA,IACtBC,EAAU,GAAAJ,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAGG,OAAO;EAAA,OACVK,KAAK,CAACC,SAAS,CAACX,qBAAqB,CAACC,IAAI,EAAEK,EAAE,CAAC,CAAC;AAAA;;AAE5D;AACA;AACA;AACO,MAAMM,iBAAiB,GAAG,UAC/BF,KAAY,EAAA;AAAA,EAAA,IACZT,IAAY,GAAAC,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAGG,OAAO;AAAA,EAAA,IACtBC,EAAU,GAAAJ,SAAA,CAAAC,MAAA,GAAA,CAAA,IAAAD,SAAA,CAAA,CAAA,CAAA,KAAAE,SAAA,GAAAF,SAAA,CAAA,CAAA,CAAA,GAAGG,OAAO;AAAA,EAAA,OACVK,KAAK,CAACC,SAAS,CAACX,qBAAqB,CAACC,IAAI,EAAEK,EAAE,CAAC,EAAE,IAAI,CAAC;AAAA;;AAElE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMO,iBAAiB,GAAGA,CAC/BC,MAAoB,EACpBb,IAAa,EACbK,EAAW,KACA;AACX,EAAA,MAAMS,CAAC,GAAGf,qBAAqB,CAACC,IAAI,EAAEK,EAAE,CAAC;AACzCU,EAAAA,sBAAsB,CACpBF,MAAM,EACNP,yBAAyB,CAACQ,CAAC,EAAED,MAAM,CAACG,aAAa,EAAE,CACrD,CAAC;AACD,EAAA,OAAOF,CAAC;AACV;;;;"}

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

@@ -0,0 +1,52 @@
+import type { XY } from '../../../Point';
+import { Point } from '../../../Point';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase';
+import type { 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: XY, T: XY, 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/StrokeLineCapProjections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrokeLineCapProjections.d.ts","sourceRoot":"","sources":["../../../../../src/util/misc/projectStroke/StrokeLineCapProjections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAE1E;;;;;;;;;;;GAWG;AACH,qBAAa,wBAAyB,SAAQ,qBAAqB;IACjE;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;IACjB;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;gBAEL,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,6BAA6B;IAMhE,wBAAwB,CACtB,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,SAAS,GAAE,MAAuC;IAMpD;;;;;OAKG;IACH,WAAW;IAOX;;;;;OAKG;IACH,YAAY;IA6BZ;;;;;OAKG;IACH,aAAa;IAgCb,SAAS,CAAC,aAAa;IAWhB,OAAO,IAAI,WAAW,EAAE;CAMhC"}

package/dist/src/util/misc/projectStroke/StrokeLineCapProjections.min.mjs

@@ -0,0 +1,2 @@
+import{Point as t}from"../../../Point.min.mjs";import{getOrthonormalVector as i,getUnitVector as s}from"../vectors.min.mjs";import{StrokeLineJoinProjections as e}from"./StrokeLineJoinProjections.min.mjs";import{StrokeProjectionsBase as o}from"./StrokeProjectionsBase.min.mjs";class r extends o{constructor(i,s,e){super(e),this.A=new t(i),this.T=new t(s)}calcOrthogonalProjection(t,s){let e=arguments.length>2&&void 0!==arguments[2]?arguments[2]:this.strokeProjectionMagnitude;const o=this.createSideVector(t,s);return this.scaleUnitVector(i(o),e)}projectButt(){return[this.projectOrthogonally(this.A,this.T,this.strokeProjectionMagnitude),this.projectOrthogonally(this.A,this.T,-this.strokeProjectionMagnitude)]}projectRound(){const i=[];if(!this.isSkewed()&&this.A.eq(this.T)){const s=new t(1,1).scalarMultiply(this.strokeProjectionMagnitude).multiply(this.strokeUniformScalar);i.push(this.applySkew(this.A.add(s)),this.applySkew(this.A.subtract(s)))}else i.push(...new e(this.A,this.T,this.T,this.options).projectRound());return i}projectSquare(){const i=[];if(this.A.eq(this.T)){const s=new t(1,1).scalarMultiply(this.strokeProjectionMagnitude).multiply(this.strokeUniformScalar);i.push(this.A.add(s),this.A.subtract(s))}else{const t=this.calcOrthogonalProjection(this.A,this.T,this.strokeProjectionMagnitude),e=this.scaleUnitVector(s(this.createSideVector(this.A,this.T)),-this.strokeProjectionMagnitude),o=this.A.add(e);i.push(o.add(t),o.subtract(t))}return i.map(t=>this.applySkew(t))}projectPoints(){switch(this.options.strokeLineCap){case"round":return this.projectRound();case"square":return this.projectSquare();default:return this.projectButt()}}project(){return this.projectPoints().map(t=>({originPoint:this.A,projectedPoint:t}))}}export{r as StrokeLineCapProjections};
+//# sourceMappingURL=StrokeLineCapProjections.min.mjs.map

package/dist/src/util/misc/projectStroke/StrokeLineCapProjections.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrokeLineCapProjections.min.mjs","sources":["../../../../../src/util/misc/projectStroke/StrokeLineCapProjections.ts"],"sourcesContent":["import type { XY } from '../../../Point';\nimport { Point } from '../../../Point';\nimport { getOrthonormalVector, getUnitVector } from '../vectors';\nimport { StrokeLineJoinProjections } from './StrokeLineJoinProjections';\nimport { StrokeProjectionsBase } from './StrokeProjectionsBase';\nimport type { TProjection, TProjectStrokeOnPointsOptions } from './types';\n\n/**\n * class in charge of finding projections for each type of line cap for start/end of an open path\n * @see {@link [Open path projections at #8344](https://github.com/fabricjs/fabric.js/pull/8344#1-open-path)}\n *\n * Reference:\n * - MDN:\n *   - https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/lineCap\n *   - https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap\n * - Spec: https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-linecap-dev\n * - Playground to understand how the line joins works: https://hypertolosana.github.io/efficient-webgl-stroking/index.html\n * - 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\n */\nexport class StrokeLineCapProjections extends StrokeProjectionsBase {\n  /**\n   * edge point\n   */\n  declare A: Point;\n  /**\n   * point next to edge point\n   */\n  declare T: Point;\n\n  constructor(A: XY, T: XY, options: TProjectStrokeOnPointsOptions) {\n    super(options);\n    this.A = new Point(A);\n    this.T = new Point(T);\n  }\n\n  calcOrthogonalProjection(\n    from: Point,\n    to: Point,\n    magnitude: number = this.strokeProjectionMagnitude,\n  ) {\n    const vector = this.createSideVector(from, to);\n    return this.scaleUnitVector(getOrthonormalVector(vector), magnitude);\n  }\n\n  /**\n   * OPEN PATH START/END - Line cap: Butt\n   * Calculation: to find the projections, just find the points orthogonal to the stroke\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#1-1-butt\n   */\n  projectButt() {\n    return [\n      this.projectOrthogonally(this.A, this.T, this.strokeProjectionMagnitude),\n      this.projectOrthogonally(this.A, this.T, -this.strokeProjectionMagnitude),\n    ];\n  }\n\n  /**\n   * OPEN PATH START/END - Line cap: Round\n   * Calculation: same as stroke line join `round`\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#1-2-round\n   */\n  projectRound() {\n    const projections: Point[] = [];\n\n    if (!this.isSkewed() && this.A.eq(this.T)) {\n      /* 1 point case without `skew`\n        When `strokeUniform` is true, scaling has no effect.\n        So we divide by scale, to remove its effect.\n      */\n      const projection = new Point(1, 1)\n        .scalarMultiply(this.strokeProjectionMagnitude)\n        .multiply(this.strokeUniformScalar);\n      projections.push(\n        this.applySkew(this.A.add(projection)),\n        this.applySkew(this.A.subtract(projection)),\n      );\n    } else {\n      projections.push(\n        ...new StrokeLineJoinProjections(\n          this.A,\n          this.T,\n          this.T,\n          this.options,\n        ).projectRound(),\n      );\n    }\n\n    return projections;\n  }\n\n  /**\n   * OPEN PATH START/END - Line cap: Square\n   * Calculation: project a rectangle of points on the stroke in the opposite direction of the vector `AT`\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#1-3-square\n   */\n  projectSquare() {\n    const projections: Point[] = [];\n\n    if (this.A.eq(this.T)) {\n      /* 1 point case without `skew`\n        When `strokeUniform` is true, scaling has no effect.\n        So we divide by scale, to remove its effect.\n      */\n      const projection = new Point(1, 1)\n        .scalarMultiply(this.strokeProjectionMagnitude)\n        .multiply(this.strokeUniformScalar);\n      projections.push(this.A.add(projection), this.A.subtract(projection));\n    } else {\n      const orthogonalProjection = this.calcOrthogonalProjection(\n        this.A,\n        this.T,\n        this.strokeProjectionMagnitude,\n      );\n      const strokePointingOut = this.scaleUnitVector(\n        getUnitVector(this.createSideVector(this.A, this.T)),\n        -this.strokeProjectionMagnitude,\n      );\n      const projectedA = this.A.add(strokePointingOut);\n      projections.push(\n        projectedA.add(orthogonalProjection),\n        projectedA.subtract(orthogonalProjection),\n      );\n    }\n\n    return projections.map((p) => this.applySkew(p));\n  }\n\n  protected projectPoints() {\n    switch (this.options.strokeLineCap) {\n      case 'round':\n        return this.projectRound();\n      case 'square':\n        return this.projectSquare();\n      default:\n        return this.projectButt();\n    }\n  }\n\n  public project(): TProjection[] {\n    return this.projectPoints().map((point) => ({\n      originPoint: this.A,\n      projectedPoint: point,\n    }));\n  }\n}\n"],"names":["StrokeLineCapProjections","StrokeProjectionsBase","constructor","A","T","options","super","this","Point","calcOrthogonalProjection","from","to","magnitude","arguments","length","undefined","strokeProjectionMagnitude","vector","createSideVector","scaleUnitVector","getOrthonormalVector","projectButt","projectOrthogonally","projectRound","projections","isSkewed","eq","projection","scalarMultiply","multiply","strokeUniformScalar","push","applySkew","add","subtract","StrokeLineJoinProjections","projectSquare","orthogonalProjection","strokePointingOut","getUnitVector","projectedA","map","p","projectPoints","strokeLineCap","project","point","originPoint","projectedPoint"],"mappings":"oRAmBO,MAAMA,UAAiCC,EAU5CC,WAAAA,CAAYC,EAAOC,EAAOC,GACxBC,MAAMD,GACNE,KAAKJ,EAAI,IAAIK,EAAML,GACnBI,KAAKH,EAAI,IAAII,EAAMJ,EACrB,CAEAK,wBAAAA,CACEC,EACAC,GAEA,IADAC,EAAiBC,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAGN,KAAKS,0BAEzB,MAAMC,EAASV,KAAKW,iBAAiBR,EAAMC,GAC3C,OAAOJ,KAAKY,gBAAgBC,EAAqBH,GAASL,EAC5D,CAQAS,WAAAA,GACE,MAAO,CACLd,KAAKe,oBAAoBf,KAAKJ,EAAGI,KAAKH,EAAGG,KAAKS,2BAC9CT,KAAKe,oBAAoBf,KAAKJ,EAAGI,KAAKH,GAAIG,KAAKS,2BAEnD,CAQAO,YAAAA,GACE,MAAMC,EAAuB,GAE7B,IAAKjB,KAAKkB,YAAclB,KAAKJ,EAAEuB,GAAGnB,KAAKH,GAAI,CAKzC,MAAMuB,EAAa,IAAInB,EAAM,EAAG,GAC7BoB,eAAerB,KAAKS,2BACpBa,SAAStB,KAAKuB,qBACjBN,EAAYO,KACVxB,KAAKyB,UAAUzB,KAAKJ,EAAE8B,IAAIN,IAC1BpB,KAAKyB,UAAUzB,KAAKJ,EAAE+B,SAASP,IAEnC,MACEH,EAAYO,QACP,IAAII,EACL5B,KAAKJ,EACLI,KAAKH,EACLG,KAAKH,EACLG,KAAKF,SACLkB,gBAIN,OAAOC,CACT,CAQAY,aAAAA,GACE,MAAMZ,EAAuB,GAE7B,GAAIjB,KAAKJ,EAAEuB,GAAGnB,KAAKH,GAAI,CAKrB,MAAMuB,EAAa,IAAInB,EAAM,EAAG,GAC7BoB,eAAerB,KAAKS,2BACpBa,SAAStB,KAAKuB,qBACjBN,EAAYO,KAAKxB,KAAKJ,EAAE8B,IAAIN,GAAapB,KAAKJ,EAAE+B,SAASP,GAC3D,KAAO,CACL,MAAMU,EAAuB9B,KAAKE,yBAChCF,KAAKJ,EACLI,KAAKH,EACLG,KAAKS,2BAEDsB,EAAoB/B,KAAKY,gBAC7BoB,EAAchC,KAAKW,iBAAiBX,KAAKJ,EAAGI,KAAKH,KAChDG,KAAKS,2BAEFwB,EAAajC,KAAKJ,EAAE8B,IAAIK,GAC9Bd,EAAYO,KACVS,EAAWP,IAAII,GACfG,EAAWN,SAASG,GAExB,CAEA,OAAOb,EAAYiB,IAAKC,GAAMnC,KAAKyB,UAAUU,GAC/C,CAEUC,aAAAA,GACR,OAAQpC,KAAKF,QAAQuC,eACnB,IAAK,QACH,OAAOrC,KAAKgB,eACd,IAAK,SACH,OAAOhB,KAAK6B,gBACd,QACE,OAAO7B,KAAKc,cAElB,CAEOwB,OAAAA,GACL,OAAOtC,KAAKoC,gBAAgBF,IAAKK,IAAK,CACpCC,YAAaxC,KAAKJ,EAClB6C,eAAgBF,IAEpB"}

package/dist/src/util/misc/projectStroke/StrokeLineCapProjections.mjs

@@ -0,0 +1,111 @@
+import { Point } from '../../../Point.mjs';
+import { getOrthonormalVector, getUnitVector } from '../vectors.mjs';
+import { StrokeLineJoinProjections } from './StrokeLineJoinProjections.mjs';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase.mjs';
+
+/**
+ * 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
+ */
+class StrokeLineCapProjections extends StrokeProjectionsBase {
+  /**
+   * edge point
+   */
+
+  /**
+   * point next to edge point
+   */
+
+  constructor(A, T, options) {
+    super(options);
+    this.A = new Point(A);
+    this.T = new Point(T);
+  }
+  calcOrthogonalProjection(from, to) {
+    let magnitude = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.strokeProjectionMagnitude;
+    const vector = this.createSideVector(from, to);
+    return this.scaleUnitVector(getOrthonormalVector(vector), magnitude);
+  }
+
+  /**
+   * 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() {
+    return [this.projectOrthogonally(this.A, this.T, this.strokeProjectionMagnitude), this.projectOrthogonally(this.A, this.T, -this.strokeProjectionMagnitude)];
+  }
+
+  /**
+   * 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() {
+    const projections = [];
+    if (!this.isSkewed() && this.A.eq(this.T)) {
+      /* 1 point case without `skew`
+        When `strokeUniform` is true, scaling has no effect.
+        So we divide by scale, to remove its effect.
+      */
+      const projection = new Point(1, 1).scalarMultiply(this.strokeProjectionMagnitude).multiply(this.strokeUniformScalar);
+      projections.push(this.applySkew(this.A.add(projection)), this.applySkew(this.A.subtract(projection)));
+    } else {
+      projections.push(...new StrokeLineJoinProjections(this.A, this.T, this.T, this.options).projectRound());
+    }
+    return projections;
+  }
+
+  /**
+   * 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() {
+    const projections = [];
+    if (this.A.eq(this.T)) {
+      /* 1 point case without `skew`
+        When `strokeUniform` is true, scaling has no effect.
+        So we divide by scale, to remove its effect.
+      */
+      const projection = new Point(1, 1).scalarMultiply(this.strokeProjectionMagnitude).multiply(this.strokeUniformScalar);
+      projections.push(this.A.add(projection), this.A.subtract(projection));
+    } else {
+      const orthogonalProjection = this.calcOrthogonalProjection(this.A, this.T, this.strokeProjectionMagnitude);
+      const strokePointingOut = this.scaleUnitVector(getUnitVector(this.createSideVector(this.A, this.T)), -this.strokeProjectionMagnitude);
+      const projectedA = this.A.add(strokePointingOut);
+      projections.push(projectedA.add(orthogonalProjection), projectedA.subtract(orthogonalProjection));
+    }
+    return projections.map(p => this.applySkew(p));
+  }
+  projectPoints() {
+    switch (this.options.strokeLineCap) {
+      case 'round':
+        return this.projectRound();
+      case 'square':
+        return this.projectSquare();
+      default:
+        return this.projectButt();
+    }
+  }
+  project() {
+    return this.projectPoints().map(point => ({
+      originPoint: this.A,
+      projectedPoint: point
+    }));
+  }
+}
+
+export { StrokeLineCapProjections };
+//# sourceMappingURL=StrokeLineCapProjections.mjs.map

package/dist/src/util/misc/projectStroke/StrokeLineCapProjections.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrokeLineCapProjections.mjs","sources":["../../../../../src/util/misc/projectStroke/StrokeLineCapProjections.ts"],"sourcesContent":["import type { XY } from '../../../Point';\nimport { Point } from '../../../Point';\nimport { getOrthonormalVector, getUnitVector } from '../vectors';\nimport { StrokeLineJoinProjections } from './StrokeLineJoinProjections';\nimport { StrokeProjectionsBase } from './StrokeProjectionsBase';\nimport type { TProjection, TProjectStrokeOnPointsOptions } from './types';\n\n/**\n * class in charge of finding projections for each type of line cap for start/end of an open path\n * @see {@link [Open path projections at #8344](https://github.com/fabricjs/fabric.js/pull/8344#1-open-path)}\n *\n * Reference:\n * - MDN:\n *   - https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/lineCap\n *   - https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap\n * - Spec: https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-linecap-dev\n * - Playground to understand how the line joins works: https://hypertolosana.github.io/efficient-webgl-stroking/index.html\n * - 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\n */\nexport class StrokeLineCapProjections extends StrokeProjectionsBase {\n  /**\n   * edge point\n   */\n  declare A: Point;\n  /**\n   * point next to edge point\n   */\n  declare T: Point;\n\n  constructor(A: XY, T: XY, options: TProjectStrokeOnPointsOptions) {\n    super(options);\n    this.A = new Point(A);\n    this.T = new Point(T);\n  }\n\n  calcOrthogonalProjection(\n    from: Point,\n    to: Point,\n    magnitude: number = this.strokeProjectionMagnitude,\n  ) {\n    const vector = this.createSideVector(from, to);\n    return this.scaleUnitVector(getOrthonormalVector(vector), magnitude);\n  }\n\n  /**\n   * OPEN PATH START/END - Line cap: Butt\n   * Calculation: to find the projections, just find the points orthogonal to the stroke\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#1-1-butt\n   */\n  projectButt() {\n    return [\n      this.projectOrthogonally(this.A, this.T, this.strokeProjectionMagnitude),\n      this.projectOrthogonally(this.A, this.T, -this.strokeProjectionMagnitude),\n    ];\n  }\n\n  /**\n   * OPEN PATH START/END - Line cap: Round\n   * Calculation: same as stroke line join `round`\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#1-2-round\n   */\n  projectRound() {\n    const projections: Point[] = [];\n\n    if (!this.isSkewed() && this.A.eq(this.T)) {\n      /* 1 point case without `skew`\n        When `strokeUniform` is true, scaling has no effect.\n        So we divide by scale, to remove its effect.\n      */\n      const projection = new Point(1, 1)\n        .scalarMultiply(this.strokeProjectionMagnitude)\n        .multiply(this.strokeUniformScalar);\n      projections.push(\n        this.applySkew(this.A.add(projection)),\n        this.applySkew(this.A.subtract(projection)),\n      );\n    } else {\n      projections.push(\n        ...new StrokeLineJoinProjections(\n          this.A,\n          this.T,\n          this.T,\n          this.options,\n        ).projectRound(),\n      );\n    }\n\n    return projections;\n  }\n\n  /**\n   * OPEN PATH START/END - Line cap: Square\n   * Calculation: project a rectangle of points on the stroke in the opposite direction of the vector `AT`\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#1-3-square\n   */\n  projectSquare() {\n    const projections: Point[] = [];\n\n    if (this.A.eq(this.T)) {\n      /* 1 point case without `skew`\n        When `strokeUniform` is true, scaling has no effect.\n        So we divide by scale, to remove its effect.\n      */\n      const projection = new Point(1, 1)\n        .scalarMultiply(this.strokeProjectionMagnitude)\n        .multiply(this.strokeUniformScalar);\n      projections.push(this.A.add(projection), this.A.subtract(projection));\n    } else {\n      const orthogonalProjection = this.calcOrthogonalProjection(\n        this.A,\n        this.T,\n        this.strokeProjectionMagnitude,\n      );\n      const strokePointingOut = this.scaleUnitVector(\n        getUnitVector(this.createSideVector(this.A, this.T)),\n        -this.strokeProjectionMagnitude,\n      );\n      const projectedA = this.A.add(strokePointingOut);\n      projections.push(\n        projectedA.add(orthogonalProjection),\n        projectedA.subtract(orthogonalProjection),\n      );\n    }\n\n    return projections.map((p) => this.applySkew(p));\n  }\n\n  protected projectPoints() {\n    switch (this.options.strokeLineCap) {\n      case 'round':\n        return this.projectRound();\n      case 'square':\n        return this.projectSquare();\n      default:\n        return this.projectButt();\n    }\n  }\n\n  public project(): TProjection[] {\n    return this.projectPoints().map((point) => ({\n      originPoint: this.A,\n      projectedPoint: point,\n    }));\n  }\n}\n"],"names":["StrokeLineCapProjections","StrokeProjectionsBase","constructor","A","T","options","Point","calcOrthogonalProjection","from","to","magnitude","arguments","length","undefined","strokeProjectionMagnitude","vector","createSideVector","scaleUnitVector","getOrthonormalVector","projectButt","projectOrthogonally","projectRound","projections","isSkewed","eq","projection","scalarMultiply","multiply","strokeUniformScalar","push","applySkew","add","subtract","StrokeLineJoinProjections","projectSquare","orthogonalProjection","strokePointingOut","getUnitVector","projectedA","map","p","projectPoints","strokeLineCap","project","point","originPoint","projectedPoint"],"mappings":"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"}

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

@@ -0,0 +1,90 @@
+import type { XY } from '../../../Point';
+import { Point } from '../../../Point';
+import type { TRadian } from '../../../typedefs';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase';
+import type { 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 AB vector
+     */
+    AB: Point;
+    /**
+     * The AC vector
+     */
+    AC: Point;
+    /**
+     * The angle of A (∠BAC)
+     */
+    alpha: TRadian;
+    /**
+     * The bisector of A (∠BAC)
+     */
+    bisector: Point;
+    static getOrthogonalRotationFactor(vector1: Point, vector2?: Point): 1 | -1;
+    constructor(A: XY, B: XY, C: XY, options: TProjectStrokeOnPointsOptions);
+    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.
+     *
+     * @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/StrokeLineJoinProjections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrokeLineJoinProjections.d.ts","sourceRoot":"","sources":["../../../../../src/util/misc/projectStroke/StrokeLineJoinProjections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAYjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAI1E;;;;;;;;;;;GAWG;AACH,qBAAa,yBAA0B,SAAQ,qBAAqB;IAClE;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;IACjB;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;IACjB;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;IACjB;;OAEG;IACH,EAAE,EAAE,KAAK,CAAC;IACV;;OAEG;IACH,EAAE,EAAE,KAAK,CAAC;IACV;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IACf;;OAEG;IACH,QAAQ,EAAE,KAAK,CAAC;IAEhB,MAAM,CAAC,2BAA2B,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,KAAK;gBAOtD,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,6BAA6B;IAevE,wBAAwB,CACtB,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,SAAS,GAAE,MAAuC;IAWpD;;;;;OAKG;IACH,YAAY;IAcZ;;;;;;OAMG;IACH,YAAY;IAmCZ;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IA0B1B;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAyD5B,YAAY;IAgCZ;;;;;OAKG;IACH,SAAS,CAAC,aAAa;IAWhB,OAAO,IAAI,WAAW,EAAE;CAQhC"}

package/dist/src/util/misc/projectStroke/StrokeLineJoinProjections.min.mjs

@@ -0,0 +1,2 @@
+import{defineProperty as t}from"../../../../_virtual/_rollupPluginBabelHelpers.min.mjs";import{Point as i}from"../../../Point.min.mjs";import{halfPI as s,twoMathPi as o}from"../../../constants.min.mjs";import{degreesToRadians as e}from"../radiansDegreesConversion.min.mjs";import{calcAngleBetweenVectors as r,calcVectorRotation as h,getUnitVector as a,rotateVector as n,getOrthonormalVector as c,magnitude as l,isBetweenVectors as p,crossProduct as u}from"../vectors.min.mjs";import{StrokeProjectionsBase as m}from"./StrokeProjectionsBase.min.mjs";const d=new i;class j extends m{static getOrthogonalRotationFactor(t,i){const o=i?r(t,i):h(t);return Math.abs(o)<s?-1:1}constructor(s,o,e,h){super(h),t(this,"AB",void 0),t(this,"AC",void 0),t(this,"alpha",void 0),t(this,"bisector",void 0),this.A=new i(s),this.B=new i(o),this.C=new i(e),this.AB=this.createSideVector(this.A,this.B),this.AC=this.createSideVector(this.A,this.C),this.alpha=r(this.AB,this.AC),this.bisector=a(n(this.AB.eq(d)?this.AC:this.AB,this.alpha/2))}calcOrthogonalProjection(t,i){let s=arguments.length>2&&void 0!==arguments[2]?arguments[2]:this.strokeProjectionMagnitude;const o=this.createSideVector(t,i),e=c(o),r=j.getOrthogonalRotationFactor(e,this.bisector);return this.scaleUnitVector(e,s*r)}projectBevel(){const t=[];return(this.alpha%o===0?[this.B]:[this.B,this.C]).forEach(i=>{t.push(this.projectOrthogonally(this.A,i)),t.push(this.projectOrthogonally(this.A,i,-this.strokeProjectionMagnitude))}),t}projectMiter(){const t=[],i=Math.abs(this.alpha),s=1/Math.sin(i/2),o=this.scaleUnitVector(this.bisector,-this.strokeProjectionMagnitude*s),e=this.options.strokeUniform?l(this.scaleUnitVector(this.bisector,this.options.strokeMiterLimit)):this.options.strokeMiterLimit;return l(o)/this.strokeProjectionMagnitude<=e&&t.push(this.applySkew(this.A.add(o))),t.push(...this.projectBevel()),t}projectRoundNoSkew(t,s){const o=[],e=new i(j.getOrthogonalRotationFactor(this.bisector),j.getOrthogonalRotationFactor(new i(this.bisector.y,this.bisector.x)));return[new i(1,0).scalarMultiply(this.strokeProjectionMagnitude).multiply(this.strokeUniformScalar).multiply(e),new i(0,1).scalarMultiply(this.strokeProjectionMagnitude).multiply(this.strokeUniformScalar).multiply(e)].forEach(i=>{p(i,t,s)&&o.push(this.A.add(i))}),o}projectRoundWithSkew(t,s){const o=[],{skewX:r,skewY:h,scaleX:a,scaleY:n,strokeUniform:c}=this.options,l=new i(Math.tan(e(r)),Math.tan(e(h))),u=this.strokeProjectionMagnitude,m=c?u/n/Math.sqrt(1/n**2+1/a**2*l.y**2):u/Math.sqrt(1+l.y**2),d=new i(Math.sqrt(Math.max(u**2-m**2,0)),m),j=c?u/Math.sqrt(1+l.x**2*(1/n)**2/(1/a+1/a*l.x*l.y)**2):u/Math.sqrt(1+l.x**2/(1+l.x*l.y)**2),k=new i(j,Math.sqrt(Math.max(u**2-j**2,0)));return[k,k.scalarMultiply(-1),d,d.scalarMultiply(-1)].map(t=>this.applySkew(c?t.multiply(this.strokeUniformScalar):t)).forEach(i=>{p(i,t,s)&&o.push(this.applySkew(this.A).add(i))}),o}projectRound(){const t=[];t.push(...this.projectBevel());const i=this.alpha%o===0,s=this.applySkew(this.A),e=t[i?0:2].subtract(s),r=t[i?1:0].subtract(s),h=i?this.applySkew(this.AB.scalarMultiply(-1)):this.applySkew(this.bisector.multiply(this.strokeUniformScalar).scalarMultiply(-1)),a=u(e,h)>0,n=a?e:r,c=a?r:e;return this.isSkewed()?t.push(...this.projectRoundWithSkew(n,c)):t.push(...this.projectRoundNoSkew(n,c)),t}projectPoints(){switch(this.options.strokeLineJoin){case"miter":return this.projectMiter();case"round":return this.projectRound();default:return this.projectBevel()}}project(){return this.projectPoints().map(t=>({originPoint:this.A,projectedPoint:t,angle:this.alpha,bisector:this.bisector}))}}export{j as StrokeLineJoinProjections};
+//# sourceMappingURL=StrokeLineJoinProjections.min.mjs.map

package/dist/src/util/misc/projectStroke/StrokeLineJoinProjections.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrokeLineJoinProjections.min.mjs","sources":["../../../../../src/util/misc/projectStroke/StrokeLineJoinProjections.ts"],"sourcesContent":["import type { XY } from '../../../Point';\nimport { Point } from '../../../Point';\nimport { halfPI, twoMathPi } from '../../../constants';\nimport type { TRadian } from '../../../typedefs';\nimport { degreesToRadians } from '../radiansDegreesConversion';\nimport {\n  calcAngleBetweenVectors,\n  calcVectorRotation,\n  crossProduct,\n  getOrthonormalVector,\n  getUnitVector,\n  isBetweenVectors,\n  magnitude,\n  rotateVector,\n} from '../vectors';\nimport { StrokeProjectionsBase } from './StrokeProjectionsBase';\nimport type { TProjection, TProjectStrokeOnPointsOptions } from './types';\n\nconst zeroVector = new Point();\n\n/**\n * class in charge of finding projections for each type of line join\n * @see {@link [Closed path projections at #8344](https://github.com/fabricjs/fabric.js/pull/8344#2-closed-path)}\n *\n * - MDN:\n *   - https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/lineJoin\n *   - https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin\n * - Spec: https://svgwg.org/svg2-draft/painting.html#StrokeLinejoinProperty\n * - Playground to understand how the line joins works: https://hypertolosana.github.io/efficient-webgl-stroking/index.html\n * - 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\n *\n */\nexport class StrokeLineJoinProjections extends StrokeProjectionsBase {\n  /**\n   * The point being projected (the angle ∠BAC)\n   */\n  declare A: Point;\n  /**\n   * The point before A\n   */\n  declare B: Point;\n  /**\n   * The point after A\n   */\n  declare C: Point;\n  /**\n   * The AB vector\n   */\n  AB: Point;\n  /**\n   * The AC vector\n   */\n  AC: Point;\n  /**\n   * The angle of A (∠BAC)\n   */\n  alpha: TRadian;\n  /**\n   * The bisector of A (∠BAC)\n   */\n  bisector: Point;\n\n  static getOrthogonalRotationFactor(vector1: Point, vector2?: Point) {\n    const angle = vector2\n      ? calcAngleBetweenVectors(vector1, vector2)\n      : calcVectorRotation(vector1);\n    return Math.abs(angle) < halfPI ? -1 : 1;\n  }\n\n  constructor(A: XY, B: XY, C: XY, options: TProjectStrokeOnPointsOptions) {\n    super(options);\n    this.A = new Point(A);\n    this.B = new Point(B);\n    this.C = new Point(C);\n    this.AB = this.createSideVector(this.A, this.B);\n    this.AC = this.createSideVector(this.A, this.C);\n    this.alpha = calcAngleBetweenVectors(this.AB, this.AC);\n    this.bisector = getUnitVector(\n      // if AC is also the zero vector nothing will be projected\n      // in that case the next point will handle the projection\n      rotateVector(this.AB.eq(zeroVector) ? this.AC : this.AB, this.alpha / 2),\n    );\n  }\n\n  calcOrthogonalProjection(\n    from: Point,\n    to: Point,\n    magnitude: number = this.strokeProjectionMagnitude,\n  ) {\n    const vector = this.createSideVector(from, to);\n    const orthogonalProjection = getOrthonormalVector(vector);\n    const correctSide = StrokeLineJoinProjections.getOrthogonalRotationFactor(\n      orthogonalProjection,\n      this.bisector,\n    );\n    return this.scaleUnitVector(orthogonalProjection, magnitude * correctSide);\n  }\n\n  /**\n   * BEVEL\n   * Calculation: the projection points are formed by the vector orthogonal to the vertex.\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#2-2-bevel\n   */\n  projectBevel() {\n    const projections: Point[] = [];\n    // if `alpha` equals 0 or 2*PI, the projections are the same for `B` and `C`\n    (this.alpha % twoMathPi === 0 ? [this.B] : [this.B, this.C]).forEach(\n      (to) => {\n        projections.push(this.projectOrthogonally(this.A, to));\n        projections.push(\n          this.projectOrthogonally(this.A, to, -this.strokeProjectionMagnitude),\n        );\n      },\n    );\n    return projections;\n  }\n\n  /**\n   * MITER\n   * Calculation: the corner is formed by extending the outer edges of the stroke\n   * at the tangents of the path segments until they intersect.\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#2-1-miter\n   */\n  projectMiter() {\n    const projections: Point[] = [],\n      alpha = Math.abs(this.alpha),\n      hypotUnitScalar = 1 / Math.sin(alpha / 2),\n      miterVector = this.scaleUnitVector(\n        this.bisector,\n        -this.strokeProjectionMagnitude * hypotUnitScalar,\n      );\n\n    // When two line segments meet at a sharp angle, it is possible for the join to extend,\n    // far beyond the thickness of the line stroking the path. The stroke-miterlimit imposes\n    // a limit on the extent of the line join.\n    // MDN: https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit\n    // When the stroke is uniform, scaling changes the arrangement of points, this changes the miter-limit\n    const strokeMiterLimit = this.options.strokeUniform\n      ? magnitude(\n          this.scaleUnitVector(this.bisector, this.options.strokeMiterLimit),\n        )\n      : this.options.strokeMiterLimit;\n\n    if (\n      magnitude(miterVector) / this.strokeProjectionMagnitude <=\n      strokeMiterLimit\n    ) {\n      projections.push(this.applySkew(this.A.add(miterVector)));\n    }\n    /* when the miter-limit is reached, the stroke line join becomes of type bevel.\n      We always need two orthogonal projections which are basically bevel-type projections,\n      so regardless of whether the miter-limit was reached or not, we include these projections.\n    */\n    projections.push(...this.projectBevel());\n\n    return projections;\n  }\n\n  /**\n   * ROUND (without skew)\n   * Calculation: the projections are the two vectors parallel to X and Y axes\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#2-3-1-round-without-skew\n   */\n  private projectRoundNoSkew(startCircle: Point, endCircle: Point) {\n    const projections: Point[] = [],\n      // correctSide is used to only consider projecting for the outer side\n      correctSide = new Point(\n        StrokeLineJoinProjections.getOrthogonalRotationFactor(this.bisector),\n        StrokeLineJoinProjections.getOrthogonalRotationFactor(\n          new Point(this.bisector.y, this.bisector.x),\n        ),\n      ),\n      radiusOnAxisX = new Point(1, 0)\n        .scalarMultiply(this.strokeProjectionMagnitude)\n        .multiply(this.strokeUniformScalar)\n        .multiply(correctSide),\n      radiusOnAxisY = new Point(0, 1)\n        .scalarMultiply(this.strokeProjectionMagnitude)\n        .multiply(this.strokeUniformScalar)\n        .multiply(correctSide);\n\n    [radiusOnAxisX, radiusOnAxisY].forEach((vector) => {\n      if (isBetweenVectors(vector, startCircle, endCircle)) {\n        projections.push(this.A.add(vector));\n      }\n    });\n    return projections;\n  }\n\n  /**\n   * ROUND (with skew)\n   * Calculation: the projections are the points furthest from the vertex in\n   * the direction of the X and Y axes after distortion.\n   *\n   * @see https://github.com/fabricjs/fabric.js/pull/8344#2-3-2-round-skew\n   */\n  private projectRoundWithSkew(startCircle: Point, endCircle: Point) {\n    const projections: Point[] = [];\n\n    const { skewX, skewY, scaleX, scaleY, strokeUniform } = this.options,\n      shearing = new Point(\n        Math.tan(degreesToRadians(skewX)),\n        Math.tan(degreesToRadians(skewY)),\n      );\n    // The points furthest from the vertex in the direction of the X and Y axes after distortion\n    const circleRadius = this.strokeProjectionMagnitude,\n      newY = strokeUniform\n        ? circleRadius /\n          scaleY /\n          Math.sqrt(1 / scaleY ** 2 + (1 / scaleX ** 2) * shearing.y ** 2)\n        : circleRadius / Math.sqrt(1 + shearing.y ** 2),\n      furthestY = new Point(\n        // Safe guard due to floating point precision. In some situations the square root\n        // was returning NaN because of a negative number close to zero.\n        Math.sqrt(Math.max(circleRadius ** 2 - newY ** 2, 0)),\n        newY,\n      ),\n      newX = strokeUniform\n        ? circleRadius /\n          Math.sqrt(\n            1 +\n              (shearing.x ** 2 * (1 / scaleY) ** 2) /\n                (1 / scaleX + (1 / scaleX) * shearing.x * shearing.y) ** 2,\n          )\n        : circleRadius /\n          Math.sqrt(1 + shearing.x ** 2 / (1 + shearing.x * shearing.y) ** 2),\n      furthestX = new Point(\n        newX,\n        Math.sqrt(Math.max(circleRadius ** 2 - newX ** 2, 0)),\n      );\n\n    [\n      furthestX,\n      furthestX.scalarMultiply(-1),\n      furthestY,\n      furthestY.scalarMultiply(-1),\n    ]\n      // We need to skew the vector here as this information is used to check if\n      // it is between the start and end of the circle segment\n      .map((vector) =>\n        this.applySkew(\n          strokeUniform ? vector.multiply(this.strokeUniformScalar) : vector,\n        ),\n      )\n      .forEach((vector) => {\n        if (isBetweenVectors(vector, startCircle, endCircle)) {\n          projections.push(this.applySkew(this.A).add(vector));\n        }\n      });\n\n    return projections;\n  }\n\n  projectRound() {\n    const projections: Point[] = [];\n    /* Include the start and end points of the circle segment, so that only\n      the projections contained within it are included */\n    // add the orthogonal projections (start and end points of circle segment)\n    projections.push(...this.projectBevel());\n    // let's determines which one of the orthogonal projection is the beginning and end of the circle segment.\n    // when `alpha` equals 0 or 2*PI, we have a straight line, so the way to find the start/end is different.\n    const isStraightLine = this.alpha % twoMathPi === 0,\n      // change the origin of the projections to point A\n      // so that the cross product calculation is correct\n      newOrigin = this.applySkew(this.A),\n      proj0 = projections[isStraightLine ? 0 : 2].subtract(newOrigin),\n      proj1 = projections[isStraightLine ? 1 : 0].subtract(newOrigin),\n      // when `isStraightLine` === true, we compare with the vector opposite AB, otherwise we compare with the bisector.\n      comparisonVector = isStraightLine\n        ? this.applySkew(this.AB.scalarMultiply(-1))\n        : this.applySkew(\n            this.bisector.multiply(this.strokeUniformScalar).scalarMultiply(-1),\n          ),\n      // the beginning of the circle segment is always to the right of the comparison vector (cross product > 0)\n      isProj0Start = crossProduct(proj0, comparisonVector) > 0,\n      startCircle = isProj0Start ? proj0 : proj1,\n      endCircle = isProj0Start ? proj1 : proj0;\n    if (!this.isSkewed()) {\n      projections.push(...this.projectRoundNoSkew(startCircle, endCircle));\n    } else {\n      projections.push(...this.projectRoundWithSkew(startCircle, endCircle));\n    }\n    return projections;\n  }\n\n  /**\n   * Project stroke width on points returning projections for each point as follows:\n   * - `miter`: 1 point corresponding to the outer boundary. If the miter limit is exceeded, it will be 2 points (becomes bevel)\n   * - `bevel`: 2 points corresponding to the bevel possible boundaries, orthogonal to the stroke.\n   * - `round`: same as `bevel` when it has no skew, with skew are 4 points.\n   */\n  protected projectPoints() {\n    switch (this.options.strokeLineJoin) {\n      case 'miter':\n        return this.projectMiter();\n      case 'round':\n        return this.projectRound();\n      default:\n        return this.projectBevel();\n    }\n  }\n\n  public project(): TProjection[] {\n    return this.projectPoints().map((point) => ({\n      originPoint: this.A,\n      projectedPoint: point,\n      angle: this.alpha,\n      bisector: this.bisector,\n    }));\n  }\n}\n"],"names":["zeroVector","Point","StrokeLineJoinProjections","StrokeProjectionsBase","getOrthogonalRotationFactor","vector1","vector2","angle","calcAngleBetweenVectors","calcVectorRotation","Math","abs","halfPI","constructor","A","B","C","options","super","_defineProperty","this","AB","createSideVector","AC","alpha","bisector","getUnitVector","rotateVector","eq","calcOrthogonalProjection","from","to","magnitude","arguments","length","undefined","strokeProjectionMagnitude","vector","orthogonalProjection","getOrthonormalVector","correctSide","scaleUnitVector","projectBevel","projections","twoMathPi","forEach","push","projectOrthogonally","projectMiter","hypotUnitScalar","sin","miterVector","strokeMiterLimit","strokeUniform","applySkew","add","projectRoundNoSkew","startCircle","endCircle","y","x","scalarMultiply","multiply","strokeUniformScalar","isBetweenVectors","projectRoundWithSkew","skewX","skewY","scaleX","scaleY","shearing","tan","degreesToRadians","circleRadius","newY","sqrt","furthestY","max","newX","furthestX","map","projectRound","isStraightLine","newOrigin","proj0","subtract","proj1","comparisonVector","isProj0Start","crossProduct","isSkewed","projectPoints","strokeLineJoin","project","point","originPoint","projectedPoint"],"mappings":"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"}