@plurid/plurid-engine 0.0.0-17 → 0.0.0-19

package/distribution/index.mjs

@@ -0,0 +1,3432 @@
+import { defaultConfiguration, internationalization, protocols, HTTPS_PROTOCOL, HTTP_PROTOCOL, compareTypes, ROOTS_GAP, LAYOUT_TYPES, PLANE_DEFAULT_ANGLE, PLURID_ROUTER_LOCATION_CHANGED } from '@plurid/plurid-data';
+import { mathematics, objects, uuid } from '@plurid/plurid-functions';
+import themes, { THEME_NAMES } from '@plurid/plurid-themes';
+
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// source/modules/general/index.ts
+var general_exports = {};
+__export(general_exports, {
+  configuration: () => configuration_exports,
+  tree: () => tree_exports
+});
+
+// source/modules/general/configuration/index.ts
+var configuration_exports = {};
+__export(configuration_exports, {
+  definePluridConfiguration: () => definePluridConfiguration,
+  merge: () => merge
+});
+var resolveTheme = (theme, type) => {
+  if (!theme) {
+    return "plurid";
+  }
+  if (typeof theme === "string") {
+    return theme;
+  }
+  if (typeof theme !== "object") {
+    return "plurid";
+  }
+  const {
+    general,
+    interaction
+  } = theme;
+  if (type === "general" && general) {
+    return general;
+  }
+  if (type === "interaction" && interaction) {
+    return interaction;
+  }
+  return "plurid";
+};
+var merge = (configuration, target) => {
+  const targetConfiguration = {
+    ...objects.clone(defaultConfiguration),
+    ...objects.clone(target || {})
+  };
+  if (!configuration) {
+    return targetConfiguration;
+  }
+  const mergedConfiguration = objects.merge(
+    targetConfiguration,
+    configuration,
+    {
+      "global.theme": () => {
+        return {
+          general: resolveTheme(configuration.global?.theme, "general"),
+          interaction: resolveTheme(configuration.global?.theme, "interaction")
+        };
+      }
+    }
+  );
+  return mergedConfiguration;
+};
+var definePluridConfiguration = (flat = {}) => {
+  const partial = {};
+  const global = {};
+  if (flat.theme !== void 0) {
+    global.theme = flat.theme;
+  }
+  if (flat.micro !== void 0) {
+    global.micro = flat.micro;
+  }
+  if (flat.transparentUI !== void 0) {
+    global.transparentUI = flat.transparentUI;
+  }
+  if (flat.language !== void 0) {
+    global.language = flat.language;
+  }
+  if (Object.keys(global).length > 0) {
+    partial.global = global;
+  }
+  const space = {};
+  if (flat.layout !== void 0) {
+    space.layout = flat.layout;
+  }
+  if (flat.perspective !== void 0) {
+    space.perspective = flat.perspective;
+  }
+  if (flat.center !== void 0) {
+    space.center = flat.center;
+  }
+  if (flat.firstPerson !== void 0) {
+    space.firstPerson = flat.firstPerson;
+  }
+  if (flat.collaboration !== void 0) {
+    space.collaboration = flat.collaboration;
+  }
+  if (flat.undo !== void 0) {
+    space.undo = flat.undo;
+  }
+  if (flat.viewpointURLWrite !== void 0) {
+    space.viewpointURLWrite = flat.viewpointURLWrite;
+  }
+  if (flat.viewpointURLRestore !== void 0) {
+    space.viewpointURLRestore = flat.viewpointURLRestore;
+  }
+  if (flat.viewpointURLParam !== void 0) {
+    space.viewpointURLParam = flat.viewpointURLParam;
+  }
+  if (flat.viewpointURLDebounce !== void 0) {
+    space.viewpointURLDebounce = flat.viewpointURLDebounce;
+  }
+  if (flat.timings !== void 0) {
+    space.timings = flat.timings;
+  }
+  if (flat.gestures !== void 0) {
+    space.gestures = flat.gestures;
+  }
+  if (flat.shortcuts !== void 0) {
+    space.shortcuts = flat.shortcuts;
+  }
+  if (flat.transformLocks !== void 0) {
+    space.transformLocks = flat.transformLocks;
+  }
+  if (flat.opaque !== void 0) {
+    space.opaque = flat.opaque;
+  }
+  if (flat.camera !== void 0) {
+    space.camera = flat.camera;
+  }
+  if (flat.transformOrigin !== void 0) {
+    space.transformOrigin = flat.transformOrigin;
+  }
+  if (flat.transformMode !== void 0) {
+    space.transformMode = flat.transformMode;
+  }
+  if (flat.transformMultimode !== void 0) {
+    space.transformMultimode = flat.transformMultimode;
+  }
+  if (flat.transformTouch !== void 0) {
+    space.transformTouch = flat.transformTouch;
+  }
+  if (flat.cullingDistance !== void 0) {
+    space.cullingDistance = flat.cullingDistance;
+  }
+  if (flat.fadeInTime !== void 0) {
+    space.fadeInTime = flat.fadeInTime;
+  }
+  if (flat.bridgeLength !== void 0 || flat.bridgePlaneAngle !== void 0) {
+    space.bridge = {};
+    if (flat.bridgeLength !== void 0) {
+      space.bridge.length = flat.bridgeLength;
+    }
+    if (flat.bridgePlaneAngle !== void 0) {
+      space.bridge.planeAngle = flat.bridgePlaneAngle;
+    }
+  }
+  if (Object.keys(space).length > 0) {
+    partial.space = space;
+  }
+  const elements = {};
+  const plane = {};
+  if (flat.planeWidth !== void 0) {
+    plane.width = flat.planeWidth;
+  }
+  if (flat.planeOpacity !== void 0) {
+    plane.opacity = flat.planeOpacity;
+  }
+  if (flat.planeControls !== void 0) {
+    plane.controls = { show: flat.planeControls };
+  }
+  if (Object.keys(plane).length > 0) {
+    elements.plane = plane;
+  }
+  if (flat.toolbar !== void 0) {
+    elements.toolbar = { show: flat.toolbar };
+  }
+  if (flat.viewcube !== void 0) {
+    elements.viewcube = { show: flat.viewcube };
+  }
+  if (flat.minimap !== void 0) {
+    elements.minimap = { show: flat.minimap };
+  }
+  if (Object.keys(elements).length > 0) {
+    partial.elements = elements;
+  }
+  const resolved = flat.extend ? objects.merge(partial, flat.extend) : partial;
+  return merge(resolved);
+};
+
+// source/modules/general/tree/index.ts
+var tree_exports = {};
+__export(tree_exports, {
+  updateTreeByPlaneIDWithLinkCoordinates: () => updateTreeByPlaneIDWithLinkCoordinates,
+  updateTreePlane: () => updateTreePlane
+});
+var updateTreePlane = (tree, page) => {
+  const updatedTree = tree.map((treePlane) => {
+    if (treePlane.planeID === page.planeID) {
+      return {
+        ...page
+      };
+    }
+    if (treePlane.children) {
+      return {
+        ...treePlane,
+        children: updateTreePlane(treePlane.children, page)
+      };
+    }
+    return treePlane;
+  });
+  return updatedTree;
+};
+var updateTreeByPlaneIDWithLinkCoordinates = (tree, planeID, linkCoordinates) => {
+  let changed = false;
+  const updatedTree = tree.map((treePlane) => {
+    if (treePlane.planeID === planeID) {
+      changed = true;
+      return {
+        ...treePlane,
+        linkCoordinates
+      };
+    }
+    if (treePlane.children) {
+      const updatedChildren = updateTreeByPlaneIDWithLinkCoordinates(
+        treePlane.children,
+        planeID,
+        linkCoordinates
+      );
+      if (updatedChildren !== treePlane.children) {
+        changed = true;
+        return {
+          ...treePlane,
+          children: updatedChildren
+        };
+      }
+    }
+    return treePlane;
+  });
+  return changed ? updatedTree : tree;
+};
+
+// source/modules/interaction/index.ts
+var interaction_exports = {};
+__export(interaction_exports, {
+  direction: () => direction_exports,
+  matrix: () => matrix_exports,
+  quaternion: () => quaternion_exports,
+  transform: () => transform_exports
+});
+
+// source/modules/interaction/direction/index.ts
+var direction_exports = {};
+__export(direction_exports, {
+  getWheelDirection: () => getWheelDirection
+});
+var getWheelDirection = (deltas, ABSTHRESHOLD = 10, THRESHOLD = 0) => {
+  let direction = "left";
+  const wheelDeltaX = deltas.deltaX;
+  const wheelDeltaY = deltas.deltaY;
+  const absWheelDeltaX = Math.abs(wheelDeltaX);
+  const absWheelDeltaY = Math.abs(wheelDeltaY);
+  if (wheelDeltaX > THRESHOLD && absWheelDeltaY < ABSTHRESHOLD && absWheelDeltaX > absWheelDeltaY) {
+    direction = "left";
+  }
+  if (wheelDeltaX < THRESHOLD && absWheelDeltaY < ABSTHRESHOLD && absWheelDeltaX > absWheelDeltaY) {
+    direction = "right";
+  }
+  if (wheelDeltaY > THRESHOLD && absWheelDeltaX < ABSTHRESHOLD && absWheelDeltaY > absWheelDeltaX) {
+    direction = "up";
+  }
+  if (wheelDeltaY < THRESHOLD && absWheelDeltaX < ABSTHRESHOLD && absWheelDeltaY > absWheelDeltaX) {
+    direction = "down";
+  }
+  return direction;
+};
+
+// source/modules/interaction/mathematics/matrix/index.ts
+var matrix_exports = {};
+__export(matrix_exports, {
+  matrixArrayToCSSMatrix: () => matrixArrayToCSSMatrix,
+  multiplyArrayOfMatrices: () => multiplyArrayOfMatrices,
+  multiplyMatrices: () => multiplyMatrices,
+  rotateMatrix: () => rotateMatrix,
+  scaleMatrix: () => scaleMatrix,
+  translateMatrix: () => translateMatrix
+});
+
+// source/modules/interaction/mathematics/quaternion/index.ts
+var quaternion_exports = {};
+__export(quaternion_exports, {
+  computeQuaternionFromEulers: () => computeQuaternionFromEulers,
+  conjugateQuaternion: () => conjugateQuaternion,
+  degToRad: () => degToRad,
+  inverseQuaternion: () => inverseQuaternion,
+  makeQuaternion: () => makeQuaternion,
+  makeRotationMatrixFromQuaternion: () => makeRotationMatrixFromQuaternion,
+  quaternionFromAxisAngle: () => quaternionFromAxisAngle,
+  quaternionMultiply: () => quaternionMultiply,
+  radToDeg: () => radToDeg,
+  rotatePointViaQuaternion: () => rotatePointViaQuaternion,
+  zeroQuaternion: () => zeroQuaternion
+});
+var degToRad = (deg) => {
+  return deg * 0.01745329252;
+};
+var radToDeg = (rad) => {
+  return rad * 57.2957795131;
+};
+var makeQuaternion = (x, y, z, w) => {
+  return {
+    x,
+    y,
+    z,
+    w
+  };
+};
+var zeroQuaternion = () => {
+  return makeQuaternion(0, 0, 0, 0);
+};
+function inverseQuaternion(quaternion) {
+  return makeQuaternion(
+    quaternion.x,
+    quaternion.y,
+    quaternion.z,
+    -quaternion.w
+  );
+}
+function conjugateQuaternion(quaternion) {
+  return makeQuaternion(
+    -quaternion.x,
+    -quaternion.y,
+    -quaternion.z,
+    quaternion.w
+  );
+}
+function computeQuaternionFromEulers(alpha, beta, gamma, radians = true) {
+  const x = radians ? beta : degToRad(beta);
+  const y = radians ? gamma : degToRad(gamma);
+  const z = radians ? alpha : degToRad(alpha);
+  const cX = Math.cos(x / 2);
+  const cY = Math.cos(y / 2);
+  const cZ = Math.cos(z / 2);
+  const sX = Math.sin(x / 2);
+  const sY = Math.sin(y / 2);
+  const sZ = Math.sin(z / 2);
+  const xQ = sX * cY * cZ - cX * sY * sZ;
+  const yQ = cX * sY * cZ + sX * cY * sZ;
+  const zQ = cX * cY * sZ + sX * sY * cZ;
+  const wQ = cX * cY * cZ - sX * sY * sZ;
+  return makeQuaternion(xQ, yQ, zQ, wQ);
+}
+function quaternionFromAxisAngle(x, y, z, angle) {
+  const q = zeroQuaternion();
+  const halfAngle = angle / 2;
+  const sine = Math.sin(halfAngle);
+  q.x = x * sine;
+  q.y = y * sine;
+  q.z = z * sine;
+  q.w = Math.cos(halfAngle);
+  return q;
+}
+function quaternionMultiply(quaternionArray) {
+  const firstQuaternion = quaternionArray[0];
+  const valueQuaternion = {
+    ...firstQuaternion
+  };
+  for (let i = 1; i < quaternionArray.length; i++) {
+    const nextQuaternion = quaternionArray[i];
+    const w = valueQuaternion.w * nextQuaternion.w - valueQuaternion.x * nextQuaternion.x - valueQuaternion.y * nextQuaternion.y - valueQuaternion.z * nextQuaternion.z;
+    const x = valueQuaternion.x * nextQuaternion.w + valueQuaternion.w * nextQuaternion.x + valueQuaternion.y * nextQuaternion.z - valueQuaternion.z * nextQuaternion.y;
+    const y = valueQuaternion.y * nextQuaternion.w + valueQuaternion.w * nextQuaternion.y + valueQuaternion.z * nextQuaternion.x - valueQuaternion.x * nextQuaternion.z;
+    const z = valueQuaternion.z * nextQuaternion.w + valueQuaternion.w * nextQuaternion.z + valueQuaternion.x * nextQuaternion.y - valueQuaternion.y * nextQuaternion.x;
+    valueQuaternion.x = x;
+    valueQuaternion.y = y;
+    valueQuaternion.z = z;
+    valueQuaternion.w = w;
+  }
+  return valueQuaternion;
+}
+function rotatePointViaQuaternion(pointRotate, quaternion) {
+  const temporaryQuaternion = {
+    x: pointRotate[0],
+    y: pointRotate[1],
+    z: pointRotate[2],
+    w: 0
+  };
+  const rotatedPointQuaternion = quaternionMultiply([
+    quaternion,
+    temporaryQuaternion,
+    conjugateQuaternion(quaternion)
+  ]);
+  return rotatedPointQuaternion;
+}
+function makeRotationMatrixFromQuaternion(quaternion) {
+  const num = quaternion.x * 2;
+  const num2 = quaternion.y * 2;
+  const num3 = quaternion.z * 2;
+  const num4 = quaternion.x * num;
+  const num5 = quaternion.y * num2;
+  const num6 = quaternion.z * num3;
+  const num7 = quaternion.x * num2;
+  const num8 = quaternion.x * num3;
+  const num9 = quaternion.y * num3;
+  const num10 = quaternion.w * num;
+  const num11 = quaternion.w * num2;
+  const num12 = quaternion.w * num3;
+  return [
+    1 - (num5 + num6),
+    num7 - num12,
+    num8 + num11,
+    0,
+    num7 + num12,
+    1 - (num4 + num6),
+    num9 - num10,
+    0,
+    num8 - num11,
+    num9 + num10,
+    1 - (num4 + num5),
+    0,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+
+// source/modules/interaction/mathematics/matrix/index.ts
+function rotateMatrix(xAngle, yAngle, zAngle = 0) {
+  const xQuaternion = computeQuaternionFromEulers(0, xAngle, 0);
+  const yQuaternion = computeQuaternionFromEulers(0, 0, yAngle);
+  const zQuaternion = computeQuaternionFromEulers(zAngle, 0, 0);
+  const quartenionMultiplication = quaternionMultiply([
+    yQuaternion,
+    xQuaternion,
+    zQuaternion
+  ]);
+  const rotationMatrix = makeRotationMatrixFromQuaternion(
+    quartenionMultiplication
+  );
+  return rotationMatrix;
+}
+function translateMatrix(x, y, z) {
+  return [
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    x,
+    y,
+    z,
+    1
+  ];
+}
+function scaleMatrix(s) {
+  return [
+    s,
+    0,
+    0,
+    0,
+    0,
+    s,
+    0,
+    0,
+    0,
+    0,
+    s,
+    0,
+    0,
+    0,
+    0,
+    1
+  ];
+}
+function multiplyMatrices(matrixA, matrixB) {
+  const result = [];
+  const a00 = matrixA[0];
+  const a01 = matrixA[1];
+  const a02 = matrixA[2];
+  const a03 = matrixA[3];
+  const a10 = matrixA[4];
+  const a11 = matrixA[5];
+  const a12 = matrixA[6];
+  const a13 = matrixA[7];
+  const a20 = matrixA[8];
+  const a21 = matrixA[9];
+  const a22 = matrixA[10];
+  const a23 = matrixA[11];
+  const a30 = matrixA[12];
+  const a31 = matrixA[13];
+  const a32 = matrixA[14];
+  const a33 = matrixA[15];
+  let b0 = matrixB[0];
+  let b1 = matrixB[1];
+  let b2 = matrixB[2];
+  let b3 = matrixB[3];
+  result[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  result[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  result[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  result[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = matrixB[4];
+  b1 = matrixB[5];
+  b2 = matrixB[6];
+  b3 = matrixB[7];
+  result[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  result[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  result[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  result[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = matrixB[8];
+  b1 = matrixB[9];
+  b2 = matrixB[10];
+  b3 = matrixB[11];
+  result[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  result[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  result[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  result[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  b0 = matrixB[12];
+  b1 = matrixB[13];
+  b2 = matrixB[14];
+  b3 = matrixB[15];
+  result[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+  result[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+  result[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+  result[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  return result;
+}
+function multiplyArrayOfMatrices(matrices) {
+  let inputMatrix = matrices[0];
+  for (let i = 1; i < matrices.length; i++) {
+    inputMatrix = multiplyMatrices(inputMatrix, matrices[i]);
+  }
+  return inputMatrix;
+}
+function matrixArrayToCSSMatrix(array) {
+  return "matrix3d(" + array.join(",") + ")";
+}
+
+// source/modules/interaction/mathematics/transform/index.ts
+var transform_exports = {};
+__export(transform_exports, {
+  general: () => general_exports2,
+  matrix3d: () => matrix3d_exports
+});
+
+// source/modules/interaction/mathematics/transform/general/index.ts
+var general_exports2 = {};
+__export(general_exports2, {
+  arrayToMatrix: () => arrayToMatrix,
+  getInitialMatrix: () => getInitialMatrix,
+  identityMatrix: () => identityMatrix,
+  inverseMatrix: () => inverseMatrix,
+  matrix3DToMatrix: () => matrix3DToMatrix,
+  matrixToArray: () => matrixToArray,
+  matrixToCSSMatrix: () => matrixToCSSMatrix,
+  multiplyMatrices: () => multiplyMatrices2,
+  multiplyMatricesArray: () => multiplyMatricesArray,
+  rotateXMatrix: () => rotateXMatrix,
+  rotateYMatrix: () => rotateYMatrix,
+  rotateZMatrix: () => rotateZMatrix,
+  rotationMatrixFromQuaternion: () => rotationMatrixFromQuaternion,
+  scaleMatrix: () => scaleMatrix2,
+  translateMatrix: () => translateMatrix2
+});
+var getInitialMatrix = () => {
+  const matrix = [
+    [1, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 1]
+  ];
+  return matrix;
+};
+var multiplyMatrices2 = (m1, m2) => {
+  const result = [];
+  for (let i = 0; i < m1.length; i++) {
+    result[i] = [];
+    for (let j = 0; j < m2[0].length; j++) {
+      let sum = 0;
+      for (let k = 0; k < m1[0].length; k++) {
+        sum += m1[i][k] * m2[k][j];
+      }
+      result[i][j] = sum;
+    }
+  }
+  return result;
+};
+var multiplyMatricesArray = (matrices) => {
+  if (matrices.length < 2) {
+    throw new Error("invalid number of matrices");
+  }
+  const first = matrices[0];
+  let result = first;
+  for (const [index, matrix] of matrices.entries()) {
+    if (index === 0) {
+      continue;
+    }
+    result = multiplyMatrices2(
+      result,
+      matrix
+    );
+  }
+  return result;
+};
+var arrayToMatrix = (array) => {
+  const matrix = [];
+  for (let i = 0; i < array.length; i += 4) {
+    const row = [];
+    row.push(array[i]);
+    row.push(array[i + 1]);
+    row.push(array[i + 2]);
+    row.push(array[i + 3]);
+    matrix.push(row);
+  }
+  return matrix;
+};
+var matrixToArray = (matrix) => {
+  return matrix.flat();
+};
+var matrix3DToMatrix = (value) => {
+  const values = value.replace("matrix3d(", "").replace(")", "").split(",").map((val) => parseFloat(val));
+  return arrayToMatrix(values);
+};
+var rotateXMatrix = (angle) => {
+  const x = Math.cos(angle);
+  const y = -1 * Math.sin(angle);
+  const z = Math.sin(angle);
+  const m = [
+    [1, 0, 0, 0],
+    [0, x, y, 0],
+    [0, z, x, 0],
+    [0, 0, 0, 1]
+  ];
+  return m;
+};
+var rotateYMatrix = (angle) => {
+  const x = Math.cos(angle);
+  const y = -1 * Math.sin(angle);
+  const z = Math.sin(angle);
+  const m = [
+    [x, 0, z, 0],
+    [0, 1, 0, 0],
+    [y, 0, x, 0],
+    [0, 0, 0, 1]
+  ];
+  return m;
+};
+var rotateZMatrix = (angle) => {
+  const x = Math.cos(angle);
+  const y = -1 * Math.sin(angle);
+  const z = Math.sin(angle);
+  const m = [
+    [x, y, 0, 0],
+    [z, x, 0, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 1]
+  ];
+  return m;
+};
+var translateMatrix2 = (x = 0, y = 0, z = 0) => {
+  const m = [
+    [1, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 1, 0],
+    [x, y, z, 1]
+  ];
+  return m;
+};
+var scaleMatrix2 = (s) => {
+  return [
+    [s, 0, 0, 0],
+    [0, s, 0, 0],
+    [0, 0, s, 0],
+    [0, 0, 0, 1]
+  ];
+};
+function rotationMatrixFromQuaternion(quaternion) {
+  const num = quaternion.x * 2;
+  const num2 = quaternion.y * 2;
+  const num3 = quaternion.z * 2;
+  const num4 = quaternion.x * num;
+  const num5 = quaternion.y * num2;
+  const num6 = quaternion.z * num3;
+  const num7 = quaternion.x * num2;
+  const num8 = quaternion.x * num3;
+  const num9 = quaternion.y * num3;
+  const num10 = quaternion.w * num;
+  const num11 = quaternion.w * num2;
+  const num12 = quaternion.w * num3;
+  return [
+    [1 - (num5 + num6), num7 - num12, num8 + num11, 0],
+    [num7 + num12, 1 - (num4 + num6), num9 - num10, 0],
+    [num8 - num11, num9 + num10, 1 - (num4 + num5), 0],
+    [0, 0, 0, 1]
+  ];
+}
+var matrixToCSSMatrix = (matrix) => {
+  const value = matrix.flat().join(",");
+  return `matrix3d(${value})`;
+};
+var identityMatrix = () => {
+  const matrix = [
+    [1, 0, 0, 0],
+    [0, 1, 0, 0],
+    [0, 0, 1, 0],
+    [0, 0, 0, 1]
+  ];
+  return matrix;
+};
+var inverseMatrix = (matrix) => {
+  const cols = 4;
+  const rows = 4;
+  const A = matrix.map((row) => [...row]);
+  const B = identityMatrix();
+  let r;
+  let s;
+  let f;
+  let temp;
+  for (let c = 0; c < cols; c++) {
+    let ABig = Math.abs(A[c][c]);
+    let rBig = c;
+    r = c + 1;
+    while (r < rows) {
+      if (Math.abs(A[r][c]) > ABig) {
+        ABig = Math.abs(A[r][c]);
+        rBig = r;
+      }
+      r++;
+    }
+    if (ABig === 0) {
+      throw Error("Cannot calculate inverse, determinant is zero");
+    }
+    r = rBig;
+    if (r !== c) {
+      temp = A[c];
+      A[c] = A[r];
+      A[r] = temp;
+      temp = B[c];
+      B[c] = B[r];
+      B[r] = temp;
+    }
+    const Ac = A[c];
+    const Bc = B[c];
+    for (r = 0; r < rows; r++) {
+      const Ar = A[r];
+      const Br = B[r];
+      if (r !== c) {
+        if (Ar[c] !== 0) {
+          f = -Ar[c] / Ac[c];
+          for (s = c; s < cols; s++) {
+            Ar[s] = Ar[s] + f * Ac[s];
+          }
+          for (s = 0; s < cols; s++) {
+            Br[s] = Br[s] + f * Bc[s];
+          }
+        }
+      } else {
+        f = Ac[c];
+        for (s = c; s < cols; s++) {
+          Ar[s] = Ar[s] / f;
+        }
+        for (s = 0; s < cols; s++) {
+          Br[s] = Br[s] / f;
+        }
+      }
+    }
+  }
+  return B;
+};
+
+// source/modules/interaction/mathematics/transform/matrix3d/index.ts
+var matrix3d_exports = {};
+__export(matrix3d_exports, {
+  getMatrixValues: () => getMatrixValues,
+  getRotationMatrix: () => getRotationMatrix,
+  getScalationValue: () => getScalationValue,
+  getTransformRotate: () => getTransformRotate,
+  getTransformScale: () => getTransformScale,
+  getTransformTranslate: () => getTransformTranslate,
+  getTranslationMatrix: () => getTranslationMatrix,
+  setTransform: () => setTransform
+});
+function getMatrixValues(matrix3d) {
+  const matrixValues = matrix3d.split("(")[1].split(")")[0].split(",");
+  const matrixValuesInt = [];
+  for (let i = 0; i < matrixValues.length; i++) {
+    matrixValuesInt[i] = parseFloat(matrixValues[i]);
+  }
+  return matrixValuesInt;
+}
+function getRotationMatrix(matrix3d) {
+  const valuesMatrix = getMatrixValues(matrix3d);
+  const scale = getScalationValue(matrix3d);
+  if (valuesMatrix.length === 16) {
+    for (let i = 0; i < 11; i++) {
+      valuesMatrix[i] /= scale;
+    }
+  } else if (valuesMatrix.length === 6) {
+    for (let i = 0; i < 4; i++) {
+      valuesMatrix[i] /= scale;
+    }
+  }
+  const rotationMatrix = valuesMatrix;
+  return rotationMatrix;
+}
+function getTranslationMatrix(matrix3d) {
+  const valuesMatrix = getMatrixValues(matrix3d);
+  let translationMatrix;
+  if (valuesMatrix.length === 16) {
+    translationMatrix = getMatrixValues(matrix3d).slice(12, 15);
+  } else if (valuesMatrix.length === 6) {
+    translationMatrix = getMatrixValues(matrix3d).slice(4);
+  }
+  return translationMatrix;
+}
+function getScalationValue(matrix3d) {
+  const valuesMatrix = getMatrixValues(matrix3d);
+  let temp = 0;
+  let scale;
+  if (valuesMatrix.length === 16) {
+    const scaleMatrix4 = getMatrixValues(matrix3d).slice(0, 4);
+    scale = 0;
+    for (const el of scaleMatrix4) {
+      scale += parseFloat(el) * parseFloat(el);
+    }
+    scale = parseFloat(Math.sqrt(scale).toPrecision(4));
+  } else if (valuesMatrix.length === 6) {
+    temp = valuesMatrix[0] * valuesMatrix[0] + valuesMatrix[1] * valuesMatrix[1];
+    scale = parseFloat(Math.sqrt(temp).toPrecision(4));
+  }
+  return scale;
+}
+function setTransform(rotationMatrix, translationMatrix, scalationMatrix) {
+  const transformMatrix = multiplyArrayOfMatrices([
+    translationMatrix,
+    rotationMatrix,
+    scalationMatrix
+  ]);
+  return matrixArrayToCSSMatrix(transformMatrix);
+}
+function getTransformRotate(matrix3d) {
+  const pi = Math.PI;
+  const values = getRotationMatrix(matrix3d);
+  let rotateX = 0;
+  let rotateY = 0;
+  if (values.length === 6) {
+    const cosa = values[0];
+    const sina = values[1];
+    if (cosa === 1 && sina === 0) {
+      rotateX = Math.asin(sina);
+      rotateY = Math.acos(cosa);
+    }
+  }
+  if (values.length === 16) {
+    const cosaX1 = values[5];
+    const sinaX3 = values[9];
+    if (sinaX3 <= 0) {
+      rotateX = Math.acos(cosaX1);
+    }
+    if (sinaX3 > 0) {
+      rotateX = 2 * pi - Math.acos(cosaX1);
+    }
+    const cosaY1 = values[0];
+    const sinaY2 = values[2];
+    if (sinaY2 <= 0) {
+      rotateY = Math.acos(cosaY1);
+    }
+    if (sinaY2 > 0) {
+      rotateY = 2 * pi - Math.acos(cosaY1);
+    }
+    rotateX = Math.atan2(values[9], values[5]);
+    rotateY = Math.atan2(values[2], values[0]);
+  }
+  return {
+    rotateX,
+    rotateY,
+    rotateZ: 0
+  };
+}
+function getTransformTranslate(matrix3d) {
+  const values = getTranslationMatrix(matrix3d);
+  const translateX = values[0];
+  const translateY = values[1];
+  const translateZ = values[2];
+  return {
+    translateX,
+    translateY,
+    translateZ
+  };
+}
+function getTransformScale(matrix3d) {
+  const scale = getScalationValue(matrix3d);
+  return {
+    scale
+  };
+}
+var internatiolate = (lamguage, field) => {
+  return internationalization[lamguage]?.[field] ?? internationalization.english?.[field] ?? field;
+};
+var internationalization_default = internatiolate;
+
+// source/modules/planes/index.ts
+var planes_exports = {};
+__export(planes_exports, {
+  Registrar: () => object_default,
+  getPlanesRegistrar: () => getPlanesRegistrar,
+  getPluridPlaneIDByData: () => getPluridPlaneIDByData,
+  getRegisteredPlane: () => getRegisteredPlane,
+  getRegisteredPlanes: () => getRegisteredPlanes,
+  registerPlanes: () => registerPlanes,
+  resolvePluridPlaneData: () => resolvePluridPlaneData,
+  resolvePluridRoutePlaneData: () => resolvePluridRoutePlaneData
+});
+
+// source/modules/planes/logic/index.ts
+var resolvePluridPlaneData = (plane) => {
+  if (Array.isArray(plane)) {
+    const [
+      route,
+      component,
+      options
+    ] = plane;
+    return {
+      route,
+      component,
+      ...options
+    };
+  }
+  return plane;
+};
+var resolvePluridRoutePlaneData = (plane) => {
+  if (Array.isArray(plane)) {
+    const [
+      value,
+      component,
+      options
+    ] = plane;
+    return {
+      value,
+      component,
+      ...options
+    };
+  }
+  return plane;
+};
+var getPluridPlaneIDByData = (element) => {
+  if (!element) {
+    return "";
+  }
+  const parent = element.parentElement;
+  if (parent && parent.dataset.pluridPlane) {
+    return parent.dataset.pluridPlane;
+  }
+  return getPluridPlaneIDByData(parent);
+};
+
+// source/modules/routing/index.ts
+var routing_exports = {};
+__export(routing_exports, {
+  IsoMatcher: () => IsoMatcher_default,
+  RouteParser: () => Parser,
+  checkParameterLength: () => checkParameterLength,
+  checkPlaneAddressType: () => checkPlaneAddressType,
+  checkValidPath: () => checkValidPath,
+  cleanPathValue: () => cleanPathValue,
+  cleanupPath: () => cleanupPath,
+  computePlaneAddress: () => computePlaneAddress,
+  extractQuery: () => extractQuery,
+  isAbsolutePlane: () => isAbsolutePlane,
+  pluridLinkPathDivider: () => pluridLinkPathDivider,
+  removeTrailingSlash: () => removeTrailingSlash,
+  resolveRoute: () => resolveRoute,
+  stringInsertInitial: () => stringInsertInitial,
+  stringRemoveTrailing: () => stringRemoveTrailing
+});
+
+// source/modules/routing/Parser/logic.ts
+var extractPathname = (location2) => {
+  const queryIndex = location2.indexOf("?");
+  const noQueryPath = queryIndex === -1 ? location2 : location2.substring(0, queryIndex);
+  const fragmentIndex = noQueryPath.indexOf("#:~:");
+  const noFragmentPath = fragmentIndex === -1 ? noQueryPath : noQueryPath.substring(0, fragmentIndex);
+  return noFragmentPath;
+};
+var extractParametersAndMatch = (location2, route) => {
+  const routeElements = splitPath(route);
+  const parameters = [];
+  routeElements.forEach((routeElement) => {
+    if (routeElement[0] === ":") {
+      parameters.push(routeElement);
+    } else {
+      parameters.push("");
+    }
+  });
+  const {
+    locationElements,
+    comparingPath
+  } = computeComparingPath(location2, parameters);
+  if (comparingPath !== route) {
+    return {
+      match: false,
+      parameters: {},
+      elements: locationElements
+    };
+  }
+  const parametersValues = extractParametersValues(
+    parameters,
+    locationElements
+  );
+  return {
+    match: true,
+    parameters: parametersValues,
+    elements: locationElements
+  };
+};
+var extractParametersValues = (parameters, pathElements) => {
+  const parametersValues = {};
+  parameters.forEach(
+    (parameter, index) => {
+      if (parameter) {
+        const parameterKey = parameter.slice(1);
+        parametersValues[parameterKey] = pathElements[index];
+      }
+    }
+  );
+  return parametersValues;
+};
+var computeComparingPath = (path, parameters) => {
+  const pathname = extractPathname(path);
+  const locationElements = splitPath(pathname);
+  const comparingPathElements = [...locationElements];
+  for (const index of locationElements.keys()) {
+    if (parameters[index]) {
+      comparingPathElements[index] = parameters[index];
+    }
+  }
+  const comparingPath = comparingPathElements.join("/");
+  return {
+    locationElements,
+    comparingPath
+  };
+};
+var splitPath = (path) => {
+  return path.split("/").filter((i) => i !== "");
+};
+var extractQuery = (path) => {
+  const fragmentIndex = path.indexOf("#:~:");
+  const noFragmentPath = fragmentIndex === -1 ? path : path.substring(0, fragmentIndex);
+  const querySplit = noFragmentPath.split("?");
+  if (querySplit.length === 2) {
+    const queryValues = {};
+    const query = querySplit[1];
+    const params = new URLSearchParams(query);
+    for (const [id, value] of params) {
+      queryValues[id] = value;
+    }
+    return queryValues;
+  } else {
+    return {};
+  }
+};
+var extractFragments = (location2) => {
+  if (!location2) {
+    return {
+      texts: [],
+      elements: []
+    };
+  }
+  const split = location2.split("#:~:");
+  const fragmentsValues = split[1];
+  if (!fragmentsValues) {
+    return {
+      texts: [],
+      elements: []
+    };
+  }
+  const fragmentItems = fragmentsValues.split("&");
+  const textFragments = [];
+  const elementFragments = [];
+  for (const item of fragmentItems) {
+    const parsedFragment = parseFragment(item);
+    if (parsedFragment) {
+      switch (parsedFragment.type) {
+        case "text":
+          textFragments.push(parsedFragment);
+          break;
+        case "element":
+          elementFragments.push(parsedFragment);
+          break;
+      }
+    }
+  }
+  return {
+    texts: textFragments,
+    elements: elementFragments
+  };
+};
+var parseFragment = (fragment) => {
+  const fragmentData = fragment.split("=");
+  const fragmentType = fragmentData[0];
+  const fragmentValues = fragmentData[1];
+  switch (fragmentType.toLowerCase()) {
+    case "text": {
+      const textValues = fragmentValues.split(",");
+      const textStart = textValues[0];
+      const textEnd = textValues[1];
+      const textOccurence = extractOccurence(textValues[2]);
+      if (!textStart) {
+        return;
+      }
+      return {
+        type: "text",
+        start: textStart,
+        end: textEnd || "",
+        occurence: textOccurence
+      };
+    }
+    case "element": {
+      const elementValues = fragmentValues.split(",");
+      const elementID = elementValues[0];
+      const elementOccurence = extractOccurence(elementValues[1]);
+      if (!elementID) {
+        return;
+      }
+      return {
+        type: "element",
+        id: elementID,
+        occurence: elementOccurence
+      };
+    }
+  }
+  return void 0;
+};
+var extractOccurence = (occurence) => {
+  if (!occurence) {
+    return 0;
+  }
+  const occurenceMatch = occurence.match(/\[(\d*)\]/);
+  const occurenceValue = occurenceMatch ? parseInt(occurenceMatch[1]) : 0;
+  return occurenceValue;
+};
+
+// source/modules/routing/logic/general/index.ts
+var stringInsertInitial = (value, insert) => {
+  if (!value.startsWith(insert)) {
+    value = insert + value;
+  }
+  return value;
+};
+var stringRemoveTrailing = (value, trail) => {
+  if (value.endsWith(trail)) {
+    value = value.slice(0, value.length - trail.length);
+  }
+  return value;
+};
+var PATH_SEPARATOR = "/";
+var cleanupPath = (value) => {
+  value = stringInsertInitial(value, PATH_SEPARATOR);
+  value = stringRemoveTrailing(value, PATH_SEPARATOR);
+  return value;
+};
+var computePlaneAddress = (plane, route, origin = "origin") => {
+  if (origin === "origin" && typeof location !== "undefined" && location.host) {
+    origin = location.host;
+  }
+  const cleanPlane = extractPathname(plane);
+  const planeAddressType = checkPlaneAddressType(cleanPlane);
+  switch (planeAddressType) {
+    case "http":
+    case "https":
+    case "pttp":
+      return cleanPlane;
+  }
+  origin = stringRemoveTrailing(origin, "/");
+  const absolutePlane = isAbsolutePlane(plane);
+  const path = route && route !== "/" ? absolutePlane ? cleanupPath(cleanPlane) : cleanupPath(route) + cleanupPath(cleanPlane) : cleanupPath(cleanPlane);
+  const planeAddress = protocols.plurid + origin + path;
+  return planeAddress;
+};
+var isAbsolutePlane = (value) => {
+  return value[0] === "/";
+};
+var checkPlaneAddressType = (value) => {
+  value = value.toLowerCase().trim();
+  if (value.startsWith(protocols.plurid)) {
+    return "pttp";
+  }
+  if (value.startsWith(protocols.https)) {
+    return HTTPS_PROTOCOL;
+  }
+  if (value.startsWith(protocols.http)) {
+    return HTTP_PROTOCOL;
+  }
+  return "relative";
+};
+var removeTrailingSlash = (value) => {
+  if (value.endsWith("/") && value.length > 1) {
+    return value.slice(0, value.length - 1);
+  }
+  return value;
+};
+var cleanPathValue = (value) => {
+  const queryStart = value.indexOf("?");
+  if (queryStart < 0) {
+    return removeTrailingSlash(
+      value
+    );
+  }
+  return removeTrailingSlash(
+    value.substring(0, queryStart)
+  );
+};
+var checkParameterLength = (parameter, length, compareType) => {
+  const parameterLength = parameter.length;
+  switch (compareType) {
+    case compareTypes.equal:
+      return parameterLength === length;
+    case compareTypes.equalLessThan:
+      return parameterLength <= length;
+    case compareTypes.lessThan:
+      return parameterLength < length;
+    case compareTypes.equalGreaterThan:
+      return parameterLength >= length;
+    case compareTypes.greaterThan:
+      return parameterLength > length;
+    default:
+      return parameterLength <= length;
+  }
+};
+var checkValidPath = (validationParameters, parameters) => {
+  if (validationParameters) {
+    for (const [parameterKey, parameterData] of Object.entries(validationParameters)) {
+      const {
+        length,
+        lengthType,
+        startsWith,
+        endsWith,
+        includes
+      } = parameterData;
+      const paramaterValue = parameters[parameterKey];
+      if (!paramaterValue) {
+        return false;
+      }
+      if (startsWith && !paramaterValue.startsWith(startsWith)) {
+        return false;
+      }
+      if (endsWith && !paramaterValue.endsWith(endsWith)) {
+        return false;
+      }
+      if (includes && !includes.includes(paramaterValue)) {
+        return false;
+      }
+      if (length) {
+        const validLength = checkParameterLength(
+          paramaterValue,
+          length,
+          lengthType
+        );
+        if (!validLength) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+};
+
+// source/modules/utilities/index.ts
+var utilities_exports = {};
+__export(utilities_exports, {
+  cleanPathElement: () => cleanPathElement
+});
+var cleanPathElement = (path) => {
+  if (path[0] === "/") {
+    return path.slice(1);
+  }
+  return path;
+};
+
+// source/modules/routing/logic/utilities/index.ts
+var pluridLinkPathDivider = (route) => {
+  const windowProtocol = typeof window === "undefined" ? "http" : window.location.protocol.replace(":", "");
+  const windowHost = typeof window === "undefined" ? "localhost:63000" : window.location.host;
+  const split = route.split("://").filter((value) => value !== "").map((value) => cleanPathElement(value));
+  let protocol = windowProtocol;
+  const host = {
+    value: windowHost,
+    controlled: false
+  };
+  const path = {
+    value: "",
+    parameters: {},
+    query: {}
+  };
+  const space = {
+    value: "",
+    parameters: {},
+    query: {}
+  };
+  const universe = {
+    value: "",
+    parameters: {},
+    query: {}
+  };
+  const cluster = {
+    value: "",
+    parameters: {},
+    query: {}
+  };
+  const plane = {
+    value: "",
+    parameters: {},
+    query: {},
+    fragments: {
+      texts: [],
+      elements: []
+    }
+  };
+  const valid = false;
+  if (split.length === 0 || split.length > 7) {
+    const url2 = {
+      protocol: {
+        value: protocol,
+        secure: true
+      },
+      host,
+      path,
+      space,
+      universe,
+      cluster,
+      plane,
+      valid
+    };
+    return url2;
+  }
+  if (route.startsWith("/://")) {
+    const routeSplit = split.slice(1);
+    switch (routeSplit.length) {
+      case 1:
+        path.value = routeSplit[0];
+        break;
+      case 5:
+        path.value = routeSplit[0];
+        space.value = routeSplit[1];
+        universe.value = routeSplit[2];
+        cluster.value = routeSplit[3];
+        plane.value = routeSplit[4];
+        break;
+    }
+    const url2 = {
+      protocol: {
+        value: protocol,
+        secure: true
+      },
+      host,
+      path,
+      space,
+      universe,
+      cluster,
+      plane,
+      valid: true
+    };
+    return url2;
+  }
+  if (split[0] !== "http" && split[0] !== "https" && split[0] !== "chrome-extension") {
+    switch (split.length) {
+      case 1:
+        plane.value = split[0];
+        break;
+      case 2:
+        cluster.value = split[0];
+        plane.value = split[1];
+        break;
+      case 3:
+        universe.value = split[0];
+        cluster.value = split[1];
+        plane.value = split[2];
+        break;
+      case 4:
+        space.value = split[0];
+        universe.value = split[1];
+        cluster.value = split[2];
+        plane.value = split[3];
+        break;
+      case 5:
+        path.value = split[0];
+        space.value = split[1];
+        universe.value = split[2];
+        cluster.value = split[3];
+        plane.value = split[4];
+        break;
+      case 6:
+        host.value = split[0];
+        path.value = split[1];
+        space.value = split[2];
+        universe.value = split[3];
+        cluster.value = split[4];
+        plane.value = split[5];
+        break;
+      default:
+        const url2 = {
+          protocol: {
+            value: protocol,
+            secure: true
+          },
+          host,
+          path,
+          space,
+          universe,
+          cluster,
+          plane,
+          valid
+        };
+        return url2;
+    }
+  } else {
+    switch (split.length) {
+      case 3:
+        protocol = split[0];
+        host.value = split[1];
+        path.value = split[2];
+        break;
+      case 7:
+        protocol = split[0];
+        host.value = split[1];
+        path.value = split[2];
+        space.value = split[3];
+        universe.value = split[4];
+        cluster.value = split[5];
+        plane.value = split[6];
+        break;
+      default:
+        const url2 = {
+          protocol: {
+            value: protocol,
+            secure: true
+          },
+          host,
+          path,
+          space,
+          universe,
+          cluster,
+          plane,
+          valid
+        };
+        return url2;
+    }
+  }
+  const url = {
+    protocol: {
+      value: protocol,
+      secure: true
+    },
+    host,
+    path,
+    space,
+    universe,
+    cluster,
+    plane,
+    valid: true
+  };
+  return url;
+};
+var resolveRoute = (route, protocol, host) => {
+  const windowProtocol = typeof window === "undefined" ? protocol || "http" : window.location.protocol.replace(":", "");
+  const windowHost = typeof window === "undefined" ? host || "localhost:63000" : window.location.host;
+  const divisions = pluridLinkPathDivider(route);
+  const defaultPathname = typeof window !== "undefined" ? window.location.pathname === "/" ? "p" : window.location.pathname.slice(1) : divisions.path.value ? divisions.path.value : "p";
+  const protocolDivision = divisions.protocol.value || windowProtocol;
+  const hostDivision = divisions.host.value ? divisions.host : {
+    value: windowHost,
+    controlled: true
+  };
+  const path = divisions.path.value ? divisions.path : {
+    value: defaultPathname,
+    parameters: {},
+    query: {}
+  };
+  const space = divisions.space.value ? divisions.space : {
+    value: "s",
+    parameters: {},
+    query: {}
+  };
+  const universe = divisions.universe.value ? divisions.universe : {
+    value: "u",
+    parameters: {},
+    query: {}
+  };
+  const cluster = divisions.cluster.value ? divisions.cluster : {
+    value: "c",
+    parameters: {},
+    query: {}
+  };
+  const plane = divisions.plane;
+  const separator = "://";
+  if (!plane.value && route !== "/") {
+    const resolvers2 = [
+      protocolDivision,
+      hostDivision.value,
+      path.value
+    ];
+    const absoluteRoute2 = resolvers2.join(separator);
+    return {
+      protocol: protocolDivision,
+      host: hostDivision,
+      path,
+      space,
+      universe,
+      cluster,
+      plane,
+      route: absoluteRoute2
+    };
+  }
+  [
+    protocolDivision,
+    hostDivision.value,
+    path.value,
+    space.value,
+    universe.value,
+    cluster.value,
+    cleanPathElement(plane.value)
+  ];
+  return {
+    protocol: "",
+    host: "",
+    path,
+    space: "",
+    universe: "",
+    cluster: "",
+    plane: "",
+    route
+  };
+};
+
+// source/modules/routing/IsoMatcher/index.ts
+var IsoMatcher = class {
+  origin;
+  routesIndex = /* @__PURE__ */ new Map();
+  planesIndex = /* @__PURE__ */ new Map();
+  routesKeys = [];
+  planesKeys = [];
+  constructor(data, origin = "origin") {
+    if (origin === "origin" && typeof location !== "undefined" && location.host) {
+      this.origin = location.host;
+    } else {
+      this.origin = origin;
+    }
+    this.updateIndexes(
+      data.routes || [],
+      data.routePlanes || [],
+      data.planes || []
+    );
+  }
+  match(path, context = "plane") {
+    switch (context) {
+      case "plane":
+        return this.matchPlane(path);
+      case "route":
+        return this.matchRoute(path);
+    }
+  }
+  /**
+   * Dynammically update the planes and routes indexes.
+   *
+   * @param data
+   */
+  index(data) {
+    this.updateIndexes(
+      data.routes || [],
+      data.routePlanes || [],
+      data.planes || []
+    );
+  }
+  /**
+   * Clear all data.
+   *
+   */
+  clear() {
+    this.routesIndex = /* @__PURE__ */ new Map();
+    this.planesIndex = /* @__PURE__ */ new Map();
+    this.routesKeys = [];
+    this.planesKeys = [];
+  }
+  getPlanesIndex() {
+    return this.planesIndex;
+  }
+  /**
+   * Creates a common data structure able to match and route accordingly.
+   *
+   */
+  updateIndexes(routes, routePlanes, planes) {
+    this.indexPlanes(
+      planes,
+      "Plane"
+    );
+    this.indexPlanes(
+      routePlanes,
+      "RoutePlane"
+    );
+    for (const route of routes) {
+      if (route.planes) {
+        this.indexPlanes(
+          route.planes,
+          "RoutePlane",
+          route.value
+        );
+      }
+      this.routesIndex.set(
+        route.value,
+        {
+          data: {
+            ...route
+          }
+        }
+      );
+    }
+    this.routesKeys = Array.from(this.routesIndex.keys());
+    this.planesKeys = Array.from(this.planesIndex.keys());
+  }
+  indexPlanes(planes, kind, parent) {
+    for (const plane of planes) {
+      const planeData = kind === "Plane" ? resolvePluridPlaneData(plane) : resolvePluridRoutePlaneData(plane);
+      const address = computePlaneAddress(
+        kind === "Plane" ? planeData.route : planeData.value,
+        parent,
+        this.origin
+      );
+      const indexedPlane = {
+        kind,
+        data: {
+          ...planeData
+        }
+      };
+      if (parent) {
+        indexedPlane["parent"] = parent;
+      }
+      this.planesIndex.set(
+        address,
+        indexedPlane
+      );
+    }
+  }
+  matchPlane(value) {
+    const planeAddress = computePlaneAddress(
+      value,
+      void 0,
+      this.origin
+    );
+    const plane = this.planesIndex.get(planeAddress);
+    if (plane) {
+      const query = extractQuery(
+        value
+      );
+      const fragments = extractFragments(
+        value
+      );
+      const match = {
+        value: planeAddress,
+        fragments,
+        query,
+        parameters: {}
+      };
+      if (plane.kind === "Plane") {
+        const {
+          kind,
+          data,
+          parent
+        } = plane;
+        const result = {
+          kind,
+          data,
+          parent,
+          match
+        };
+        return result;
+      }
+      if (plane.kind === "RoutePlane") {
+        const {
+          kind,
+          data,
+          parent
+        } = plane;
+        const result = {
+          kind,
+          data,
+          parent,
+          match
+        };
+        return result;
+      }
+    }
+    for (const planePath of this.planesKeys) {
+      const normalizedPlanePath = planePath.replace(protocols.plurid, "");
+      const normalizedPlaneAddress = planeAddress.replace(protocols.plurid, "");
+      const planePathSplit = normalizedPlanePath.split("/");
+      const planeAddressSplit = normalizedPlaneAddress.split("/");
+      if (planePathSplit[0] !== planeAddressSplit[0]) {
+        continue;
+      }
+      if (planePathSplit.length !== planeAddressSplit.length) {
+        continue;
+      }
+      const parametersAndMatch = extractParametersAndMatch(
+        normalizedPlaneAddress,
+        normalizedPlanePath
+      );
+      if (parametersAndMatch.match) {
+        const plane2 = this.planesIndex.get(planePath);
+        if (!plane2) {
+          continue;
+        }
+        const {
+          parameters
+        } = parametersAndMatch;
+        const validPath = checkValidPath(
+          plane2.data.parameters,
+          parameters
+        );
+        if (!validPath) {
+          continue;
+        }
+        const query = extractQuery(
+          value
+        );
+        const fragments = extractFragments(
+          value
+        );
+        const match = {
+          value: planeAddress,
+          fragments,
+          query,
+          parameters
+        };
+        if (plane2.kind === "Plane") {
+          const {
+            kind,
+            data,
+            parent
+          } = plane2;
+          const result = {
+            kind,
+            data,
+            parent,
+            match
+          };
+          return result;
+        }
+        if (plane2.kind === "RoutePlane") {
+          const {
+            kind,
+            data,
+            parent
+          } = plane2;
+          const result = {
+            kind,
+            data,
+            parent,
+            match
+          };
+          return result;
+        }
+      }
+    }
+    return;
+  }
+  matchRoute(value) {
+    const routeValue = cleanPathValue(value);
+    const route = this.routesIndex.get(routeValue);
+    if (route) {
+      const query = extractQuery(
+        value
+      );
+      const result = {
+        kind: "Route",
+        data: route.data,
+        match: {
+          // value: extractPathname(value),
+          value: routeValue,
+          query,
+          parameters: {}
+        }
+      };
+      return result;
+    }
+    for (const routePath of this.routesKeys) {
+      const routeSplit = routePath.split("/");
+      const valueSplit = routeValue.split("/");
+      if (routeSplit.length !== valueSplit.length) {
+        continue;
+      }
+      const parametersAndMatch = extractParametersAndMatch(
+        routeValue.slice(1),
+        routePath.slice(1)
+      );
+      if (parametersAndMatch.match) {
+        const route2 = this.routesIndex.get(routePath);
+        if (!route2) {
+          continue;
+        }
+        const {
+          parameters
+        } = parametersAndMatch;
+        const validPath = checkValidPath(
+          route2.data.parameters,
+          parameters
+        );
+        if (!validPath) {
+          continue;
+        }
+        const query = extractQuery(
+          value
+        );
+        const match = {
+          // value: extractPathname(value),
+          value: routeValue,
+          query,
+          parameters
+        };
+        if (route2) {
+          const result = {
+            kind: "Route",
+            data: route2.data,
+            match
+          };
+          return result;
+        }
+      }
+    }
+    const routePlane = this.matchPlane(routeValue);
+    if (routePlane) {
+      const result = {
+        kind: "RoutePlane",
+        data: routePlane.data,
+        // HACK
+        match: {
+          // value: extractPathname(value),
+          value: routeValue,
+          query: routePlane.match.query,
+          parameters: routePlane.match.parameters
+        }
+      };
+      return result;
+    }
+    return;
+  }
+};
+var IsoMatcher_default = IsoMatcher;
+
+// source/modules/routing/Parser/index.ts
+var Parser = class {
+  /** properties */
+  location;
+  path;
+  options;
+  /** constructor */
+  constructor(location2, path, options) {
+    this.location = location2;
+    this.path = path;
+    this.options = this.handleOptions(options);
+  }
+  /** private */
+  handleOptions(options) {
+    const parserOptions = {
+      fragment: options?.fragment || true
+    };
+    return parserOptions;
+  }
+  extractPathname() {
+    const pathname = extractPathname(
+      this.location
+    );
+    return pathname;
+  }
+  extractParametersAndMatch() {
+    const parametersAndMatch = extractParametersAndMatch(
+      this.location,
+      this.path.value
+    );
+    return parametersAndMatch;
+  }
+  extractQuery() {
+    const query = extractQuery(
+      this.location
+    );
+    return query;
+  }
+  extractFragments() {
+    const fragments = this.options.fragment ? extractFragments(this.location) : extractFragments();
+    return fragments;
+  }
+  /** public */
+  /**
+   * Extract pathname, parameters, query, and fragment, if available.
+   */
+  extract() {
+    const pathname = this.extractPathname();
+    const {
+      match,
+      parameters,
+      elements
+    } = this.extractParametersAndMatch();
+    const query = this.extractQuery();
+    const queryData = Object.entries(query).map(([key, value]) => {
+      return key + "=" + value;
+    }).join("&");
+    const queryString = queryData ? "?" + queryData : "";
+    const fragments = this.extractFragments();
+    const parserResponse = {
+      path: this.path,
+      pathname,
+      elements,
+      match,
+      parameters,
+      query,
+      fragments,
+      route: pathname + queryString
+    };
+    return parserResponse;
+  }
+};
+
+// source/modules/planes/registrar/object.ts
+var PluridPlanesRegistrar = class {
+  isoMatcher;
+  constructor(planes, origin = "origin") {
+    this.isoMatcher = new IsoMatcher_default(
+      {
+        planes
+      },
+      origin
+    );
+  }
+  register(planes) {
+    this.isoMatcher.index({
+      planes
+    });
+  }
+  identify() {
+    const planes = this.isoMatcher.getPlanesIndex();
+    return [...planes.keys()];
+  }
+  get(route) {
+    const match = this.isoMatcher.match(route);
+    if (match) {
+      const absoluteRoute = match.kind === "Plane" ? match.data.route : match.data.value;
+      const registeredPlane = {
+        route: {
+          absolute: absoluteRoute,
+          fragments: match.match.fragments,
+          parameters: match.match.parameters,
+          query: match.match.query
+        },
+        component: match.data.component
+      };
+      return registeredPlane;
+    }
+    return;
+  }
+  getAll() {
+    const planes = this.isoMatcher.getPlanesIndex();
+    const all = /* @__PURE__ */ new Map();
+    for (const [path, plane] of planes) {
+      const absoluteRoute = plane.kind === "Plane" ? plane.data.route : plane.data.value;
+      const registeredPlane = {
+        route: {
+          absolute: absoluteRoute,
+          fragments: {
+            elements: [],
+            texts: []
+          },
+          parameters: {},
+          query: {}
+        },
+        component: plane.data.component
+      };
+      all.set(
+        path,
+        registeredPlane
+      );
+    }
+    return all;
+  }
+};
+var object_default = PluridPlanesRegistrar;
+
+// source/modules/planes/registrar/utilities.ts
+var registerPlanes = (planes, planesRegistrar, origin = "origin") => {
+  if (!planes) {
+    return;
+  }
+  if (planesRegistrar) {
+    planesRegistrar.register(planes);
+    return;
+  }
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (typeof window.__pluridPlanesRegistrar__ === "undefined") {
+    const pluridPlanesRegistrar = new object_default([], origin);
+    window.__pluridPlanesRegistrar__ = pluridPlanesRegistrar;
+    window.__pluridPlanesRegistrar__.register(planes);
+    return;
+  }
+  window.__pluridPlanesRegistrar__.register(planes);
+  return;
+};
+var getPlanesRegistrar = (planesRegistrar) => {
+  if (planesRegistrar) {
+    return planesRegistrar;
+  }
+  if (typeof window !== "undefined") {
+    if (window.__pluridPlanesRegistrar__ !== void 0) {
+      return window.__pluridPlanesRegistrar__;
+    }
+  }
+  return;
+};
+var getRegisteredPlanes = (planesRegistrar) => {
+  if (planesRegistrar) {
+    return planesRegistrar.getAll();
+  }
+  if (typeof window !== "undefined") {
+    if (window.__pluridPlanesRegistrar__ !== void 0) {
+      return window.__pluridPlanesRegistrar__.getAll();
+    }
+  }
+  return /* @__PURE__ */ new Map();
+};
+var getRegisteredPlane = (route, planesRegistrar) => {
+  if (planesRegistrar) {
+    return planesRegistrar.get(route);
+  }
+  if (typeof window !== "undefined") {
+    if (window.__pluridPlanesRegistrar__ !== void 0) {
+      return window.__pluridPlanesRegistrar__.get(route);
+    }
+  }
+  return;
+};
+
+// source/modules/space/index.ts
+var space_exports = {};
+__export(space_exports, {
+  layout: () => layout_exports,
+  location: () => location_exports,
+  tree: () => tree_exports2,
+  utilities: () => utilities_exports2,
+  view: () => view_exports
+});
+
+// source/modules/space/layout/index.ts
+var layout_exports = {};
+__export(layout_exports, {
+  computeColumnLayout: () => column_default,
+  computeFaceToFaceLayout: () => faceToFace_default,
+  computeRowLayout: () => row_default,
+  computeSheavesLayout: () => sheaves_default,
+  computeZigZagLayout: () => zigZag_default
+});
+
+// source/modules/space/location/index.ts
+var location_exports = {};
+__export(location_exports, {
+  computePath: () => computePath,
+  computePluridPlaneLocation: () => computePluridPlaneLocation,
+  recomputeChildrenLocation: () => recomputeChildrenLocation
+});
+
+// source/modules/space/utilities/index.ts
+var utilities_exports2 = {};
+__export(utilities_exports2, {
+  computeSpaceSize: () => computeSpaceSize,
+  findPage: () => findPage,
+  getTreePlaneByPlaneID: () => getTreePlaneByPlaneID,
+  splitIntoGroups: () => splitIntoGroups
+});
+var computeSpaceSize = (tree) => {
+  let width = 0;
+  let height = 0;
+  let depth = 0;
+  const topCorner = {
+    x: 0,
+    y: 0,
+    z: 0
+  };
+  tree.map((treePage) => {
+    const spaceWidth = treePage.location.translateX + treePage.width;
+    if (spaceWidth > width) {
+      width = spaceWidth;
+    }
+    const spaceHeight = treePage.location.translateY + treePage.height;
+    if (spaceHeight > height) {
+      height = spaceHeight;
+    }
+    const spaceDepth = treePage.location.translateZ;
+    if (spaceDepth > depth) {
+      depth = spaceDepth;
+    }
+  });
+  return {
+    width,
+    height,
+    depth,
+    topCorner
+  };
+};
+var findPage = (view, pages) => {
+  for (const page of pages) {
+    if (page.route === view) {
+      return page;
+    }
+  }
+  return;
+};
+var splitIntoGroups = (data, length) => {
+  const initialArray = [...data];
+  const groups = [];
+  while (initialArray.length) {
+    const group = initialArray.splice(0, length);
+    groups.push(group);
+  }
+  return groups;
+};
+var getTreePlaneByPlaneID = (tree, planeID) => {
+  let _page = null;
+  for (const page of tree) {
+    if (page.planeID === planeID) {
+      _page = page;
+    }
+    if (page.children && !_page) {
+      _page = getTreePlaneByPlaneID(page.children, planeID);
+    }
+    if (_page) {
+      break;
+    }
+  }
+  return _page;
+};
+
+// source/modules/space/location/logic.ts
+var toRadians = mathematics.geometry.toRadians;
+var computePath = (tree, planeID) => {
+  const path = [];
+  const page = getTreePlaneByPlaneID(tree, planeID);
+  if (page) {
+    path.push({ ...page });
+    let parentID = page.parentPlaneID;
+    if (!parentID) {
+      return path;
+    }
+    while (parentID) {
+      const parentPage = getTreePlaneByPlaneID(tree, parentID);
+      if (parentPage) {
+        const page2 = { ...parentPage };
+        page2.children = [];
+        path.push(page2);
+        parentID = parentPage.parentPlaneID;
+      }
+    }
+  }
+  return path.reverse();
+};
+var computePluridPlaneLocation = (linkCoordinates, treePageParent, bridgeLength = 100, linkPlaneAngle = 90) => {
+  const parentAngleRadians = toRadians(treePageParent.location.rotateY);
+  const linkPoint = {
+    x: treePageParent.location.translateX + linkCoordinates.x * Math.cos(parentAngleRadians),
+    z: treePageParent.location.translateZ - linkCoordinates.x * Math.sin(parentAngleRadians)
+  };
+  const linkAngleRadians = toRadians(linkPlaneAngle + treePageParent.location.rotateY);
+  const x = linkPoint.x + bridgeLength * Math.cos(linkAngleRadians);
+  const z = linkPoint.z - bridgeLength * Math.sin(linkAngleRadians);
+  const y = treePageParent.location.translateY + linkCoordinates.y;
+  const locationCoordinates = {
+    x,
+    y,
+    z
+  };
+  return locationCoordinates;
+};
+var recomputeChildrenLocation = (page) => {
+  if (!page.children) {
+    return [];
+  }
+  const updatedChildren = [];
+  for (const child of page.children) {
+    if (child.linkCoordinates) {
+      const location2 = computePluridPlaneLocation(
+        child.linkCoordinates,
+        page,
+        child.bridgeLength,
+        child.planeAngle
+      );
+      const updatedChild = {
+        ...child,
+        location: {
+          ...child.location,
+          translateX: location2.x,
+          translateY: location2.y,
+          translateZ: location2.z
+        }
+      };
+      const children = updatedChild.children ? recomputeChildrenLocation(updatedChild) : [];
+      const updatedChildWithChildren = {
+        ...updatedChild,
+        children
+      };
+      updatedChildren.push(updatedChildWithChildren);
+    }
+  }
+  return updatedChildren;
+};
+
+// source/modules/space/layout/column.ts
+var computeColumnLayout = (roots, columns = 1, columnLength, gap = ROOTS_GAP, configuration = defaultConfiguration) => {
+  const windowInnerWidth = typeof window === "undefined" ? 1440 : window.innerWidth;
+  const windowInnerHeight = typeof window === "undefined" ? 840 : window.innerHeight;
+  const tree = [];
+  const configurationWidth = configuration.elements.plane.width;
+  const width = mathematics.numbers.checkIntegerNonUnit(configurationWidth) ? configurationWidth : configurationWidth * windowInnerWidth;
+  const height = windowInnerHeight;
+  const gapValue = mathematics.numbers.checkIntegerNonUnit(gap) ? gap : gap * width;
+  const safeColumns = columns > 0 ? columns : 1;
+  const length = columnLength && columnLength > 0 ? columnLength : Math.ceil(roots.length / safeColumns);
+  for (const [index, root] of roots.entries()) {
+    const rowIndex = index % length;
+    const columnIndex = Math.floor(index / length);
+    const translateX = columnIndex * (width + gapValue);
+    const translateY = rowIndex * (height + gapValue);
+    const treePage = {
+      ...root,
+      location: {
+        translateX,
+        translateY,
+        translateZ: 0,
+        rotateX: 0,
+        rotateY: 0
+      }
+    };
+    const children = recomputeChildrenLocation(treePage);
+    const treePageWithChildren = {
+      ...treePage,
+      children
+    };
+    tree.push(treePageWithChildren);
+  }
+  return tree;
+};
+var column_default = computeColumnLayout;
+var computeRowLayout = (roots, rows = 1, rowLength, gap = ROOTS_GAP, configuration = defaultConfiguration) => {
+  const windowInnerWidth = typeof window === "undefined" ? 1440 : window.innerWidth;
+  const windowInnerHeight = typeof window === "undefined" ? 840 : window.innerHeight;
+  const tree = [];
+  const configurationWidth = configuration.elements.plane.width;
+  const width = mathematics.numbers.checkIntegerNonUnit(configurationWidth) ? configurationWidth : configurationWidth * windowInnerWidth;
+  const height = windowInnerHeight;
+  const gapValue = mathematics.numbers.checkIntegerNonUnit(gap) ? gap : gap * width;
+  const safeRows = rows > 0 ? rows : 1;
+  const length = rowLength && rowLength > 0 ? rowLength : Math.ceil(roots.length / safeRows);
+  for (const [index, root] of roots.entries()) {
+    const rowIndex = Math.floor(index / length);
+    const columnIndex = index % length;
+    const translateX = columnIndex * (width + gapValue);
+    const translateY = rowIndex * (height + gapValue);
+    const treePage = {
+      ...root,
+      location: {
+        translateX,
+        translateY,
+        translateZ: 0,
+        rotateX: 0,
+        rotateY: 0
+      }
+    };
+    const children = recomputeChildrenLocation(treePage);
+    const treePageWithChildren = {
+      ...treePage,
+      children
+    };
+    tree.push(treePageWithChildren);
+  }
+  return tree;
+};
+var row_default = computeRowLayout;
+var toRadians2 = mathematics.geometry.toRadians;
+var computeFaceToFaceTranslateZ = (width, angle, first) => {
+  if (first) {
+    return width * Math.sin(toRadians2(angle));
+  }
+  return 0;
+};
+var computeFaceToFaceTranslateX = (width, angle, gap, first, index) => {
+  const firstTranslateX = width * Math.cos(toRadians2(angle));
+  if (first) {
+    return firstTranslateX;
+  }
+  const value = width * (index - 1) + 2 * firstTranslateX + gap * index;
+  return value;
+};
+var computeFaceToFaceRotateY = (angle, first, last) => {
+  const rotateY = first ? angle : last ? -angle : 0;
+  return rotateY;
+};
+var computeFaceToFaceLayout = (roots, angle = 45, gap = 0, middle = 0, configuration = defaultConfiguration) => {
+  const windowInnerWidth = typeof window === "undefined" ? 1440 : window.innerWidth;
+  const windowInnerHeight = typeof window === "undefined" ? 840 : window.innerHeight;
+  const tree = [];
+  const width = mathematics.numbers.checkIntegerNonUnit(configuration.elements.plane.width) ? configuration.elements.plane.width : configuration.elements.plane.width * windowInnerWidth;
+  const height = windowInnerHeight;
+  const planeAngle = 90 - angle / 2;
+  const columns = 2 + middle;
+  const rows = splitIntoGroups(roots, columns);
+  const gapValue = mathematics.numbers.checkIntegerNonUnit(gap) ? gap : gap * width;
+  for (const [rowIndex, row] of rows.entries()) {
+    const translateY = rowIndex * (height + gapValue);
+    for (const [index, page] of row.entries()) {
+      const first = index === 0;
+      const last = index === row.length - 1;
+      const translateZ = computeFaceToFaceTranslateZ(
+        width,
+        planeAngle,
+        first
+      );
+      const translateX = computeFaceToFaceTranslateX(
+        width,
+        planeAngle,
+        gapValue,
+        first,
+        index
+      );
+      const rotateY = computeFaceToFaceRotateY(
+        planeAngle,
+        first,
+        last
+      );
+      const treePage = {
+        ...page,
+        location: {
+          translateX,
+          translateY,
+          translateZ,
+          rotateX: 0,
+          rotateY
+        }
+      };
+      const children = recomputeChildrenLocation(treePage);
+      const treePageWithChildren = {
+        ...treePage,
+        children
+      };
+      tree.push(treePageWithChildren);
+    }
+  }
+  return tree;
+};
+var faceToFace_default = computeFaceToFaceLayout;
+var computeSheavesLayout = (roots, depth = 0.3, offsetX = 0, offsetY = 0, configuration = defaultConfiguration) => {
+  const windowInnerWidth = typeof window === "undefined" ? 1440 : window.innerWidth;
+  const tree = [];
+  const width = mathematics.numbers.checkIntegerNonUnit(configuration.elements.plane.width) ? configuration.elements.plane.width : configuration.elements.plane.width * windowInnerWidth;
+  const depthStep = mathematics.numbers.checkIntegerNonUnit(depth) ? depth : depth * width;
+  for (const [index, page] of roots.entries()) {
+    const translateX = index * offsetX;
+    const translateY = index * offsetY;
+    const translateZ = -index * depthStep;
+    const treePage = {
+      ...page,
+      location: {
+        translateX,
+        translateY,
+        translateZ,
+        rotateX: 0,
+        rotateY: 0
+      }
+    };
+    const children = recomputeChildrenLocation(treePage);
+    const treePageWithChildren = {
+      ...treePage,
+      children
+    };
+    tree.push(treePageWithChildren);
+  }
+  return tree;
+};
+var sheaves_default = computeSheavesLayout;
+var computeZigZagLayout = (pages, angle = 45, configuration = defaultConfiguration) => {
+  const tree = [];
+  const singleColumnedRoots = column_default(pages, 1);
+  for (const [index, page] of singleColumnedRoots.entries()) {
+    const value = index % 2 === 0 ? 1 : -1;
+    page.location.rotateY = value * angle;
+    const children = recomputeChildrenLocation(page);
+    const treePageWithChildren = {
+      ...page,
+      children
+    };
+    tree.push(
+      { ...treePageWithChildren }
+    );
+  }
+  return tree;
+};
+var zigZag_default = computeZigZagLayout;
+
+// source/modules/space/tree/index.ts
+var tree_exports2 = {};
+__export(tree_exports2, {
+  Tree: () => Tree,
+  logic: () => logic_exports
+});
+
+// source/modules/space/tree/logic.ts
+var logic_exports = {};
+__export(logic_exports, {
+  computeSpaceTree: () => computeSpaceTree,
+  getTreePlaneByID: () => getTreePlaneByID,
+  reconcileTree: () => reconcileTree,
+  removePlaneFromTree: () => removePlaneFromTree,
+  removeRootFromTree: () => removeRootFromTree,
+  resolveViewItem: () => resolveViewItem,
+  toggleAllChildren: () => toggleAllChildren,
+  toggleChildren: () => toggleChildren,
+  togglePlaneFromTree: () => togglePlaneFromTree,
+  updatePlaneLocation: () => updatePlaneLocation,
+  updateTreePlane: () => updateTreePlane2,
+  updateTreeWithNewPage: () => updateTreeWithNewPage,
+  updateTreeWithNewPlane: () => updateTreeWithNewPlane
+});
+var resolveViewItem = (planes, view, configuration, origin = "origin", getCount) => {
+  const {
+    protocol,
+    host
+  } = configuration.network;
+  const viewData = typeof view === "string" ? view : view.plane;
+  const viewAddress = computePlaneAddress(
+    viewData,
+    void 0,
+    origin
+  );
+  const iPlanes = planes.values();
+  const pluridPlanes = [];
+  for (const iPlane of iPlanes) {
+    const plane = {
+      route: iPlane.route.absolute,
+      component: iPlane.component
+    };
+    pluridPlanes.push(plane);
+  }
+  const isoMatcher = new IsoMatcher_default(
+    {
+      planes: pluridPlanes
+    },
+    origin
+  );
+  const match = isoMatcher.match(viewData);
+  if (match) {
+    const route = match.match.value;
+    const count = getCount ? getCount() : uuid.generate();
+    const planeID = route + "@" + count;
+    const treePlane = {
+      sourceID: route,
+      planeID,
+      // route: resolvedView.route,
+      route: viewAddress,
+      routeDivisions: {
+        protocol: {
+          value: "",
+          secure: false
+        },
+        host: {
+          value: host,
+          controlled: true
+        },
+        path: {
+          parameters: {},
+          query: {},
+          value: ""
+        },
+        space: {
+          parameters: {},
+          query: {},
+          value: ""
+        },
+        universe: {
+          parameters: {},
+          query: {},
+          value: ""
+        },
+        cluster: {
+          parameters: {},
+          query: {},
+          value: ""
+        },
+        plane: {
+          parameters: {},
+          fragments: {
+            elements: [],
+            texts: []
+          },
+          query: {},
+          value: ""
+        },
+        valid: true
+      },
+      height: 0,
+      width: 0,
+      location: {
+        translateX: 0,
+        translateY: 0,
+        translateZ: 0,
+        rotateX: 0,
+        rotateY: 0
+      },
+      show: true
+    };
+    return treePlane;
+  }
+  return;
+};
+var computeSpaceTree = (planes, view, configuration, layout, origin = "origin", getCount) => {
+  const treePlanes = [];
+  for (const viewItem of view) {
+    const treePlane = resolveViewItem(
+      planes,
+      viewItem,
+      configuration,
+      origin,
+      getCount
+    );
+    if (treePlane) {
+      treePlanes.push(treePlane);
+    }
+  }
+  if (!layout) {
+    const layoutlessTreePlanes = treePlanes.map((plane) => {
+      return {
+        ...plane,
+        location: {
+          rotateX: 0,
+          rotateY: 0,
+          translateX: 0,
+          translateY: 0,
+          translateZ: 0
+        }
+      };
+    });
+    return layoutlessTreePlanes;
+  }
+  switch (configuration.space.layout.type) {
+    case LAYOUT_TYPES.COLUMNS: {
+      const {
+        columns,
+        columnLength,
+        gap
+      } = configuration.space.layout;
+      const columnLayoutTree = column_default(
+        treePlanes,
+        columns,
+        columnLength,
+        gap,
+        configuration
+      );
+      return columnLayoutTree;
+    }
+    case LAYOUT_TYPES.ROWS: {
+      const {
+        rows,
+        rowLength,
+        gap
+      } = configuration.space.layout;
+      const rowLayoutTree = row_default(
+        treePlanes,
+        rows,
+        rowLength,
+        gap,
+        configuration
+      );
+      return rowLayoutTree;
+    }
+    case LAYOUT_TYPES.ZIG_ZAG: {
+      const {
+        angle
+      } = configuration.space.layout;
+      const zigzagLayoutTree = zigZag_default(
+        treePlanes,
+        angle,
+        configuration
+      );
+      return zigzagLayoutTree;
+    }
+    case LAYOUT_TYPES.FACE_TO_FACE: {
+      const {
+        angle,
+        gap,
+        middle
+      } = configuration.space.layout;
+      const faceToFaceLayoutTree = faceToFace_default(
+        treePlanes,
+        angle,
+        gap,
+        middle,
+        configuration
+      );
+      return faceToFaceLayoutTree;
+    }
+    case LAYOUT_TYPES.SHEAVES: {
+      const {
+        depth,
+        offsetX,
+        offsetY
+      } = configuration.space.layout;
+      const sheavesLayoutTree = sheaves_default(
+        treePlanes,
+        depth,
+        offsetX,
+        offsetY,
+        configuration
+      );
+      return sheavesLayoutTree;
+    }
+    case LAYOUT_TYPES.META: {
+      return [];
+    }
+    default:
+      return [];
+  }
+};
+var updateTreePlane2 = (tree, updatedPlane) => {
+  let changed = false;
+  const mapped = tree.map((treePlane) => {
+    if (treePlane.planeID === updatedPlane.planeID) {
+      changed = true;
+      return updatedPlane;
+    }
+    if (treePlane.children) {
+      const newChildren = updateTreePlane2(
+        treePlane.children,
+        updatedPlane
+      );
+      if (newChildren !== treePlane.children) {
+        changed = true;
+        return {
+          ...treePlane,
+          children: newChildren
+        };
+      }
+    }
+    return treePlane;
+  });
+  return changed ? mapped : tree;
+};
+var updateTreeWithNewPlane = (planeRoute, parentPlaneID, linkCoordinates, tree, planesRegistry, configuration, hostname = "origin") => {
+  const parentPlane = getTreePlaneByPlaneID(tree, parentPlaneID);
+  if (!parentPlane) {
+    return {
+      pluridPlaneID: "",
+      updatedTree: tree
+    };
+  }
+  const location2 = computePluridPlaneLocation(
+    linkCoordinates,
+    parentPlane,
+    // Couple the parent→child GAP to the same configured length the bridge renders at,
+    // otherwise the bridge visual (width) overshoots/undershoots the actual gap.
+    configuration.space.bridge?.length ?? 100
+  );
+  const treePlane = resolveViewItem(
+    planesRegistry,
+    planeRoute,
+    configuration,
+    hostname
+  );
+  if (!treePlane) {
+    return {
+      pluridPlaneID: "",
+      updatedTree: tree
+    };
+  }
+  const updatedTreePlane = {
+    ...treePlane,
+    parentPlaneID,
+    location: {
+      translateX: location2.x,
+      translateY: location2.y,
+      translateZ: location2.z,
+      rotateX: 0,
+      rotateY: parentPlane.location.rotateY + PLANE_DEFAULT_ANGLE
+    },
+    // Configurable bridge geometry (defaults preserve the original 100 / 90).
+    bridgeLength: configuration.space.bridge?.length ?? 100,
+    planeAngle: configuration.space.bridge?.planeAngle ?? 90,
+    linkCoordinates
+  };
+  const updatedParentPlane = {
+    ...parentPlane,
+    children: parentPlane.children ? [...parentPlane.children, updatedTreePlane] : [updatedTreePlane]
+  };
+  const updatedTree = updateTreePlane2(tree, updatedParentPlane);
+  return {
+    pluridPlaneID: updatedTreePlane.planeID,
+    updatedTree,
+    updatedTreePlane
+  };
+};
+var updatePlaneLocation = (tree, parentPlaneID, planeID, linkCoordinates) => {
+  const parentPlane = getTreePlaneByPlaneID(tree, parentPlaneID);
+  const plane = getTreePlaneByPlaneID(tree, planeID);
+  if (!parentPlane || !plane) {
+    return tree;
+  }
+  const location2 = computePluridPlaneLocation(
+    linkCoordinates,
+    parentPlane,
+    // Use the plane's STORED bridge geometry (set at spawn from config), otherwise this
+    // recompute resets the gap to the default 100 and the bridge visual overshoots.
+    plane.bridgeLength,
+    plane.planeAngle
+  );
+  const updatedPlane = {
+    ...plane,
+    location: {
+      translateX: location2.x,
+      translateY: location2.y,
+      translateZ: location2.z,
+      rotateX: 0,
+      rotateY: parentPlane.location.rotateY + PLANE_DEFAULT_ANGLE
+    }
+  };
+  const updatedTree = updateTreePlane2(
+    tree,
+    updatedPlane
+  );
+  return updatedTree;
+};
+var updateTreeWithNewPage = (tree, treePageParentPlaneID, pagePath, pageID, linkCoordinates, parameters) => {
+  const treePageParent = getTreePlaneByPlaneID(tree, treePageParentPlaneID);
+  if (treePageParent) {
+    const location2 = computePluridPlaneLocation(
+      linkCoordinates,
+      treePageParent
+    );
+    const planeID = uuid.generate();
+    const newTreePlane = {
+      sourceID: pageID,
+      route: pagePath,
+      routeDivisions: {
+        protocol: {
+          value: "",
+          secure: false
+        },
+        host: {
+          value: "",
+          controlled: false
+        },
+        path: {
+          value: "",
+          parameters: {},
+          query: {}
+        },
+        space: {
+          value: "",
+          parameters: {},
+          query: {}
+        },
+        universe: {
+          value: "",
+          parameters: {},
+          query: {}
+        },
+        cluster: {
+          value: "",
+          parameters: {},
+          query: {}
+        },
+        plane: {
+          value: "",
+          parameters: {},
+          query: {},
+          fragments: {
+            texts: [],
+            elements: []
+          }
+        },
+        valid: false
+      },
+      // parameters: extractedParameters,
+      // parameters: {},
+      planeID,
+      width: 0,
+      height: 0,
+      parentPlaneID: treePageParentPlaneID,
+      location: {
+        translateX: location2.x,
+        translateY: location2.y,
+        translateZ: location2.z,
+        rotateX: 0,
+        rotateY: treePageParent.location.rotateY + PLANE_DEFAULT_ANGLE
+      },
+      show: true,
+      bridgeLength: 100,
+      planeAngle: 90,
+      linkCoordinates
+    };
+    const updatedTreePlaneParent = {
+      ...treePageParent,
+      children: treePageParent.children ? [...treePageParent.children, newTreePlane] : [newTreePlane]
+    };
+    const updatedTree = updateTreePlane2(tree, updatedTreePlaneParent);
+    return {
+      pluridPlaneID: planeID,
+      updatedTree
+    };
+  }
+  return {
+    pluridPlaneID: "",
+    updatedTree: tree
+  };
+};
+var toggleChildren = (children) => {
+  const updatedChildren = children.map((child) => {
+    if (child.children) {
+      const updatedChild2 = {
+        ...child,
+        show: !child.show,
+        children: toggleChildren(child.children)
+      };
+      return updatedChild2;
+    }
+    const updatedChild = {
+      ...child,
+      show: !child.show
+    };
+    return updatedChild;
+  });
+  return updatedChildren;
+};
+var toggleAllChildren = (tree, show) => {
+  return tree.map((plane) => ({
+    ...plane,
+    show,
+    children: plane.children ? toggleAllChildren(plane.children, show) : plane.children
+  }));
+};
+var togglePlaneFromTree = (tree, pluridPlaneID, forceShow) => {
+  const updatedTree = [];
+  let updatedPlane;
+  for (const plane of tree) {
+    if (plane.planeID === pluridPlaneID) {
+      const show = forceShow ?? !plane.show;
+      const treeUpdatedPlane = {
+        ...plane,
+        show
+      };
+      if (treeUpdatedPlane.children) {
+        const children = toggleAllChildren(
+          treeUpdatedPlane.children,
+          show
+        );
+        treeUpdatedPlane.children = children;
+      }
+      updatedTree.push(treeUpdatedPlane);
+      updatedPlane = {
+        ...treeUpdatedPlane
+      };
+      continue;
+    }
+    if (plane.children) {
+      const {
+        updatedTree: childrenUpdatedTree,
+        updatedPlane: childrenUpdatedPlane
+      } = togglePlaneFromTree(
+        plane.children,
+        pluridPlaneID,
+        forceShow
+      );
+      updatedTree.push({
+        ...plane,
+        children: [...childrenUpdatedTree]
+      });
+      if (childrenUpdatedPlane) {
+        updatedPlane = {
+          ...childrenUpdatedPlane
+        };
+      }
+      continue;
+    }
+    updatedTree.push(plane);
+  }
+  return {
+    updatedTree,
+    updatedPlane
+  };
+};
+var getTreePlaneByID = (stateTree, id) => {
+  if (!id) {
+    return;
+  }
+  for (const plane of stateTree) {
+    if (plane.planeID === id) {
+      return plane;
+    }
+    if (plane.children) {
+      const found = getTreePlaneByID(
+        plane.children,
+        id
+      );
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return;
+};
+var removeRootFromTree = (tree, pluridPlaneID) => {
+  const updatedTree = tree.filter((plane) => plane.planeID !== pluridPlaneID);
+  return {
+    updatedTree
+  };
+};
+var removePlaneFromTree = (tree, pluridPlaneID) => {
+  let changed = false;
+  const updatedTree = [];
+  for (const plane of tree) {
+    if (plane.planeID === pluridPlaneID) {
+      changed = true;
+      continue;
+    }
+    if (plane.children) {
+      const children = removePlaneFromTree(
+        plane.children,
+        pluridPlaneID
+      );
+      if (children !== plane.children) {
+        changed = true;
+        updatedTree.push({ ...plane, children });
+        continue;
+      }
+    }
+    updatedTree.push(plane);
+  }
+  return changed ? updatedTree : tree;
+};
+var carriedDimension = (next, previous) => !next && previous ? previous : next;
+var sameLocation = (a, b) => a.translateX === b.translateX && a.translateY === b.translateY && a.translateZ === b.translateZ && a.rotateX === b.rotateX && a.rotateY === b.rotateY;
+var sameNodeOwnFieldsExceptLocation = (a, b) => a.sourceID === b.sourceID && a.planeID === b.planeID && a.parentPlaneID === b.parentPlaneID && a.route === b.route && a.show === b.show && a.bridgeLength === b.bridgeLength && a.planeAngle === b.planeAngle;
+var sameNodeOwnFields = (a, b) => sameNodeOwnFieldsExceptLocation(a, b) && sameLocation(a.location, b.location);
+function reconcileNodeList(previous, next) {
+  if (!previous || previous.length === 0) {
+    return next;
+  }
+  const previousByID = /* @__PURE__ */ new Map();
+  for (const node of previous) {
+    if (node.planeID) {
+      previousByID.set(node.planeID, node);
+    }
+  }
+  let everyReused = previous.length === next.length;
+  const reconciled = next.map((nextNode, index) => {
+    const previousNode = nextNode.planeID && previousByID.get(nextNode.planeID) || previous[index];
+    const result = reconcileNode(previousNode, nextNode);
+    if (result !== previous[index]) {
+      everyReused = false;
+    }
+    return result;
+  });
+  return everyReused ? previous : reconciled;
+}
+function reconcileNode(previous, next) {
+  if (!previous || previous === next) {
+    return next;
+  }
+  let children = next.children;
+  if (next.children && next.children.length > 0) {
+    children = reconcileNodeList(previous.children, next.children);
+  } else if ((!next.children || next.children.length === 0) && previous.children && previous.children.length === 0) {
+    children = previous.children;
+  }
+  const width = carriedDimension(next.width, previous.width);
+  const height = carriedDimension(next.height, previous.height);
+  const pinned = previous.manuallyPositioned === true;
+  const location2 = pinned ? previous.location : next.location;
+  const manuallyPositioned = pinned ? true : next.manuallyPositioned;
+  const ownUnchanged = pinned ? sameNodeOwnFieldsExceptLocation(previous, next) : sameNodeOwnFields(previous, next);
+  const unchanged = ownUnchanged && children === previous.children && width === previous.width && height === previous.height && manuallyPositioned === previous.manuallyPositioned;
+  if (unchanged) {
+    return previous;
+  }
+  if (children !== next.children || width !== next.width || height !== next.height || location2 !== next.location || manuallyPositioned !== next.manuallyPositioned) {
+    return {
+      ...next,
+      width,
+      height,
+      children,
+      location: location2,
+      manuallyPositioned
+    };
+  }
+  return next;
+}
+var reconcileTree = (previousTree, nextTree) => {
+  if (!previousTree || previousTree === nextTree) {
+    return nextTree;
+  }
+  return reconcileNodeList(previousTree, nextTree);
+};
+
+// source/modules/space/tree/object.ts
+var Tree = class {
+  data;
+  origin;
+  count = 0;
+  constructor(data, origin = "origin") {
+    this.data = data;
+    this.origin = origin;
+  }
+  compute() {
+    const {
+      planes,
+      view,
+      configuration,
+      layout
+    } = this.data;
+    return computeSpaceTree(
+      planes,
+      view,
+      configuration,
+      layout,
+      this.origin,
+      this.getCount.bind(this)
+    );
+  }
+  getCount() {
+    return this.count++;
+  }
+};
+
+// source/modules/space/view/index.ts
+var view_exports = {};
+__export(view_exports, {
+  checkPageInView: () => checkPageInView,
+  computeCulledView: () => computeCulledView,
+  computeViewTree: () => computeViewTree
+});
+
+// source/modules/space/view/logic.ts
+var computeViewTree = (pages, view) => {
+  const viewTree = [];
+  for (const pageView of view) {
+    const page = pages.find((p) => p.route === pageView);
+    if (page) {
+      viewTree.push(page);
+    }
+  }
+  return viewTree;
+};
+var computeCulledView = (pages, view, location2, radius = 8e3) => {
+  const culledView = [];
+  for (const viewPage of view) {
+    const path = typeof viewPage === "string" ? viewPage : viewPage.plane;
+    const page = findPage(
+      path,
+      pages
+    );
+    if (!page) {
+      return;
+    }
+    const pageInView = checkPageInView(
+      page,
+      location2,
+      radius
+    );
+    if (pageInView) {
+      culledView.push(
+        page.route
+      );
+    }
+  }
+  return culledView;
+};
+var checkPageInView = (page, location2, radius) => {
+  const radiusLeft = location2.translationX < 0 ? Math.abs(location2.translationX) - radius : -1 * location2.translationX - radius;
+  const radiusRight = location2.translationX < 0 ? Math.abs(location2.translationX) + radius : -1 * location2.translationX + radius;
+  const locationX = page.location.translateX;
+  const radiusTop = location2.translationY < 0 ? Math.abs(location2.translationY) - radius : -1 * location2.translationY - radius;
+  const radiusBottom = location2.translationY < 0 ? Math.abs(location2.translationY) + radius : -1 * location2.translationY + radius;
+  const locationY = page.location.translateY;
+  const inViewOnX = radiusLeft <= locationX && locationX <= radiusRight;
+  const inViewOnY = radiusTop <= locationY && locationY <= radiusBottom;
+  if (inViewOnX && inViewOnY) {
+    return true;
+  }
+  return false;
+};
+
+// source/modules/state/index.ts
+var state_exports = {};
+__export(state_exports, {
+  compute: () => compute_default,
+  local: () => local_exports
+});
+
+// source/modules/state/compute/space/index.ts
+var resolveSpace = (view, configuration, planesRegistrar, currentState, localState, precomputedState, contextState, hostname = "origin") => {
+  const registeredPlanes = getRegisteredPlanes(planesRegistrar);
+  const spaceTree = new tree_exports2.Tree(
+    {
+      planes: registeredPlanes,
+      configuration,
+      view
+    },
+    hostname
+  );
+  const computedTree = spaceTree.compute();
+  const stateSpace = {
+    loading: true,
+    resolvedLayout: false,
+    animatedTransform: false,
+    transformTime: 450,
+    scale: 1,
+    rotationX: 0,
+    rotationY: 0,
+    translationX: 0,
+    translationY: 0,
+    translationZ: 0,
+    transform: "matrix3d(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1)",
+    activeUniverseID: "",
+    camera: {
+      x: 0,
+      y: 0,
+      z: 0
+    },
+    viewSize: {
+      width: 771,
+      height: 764
+    },
+    spaceSize: {
+      width: 771,
+      height: 764,
+      depth: 0,
+      topCorner: {
+        x: 0,
+        y: 0,
+        z: 0
+      }
+    },
+    culledView: [],
+    activePlaneID: "",
+    isolatePlane: "",
+    lastClosedPlane: "",
+    selectedPlaneIDs: [],
+    draggingSelection: false,
+    tree: computedTree,
+    links: [],
+    ...precomputedState?.space,
+    ...contextState?.space,
+    ...localState?.space,
+    ...currentState?.space,
+    view
+  };
+  if (currentState) {
+    stateSpace.translationX = currentState.space.translationX;
+    stateSpace.translationY = currentState.space.translationY;
+    stateSpace.translationZ = currentState.space.translationZ;
+    stateSpace.rotationX = currentState.space.rotationX;
+    stateSpace.rotationY = currentState.space.rotationY;
+    stateSpace.scale = currentState.space.scale;
+  }
+  if (localState && !currentState) {
+    stateSpace.translationX = localState.space.translationX;
+    stateSpace.translationY = localState.space.translationY;
+    stateSpace.translationZ = localState.space.translationZ;
+    stateSpace.rotationX = localState.space.rotationX;
+    stateSpace.rotationY = localState.space.rotationY;
+    stateSpace.scale = localState.space.scale;
+  }
+  return stateSpace;
+};
+var resolveThemes = (configuration, precomputedState) => {
+  let generalTheme;
+  let interactionTheme;
+  if (typeof configuration.global.theme === "object") {
+    const {
+      general,
+      interaction
+    } = configuration.global.theme;
+    if (typeof general === "string") {
+      if (Object.keys(THEME_NAMES).includes(general)) {
+        generalTheme = themes[general];
+      }
+    }
+    if (typeof interaction === "string") {
+      if (Object.keys(THEME_NAMES).includes(interaction)) {
+        interactionTheme = themes[interaction];
+      }
+    }
+  } else {
+    if (Object.keys(THEME_NAMES).includes(configuration.global.theme)) {
+      generalTheme = themes[configuration.global.theme];
+      interactionTheme = themes[configuration.global.theme];
+    }
+  }
+  const stateThemes = {
+    general: generalTheme || themes.plurid,
+    interaction: interactionTheme || themes.plurid,
+    ...precomputedState?.themes
+  };
+  return stateThemes;
+};
+
+// source/modules/state/compute/index.ts
+var compute = (view, configuration, planesRegistrar, currentState, localState, precomputedState, contextState, hostname = "origin") => {
+  let stateConfiguration = configuration_exports.merge(configuration);
+  const configurations = [
+    precomputedState?.configuration,
+    contextState?.configuration,
+    localState?.configuration,
+    currentState?.configuration
+  ];
+  for (const layer of configurations) {
+    if (layer) {
+      stateConfiguration = configuration_exports.merge(layer, stateConfiguration);
+    }
+  }
+  const stateSpace = resolveSpace(
+    view,
+    stateConfiguration,
+    planesRegistrar,
+    currentState,
+    localState,
+    precomputedState,
+    contextState,
+    hostname
+  );
+  const stateThemes = resolveThemes(
+    stateConfiguration,
+    precomputedState
+  );
+  const state = {
+    configuration: {
+      ...stateConfiguration
+    },
+    shortcuts: {
+      global: true,
+      ...precomputedState?.shortcuts
+    },
+    space: {
+      ...stateSpace
+    },
+    themes: {
+      ...stateThemes
+    },
+    ui: {
+      toolbarScrollPosition: 0,
+      ...precomputedState?.ui,
+      ...contextState?.ui
+    }
+  };
+  return state;
+};
+var compute_default = compute;
+
+// source/modules/state/local/index.ts
+var local_exports = {};
+__export(local_exports, {
+  load: () => load,
+  loadContent: () => loadContent,
+  save: () => save,
+  saveContent: () => saveContent,
+  serialize: () => serialize
+});
+var PERSISTED_STATE_VERSION = 2;
+var STORAGE_PREFIX = "pluridState-";
+var serializeFailureWarned = false;
+var PERSISTED_SPACE_FIELDS = [
+  "rotationX",
+  "rotationY",
+  "scale",
+  "translationX",
+  "translationY",
+  "translationZ",
+  "transform",
+  "camera",
+  "activePlaneID",
+  "isolatePlane",
+  "lastClosedPlane",
+  "tree",
+  "links"
+];
+var storageKey = (id) => STORAGE_PREFIX + (id || "default");
+var localStorageAdapter = () => {
+  if (typeof localStorage === "undefined") {
+    return void 0;
+  }
+  return {
+    getItem: (key) => localStorage.getItem(key),
+    setItem: (key, value) => {
+      localStorage.setItem(key, value);
+    },
+    removeItem: (key) => {
+      localStorage.removeItem(key);
+    }
+  };
+};
+var resolveAdapter = (adapter) => adapter || localStorageAdapter();
+var serialize = (state) => {
+  const space = {};
+  for (const field of PERSISTED_SPACE_FIELDS) {
+    const value = state.space[field];
+    if (value !== void 0) {
+      space[field] = value;
+    }
+  }
+  const snapshot = {
+    version: PERSISTED_STATE_VERSION,
+    space
+  };
+  return JSON.stringify(snapshot);
+};
+var save = (id, state, adapter) => {
+  const store = resolveAdapter(adapter);
+  if (!state || !store) {
+    return;
+  }
+  let serialized;
+  try {
+    serialized = serialize(state);
+  } catch (error) {
+    if (!serializeFailureWarned && typeof console !== "undefined") {
+      serializeFailureWarned = true;
+      console.warn(
+        "[plurid] state persistence skipped \u2014 could not serialize the space snapshot. A non-serializable value (cycle, DOM node, or function) is in the persisted fields. Persistence is disabled until it is removed.",
+        error
+      );
+    }
+    return;
+  }
+  try {
+    store.setItem(
+      storageKey(id),
+      serialized
+    );
+  } catch (_error) {
+  }
+};
+var load = (id, useLocalStorage, adapter) => {
+  if (!useLocalStorage) {
+    return;
+  }
+  const store = resolveAdapter(adapter);
+  if (!store) {
+    return;
+  }
+  try {
+    const stateData = store.getItem(storageKey(id));
+    if (!stateData) {
+      return;
+    }
+    const snapshot = JSON.parse(stateData);
+    if (!snapshot || snapshot.version !== PERSISTED_STATE_VERSION) {
+      return;
+    }
+    if (!snapshot.space) {
+      return;
+    }
+    return { space: snapshot.space };
+  } catch (_error) {
+    return;
+  }
+};
+var CONTENT_PREFIX = "pluridContent-";
+var contentKey = (id) => CONTENT_PREFIX + (id || "default");
+var saveContent = (id, content, adapter) => {
+  const store = resolveAdapter(adapter);
+  if (content === void 0 || !store) {
+    return;
+  }
+  try {
+    store.setItem(
+      contentKey(id),
+      JSON.stringify(content)
+    );
+  } catch (_error) {
+  }
+};
+var loadContent = (id, adapter) => {
+  const store = resolveAdapter(adapter);
+  if (!store) {
+    return void 0;
+  }
+  try {
+    const raw = store.getItem(contentKey(id));
+    if (!raw) {
+      return void 0;
+    }
+    return JSON.parse(raw);
+  } catch (_error) {
+    return void 0;
+  }
+};
+
+// source/functions/template/index.ts
+var cleanTemplate = (template) => {
+  return template.replace(/(?:\r\n|\r|\n)/g, " ").replace(/  +/g, " ").trim();
+};
+var pluridRouterNavigate = (path) => {
+  if (typeof CustomEvent === "undefined" || typeof window === "undefined") {
+    return;
+  }
+  const event = new CustomEvent(
+    PLURID_ROUTER_LOCATION_CHANGED,
+    {
+      detail: {
+        path
+      }
+    }
+  );
+  window.dispatchEvent(event);
+};
+
+export { IsoMatcher_default as IsoMatcher, Parser as RouteParser, cleanTemplate, definePluridConfiguration, general_exports as general, interaction_exports as interaction, internationalization_default as internatiolate, planes_exports as planes, pluridRouterNavigate, routing_exports as routing, space_exports as space, state_exports as state, utilities_exports as utilities };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map