@react-fabric/graph 1.0.0-beta.63 → 1.0.1

package/dist/esm/programs/node-rect/base/index.js

@@ -1,135 +0,0 @@
-'use client';
-
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
-import _inherits from '@babel/runtime/helpers/inherits';
-import { NodeProgram } from 'sigma/rendering';
-import { floatColor } from 'sigma/utils';
-import SHADER_SOURCE$1 from './frag.glsl.js';
-import SHADER_SOURCE from './vert.glsl.js';
-
-function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-
-/* istanbul ignore file */
-
-var _WebGLRenderingContex = WebGLRenderingContext,
-  UNSIGNED_BYTE = _WebGLRenderingContex.UNSIGNED_BYTE,
-  FLOAT = _WebGLRenderingContex.FLOAT;
-var UNIFORMS = ["u_sizeRatio", "u_correctionRatio", "u_cameraAngle", "u_matrix"];
-var PI = Math.PI;
-var NodeRectBase = /*#__PURE__*/function (_NodeProgram) {
-  function NodeRectBase() {
-    _classCallCheck(this, NodeRectBase);
-    return _callSuper(this, NodeRectBase, arguments);
-  }
-  _inherits(NodeRectBase, _NodeProgram);
-  return _createClass(NodeRectBase, [{
-    key: "getDefinition",
-    value: function getDefinition() {
-      return {
-        VERTICES: 6,
-        VERTEX_SHADER_SOURCE: SHADER_SOURCE,
-        FRAGMENT_SHADER_SOURCE: SHADER_SOURCE$1,
-        METHOD: WebGLRenderingContext.TRIANGLES,
-        UNIFORMS: UNIFORMS,
-        ATTRIBUTES: [{
-          name: "a_position",
-          size: 2,
-          type: FLOAT
-        }, {
-          name: "a_size",
-          size: 1,
-          type: FLOAT
-        }, {
-          name: "a_border",
-          size: 1,
-          type: FLOAT
-        }, {
-          name: "a_opacity",
-          size: 1,
-          type: FLOAT
-        }, {
-          name: "a_base",
-          size: 4,
-          type: UNSIGNED_BYTE,
-          normalized: true
-        }, {
-          name: "a_color",
-          size: 4,
-          type: UNSIGNED_BYTE,
-          normalized: true
-        }, {
-          name: "a_stroke",
-          size: 4,
-          type: UNSIGNED_BYTE,
-          normalized: true
-        }, {
-          name: "a_segments",
-          size: 1,
-          type: FLOAT
-        }].concat(_toConsumableArray(Array(7).fill(0).map(function (_, idx) {
-          return {
-            name: "a_colors_" + idx,
-            size: 4,
-            type: UNSIGNED_BYTE,
-            normalized: true
-          };
-        })), [{
-          name: "a_id",
-          size: 4,
-          type: UNSIGNED_BYTE,
-          normalized: true
-        }]),
-        CONSTANT_ATTRIBUTES: [{
-          name: "a_angle",
-          size: 1,
-          type: FLOAT
-        }],
-        CONSTANT_DATA: [[PI / 4], [3 * PI / 4], [-PI / 4], [3 * PI / 4], [-PI / 4], [-3 * PI / 4]]
-      };
-    }
-  }, {
-    key: "processVisibleItem",
-    value: function processVisibleItem(nodeIndex, startIndex, data) {
-      var _data$color, _data$borderColor, _data$border, _data$opacity, _data$pie$length, _data$pie;
-      var array = this.array;
-      var base = floatColor(this.renderer.getSetting("defaultNodeColor"));
-      var color = floatColor((_data$color = data.color) !== null && _data$color !== void 0 ? _data$color : this.renderer.getSetting("defaultNodeColor"));
-      var stroke = floatColor((_data$borderColor = data.borderColor) !== null && _data$borderColor !== void 0 ? _data$borderColor : this.renderer.getSetting("defaultEdgeColor"));
-      array[startIndex++] = data.x;
-      array[startIndex++] = data.y;
-      array[startIndex++] = data.size;
-      array[startIndex++] = Math.min((_data$border = data.border) !== null && _data$border !== void 0 ? _data$border : 0, 4);
-      array[startIndex++] = (_data$opacity = data.opacity) !== null && _data$opacity !== void 0 ? _data$opacity : 1;
-      array[startIndex++] = base;
-      array[startIndex++] = color;
-      array[startIndex++] = stroke;
-      array[startIndex++] = Math.min(7, (_data$pie$length = (_data$pie = data.pie) === null || _data$pie === void 0 ? void 0 : _data$pie.length) !== null && _data$pie$length !== void 0 ? _data$pie$length : 0);
-      Array(7).fill(0).forEach(function (_, idx) {
-        var _data$pie$idx, _data$pie2;
-        array[startIndex++] = floatColor((_data$pie$idx = (_data$pie2 = data.pie) === null || _data$pie2 === void 0 ? void 0 : _data$pie2[idx]) !== null && _data$pie$idx !== void 0 ? _data$pie$idx : "#0000");
-      });
-      array[startIndex++] = nodeIndex;
-    }
-  }, {
-    key: "setUniforms",
-    value: function setUniforms(params, _ref) {
-      var gl = _ref.gl,
-        uniformLocations = _ref.uniformLocations;
-      var u_sizeRatio = uniformLocations.u_sizeRatio,
-        u_correctionRatio = uniformLocations.u_correctionRatio,
-        u_cameraAngle = uniformLocations.u_cameraAngle,
-        u_matrix = uniformLocations.u_matrix;
-      gl.uniform1f(u_sizeRatio, params.sizeRatio);
-      gl.uniform1f(u_cameraAngle, params.cameraAngle);
-      gl.uniform1f(u_correctionRatio, params.correctionRatio);
-      gl.uniformMatrix3fv(u_matrix, false, params.matrix);
-    }
-  }]);
-}(NodeProgram);
-
-export { NodeRectBase };

package/dist/esm/programs/node-rect/base/vert.glsl.js

