@plurid/plurid-engine 0.0.0-2 → 0.0.0-20

package/distribution/index.es.js

@@ -1,2590 +0,0 @@
-import { defaultConfiguration, compareTypes, defaultTreePlane, internationalization, ROOTS_GAP, LAYOUT_TYPES, PLANE_DEFAULT_ANGLE, PLURID_ROUTER_LOCATION_CHANGED } from "@plurid/plurid-data";
-
-import { objects, uuid, mathematics } from "@plurid/plurid-functions";
-
-import themes, { THEME_NAMES } from "@plurid/plurid-themes";
-
-const specifiedOrDefault = (path, type, configuration) => {
-    const item = objects.getNested(configuration, path);
-    if (typeof item === type) {
-        return item;
-    }
-    return objects.getNested(defaultConfiguration, path);
-};
-
-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) => {
-    var _a, _b, _c, _d, _e;
-    const targetConfiguration = Object.assign(Object.assign({}, defaultConfiguration), target);
-    if (!configuration) {
-        return Object.assign({}, targetConfiguration);
-    }
-    const layout = configuration && configuration.space && typeof configuration.space.layout === "object" ? configuration.space.layout : targetConfiguration.space.layout;
-    const mergedConfiguration = Object.assign(Object.assign({}, targetConfiguration), {
-        global: {
-            micro: specifiedOrDefault("global.micro", "boolean", configuration),
-            transparentUI: specifiedOrDefault("global.transparentUI", "boolean", configuration),
-            language: specifiedOrDefault("global.language", "string", configuration),
-            render: specifiedOrDefault("global.render", "string", configuration),
-            theme: {
-                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")
-            }
-        },
-        elements: Object.assign(Object.assign({}, targetConfiguration.elements), {
-            toolbar: {
-                show: specifiedOrDefault("elements.toolbar.show", "boolean", configuration),
-                opaque: specifiedOrDefault("elements.toolbar.opaque", "boolean", configuration),
-                conceal: specifiedOrDefault("elements.toolbar.conceal", "boolean", configuration),
-                transformIcons: specifiedOrDefault("elements.toolbar.transformIcons", "boolean", configuration),
-                transformButtons: specifiedOrDefault("elements.toolbar.transformButtons", "boolean", configuration),
-                toggledDrawers: configuration.elements && configuration.elements.toolbar && configuration.elements.toolbar.toggledDrawers ? configuration.elements.toolbar.toggledDrawers : targetConfiguration.elements.toolbar.toggledDrawers
-            },
-            viewcube: {
-                show: specifiedOrDefault("elements.viewcube.show", "boolean", configuration),
-                opaque: specifiedOrDefault("elements.viewcube.opaque", "boolean", configuration),
-                conceal: specifiedOrDefault("elements.viewcube.conceal", "boolean", configuration),
-                buttons: specifiedOrDefault("elements.viewcube.buttons", "boolean", configuration)
-            },
-            plane: {
-                width: specifiedOrDefault("elements.plane.width", "number", configuration),
-                opacity: specifiedOrDefault("elements.plane.opacity", "number", configuration),
-                controls: {
-                    show: specifiedOrDefault("elements.plane.controls.show", "boolean", configuration),
-                    pathbar: {
-                        domainURL: specifiedOrDefault("elements.plane.controls.pathbar.domainURL", "boolean", configuration)
-                    }
-                }
-            },
-            switch: {
-                show: (_e = (_d = (_c = configuration === null || configuration === void 0 ? void 0 : configuration.elements) === null || _c === void 0 ? void 0 : _c.switch) === null || _d === void 0 ? void 0 : _d.show) !== null && _e !== void 0 ? _e : false
-            }
-        }),
-        space: Object.assign(Object.assign({}, targetConfiguration.space), {
-            layout: layout,
-            camera: specifiedOrDefault("space.camera", "string", configuration),
-            perspective: specifiedOrDefault("space.perspective", "number", configuration),
-            opaque: specifiedOrDefault("space.opaque", "boolean", configuration),
-            fadeInTime: specifiedOrDefault("space.fadeInTime", "number", configuration),
-            center: specifiedOrDefault("space.center", "boolean", configuration),
-            transformOrigin: {
-                show: specifiedOrDefault("space.transformOrigin.show", "boolean", configuration),
-                size: specifiedOrDefault("space.transformOrigin.size", "string", configuration)
-            },
-            transformLocks: {
-                rotationX: specifiedOrDefault("space.transformLocks.rotationX", "boolean", configuration),
-                rotationY: specifiedOrDefault("space.transformLocks.rotationY", "boolean", configuration),
-                translationX: specifiedOrDefault("space.transformLocks.translationX", "boolean", configuration),
-                translationY: specifiedOrDefault("space.transformLocks.translationY", "boolean", configuration),
-                translationZ: specifiedOrDefault("space.transformLocks.translationZ", "boolean", configuration),
-                scale: specifiedOrDefault("space.transformLocks.scale", "boolean", configuration)
-            },
-            transformMode: specifiedOrDefault("space.transformMode", "string", configuration),
-            transformMultimode: specifiedOrDefault("space.transformMultimode", "boolean", configuration),
-            transformTouch: specifiedOrDefault("space.transformTouch", "string", configuration),
-            firstPerson: specifiedOrDefault("space.firstPerson", "boolean", configuration)
-        }),
-        network: {
-            host: specifiedOrDefault("network.host", "string", configuration),
-            protocol: specifiedOrDefault("network.protocol", "string", configuration)
-        },
-        development: {
-            planeDebugger: specifiedOrDefault("development.planeDebugger", "boolean", configuration),
-            spaceDebugger: specifiedOrDefault("development.spaceDebugger", "boolean", configuration)
-        }
-    });
-    return mergedConfiguration;
-};
-
-var index$i = 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 PTTP_PROTOCOL = "pttp://";
-
-const cleanupPath = value => {
-    value = stringInsertInitial(value, PATH_SEPARATOR);
-    value = stringRemoveTrailing(value, PATH_SEPARATOR);
-    return value;
-};
-
-const computePlaneAddress = (plane, route, origin = "origin") => {
-    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 = PTTP_PROTOCOL + origin + path;
-    return planeAddress;
-};
-
-const isAbsolutePlane = value => value[0] === "/";
-
-const checkPlaneAddressType = value => {
-    value = value.toLowerCase().trim();
-    if (value.startsWith(PTTP_PROTOCOL)) {
-        return "pttp";
-    }
-    if (value.startsWith("https://")) {
-        return "https";
-    }
-    if (value.startsWith("http://")) {
-        return "http";
-    }
-    return "relative";
-};
-
-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$h = 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 createTreePlane = (contextPlane, documentPlane) => {
-    const routeDivisions = pluridLinkPathDivider(contextPlane.path);
-    const treePlane = Object.assign(Object.assign({}, defaultTreePlane), {
-        routeDivisions: routeDivisions,
-        sourceID: contextPlane.id,
-        planeID: uuid.generate(),
-        route: contextPlane.path,
-        show: true
-    });
-    return treePlane;
-};
-
-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$g = Object.freeze({
-    __proto__: null,
-    createTreePlane: createTreePlane,
-    updateTreePlane: updateTreePlane$1,
-    updateTreeByPlaneIDWithLinkCoordinates: updateTreeByPlaneIDWithLinkCoordinates
-});
-
-var index$f = Object.freeze({
-    __proto__: null,
-    configuration: index$i,
-    tree: index$g
-});
-
-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$e = 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) {
-    const x = beta;
-    const y = gamma;
-    const z = 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;
-    q.x = x * Math.sin(halfAngle);
-    q.y = y * Math.sin(halfAngle);
-    q.z = z * Math.sin(halfAngle);
-    q.w = Math.cos(halfAngle);
-    return q;
-}
-
-function quaternionMultiply(quaternionArray) {
-    const temporaryQuaternion = quaternionArray[0];
-    const copyQuaternion = {
-        x: temporaryQuaternion.x,
-        y: temporaryQuaternion.y,
-        z: temporaryQuaternion.z,
-        w: temporaryQuaternion.w
-    };
-    for (let i = 1; i < quaternionArray.length; i++) {
-        const secondaryTemporaryQuaternion = quaternionArray[i];
-        const nextQuaternion = {
-            x: secondaryTemporaryQuaternion.x,
-            y: secondaryTemporaryQuaternion.y,
-            z: secondaryTemporaryQuaternion.z,
-            w: secondaryTemporaryQuaternion.w
-        };
-        const w = copyQuaternion.w * nextQuaternion.w - copyQuaternion.x * nextQuaternion.x - copyQuaternion.y * nextQuaternion.y - copyQuaternion.z * nextQuaternion.z;
-        const x = copyQuaternion.x * nextQuaternion.w + copyQuaternion.w * nextQuaternion.x + copyQuaternion.y * nextQuaternion.z - copyQuaternion.z * nextQuaternion.y;
-        const y = copyQuaternion.y * nextQuaternion.w + copyQuaternion.w * nextQuaternion.y + copyQuaternion.z * nextQuaternion.x - copyQuaternion.x * nextQuaternion.z;
-        const z = copyQuaternion.z * nextQuaternion.w + copyQuaternion.w * nextQuaternion.z + copyQuaternion.x * nextQuaternion.y - copyQuaternion.y * nextQuaternion.x;
-        copyQuaternion.x = x;
-        copyQuaternion.y = y;
-        copyQuaternion.z = z;
-        copyQuaternion.w = w;
-    }
-    return copyQuaternion;
-}
-
-function rotatePointViaQuaternion(pointRotate, quaternion) {
-    const temporaryQuaternion = {
-        x: pointRotate[0],
-        y: pointRotate[1],
-        z: pointRotate[2],
-        w: 0
-    };
-    const rotatedPoint = quaternionMultiply([ quaternion, temporaryQuaternion, conjugateQuaternion(quaternion) ]);
-    return {
-        x: rotatedPoint.x,
-        y: rotatedPoint.y,
-        z: rotatedPoint.z,
-        w: rotatedPoint.w
-    };
-}
-
-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$d = 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(x, y, z) {
-    return [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1 ];
-}
-
-function scaleMatrix(s) {
-    return [ s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1 ];
-}
-
-function multiplyMatrices(matrixA, matrixB) {
-    const result = [];
-    const a00 = matrixA[0];
-    const a01 = matrixA[1];
-    const a02 = matrixA[2];
-    const a03 = matrixA[3];
-    const a10 = matrixA[4];
-    const a11 = matrixA[5];
-    const a12 = matrixA[6];
-    const a13 = matrixA[7];
-    const a20 = matrixA[8];
-    const a21 = matrixA[9];
-    const a22 = matrixA[10];
-    const a23 = matrixA[11];
-    const a30 = matrixA[12];
-    const a31 = matrixA[13];
-    const a32 = matrixA[14];
-    const a33 = matrixA[15];
-    let b0 = matrixB[0];
-    let b1 = matrixB[1];
-    let b2 = matrixB[2];
-    let b3 = matrixB[3];
-    result[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-    result[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-    result[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-    result[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-    b0 = matrixB[4];
-    b1 = matrixB[5];
-    b2 = matrixB[6];
-    b3 = matrixB[7];
-    result[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-    result[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-    result[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-    result[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-    b0 = matrixB[8];
-    b1 = matrixB[9];
-    b2 = matrixB[10];
-    b3 = matrixB[11];
-    result[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-    result[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-    result[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-    result[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-    b0 = matrixB[12];
-    b1 = matrixB[13];
-    b2 = matrixB[14];
-    b3 = matrixB[15];
-    result[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
-    result[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
-    result[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
-    result[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
-    return result;
-}
-
-function multiplyArrayOfMatrices(matrices) {
-    let inputMatrix = matrices[0];
-    for (let i = 1; i < matrices.length; i++) {
-        inputMatrix = multiplyMatrices(inputMatrix, matrices[i]);
-    }
-    return inputMatrix;
-}
-
-function matrixArrayToCSSMatrix(array) {
-    return "matrix3d(" + array.join(",") + ")";
-}
-
-var index$c = Object.freeze({
-    __proto__: null,
-    rotateMatrix: rotateMatrix,
-    translateMatrix: translateMatrix,
-    scaleMatrix: scaleMatrix,
-    multiplyMatrices: multiplyMatrices,
-    multiplyArrayOfMatrices: multiplyArrayOfMatrices,
-    matrixArrayToCSSMatrix: matrixArrayToCSSMatrix
-});
-
-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(translateX, translateY, translateZ);
-    const valScalationMatrix = scaleMatrix(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(translateX, translateY, translateZ);
-    const valScalationMatrix = scaleMatrix(scale);
-    scale < .5 ? linearIncrement = 50 : linearIncrement = 30;
-    if (direction === "left") {
-        translateX += linearIncrement;
-        valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
-    }
-    if (direction === "right") {
-        translateX -= linearIncrement;
-        valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
-    }
-    if (direction === "up") {
-        translateY += linearIncrement;
-        valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
-    }
-    if (direction === "down") {
-        translateY -= linearIncrement;
-        valTranslationMatrix = translateMatrix(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(translateX, translateY, translateZ);
-    let valScalationMatrix = scaleMatrix(scale);
-    if (direction === "up") {
-        scale -= scaleIncrement;
-        if (scale < .1) {
-            scale = .1;
-        }
-        valScalationMatrix = scaleMatrix(scale);
-    }
-    if (direction === "down") {
-        scale += scaleIncrement;
-        if (scale > 4) {
-            scale = 4;
-        }
-        valScalationMatrix = scaleMatrix(scale);
-    }
-    const transformedMatrix3d = setTransform(valRotationMatrix, valTranslationMatrix, valScalationMatrix);
-    return transformedMatrix3d;
-}
-
-var index$b = 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$a = Object.freeze({
-    __proto__: null,
-    direction: index$e,
-    matrix: index$c,
-    quaternion: index$d,
-    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 createInternalStatePlane = plane => {
-    const planeData = resolvePluridPlaneData(plane);
-    const statePlane = {
-        id: uuid.generate(),
-        path: planeData.route
-    };
-    return statePlane;
-};
-
-const createInternalContextPlane = plane => {
-    const planeData = resolvePluridPlaneData(plane);
-    const {route: route, component: component} = planeData;
-    const contextPlane = {
-        id: uuid.generate(),
-        path: route,
-        component: component
-    };
-    return contextPlane;
-};
-
-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 = [];
-        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("pttp://", "");
-            const normalizedPlaneAddress = planeAddress.replace("pttp://", "");
-            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 route = this.routesIndex.get(value);
-        if (route) {
-            const query = extractQuery(value);
-            const result = {
-                kind: "Route",
-                data: route.data,
-                match: {
-                    value: value,
-                    query: query,
-                    parameters: {}
-                }
-            };
-            return result;
-        }
-        for (const routePath of this.routesKeys) {
-            const routeSplit = routePath.split("/");
-            const valueSplit = value.split("/");
-            if (routeSplit.length !== valueSplit.length) {
-                continue;
-            }
-            const parametersAndMatch = extractParametersAndMatch(value.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(value);
-                const match = {
-                    value: value,
-                    query: query,
-                    parameters: parameters
-                };
-                if (route) {
-                    const result = {
-                        kind: "Route",
-                        data: route.data,
-                        match: match
-                    };
-                    return result;
-                }
-            }
-        }
-        const routePlane = this.matchPlane(value);
-        if (routePlane) {
-            const result = {
-                kind: "RoutePlane",
-                data: routePlane.data,
-                match: {
-                    value: value,
-                    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,
-    checkParameterLength: checkParameterLength,
-    checkValidPath: checkValidPath,
-    mapPathsToRoutes: mapPathsToRoutes,
-    pluridLinkPathDivider: pluridLinkPathDivider,
-    resolveRoute: resolveRoute
-});
-
-class PluridPlanesRegistrar {
-    constructor(planes) {
-        this.isoMatcher = new IsoMatcher({
-            planes: planes
-        });
-    }
-    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
-                },
-                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
-                },
-                component: plane.data.component
-            };
-            all.set(path, registeredPlane);
-        }
-        return all;
-    }
-}
-
-const registerPlanes = (planes, planesRegistrar) => {
-    if (!planes) {
-        return;
-    }
-    if (planesRegistrar) {
-        planesRegistrar.register(planes);
-        return;
-    }
-    if (typeof window === "undefined") {
-        return;
-    }
-    if (typeof window.__pluridPlanesRegistrar__ === "undefined") {
-        const pluridPlanesRegistrar = new PluridPlanesRegistrar;
-        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,
-    createInternalStatePlane: createInternalStatePlane,
-    createInternalContextPlane: createInternalContextPlane,
-    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) => {
-    const {protocol: protocol, host: host} = configuration.network;
-    const viewData = typeof view === "string" ? view : view.plane;
-    const viewAddress = computePlaneAddress(viewData);
-    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
-    });
-    const match = isoMatcher.match(viewData);
-    if (match) {
-        const route = match.match.value;
-        const treePlane = {
-            sourceID: route,
-            planeID: uuid.generate(),
-            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) => {
-    const treePlanes = [];
-    for (const viewItem of view) {
-        const treePlane = resolveViewItem(planes, viewItem, configuration);
-        if (treePlane) {
-            treePlanes.push(treePlane);
-        }
-    }
-    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, updatedPage) => {
-    const updatedTree = tree.map((page => {
-        if (page.planeID === updatedPage.planeID) {
-            return updatedPage;
-        }
-        if (page.children) {
-            const pageTree = updateTreePlane(page.children, updatedPage);
-            page.children = pageTree;
-            return page;
-        }
-        return page;
-    }));
-    return updatedTree;
-};
-
-const updateTreeWithNewPlane = (planeRoute, parentPlaneID, linkCoordinates, tree, planesRegistry, configuration) => {
-    const parentPlane = getTreePlaneByPlaneID(tree, parentPlaneID);
-    if (!parentPlane) {
-        return {
-            pluridPlaneID: "",
-            updatedTree: tree
-        };
-    }
-    const location = computePluridPlaneLocation(linkCoordinates, parentPlane);
-    const treePlane = resolveViewItem(planesRegistry, planeRoute, configuration);
-    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
-    };
-};
-
-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 togglePlaneFromTree = (tree, pluridPlaneID) => {
-    const updatedTree = [];
-    for (const page of tree) {
-        if (page.planeID === pluridPlaneID) {
-            const updatedPage = Object.assign(Object.assign({}, page), {
-                show: !page.show,
-                children: []
-            });
-            updatedTree.push(updatedPage);
-            continue;
-        }
-        if (page.children) {
-            const pageTree = togglePlaneFromTree(page.children, pluridPlaneID);
-            page.children = [ ...pageTree ];
-            updatedTree.push(page);
-            continue;
-        }
-        updatedTree.push(page);
-    }
-    return updatedTree;
-};
-
-var logic = Object.freeze({
-    __proto__: null,
-    resolveViewItem: resolveViewItem,
-    computeSpaceTree: computeSpaceTree,
-    isParametric: isParametric,
-    matchForParameters: matchForParameters,
-    assignPagesFromView: assignPagesFromView,
-    updateTreePlane: updateTreePlane,
-    updateTreeWithNewPlane: updateTreeWithNewPlane,
-    updateTreeWithNewPage: updateTreeWithNewPage,
-    removePageFromTree: removePageFromTree,
-    toggleChildren: toggleChildren,
-    togglePlaneFromTree: togglePlaneFromTree
-});
-
-class Tree {
-    constructor(data) {
-        this.data = data;
-    }
-    compute() {
-        const {planes: planes, view: view, configuration: configuration} = this.data;
-        return computeSpaceTree(planes, view, configuration);
-    }
-}
-
-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) => {
-    const registeredPlanes = getRegisteredPlanes(planesRegistrar);
-    const spaceTree = new Tree({
-        planes: registeredPlanes,
-        configuration: configuration,
-        view: view
-    });
-    const computedTree = spaceTree.compute();
-    const stateSpace = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({
-        loading: true,
-        animatedTransform: false,
-        transformTime: 450,
-        scale: 1,
-        rotationX: 0,
-        rotationY: 0,
-        translationX: 0,
-        translationY: 0,
-        translationZ: 0,
-        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: []
-    }, 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,
-        initialTree: computedTree,
-        tree: computedTree
-    });
-    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) => {
-    const specifiedConfiguration = merge(configuration);
-    const stateConfiguration = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, specifiedConfiguration), 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);
-    const stateSpace = resolveSpace(view, stateConfiguration, planesRegistrar, currentState, localState, precomputedState, contextState);
-    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$f as general, index$a as interaction, internatiolate, index$8 as planes, pluridRouterNavigate, index$9 as routing, index$2 as space, index as state, index$h as utilities };
-//# sourceMappingURL=index.es.js.map