flow like the river

VISUALIZACION/public/libs/3d-force-graph.js

@@ -0,0 +1,438 @@
+import  { AmbientLight, DirectionalLight, Vector3, REVISION } from "./three.module.js";
+
+
+const three = window.THREE
+  ? window.THREE // Prefer consumption from global THREE, if exists
+  : { AmbientLight, DirectionalLight, Vector3, REVISION };
+
+import { DragControls as ThreeDragControls } from './DragControls.js';
+
+import ThreeForceGraph from "./three-forcegraph.js";
+import ThreeRenderObjects from "./three-render-objects.js";
+
+import accessorFn from "./accessor-fn.js";
+import Kapsule from "./kapsule.js";
+
+import linkKapsule from './kapsule-link.js';
+
+//
+
+const CAMERA_DISTANCE2NODES_FACTOR = 170;
+
+//
+
+// Expose config from forceGraph
+const bindFG = linkKapsule('forceGraph', ThreeForceGraph);
+const linkedFGProps = Object.assign(...[
+  'jsonUrl',
+  'graphData',
+  'numDimensions',
+  'dagMode',
+  'dagLevelDistance',
+  'dagNodeFilter',
+  'onDagError',
+  'nodeRelSize',
+  'nodeId',
+  'nodeVal',
+  'nodeResolution',
+  'nodeColor',
+  'nodeAutoColorBy',
+  'nodeOpacity',
+  'nodeVisibility',
+  'nodeThreeObject',
+  'nodeThreeObjectExtend',
+  'linkSource',
+  'linkTarget',
+  'linkVisibility',
+  'linkColor',
+  'linkAutoColorBy',
+  'linkOpacity',
+  'linkWidth',
+  'linkResolution',
+  'linkCurvature',
+  'linkCurveRotation',
+  'linkMaterial',
+  'linkThreeObject',
+  'linkThreeObjectExtend',
+  'linkPositionUpdate',
+  'linkDirectionalArrowLength',
+  'linkDirectionalArrowColor',
+  'linkDirectionalArrowRelPos',
+  'linkDirectionalArrowResolution',
+  'linkDirectionalParticles',
+  'linkDirectionalParticleSpeed',
+  'linkDirectionalParticleWidth',
+  'linkDirectionalParticleColor',
+  'linkDirectionalParticleResolution',
+  'forceEngine',
+  'd3AlphaDecay',
+  'd3VelocityDecay',
+  'd3AlphaMin',
+  'ngraphPhysics',
+  'warmupTicks',
+  'cooldownTicks',
+  'cooldownTime',
+  'onEngineTick',
+  'onEngineStop'
+].map(p => ({ [p]: bindFG.linkProp(p)})));
+const linkedFGMethods = Object.assign(...[
+  'refresh',
+  'getGraphBbox',
+  'd3Force',
+  'd3ReheatSimulation',
+  'emitParticle'
+].map(p => ({ [p]: bindFG.linkMethod(p)})));
+
+// Expose config from renderObjs
+const bindRenderObjs = linkKapsule('renderObjs', ThreeRenderObjects);
+const linkedRenderObjsProps = Object.assign(...[
+  'width',
+  'height',
+  'backgroundColor',
+  'showNavInfo',
+  'enablePointerInteraction'
+].map(p => ({ [p]: bindRenderObjs.linkProp(p)})));
+const linkedRenderObjsMethods = Object.assign(
+  ...[
+    'lights',
+    'cameraPosition',
+    'postProcessingComposer'
+  ].map(p => ({ [p]: bindRenderObjs.linkMethod(p)})),
+  {
+    graph2ScreenCoords: bindRenderObjs.linkMethod('getScreenCoords'),
+    screen2GraphCoords: bindRenderObjs.linkMethod('getSceneCoords')
+  }
+);
+
+//
+
+export default Kapsule({
+
+  props: {
+    nodeLabel: { default: 'name', triggerUpdate: false },
+    linkLabel: { default: 'name', triggerUpdate: false },
+    linkHoverPrecision: { default: 1, onChange: (p, state) => state.renderObjs.lineHoverPrecision(p), triggerUpdate: false },
+    enableNavigationControls: {
+      default: true,
+      onChange(enable, state) {
+        const controls = state.renderObjs.controls();
+        if (controls) {
+          controls.enabled = enable;
+          // trigger mouseup on re-enable to prevent sticky controls
+          enable && controls.domElement && controls.domElement.dispatchEvent(new PointerEvent('pointerup'));
+        }
+      },
+      triggerUpdate: false
+    },
+    enableNodeDrag: { default: true, triggerUpdate: false },
+    onNodeDrag: { default: () => {}, triggerUpdate: false },
+    onNodeDragEnd: { default: () => {}, triggerUpdate: false },
+    onNodeClick: { triggerUpdate: false },
+    onNodeRightClick: { triggerUpdate: false },
+    onNodeHover: { triggerUpdate: false },
+    onLinkClick: { triggerUpdate: false },
+    onLinkRightClick: { triggerUpdate: false },
+    onLinkHover: { triggerUpdate: false },
+    onBackgroundClick: { triggerUpdate: false },
+    onBackgroundRightClick: { triggerUpdate: false },
+    ...linkedFGProps,
+    ...linkedRenderObjsProps
+  },
+
+  methods: {
+    zoomToFit: function(state, transitionDuration, padding, ...bboxArgs) {
+      state.renderObjs.fitToBbox(
+        state.forceGraph.getGraphBbox(...bboxArgs),
+        transitionDuration,
+        padding
+      );
+      return this;
+    },
+    pauseAnimation: function(state) {
+      if (state.animationFrameRequestId !== null) {
+        cancelAnimationFrame(state.animationFrameRequestId);
+        state.animationFrameRequestId = null;
+      }
+      return this;
+    },
+
+    resumeAnimation: function(state) {
+      if (state.animationFrameRequestId === null) {
+        this._animationCycle();
+      }
+      return this;
+    },
+    _animationCycle(state) {
+      if (state.enablePointerInteraction) {
+        // reset canvas cursor (override dragControls cursor)
+        this.renderer().domElement.style.cursor = null;
+      }
+
+      // Frame cycle
+      state.forceGraph.tickFrame();
+      state.renderObjs.tick();
+      state.animationFrameRequestId = requestAnimationFrame(this._animationCycle);
+    },
+    scene: state => state.renderObjs.scene(), // Expose scene
+    camera: state => state.renderObjs.camera(), // Expose camera
+    renderer: state => state.renderObjs.renderer(), // Expose renderer
+    controls: state => state.renderObjs.controls(), // Expose controls
+    tbControls: state => state.renderObjs.tbControls(), // To be deprecated
+    _destructor: function() {
+      this.pauseAnimation();
+      this.graphData({ nodes: [], links: []});
+    },
+    ...linkedFGMethods,
+    ...linkedRenderObjsMethods
+  },
+
+  stateInit: ({ controlType, rendererConfig, extraRenderers }) => {
+    const forceGraph = new ThreeForceGraph();
+    return {
+      forceGraph,
+      renderObjs: ThreeRenderObjects({ controlType, rendererConfig, extraRenderers })
+        .objects([forceGraph]) // Populate scene
+        .lights([
+          new three.AmbientLight(0xcccccc, Math.PI),
+          new three.DirectionalLight(0xffffff, 0.6 * Math.PI)
+        ])
+    }
+  },
+
+  init: function(domNode, state) {
+    // Wipe DOM
+    domNode.innerHTML = '';
+
+    // Add relative container
+    domNode.appendChild(state.container = document.createElement('div'));
+    state.container.style.position = 'relative';
+
+    // Add renderObjs
+    const roDomNode = document.createElement('div');
+    state.container.appendChild(roDomNode);
+    state.renderObjs(roDomNode);
+    const camera = state.renderObjs.camera();
+    const renderer = state.renderObjs.renderer();
+    const controls = state.renderObjs.controls();
+    controls.enabled = !!state.enableNavigationControls;
+    state.lastSetCameraZ = camera.position.z;
+
+    // Add info space
+    let infoElem;
+    state.container.appendChild(infoElem = document.createElement('div'));
+    infoElem.className = 'graph-info-msg';
+    infoElem.textContent = '';
+
+    // config forcegraph
+    state.forceGraph
+      .onLoading(() => { infoElem.textContent = 'Loading...' })
+      .onFinishLoading(() => { infoElem.textContent = '' })
+      .onUpdate(() => {
+        // sync graph data structures
+        state.graphData = state.forceGraph.graphData();
+
+        // re-aim camera, if still in default position (not user modified)
+        if (camera.position.x === 0 && camera.position.y === 0 && camera.position.z === state.lastSetCameraZ && state.graphData.nodes.length) {
+          camera.lookAt(state.forceGraph.position);
+          state.lastSetCameraZ = camera.position.z = Math.cbrt(state.graphData.nodes.length) * CAMERA_DISTANCE2NODES_FACTOR;
+        }
+      })
+      .onFinishUpdate(() => {
+        // Setup node drag interaction
+        if (state._dragControls) {
+          const curNodeDrag = state.graphData.nodes.find(node => node.__initialFixedPos && !node.__disposeControlsAfterDrag); // detect if there's a node being dragged using the existing drag controls
+          if (curNodeDrag) {
+            curNodeDrag.__disposeControlsAfterDrag = true; // postpone previous controls disposal until drag ends
+          } else {
+            state._dragControls.dispose(); // cancel previous drag controls
+          }
+
+          state._dragControls = undefined;
+        }
+
+        if (state.enableNodeDrag && state.enablePointerInteraction && state.forceEngine === 'd3') { // Can't access node positions programmatically in ngraph
+          const dragControls = state._dragControls = new ThreeDragControls(
+            state.graphData.nodes.map(node => node.__threeObj).filter(obj => obj),
+            camera,
+            renderer.domElement
+          );
+
+          dragControls.addEventListener('dragstart', function (event) {
+            controls.enabled = false; // Disable controls while dragging
+
+            // track drag object movement
+            event.object.__initialPos = event.object.position.clone();
+            event.object.__prevPos = event.object.position.clone();
+
+            const node = getGraphObj(event.object).__data;
+            !node.__initialFixedPos && (node.__initialFixedPos = {fx: node.fx, fy: node.fy, fz: node.fz});
+            !node.__initialPos && (node.__initialPos = {x: node.x, y: node.y, z: node.z});
+
+            // lock node
+            ['x', 'y', 'z'].forEach(c => node[`f${c}`] = node[c]);
+
+            // drag cursor
+            renderer.domElement.classList.add('grabbable');
+          });
+
+          dragControls.addEventListener('drag', function (event) {
+            const nodeObj = getGraphObj(event.object);
+
+            if (!event.object.hasOwnProperty('__graphObjType')) {
+              // If dragging a child of the node, update the node object instead
+              const initPos = event.object.__initialPos;
+              const prevPos = event.object.__prevPos;
+              const newPos = event.object.position;
+
+              nodeObj.position.add(newPos.clone().sub(prevPos)); // translate node object by the motion delta
+              prevPos.copy(newPos);
+              newPos.copy(initPos); // reset child back to its initial position
+            }
+
+            const node = nodeObj.__data;
+            const newPos = nodeObj.position;
+            const translate = {x: newPos.x - node.x, y: newPos.y - node.y, z: newPos.z - node.z};
+            // Move fx/fy/fz (and x/y/z) of nodes based on object new position
+            ['x', 'y', 'z'].forEach(c => node[`f${c}`] = node[c] = newPos[c]);
+
+            state.forceGraph
+              .d3AlphaTarget(0.3) // keep engine running at low intensity throughout drag
+              .resetCountdown();  // prevent freeze while dragging
+
+            node.__dragged = true;
+            state.onNodeDrag(node, translate);
+          });
+
+          dragControls.addEventListener('dragend', function (event) {
+            delete(event.object.__initialPos); // remove tracking attributes
+            delete(event.object.__prevPos);
+
+            const node = getGraphObj(event.object).__data;
+
+            // dispose previous controls if needed
+            if (node.__disposeControlsAfterDrag) {
+              dragControls.dispose();
+              delete(node.__disposeControlsAfterDrag);
+            }
+
+            const initFixedPos = node.__initialFixedPos;
+            const initPos = node.__initialPos;
+            const translate = {x: initPos.x - node.x, y: initPos.y - node.y, z: initPos.z - node.z};
+            if (initFixedPos) {
+              ['x', 'y', 'z'].forEach(c => {
+                const fc = `f${c}`;
+                if (initFixedPos[fc] === undefined) {
+                  delete(node[fc])
+                }
+              });
+              delete(node.__initialFixedPos);
+              delete(node.__initialPos);
+              if (node.__dragged) {
+                delete(node.__dragged);
+                state.onNodeDragEnd(node, translate);
+              }
+            }
+
+            state.forceGraph
+              .d3AlphaTarget(0)   // release engine low intensity
+              .resetCountdown();  // let the engine readjust after releasing fixed nodes
+
+            if (state.enableNavigationControls) {
+              controls.enabled = true; // Re-enable controls
+              controls.domElement && controls.domElement.ownerDocument && controls.domElement.ownerDocument.dispatchEvent(
+                // simulate mouseup to ensure the controls don't take over after dragend
+                new PointerEvent('pointerup', { pointerType: 'touch' })
+              );
+            }
+
+            // clear cursor
+            renderer.domElement.classList.remove('grabbable');
+          });
+        }
+      });
+
+    // config renderObjs
+    three.REVISION < 155 && (state.renderObjs.renderer().useLegacyLights = false); // force behavior for three < 155
+    state.renderObjs
+      .hoverOrderComparator((a, b) => {
+        // Prioritize graph objects
+        const aObj = getGraphObj(a);
+        if (!aObj) return 1;
+        const bObj = getGraphObj(b);
+        if (!bObj) return -1;
+
+        // Prioritize nodes over links
+        const isNode = o => o.__graphObjType === 'node';
+        return isNode(bObj) - isNode(aObj);
+      })
+      .tooltipContent(obj => {
+        const graphObj = getGraphObj(obj);
+        return graphObj ? accessorFn(state[`${graphObj.__graphObjType}Label`])(graphObj.__data) || '' : '';
+      })
+      .hoverDuringDrag(false)
+      .onHover(obj => {
+        // Update tooltip and trigger onHover events
+        const hoverObj = getGraphObj(obj);
+
+        if (hoverObj !== state.hoverObj) {
+          const prevObjType = state.hoverObj ? state.hoverObj.__graphObjType : null;
+          const prevObjData = state.hoverObj ? state.hoverObj.__data : null;
+          const objType = hoverObj ? hoverObj.__graphObjType : null;
+          const objData = hoverObj ? hoverObj.__data : null;
+          if (prevObjType && prevObjType !== objType) {
+            // Hover out
+            const fn = state[`on${prevObjType === 'node' ? 'Node' : 'Link'}Hover`];
+            fn && fn(null, prevObjData);
+          }
+          if (objType) {
+            // Hover in
+            const fn = state[`on${objType === 'node' ? 'Node' : 'Link'}Hover`];
+            fn && fn(objData, prevObjType === objType ? prevObjData : null);
+          }
+
+          // set pointer if hovered object is clickable
+          renderer.domElement.classList[
+            ((hoverObj && state[`on${objType === 'node' ? 'Node' : 'Link'}Click`]) || (!hoverObj && state.onBackgroundClick)) ? 'add' : 'remove'
+          ]('clickable');
+
+          state.hoverObj = hoverObj;
+        }
+      })
+      .clickAfterDrag(false)
+      .onClick((obj, ev) => {
+        const graphObj = getGraphObj(obj);
+        if (graphObj) {
+          const fn = state[`on${graphObj.__graphObjType === 'node' ? 'Node' : 'Link'}Click`];
+          fn && fn(graphObj.__data, ev);
+        } else {
+          state.onBackgroundClick && state.onBackgroundClick(ev);
+        }
+      })
+      .onRightClick((obj, ev) => {
+        // Handle right-click events
+        const graphObj = getGraphObj(obj);
+        if (graphObj) {
+          const fn = state[`on${graphObj.__graphObjType === 'node' ? 'Node' : 'Link'}RightClick`];
+          fn && fn(graphObj.__data, ev);
+        } else {
+          state.onBackgroundRightClick && state.onBackgroundRightClick(ev);
+        }
+      });
+
+    //
+
+    // Kick-off renderer
+    this._animationCycle();
+  }
+});
+
+//
+
+function getGraphObj(object) {
+  let obj = object;
+  // recurse up object chain until finding the graph object
+  while (obj && !obj.hasOwnProperty('__graphObjType')) {
+    obj = obj.parent;
+  }
+  return obj;
+}