@@ -1,8 +0,0 @@
-'use client';
-
-/* istanbul ignore file */
-
-// language=GLSL
-var SHADER_SOURCE = /* glsl */"\nattribute vec4 a_id;\nattribute vec4 a_base;\nattribute vec4 a_color;\nattribute vec4 a_stroke;\nattribute vec2 a_position;\nattribute float a_size;\nattribute float a_border;\nattribute float a_angle;\nattribute float a_opacity;\nattribute float a_segments;\nattribute vec4 a_colors_0;\nattribute vec4 a_colors_1;\nattribute vec4 a_colors_2;\nattribute vec4 a_colors_3;\nattribute vec4 a_colors_4;\nattribute vec4 a_colors_5;\nattribute vec4 a_colors_6;\n\nuniform mat3 u_matrix;\nuniform float u_sizeRatio;\nuniform float u_cameraAngle;\nuniform float u_correctionRatio;\n\nvarying vec4 v_color;\nvarying vec4 v_stroke;\nvarying float v_border;\nvarying vec2 v_diffVector;\nvarying float v_segmentAngle;\nvarying vec4 v_colors_0;\nvarying vec4 v_colors_1;\nvarying vec4 v_colors_2;\nvarying vec4 v_colors_3;\nvarying vec4 v_colors_4;\nvarying vec4 v_colors_5;\nvarying vec4 v_colors_6;\n\nconst float bias = 255.0 / 254.0;\nconst float sqrt_8 = sqrt(8.0);\n\nvoid main() {\n  float angle = a_angle + u_cameraAngle; \n\n  float size = a_size * u_correctionRatio / u_sizeRatio * sqrt_8;\n  vec2 diffVector = size * vec2(cos(angle), sin(angle));\n  vec2 position = a_position + diffVector;\n\n  float borderLessSize = (a_size - a_border) * u_correctionRatio / u_sizeRatio * sqrt_8;\n\n  gl_Position = vec4(\n    (u_matrix * vec3(position, 1)).xy,\n    0,\n    1\n  );\n\n  v_diffVector = diffVector;\n  v_border = a_border * u_correctionRatio / u_sizeRatio * sqrt_8;\n  v_border = borderLessSize / ".concat(Math.PI / 2.2, ";\n\n  #ifdef PICKING_MODE\n    v_color = a_id;\n  #else\n    v_color = mix(a_base, a_color, a_opacity * bias);\n    v_stroke = mix(a_base, a_stroke, a_opacity * bias);\n\n    // pie colors\n    v_segmentAngle = 0.0;\n    if(a_segments > 0.0) {\n      v_segmentAngle = ").concat(Math.PI * 2, " / a_segments;\n      v_colors_0 = mix(a_base, a_colors_0, a_opacity * bias);\n      v_colors_1 = mix(a_base, a_colors_1, a_opacity * bias);\n      v_colors_2 = mix(a_base, a_colors_2, a_opacity * bias);\n      v_colors_3 = mix(a_base, a_colors_3, a_opacity * bias);\n      v_colors_4 = mix(a_base, a_colors_4, a_opacity * bias);\n      v_colors_5 = mix(a_base, a_colors_5, a_opacity * bias);\n      v_colors_6 = mix(a_base, a_colors_6, a_opacity * bias);\n    }\n  #endif\n\n  v_color.a *= bias;\n}\n");
-
-export { SHADER_SOURCE as default };

package/dist/esm/programs/node-rect/index.js

@@ -1,15 +0,0 @@
-'use client';
-
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import { createNodeCompoundProgram } from 'sigma/rendering';
-import { NodeBadgeProgram } from '../node-badge/index.js';
-import { NodeImageProgram } from '../node-image/index.js';
-import { NodeRectBase } from './base/index.js';
-import { drawNodeHover } from './base/drawHover.js';
-import { drawNodeLabel } from './base/drawLabel.js';
-
-/* istanbul ignore file */
-
-var NodeRectProgram = createNodeCompoundProgram([NodeRectBase, NodeImageProgram(false)].concat(_toConsumableArray(NodeBadgeProgram(false))), drawNodeLabel, drawNodeHover);
-
-export { NodeRectProgram };

package/dist/types/components/ContextMenu.d.ts

@@ -1 +0,0 @@
-export declare const GraphContextMenu: () => false | import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Provider.d.ts

