@plurid/plurid-engine 0.0.0-1 → 0.0.0-10

package/distribution/index.js

@@ -18,34 +18,6 @@ function _interopDefaultLegacy(e) {
 
 var themes__default = _interopDefaultLegacy(themes);
 
-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$k = Object.freeze({
-    __proto__: null,
-    getWheelDirection: getWheelDirection
-});
-
-const internatiolate = (lamguage, field) => pluridData.internationalization[lamguage][field];
-
 const specifiedOrDefault = (path, type, configuration) => {
     const item = pluridFunctions.objects.getNested(configuration, path);
     if (typeof item === type) {
@@ -99,6 +71,7 @@ const merge = (configuration, target) => {
                 conceal: specifiedOrDefault("elements.toolbar.conceal", "boolean", configuration),
                 transformIcons: specifiedOrDefault("elements.toolbar.transformIcons", "boolean", configuration),
                 transformButtons: specifiedOrDefault("elements.toolbar.transformButtons", "boolean", configuration),
+                drawers: configuration.elements && configuration.elements.toolbar && configuration.elements.toolbar.drawers ? configuration.elements.toolbar.drawers : targetConfiguration.elements.toolbar.drawers,
                 toggledDrawers: configuration.elements && configuration.elements.toolbar && configuration.elements.toolbar.toggledDrawers ? configuration.elements.toolbar.toggledDrawers : targetConfiguration.elements.toolbar.toggledDrawers
             },
             viewcube: {
@@ -126,6 +99,7 @@ const merge = (configuration, target) => {
             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),
@@ -156,94 +130,11 @@ const merge = (configuration, target) => {
     return mergedConfiguration;
 };
 
-var index$j = Object.freeze({
+var index$k = Object.freeze({
     __proto__: null,
     merge: merge
 });
 
-const createIndexed = items => pluridFunctions.indexing.create(items);
-
-var index$i = Object.freeze({
-    __proto__: null,
-    createIndexed: createIndexed
-});
-
-const registerPaths = pages => {
-    const paths = [];
-    for (const page of pages) {
-        const handledPath = handlePath(page.path);
-        const path = {
-            id: pluridFunctions.uuid.generate(),
-            pageID: page.id,
-            address: page.path,
-            parameters: handledPath.parameters
-        };
-        paths.push(path);
-    }
-    return paths;
-};
-
-const handlePath = path => ({
-    regex: ""
-});
-
-const composePathRegex = match => {
-    let reString = "";
-    for (const matched of match) {
-        if (!subpathIsParameter(matched)) {
-            reString += matched.replace("/", "\\/");
-        } else {
-            reString += "\\/([^\\/]+)";
-        }
-    }
-    return reString;
-};
-
-const subpathIsParameter = subpath => subpath[0] === "/" && subpath[1] === ":";
-
-var index$h = Object.freeze({
-    __proto__: null,
-    registerPaths: registerPaths,
-    composePathRegex: composePathRegex,
-    subpathIsParameter: subpathIsParameter
-});
-
-const createInternalStatePlane = plane => {
-    const statePlane = {
-        id: pluridFunctions.uuid.generate(),
-        path: plane.route
-    };
-    return statePlane;
-};
-
-const createInternalContextPlane = plane => {
-    const {route: route, component: component} = plane;
-    const contextPlane = {
-        id: pluridFunctions.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);
-};
-
-var index$g = Object.freeze({
-    __proto__: null,
-    createInternalStatePlane: createInternalStatePlane,
-    createInternalContextPlane: createInternalContextPlane,
-    getPluridPlaneIDByData: getPluridPlaneIDByData
-});
-
 const extractPathname = location => {
     const queryIndex = location.indexOf("?");
     const noQueryPath = queryIndex === -1 ? location : location.substring(0, queryIndex);
@@ -298,7 +189,7 @@ const computeComparingPath = (path, parameters) => {
             comparingPathElements[index] = parameters[index];
         }
     }
-    const comparingPath = "/" + comparingPathElements.join("/");
+    const comparingPath = comparingPathElements.join("/");
     return {
         locationElements: locationElements,
         comparingPath: comparingPath
@@ -414,54 +305,77 @@ const extractOccurence = occurence => {
     return occurenceValue;
 };
 
-class Parser {
-    constructor(location, path, options) {
-        this.location = location;
-        this.path = path;
-        this.options = this.handleOptions(options);
+const stringInsertInitial = (value, insert) => {
+    if (!value.startsWith(insert)) {
+        value = insert + value;
     }
-    handleOptions(options) {
-        const parserOptions = {
-            fragment: (options === null || options === void 0 ? void 0 : options.fragment) || true
-        };
-        return parserOptions;
+    return value;
+};
+
+const stringRemoveTrailing = (value, trail) => {
+    if (value.endsWith(trail)) {
+        value = value.slice(0, value.length - trail.length);
     }
-    extractPathname() {
-        const pathname = extractPathname(this.location);
-        return pathname;
+    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") {
+        origin = location.host;
     }
-    extractParametersAndMatch() {
-        const parametersAndMatch = extractParametersAndMatch(this.location, this.path.value);
-        return parametersAndMatch;
+    const cleanPlane = extractPathname(plane);
+    const planeAddressType = checkPlaneAddressType(cleanPlane);
+    switch (planeAddressType) {
+      case "http":
+      case "https":
+      case "pttp":
+        return cleanPlane;
     }
-    extractQuery() {
-        const query = extractQuery(this.location);
-        return query;
+    origin = stringRemoveTrailing(origin, "/");
+    const absolutePlane = isAbsolutePlane(plane);
+    const path = route && route !== "/" ? absolutePlane ? cleanupPath(cleanPlane) : cleanupPath(route) + cleanupPath(cleanPlane) : cleanupPath(cleanPlane);
+    const planeAddress = pluridData.protocols.plurid + origin + path;
+    return planeAddress;
+};
+
+const isAbsolutePlane = value => value[0] === "/";
+
+const checkPlaneAddressType = value => {
+    value = value.toLowerCase().trim();
+    if (value.startsWith(pluridData.protocols.plurid)) {
+        return "pttp";
     }
-    extractFragments() {
-        const fragments = this.options.fragment ? extractFragments(this.location) : extractFragments();
-        return fragments;
+    if (value.startsWith(pluridData.protocols.https)) {
+        return pluridData.HTTPS_PROTOCOL;
     }
-    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;
+    if (value.startsWith(pluridData.protocols.http)) {
+        return pluridData.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;
@@ -486,9 +400,7 @@ const checkParameterLength = (parameter, length, compareType) => {
     }
 };
 
-const checkValidPath$1 = data => {
-    const {path: path, parameters: parameters} = data;
-    const {parameters: validationParameters} = path;
+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;
@@ -514,35 +426,6 @@ const checkValidPath$1 = data => {
     return true;
 };
 
-class Matcher {
-    constructor(location, path, options) {
-        this.location = location;
-        this.path = path;
-        this.options = this.handleOptions(options);
-        this.checkMatch();
-    }
-    handleOptions(options) {
-        const matcherOptions = {};
-        return matcherOptions;
-    }
-    checkMatch() {
-        const parsedLocation = new Parser(this.location, this.path);
-        const parserResponse = parsedLocation.extract();
-        if (parserResponse.match) {
-            const validPath = checkValidPath$1(parserResponse);
-            if (validPath) {
-                const matcherResponse = Object.assign({}, parserResponse);
-                this.matchedData = matcherResponse;
-            } else {
-                this.matchedData = undefined;
-            }
-        }
-    }
-    data() {
-        return this.matchedData;
-    }
-}
-
 const cleanPathElement = path => {
     if (path[0] === "/") {
         return path.slice(1);
@@ -550,7 +433,7 @@ const cleanPathElement = path => {
     return path;
 };
 
-var index$f = Object.freeze({
+var index$j = Object.freeze({
     __proto__: null,
     cleanPathElement: cleanPathElement
 });
@@ -808,402 +691,103 @@ const resolveRoute = (route, protocol, host) => {
             route: absoluteRoute
         };
     }
-    const resolvers = [ protocolDivision, hostDivision.value, path.value, space.value, universe.value, cluster.value, cleanPathElement(plane.value) ];
-    const absoluteRoute = resolvers.join(separator);
+    [ protocolDivision, hostDivision.value, path.value, space.value, universe.value, cluster.value, cleanPathElement(plane.value) ];
     return {
-        protocol: protocolDivision,
-        host: hostDivision,
+        protocol: "",
+        host: "",
         path: path,
-        space: space,
-        universe: universe,
-        cluster: cluster,
-        plane: plane,
-        route: absoluteRoute
+        space: "",
+        universe: "",
+        cluster: "",
+        plane: "",
+        route: route
     };
 };
 
-const findPathByDivisions = (paths, queryData) => {
-    const pathDivisions = pluridLinkPathDivider(queryData);
-    for (const path of paths) {
-        if (path.value === pathDivisions.path.value || path.value === "/" && pathDivisions.path.value === "p") {
-            console.log("path", path);
-            if (path.spaces) {
-                for (const space of path.spaces) {
-                    if (space.value === pathDivisions.space.value || space.value === "default" && pathDivisions.space.value === "s") {
-                        console.log("space", space);
-                        if (space.universes) {
-                            for (const universe of space.universes) {
-                                if (universe.value === pathDivisions.universe.value || universe.value === "default" && pathDivisions.universe.value === "u") {
-                                    console.log("universe", universe);
-                                    if (universe.clusters) {
-                                        for (const cluster of universe.clusters) {
-                                            if (cluster.value === pathDivisions.cluster.value || cluster.value === "default" && pathDivisions.cluster.value === "c") {
-                                                console.log("cluster", cluster);
-                                                if (cluster.planes) {
-                                                    for (const plane of cluster.planes) {
-                                                        console.log("plane", plane);
-                                                        if (plane.value === pathDivisions.plane.value) {
-                                                            return {
-                                                                path: path,
-                                                                pathname: path.value,
-                                                                parameters: {},
-                                                                query: {},
-                                                                fragments: {
-                                                                    texts: [],
-                                                                    elements: []
-                                                                },
-                                                                route: ""
-                                                            };
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return;
+const createTreePlane = (contextPlane, documentPlane) => {
+    const routeDivisions = pluridLinkPathDivider(contextPlane.path);
+    const treePlane = Object.assign(Object.assign({}, pluridData.defaultTreePlane), {
+        routeDivisions: routeDivisions,
+        sourceID: contextPlane.id,
+        planeID: pluridFunctions.uuid.generate(),
+        route: contextPlane.path,
+        show: true
+    });
+    return treePlane;
 };
 
-class Router {
-    constructor(paths, options) {
-        this.paths = paths;
-        this.options = this.handleOptions(options);
-        this.cachedMatched = {};
-    }
-    handleOptions(options) {
-        const routerOptions = {
-            cacheLimit: (options === null || options === void 0 ? void 0 : options.cacheLimit) || 1e3,
-            gateway: options === null || options === void 0 ? void 0 : options.gateway
-        };
-        return routerOptions;
-    }
-    checkCacheReset() {
-        if (Object.entries(this.cachedMatched).length > this.options.cacheLimit) {
-            this.cachedMatched = {};
-        }
-    }
-    match(location) {
-        if (location === this.options.gateway) {
-            const query = extractQuery(window.location.search);
-            if (query.plurid) {
-                const path = findPathByDivisions(this.paths, query.plurid);
-                if (path) {
-                    return path;
-                }
-                console.log("GATEWAY");
-                console.log("query", query);
-                console.log("paths", this.paths);
-            }
-            if (query.plurids) {
-                const split = query.plurids.split(",");
-                const paths = [];
-                for (const plurid of split) {
-                    const path = findPathByDivisions(this.paths, plurid);
-                    if (path) {
-                        paths.push(path);
-                    }
-                }
-                console.log("GATEWAY");
-                console.log("query", query);
-                console.log("paths", this.paths);
-                console.log("paths", paths);
-            }
-        }
-        const cached = this.cachedMatched[location];
-        if (cached) {
-            this.checkCacheReset();
-            return cached;
-        }
-        for (const path of this.paths) {
-            const matcher = new Matcher(location, path);
-            const data = matcher.data();
-            if (data) {
-                this.cachedMatched[location] = Object.assign({}, data);
-                return data;
-            }
+const updateTreePlane$1 = (tree, page) => {
+    const updatedTree = tree.map((treePlane => {
+        if (treePlane.planeID === page.planeID) {
+            return Object.assign({}, page);
         }
-        return;
-    }
-}
-
-const processRoute = route => {
-    const routeElements = splitPath(route.value);
-    const parametersValues = [];
-    routeElements.map((routeElement => {
-        if (routeElement[0] === ":") {
-            parametersValues.push(routeElement);
-        } else {
-            parametersValues.push("");
+        if (treePlane.children) {
+            return Object.assign(Object.assign({}, treePlane), {
+                children: updateTreePlane$1(treePlane.children, page)
+            });
         }
+        return treePlane;
     }));
-    const processedRoute = {
-        value: route.value,
-        parametersValues: parametersValues,
-        parameters: route.parameters
-    };
-    return processedRoute;
+    return updatedTree;
 };
 
-const matchRoutes = (route, routes) => {
-    for (const processedRoute of Object.values(routes)) {
-        const match = matchRoute(route, processedRoute);
-        if (!match) {
-            continue;
+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;
         }
-        return match;
-    }
-    return;
+        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;
 };
 
-const matchRoute = (route, processedRoute) => {
-    const {locationElements: locationElements, comparingPath: comparingPath} = computeComparingPath(route, processedRoute.parametersValues);
-    if (comparingPath !== processedRoute.value) {
-        return;
-    }
-    const parametersValues = extractParametersValues(processedRoute.parametersValues, locationElements);
-    const validPath = checkValidPath(parametersValues, processedRoute.parameters);
-    if (!validPath) {
-        return;
-    }
-    const internalMatchedRoute = {
-        target: processedRoute.value,
-        source: route,
-        parameters: parametersValues
-    };
-    return internalMatchedRoute;
-};
+var index$i = Object.freeze({
+    __proto__: null,
+    createTreePlane: createTreePlane,
+    updateTreePlane: updateTreePlane$1,
+    updateTreeByPlaneIDWithLinkCoordinates: updateTreeByPlaneIDWithLinkCoordinates
+});
 
-const extractRouteElements = route => {
-    const splitPath = route.split("?");
-    const path = splitPath[0] || "";
-    const queryAndFragment = splitPath[1] || "";
-    const splitQuery = queryAndFragment.split("#");
-    const query = splitQuery[0] || "";
-    const fragment = splitQuery[1] || "";
-    const routeElements = {
-        path: path,
-        query: query,
-        fragment: fragment
-    };
-    return routeElements;
-};
+var index$h = Object.freeze({
+    __proto__: null,
+    configuration: index$k,
+    tree: index$i
+});
 
-const checkValidPath = (parameters, validationParameters) => {
-    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 CATCH_ALL_ROUTE = "*";
-
-class URLRouter {
-    constructor(routes) {
-        this.routes = this.processRoutes(routes);
-    }
-    match(route) {
-        const routeElements = extractRouteElements(route);
-        const {path: path} = routeElements;
-        if (this.routes[path]) {
-            const matchedRoute = matchRoute(path, this.routes[path]);
-            if (matchedRoute) {
-                const {target: target, source: source, parameters: parameters} = matchedRoute;
-                return {
-                    elements: routeElements,
-                    target: target,
-                    source: source,
-                    parameters: parameters
-                };
-            }
-        }
-        const matchedRoute = matchRoutes(path, this.routes);
-        if (matchedRoute) {
-            const {target: target, source: source, parameters: parameters} = matchedRoute;
-            return {
-                elements: routeElements,
-                target: target,
-                source: source,
-                parameters: parameters
-            };
-        }
-        if (this.routes[CATCH_ALL_ROUTE]) {
-            const matchedRoute = matchRoute(path, this.routes[CATCH_ALL_ROUTE]);
-            if (matchedRoute) {
-                const {target: target, source: source, parameters: parameters} = matchedRoute;
-                return {
-                    elements: routeElements,
-                    target: target,
-                    source: source,
-                    parameters: parameters
-                };
-            }
-        }
-        return;
+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";
     }
-    processRoutes(routes) {
-        const index = {};
-        for (const route of routes) {
-            const processedRoute = processRoute(route);
-            index[processedRoute.value] = Object.assign({}, processedRoute);
-        }
-        return index;
+    if (wheelDeltaX < THRESHOLD && absWheelDeltaY < ABSTHRESHOLD && absWheelDeltaX > absWheelDeltaY) {
+        direction = "right";
     }
-}
-
-var index$e = Object.freeze({
-    __proto__: null,
-    default: Router,
-    URLRouter: URLRouter,
-    RouteMatcher: Matcher,
-    RouteParser: Parser,
-    mapPathsToRoutes: mapPathsToRoutes,
-    pluridLinkPathDivider: pluridLinkPathDivider,
-    resolveRoute: resolveRoute,
-    extractQuery: extractQuery
-});
-
-const createTreePlane = (contextPlane, documentPlane) => {
-    const routeDivisions = pluridLinkPathDivider(contextPlane.path);
-    const treePlane = Object.assign(Object.assign({}, pluridData.defaultTreePlane), {
-        routeDivisions: routeDivisions,
-        sourceID: contextPlane.id,
-        planeID: pluridFunctions.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$d = Object.freeze({
-    __proto__: null,
-    createTreePlane: createTreePlane,
-    updateTreePlane: updateTreePlane$1,
-    updateTreeByPlaneIDWithLinkCoordinates: updateTreeByPlaneIDWithLinkCoordinates
-});
-
-const createInternalStateUniverse = universe => {
-    const statePlanes = universe.planes.map((plane => {
-        const internalStatePlane = createInternalStatePlane(plane);
-        return internalStatePlane;
-    }));
-    const indexedStatePlanes = createIndexed(statePlanes);
-    const paths = registerPaths(statePlanes);
-    const indexedPaths = createIndexed(paths);
-    const stateUniverse = {
-        name: universe.name,
-        planes: indexedStatePlanes,
-        paths: indexedPaths,
-        id: universe.id || pluridFunctions.uuid.generate(),
-        ordinal: universe.ordinal || 0,
-        active: universe.active || false
-    };
-    return stateUniverse;
-};
-
-const createInternalContextUniverse = universe => {
-    const contextPlanes = universe.planes.map((plane => {
-        const internalContextPlane = createInternalContextPlane(plane);
-        return internalContextPlane;
-    }));
-    const indexedContextPlanes = createIndexed(contextPlanes);
-    const contextUniverse = {
-        name: universe.name,
-        planes: indexedContextPlanes,
-        id: universe.id || pluridFunctions.uuid.generate()
-    };
-    return contextUniverse;
-};
-
-const findActiveUniverse = universes => {
-    if (universes.length === 0) {
-        return "";
+    if (wheelDeltaY > THRESHOLD && absWheelDeltaX < ABSTHRESHOLD && absWheelDeltaY > absWheelDeltaX) {
+        direction = "up";
     }
-    let activeUniverseID = universes[0].id;
-    for (const universe of universes) {
-        if (universe.active) {
-            activeUniverseID = universe.id;
-            break;
-        }
+    if (wheelDeltaY < THRESHOLD && absWheelDeltaX < ABSTHRESHOLD && absWheelDeltaY > absWheelDeltaX) {
+        direction = "down";
     }
-    return activeUniverseID;
+    return direction;
 };
 
-var index$c = Object.freeze({
-    __proto__: null,
-    createInternalStateUniverse: createInternalStateUniverse,
-    createInternalContextUniverse: createInternalContextUniverse,
-    findActiveUniverse: findActiveUniverse
-});
-
-var index$b = Object.freeze({
+var index$g = Object.freeze({
     __proto__: null,
-    configuration: index$j,
-    universes: index$c,
-    helpers: index$i,
-    planes: index$g,
-    paths: index$h,
-    tree: index$d
+    getWheelDirection: getWheelDirection
 });
 
 const degToRad = deg => deg * .01745329252;
@@ -1314,7 +898,7 @@ function makeRotationMatrixFromQuaternion(quaternion) {
     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$a = Object.freeze({
+var index$f = Object.freeze({
     __proto__: null,
     degToRad: degToRad,
     radToDeg: radToDeg,
@@ -1338,7 +922,7 @@ function rotateMatrix(xAngle, yAngle, zAngle = 0) {
     return rotationMatrix;
 }
 
-function translateMatrix(x, y, z) {
+function translateMatrix$1(x, y, z) {
     return [ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, x, y, z, 1 ];
 }
 
@@ -1346,7 +930,7 @@ function scaleMatrix(s) {
     return [ s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1 ];
 }
 
-function multiplyMatrices(matrixA, matrixB) {
+function multiplyMatrices$1(matrixA, matrixB) {
     const result = [];
     const a00 = matrixA[0];
     const a01 = matrixA[1];
@@ -1402,7 +986,7 @@ function multiplyMatrices(matrixA, matrixB) {
 function multiplyArrayOfMatrices(matrices) {
     let inputMatrix = matrices[0];
     for (let i = 1; i < matrices.length; i++) {
-        inputMatrix = multiplyMatrices(inputMatrix, matrices[i]);
+        inputMatrix = multiplyMatrices$1(inputMatrix, matrices[i]);
     }
     return inputMatrix;
 }
@@ -1411,16 +995,105 @@ function matrixArrayToCSSMatrix(array) {
     return "matrix3d(" + array.join(",") + ")";
 }
 
-var index$9 = Object.freeze({
+var index$e = Object.freeze({
     __proto__: null,
     rotateMatrix: rotateMatrix,
-    translateMatrix: translateMatrix,
+    translateMatrix: translateMatrix$1,
     scaleMatrix: scaleMatrix,
-    multiplyMatrices: multiplyMatrices,
+    multiplyMatrices: multiplyMatrices$1,
     multiplyArrayOfMatrices: multiplyArrayOfMatrices,
     matrixArrayToCSSMatrix: matrixArrayToCSSMatrix
 });
 
+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 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 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;
+};
+
+var index$d = Object.freeze({
+    __proto__: null,
+    multiplyMatrices: multiplyMatrices,
+    arrayToMatrix: arrayToMatrix,
+    matrixToArray: matrixToArray,
+    printMatrix: printMatrix,
+    rotateXMatrix: rotateXMatrix,
+    rotateYMatrix: rotateYMatrix,
+    rotateZMatrix: rotateZMatrix,
+    translateMatrix: translateMatrix
+});
+
 function getMatrixValues(matrix3d) {
     const matrixValues = matrix3d.split("(")[1].split(")")[0].split(",");
     const matrixValuesInt = [];
@@ -1550,7 +1223,7 @@ function rotatePlurid(matrix3d, direction = "", angleIncrement = .07) {
     const translateZ = transformTranslate.translateZ;
     const scale = getTransformScale(matrix3d).scale;
     let valRotationMatrix = rotateMatrix(rotateX, rotateY, rotateZ);
-    const valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
+    const valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
     const valScalationMatrix = scaleMatrix(scale);
     if (direction === "left") {
         rotateY -= angleIncrement;
@@ -1583,73 +1256,552 @@ function translatePlurid(matrix3d, direction = "", linearIncrement = 50) {
     const translateZ = transformTranslate.translateZ;
     const scale = getTransformScale(matrix3d).scale;
     const valRotationMatrix = rotateMatrix(rotateX, rotateY, rotateZ);
-    let valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
+    let valTranslationMatrix = translateMatrix$1(translateX, translateY, translateZ);
     const valScalationMatrix = scaleMatrix(scale);
     scale < .5 ? linearIncrement = 50 : linearIncrement = 30;
     if (direction === "left") {
         translateX += linearIncrement;
-        valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
+        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(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$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) => pluridData.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: pluridFunctions.uuid.generate(),
+        path: planeData.route
+    };
+    return statePlane;
+};
+
+const createInternalContextPlane = plane => {
+    const planeData = resolvePluridPlaneData(plane);
+    const {route: route, component: component} = planeData;
+    const contextPlane = {
+        id: pluridFunctions.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 = [];
+        if (origin === "origin" && typeof location !== "undefined") {
+            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(pluridData.protocols.plurid, "");
+            const normalizedPlaneAddress = planeAddress.replace(pluridData.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) {
+        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,
+                    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) => {
+    if (!planes) {
+        return;
     }
-    if (direction === "right") {
-        translateX -= linearIncrement;
-        valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
+    if (planesRegistrar) {
+        planesRegistrar.register(planes);
+        return;
     }
-    if (direction === "up") {
-        translateY += linearIncrement;
-        valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
+    if (typeof window === "undefined") {
+        return;
     }
-    if (direction === "down") {
-        translateY -= linearIncrement;
-        valTranslationMatrix = translateMatrix(translateX, translateY, translateZ);
+    if (typeof window.__pluridPlanesRegistrar__ === "undefined") {
+        const pluridPlanesRegistrar = new PluridPlanesRegistrar;
+        window.__pluridPlanesRegistrar__ = pluridPlanesRegistrar;
+        window.__pluridPlanesRegistrar__.register(planes);
+        return;
     }
-    const transformedMatrix3d = setTransform(valRotationMatrix, valTranslationMatrix, valScalationMatrix);
-    return transformedMatrix3d;
-}
+    window.__pluridPlanesRegistrar__.register(planes);
+    return;
+};
 
-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;
+const getPlanesRegistrar = planesRegistrar => {
+    if (planesRegistrar) {
+        return planesRegistrar;
+    }
+    if (typeof window !== "undefined") {
+        if (window.__pluridPlanesRegistrar__ !== undefined) {
+            return window.__pluridPlanesRegistrar__;
         }
-        valScalationMatrix = scaleMatrix(scale);
     }
-    if (direction === "down") {
-        scale += scaleIncrement;
-        if (scale > 4) {
-            scale = 4;
+    return;
+};
+
+const getRegisteredPlanes = planesRegistrar => {
+    if (planesRegistrar) {
+        return planesRegistrar.getAll();
+    }
+    if (typeof window !== "undefined") {
+        if (window.__pluridPlanesRegistrar__ !== undefined) {
+            return window.__pluridPlanesRegistrar__.getAll();
         }
-        valScalationMatrix = scaleMatrix(scale);
     }
-    const transformedMatrix3d = setTransform(valRotationMatrix, valTranslationMatrix, valScalationMatrix);
-    return transformedMatrix3d;
-}
+    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,
-    getMatrixValues: getMatrixValues,
-    getRotationMatrix: getRotationMatrix,
-    getTranslationMatrix: getTranslationMatrix,
-    getScalationValue: getScalationValue,
-    setTransform: setTransform,
-    getTransformRotate: getTransformRotate,
-    getTransformTranslate: getTransformTranslate,
-    getTransformScale: getTransformScale,
-    rotatePlurid: rotatePlurid,
-    translatePlurid: translatePlurid,
-    scalePlurid: scalePlurid
+    resolvePluridPlaneData: resolvePluridPlaneData,
+    resolvePluridRoutePlaneData: resolvePluridRoutePlaneData,
+    createInternalStatePlane: createInternalStatePlane,
+    createInternalContextPlane: createInternalContextPlane,
+    getPluridPlaneIDByData: getPluridPlaneIDByData,
+    registerPlanes: registerPlanes,
+    getPlanesRegistrar: getPlanesRegistrar,
+    getRegisteredPlanes: getRegisteredPlanes,
+    getRegisteredPlane: getRegisteredPlane,
+    Registrar: PluridPlanesRegistrar
 });
 
 const computeSpaceSize = tree => {
@@ -1973,93 +2125,29 @@ var index$5 = Object.freeze({
     computeZigZagLayout: computeZigZagLayout
 });
 
-const matchRouteElements = (routePath, viewPath) => {
-    if (routePath === viewPath) {
-        return {
-            value: viewPath,
-            parameters: {},
-            query: {}
-        };
-    }
-    const parameters = [];
-    const routeSplit = routePath.split("/");
-    routeSplit.forEach((routeElement => {
-        if (routeElement[0] === ":") {
-            parameters.push(routeElement);
-        } else {
-            parameters.push("");
-        }
-    }));
-    const {locationElements: locationElements, comparingPath: comparingPath} = computeComparingPath(viewPath, parameters);
-    if (comparingPath !== "/" + routePath) {
-        return;
-    }
-    const parametersValues = extractParametersValues(parameters, locationElements);
-    return {
-        value: viewPath,
-        parameters: parametersValues,
-        query: {}
-    };
-};
-
-const matchRouteToView = (route, view) => {
-    const routeSplit = route.split(pluridData.PLURID_ROUTE_SEPARATOR);
-    const viewSplit = view.split(pluridData.PLURID_ROUTE_SEPARATOR);
-    if (routeSplit.length !== viewSplit.length) {
-        return;
-    }
-    const routePath = routeSplit[2];
-    const viewPath = viewSplit[2];
-    const pathMatch = matchRouteElements(routePath, viewPath);
-    if (!pathMatch) {
-        return;
-    }
-    const routeSpace = routeSplit[3];
-    const viewSpace = viewSplit[3];
-    const spaceMatch = matchRouteElements(routeSpace, viewSpace);
-    if (!spaceMatch) {
-        return;
-    }
-    const routeUniverse = routeSplit[4];
-    const viewUniverse = viewSplit[4];
-    const universeMatch = matchRouteElements(routeUniverse, viewUniverse);
-    if (!universeMatch) {
-        return;
-    }
-    const routeCluster = routeSplit[5];
-    const viewCluster = viewSplit[5];
-    const clusterMatch = matchRouteElements(routeCluster, viewCluster);
-    if (!clusterMatch) {
-        return;
-    }
-    const routePlane = routeSplit[6];
-    const viewPlane = viewSplit[6];
-    const planeMatch = matchRouteElements(routePlane, viewPlane);
-    if (!planeMatch) {
-        return;
-    }
-    return {
-        path: Object.assign({}, pathMatch),
-        space: Object.assign({}, spaceMatch),
-        universe: Object.assign({}, universeMatch),
-        cluster: Object.assign({}, clusterMatch),
-        plane: Object.assign({}, planeMatch)
-    };
-};
-
 const resolveViewItem = (planes, view, configuration) => {
     const {protocol: protocol, host: host} = configuration.network;
     const viewData = typeof view === "string" ? view : view.plane;
-    const resolvedView = resolveRoute(viewData, protocol, host);
-    for (const [route, _] of planes) {
-        const routeMatch = matchRouteToView(route, resolvedView.route);
-        if (!routeMatch) {
-            continue;
-        }
+    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: pluridFunctions.uuid.generate(),
-            route: resolvedView.route,
+            route: viewAddress,
             routeDivisions: {
                 protocol: {
                     value: "",
@@ -2069,11 +2157,35 @@ const resolveViewItem = (planes, view, configuration) => {
                     value: host,
                     controlled: true
                 },
-                path: routeMatch.path,
-                space: routeMatch.space,
-                universe: routeMatch.universe,
-                cluster: routeMatch.cluster,
-                plane: routeMatch.plane,
+                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,
@@ -2180,16 +2292,16 @@ const assignPagesFromView = (planes, view) => {
 };
 
 const updateTreePlane = (tree, updatedPage) => {
-    const updatedTree = tree.map((page => {
-        if (page.planeID === updatedPage.planeID) {
+    const updatedTree = tree.map((treePlane => {
+        if (treePlane.planeID === updatedPage.planeID) {
             return updatedPage;
         }
-        if (page.children) {
-            const pageTree = updateTreePlane(page.children, updatedPage);
-            page.children = pageTree;
-            return page;
+        if (treePlane.children) {
+            const pageTree = updateTreePlane(treePlane.children, updatedPage);
+            treePlane.children = pageTree;
+            return treePlane;
         }
-        return page;
+        return treePlane;
     }));
     return updatedTree;
 };
@@ -2232,7 +2344,8 @@ const updateTreeWithNewPlane = (planeRoute, parentPlaneID, linkCoordinates, tree
     const updatedTree = updateTreePlane(tree, updatedParentPlane);
     return {
         pluridPlaneID: updatedTreePlane.planeID,
-        updatedTree: updatedTree
+        updatedTree: updatedTree,
+        updatedTreePlane: updatedTreePlane
     };
 };
 
@@ -2352,24 +2465,32 @@ const toggleChildren = children => {
 
 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,
+    let updatedPlane;
+    for (const plane of tree) {
+        if (plane.planeID === pluridPlaneID) {
+            const treeUpdatedPlane = Object.assign(Object.assign({}, plane), {
+                show: !plane.show,
                 children: []
             });
-            updatedTree.push(updatedPage);
+            updatedTree.push(treeUpdatedPlane);
+            updatedPlane = Object.assign({}, treeUpdatedPlane);
             continue;
         }
-        if (page.children) {
-            const pageTree = togglePlaneFromTree(page.children, pluridPlaneID);
-            page.children = [ ...pageTree ];
-            updatedTree.push(page);
+        if (plane.children) {
+            const {updatedTree: childrenUpdatedTree, updatedPlane: childrenUpdatedPlane} = togglePlaneFromTree(plane.children, pluridPlaneID);
+            plane.children = [ ...childrenUpdatedTree ];
+            updatedTree.push(plane);
+            if (childrenUpdatedPlane) {
+                updatedPlane = Object.assign({}, childrenUpdatedPlane);
+            }
             continue;
         }
-        updatedTree.push(page);
+        updatedTree.push(plane);
     }
-    return updatedTree;
+    return {
+        updatedTree: updatedTree,
+        updatedPlane: updatedPlane
+    };
 };
 
 var logic = Object.freeze({
@@ -2461,106 +2582,6 @@ var index$2 = Object.freeze({
     view: index$3
 });
 
-class PluridPlanesRegistrar {
-    constructor() {
-        this.planes = new Map;
-    }
-    register(planes) {
-        for (const plane of planes) {
-            const {component: component, route: route} = plane;
-            const resolvedRoute = resolveRoute(route, "http", "localhost");
-            const {protocol: protocol, host: host, path: routePath, space: space, universe: universe, cluster: cluster, plane: planePath, route: absoluteRoute} = resolvedRoute;
-            const registeredPluridPlane = {
-                component: component,
-                route: {
-                    protocol: {},
-                    host: {},
-                    path: {},
-                    space: {},
-                    universe: {},
-                    cluster: {},
-                    plane: {},
-                    absolute: absoluteRoute
-                }
-            };
-            this.planes.set(absoluteRoute, registeredPluridPlane);
-        }
-    }
-    identify() {
-        if (this.planes.size === 0) {
-            return [];
-        }
-        const ids = [];
-        for (const [id, _] of this.planes) {
-            ids.push(id);
-        }
-        return ids;
-    }
-    get(route) {
-        return this.planes.get(route);
-    }
-    getAll() {
-        return this.planes;
-    }
-}
-
-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;
-};
-
 const resolveSpace = (view, configuration, planesRegistrar, currentState, localState, precomputedState, contextState) => {
     const registeredPlanes = getRegisteredPlanes(planesRegistrar);
     const spaceTree = new Tree({
@@ -2702,33 +2723,37 @@ var index = Object.freeze({
     local: index$1
 });
 
-exports.PluridPlanesRegistrar = PluridPlanesRegistrar;
+const cleanTemplate = template => template.replace(/(?:\r\n|\r|\n)/g, " ").replace(/  +/g, " ").trim();
 
-exports.direction = index$k;
-
-exports.general = index$b;
+const pluridRouterNavigate = path => {
+    if (!CustomEvent || !window) {
+        return;
+    }
+    const event = new CustomEvent(pluridData.PLURID_ROUTER_LOCATION_CHANGED, {
+        detail: {
+            path: path
+        }
+    });
+    window.dispatchEvent(event);
+};
 
-exports.getPlanesRegistrar = getPlanesRegistrar;
+exports.cleanTemplate = cleanTemplate;
 
-exports.getRegisteredPlane = getRegisteredPlane;
+exports.general = index$h;
 
-exports.getRegisteredPlanes = getRegisteredPlanes;
+exports.interaction = index$a;
 
 exports.internatiolate = internatiolate;
 
-exports.matrix = index$9;
+exports.planes = index$8;
 
-exports.quaternion = index$a;
+exports.pluridRouterNavigate = pluridRouterNavigate;
 
-exports.registerPlanes = registerPlanes;
-
-exports.router = index$e;
+exports.routing = index$9;
 
 exports.space = index$2;
 
 exports.state = index;
 
-exports.transform = index$8;
-
-exports.utilities = index$f;
+exports.utilities = index$j;
 //# sourceMappingURL=index.js.map