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

package/distribution/index.es.js

@@ -1,2829 +0,0 @@
-import { defaultConfiguration, protocols, HTTPS_PROTOCOL, HTTP_PROTOCOL, compareTypes, internationalization, ROOTS_GAP, LAYOUT_TYPES, PLANE_DEFAULT_ANGLE, PLURID_ROUTER_LOCATION_CHANGED } from "@plurid/plurid-data";
-
-import { objects, mathematics, uuid } from "@plurid/plurid-functions";
-
-import themes, { THEME_NAMES } from "@plurid/plurid-themes";
-
-const resolveTheme = (theme, type) => {
-    if (!theme) {
-        return "plurid";
-    }
-    if (typeof theme === "string") {
-        return theme;
-    }
-    if (typeof theme !== "object") {
-        return "plurid";
-    }
-    const {general: general, interaction: interaction} = theme;
-    if (type === "general" && general) {
-        return general;
-    }
-    if (type === "interaction" && interaction) {
-        return interaction;
-    }
-    return "plurid";
-};
-
-const merge = (configuration, target) => {
-    const targetConfiguration = Object.assign(Object.assign({}, objects.clone(defaultConfiguration)), objects.clone(target || {}));
-    if (!configuration) {
-        return targetConfiguration;
-    }
-    const mergedConfiguration = objects.merge(targetConfiguration, configuration, {
-        "global.theme": () => {
-            var _a, _b;
-            return {
-                general: resolveTheme((_a = configuration.global) === null || _a === void 0 ? void 0 : _a.theme, "general"),
-                interaction: resolveTheme((_b = configuration.global) === null || _b === void 0 ? void 0 : _b.theme, "interaction")
-            };
-        }
-    });
-    return mergedConfiguration;
-};
-
-var index$k = Object.freeze({
-    __proto__: null,
-    merge: merge
-});
-
-const extractPathname = location => {
-    const queryIndex = location.indexOf("?");
-    const noQueryPath = queryIndex === -1 ? location : location.substring(0, queryIndex);
-    const fragmentIndex = noQueryPath.indexOf("#:~:");
-    const noFragmentPath = fragmentIndex === -1 ? noQueryPath : noQueryPath.substring(0, fragmentIndex);
-    return noFragmentPath;
-};
-
-const extractParametersAndMatch = (location, route) => {
-    const routeElements = splitPath(route);
-    const parameters = [];
-    routeElements.forEach((routeElement => {
-        if (routeElement[0] === ":") {
-            parameters.push(routeElement);
-        } else {
-            parameters.push("");
-        }
-    }));
-    const {locationElements: locationElements, comparingPath: comparingPath} = computeComparingPath(location, parameters);
-    if (comparingPath !== route) {
-        return {
-            match: false,
-            parameters: {},
-            elements: locationElements
-        };
-    }
-    const parametersValues = extractParametersValues(parameters, locationElements);
-    return {
-        match: true,
-        parameters: parametersValues,
-        elements: locationElements
-    };
-};
-
-const extractParametersValues = (parameters, pathElements) => {
-    const parametersValues = {};
-    parameters.forEach(((parameter, index) => {
-        if (parameter) {
-            const parameterKey = parameter.slice(1);
-            parametersValues[parameterKey] = pathElements[index];
-        }
-    }));
-    return parametersValues;
-};
-
-const 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: locationElements,
-        comparingPath: comparingPath
-    };
-};
-
-const splitPath = path => path.split("/").filter((i => i !== ""));
-
-const 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 queryItems = query.split("&");
-        for (const item of queryItems) {
-            const queryValue = item.split("=");
-            const id = queryValue[0];
-            const value = decodeURIComponent(queryValue[1]);
-            queryValues[id] = value;
-        }
-        return queryValues;
-    } else {
-        return {};
-    }
-};
-
-const extractFragments = location => {
-    if (!location) {
-        return {
-            texts: [],
-            elements: []
-        };
-    }
-    const split = location.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
-    };
-};
-
-const 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 undefined;
-};
-
-const extractOccurence = occurence => {
-    if (!occurence) {
-        return 0;
-    }
-    const occurenceMatch = occurence.match(/\[(\d*)\]/);
-    const occurenceValue = occurenceMatch ? parseInt(occurenceMatch[1]) : 0;
-    return occurenceValue;
-};
-
-const stringInsertInitial = (value, insert) => {
-    if (!value.startsWith(insert)) {
-        value = insert + value;
-    }
-    return value;
-};
-
-const stringRemoveTrailing = (value, trail) => {
-    if (value.endsWith(trail)) {
-        value = value.slice(0, value.length - trail.length);
-    }
-    return value;
-};
-
-const PATH_SEPARATOR = "/";
-
-const cleanupPath = value => {
-    value = stringInsertInitial(value, PATH_SEPARATOR);
-    value = stringRemoveTrailing(value, PATH_SEPARATOR);
-    return value;
-};
-
-const 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;
-};
-
-const isAbsolutePlane = value => value[0] === "/";
-
-const 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";
-};
-
-const removeTrailingSlash = value => {
-    if (value.endsWith("/") && value.length > 1) {
-        return value.slice(0, value.length - 1);
-    }
-    return value;
-};
-
-const cleanPathValue = value => {
-    const queryStart = value.indexOf("?");
-    if (queryStart < 0) {
-        return removeTrailingSlash(value);
-    }
-    return removeTrailingSlash(value.substring(0, queryStart));
-};
-
-const 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;
-    }
-};
-
-const checkValidPath = (validationParameters, parameters) => {
-    if (validationParameters) {
-        for (const [parameterKey, parameterData] of Object.entries(validationParameters)) {
-            const {length: length, lengthType: lengthType, startsWith: startsWith, endsWith: endsWith, includes: 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);
-                return validLength;
-            }
-        }
-    }
-    return true;
-};
-
-const cleanPathElement = path => {
-    if (path[0] === "/") {
-        return path.slice(1);
-    }
-    return path;
-};
-
-var index$j = Object.freeze({
-    __proto__: null,
-    cleanPathElement: cleanPathElement
-});
-
-const mapPathsToRoutes = (paths, view) => {
-    const routes = [];
-    for (const [key, path] of Object.entries(paths)) {
-        const pathView = view[key];
-        if (pathView) {
-            const route = {
-                value: ""
-            };
-            routes.push(route);
-        }
-    }
-    return routes;
-};
-
-const 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 url = {
-            protocol: {
-                value: protocol,
-                secure: true
-            },
-            host: host,
-            path: path,
-            space: space,
-            universe: universe,
-            cluster: cluster,
-            plane: plane,
-            valid: valid
-        };
-        return url;
-    }
-    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 url = {
-            protocol: {
-                value: protocol,
-                secure: true
-            },
-            host: host,
-            path: path,
-            space: space,
-            universe: universe,
-            cluster: cluster,
-            plane: plane,
-            valid: true
-        };
-        return url;
-    }
-    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 url = {
-                protocol: {
-                    value: protocol,
-                    secure: true
-                },
-                host: host,
-                path: path,
-                space: space,
-                universe: universe,
-                cluster: cluster,
-                plane: plane,
-                valid: valid
-            };
-            return url;
-        }
-    } 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 url = {
-                protocol: {
-                    value: protocol,
-                    secure: true
-                },
-                host: host,
-                path: path,
-                space: space,
-                universe: universe,
-                cluster: cluster,
-                plane: plane,
-                valid: valid
-            };
-            return url;
-        }
-    }
-    const url = {
-        protocol: {
-            value: protocol,
-            secure: true
-        },
-        host: host,
-        path: path,
-        space: space,
-        universe: universe,
-        cluster: cluster,
-        plane: plane,
-        valid: true
-    };
-    return url;
-};
-
-const 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 resolvers = [ protocolDivision, hostDivision.value, path.value ];
-        const absoluteRoute = resolvers.join(separator);
-        return {
-            protocol: protocolDivision,
-            host: hostDivision,
-            path: path,
-            space: space,
-            universe: universe,
-            cluster: cluster,
-            plane: plane,
-            route: absoluteRoute
-        };
-    }
-    [ protocolDivision, hostDivision.value, path.value, space.value, universe.value, cluster.value, cleanPathElement(plane.value) ];
-    return {
-        protocol: "",
-        host: "",
-        path: path,
-        space: "",
-        universe: "",
-        cluster: "",
-        plane: "",
-        route: route
-    };
-};
-
-const updateTreePlane$1 = (tree, page) => {
-    const updatedTree = tree.map((treePlane => {
-        if (treePlane.planeID === page.planeID) {
-            return Object.assign({}, page);
-        }
-        if (treePlane.children) {
-            return Object.assign(Object.assign({}, treePlane), {
-                children: updateTreePlane$1(treePlane.children, page)
-            });
-        }
-        return treePlane;
-    }));
-    return updatedTree;
-};
-
-const updateTreeByPlaneIDWithLinkCoordinates = (tree, planeID, linkCoordinates) => {
-    const updatedTree = tree.map((treePlane => {
-        if (treePlane.planeID === planeID) {
-            const updatedPlane = Object.assign(Object.assign({}, treePlane), {
-                linkCoordinates: linkCoordinates
-            });
-            return updatedPlane;
-        }
-        if (treePlane.children) {
-            const updatedChildren = updateTreeByPlaneIDWithLinkCoordinates(treePlane.children, planeID, linkCoordinates);
-            const updatedPlane = Object.assign(Object.assign({}, treePlane), {
-                children: updatedChildren
-            });
-            return updatedPlane;
-        }
-        return treePlane;
-    }));
-    return updatedTree;
-};
-
-var index$i = Object.freeze({
-    __proto__: null,
-    updateTreePlane: updateTreePlane$1,
-    updateTreeByPlaneIDWithLinkCoordinates: updateTreeByPlaneIDWithLinkCoordinates
-});
-
-var index$h = Object.freeze({
-    __proto__: null,
-    configuration: index$k,
-    tree: index$i
-});
-
-const 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;
-};
-
-var index$g = Object.freeze({
-    __proto__: null,
-    getWheelDirection: getWheelDirection
-});
-
-const degToRad = deg => deg * .01745329252;
-
-const radToDeg = rad => rad * 57.2957795131;
-
-const makeQuaternion = (x, y, z, w) => ({
-    x: x,
-    y: y,
-    z: z,
-    w: w
-});
-
-const zeroQuaternion = () => 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 = Object.assign({}, 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 ];
-}
-
-var index$f = Object.freeze({
-    __proto__: null,
-    degToRad: degToRad,
-    radToDeg: radToDeg,
-    makeQuaternion: makeQuaternion,
-    zeroQuaternion: zeroQuaternion,
-    inverseQuaternion: inverseQuaternion,
-    conjugateQuaternion: conjugateQuaternion,
-    computeQuaternionFromEulers: computeQuaternionFromEulers,
-    quaternionFromAxisAngle: quaternionFromAxisAngle,
-    quaternionMultiply: quaternionMultiply,
-    rotatePointViaQuaternion: rotatePointViaQuaternion,
-    makeRotationMatrixFromQuaternion: makeRotationMatrixFromQuaternion
-});
-
-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$1(x, y, z) {
-    return [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1 ];
-}
-
-function scaleMatrix$1(s) {
-    return [ s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1 ];
-}
-
-function multiplyMatrices$1(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$1(inputMatrix, matrices[i]);
-    }
-    return inputMatrix;
-}
-
-function matrixArrayToCSSMatrix(array) {
-    return "matrix3d(" + array.join(",") + ")";
-}
-
-var index$e = Object.freeze({
-    __proto__: null,
-    rotateMatrix: rotateMatrix,
-    translateMatrix: translateMatrix$1,
-    scaleMatrix: scaleMatrix$1,
-    multiplyMatrices: multiplyMatrices$1,
-    multiplyArrayOfMatrices: multiplyArrayOfMatrices,
-    matrixArrayToCSSMatrix: matrixArrayToCSSMatrix
-});
-
-const getInitialMatrix = () => {
-    const matrix = [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ];
-    return matrix;
-};
-
-const multiplyMatrices = (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;
-};
-
-const 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 = multiplyMatrices(result, matrix);
-    }
-    return result;
-};
-
-const 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;
-};
-
-const matrixToArray = matrix => matrix.flat();
-
-const matrix3DToMatrix = value => {
-    const values = value.replace("matrix3d(", "").replace(")", "").split(",").map((val => parseFloat(val)));
-    return arrayToMatrix(values);
-};
-
-const printMatrix = (matrix, name) => {
-    const normalize = value => {
-        if (value === 1 || value === 0) {
-            return value + "     ";
-        }
-        if (value > 0) {
-            return value.toFixed(2) + "  ";
-        }
-        return value.toFixed(2) + " ";
-    };
-    console.log("matrix", name + ":");
-    for (const row of matrix) {
-        console.log(normalize(row[0]), normalize(row[1]), normalize(row[2]), normalize(row[3]));
-    }
-    console.log(`matrix3d(${matrix.flat().join(",")})`);
-    console.log();
-};
-
-const 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;
-};
-
-const 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;
-};
-
-const 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;
-};
-
-const translateMatrix = (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;
-};
-
-const scaleMatrix = s => [ [ 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 ] ];
-}
-
-const matrixToCSSMatrix = matrix => {
-    const value = matrix.flat().join(",");
-    return `matrix3d(${value})`;
-};
-
-const identityMatrix = () => {
-    const matrix = [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ];
-    return matrix;
-};
-
-const inverseMatrix = matrix => {
-    const cols = 4;
-    const rows = 4;
-    const A = [ ...matrix ];
-    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;
-};
-
-var index$d = Object.freeze({
-    __proto__: null,
-    getInitialMatrix: getInitialMatrix,
-    multiplyMatrices: multiplyMatrices,
-    multiplyMatricesArray: multiplyMatricesArray,
-    arrayToMatrix: arrayToMatrix,
-    matrixToArray: matrixToArray,
-    matrix3DToMatrix: matrix3DToMatrix,
-    printMatrix: printMatrix,
-    rotateXMatrix: rotateXMatrix,
-    rotateYMatrix: rotateYMatrix,
-    rotateZMatrix: rotateZMatrix,
-    translateMatrix: translateMatrix,
-    scaleMatrix: scaleMatrix,
-    rotationMatrixFromQuaternion: rotationMatrixFromQuaternion,
-    matrixToCSSMatrix: matrixToCSSMatrix,
-    identityMatrix: identityMatrix,
-    inverseMatrix: inverseMatrix
-});
-
-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 scaleMatrix = getMatrixValues(matrix3d).slice(0, 4);
-        scale = 0;
-        for (const el of scaleMatrix) {
-            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: rotateX,
-        rotateY: rotateY,
-        rotateZ: 0
-    };
-}
-
-function getTransformTranslate(matrix3d) {
-    const values = getTranslationMatrix(matrix3d);
-    const translateX = values[0];
-    const translateY = values[1];
-    const translateZ = values[2];
-    return {
-        translateX: translateX,
-        translateY: translateY,
-        translateZ: translateZ
-    };
-}
-
-function getTransformScale(matrix3d) {
-    const scale = getScalationValue(matrix3d);
-    return {
-        scale: scale
-    };
-}
-
-function rotatePlurid(matrix3d, direction = "", angleIncrement = .07) {
-    const transformRotate = getTransformRotate(matrix3d);
-    const rotateX = transformRotate.rotateX;
-    let rotateY = transformRotate.rotateY;
-    const rotateZ = transformRotate.rotateZ;
-    const transformTranslate = getTransformTranslate(matrix3d);
-    const translateX = transformTranslate.translateX;
-    const translateY = transformTranslate.translateY;
-    const translateZ = transformTranslate.translateZ;
-    const scale = getTransformScale(matrix3d).scale;
-    let valRotationMatrix = rotateMatrix(rotateX, rotateY, rotateZ);
-    const valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
-    const valScalationMatrix = scaleMatrix$1(scale);
-    if (direction === "left") {
-        rotateY -= angleIncrement;
-        valRotationMatrix = rotateMatrix(rotateX, rotateY);
-    }
-    if (direction === "right") {
-        rotateY += angleIncrement;
-        valRotationMatrix = rotateMatrix(rotateX, rotateY);
-    }
-    if (direction === "up") {
-        rotateY -= angleIncrement;
-        valRotationMatrix = rotateMatrix(rotateX, rotateY);
-    }
-    if (direction === "down") {
-        rotateY += angleIncrement;
-        valRotationMatrix = rotateMatrix(rotateX, rotateY);
-    }
-    const transformedMatrix3d = setTransform(valRotationMatrix, valTranslationMatrix, valScalationMatrix);
-    return transformedMatrix3d;
-}
-
-function translatePlurid(matrix3d, direction = "", linearIncrement = 50) {
-    const transformRotate = getTransformRotate(matrix3d);
-    const rotateX = transformRotate.rotateX;
-    const rotateY = transformRotate.rotateY;
-    const rotateZ = transformRotate.rotateZ;
-    const transformTranslate = getTransformTranslate(matrix3d);
-    let translateX = transformTranslate.translateX;
-    let translateY = transformTranslate.translateY;
-    const translateZ = transformTranslate.translateZ;
-    const scale = getTransformScale(matrix3d).scale;
-    const valRotationMatrix = rotateMatrix(rotateX, rotateY, rotateZ);
-    let valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
-    const valScalationMatrix = scaleMatrix$1(scale);
-    scale < .5 ? linearIncrement = 50 : linearIncrement = 30;
-    if (direction === "left") {
-        translateX += linearIncrement;
-        valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
-    }
-    if (direction === "right") {
-        translateX -= linearIncrement;
-        valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
-    }
-    if (direction === "up") {
-        translateY += linearIncrement;
-        valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
-    }
-    if (direction === "down") {
-        translateY -= linearIncrement;
-        valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
-    }
-    const transformedMatrix3d = setTransform(valRotationMatrix, valTranslationMatrix, valScalationMatrix);
-    return transformedMatrix3d;
-}
-
-function scalePlurid(matrix3d, direction = "", scaleIncrement = .05) {
-    const transformRotate = getTransformRotate(matrix3d);
-    const rotateX = transformRotate.rotateX;
-    const rotateY = transformRotate.rotateY;
-    const rotateZ = transformRotate.rotateZ;
-    const transformTranslate = getTransformTranslate(matrix3d);
-    const translateX = transformTranslate.translateX;
-    const translateY = transformTranslate.translateY;
-    const translateZ = transformTranslate.translateZ;
-    let scale = getTransformScale(matrix3d).scale;
-    const valRotationMatrix = rotateMatrix(rotateX, rotateY, rotateZ);
-    const valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
-    let valScalationMatrix = scaleMatrix$1(scale);
-    if (direction === "up") {
-        scale -= scaleIncrement;
-        if (scale < .1) {
-            scale = .1;
-        }
-        valScalationMatrix = scaleMatrix$1(scale);
-    }
-    if (direction === "down") {
-        scale += scaleIncrement;
-        if (scale > 4) {
-            scale = 4;
-        }
-        valScalationMatrix = scaleMatrix$1(scale);
-    }
-    const transformedMatrix3d = setTransform(valRotationMatrix, valTranslationMatrix, valScalationMatrix);
-    return transformedMatrix3d;
-}
-
-var index$c = Object.freeze({
-    __proto__: null,
-    getMatrixValues: getMatrixValues,
-    getRotationMatrix: getRotationMatrix,
-    getTranslationMatrix: getTranslationMatrix,
-    getScalationValue: getScalationValue,
-    setTransform: setTransform,
-    getTransformRotate: getTransformRotate,
-    getTransformTranslate: getTransformTranslate,
-    getTransformScale: getTransformScale,
-    rotatePlurid: rotatePlurid,
-    translatePlurid: translatePlurid,
-    scalePlurid: scalePlurid
-});
-
-var index$b = Object.freeze({
-    __proto__: null,
-    general: index$d,
-    matrix3d: index$c
-});
-
-var index$a = Object.freeze({
-    __proto__: null,
-    direction: index$g,
-    matrix: index$e,
-    quaternion: index$f,
-    transform: index$b
-});
-
-const internatiolate = (lamguage, field) => internationalization[lamguage][field];
-
-const resolvePluridPlaneData = plane => {
-    if (Array.isArray(plane)) {
-        const [route, component, options] = plane;
-        return Object.assign({
-            route: route,
-            component: component
-        }, options);
-    }
-    return plane;
-};
-
-const resolvePluridRoutePlaneData = plane => {
-    if (Array.isArray(plane)) {
-        const [value, component, options] = plane;
-        return Object.assign({
-            value: value,
-            component: component
-        }, options);
-    }
-    return plane;
-};
-
-const getPluridPlaneIDByData = element => {
-    if (!element) {
-        return "";
-    }
-    const parent = element.parentElement;
-    if (parent && parent.dataset.pluridPlane) {
-        return parent.dataset.pluridPlane;
-    }
-    return getPluridPlaneIDByData(parent);
-};
-
-class IsoMatcher {
-    constructor(data, origin = "origin") {
-        this.routesIndex = new Map;
-        this.planesIndex = new Map;
-        this.routesKeys = [];
-        this.planesKeys = [];
-        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);
-        }
-    }
-    index(data) {
-        this.updateIndexes(data.routes || [], data.routePlanes || [], data.planes || []);
-    }
-    clear() {
-        this.routesIndex = new Map;
-        this.planesIndex = new Map;
-        this.routesKeys = [];
-        this.planesKeys = [];
-    }
-    getPlanesIndex() {
-        return this.planesIndex;
-    }
-    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: Object.assign({}, 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: kind,
-                data: Object.assign({}, planeData)
-            };
-            if (parent) {
-                indexedPlane["parent"] = parent;
-            }
-            this.planesIndex.set(address, indexedPlane);
-        }
-    }
-    matchPlane(value) {
-        const planeAddress = computePlaneAddress(value, undefined, this.origin);
-        const plane = this.planesIndex.get(planeAddress);
-        if (plane) {
-            const query = extractQuery(value);
-            const fragments = extractFragments(value);
-            const match = {
-                value: planeAddress,
-                fragments: fragments,
-                query: query,
-                parameters: {}
-            };
-            if (plane.kind === "Plane") {
-                const {kind: kind, data: data, parent: parent} = plane;
-                const result = {
-                    kind: kind,
-                    data: data,
-                    parent: parent,
-                    match: match
-                };
-                return result;
-            }
-            if (plane.kind === "RoutePlane") {
-                const {kind: kind, data: data, parent: parent} = plane;
-                const result = {
-                    kind: kind,
-                    data: data,
-                    parent: parent,
-                    match: 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 plane = this.planesIndex.get(planePath);
-                if (!plane) {
-                    return;
-                }
-                const {parameters: parameters} = parametersAndMatch;
-                const validPath = checkValidPath(plane.data.parameters, parameters);
-                if (!validPath) {
-                    return;
-                }
-                const query = extractQuery(value);
-                const fragments = extractFragments(value);
-                const match = {
-                    value: planeAddress,
-                    fragments: fragments,
-                    query: query,
-                    parameters: parameters
-                };
-                if (plane.kind === "Plane") {
-                    const {kind: kind, data: data, parent: parent} = plane;
-                    const result = {
-                        kind: kind,
-                        data: data,
-                        parent: parent,
-                        match: match
-                    };
-                    return result;
-                }
-                if (plane.kind === "RoutePlane") {
-                    const {kind: kind, data: data, parent: parent} = plane;
-                    const result = {
-                        kind: kind,
-                        data: data,
-                        parent: parent,
-                        match: 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: routeValue,
-                    query: 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 route = this.routesIndex.get(routePath);
-                if (!route) {
-                    return;
-                }
-                const {parameters: parameters} = parametersAndMatch;
-                const validPath = checkValidPath(route.data.parameters, parameters);
-                if (!validPath) {
-                    return;
-                }
-                const query = extractQuery(routeValue);
-                const match = {
-                    value: routeValue,
-                    query: query,
-                    parameters: parameters
-                };
-                if (route) {
-                    const result = {
-                        kind: "Route",
-                        data: route.data,
-                        match: match
-                    };
-                    return result;
-                }
-            }
-        }
-        const routePlane = this.matchPlane(routeValue);
-        if (routePlane) {
-            const result = {
-                kind: "RoutePlane",
-                data: routePlane.data,
-                match: {
-                    value: routeValue,
-                    query: routePlane.match.query,
-                    parameters: routePlane.match.parameters
-                }
-            };
-            return result;
-        }
-        return;
-    }
-}
-
-class Parser {
-    constructor(location, path, options) {
-        this.location = location;
-        this.path = path;
-        this.options = this.handleOptions(options);
-    }
-    handleOptions(options) {
-        const parserOptions = {
-            fragment: (options === null || options === void 0 ? void 0 : 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;
-    }
-    extract() {
-        const pathname = this.extractPathname();
-        const {match: match, parameters: parameters, elements: elements} = this.extractParametersAndMatch();
-        const query = this.extractQuery();
-        const queryData = Object.entries(query).map((([key, value]) => key + "=" + value)).join("&");
-        const queryString = queryData ? "?" + queryData : "";
-        const fragments = this.extractFragments();
-        const parserResponse = {
-            path: this.path,
-            pathname: pathname,
-            elements: elements,
-            match: match,
-            parameters: parameters,
-            query: query,
-            fragments: fragments,
-            route: pathname + queryString
-        };
-        return parserResponse;
-    }
-}
-
-var index$9 = Object.freeze({
-    __proto__: null,
-    IsoMatcher: IsoMatcher,
-    RouteParser: Parser,
-    extractQuery: extractQuery,
-    stringInsertInitial: stringInsertInitial,
-    stringRemoveTrailing: stringRemoveTrailing,
-    cleanupPath: cleanupPath,
-    computePlaneAddress: computePlaneAddress,
-    isAbsolutePlane: isAbsolutePlane,
-    checkPlaneAddressType: checkPlaneAddressType,
-    removeTrailingSlash: removeTrailingSlash,
-    cleanPathValue: cleanPathValue,
-    checkParameterLength: checkParameterLength,
-    checkValidPath: checkValidPath,
-    mapPathsToRoutes: mapPathsToRoutes,
-    pluridLinkPathDivider: pluridLinkPathDivider,
-    resolveRoute: resolveRoute
-});
-
-class PluridPlanesRegistrar {
-    constructor(planes, origin = "origin") {
-        this.isoMatcher = new IsoMatcher({
-            planes: planes
-        }, origin);
-    }
-    register(planes) {
-        this.isoMatcher.index({
-            planes: 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 = 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;
-    }
-}
-
-const 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 PluridPlanesRegistrar([], origin);
-        window.__pluridPlanesRegistrar__ = pluridPlanesRegistrar;
-        window.__pluridPlanesRegistrar__.register(planes);
-        return;
-    }
-    window.__pluridPlanesRegistrar__.register(planes);
-    return;
-};
-
-const getPlanesRegistrar = planesRegistrar => {
-    if (planesRegistrar) {
-        return planesRegistrar;
-    }
-    if (typeof window !== "undefined") {
-        if (window.__pluridPlanesRegistrar__ !== undefined) {
-            return window.__pluridPlanesRegistrar__;
-        }
-    }
-    return;
-};
-
-const getRegisteredPlanes = planesRegistrar => {
-    if (planesRegistrar) {
-        return planesRegistrar.getAll();
-    }
-    if (typeof window !== "undefined") {
-        if (window.__pluridPlanesRegistrar__ !== undefined) {
-            return window.__pluridPlanesRegistrar__.getAll();
-        }
-    }
-    return new Map;
-};
-
-const getRegisteredPlane = (route, planesRegistrar) => {
-    if (planesRegistrar) {
-        return planesRegistrar.get(route);
-    }
-    if (typeof window !== "undefined") {
-        if (window.__pluridPlanesRegistrar__ !== undefined) {
-            return window.__pluridPlanesRegistrar__.get(route);
-        }
-    }
-    return;
-};
-
-var index$8 = Object.freeze({
-    __proto__: null,
-    resolvePluridPlaneData: resolvePluridPlaneData,
-    resolvePluridRoutePlaneData: resolvePluridRoutePlaneData,
-    getPluridPlaneIDByData: getPluridPlaneIDByData,
-    registerPlanes: registerPlanes,
-    getPlanesRegistrar: getPlanesRegistrar,
-    getRegisteredPlanes: getRegisteredPlanes,
-    getRegisteredPlane: getRegisteredPlane,
-    Registrar: PluridPlanesRegistrar
-});
-
-const 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: width,
-        height: height,
-        depth: depth,
-        topCorner: topCorner
-    };
-};
-
-const findPage = (view, pages) => {
-    for (const page of pages) {
-        if (page.route === view) {
-            return page;
-        }
-    }
-    return;
-};
-
-const splitIntoGroups = (data, length) => {
-    const initialArray = [ ...data ];
-    const groups = [];
-    while (initialArray.length) {
-        const group = initialArray.splice(0, length);
-        groups.push(group);
-    }
-    return groups;
-};
-
-const 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;
-};
-
-var index$7 = Object.freeze({
-    __proto__: null,
-    computeSpaceSize: computeSpaceSize,
-    findPage: findPage,
-    splitIntoGroups: splitIntoGroups,
-    getTreePlaneByPlaneID: getTreePlaneByPlaneID
-});
-
-const toRadians$1 = mathematics.geometry.toRadians;
-
-const computePath = (tree, planeID) => {
-    const path = [];
-    const page = getTreePlaneByPlaneID(tree, planeID);
-    if (page) {
-        path.push(Object.assign({}, page));
-        let parentID = page.parentPlaneID;
-        if (!parentID) {
-            return path;
-        }
-        while (parentID) {
-            const parentPage = getTreePlaneByPlaneID(tree, parentID);
-            if (parentPage) {
-                const page = Object.assign({}, parentPage);
-                page.children = [];
-                path.push(page);
-                parentID = parentPage.parentPlaneID;
-            }
-        }
-    }
-    return path.reverse();
-};
-
-const computePluridPlaneLocation = (linkCoordinates, treePageParent, bridgeLength = 100, linkPlaneAngle = 90) => {
-    const parentAngleRadians = toRadians$1(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$1(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: x,
-        y: y,
-        z: z
-    };
-    return locationCoordinates;
-};
-
-const recomputeChildrenLocation = page => {
-    if (!page.children) {
-        return [];
-    }
-    const updatedChildren = [];
-    for (const child of page.children) {
-        if (child.linkCoordinates) {
-            const location = computePluridPlaneLocation(child.linkCoordinates, page, child.bridgeLength, child.planeAngle);
-            const updatedChild = Object.assign(Object.assign({}, child), {
-                location: Object.assign(Object.assign({}, child.location), {
-                    translateX: location.x,
-                    translateY: location.y,
-                    translateZ: location.z
-                })
-            });
-            const children = updatedChild.children ? recomputeChildrenLocation(updatedChild) : [];
-            const updatedChildWithChildren = Object.assign(Object.assign({}, updatedChild), {
-                children: children
-            });
-            updatedChildren.push(updatedChildWithChildren);
-        }
-    }
-    return updatedChildren;
-};
-
-var index$6 = Object.freeze({
-    __proto__: null,
-    computePath: computePath,
-    computePluridPlaneLocation: computePluridPlaneLocation,
-    recomputeChildrenLocation: recomputeChildrenLocation
-});
-
-const 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 length = columnLength || Math.ceil(roots.length / columns);
-    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 = Object.assign(Object.assign({}, root), {
-            location: {
-                translateX: translateX,
-                translateY: translateY,
-                translateZ: 0,
-                rotateX: 0,
-                rotateY: 0
-            }
-        });
-        const children = recomputeChildrenLocation(treePage);
-        const treePageWithChildren = Object.assign(Object.assign({}, treePage), {
-            children: children
-        });
-        tree.push(treePageWithChildren);
-    }
-    return tree;
-};
-
-const 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 length = rowLength || Math.ceil(roots.length / rows);
-    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 = Object.assign(Object.assign({}, root), {
-            location: {
-                translateX: translateX,
-                translateY: translateY,
-                translateZ: 0,
-                rotateX: 0,
-                rotateY: 0
-            }
-        });
-        const children = recomputeChildrenLocation(treePage);
-        const treePageWithChildren = Object.assign(Object.assign({}, treePage), {
-            children: children
-        });
-        tree.push(treePageWithChildren);
-    }
-    return tree;
-};
-
-const toRadians = mathematics.geometry.toRadians;
-
-const computeFaceToFaceTranslateZ = (width, angle, first) => {
-    if (first) {
-        return width * Math.sin(toRadians(angle));
-    }
-    return 0;
-};
-
-const computeFaceToFaceTranslateX = (width, angle, gap, first, index) => {
-    const firstTranslateX = width * Math.cos(toRadians(angle));
-    if (first) {
-        return firstTranslateX;
-    }
-    const value = width * (index - 1) + 2 * firstTranslateX + gap * index;
-    return value;
-};
-
-const computeFaceToFaceRotateY = (angle, first, last) => {
-    const rotateY = first ? angle : last ? -angle : 0;
-    return rotateY;
-};
-
-const 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 = Number.isInteger(gap) ? gap : gap * width;
-    for (const [index, row] of rows.entries()) {
-        const translateY = index * height;
-        for (const [index, page] of row.entries()) {
-            const first = index === 0;
-            const last = index === columns - 1;
-            const translateZ = computeFaceToFaceTranslateZ(width, planeAngle, first);
-            const translateX = computeFaceToFaceTranslateX(width, planeAngle, gapValue, first, index);
-            const rotateY = computeFaceToFaceRotateY(planeAngle, first, last);
-            const treePage = Object.assign(Object.assign({}, page), {
-                location: {
-                    translateX: translateX,
-                    translateY: translateY,
-                    translateZ: translateZ,
-                    rotateX: 0,
-                    rotateY: rotateY
-                }
-            });
-            const children = recomputeChildrenLocation(treePage);
-            const treePageWithChildren = Object.assign(Object.assign({}, treePage), {
-                children: children
-            });
-            tree.push(treePageWithChildren);
-        }
-    }
-    return tree;
-};
-
-const computeSheavesLayout = (roots, depth = .3, offsetX = 0, offsetY = 0, configuration = defaultConfiguration) => {
-    const windowInnerWidth = typeof window === "undefined" ? 1440 : window.innerWidth;
-    const tree = [];
-    mathematics.numbers.checkIntegerNonUnit(configuration.elements.plane.width) ? configuration.elements.plane.width : configuration.elements.plane.width * windowInnerWidth;
-    for (const [index, page] of roots.entries()) {
-        const translateX = 0;
-        const translateY = 0;
-        const treePage = Object.assign(Object.assign({}, page), {
-            location: {
-                translateX: translateX,
-                translateY: translateY,
-                translateZ: 0,
-                rotateX: 0,
-                rotateY: 0
-            }
-        });
-        const children = recomputeChildrenLocation(treePage);
-        const treePageWithChildren = Object.assign(Object.assign({}, treePage), {
-            children: children
-        });
-        tree.push(treePageWithChildren);
-    }
-    return tree;
-};
-
-const computeZigZagLayout = (pages, angle = 45, configuration = defaultConfiguration) => {
-    const tree = [];
-    const singleColumnedRoots = computeColumnLayout(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 = Object.assign(Object.assign({}, page), {
-            children: children
-        });
-        tree.push(Object.assign({}, treePageWithChildren));
-    }
-    return tree;
-};
-
-var index$5 = Object.freeze({
-    __proto__: null,
-    computeColumnLayout: computeColumnLayout,
-    computeRowLayout: computeRowLayout,
-    computeFaceToFaceLayout: computeFaceToFaceLayout,
-    computeSheavesLayout: computeSheavesLayout,
-    computeZigZagLayout: computeZigZagLayout
-});
-
-const resolveViewItem = (planes, view, configuration, origin = "origin", getCount) => {
-    const {protocol: protocol, host: host} = configuration.network;
-    const viewData = typeof view === "string" ? view : view.plane;
-    const viewAddress = computePlaneAddress(viewData, undefined, 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({
-        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: planeID,
-            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;
-};
-
-const 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 => Object.assign(Object.assign({}, 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: columns, columnLength: columnLength, gap: gap} = configuration.space.layout;
-            const columnLayoutTree = computeColumnLayout(treePlanes, columns, columnLength, gap, configuration);
-            return columnLayoutTree;
-        }
-
-      case LAYOUT_TYPES.ROWS:
-        {
-            const {rows: rows, rowLength: rowLength, gap: gap} = configuration.space.layout;
-            const rowLayoutTree = computeRowLayout(treePlanes, rows, rowLength, gap, configuration);
-            return rowLayoutTree;
-        }
-
-      case LAYOUT_TYPES.ZIG_ZAG:
-        {
-            const {angle: angle} = configuration.space.layout;
-            const zigzagLayoutTree = computeZigZagLayout(treePlanes, angle, configuration);
-            return zigzagLayoutTree;
-        }
-
-      case LAYOUT_TYPES.FACE_TO_FACE:
-        {
-            const {angle: angle, gap: gap, middle: middle} = configuration.space.layout;
-            const faceToFaceLayoutTree = computeFaceToFaceLayout(treePlanes, angle, gap, middle, configuration);
-            return faceToFaceLayoutTree;
-        }
-
-      case LAYOUT_TYPES.SHEAVES:
-        {
-            const {depth: depth, offsetX: offsetX, offsetY: offsetY} = configuration.space.layout;
-            const sheavesLayoutTree = computeSheavesLayout(treePlanes, depth, offsetX, offsetY, configuration);
-            return sheavesLayoutTree;
-        }
-
-      case LAYOUT_TYPES.META:
-        {
-            return [];
-        }
-
-      default:
-        return [];
-    }
-};
-
-const isParametric = (viewRoute, planeRoute) => true;
-
-const matchForParameters = (viewRoute, planeRoute) => {
-    const splitViewRoute = viewRoute.split("://");
-    const splitPlaneRoute = planeRoute.split("://");
-    splitViewRoute[2];
-    splitPlaneRoute[2];
-};
-
-const assignPagesFromView = (planes, view) => {
-    if (!view) {
-        return planes;
-    }
-    const tree = [];
-    for (const viewPlane of view) {
-        if (typeof viewPlane === "string") {
-            for (const plane of planes) {
-                if (viewPlane === plane.sourceID) {
-                    tree.push(plane);
-                }
-                if (isParametric(viewPlane, plane.sourceID)) {
-                    const parametricPlane = Object.assign({}, plane);
-                    parametricPlane.routeDivisions.plane.parameters.id = "one";
-                    parametricPlane.routeDivisions.plane.value = "one";
-                    parametricPlane.route = viewPlane;
-                    tree.push(parametricPlane);
-                }
-            }
-        }
-    }
-    return tree;
-};
-
-const updateTreePlane = (tree, updatedPlane) => {
-    const updatedTree = tree.map((treePlane => {
-        if (treePlane.planeID === updatedPlane.planeID) {
-            return updatedPlane;
-        }
-        if (treePlane.children) {
-            const children = updateTreePlane(treePlane.children, updatedPlane);
-            treePlane.children = children;
-            return treePlane;
-        }
-        return treePlane;
-    }));
-    return updatedTree;
-};
-
-const updateTreeWithNewPlane = (planeRoute, parentPlaneID, linkCoordinates, tree, planesRegistry, configuration, hostname = "origin") => {
-    const parentPlane = getTreePlaneByPlaneID(tree, parentPlaneID);
-    if (!parentPlane) {
-        return {
-            pluridPlaneID: "",
-            updatedTree: tree
-        };
-    }
-    const location = computePluridPlaneLocation(linkCoordinates, parentPlane);
-    const treePlane = resolveViewItem(planesRegistry, planeRoute, configuration, hostname);
-    if (!treePlane) {
-        return {
-            pluridPlaneID: "",
-            updatedTree: tree
-        };
-    }
-    const updatedTreePlane = Object.assign(Object.assign({}, treePlane), {
-        parentPlaneID: parentPlaneID,
-        location: {
-            translateX: location.x,
-            translateY: location.y,
-            translateZ: location.z,
-            rotateX: 0,
-            rotateY: parentPlane.location.rotateY + PLANE_DEFAULT_ANGLE
-        },
-        bridgeLength: 100,
-        planeAngle: 90,
-        linkCoordinates: linkCoordinates
-    });
-    const updatedParentPlane = Object.assign({}, parentPlane);
-    if (updatedParentPlane.children) {
-        updatedParentPlane.children.push(updatedTreePlane);
-    } else {
-        updatedParentPlane.children = [ updatedTreePlane ];
-    }
-    const updatedTree = updateTreePlane(tree, updatedParentPlane);
-    return {
-        pluridPlaneID: updatedTreePlane.planeID,
-        updatedTree: updatedTree,
-        updatedTreePlane: updatedTreePlane
-    };
-};
-
-const updatePlaneLocation = (tree, parentPlaneID, planeID, linkCoordinates) => {
-    const parentPlane = getTreePlaneByPlaneID(tree, parentPlaneID);
-    const plane = getTreePlaneByPlaneID(tree, planeID);
-    if (!parentPlane || !plane) {
-        return tree;
-    }
-    const location = computePluridPlaneLocation(linkCoordinates, parentPlane);
-    plane.location = {
-        translateX: location.x,
-        translateY: location.y,
-        translateZ: location.z,
-        rotateX: 0,
-        rotateY: parentPlane.location.rotateY + PLANE_DEFAULT_ANGLE
-    };
-    const updatedTree = updateTreePlane(tree, plane);
-    return updatedTree;
-};
-
-const updateTreeWithNewPage = (tree, treePageParentPlaneID, pagePath, pageID, linkCoordinates, parameters) => {
-    const treePageParent = getTreePlaneByPlaneID(tree, treePageParentPlaneID);
-    if (treePageParent) {
-        const location = 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
-            },
-            planeID: planeID,
-            width: 0,
-            height: 0,
-            parentPlaneID: treePageParentPlaneID,
-            location: {
-                translateX: location.x,
-                translateY: location.y,
-                translateZ: location.z,
-                rotateX: 0,
-                rotateY: treePageParent.location.rotateY + PLANE_DEFAULT_ANGLE
-            },
-            show: true,
-            bridgeLength: 100,
-            planeAngle: 90,
-            linkCoordinates: linkCoordinates
-        };
-        const updatedTreePlaneParent = Object.assign({}, treePageParent);
-        if (updatedTreePlaneParent.children) {
-            updatedTreePlaneParent.children.push(newTreePlane);
-        } else {
-            updatedTreePlaneParent.children = [ newTreePlane ];
-        }
-        const updatedTree = updateTreePlane(tree, updatedTreePlaneParent);
-        return {
-            pluridPlaneID: planeID,
-            updatedTree: updatedTree
-        };
-    }
-    return {
-        pluridPlaneID: "",
-        updatedTree: tree
-    };
-};
-
-const removePageFromTree = (tree, pluridPlaneID) => {
-    const updatedTree = tree.filter((page => {
-        if (page.planeID === pluridPlaneID) {
-            return false;
-        }
-        if (page.children) {
-            const pageTree = removePageFromTree(page.children, pluridPlaneID);
-            page.children = pageTree;
-            return page;
-        }
-        return page;
-    }));
-    return updatedTree;
-};
-
-const toggleChildren = children => {
-    const updatedChildren = children.map((child => {
-        if (child.children) {
-            const updatedChild = Object.assign(Object.assign({}, child), {
-                show: !child.show,
-                children: toggleChildren(child.children)
-            });
-            return updatedChild;
-        }
-        const updatedChild = Object.assign(Object.assign({}, child), {
-            show: !child.show
-        });
-        return updatedChild;
-    }));
-    return updatedChildren;
-};
-
-const toggleAllChildren = (tree, show) => {
-    for (const plane of tree) {
-        if (plane.children) {
-            plane.children = toggleAllChildren(plane.children, show);
-        }
-        plane.show = show;
-    }
-    return tree;
-};
-
-const togglePlaneFromTree = (tree, pluridPlaneID, forceShow) => {
-    const updatedTree = [];
-    let updatedPlane;
-    for (const plane of tree) {
-        if (plane.planeID === pluridPlaneID) {
-            const show = forceShow !== null && forceShow !== void 0 ? forceShow : !plane.show;
-            const treeUpdatedPlane = Object.assign(Object.assign({}, plane), {
-                show: show
-            });
-            if (treeUpdatedPlane.children) {
-                const children = toggleAllChildren(treeUpdatedPlane.children, show);
-                treeUpdatedPlane.children = children;
-            }
-            updatedTree.push(treeUpdatedPlane);
-            updatedPlane = Object.assign({}, treeUpdatedPlane);
-            continue;
-        }
-        if (plane.children) {
-            const {updatedTree: childrenUpdatedTree, updatedPlane: childrenUpdatedPlane} = togglePlaneFromTree(plane.children, pluridPlaneID, forceShow);
-            plane.children = [ ...childrenUpdatedTree ];
-            updatedTree.push(plane);
-            if (childrenUpdatedPlane) {
-                updatedPlane = Object.assign({}, childrenUpdatedPlane);
-            }
-            continue;
-        }
-        updatedTree.push(plane);
-    }
-    return {
-        updatedTree: updatedTree,
-        updatedPlane: updatedPlane
-    };
-};
-
-const 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;
-};
-
-const removeRootFromTree = (tree, pluridPlaneID) => {
-    const updatedTree = tree.filter((plane => plane.planeID !== pluridPlaneID));
-    return {
-        updatedTree: updatedTree
-    };
-};
-
-const removePlaneFromTree = (tree, pluridPlaneID) => {
-    const updatedTree = [];
-    for (const plane of tree) {
-        if (plane.planeID === pluridPlaneID) {
-            continue;
-        }
-        if (plane.children) {
-            const children = removePlaneFromTree(plane.children, pluridPlaneID);
-            plane.children = children;
-        }
-        updatedTree.push(plane);
-    }
-    return updatedTree;
-};
-
-var logic = Object.freeze({
-    __proto__: null,
-    resolveViewItem: resolveViewItem,
-    computeSpaceTree: computeSpaceTree,
-    isParametric: isParametric,
-    matchForParameters: matchForParameters,
-    assignPagesFromView: assignPagesFromView,
-    updateTreePlane: updateTreePlane,
-    updateTreeWithNewPlane: updateTreeWithNewPlane,
-    updatePlaneLocation: updatePlaneLocation,
-    updateTreeWithNewPage: updateTreeWithNewPage,
-    removePageFromTree: removePageFromTree,
-    toggleChildren: toggleChildren,
-    toggleAllChildren: toggleAllChildren,
-    togglePlaneFromTree: togglePlaneFromTree,
-    getTreePlaneByID: getTreePlaneByID,
-    removeRootFromTree: removeRootFromTree,
-    removePlaneFromTree: removePlaneFromTree
-});
-
-class Tree {
-    constructor(data, origin = "origin") {
-        this.count = 0;
-        this.data = data;
-        this.origin = origin;
-    }
-    compute() {
-        const {planes: planes, view: view, configuration: configuration, layout: layout} = this.data;
-        return computeSpaceTree(planes, view, configuration, layout, this.origin, this.getCount.bind(this));
-    }
-    getCount() {
-        return this.count++;
-    }
-}
-
-var index$4 = Object.freeze({
-    __proto__: null,
-    Tree: Tree,
-    logic: logic
-});
-
-const 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;
-};
-
-const computeCulledView = (pages, view, location, 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, location, radius);
-        if (pageInView) {
-            culledView.push(page.route);
-        }
-    }
-    return culledView;
-};
-
-const checkPageInView = (page, location, radius) => {
-    const radiusLeft = location.translationX < 0 ? Math.abs(location.translationX) - radius : -1 * location.translationX - radius;
-    const radiusRight = location.translationX < 0 ? Math.abs(location.translationX) + radius : -1 * location.translationX + radius;
-    const locationX = page.location.translateX;
-    const radiusTop = location.translationY < 0 ? Math.abs(location.translationY) - radius : -1 * location.translationY - radius;
-    const radiusBottom = location.translationY < 0 ? Math.abs(location.translationY) + radius : -1 * location.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;
-};
-
-var index$3 = Object.freeze({
-    __proto__: null,
-    computeViewTree: computeViewTree,
-    computeCulledView: computeCulledView,
-    checkPageInView: checkPageInView
-});
-
-var index$2 = Object.freeze({
-    __proto__: null,
-    layout: index$5,
-    location: index$6,
-    tree: index$4,
-    utilities: index$7,
-    view: index$3
-});
-
-const resolveSpace = (view, configuration, planesRegistrar, currentState, localState, precomputedState, contextState, hostname = "origin") => {
-    const registeredPlanes = getRegisteredPlanes(planesRegistrar);
-    const spaceTree = new Tree({
-        planes: registeredPlanes,
-        configuration: configuration,
-        view: view
-    }, hostname);
-    const computedTree = spaceTree.compute();
-    const stateSpace = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({
-        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: "",
-        tree: computedTree
-    }, precomputedState === null || precomputedState === void 0 ? void 0 : precomputedState.space), contextState === null || contextState === void 0 ? void 0 : contextState.space), localState === null || localState === void 0 ? void 0 : localState.space), currentState === null || currentState === void 0 ? void 0 : currentState.space), {
-        view: 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;
-};
-
-const resolveThemes = (configuration, precomputedState) => {
-    let generalTheme;
-    let interactionTheme;
-    if (typeof configuration.global.theme === "object") {
-        const {general: general, interaction: 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 = Object.assign({
-        general: generalTheme || themes.plurid,
-        interaction: interactionTheme || themes.plurid
-    }, precomputedState === null || precomputedState === void 0 ? void 0 : precomputedState.themes);
-    return stateThemes;
-};
-
-const compute = (view, configuration, planesRegistrar, currentState, localState, precomputedState, contextState, hostname = "origin") => {
-    let stateConfiguration = merge(configuration);
-    const configurations = [ precomputedState === null || precomputedState === void 0 ? void 0 : precomputedState.configuration, contextState === null || contextState === void 0 ? void 0 : contextState.configuration, localState === null || localState === void 0 ? void 0 : localState.configuration, currentState === null || currentState === void 0 ? void 0 : currentState.configuration ];
-    for (const configuration of configurations) {
-        if (configuration) {
-            stateConfiguration = merge(configuration);
-        }
-    }
-    const stateSpace = resolveSpace(view, stateConfiguration, planesRegistrar, currentState, localState, precomputedState, contextState, hostname);
-    const stateThemes = resolveThemes(stateConfiguration, precomputedState);
-    const state = {
-        configuration: Object.assign({}, stateConfiguration),
-        shortcuts: Object.assign({
-            global: true
-        }, precomputedState === null || precomputedState === void 0 ? void 0 : precomputedState.shortcuts),
-        space: Object.assign({}, stateSpace),
-        themes: Object.assign({}, stateThemes),
-        ui: Object.assign(Object.assign({
-            toolbarScrollPosition: 0
-        }, precomputedState === null || precomputedState === void 0 ? void 0 : precomputedState.ui), contextState === null || contextState === void 0 ? void 0 : contextState.ui)
-    };
-    return state;
-};
-
-const load = (id, useLocalStorage) => {
-    if (!useLocalStorage) {
-        return;
-    }
-    if (typeof localStorage === "undefined") {
-        return;
-    }
-    try {
-        const stateID = id || "default";
-        const stateData = localStorage.getItem("pluridState-" + stateID);
-        if (!stateData) {
-            return;
-        }
-        const state = JSON.parse(stateData);
-        return state;
-    } catch (error) {
-        return;
-    }
-};
-
-var index$1 = Object.freeze({
-    __proto__: null,
-    load: load
-});
-
-var index = Object.freeze({
-    __proto__: null,
-    compute: compute,
-    local: index$1
-});
-
-const cleanTemplate = template => template.replace(/(?:\r\n|\r|\n)/g, " ").replace(/  +/g, " ").trim();
-
-const pluridRouterNavigate = path => {
-    if (!CustomEvent || !window) {
-        return;
-    }
-    const event = new CustomEvent(PLURID_ROUTER_LOCATION_CHANGED, {
-        detail: {
-            path: path
-        }
-    });
-    window.dispatchEvent(event);
-};
-
-export { cleanTemplate, index$h as general, index$a as interaction, internatiolate, index$8 as planes, pluridRouterNavigate, index$9 as routing, index$2 as space, index as state, index$j as utilities };
-//# sourceMappingURL=index.es.js.map