@plait/graph-viz 0.62.0-next.7

package/esm2022/perfect-arrows/get-arrow.mjs

@@ -0,0 +1,91 @@
+// Credits to perfect-arrows
+// https://github.com/steveruizok/perfect-arrows/blob/master/src/lib/getArrow.ts
+import { getAngle, getDistance, getAngliness, projectPoint, getPointBetween, getSector, rotatePoint, modulate } from './utils';
+/**
+   * getArrow
+   * Get the points for a linking line between two points.
+   * @description Draw an arrow between two points.
+   * @param x0 The x position of the "from" point.
+   * @param y0 The y position of the "from" point.
+   * @param x1 The x position of the "to" point.
+   * @param y1 The y position of the "to" point.
+   * @param options Additional options for computing the line.
+   * @returns [sx, sy, cx, cy, e1, e2, ae, as, ac]
+   * @example
+   * const arrow = getArrow(0, 0, 100, 200, {
+      bow: 0
+      stretch: .5
+      stretchMin: 0
+      stretchMax: 420
+      padStart: 0
+      padEnd: 0
+      flip: false
+      straights: true
+   * })
+   *
+   * const [
+   *  startX, startY,
+   *  controlX, controlY,
+   *  endX, endY,
+   *  endAngle,
+   *  startAngle,
+   *  controlAngle
+   *  ] = arrow
+   */
+export default function getArrow(x0, y0, x1, y1, options = {}) {
+    const { bow = 0, stretch = 0.5, stretchMin = 0, stretchMax = 420, padStart = 0, padEnd = 0, flip = false, straights = true } = options;
+    const angle = getAngle(x0, y0, x1, y1);
+    const dist = getDistance(x0, y0, x1, y1);
+    const angliness = getAngliness(x0, y0, x1, y1);
+    // Step 0 ⤜⤏ Should the arrow be straight?
+    if (dist < (padStart + padEnd) * 2 || // Too short
+        (bow === 0 && stretch === 0) || // No bow, no stretch
+        (straights && [0, 1, Infinity].includes(angliness)) // 45 degree angle
+    ) {
+        // ⤜⤏ Arrow is straight! Just pad start and end points.
+        // Padding distances
+        const ps = Math.max(0, Math.min(dist - padStart, padStart));
+        const pe = Math.max(0, Math.min(dist - ps, padEnd));
+        // Move start point toward end point
+        let [px0, py0] = projectPoint(x0, y0, angle, ps);
+        // Move end point toward start point
+        let [px1, py1] = projectPoint(x1, y1, angle + Math.PI, pe);
+        // Get midpoint between new points
+        const [mx, my] = getPointBetween(px0, py0, px1, py1, 0.5);
+        return [px0, py0, mx, my, px1, py1, angle, angle, angle];
+    }
+    // ⤜⤏ Arrow is an arc!
+    // Is the arc clockwise or counterclockwise?
+    let rot = (getSector(angle) % 2 === 0 ? 1 : -1) * (flip ? -1 : 1);
+    // Calculate how much the line should "bow" away from center
+    const arc = bow + modulate(dist, [stretchMin, stretchMax], [1, 0], true) * stretch;
+    // Step 1 ⤜⤏ Find padded points.
+    // Get midpoint.
+    const [mx, my] = getPointBetween(x0, y0, x1, y1, 0.5);
+    // Get control point.
+    let [cx, cy] = getPointBetween(x0, y0, x1, y1, 0.5 - arc);
+    // Rotate control point (clockwise or counterclockwise).
+    [cx, cy] = rotatePoint(cx, cy, mx, my, (Math.PI / 2) * rot);
+    // Get padded start point.
+    const a0 = getAngle(x0, y0, cx, cy);
+    const [px0, py0] = projectPoint(x0, y0, a0, padStart);
+    // Get padded end point.
+    const a1 = getAngle(x1, y1, cx, cy);
+    const [px1, py1] = projectPoint(x1, y1, a1, padEnd);
+    // Step 2  ⤜⤏ Find start and end angles.
+    // Start angle
+    const as = getAngle(cx, cy, x0, y0);
+    // End angle
+    const ae = getAngle(cx, cy, x1, y1);
+    // Step 3 ⤜⤏ Find control point for padded points.
+    // Get midpoint between padded start / end points.
+    const [mx1, my1] = getPointBetween(px0, py0, px1, py1, 0.5);
+    // Get control point for padded start / end points.
+    let [cx1, cy1] = getPointBetween(px0, py0, px1, py1, 0.5 - arc);
+    // Rotate control point (clockwise or counterclockwise).
+    [cx1, cy1] = rotatePoint(cx1, cy1, mx1, my1, (Math.PI / 2) * rot);
+    // Finally, average the two control points.
+    let [cx2, cy2] = getPointBetween(cx, cy, cx1, cy1, 0.5);
+    return [px0, py0, cx2, cy2, px1, py1, ae, as, angle];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"get-arrow.js","sourceRoot":"","sources":["../../../../packages/graph-viz/src/perfect-arrows/get-arrow.ts"],"names":[],"mappings":"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","sourcesContent":["// Credits to perfect-arrows\n// https://github.com/steveruizok/perfect-arrows/blob/master/src/lib/getArrow.ts\n\nimport { getAngle, getDistance, getAngliness, projectPoint, getPointBetween, getSector, rotatePoint, modulate } from './utils';\n\nexport type ArrowOptions = {\n    bow?: number;\n    stretchMin?: number;\n    stretchMax?: number;\n    stretch?: number;\n    padStart?: number;\n    padEnd?: number;\n    flip?: boolean;\n    straights?: boolean;\n};\n\n/**\n   * getArrow\n   * Get the points for a linking line between two points.\n   * @description Draw an arrow between two points.\n   * @param x0 The x position of the \"from\" point.\n   * @param y0 The y position of the \"from\" point.\n   * @param x1 The x position of the \"to\" point.\n   * @param y1 The y position of the \"to\" point.\n   * @param options Additional options for computing the line.\n   * @returns [sx, sy, cx, cy, e1, e2, ae, as, ac]\n   * @example\n   * const arrow = getArrow(0, 0, 100, 200, {\n      bow: 0\n      stretch: .5\n      stretchMin: 0\n      stretchMax: 420\n      padStart: 0\n      padEnd: 0\n      flip: false\n      straights: true\n   * })\n   * \n   * const [\n   *  startX, startY, \n   *  controlX, controlY, \n   *  endX, endY, \n   *  endAngle, \n   *  startAngle,\n   *  controlAngle\n   *  ] = arrow\n   */\nexport default function getArrow(x0: number, y0: number, x1: number, y1: number, options: ArrowOptions = {} as ArrowOptions): number[] {\n    const { bow = 0, stretch = 0.5, stretchMin = 0, stretchMax = 420, padStart = 0, padEnd = 0, flip = false, straights = true } = options;\n\n    const angle = getAngle(x0, y0, x1, y1);\n    const dist = getDistance(x0, y0, x1, y1);\n    const angliness = getAngliness(x0, y0, x1, y1);\n\n    // Step 0 ⤜⤏ Should the arrow be straight?\n\n    if (\n        dist < (padStart + padEnd) * 2 || // Too short\n        (bow === 0 && stretch === 0) || // No bow, no stretch\n        (straights && [0, 1, Infinity].includes(angliness)) // 45 degree angle\n    ) {\n        // ⤜⤏ Arrow is straight! Just pad start and end points.\n\n        // Padding distances\n        const ps = Math.max(0, Math.min(dist - padStart, padStart));\n        const pe = Math.max(0, Math.min(dist - ps, padEnd));\n\n        // Move start point toward end point\n        let [px0, py0] = projectPoint(x0, y0, angle, ps);\n\n        // Move end point toward start point\n        let [px1, py1] = projectPoint(x1, y1, angle + Math.PI, pe);\n\n        // Get midpoint between new points\n        const [mx, my] = getPointBetween(px0, py0, px1, py1, 0.5);\n\n        return [px0, py0, mx, my, px1, py1, angle, angle, angle];\n    }\n\n    // ⤜⤏ Arrow is an arc!\n\n    // Is the arc clockwise or counterclockwise?\n    let rot = (getSector(angle) % 2 === 0 ? 1 : -1) * (flip ? -1 : 1);\n\n    // Calculate how much the line should \"bow\" away from center\n    const arc = bow + modulate(dist, [stretchMin, stretchMax], [1, 0], true) * stretch;\n\n    // Step 1 ⤜⤏ Find padded points.\n\n    // Get midpoint.\n    const [mx, my] = getPointBetween(x0, y0, x1, y1, 0.5);\n\n    // Get control point.\n    let [cx, cy] = getPointBetween(x0, y0, x1, y1, 0.5 - arc);\n\n    // Rotate control point (clockwise or counterclockwise).\n    [cx, cy] = rotatePoint(cx, cy, mx, my, (Math.PI / 2) * rot);\n\n    // Get padded start point.\n    const a0 = getAngle(x0, y0, cx, cy);\n    const [px0, py0] = projectPoint(x0, y0, a0, padStart);\n\n    // Get padded end point.\n    const a1 = getAngle(x1, y1, cx, cy);\n    const [px1, py1] = projectPoint(x1, y1, a1, padEnd);\n\n    // Step 2  ⤜⤏ Find start and end angles.\n\n    // Start angle\n    const as = getAngle(cx, cy, x0, y0);\n\n    // End angle\n    const ae = getAngle(cx, cy, x1, y1);\n\n    // Step 3 ⤜⤏ Find control point for padded points.\n\n    // Get midpoint between padded start / end points.\n    const [mx1, my1] = getPointBetween(px0, py0, px1, py1, 0.5);\n\n    // Get control point for padded start / end points.\n    let [cx1, cy1] = getPointBetween(px0, py0, px1, py1, 0.5 - arc);\n\n    // Rotate control point (clockwise or counterclockwise).\n    [cx1, cy1] = rotatePoint(cx1, cy1, mx1, my1, (Math.PI / 2) * rot);\n\n    // Finally, average the two control points.\n    let [cx2, cy2] = getPointBetween(cx, cy, cx1, cy1, 0.5);\n\n    return [px0, py0, cx2, cy2, px1, py1, ae, as, angle];\n}\n"]}