VISUALIZACION/public/libs/DragControls.js

@@ -0,0 +1,410 @@
+import {
+	Controls,
+	Matrix4,
+	Plane,
+	Raycaster,
+	Vector2,
+	Vector3,
+	MOUSE,
+	TOUCH
+} from './three.module.js';
+
+const _plane = new Plane();
+
+const _pointer = new Vector2();
+const _offset = new Vector3();
+const _diff = new Vector2();
+const _previousPointer = new Vector2();
+const _intersection = new Vector3();
+const _worldPosition = new Vector3();
+const _inverseMatrix = new Matrix4();
+
+const _up = new Vector3();
+const _right = new Vector3();
+
+let _selected = null, _hovered = null;
+const _intersections = [];
+
+const STATE = {
+	NONE: - 1,
+	PAN: 0,
+	ROTATE: 1
+};
+
+class DragControls extends Controls {
+
+	constructor( objects, camera, domElement = null ) {
+
+		super( camera, domElement );
+
+		this.objects = objects;
+
+		this.recursive = true;
+		this.transformGroup = false;
+		this.rotateSpeed = 1;
+
+		this.raycaster = new Raycaster();
+
+		// interaction
+
+		this.mouseButtons = { LEFT: MOUSE.PAN, MIDDLE: MOUSE.PAN, RIGHT: MOUSE.ROTATE };
+		this.touches = { ONE: TOUCH.PAN };
+
+		// event listeners
+
+		this._onPointerMove = onPointerMove.bind( this );
+		this._onPointerDown = onPointerDown.bind( this );
+		this._onPointerCancel = onPointerCancel.bind( this );
+		this._onContextMenu = onContextMenu.bind( this );
+
+		//
+
+		if ( domElement !== null ) {
+
+			this.connect();
+
+		}
+
+	}
+
+	connect() {
+
+		this.domElement.addEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.addEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.addEventListener( 'pointerup', this._onPointerCancel );
+		this.domElement.addEventListener( 'pointerleave', this._onPointerCancel );
+		this.domElement.addEventListener( 'contextmenu', this._onContextMenu );
+
+		this.domElement.style.touchAction = 'none'; // disable touch scroll
+
+	}
+
+	disconnect() {
+
+		this.domElement.removeEventListener( 'pointermove', this._onPointerMove );
+		this.domElement.removeEventListener( 'pointerdown', this._onPointerDown );
+		this.domElement.removeEventListener( 'pointerup', this._onPointerCancel );
+		this.domElement.removeEventListener( 'pointerleave', this._onPointerCancel );
+		this.domElement.removeEventListener( 'contextmenu', this._onContextMenu );
+
+		this.domElement.style.touchAction = 'auto';
+		this.domElement.style.cursor = '';
+
+	}
+
+	dispose() {
+
+		this.disconnect();
+
+	}
+
+	_updatePointer( event ) {
+
+		const rect = this.domElement.getBoundingClientRect();
+
+		_pointer.x = ( event.clientX - rect.left ) / rect.width * 2 - 1;
+		_pointer.y = - ( event.clientY - rect.top ) / rect.height * 2 + 1;
+
+	}
+
+	_updateState( event ) {
+
+		// determine action
+
+		let action;
+
+		if ( event.pointerType === 'touch' ) {
+
+			action = this.touches.ONE;
+
+		} else {
+
+			switch ( event.button ) {
+
+				case 0:
+
+					action = this.mouseButtons.LEFT;
+					break;
+
+				case 1:
+
+					action = this.mouseButtons.MIDDLE;
+					break;
+
+				case 2:
+
+					action = this.mouseButtons.RIGHT;
+					break;
+
+				default:
+
+					action = null;
+
+			}
+
+		}
+
+		// determine state
+
+		switch ( action ) {
+
+			case MOUSE.PAN:
+			case TOUCH.PAN:
+
+				this.state = STATE.PAN;
+
+				break;
+
+			case MOUSE.ROTATE:
+			case TOUCH.ROTATE:
+
+				this.state = STATE.ROTATE;
+
+				break;
+
+			default:
+
+				this.state = STATE.NONE;
+
+		}
+
+	}
+
+	getRaycaster() {
+
+		console.warn( 'THREE.DragControls: getRaycaster() has been deprecated. Use controls.raycaster instead.' ); // @deprecated r169
+
+		return this.raycaster;
+
+	}
+
+	setObjects( objects ) {
+
+		console.warn( 'THREE.DragControls: setObjects() has been deprecated. Use controls.objects instead.' ); // @deprecated r169
+
+		this.objects = objects;
+
+	}
+
+	getObjects() {
+
+		console.warn( 'THREE.DragControls: getObjects() has been deprecated. Use controls.objects instead.' ); // @deprecated r169
+
+		return this.objects;
+
+	}
+
+	activate() {
+
+		console.warn( 'THREE.DragControls: activate() has been renamed to connect().' ); // @deprecated r169
+		this.connect();
+
+	}
+
+	deactivate() {
+
+		console.warn( 'THREE.DragControls: deactivate() has been renamed to disconnect().' ); // @deprecated r169
+		this.disconnect();
+
+	}
+
+	set mode( value ) {
+
+		console.warn( 'THREE.DragControls: The .mode property has been removed. Define the type of transformation via the .mouseButtons or .touches properties.' ); // @deprecated r169
+
+	}
+
+	get mode() {
+
+		console.warn( 'THREE.DragControls: The .mode property has been removed. Define the type of transformation via the .mouseButtons or .touches properties.' ); // @deprecated r169
+
+	}
+
+}
+
+function onPointerMove( event ) {
+
+	const camera = this.object;
+	const domElement = this.domElement;
+	const raycaster = this.raycaster;
+
+	if ( this.enabled === false ) return;
+
+	this._updatePointer( event );
+
+	raycaster.setFromCamera( _pointer, camera );
+
+	if ( _selected ) {
+
+		if ( this.state === STATE.PAN ) {
+
+			if ( raycaster.ray.intersectPlane( _plane, _intersection ) ) {
+
+				_selected.position.copy( _intersection.sub( _offset ).applyMatrix4( _inverseMatrix ) );
+
+			}
+
+		} else if ( this.state === STATE.ROTATE ) {
+
+			_diff.subVectors( _pointer, _previousPointer ).multiplyScalar( this.rotateSpeed );
+			_selected.rotateOnWorldAxis( _up, _diff.x );
+			_selected.rotateOnWorldAxis( _right.normalize(), - _diff.y );
+
+		}
+
+		this.dispatchEvent( { type: 'drag', object: _selected } );
+
+		_previousPointer.copy( _pointer );
+
+	} else {
+
+		// hover support
+
+		if ( event.pointerType === 'mouse' || event.pointerType === 'pen' ) {
+
+			_intersections.length = 0;
+
+			raycaster.setFromCamera( _pointer, camera );
+			raycaster.intersectObjects( this.objects, this.recursive, _intersections );
+
+			if ( _intersections.length > 0 ) {
+
+				const object = _intersections[ 0 ].object;
+
+				_plane.setFromNormalAndCoplanarPoint( camera.getWorldDirection( _plane.normal ), _worldPosition.setFromMatrixPosition( object.matrixWorld ) );
+
+				if ( _hovered !== object && _hovered !== null ) {
+
+					this.dispatchEvent( { type: 'hoveroff', object: _hovered } );
+
+					domElement.style.cursor = 'auto';
+					_hovered = null;
+
+				}
+
+				if ( _hovered !== object ) {
+
+					this.dispatchEvent( { type: 'hoveron', object: object } );
+
+					domElement.style.cursor = 'pointer';
+					_hovered = object;
+
+				}
+
+			} else {
+
+				if ( _hovered !== null ) {
+
+					this.dispatchEvent( { type: 'hoveroff', object: _hovered } );
+
+					domElement.style.cursor = 'auto';
+					_hovered = null;
+
+				}
+
+			}
+
+		}
+
+	}
+
+	_previousPointer.copy( _pointer );
+
+}
+
+function onPointerDown( event ) {
+
+	const camera = this.object;
+	const domElement = this.domElement;
+	const raycaster = this.raycaster;
+
+	if ( this.enabled === false ) return;
+
+	this._updatePointer( event );
+	this._updateState( event );
+
+	_intersections.length = 0;
+
+	raycaster.setFromCamera( _pointer, camera );
+	raycaster.intersectObjects( this.objects, this.recursive, _intersections );
+
+	if ( _intersections.length > 0 ) {
+
+		if ( this.transformGroup === true ) {
+
+			// look for the outermost group in the object's upper hierarchy
+
+			_selected = findGroup( _intersections[ 0 ].object );
+
+		} else {
+
+			_selected = _intersections[ 0 ].object;
+
+		}
+
+		_plane.setFromNormalAndCoplanarPoint( camera.getWorldDirection( _plane.normal ), _worldPosition.setFromMatrixPosition( _selected.matrixWorld ) );
+
+		if ( raycaster.ray.intersectPlane( _plane, _intersection ) ) {
+
+			if ( this.state === STATE.PAN ) {
+
+				_inverseMatrix.copy( _selected.parent.matrixWorld ).invert();
+				_offset.copy( _intersection ).sub( _worldPosition.setFromMatrixPosition( _selected.matrixWorld ) );
+
+			} else if ( this.state === STATE.ROTATE ) {
+
+				// the controls only support Y+ up
+				_up.set( 0, 1, 0 ).applyQuaternion( camera.quaternion ).normalize();
+				_right.set( 1, 0, 0 ).applyQuaternion( camera.quaternion ).normalize();
+
+			}
+
+		}
+
+		domElement.style.cursor = 'move';
+
+		this.dispatchEvent( { type: 'dragstart', object: _selected } );
+
+	}
+
+	_previousPointer.copy( _pointer );
+
+}
+
+function onPointerCancel() {
+
+	if ( this.enabled === false ) return;
+
+	if ( _selected ) {
+
+		this.dispatchEvent( { type: 'dragend', object: _selected } );
+
+		_selected = null;
+
+	}
+
+	this.domElement.style.cursor = _hovered ? 'pointer' : 'auto';
+
+	this.state = STATE.NONE;
+
+}
+
+function onContextMenu( event ) {
+
+	if ( this.enabled === false ) return;
+
+	event.preventDefault();
+
+}
+
+function findGroup( obj, group = null ) {
+
+	if ( obj.isGroup ) group = obj;
+
+	if ( obj.parent === null ) return group;
+
+	return findGroup( obj.parent, group );
+
+}
+
+export { DragControls };