@@ -1,3 +0,0 @@
-import { type PropsWithChildren } from "react";
-import { type GraphProps } from "../types";
-export declare const GraphProvider: <N = KeyValue, E = KeyValue>({ ref, data, children, nodeReducer, edgeReducer, onSelectChange, onNodeDoubleClick, onContextMenu, }: PropsWithChildren<GraphProps<N, E>>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Tools.d.ts

@@ -1 +0,0 @@
-export declare const Tools: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Viewer.d.ts

@@ -1,2 +0,0 @@
-import { type GraphProps } from "../types";
-export declare const SigmaGraph: <N = KeyValue, E = KeyValue>(props: GraphProps<N, E>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/context.d.ts

@@ -1,17 +0,0 @@
-import { Graph } from "../graph";
-import { useDragSelection } from "../hooks/sigmaDragSelect";
-import { useSigma } from "../hooks/useSigma";
-import { EdgeAttributes, NodeAttributes } from "../types";
-interface Context<N = KeyValue, E = KeyValue> {
-    sigma: ReturnType<typeof useSigma>;
-    graph: Graph<NodeAttributes<N>, EdgeAttributes<E>>;
-    selected: string[];
-    layoutRunning: boolean;
-    dragSelector: ReturnType<typeof useDragSelection>;
-    resetViewport: () => void;
-    zoomIn: () => void;
-    zoomOut: () => void;
-}
-export declare const GraphContext: import("react").Context<Context<KeyValue<any>, KeyValue<any>>>;
-export declare const useGraph: <N = KeyValue, E = KeyValue>() => Context<N, E>;
-export {};

package/dist/types/constants/index.d.ts

@@ -1,12 +0,0 @@
-export declare const ICONS: {
-    focus: string;
-    zoomIn: string;
-    zoomOut: string;
-    lasso: string;
-    select: string;
-    cancel: string;
-    delete: string;
-    clear: string;
-    expand: string;
-    collapse: string;
-};

package/dist/types/graph/layout.worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/hooks/sigmaDragSelect.d.ts

@@ -1,8 +0,0 @@
-import type Sigma from "sigma";
-import { type EdgeAttributes, type NodeAttributes } from "../types";
-export declare const useDragSelection: (renderer?: Sigma<NodeAttributes<any>, EdgeAttributes<any>>) => {
-    selectionMode: false | "rectangle" | "lasso";
-    startRectangleSelection: () => void;
-    startLassoSelection: () => void;
-    cancelSelection: () => void;
-};

package/dist/types/hooks/sigmaHilighter.d.ts

@@ -1,3 +0,0 @@
-import type Sigma from "sigma";
-import { type EdgeAttributes, type NodeAttributes } from "../types";
-export declare const attachHighlighter: (renderer: Sigma<NodeAttributes<any>, EdgeAttributes<any>>) => void;

package/dist/types/hooks/sigmaMouseActions.d.ts

@@ -1,3 +0,0 @@
-import type Sigma from "sigma";
-import { type EdgeAttributes, type NodeAttributes } from "../types";
-export declare const attachMouseActions: (renderer: Sigma<NodeAttributes<any>, EdgeAttributes<any>>) => void;

package/dist/types/hooks/useGraphology.d.ts

@@ -1,6 +0,0 @@
-import { Graph } from "../graph";
-import { type GraphProps } from "../types";
-export declare const useGraphology: <N, E>(data: GraphProps<N, E>["data"]) => {
-    graph: Graph<N, E>;
-    selected: string[];
-};

package/dist/types/hooks/useSigma.d.ts

@@ -1,8 +0,0 @@
-import Sigma from "sigma";
-import { type Graph } from "../graph";
-import { type EdgeAttributes, type NodeAttributes } from "../types";
-export declare const useSigma: <N, E>(graph: Graph<N, E>, nodeReducer?: (node: NodeAttributes<N>) => NodeAttributes<N>, edgeReducer?: (edge: EdgeAttributes<E>) => EdgeAttributes<E>) => {
-    instance: Sigma<NodeAttributes<N>, EdgeAttributes<E>, import("graphology-types").Attributes> | undefined;
-    containerRef: import("react").Dispatch<import("react").SetStateAction<HTMLDivElement | null>>;
-    componentsRef: import("react").Dispatch<import("react").SetStateAction<HTMLDivElement | null>>;
-};

package/dist/types/programs/arrow-head/frag.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER_SOURCE = "\nprecision mediump float;\n\nvarying vec4 v_color;\nvarying float v_opacity;\n\nconst vec4 transparent = vec4(0.0, 0.0, 0.0, 0.0);\n\nvoid main(void) {\n  gl_FragColor = v_color;\n  gl_FragColor = mix(transparent, gl_FragColor, v_opacity);\n}\n";
-export default SHADER_SOURCE;

package/dist/types/programs/arrow-head/index.d.ts

@@ -1,9 +0,0 @@
-import { type Attributes } from "graphology-types";
-import { type EdgeProgramType } from "sigma/rendering";
-export interface CreateEdgeArrowHeadProgramOptions {
-    extremity: "source" | "target";
-    lengthToThicknessRatio: number;
-    widenessToThicknessRatio: number;
-}
-export declare const DEFAULT_EDGE_ARROW_HEAD_PROGRAM_OPTIONS: CreateEdgeArrowHeadProgramOptions;
-export declare function createEdgeArrowHeadProgram<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes>(inputOptions?: Partial<CreateEdgeArrowHeadProgramOptions>): EdgeProgramType<N, E, G>;

package/dist/types/programs/arrow-head/vert.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER_SOURCE = "\nattribute vec2 a_position;\nattribute vec2 a_normal;\nattribute float a_radius;\nattribute vec3 a_barycentric;\nattribute float a_opacity;\n\n#ifdef PICKING_MODE\nattribute vec4 a_id;\n#else\nattribute vec4 a_color;\n#endif\n\nuniform mat3 u_matrix;\nuniform float u_sizeRatio;\nuniform float u_correctionRatio;\nuniform float u_minEdgeThickness;\nuniform float u_lengthToThicknessRatio;\nuniform float u_widenessToThicknessRatio;\n\nvarying vec4 v_color;\nvarying float v_opacity;\n\nconst float bias = 255.0 / 254.0;\n\nvoid main() {\n  float minThickness = u_minEdgeThickness;\n\n  float normalLength = length(a_normal);\n  vec2 unitNormal = a_normal / normalLength;\n\n  // These first computations are taken from edge.vert.glsl and\n  // edge.clamped.vert.glsl. Please read it to get better comments on what's\n  // happening:\n  float pixelsThickness = max(normalLength / u_sizeRatio, minThickness);\n  float webGLThickness = pixelsThickness * u_correctionRatio;\n  float webGLNodeRadius = a_radius * 2.0 * u_correctionRatio / u_sizeRatio;\n  float webGLArrowHeadLength = webGLThickness * u_lengthToThicknessRatio * 2.0;\n  float webGLArrowHeadThickness = webGLThickness * u_widenessToThicknessRatio;\n\n  float da = a_barycentric.x;\n  float db = a_barycentric.y;\n  float dc = a_barycentric.z;\n\n  vec2 delta = vec2(\n      da * (webGLNodeRadius * unitNormal.y)\n    + db * ((webGLNodeRadius + webGLArrowHeadLength) * unitNormal.y + webGLArrowHeadThickness * unitNormal.x)\n    + dc * ((webGLNodeRadius + webGLArrowHeadLength) * unitNormal.y - webGLArrowHeadThickness * unitNormal.x),\n\n      da * (-webGLNodeRadius * unitNormal.x)\n    + db * (-(webGLNodeRadius + webGLArrowHeadLength) * unitNormal.x + webGLArrowHeadThickness * unitNormal.y)\n    + dc * (-(webGLNodeRadius + webGLArrowHeadLength) * unitNormal.x - webGLArrowHeadThickness * unitNormal.y)\n  );\n\n  vec2 position = (u_matrix * vec3(a_position + delta, 1)).xy;\n\n  gl_Position = vec4(position, 0, 1);\n\n  #ifdef PICKING_MODE\n  // For picking mode, we use the ID as the color:\n  v_color = a_id;\n  #else\n  // For normal mode, we use the color:\n  v_color = a_color;\n  v_opacity = a_opacity;\n  #endif\n\n  v_color.a *= bias;\n}\n";
-export default SHADER_SOURCE;

package/dist/types/programs/edge-curve/drawLabel.d.ts

@@ -1,6 +0,0 @@
-import { type CreateEdgeCurveProgramOptions } from "@sigma/edge-curve";
-import { type Attributes } from "graphology-types";
-import { type EdgeLabelDrawingFunction } from "sigma/rendering";
-export declare function createDrawCurvedEdgeLabel<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes>({ curvatureAttribute, defaultCurvature, keepLabelUpright, }: CreateEdgeCurveProgramOptions & {
-    keepLabelUpright?: boolean;
-}): EdgeLabelDrawingFunction<N, E, G>;

package/dist/types/programs/edge-curve/frag.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER = "\nprecision highp float;\n\nvarying vec4 v_color;\nvarying float v_opacity;\nvarying float v_thickness;\nvarying float v_feather;\nvarying vec2 v_cpA;\nvarying vec2 v_cpB;\nvarying vec2 v_cpC;\nvarying float v_sourceSize;\nvarying vec2 v_sourcePoint;\nvarying float v_targetSize;\nvarying vec2 v_targetPoint;\n\nuniform float u_lengthToThicknessRatio;\nuniform float u_widenessToThicknessRatio;\n\nfloat det(vec2 a, vec2 b) {\n  return a.x * b.y - b.x * a.y;\n}\n\nvec2 getDistanceVector(vec2 b0, vec2 b1, vec2 b2) {\n  float a = det(b0, b2), b = 2.0 * det(b1, b0), d = 2.0 * det(b2, b1);\n  float f = b * d - a * a;\n  vec2 d21 = b2 - b1, d10 = b1 - b0, d20 = b2 - b0;\n  vec2 gf = 2.0 * (b * d21 + d * d10 + a * d20);\n  gf = vec2(gf.y, -gf.x);\n  vec2 pp = -f * gf / dot(gf, gf);\n  vec2 d0p = b0 - pp;\n  float ap = det(d0p, d20), bp = 2.0 * det(d10, d0p);\n  float t = clamp((ap + bp) / (2.0 * a + b + d), 0.0, 1.0);\n  return mix(mix(b0, b1, t), mix(b1, b2, t), t);\n}\n\nfloat distToQuadraticBezierCurve(vec2 p, vec2 b0, vec2 b1, vec2 b2) {\n  return length(getDistanceVector(b0 - p, b1 - p, b2 - p));\n}\n\nconst float epsilon = 0.7;\nconst vec4 transparent = vec4(0.0, 0.0, 0.0, 0.0);\n\nvoid main(void) {\n  float dist = distToQuadraticBezierCurve(gl_FragCoord.xy, v_cpA, v_cpB, v_cpC);\n  float thickness = v_thickness;\n\n  if(v_sourceSize > 0.0) {\n    float distToSource = length(gl_FragCoord.xy - v_sourcePoint);\n    float sourceArrowLength = v_sourceSize + (thickness) * u_lengthToThicknessRatio;\n    if (distToSource < sourceArrowLength) {\n      thickness = (distToSource - v_sourceSize) / (sourceArrowLength - v_sourceSize) * u_widenessToThicknessRatio * thickness;\n    }\n  }\n\n  if(v_targetSize > 0.0) {\n    float distToTarget = length(gl_FragCoord.xy - v_targetPoint);\n    float targetArrowLength = v_targetSize + (thickness) * u_lengthToThicknessRatio;\n    if (distToTarget < targetArrowLength) {\n      thickness = (distToTarget - v_targetSize) / (targetArrowLength - v_targetSize) * u_widenessToThicknessRatio * thickness;\n    }\n  }\n\n  float halfThickness = thickness / 2.0;\n  if (dist < halfThickness) {\n    #ifdef PICKING_MODE\n    gl_FragColor = v_color;\n    #else\n    float t = smoothstep(\n      halfThickness - v_feather,\n      halfThickness,\n      dist\n    );\n\n    gl_FragColor = mix(v_color, transparent, t);\n    gl_FragColor = mix(transparent, gl_FragColor, v_opacity);\n    #endif\n  } else {\n    gl_FragColor = transparent;\n  }\n}\n";
-export default SHADER;

package/dist/types/programs/edge-curve/index.d.ts

@@ -1,43 +0,0 @@
-import { type Attributes } from "graphology-types";
-import { EdgeProgram, type ProgramInfo } from "sigma/rendering";
-import { type EdgeDisplayData, type NodeDisplayData, type RenderParams } from "sigma/types";
-import { type InternalEdgeAttributes } from "../../types";
-declare const UNIFORMS: readonly ["u_matrix", "u_sizeRatio", "u_dimensions", "u_pixelRatio", "u_feather", "u_minEdgeThickness", "u_lengthToThicknessRatio", "u_widenessToThicknessRatio"];
-export declare class EdgeCurveProgramBase<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes> extends EdgeProgram<(typeof UNIFORMS)[number], N, E, G> {
-    getDefinition(): {
-        VERTICES: number;
-        VERTEX_SHADER_SOURCE: string;
-        FRAGMENT_SHADER_SOURCE: string;
-        METHOD: 4;
-        UNIFORMS: readonly ["u_matrix", "u_sizeRatio", "u_dimensions", "u_pixelRatio", "u_feather", "u_minEdgeThickness", "u_lengthToThicknessRatio", "u_widenessToThicknessRatio"];
-        ATTRIBUTES: ({
-            name: string;
-            size: number;
-            type: 5126;
-            normalized?: undefined;
-        } | {
-            name: string;
-            size: number;
-            type: 5121;
-            normalized: boolean;
-        })[];
-        CONSTANT_ATTRIBUTES: {
-            name: string;
-            size: number;
-            type: 5126;
-        }[];
-        CONSTANT_DATA: number[][];
-    };
-    processVisibleItem(edgeIndex: number, startIndex: number, sourceData: NodeDisplayData, targetData: NodeDisplayData, data: EdgeDisplayData & InternalEdgeAttributes): void;
-    setUniforms(params: RenderParams, { gl, uniformLocations }: ProgramInfo): void;
-}
-export declare const EdgeCurveProgram: {
-    new (_gl: WebGLRenderingContext, _pickingBuffer: WebGLFramebuffer | null, _renderer: import("sigma").default<Attributes, Attributes, Attributes>): {
-        drawLabel: import("sigma/rendering").EdgeLabelDrawingFunction<Attributes, Attributes, Attributes> | undefined;
-        kill(): void;
-        reallocate(_capacity: number): void;
-        process(_edgeIndex: number, _offset: number, _sourceData: NodeDisplayData, _targetData: NodeDisplayData, _data: EdgeDisplayData): void;
-        render(_params: RenderParams): void;
-    };
-};
-export {};

package/dist/types/programs/edge-curve/vert.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER = "\nattribute vec4 a_id;\nattribute vec4 a_color;\nattribute float a_direction;\nattribute float a_thickness;\nattribute float a_opacity;\nattribute vec2 a_source;\nattribute vec2 a_target;\nattribute float a_current;\nattribute float a_curvature;\nattribute float a_sourceSize;\nattribute float a_targetSize;\n\nuniform mat3 u_matrix;\nuniform float u_sizeRatio;\nuniform float u_pixelRatio;\nuniform vec2 u_dimensions;\nuniform float u_minEdgeThickness;\nuniform float u_feather;\nuniform float u_widenessToThicknessRatio;\n\nvarying vec4 v_color;\nvarying float v_opacity;\nvarying float v_thickness;\nvarying float v_feather;\nvarying vec2 v_cpA;\nvarying vec2 v_cpB;\nvarying vec2 v_cpC;\nvarying float v_sourceSize;\nvarying vec2 v_sourcePoint;\nvarying float v_targetSize;\nvarying vec2 v_targetPoint;\n\nconst float bias = 255.0 / 254.0;\nconst float epsilon = 0.7;\n\nvec2 clipspaceToViewport(vec2 pos, vec2 dimensions) {\n  return vec2(\n    (pos.x + 1.0) * dimensions.x / 2.0,\n    (pos.y + 1.0) * dimensions.y / 2.0\n  );\n}\n\nvec2 viewportToClipspace(vec2 pos, vec2 dimensions) {\n  return vec2(\n    pos.x / dimensions.x * 2.0 - 1.0,\n    pos.y / dimensions.y * 2.0 - 1.0\n  );\n}\n\nvoid main() {\n  float minThickness = u_minEdgeThickness;\n  // Selecting the correct position\n  // Branchless \"position = a_source if a_current == 1.0 else a_target\"\n  vec2 position = a_source * max(0.0, a_current) + a_target * max(0.0, 1.0 - a_current);\n  position = (u_matrix * vec3(position, 1)).xy;\n\n  vec2 source = (u_matrix * vec3(a_source, 1)).xy;\n  vec2 target = (u_matrix * vec3(a_target, 1)).xy;\n\n  vec2 viewportPosition = clipspaceToViewport(position, u_dimensions);\n  vec2 viewportSource = clipspaceToViewport(source, u_dimensions);\n  vec2 viewportTarget = clipspaceToViewport(target, u_dimensions);\n\n  vec2 delta = viewportTarget.xy - viewportSource.xy;\n  float len = length(delta);\n  vec2 normal = vec2(-delta.y, delta.x) * a_direction;\n  vec2 unitNormal = normal / len;\n  float boundingBoxThickness = len * a_curvature;\n  float curveThickness = max(minThickness, a_thickness / 2.0 / u_sizeRatio * u_pixelRatio);\n\n  v_thickness = curveThickness;\n  v_feather = u_feather;\n\n  v_cpA = viewportSource;\n  v_cpB = 0.5 * (viewportSource + viewportTarget) + unitNormal * a_direction * boundingBoxThickness;\n  v_cpC = viewportTarget;\n\n  vec2 viewportOffsetPosition = (\n    viewportPosition +\n    unitNormal * (boundingBoxThickness / 2.0 + sign(boundingBoxThickness) * (curveThickness + epsilon)) *\n    max(0.0, a_direction) // NOTE: cutting the bounding box in half to avoid overdraw\n  );\n\n  position = viewportToClipspace(viewportOffsetPosition, u_dimensions);\n  gl_Position = vec4(position, 0, 1);\n\n  v_sourceSize = a_sourceSize * u_pixelRatio / u_sizeRatio;\n  v_sourcePoint = viewportSource;\n  \n  v_targetSize = a_targetSize * u_pixelRatio / u_sizeRatio;\n  v_targetPoint = viewportTarget;\n    \n  #ifdef PICKING_MODE\n  // For picking mode, we use the ID as the color:\n  v_color = a_id;\n  #else\n  // For normal mode, we use the color:\n  v_color = a_color;\n  v_opacity = a_opacity;\n  #endif\n\n  v_color.a *= bias;\n}\n";
-export default SHADER;

package/dist/types/programs/edge-line/drawLabel.d.ts

@@ -1,5 +0,0 @@
-import { type Attributes } from "graphology-types";
-import { type Settings } from "sigma/settings";
-import { type EdgeDisplayData, type NodeDisplayData, type PartialButFor } from "sigma/types";
-export type EdgeLabelDrawingFunction<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes> = (context: CanvasRenderingContext2D, edgeData: PartialButFor<EdgeDisplayData, "label" | "color" | "size">, sourceData: PartialButFor<NodeDisplayData, "x" | "y" | "size">, targetData: PartialButFor<NodeDisplayData, "x" | "y" | "size">, settings: Settings<N, E, G>) => void;
-export declare function drawLineLabel<N extends Attributes = Attributes, E extends Attributes = Attributes, G extends Attributes = Attributes>(context: CanvasRenderingContext2D, edgeData: PartialButFor<EdgeDisplayData, "label" | "color" | "size">, sourceData: PartialButFor<NodeDisplayData, "x" | "y" | "size">, targetData: PartialButFor<NodeDisplayData, "x" | "y" | "size">, settings: Settings<N, E, G>): void;

package/dist/types/programs/edge-line/frag.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER_SOURCE = "\nprecision mediump float;\n\nvarying vec4 v_color;\nvarying vec2 v_normal;\nvarying float v_opacity;\nvarying float v_thickness;\nvarying float v_feather;\n\nconst vec4 transparent = vec4(0.0, 0.0, 0.0, 0.0);\n\nvoid main(void) {\n  // We only handle antialiasing for normal mode:\n  #ifdef PICKING_MODE\n  gl_FragColor = v_color;\n  #else\n  float dist = length(v_normal) * v_thickness;\n\n  float t = smoothstep(\n    v_thickness - v_feather,\n    v_thickness,\n    dist\n  );\n\n  gl_FragColor = mix(v_color, transparent, t);\n  gl_FragColor = mix(transparent, gl_FragColor, v_opacity);\n  #endif\n}\n";
-export default SHADER_SOURCE;

package/dist/types/programs/edge-line/index.d.ts

@@ -1,11 +0,0 @@
-import { type Attributes } from "graphology-types";
-import { type EdgeDisplayData, type NodeDisplayData, type RenderParams } from "sigma/types";
-export declare const EdgeLineProgram: {
-    new (_gl: WebGLRenderingContext, _pickingBuffer: WebGLFramebuffer | null, _renderer: import("sigma").default<Attributes, Attributes, Attributes>): {
-        drawLabel: import("sigma/rendering").EdgeLabelDrawingFunction<Attributes, Attributes, Attributes> | undefined;
-        kill(): void;
-        reallocate(_capacity: number): void;
-        process(_edgeIndex: number, _offset: number, _sourceData: NodeDisplayData, _targetData: NodeDisplayData, _data: EdgeDisplayData): void;
-        render(_params: RenderParams): void;
-    };
-};

package/dist/types/programs/edge-line/vert.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER_SOURCE = "\nattribute vec4 a_id;\nattribute vec4 a_color;\nattribute vec2 a_normal;\nattribute float a_opacity;\nattribute float a_normalCoef;\nattribute vec2 a_positionStart;\nattribute vec2 a_positionEnd;\nattribute float a_positionCoef;\nattribute float a_sourceRadius;\nattribute float a_targetRadius;\nattribute float a_sourceRadiusCoef;\nattribute float a_targetRadiusCoef;\n\nuniform mat3 u_matrix;\nuniform float u_sizeRatio;\nuniform float u_zoomRatio;\nuniform float u_pixelRatio;\nuniform float u_correctionRatio;\nuniform float u_minEdgeThickness;\nuniform float u_lengthToThicknessRatio;\nuniform float u_feather;\n\nvarying vec4 v_color;\nvarying vec2 v_normal;\nvarying float v_opacity;\nvarying float v_thickness;\nvarying float v_feather;\n\nconst float minThickness = 1.7;\nconst float bias = 255.0 / 254.0;\n\nvoid main() {\n  vec2 normal = a_normal * a_normalCoef;\n  vec2 position = a_positionStart * (1.0 - a_positionCoef) + a_positionEnd * a_positionCoef;\n\n  float normalLength = length(normal);\n  vec2 unitNormal = normal / normalLength;\n\n  // We require edges to be at least \"minThickness\" pixels thick *on screen*\n  // (so we need to compensate the size ratio):\n  float pixelsThickness = max(normalLength, minThickness * u_sizeRatio);\n\n  // Then, we need to retrieve the normalized thickness of the edge in the WebGL\n  // referential (in a ([0, 1], [0, 1]) space), using our \"magic\" correction\n  // ratio:\n  float webGLThickness = pixelsThickness * u_correctionRatio / u_sizeRatio;\n\n  // Here, we move the point to leave space for the arrow heads:\n  // Source arrow head\n  float sourceRadius = a_sourceRadius * a_sourceRadiusCoef;\n  float sourceDirection = sign(sourceRadius);\n  float webGLSourceRadius = sourceDirection * sourceRadius * 2.0 * u_correctionRatio / u_sizeRatio;\n  float webGLSourceArrowHeadLength = webGLThickness * u_lengthToThicknessRatio * 2.0;\n  vec2 sourceCompensationVector =\n    vec2(-sourceDirection * unitNormal.y, sourceDirection * unitNormal.x)\n    * (webGLSourceRadius + webGLSourceArrowHeadLength);\n    \n  // Target arrow head\n  float targetRadius = a_targetRadius * a_targetRadiusCoef;\n  float targetDirection = sign(targetRadius);\n  float webGLTargetRadius = targetDirection * targetRadius * 2.0 * u_correctionRatio / u_sizeRatio;\n  float webGLTargetArrowHeadLength = webGLThickness * u_lengthToThicknessRatio * 2.0;\n  vec2 targetCompensationVector =\n  vec2(-targetDirection * unitNormal.y, targetDirection * unitNormal.x)\n    * (webGLTargetRadius + webGLTargetArrowHeadLength);\n\n  if(a_sourceRadius == 0.0) {\n    sourceCompensationVector = vec2(0.0, 0.0);\n  }\n  if(a_targetRadius == 0.0) {\n    targetCompensationVector = vec2(0.0, 0.0);\n  }\n\n  // Here is the proper position of the vertex\n  gl_Position = vec4((u_matrix * vec3(position + unitNormal * webGLThickness + sourceCompensationVector + targetCompensationVector, 1)).xy, 0, 1);\n\n  // For the fragment shader though, we need a thickness that takes the \"magic\"\n  // correction ratio into account (as in webGLThickness), but so that the\n  // antialiasing effect does not depend on the zoom level. So here's yet\n  // another thickness version:\n  v_thickness = webGLThickness / u_zoomRatio;\n\n  v_normal = unitNormal;\n\n  v_feather = u_feather * u_correctionRatio / u_zoomRatio / u_pixelRatio * 2.0;\n\n  #ifdef PICKING_MODE\n  // For picking mode, we use the ID as the color:\n  v_color = a_id;\n  #else\n  // For normal mode, we use the color:\n  v_color = a_color;\n  v_opacity = a_opacity;\n  #endif\n\n  v_color.a *= bias;\n}\n";
-export default SHADER_SOURCE;

package/dist/types/programs/node-badge/factory.d.ts

@@ -1,27 +0,0 @@
-import { type Attributes } from "graphology-types";
-import { type NodeHoverDrawingFunction, type NodeLabelDrawingFunction, type NodeProgramType } from "sigma/rendering";
-import { type EdgeAttributes, type NodeAttributes } from "../../types";
-import { type TextureManagerOptions } from "./texture";
-interface CreateNodeImageProgramOptions<N extends Attributes, E extends Attributes, G extends Attributes> extends TextureManagerOptions {
-    drawingMode: "background" | "color";
-    keepWithinCircle: boolean;
-    drawLabel: NodeLabelDrawingFunction<N, E, G> | undefined;
-    drawHover: NodeHoverDrawingFunction<N, E, G> | undefined;
-    padding: number;
-    colorAttribute: string;
-}
-/**
- * To share the texture between the program instances of the graph and the
- * hovered nodes (to prevent some flickering, mostly), this program must be
- * "built" for each sigma instance:
- */
-export default function getNodeImageProgram(options?: Partial<CreateNodeImageProgramOptions<NodeAttributes & {
-    bg: string;
-    opacity: number;
-}, EdgeAttributes, Attributes>> & {
-    badgePosition: string;
-}): NodeProgramType<NodeAttributes & {
-    bg: string;
-    opacity: number;
-}, EdgeAttributes>;
-export {};

package/dist/types/programs/node-badge/frag.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER_SOURCE = "\nprecision highp float;\n\nvarying vec4 v_fill;\nvarying vec4 v_color;\nvarying vec4 v_texture;\nvarying vec2 v_diffVector;\nvarying float v_opacity;\nvarying float v_radius;\n\nuniform sampler2D u_atlas;\nuniform float u_correctionRatio;\nuniform float u_cameraAngle;\nuniform float u_percentagePadding;\nuniform bool u_keepWithinCircle;\nuniform bool u_shape;\n\nconst vec4 transparent = vec4(0.0, 0.0, 0.0, 0.0);\n\nconst float radius = 0.5;\n\nvoid main(void) {\n  float border = 2.0 * u_correctionRatio;\n  float dist = length(v_diffVector);\n  vec4 color = v_fill;\n\n  float c = cos(-u_cameraAngle);\n  float s = sin(-u_cameraAngle);\n  vec2 diffVector = mat2(c, s, -s, c) * (v_diffVector);\n\n  // No antialiasing for picking mode:\n  #ifdef PICKING_MODE\n  border = 0.0;\n  gl_FragColor = v_color;\n\n  #else\n  // First case: No image to display\n  if (v_texture.w <= 0.0) {\n     color = v_fill;\n  }\n\n  // Second case: Image loaded into the texture\n  else {\n    float paddingRatio = 1.0 + 2.0 * u_percentagePadding;\n    float coef = 1.0;\n    vec2 coordinateInTexture = diffVector * vec2(paddingRatio, -paddingRatio) / v_radius / 2.0 * coef + vec2(0.5, 0.5);\n    vec4 texel = texture2D(u_atlas, (v_texture.xy + coordinateInTexture * v_texture.zw), -1.0);\n\n    // Colorize all visible image pixels:\n    color = mix(v_fill, v_color, texel.a);\n    \n    // Erase pixels \"in the padding\":\n    if (abs(diffVector.x) > v_radius / paddingRatio || abs(diffVector.y) > v_radius / paddingRatio) {\n      color = v_fill;\n    }\n  }\n\n  // Crop in a circle when u_keepWithinCircle is truthy:\n  if(v_opacity == 0.0) {\n    gl_FragColor = transparent;\n  }\n  else if (dist - v_radius + border > border)\n    gl_FragColor = transparent;\n  else if (dist - v_radius + border > 0.0) {\n    gl_FragColor = mix(v_fill, transparent, (dist - v_radius + border) / border);\n  }\n  else  {\n    gl_FragColor = mix(v_fill, color, v_opacity);\n  }\n  #endif\n  \n\n}\n";
-export default SHADER_SOURCE;

package/dist/types/programs/node-badge/index.d.ts

@@ -1,5 +0,0 @@
-export { default as createNodeImageProgram } from "./factory";
-export declare const NodeBadgeProgram: (isCircle: boolean) => import("sigma/rendering").NodeProgramType<import("../..").NodeAttributes<KeyValue<any>> & {
-    bg: string;
-    opacity: number;
-}, import("../..").EdgeAttributes<KeyValue<any>>>[];

package/dist/types/programs/node-badge/texture.d.ts

@@ -1,102 +0,0 @@
-import { EventEmitter } from "events";
-import { type Coordinates } from "sigma/types";
-/**
- * Useful types:
- * *************
- */
-export interface ImageLoading {
-    status: "loading";
-}
-export interface ImageError {
-    status: "error";
-}
-export interface ImageReady {
-    status: "ready";
-    image: HTMLImageElement;
-    sourceX: number;
-    sourceY: number;
-    sourceSize: number;
-    destinationSize: number;
-}
-export type ImageType = ImageLoading | ImageError | ImageReady;
-export type Atlas = Record<string, Coordinates & {
-    size: number;
-}>;
-export interface TextureManagerOptions {
-    size: {
-        mode: "auto";
-    } | {
-        mode: "max";
-        value: number;
-    } | {
-        mode: "force";
-        value: number;
-    };
-    objectFit: "contain" | "cover" | "fill";
-    correctCentering: boolean;
-}
-export declare const DEFAULT_TEXTURE_MANAGER_OPTIONS: TextureManagerOptions;
-export declare const DEBOUNCE_TIMEOUT = 100;
-export declare const MARGIN_IN_TEXTURE = 1;
-/**
- * Helpers:
- * ********
- */
-/**
- * This helper loads an image at a given URL, and returns an HTMLImageElement
- * with it displayed once it's properly loaded, within a promise.
- */
-export declare function loadRasterImage(imageSource: string): Promise<HTMLImageElement>;
-export declare const makeSvg: (path?: string) => string;
-/**
- * This helper loads an SVG image at a given URL, adjusts its size to a given
- * size, and returns an HTMLImageElement with it displayed once it's properly
- * loaded, within a promise.
- */
-export declare function loadSVGImage(imageSource: string, { size }?: {
-    size?: number;
-}): Promise<HTMLImageElement>;
-/**
- * This helper loads an image using the proper function.
- */
-export declare function loadImage(imageSource: string, { size }?: {
-    size?: number;
-}): Promise<HTMLImageElement>;
-/**
- * This helper computes exact coordinates to draw an image onto a texture.
- */
-export declare function refineImage(image: HTMLImageElement, corrector: PictogramCenteringCorrector, { objectFit, size, correctCentering }: TextureManagerOptions): Omit<ImageReady, "status" | "image">;
-/**
- * This helper takes a collection of image states and a context, draw all the
- * images in the context, and returns an atlas to get where each image is drawn
- * on the texture.
- */
-export declare function drawTexture(ctx: CanvasRenderingContext2D, images: Record<string, ImageType>): Atlas;
-/**
- * This class helps to "correct" the centering of an SVG pictogram by finding
- * the "true" visually correct center through the barycenter of the pictogram's
- * alpha layer in x and y dimension.
- */
-export declare class PictogramCenteringCorrector {
-    canvas: HTMLCanvasElement;
-    context: CanvasRenderingContext2D;
-    constructor();
-    getCorrectionOffset(image: HTMLImageElement, size: number): Coordinates;
-}
-export declare class TextureManager extends EventEmitter {
-    static NEW_TEXTURE_EVENT: string;
-    private readonly options;
-    private readonly canvas;
-    private readonly ctx;
-    private frameId?;
-    private readonly corrector;
-    private imageStates;
-    private texture;
-    private atlas;
-    constructor(options?: Partial<TextureManagerOptions>);
-    private scheduleGenerateTexture;
-    private generateTexture;
-    registerImage(source: string): Promise<void>;
-    getAtlas(): Atlas;
-    getTexture(): ImageData;
-}

package/dist/types/programs/node-badge/vert.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const VERTEX_SHADER_SOURCE: string;
-export default VERTEX_SHADER_SOURCE;

package/dist/types/programs/node-circle/base/drawHover.d.ts

@@ -1,8 +0,0 @@
-import { type Settings } from "sigma/settings";
-import { type EdgeAttributes, type NodeAttributes } from "../../../types";
-export declare function drawNodeHover(context: CanvasRenderingContext2D, data: NodeAttributes & {
-    opacity: number;
-    x: number;
-    y: number;
-    size: number;
-}, settings: Settings<NodeAttributes, EdgeAttributes>): void;

package/dist/types/programs/node-circle/base/drawLabel.d.ts

@@ -1,8 +0,0 @@
-import { type Settings } from "sigma/settings";
-import { type EdgeAttributes, type InternalNodeAttributes, type NodeAttributes } from "../../../types";
-export declare function drawNodeLabel(context: CanvasRenderingContext2D, data: InternalNodeAttributes & {
-    opacity: number;
-    x: number;
-    y: number;
-    size: number;
-}, settings: Settings<NodeAttributes, EdgeAttributes>): void;

package/dist/types/programs/node-circle/base/frag.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER_SOURCE: string;
-export default SHADER_SOURCE;

package/dist/types/programs/node-circle/base/index.d.ts

@@ -1,37 +0,0 @@
-import { NodeProgram, type ProgramInfo } from "sigma/rendering";
-import { type NodeDisplayData, type RenderParams } from "sigma/types";
-import { type EdgeAttributes, type NodeAttributes } from "../../../types";
-declare const UNIFORMS: readonly ["u_sizeRatio", "u_correctionRatio", "u_matrix"];
-export declare class NodeCircleBase extends NodeProgram<(typeof UNIFORMS)[number], NodeAttributes, EdgeAttributes> {
-    static readonly ANGLE_1 = 0;
-    static readonly ANGLE_2: number;
-    static readonly ANGLE_3: number;
-    getDefinition(): {
-        VERTICES: number;
-        VERTEX_SHADER_SOURCE: string;
-        FRAGMENT_SHADER_SOURCE: string;
-        METHOD: 4;
-        UNIFORMS: readonly ["u_sizeRatio", "u_correctionRatio", "u_matrix"];
-        ATTRIBUTES: ({
-            name: string;
-            size: number;
-            type: 5121;
-            normalized: boolean;
-        } | {
-            name: string;
-            size: number;
-            type: 5126;
-        })[];
-        CONSTANT_ATTRIBUTES: {
-            name: string;
-            size: number;
-            type: 5126;
-        }[];
-        CONSTANT_DATA: number[][];
-    };
-    processVisibleItem(nodeIndex: number, startIndex: number, data: NodeDisplayData & NodeAttributes & {
-        opacity: number;
-    }): void;
-    setUniforms(params: RenderParams, { gl, uniformLocations }: ProgramInfo): void;
-}
-export {};

package/dist/types/programs/node-circle/base/vert.glsl.d.ts

@@ -1,2 +0,0 @@
-declare const SHADER_SOURCE: string;
-export default SHADER_SOURCE;

package/dist/types/programs/node-circle/index.d.ts

@@ -1,11 +0,0 @@
-import { type NodeAttributes } from "../../types";
-export declare const NodeCircleProgram: {
-    new (_gl: WebGLRenderingContext, _pickingBuffer: WebGLFramebuffer | null, _renderer: import("sigma").default<NodeAttributes<any>, import("graphology-types").Attributes, import("graphology-types").Attributes>): {
-        drawLabel: import("sigma/rendering").NodeLabelDrawingFunction<NodeAttributes<any>, import("graphology-types").Attributes, import("graphology-types").Attributes> | undefined;
-        drawHover: import("sigma/rendering").NodeHoverDrawingFunction<NodeAttributes<any>, import("graphology-types").Attributes, import("graphology-types").Attributes> | undefined;
-        kill(): void;
-        reallocate(_capacity: number): void;
-        process(_nodeIndex: number, _offset: number, _data: import("sigma/types").NodeDisplayData): void;
-        render(_params: import("sigma/types").RenderParams): void;
-    };
-};