package/esm2022/perfect-arrows/utils.mjs

@@ -0,0 +1,111 @@
+// Credits to perfect-arrows
+// https://github.com/steveruizok/perfect-arrows/blob/master/src/lib/utils.ts
+const PI = Math.PI;
+/**
+ * Modulate a value between two ranges.
+ * @param value
+ * @param rangeA from [low, high]
+ * @param rangeB to [low, high]
+ * @param clamp
+ */
+export function modulate(value, rangeA, rangeB, clamp = false) {
+    const [fromLow, fromHigh] = rangeA;
+    const [toLow, toHigh] = rangeB;
+    const result = toLow + ((value - fromLow) / (fromHigh - fromLow)) * (toHigh - toLow);
+    if (clamp === true) {
+        if (toLow < toHigh) {
+            if (result < toLow) {
+                return toLow;
+            }
+            if (result > toHigh) {
+                return toHigh;
+            }
+        }
+        else {
+            if (result > toLow) {
+                return toLow;
+            }
+            if (result < toHigh) {
+                return toHigh;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Rotate a point around a center.
+ * @param x The x-axis coordinate of the point.
+ * @param y The y-axis coordinate of the point.
+ * @param cx The x-axis coordinate of the point to rotate round.
+ * @param cy The y-axis coordinate of the point to rotate round.
+ * @param angle The distance (in radians) to rotate.
+ */
+export function rotatePoint(x, y, cx, cy, angle) {
+    const s = Math.sin(angle);
+    const c = Math.cos(angle);
+    const px = x - cx;
+    const py = y - cy;
+    const nx = px * c - py * s;
+    const ny = px * s + py * c;
+    return [nx + cx, ny + cy];
+}
+/**
+ * Get the distance between two points.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ */
+export function getDistance(x0, y0, x1, y1) {
+    return Math.hypot(y1 - y0, x1 - x0);
+}
+/**
+ * Get an angle (radians) between two points.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ */
+export function getAngle(x0, y0, x1, y1) {
+    return Math.atan2(y1 - y0, x1 - x0);
+}
+/**
+ * Move a point in an angle by a distance.
+ * @param x0
+ * @param y0
+ * @param a angle (radians)
+ * @param d distance
+ */
+export function projectPoint(x0, y0, a, d) {
+    return [Math.cos(a) * d + x0, Math.sin(a) * d + y0];
+}
+/**
+ * Get a point between two points.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ * @param d Normalized
+ */
+export function getPointBetween(x0, y0, x1, y1, d = 0.5) {
+    return [x0 + (x1 - x0) * d, y0 + (y1 - y0) * d];
+}
+/**
+ * Get the sector of an angle (e.g. quadrant, octant)
+ * @param a The angle to check.
+ * @param s The number of sectors to check.
+ */
+export function getSector(a, s = 8) {
+    return Math.floor(s * (0.5 + ((a / (PI * 2)) % s)));
+}
+/**
+ * Get a normal value representing how close two points are from being at a 45 degree angle.
+ * @param x0 The x-axis coordinate of the first point.
+ * @param y0 The y-axis coordinate of the first point.
+ * @param x1 The x-axis coordinate of the second point.
+ * @param y1 The y-axis coordinate of the second point.
+ */
+export function getAngliness(x0, y0, x1, y1) {
+    return Math.abs((x1 - x0) / 2 / ((y1 - y0) / 2));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../packages/graph-viz/src/perfect-arrows/utils.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,6EAA6E;AAE7E,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;AAEnB;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,KAAa,EAAE,MAAgB,EAAE,MAAgB,EAAE,KAAK,GAAG,KAAK;IACrF,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,MAAM,CAAC;IACnC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC;IAC/B,MAAM,MAAM,GAAG,KAAK,GAAG,CAAC,CAAC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;IACrF,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACjB,IAAI,KAAK,GAAG,MAAM,EAAE,CAAC;YACjB,IAAI,MAAM,GAAG,KAAK,EAAE,CAAC;gBACjB,OAAO,KAAK,CAAC;YACjB,CAAC;YACD,IAAI,MAAM,GAAG,MAAM,EAAE,CAAC;gBAClB,OAAO,MAAM,CAAC;YAClB,CAAC;QACL,CAAC;aAAM,CAAC;YACJ,IAAI,MAAM,GAAG,KAAK,EAAE,CAAC;gBACjB,OAAO,KAAK,CAAC;YACjB,CAAC;YACD,IAAI,MAAM,GAAG,MAAM,EAAE,CAAC;gBAClB,OAAO,MAAM,CAAC;YAClB,CAAC;QACL,CAAC;IACL,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,CAAS,EAAE,CAAS,EAAE,EAAU,EAAE,EAAU,EAAE,KAAa;IACnF,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC1B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAE1B,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;IAElB,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC3B,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAE3B,OAAO,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;IACtE,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;IACnE,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,EAAU,EAAE,EAAU,EAAE,CAAS,EAAE,CAAS;IACrE,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,CAAC,GAAG,GAAG;IACnF,OAAO,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;AACpD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,CAAS,EAAE,CAAC,GAAG,CAAC;IACtC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;IACvE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACrD,CAAC","sourcesContent":["// Credits to perfect-arrows\n// https://github.com/steveruizok/perfect-arrows/blob/master/src/lib/utils.ts\n\nconst PI = Math.PI;\n\n/**\n * Modulate a value between two ranges.\n * @param value\n * @param rangeA from [low, high]\n * @param rangeB to [low, high]\n * @param clamp\n */\nexport function modulate(value: number, rangeA: number[], rangeB: number[], clamp = false) {\n    const [fromLow, fromHigh] = rangeA;\n    const [toLow, toHigh] = rangeB;\n    const result = toLow + ((value - fromLow) / (fromHigh - fromLow)) * (toHigh - toLow);\n    if (clamp === true) {\n        if (toLow < toHigh) {\n            if (result < toLow) {\n                return toLow;\n            }\n            if (result > toHigh) {\n                return toHigh;\n            }\n        } else {\n            if (result > toLow) {\n                return toLow;\n            }\n            if (result < toHigh) {\n                return toHigh;\n            }\n        }\n    }\n    return result;\n}\n\n/**\n * Rotate a point around a center.\n * @param x The x-axis coordinate of the point.\n * @param y The y-axis coordinate of the point.\n * @param cx The x-axis coordinate of the point to rotate round.\n * @param cy The y-axis coordinate of the point to rotate round.\n * @param angle The distance (in radians) to rotate.\n */\nexport function rotatePoint(x: number, y: number, cx: number, cy: number, angle: number) {\n    const s = Math.sin(angle);\n    const c = Math.cos(angle);\n\n    const px = x - cx;\n    const py = y - cy;\n\n    const nx = px * c - py * s;\n    const ny = px * s + py * c;\n\n    return [nx + cx, ny + cy];\n}\n\n/**\n * Get the distance between two points.\n * @param x0 The x-axis coordinate of the first point.\n * @param y0 The y-axis coordinate of the first point.\n * @param x1 The x-axis coordinate of the second point.\n * @param y1 The y-axis coordinate of the second point.\n */\nexport function getDistance(x0: number, y0: number, x1: number, y1: number) {\n    return Math.hypot(y1 - y0, x1 - x0);\n}\n\n/**\n * Get an angle (radians) between two points.\n * @param x0 The x-axis coordinate of the first point.\n * @param y0 The y-axis coordinate of the first point.\n * @param x1 The x-axis coordinate of the second point.\n * @param y1 The y-axis coordinate of the second point.\n */\nexport function getAngle(x0: number, y0: number, x1: number, y1: number) {\n    return Math.atan2(y1 - y0, x1 - x0);\n}\n\n/**\n * Move a point in an angle by a distance.\n * @param x0\n * @param y0\n * @param a angle (radians)\n * @param d distance\n */\nexport function projectPoint(x0: number, y0: number, a: number, d: number) {\n    return [Math.cos(a) * d + x0, Math.sin(a) * d + y0];\n}\n\n/**\n * Get a point between two points.\n * @param x0 The x-axis coordinate of the first point.\n * @param y0 The y-axis coordinate of the first point.\n * @param x1 The x-axis coordinate of the second point.\n * @param y1 The y-axis coordinate of the second point.\n * @param d Normalized\n */\nexport function getPointBetween(x0: number, y0: number, x1: number, y1: number, d = 0.5) {\n    return [x0 + (x1 - x0) * d, y0 + (y1 - y0) * d];\n}\n\n/**\n * Get the sector of an angle (e.g. quadrant, octant)\n * @param a The angle to check.\n * @param s The number of sectors to check.\n */\nexport function getSector(a: number, s = 8) {\n    return Math.floor(s * (0.5 + ((a / (PI * 2)) % s)));\n}\n\n/**\n * Get a normal value representing how close two points are from being at a 45 degree angle.\n * @param x0 The x-axis coordinate of the first point.\n * @param y0 The y-axis coordinate of the first point.\n * @param x1 The x-axis coordinate of the second point.\n * @param y1 The y-axis coordinate of the second point.\n */\nexport function getAngliness(x0: number, y0: number, x1: number, y1: number) {\n    return Math.abs((x1 - x0) / 2 / ((y1 - y0) / 2));\n}\n"]}

package/esm2022/plait-graph-viz.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhaXQtZ3JhcGgtdml6LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGFja2FnZXMvZ3JhcGgtdml6L3NyYy9wbGFpdC1ncmFwaC12aXoudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API Surface of utils
+ */
+export * from './force-atlas/constants';
+export * from './force-atlas/types';
+export * from './force-atlas/with-force-atlas';
+export * from './interfaces/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3BhY2thZ2VzL2dyYXBoLXZpei9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHV0aWxzXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9mb3JjZS1hdGxhcy9jb25zdGFudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JjZS1hdGxhcy90eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZvcmNlLWF0bGFzL3dpdGgtZm9yY2UtYXRsYXMnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmZhY2VzL2luZGV4JztcbiJdfQ==