VISUALIZACION/public/libs/accessor-fn.js

@@ -0,0 +1,22 @@
+// Version 1.5.0 accessor-fn - https://github.com/vasturiano/accessor-fn
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.accessorFn = factory());
+})(this, (function () { 'use strict';
+
+    var index = (function (p) {
+      return typeof p === 'function' ? p // fn
+      : typeof p === 'string' ? function (obj) {
+        return obj[p];
+      } // property name
+      : function (obj) {
+        return p;
+      };
+    }); // constant
+
+    return index;
+
+}));
+//# sourceMappingURL=accessor-fn.js.map
+export default TableCsv

VISUALIZACION/public/libs/kapsule-link.js

@@ -0,0 +1,26 @@
+export default function(kapsulePropName, kapsuleType) {
+
+  const dummyK = new kapsuleType(); // To extract defaults
+  dummyK._destructor && dummyK._destructor();
+
+  return {
+    linkProp: function(prop) { // link property config
+      return {
+        default: dummyK[prop](),
+        onChange(v, state) { state[kapsulePropName][prop](v) },
+        triggerUpdate: false
+      }
+    },
+    linkMethod: function(method) { // link method pass-through
+      return function(state, ...args) {
+        const kapsuleInstance = state[kapsulePropName];
+        const returnVal = kapsuleInstance[method](...args);
+
+        return returnVal === kapsuleInstance
+          ? this // chain based on the parent object, not the inner kapsule
+          : returnVal;
+      }
+    }
+  }
+
+}

VISUALIZACION/public/libs/kapsule.js

@@ -0,0 +1,716 @@
+// Version 1.14.4 kapsule - https://github.com/vasturiano/kapsule
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Kapsule = factory());
+})(this, (function () { 'use strict';
+
+  function _iterableToArrayLimit(arr, i) {
+    var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"];
+    if (null != _i) {
+      var _s,
+        _e,
+        _x,
+        _r,
+        _arr = [],
+        _n = !0,
+        _d = !1;
+      try {
+        if (_x = (_i = _i.call(arr)).next, 0 === i) {
+          if (Object(_i) !== _i) return;
+          _n = !1;
+        } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0);
+      } catch (err) {
+        _d = !0, _e = err;
+      } finally {
+        try {
+          if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return;
+        } finally {
+          if (_d) throw _e;
+        }
+      }
+      return _arr;
+    }
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
+    return Constructor;
+  }
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+  }
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _toPrimitive(input, hint) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+      var res = prim.call(input, hint || "default");
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
+
+  /** Detect free variable `global` from Node.js. */
+  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+  var freeGlobal$1 = freeGlobal;
+
+  /** Detect free variable `self`. */
+  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+  /** Used as a reference to the global object. */
+  var root = freeGlobal$1 || freeSelf || Function('return this')();
+
+  var root$1 = root;
+
+  /** Built-in value references. */
+  var Symbol$1 = root$1.Symbol;
+
+  var Symbol$2 = Symbol$1;
+
+  /** Used for built-in method references. */
+  var objectProto$1 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto$1.hasOwnProperty;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString$1 = objectProto$1.toString;
+
+  /** Built-in value references. */
+  var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
+
+  /**
+   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the raw `toStringTag`.
+   */
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty.call(value, symToStringTag$1),
+        tag = value[symToStringTag$1];
+
+    try {
+      value[symToStringTag$1] = undefined;
+      var unmasked = true;
+    } catch (e) {}
+
+    var result = nativeObjectToString$1.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag$1] = tag;
+      } else {
+        delete value[symToStringTag$1];
+      }
+    }
+    return result;
+  }
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString = objectProto.toString;
+
+  /**
+   * Converts `value` to a string using `Object.prototype.toString`.
+   *
+   * @private
+   * @param {*} value The value to convert.
+   * @returns {string} Returns the converted string.
+   */
+  function objectToString(value) {
+    return nativeObjectToString.call(value);
+  }
+
+  /** `Object#toString` result references. */
+  var nullTag = '[object Null]',
+      undefinedTag = '[object Undefined]';
+
+  /** Built-in value references. */
+  var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : undefined;
+
+  /**
+   * The base implementation of `getTag` without fallbacks for buggy environments.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  function baseGetTag(value) {
+    if (value == null) {
+      return value === undefined ? undefinedTag : nullTag;
+    }
+    return (symToStringTag && symToStringTag in Object(value))
+      ? getRawTag(value)
+      : objectToString(value);
+  }
+
+  /**
+   * Checks if `value` is object-like. A value is object-like if it's not `null`
+   * and has a `typeof` result of "object".
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+   * @example
+   *
+   * _.isObjectLike({});
+   * // => true
+   *
+   * _.isObjectLike([1, 2, 3]);
+   * // => true
+   *
+   * _.isObjectLike(_.noop);
+   * // => false
+   *
+   * _.isObjectLike(null);
+   * // => false
+   */
+  function isObjectLike(value) {
+    return value != null && typeof value == 'object';
+  }
+
+  /** `Object#toString` result references. */
+  var symbolTag = '[object Symbol]';
+
+  /**
+   * Checks if `value` is classified as a `Symbol` primitive or object.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+   * @example
+   *
+   * _.isSymbol(Symbol.iterator);
+   * // => true
+   *
+   * _.isSymbol('abc');
+   * // => false
+   */
+  function isSymbol(value) {
+    return typeof value == 'symbol' ||
+      (isObjectLike(value) && baseGetTag(value) == symbolTag);
+  }
+
+  /** Used to match a single whitespace character. */
+  var reWhitespace = /\s/;
+
+  /**
+   * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+   * character of `string`.
+   *
+   * @private
+   * @param {string} string The string to inspect.
+   * @returns {number} Returns the index of the last non-whitespace character.
+   */
+  function trimmedEndIndex(string) {
+    var index = string.length;
+
+    while (index-- && reWhitespace.test(string.charAt(index))) {}
+    return index;
+  }
+
+  /** Used to match leading whitespace. */
+  var reTrimStart = /^\s+/;
+
+  /**
+   * The base implementation of `_.trim`.
+   *
+   * @private
+   * @param {string} string The string to trim.
+   * @returns {string} Returns the trimmed string.
+   */
+  function baseTrim(string) {
+    return string
+      ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+      : string;
+  }
+
+  /**
+   * Checks if `value` is the
+   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+   * @example
+   *
+   * _.isObject({});
+   * // => true
+   *
+   * _.isObject([1, 2, 3]);
+   * // => true
+   *
+   * _.isObject(_.noop);
+   * // => true
+   *
+   * _.isObject(null);
+   * // => false
+   */
+  function isObject(value) {
+    var type = typeof value;
+    return value != null && (type == 'object' || type == 'function');
+  }
+
+  /** Used as references for various `Number` constants. */
+  var NAN = 0 / 0;
+
+  /** Used to detect bad signed hexadecimal string values. */
+  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+  /** Used to detect binary string values. */
+  var reIsBinary = /^0b[01]+$/i;
+
+  /** Used to detect octal string values. */
+  var reIsOctal = /^0o[0-7]+$/i;
+
+  /** Built-in method references without a dependency on `root`. */
+  var freeParseInt = parseInt;
+
+  /**
+   * Converts `value` to a number.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to process.
+   * @returns {number} Returns the number.
+   * @example
+   *
+   * _.toNumber(3.2);
+   * // => 3.2
+   *
+   * _.toNumber(Number.MIN_VALUE);
+   * // => 5e-324
+   *
+   * _.toNumber(Infinity);
+   * // => Infinity
+   *
+   * _.toNumber('3.2');
+   * // => 3.2
+   */
+  function toNumber(value) {
+    if (typeof value == 'number') {
+      return value;
+    }
+    if (isSymbol(value)) {
+      return NAN;
+    }
+    if (isObject(value)) {
+      var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+      value = isObject(other) ? (other + '') : other;
+    }
+    if (typeof value != 'string') {
+      return value === 0 ? value : +value;
+    }
+    value = baseTrim(value);
+    var isBinary = reIsBinary.test(value);
+    return (isBinary || reIsOctal.test(value))
+      ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+      : (reIsBadHex.test(value) ? NAN : +value);
+  }
+
+  /**
+   * Gets the timestamp of the number of milliseconds that have elapsed since
+   * the Unix epoch (1 January 1970 00:00:00 UTC).
+   *
+   * @static
+   * @memberOf _
+   * @since 2.4.0
+   * @category Date
+   * @returns {number} Returns the timestamp.
+   * @example
+   *
+   * _.defer(function(stamp) {
+   *   console.log(_.now() - stamp);
+   * }, _.now());
+   * // => Logs the number of milliseconds it took for the deferred invocation.
+   */
+  var now = function() {
+    return root$1.Date.now();
+  };
+
+  var now$1 = now;
+
+  /** Error message constants. */
+  var FUNC_ERROR_TEXT = 'Expected a function';
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeMax = Math.max,
+      nativeMin = Math.min;
+
+  /**
+   * Creates a debounced function that delays invoking `func` until after `wait`
+   * milliseconds have elapsed since the last time the debounced function was
+   * invoked. The debounced function comes with a `cancel` method to cancel
+   * delayed `func` invocations and a `flush` method to immediately invoke them.
+   * Provide `options` to indicate whether `func` should be invoked on the
+   * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
+   * with the last arguments provided to the debounced function. Subsequent
+   * calls to the debounced function return the result of the last `func`
+   * invocation.
+   *
+   * **Note:** If `leading` and `trailing` options are `true`, `func` is
+   * invoked on the trailing edge of the timeout only if the debounced function
+   * is invoked more than once during the `wait` timeout.
+   *
+   * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
+   * until to the next tick, similar to `setTimeout` with a timeout of `0`.
+   *
+   * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
+   * for details over the differences between `_.debounce` and `_.throttle`.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Function
+   * @param {Function} func The function to debounce.
+   * @param {number} [wait=0] The number of milliseconds to delay.
+   * @param {Object} [options={}] The options object.
+   * @param {boolean} [options.leading=false]
+   *  Specify invoking on the leading edge of the timeout.
+   * @param {number} [options.maxWait]
+   *  The maximum time `func` is allowed to be delayed before it's invoked.
+   * @param {boolean} [options.trailing=true]
+   *  Specify invoking on the trailing edge of the timeout.
+   * @returns {Function} Returns the new debounced function.
+   * @example
+   *
+   * // Avoid costly calculations while the window size is in flux.
+   * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
+   *
+   * // Invoke `sendMail` when clicked, debouncing subsequent calls.
+   * jQuery(element).on('click', _.debounce(sendMail, 300, {
+   *   'leading': true,
+   *   'trailing': false
+   * }));
+   *
+   * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
+   * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
+   * var source = new EventSource('/stream');
+   * jQuery(source).on('message', debounced);
+   *
+   * // Cancel the trailing debounced invocation.
+   * jQuery(window).on('popstate', debounced.cancel);
+   */
+  function debounce(func, wait, options) {
+    var lastArgs,
+        lastThis,
+        maxWait,
+        result,
+        timerId,
+        lastCallTime,
+        lastInvokeTime = 0,
+        leading = false,
+        maxing = false,
+        trailing = true;
+
+    if (typeof func != 'function') {
+      throw new TypeError(FUNC_ERROR_TEXT);
+    }
+    wait = toNumber(wait) || 0;
+    if (isObject(options)) {
+      leading = !!options.leading;
+      maxing = 'maxWait' in options;
+      maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+      trailing = 'trailing' in options ? !!options.trailing : trailing;
+    }
+
+    function invokeFunc(time) {
+      var args = lastArgs,
+          thisArg = lastThis;
+
+      lastArgs = lastThis = undefined;
+      lastInvokeTime = time;
+      result = func.apply(thisArg, args);
+      return result;
+    }
+
+    function leadingEdge(time) {
+      // Reset any `maxWait` timer.
+      lastInvokeTime = time;
+      // Start the timer for the trailing edge.
+      timerId = setTimeout(timerExpired, wait);
+      // Invoke the leading edge.
+      return leading ? invokeFunc(time) : result;
+    }
+
+    function remainingWait(time) {
+      var timeSinceLastCall = time - lastCallTime,
+          timeSinceLastInvoke = time - lastInvokeTime,
+          timeWaiting = wait - timeSinceLastCall;
+
+      return maxing
+        ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
+        : timeWaiting;
+    }
+
+    function shouldInvoke(time) {
+      var timeSinceLastCall = time - lastCallTime,
+          timeSinceLastInvoke = time - lastInvokeTime;
+
+      // Either this is the first call, activity has stopped and we're at the
+      // trailing edge, the system time has gone backwards and we're treating
+      // it as the trailing edge, or we've hit the `maxWait` limit.
+      return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
+        (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
+    }
+
+    function timerExpired() {
+      var time = now$1();
+      if (shouldInvoke(time)) {
+        return trailingEdge(time);
+      }
+      // Restart the timer.
+      timerId = setTimeout(timerExpired, remainingWait(time));
+    }
+
+    function trailingEdge(time) {
+      timerId = undefined;
+
+      // Only invoke if we have `lastArgs` which means `func` has been
+      // debounced at least once.
+      if (trailing && lastArgs) {
+        return invokeFunc(time);
+      }
+      lastArgs = lastThis = undefined;
+      return result;
+    }
+
+    function cancel() {
+      if (timerId !== undefined) {
+        clearTimeout(timerId);
+      }
+      lastInvokeTime = 0;
+      lastArgs = lastCallTime = lastThis = timerId = undefined;
+    }
+
+    function flush() {
+      return timerId === undefined ? result : trailingEdge(now$1());
+    }
+
+    function debounced() {
+      var time = now$1(),
+          isInvoking = shouldInvoke(time);
+
+      lastArgs = arguments;
+      lastThis = this;
+      lastCallTime = time;
+
+      if (isInvoking) {
+        if (timerId === undefined) {
+          return leadingEdge(lastCallTime);
+        }
+        if (maxing) {
+          // Handle invocations in a tight loop.
+          clearTimeout(timerId);
+          timerId = setTimeout(timerExpired, wait);
+          return invokeFunc(lastCallTime);
+        }
+      }
+      if (timerId === undefined) {
+        timerId = setTimeout(timerExpired, wait);
+      }
+      return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    return debounced;
+  }
+
+  var Prop = /*#__PURE__*/_createClass(function Prop(name, _ref) {
+    var _ref$default = _ref["default"],
+      defaultVal = _ref$default === void 0 ? null : _ref$default,
+      _ref$triggerUpdate = _ref.triggerUpdate,
+      triggerUpdate = _ref$triggerUpdate === void 0 ? true : _ref$triggerUpdate,
+      _ref$onChange = _ref.onChange,
+      onChange = _ref$onChange === void 0 ? function (newVal, state) {} : _ref$onChange;
+    _classCallCheck(this, Prop);
+    this.name = name;
+    this.defaultVal = defaultVal;
+    this.triggerUpdate = triggerUpdate;
+    this.onChange = onChange;
+  });
+  function index (_ref2) {
+    var _ref2$stateInit = _ref2.stateInit,
+      stateInit = _ref2$stateInit === void 0 ? function () {
+        return {};
+      } : _ref2$stateInit,
+      _ref2$props = _ref2.props,
+      rawProps = _ref2$props === void 0 ? {} : _ref2$props,
+      _ref2$methods = _ref2.methods,
+      methods = _ref2$methods === void 0 ? {} : _ref2$methods,
+      _ref2$aliases = _ref2.aliases,
+      aliases = _ref2$aliases === void 0 ? {} : _ref2$aliases,
+      _ref2$init = _ref2.init,
+      initFn = _ref2$init === void 0 ? function () {} : _ref2$init,
+      _ref2$update = _ref2.update,
+      updateFn = _ref2$update === void 0 ? function () {} : _ref2$update;
+    // Parse props into Prop instances
+    var props = Object.keys(rawProps).map(function (propName) {
+      return new Prop(propName, rawProps[propName]);
+    });
+    return function () {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      // Holds component state
+      var state = Object.assign({}, stateInit instanceof Function ? stateInit(options) : stateInit,
+      // Support plain objects for backwards compatibility
+      {
+        initialised: false
+      });
+
+      // keeps track of which props triggered an update
+      var changedProps = {};
+
+      // Component constructor
+      function comp(nodeElement) {
+        initStatic(nodeElement, options);
+        digest();
+        return comp;
+      }
+      var initStatic = function initStatic(nodeElement, options) {
+        initFn.call(comp, nodeElement, state, options);
+        state.initialised = true;
+      };
+      var digest = debounce(function () {
+        if (!state.initialised) {
+          return;
+        }
+        updateFn.call(comp, state, changedProps);
+        changedProps = {};
+      }, 1);
+
+      // Getter/setter methods
+      props.forEach(function (prop) {
+        comp[prop.name] = getSetProp(prop);
+        function getSetProp(_ref3) {
+          var prop = _ref3.name,
+            _ref3$triggerUpdate = _ref3.triggerUpdate,
+            redigest = _ref3$triggerUpdate === void 0 ? false : _ref3$triggerUpdate,
+            _ref3$onChange = _ref3.onChange,
+            onChange = _ref3$onChange === void 0 ? function (newVal, state) {} : _ref3$onChange,
+            _ref3$defaultVal = _ref3.defaultVal,
+            defaultVal = _ref3$defaultVal === void 0 ? null : _ref3$defaultVal;
+          return function (_) {
+            var curVal = state[prop];
+            if (!arguments.length) {
+              return curVal;
+            } // Getter mode
+
+            var val = _ === undefined ? defaultVal : _; // pick default if value passed is undefined
+            state[prop] = val;
+            onChange.call(comp, val, state, curVal);
+
+            // track changed props
+            !changedProps.hasOwnProperty(prop) && (changedProps[prop] = curVal);
+            if (redigest) {
+              digest();
+            }
+            return comp;
+          };
+        }
+      });
+
+      // Other methods
+      Object.keys(methods).forEach(function (methodName) {
+        comp[methodName] = function () {
+          var _methods$methodName;
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          return (_methods$methodName = methods[methodName]).call.apply(_methods$methodName, [comp, state].concat(args));
+        };
+      });
+
+      // Link aliases
+      Object.entries(aliases).forEach(function (_ref4) {
+        var _ref5 = _slicedToArray(_ref4, 2),
+          alias = _ref5[0],
+          target = _ref5[1];
+        return comp[alias] = comp[target];
+      });
+
+      // Reset all component props to their default value
+      comp.resetProps = function () {
+        props.forEach(function (prop) {
+          comp[prop.name](prop.defaultVal);
+        });
+        return comp;
+      };
+
+      //
+
+      comp.resetProps(); // Apply all prop defaults
+      state._rerender = digest; // Expose digest method
+
+      return comp;
+    };
+  }
+
+  return index;
+
+}));
+//# sourceMappingURL=kapsule.js.map
+export default TableCsv