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

package/distribution/index.d.ts

@@ -1,2 +1,744 @@
-export * from './modules';
-export * from './functions';
+import * as _plurid_plurid_data from '@plurid/plurid-data';
+import { FlatPluridConfiguration, PluridConfiguration, PluridPartialConfiguration, TreePlane, LinkCoordinates, WheelDeltas, InternationalizationLanguageType, InternationalizationFieldType, PluridPlane, PluridPlaneObject, PluridRoutePlane, PluridRoutePlaneObject, PluridPlanesRegistrar as PluridPlanesRegistrar$1, RegisteredPluridPlane, IsoMatcherData, IsoMatcherRouteResult, IsoMatcherPlaneResult, IsoMatcherIndexedPlane, PluridRoute, Indexed, PluridRouteFragments, CompareType, PluridRouteParameter, RouteDivisions, LocationCoordinates, PluridApplicationView, PluridView, PathParameters, SpaceLocation, RecursivePartial, PluridState, PluridMetastateState, PluridStorageAdapter } from '@plurid/plurid-data';
+
+declare const merge: (configuration?: PluridPartialConfiguration, target?: PluridConfiguration) => PluridConfiguration;
+/**
+ * Build a full `PluridConfiguration` from a FLAT shorthand, so consumers can configure the common
+ * options without authoring the 5-level nested object. Flat fields are expanded to their nested
+ * locations, then `extend` (a normal nested partial) is layered on top, then the whole thing is
+ * merged over the defaults via `merge` (which also resolves `theme`). Anything omitted keeps its
+ * default. Returns a complete, ready-to-use configuration.
+ *
+ * @example
+ * definePluridConfiguration({ theme: 'plurid', center: true, planeWidth: 0.32, bridgeLength: 160 })
+ */
+declare const definePluridConfiguration: (flat?: FlatPluridConfiguration) => PluridConfiguration;
+
+declare const index$k_definePluridConfiguration: typeof definePluridConfiguration;
+declare const index$k_merge: typeof merge;
+declare namespace index$k {
+  export { index$k_definePluridConfiguration as definePluridConfiguration, index$k_merge as merge };
+}
+
+declare const updateTreePlane$1: (tree: TreePlane[], page: TreePlane) => TreePlane[];
+declare const updateTreeByPlaneIDWithLinkCoordinates: (tree: TreePlane[], planeID: string, linkCoordinates: LinkCoordinates) => TreePlane[];
+
+declare const index$j_updateTreeByPlaneIDWithLinkCoordinates: typeof updateTreeByPlaneIDWithLinkCoordinates;
+declare namespace index$j {
+  export { index$j_updateTreeByPlaneIDWithLinkCoordinates as updateTreeByPlaneIDWithLinkCoordinates, updateTreePlane$1 as updateTreePlane };
+}
+
+declare namespace index$i {
+  export { index$k as configuration, index$j as tree };
+}
+
+declare const getWheelDirection: (deltas: WheelDeltas, ABSTHRESHOLD?: number, THRESHOLD?: number) => string;
+
+declare const index$h_getWheelDirection: typeof getWheelDirection;
+declare namespace index$h {
+  export { index$h_getWheelDirection as getWheelDirection };
+}
+
+/**
+ *
+ * @param xAngle
+ * @param yAngle
+ * @param zAngle
+ */
+declare function rotateMatrix(xAngle: number, yAngle: number, zAngle?: number): number[];
+/**
+ *
+ * @param x
+ * @param y
+ * @param z
+ */
+declare function translateMatrix$1(x: number, y: number, z: number): number[];
+/**
+ *
+ * @param s
+ */
+declare function scaleMatrix$1(s: number): number[];
+/**
+ *
+ * @param matrixA
+ * @param matrixB
+ */
+declare function multiplyMatrices$1(matrixA: number[], matrixB: number[]): number[];
+/**
+ *
+ * @param matrices
+ */
+declare function multiplyArrayOfMatrices(matrices: number[][]): number[];
+declare function matrixArrayToCSSMatrix(array: number[]): string;
+
+declare const index$g_matrixArrayToCSSMatrix: typeof matrixArrayToCSSMatrix;
+declare const index$g_multiplyArrayOfMatrices: typeof multiplyArrayOfMatrices;
+declare const index$g_rotateMatrix: typeof rotateMatrix;
+declare namespace index$g {
+  export { index$g_matrixArrayToCSSMatrix as matrixArrayToCSSMatrix, index$g_multiplyArrayOfMatrices as multiplyArrayOfMatrices, multiplyMatrices$1 as multiplyMatrices, index$g_rotateMatrix as rotateMatrix, scaleMatrix$1 as scaleMatrix, translateMatrix$1 as translateMatrix };
+}
+
+/**
+ * Converts degrees to radians.
+ *
+ * @param deg
+ * @returns radians
+ */
+declare const degToRad: (deg: number) => number;
+/**
+ * Converts radians to degrees.
+ *
+ * @param deg
+ * @returns degrees
+ */
+declare const radToDeg: (rad: number) => number;
+interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+/**
+ *
+ * @param x
+ * @param y
+ * @param z
+ * @param w
+ * @returns {Quaternion}
+ */
+declare const makeQuaternion: (x: number, y: number, z: number, w: number) => Quaternion;
+/**
+ * Returns all-fields 0-ed quaternion.
+ *
+ * @returns {Quaternion}
+ */
+declare const zeroQuaternion: () => Quaternion;
+/**
+ *
+ * @param quaternion
+ */
+declare function inverseQuaternion(quaternion: Quaternion): Quaternion;
+/**
+ *
+ * @param quaternion
+ */
+declare function conjugateQuaternion(quaternion: Quaternion): Quaternion;
+/**
+ * Generates quaternion based on Euler angles (in radians).
+ *
+ * @param alpha     around Z axis
+ * @param beta      around X axis
+ * @param gamma     around Y axis
+ * @returns {Quaternion}
+ */
+declare function computeQuaternionFromEulers(alpha: number, beta: number, gamma: number, radians?: boolean): Quaternion;
+/**
+ *
+ * @param x
+ * @param y
+ * @param z
+ * @param angle
+ */
+declare function quaternionFromAxisAngle(x: number, y: number, z: number, angle: number): Quaternion;
+/**
+ *
+ * @param quaternionArray
+ */
+declare function quaternionMultiply(quaternionArray: Quaternion[]): Quaternion;
+/**
+ *
+ * @param pointRotate
+ * @param quaternion
+ */
+declare function rotatePointViaQuaternion(pointRotate: [number, number, number], quaternion: Quaternion): Quaternion;
+/**
+ *
+ * @param quaternion
+ */
+declare function makeRotationMatrixFromQuaternion(quaternion: Quaternion): number[];
+
+type index$f_Quaternion = Quaternion;
+declare const index$f_computeQuaternionFromEulers: typeof computeQuaternionFromEulers;
+declare const index$f_conjugateQuaternion: typeof conjugateQuaternion;
+declare const index$f_degToRad: typeof degToRad;
+declare const index$f_inverseQuaternion: typeof inverseQuaternion;
+declare const index$f_makeQuaternion: typeof makeQuaternion;
+declare const index$f_makeRotationMatrixFromQuaternion: typeof makeRotationMatrixFromQuaternion;
+declare const index$f_quaternionFromAxisAngle: typeof quaternionFromAxisAngle;
+declare const index$f_quaternionMultiply: typeof quaternionMultiply;
+declare const index$f_radToDeg: typeof radToDeg;
+declare const index$f_rotatePointViaQuaternion: typeof rotatePointViaQuaternion;
+declare const index$f_zeroQuaternion: typeof zeroQuaternion;
+declare namespace index$f {
+  export { type index$f_Quaternion as Quaternion, index$f_computeQuaternionFromEulers as computeQuaternionFromEulers, index$f_conjugateQuaternion as conjugateQuaternion, index$f_degToRad as degToRad, index$f_inverseQuaternion as inverseQuaternion, index$f_makeQuaternion as makeQuaternion, index$f_makeRotationMatrixFromQuaternion as makeRotationMatrixFromQuaternion, index$f_quaternionFromAxisAngle as quaternionFromAxisAngle, index$f_quaternionMultiply as quaternionMultiply, index$f_radToDeg as radToDeg, index$f_rotatePointViaQuaternion as rotatePointViaQuaternion, index$f_zeroQuaternion as zeroQuaternion };
+}
+
+type Matrix = number[][];
+declare const getInitialMatrix: () => Matrix;
+declare const multiplyMatrices: (m1: Matrix, m2: Matrix) => Matrix;
+/**
+ * Multiplies multiple `matrices`, must contain at least 2.
+ *
+ * @param matrices
+ * @returns
+ */
+declare const multiplyMatricesArray: (matrices: Matrix[]) => Matrix;
+declare const arrayToMatrix: (array: number[]) => Matrix;
+declare const matrixToArray: (matrix: Matrix) => number[];
+/**
+ * Parse a `matrix3d` string into a `Matrix`.
+ *
+ * @param value
+ * @returns
+ */
+declare const matrix3DToMatrix: (value: string) => Matrix;
+declare const rotateXMatrix: (angle: number) => Matrix;
+declare const rotateYMatrix: (angle: number) => Matrix;
+declare const rotateZMatrix: (angle: number) => Matrix;
+declare const translateMatrix: (x?: number, y?: number, z?: number) => Matrix;
+declare const scaleMatrix: (s: number) => Matrix;
+declare function rotationMatrixFromQuaternion(quaternion: Quaternion): Matrix;
+declare const matrixToCSSMatrix: (matrix: Matrix) => string;
+declare const identityMatrix: () => Matrix;
+/**
+ * Inverse a matrix based on
+ * https://github.com/josdejong/mathjs/blob/develop/src/function/matrix/inv.js
+ *
+ * @param matrix
+ * @returns
+ */
+declare const inverseMatrix: (matrix: Matrix) => Matrix;
+
+type index$e_Matrix = Matrix;
+declare const index$e_arrayToMatrix: typeof arrayToMatrix;
+declare const index$e_getInitialMatrix: typeof getInitialMatrix;
+declare const index$e_identityMatrix: typeof identityMatrix;
+declare const index$e_inverseMatrix: typeof inverseMatrix;
+declare const index$e_matrix3DToMatrix: typeof matrix3DToMatrix;
+declare const index$e_matrixToArray: typeof matrixToArray;
+declare const index$e_matrixToCSSMatrix: typeof matrixToCSSMatrix;
+declare const index$e_multiplyMatrices: typeof multiplyMatrices;
+declare const index$e_multiplyMatricesArray: typeof multiplyMatricesArray;
+declare const index$e_rotateXMatrix: typeof rotateXMatrix;
+declare const index$e_rotateYMatrix: typeof rotateYMatrix;
+declare const index$e_rotateZMatrix: typeof rotateZMatrix;
+declare const index$e_rotationMatrixFromQuaternion: typeof rotationMatrixFromQuaternion;
+declare const index$e_scaleMatrix: typeof scaleMatrix;
+declare const index$e_translateMatrix: typeof translateMatrix;
+declare namespace index$e {
+  export { type index$e_Matrix as Matrix, index$e_arrayToMatrix as arrayToMatrix, index$e_getInitialMatrix as getInitialMatrix, index$e_identityMatrix as identityMatrix, index$e_inverseMatrix as inverseMatrix, index$e_matrix3DToMatrix as matrix3DToMatrix, index$e_matrixToArray as matrixToArray, index$e_matrixToCSSMatrix as matrixToCSSMatrix, index$e_multiplyMatrices as multiplyMatrices, index$e_multiplyMatricesArray as multiplyMatricesArray, index$e_rotateXMatrix as rotateXMatrix, index$e_rotateYMatrix as rotateYMatrix, index$e_rotateZMatrix as rotateZMatrix, index$e_rotationMatrixFromQuaternion as rotationMatrixFromQuaternion, index$e_scaleMatrix as scaleMatrix, index$e_translateMatrix as translateMatrix };
+}
+
+/**
+ * Converts the CSS string matrix3d into an array of numbers.
+ *
+ * @param matrix3d      CSS string obtained from
+ *                      window
+ *                          .getComputedStyle(element)
+ *                          .getPropertyValue('transform').
+ * @returns             Numbers array.
+ */
+declare function getMatrixValues(matrix3d: string): number[];
+/**
+ * Extracts the rotation matrix from the matrix3d CSS string.
+ *
+ * @param matrix3d      CSS string obtained from
+ *                      window
+ *                          .getComputedStyle(element)
+ *                          .getPropertyValue("transform").
+ * @returns             Rotation matrix.
+ */
+declare function getRotationMatrix(matrix3d: string): number[];
+/**
+ * Extracts the translation matrix from the matrix3d CSS string.
+ *
+ * @param matrix3d      CSS string obtained from
+ *                      window
+ *                          .getComputedStyle(element)
+ *                          .getPropertyValue("transform").
+ * @returns             Translation matrix.
+ */
+declare function getTranslationMatrix(matrix3d: string): number[];
+/**
+ * Extracts the scalation value from the matrix3d CSS string.
+ *
+ * @param matrix3d      CSS string obtained from
+ *                      window
+ *                          .getComputedStyle(element)
+ *                          .getPropertyValue("transform").
+ * @returns             Scalation value.
+ */
+declare function getScalationValue(matrix3d: string): number;
+/**
+ * Returns a a matrix3d CSS string.
+ *
+ * @param       rotationMatrix
+ * @param       translationMatrix
+ * @param       scalationMatrix
+ * @returns     matrix3d CSS string.
+ */
+declare function setTransform(rotationMatrix: number[], translationMatrix: number[], scalationMatrix: number[]): string;
+interface RotationValues {
+    rotateX: number;
+    rotateY: number;
+    rotateZ: number;
+}
+declare function getTransformRotate(matrix3d: string): RotationValues;
+interface TranslationValues {
+    translateX: number;
+    translateY: number;
+    translateZ: number;
+}
+declare function getTransformTranslate(matrix3d: string): TranslationValues;
+interface ScalationValue {
+    scale: number;
+}
+declare function getTransformScale(matrix3d: string): ScalationValue;
+
+type index$d_RotationValues = RotationValues;
+type index$d_ScalationValue = ScalationValue;
+type index$d_TranslationValues = TranslationValues;
+declare const index$d_getMatrixValues: typeof getMatrixValues;
+declare const index$d_getRotationMatrix: typeof getRotationMatrix;
+declare const index$d_getScalationValue: typeof getScalationValue;
+declare const index$d_getTransformRotate: typeof getTransformRotate;
+declare const index$d_getTransformScale: typeof getTransformScale;
+declare const index$d_getTransformTranslate: typeof getTransformTranslate;
+declare const index$d_getTranslationMatrix: typeof getTranslationMatrix;
+declare const index$d_setTransform: typeof setTransform;
+declare namespace index$d {
+  export { type index$d_RotationValues as RotationValues, type index$d_ScalationValue as ScalationValue, type index$d_TranslationValues as TranslationValues, index$d_getMatrixValues as getMatrixValues, index$d_getRotationMatrix as getRotationMatrix, index$d_getScalationValue as getScalationValue, index$d_getTransformRotate as getTransformRotate, index$d_getTransformScale as getTransformScale, index$d_getTransformTranslate as getTransformTranslate, index$d_getTranslationMatrix as getTranslationMatrix, index$d_setTransform as setTransform };
+}
+
+declare namespace index$c {
+  export { index$e as general, index$d as matrix3d };
+}
+
+declare namespace index$b {
+  export { index$h as direction, index$g as matrix, index$f as quaternion, index$c as transform };
+}
+
+declare const internatiolate: (lamguage: InternationalizationLanguageType, field: InternationalizationFieldType) => string;
+
+declare const resolvePluridPlaneData: <C>(plane: PluridPlane<C>) => PluridPlaneObject<C>;
+declare const resolvePluridRoutePlaneData: <C>(plane: PluridRoutePlane<C>) => PluridRoutePlaneObject<C>;
+declare const getPluridPlaneIDByData: (element: HTMLElement | null) => string;
+
+/**
+ * The planes registrar can be stored in-memory (server-side)
+ * or on the `window.__pluridPlanesRegistrar__` object (browser-side).
+ */
+declare class PluridPlanesRegistrar<C> implements PluridPlanesRegistrar$1<C> {
+    private isoMatcher;
+    constructor(planes?: PluridPlane<C>[], origin?: string);
+    register(planes: PluridPlane<C>[]): void;
+    identify(): string[];
+    get(route: string): RegisteredPluridPlane<C> | undefined;
+    getAll(): Map<any, any>;
+}
+
+declare const registerPlanes: <C>(planes?: PluridPlane<C>[], planesRegistrar?: PluridPlanesRegistrar$1<C>, origin?: string) => void;
+declare const getPlanesRegistrar: <C>(planesRegistrar: PluridPlanesRegistrar$1<C> | undefined) => PluridPlanesRegistrar$1<C> | undefined;
+declare const getRegisteredPlanes: <C>(planesRegistrar: PluridPlanesRegistrar$1<C> | undefined) => Map<any, any>;
+declare const getRegisteredPlane: <C>(route: string, planesRegistrar: PluridPlanesRegistrar$1<C> | undefined) => _plurid_plurid_data.RegisteredPluridPlane<C> | undefined;
+
+declare const index$a_getPlanesRegistrar: typeof getPlanesRegistrar;
+declare const index$a_getPluridPlaneIDByData: typeof getPluridPlaneIDByData;
+declare const index$a_getRegisteredPlane: typeof getRegisteredPlane;
+declare const index$a_getRegisteredPlanes: typeof getRegisteredPlanes;
+declare const index$a_registerPlanes: typeof registerPlanes;
+declare const index$a_resolvePluridPlaneData: typeof resolvePluridPlaneData;
+declare const index$a_resolvePluridRoutePlaneData: typeof resolvePluridRoutePlaneData;
+declare namespace index$a {
+  export { PluridPlanesRegistrar as Registrar, index$a_getPlanesRegistrar as getPlanesRegistrar, index$a_getPluridPlaneIDByData as getPluridPlaneIDByData, index$a_getRegisteredPlane as getRegisteredPlane, index$a_getRegisteredPlanes as getRegisteredPlanes, index$a_registerPlanes as registerPlanes, index$a_resolvePluridPlaneData as resolvePluridPlaneData, index$a_resolvePluridRoutePlaneData as resolvePluridRoutePlaneData };
+}
+
+/**
+ * The `IsoMatcher` gathers all the known information about `routes` and `planes`
+ * and matches client-side or server-side, in-browser or in-plurid.
+ */
+declare class IsoMatcher<C> {
+    private origin;
+    private routesIndex;
+    private planesIndex;
+    private routesKeys;
+    private planesKeys;
+    constructor(data: IsoMatcherData<C>, origin?: string);
+    /**
+     * Matches a `path` with a known `route` or `plane`,
+     * based on the strategy imposed by the `context`.
+     *
+     * @param path
+     * @param context
+     */
+    match(path: string, context: 'route'): IsoMatcherRouteResult<C> | undefined;
+    match(path: string): IsoMatcherPlaneResult<C> | undefined;
+    match(path: string, context: 'plane'): IsoMatcherPlaneResult<C> | undefined;
+    /**
+     * Dynammically update the planes and routes indexes.
+     *
+     * @param data
+     */
+    index(data: IsoMatcherData<C>): void;
+    /**
+     * Clear all data.
+     *
+     */
+    clear(): void;
+    getPlanesIndex(): Map<string, IsoMatcherIndexedPlane<C>>;
+    /**
+     * Creates a common data structure able to match and route accordingly.
+     *
+     */
+    private updateIndexes;
+    private indexPlanes;
+    private matchPlane;
+    private matchRoute;
+}
+
+type ParserPartialOptions = Partial<ParserOptions>;
+interface ParserOptions {
+    /**
+     * Allow the parsing of fragments. Default `true`.
+     */
+    fragment: boolean;
+}
+interface ParserResponse<C> {
+    path: PluridRoute<C>;
+    pathname: string;
+    elements: string[];
+    match: boolean;
+    parameters: Indexed<string>;
+    query: Indexed<string>;
+    fragments: PluridRouteFragments;
+    route: string;
+}
+interface MatcherResponse<C> {
+    path: PluridRoute<C>;
+    pathname: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+    fragments: PluridRouteFragments;
+    route: string;
+}
+interface ParserParametersAndMatch {
+    match: boolean;
+    parameters: Indexed<string>;
+    elements: string[];
+}
+
+declare class Parser<C> {
+    /** properties */
+    private location;
+    private path;
+    private options;
+    /** constructor */
+    constructor(location: string, path: PluridRoute<C>, options?: ParserPartialOptions);
+    /** private */
+    private handleOptions;
+    private extractPathname;
+    private extractParametersAndMatch;
+    private extractQuery;
+    private extractFragments;
+    /** public */
+    /**
+     * Extract pathname, parameters, query, and fragment, if available.
+     */
+    extract(): ParserResponse<C>;
+}
+
+/**
+ * Extract the query values.
+ *
+ * e.g.
+ *
+ * `path = '/foo?id=1&asd=asd'`
+ *
+ * `query = { id: 1, asd: 'asd' }`
+ *
+ * @param path
+ */
+declare const extractQuery: (path: string) => Indexed<string>;
+
+declare const stringInsertInitial: (value: string, insert: string) => string;
+declare const stringRemoveTrailing: (value: string, trail: string) => string;
+declare const cleanupPath: (value: string) => string;
+declare const computePlaneAddress: (plane: string, route?: string, origin?: string) => string;
+declare const isAbsolutePlane: (value: string) => boolean;
+declare const checkPlaneAddressType: (value: string) => "http" | "https" | "pttp" | "relative";
+declare const removeTrailingSlash: (value: string) => string;
+declare const cleanPathValue: (value: string) => string;
+
+declare const checkParameterLength: (parameter: string, length: number, compareType?: CompareType) => boolean;
+declare const checkValidPath: <C>(validationParameters: Record<string, PluridRouteParameter> | undefined, parameters: Indexed<string>) => boolean;
+
+declare const pluridLinkPathDivider: (route: string) => RouteDivisions;
+/**
+ * Given a partial `route`, e.g. `/route`, or `://cluster://route`,
+ * it resolves it to the absolute form
+ * `protocol://origin://route://space://universe://cluster://plane`.
+ *
+ * @param path
+ */
+declare const resolveRoute: (route: string, protocol?: string, host?: string) => {
+    protocol: string;
+    host: _plurid_plurid_data.RouteHostDivision;
+    path: _plurid_plurid_data.RoutePathDivision;
+    space: _plurid_plurid_data.RouteSpaceDivision;
+    universe: _plurid_plurid_data.RouteUniverseDivision;
+    cluster: _plurid_plurid_data.RouteClusterDivision;
+    plane: _plurid_plurid_data.RoutePlaneDivision;
+    route: string;
+} | {
+    protocol: string;
+    host: string;
+    path: _plurid_plurid_data.RoutePathDivision;
+    space: string;
+    universe: string;
+    cluster: string;
+    plane: string;
+    route: string;
+};
+
+type index$9_IsoMatcher<C> = IsoMatcher<C>;
+declare const index$9_IsoMatcher: typeof IsoMatcher;
+type index$9_MatcherResponse<C> = MatcherResponse<C>;
+type index$9_ParserOptions = ParserOptions;
+type index$9_ParserParametersAndMatch = ParserParametersAndMatch;
+type index$9_ParserPartialOptions = ParserPartialOptions;
+type index$9_ParserResponse<C> = ParserResponse<C>;
+declare const index$9_checkParameterLength: typeof checkParameterLength;
+declare const index$9_checkPlaneAddressType: typeof checkPlaneAddressType;
+declare const index$9_checkValidPath: typeof checkValidPath;
+declare const index$9_cleanPathValue: typeof cleanPathValue;
+declare const index$9_cleanupPath: typeof cleanupPath;
+declare const index$9_computePlaneAddress: typeof computePlaneAddress;
+declare const index$9_extractQuery: typeof extractQuery;
+declare const index$9_isAbsolutePlane: typeof isAbsolutePlane;
+declare const index$9_pluridLinkPathDivider: typeof pluridLinkPathDivider;
+declare const index$9_removeTrailingSlash: typeof removeTrailingSlash;
+declare const index$9_resolveRoute: typeof resolveRoute;
+declare const index$9_stringInsertInitial: typeof stringInsertInitial;
+declare const index$9_stringRemoveTrailing: typeof stringRemoveTrailing;
+declare namespace index$9 {
+  export { index$9_IsoMatcher as IsoMatcher, type index$9_MatcherResponse as MatcherResponse, type index$9_ParserOptions as ParserOptions, type index$9_ParserParametersAndMatch as ParserParametersAndMatch, type index$9_ParserPartialOptions as ParserPartialOptions, type index$9_ParserResponse as ParserResponse, Parser as RouteParser, index$9_checkParameterLength as checkParameterLength, index$9_checkPlaneAddressType as checkPlaneAddressType, index$9_checkValidPath as checkValidPath, index$9_cleanPathValue as cleanPathValue, index$9_cleanupPath as cleanupPath, index$9_computePlaneAddress as computePlaneAddress, index$9_extractQuery as extractQuery, index$9_isAbsolutePlane as isAbsolutePlane, index$9_pluridLinkPathDivider as pluridLinkPathDivider, index$9_removeTrailingSlash as removeTrailingSlash, index$9_resolveRoute as resolveRoute, index$9_stringInsertInitial as stringInsertInitial, index$9_stringRemoveTrailing as stringRemoveTrailing };
+}
+
+declare const computeColumnLayout: (roots: TreePlane[], columns?: number, columnLength?: number, gap?: number, configuration?: PluridConfiguration) => TreePlane[];
+
+declare const computeRowLayout: (roots: TreePlane[], rows?: number, rowLength?: number, gap?: number, configuration?: PluridConfiguration) => TreePlane[];
+
+declare const computeFaceToFaceLayout: (roots: TreePlane[], angle?: number, gap?: number, middle?: number, configuration?: PluridConfiguration) => TreePlane[];
+
+declare const computeSheavesLayout: (roots: TreePlane[], depth?: number, offsetX?: number, offsetY?: number, configuration?: PluridConfiguration) => TreePlane[];
+
+declare const computeZigZagLayout: (pages: TreePlane[], angle?: number, configuration?: PluridConfiguration) => TreePlane[];
+
+declare const index$8_computeColumnLayout: typeof computeColumnLayout;
+declare const index$8_computeFaceToFaceLayout: typeof computeFaceToFaceLayout;
+declare const index$8_computeRowLayout: typeof computeRowLayout;
+declare const index$8_computeSheavesLayout: typeof computeSheavesLayout;
+declare const index$8_computeZigZagLayout: typeof computeZigZagLayout;
+declare namespace index$8 {
+  export { index$8_computeColumnLayout as computeColumnLayout, index$8_computeFaceToFaceLayout as computeFaceToFaceLayout, index$8_computeRowLayout as computeRowLayout, index$8_computeSheavesLayout as computeSheavesLayout, index$8_computeZigZagLayout as computeZigZagLayout };
+}
+
+declare const computePath: (tree: TreePlane[], planeID: string) => TreePlane[];
+declare const computePluridPlaneLocation: (linkCoordinates: LinkCoordinates, treePageParent: TreePlane, bridgeLength?: number, linkPlaneAngle?: number) => LocationCoordinates;
+declare const recomputeChildrenLocation: (page: TreePlane) => TreePlane[];
+
+declare const index$7_computePath: typeof computePath;
+declare const index$7_computePluridPlaneLocation: typeof computePluridPlaneLocation;
+declare const index$7_recomputeChildrenLocation: typeof recomputeChildrenLocation;
+declare namespace index$7 {
+  export { index$7_computePath as computePath, index$7_computePluridPlaneLocation as computePluridPlaneLocation, index$7_recomputeChildrenLocation as recomputeChildrenLocation };
+}
+
+interface TreeData<C> {
+    planes: Map<string, RegisteredPluridPlane<C>>;
+    view: PluridApplicationView;
+    configuration: PluridConfiguration;
+    layout?: boolean;
+    previousTree?: TreePlane[];
+}
+declare class Tree<C> {
+    private data;
+    private origin;
+    private count;
+    constructor(data: TreeData<C>, origin?: string);
+    compute(): TreePlane[];
+    private getCount;
+}
+
+/**
+ * Given a view resolve it to an absolute view
+ * and compute a TreePlane if there is a RegisteredPluridPlane
+ * for that absolute view.
+ *
+ * @param view
+ */
+declare const resolveViewItem: <C>(planes: Map<string, RegisteredPluridPlane<C>>, view: string | PluridView, configuration: PluridConfiguration, origin?: string, getCount?: () => number) => TreePlane | undefined;
+/**
+ * Compute the space based on the layout.
+ * If there is no configuration.space.layout, it uses the default '2 COLUMNS' layout.
+ *
+ * @param planes
+ * @param configuration
+ */
+declare const computeSpaceTree: <C>(planes: Map<string, RegisteredPluridPlane<C>>, view: PluridApplicationView, configuration: PluridConfiguration, layout: boolean | undefined, origin: string | undefined, getCount: () => number) => TreePlane[];
+declare const updateTreePlane: (tree: TreePlane[], updatedPlane: TreePlane) => TreePlane[];
+interface UpdatedTreeWithNewPlane {
+    pluridPlaneID: string;
+    updatedTree: TreePlane[];
+    updatedTreePlane?: TreePlane;
+}
+declare const updateTreeWithNewPlane: <C>(planeRoute: string, parentPlaneID: string, linkCoordinates: LinkCoordinates, tree: TreePlane[], planesRegistry: Map<string, RegisteredPluridPlane<C>>, configuration: PluridConfiguration, hostname?: string) => UpdatedTreeWithNewPlane;
+declare const updatePlaneLocation: (tree: TreePlane[], parentPlaneID: string, planeID: string, linkCoordinates: LinkCoordinates) => TreePlane[];
+declare const updateTreeWithNewPage: (tree: TreePlane[], treePageParentPlaneID: string, pagePath: string, pageID: string, linkCoordinates: LinkCoordinates, parameters?: PathParameters) => UpdatedTreeWithNewPlane;
+declare const toggleChildren: (children: TreePlane[]) => TreePlane[];
+declare const toggleAllChildren: (tree: TreePlane[], show: boolean) => TreePlane[];
+interface TogglePlaneFromTree {
+    updatedTree: TreePlane[];
+    updatedPlane: TreePlane | undefined;
+}
+declare const togglePlaneFromTree: (tree: TreePlane[], pluridPlaneID: string, forceShow?: boolean) => TogglePlaneFromTree;
+declare const getTreePlaneByID: (stateTree: TreePlane[], id: string | undefined) => TreePlane | undefined;
+declare const removeRootFromTree: (tree: TreePlane[], pluridPlaneID: string) => {
+    updatedTree: TreePlane[];
+};
+declare const removePlaneFromTree: (tree: TreePlane[], pluridPlaneID: string) => TreePlane[];
+/**
+ * Structural-sharing reconciliation: returns `nextTree`, but every node (and array) that is
+ * deep-equal to its counterpart in `previousTree` is replaced by the PREVIOUS reference. Producers
+ * of a new tree routinely rebuild it from scratch (a layout recompute emits brand-new node objects
+ * for every plane even when only one moved); without this, every connected `<PluridRoot>`/`<Plane>`
+ * receives fresh-identity props and re-renders. Running this in the `setTree` reducer means EVERY
+ * tree-replacing path (link spawn, relayout, resize, persistence restore) gets reference stability
+ * for free, so per-plane memoization actually pays off and only the genuinely-changed planes render.
+ */
+declare const reconcileTree: (previousTree: TreePlane[] | undefined, nextTree: TreePlane[]) => TreePlane[];
+
+type logic_TogglePlaneFromTree = TogglePlaneFromTree;
+type logic_UpdatedTreeWithNewPlane = UpdatedTreeWithNewPlane;
+declare const logic_computeSpaceTree: typeof computeSpaceTree;
+declare const logic_getTreePlaneByID: typeof getTreePlaneByID;
+declare const logic_reconcileTree: typeof reconcileTree;
+declare const logic_removePlaneFromTree: typeof removePlaneFromTree;
+declare const logic_removeRootFromTree: typeof removeRootFromTree;
+declare const logic_resolveViewItem: typeof resolveViewItem;
+declare const logic_toggleAllChildren: typeof toggleAllChildren;
+declare const logic_toggleChildren: typeof toggleChildren;
+declare const logic_togglePlaneFromTree: typeof togglePlaneFromTree;
+declare const logic_updatePlaneLocation: typeof updatePlaneLocation;
+declare const logic_updateTreePlane: typeof updateTreePlane;
+declare const logic_updateTreeWithNewPage: typeof updateTreeWithNewPage;
+declare const logic_updateTreeWithNewPlane: typeof updateTreeWithNewPlane;
+declare namespace logic {
+  export { type logic_TogglePlaneFromTree as TogglePlaneFromTree, type logic_UpdatedTreeWithNewPlane as UpdatedTreeWithNewPlane, logic_computeSpaceTree as computeSpaceTree, logic_getTreePlaneByID as getTreePlaneByID, logic_reconcileTree as reconcileTree, logic_removePlaneFromTree as removePlaneFromTree, logic_removeRootFromTree as removeRootFromTree, logic_resolveViewItem as resolveViewItem, logic_toggleAllChildren as toggleAllChildren, logic_toggleChildren as toggleChildren, logic_togglePlaneFromTree as togglePlaneFromTree, logic_updatePlaneLocation as updatePlaneLocation, logic_updateTreePlane as updateTreePlane, logic_updateTreeWithNewPage as updateTreeWithNewPage, logic_updateTreeWithNewPlane as updateTreeWithNewPlane };
+}
+
+type index$6_Tree<C> = Tree<C>;
+declare const index$6_Tree: typeof Tree;
+declare const index$6_logic: typeof logic;
+declare namespace index$6 {
+  export { index$6_Tree as Tree, index$6_logic as logic };
+}
+
+declare const computeSpaceSize: (tree: TreePlane[]) => {
+    width: number;
+    height: number;
+    depth: number;
+    topCorner: {
+        x: number;
+        y: number;
+        z: number;
+    };
+};
+declare const findPage: (view: string, pages: TreePlane[]) => TreePlane | undefined;
+declare const splitIntoGroups: <T>(data: T[], length: number) => T[][];
+declare const getTreePlaneByPlaneID: (tree: TreePlane[], planeID: string) => TreePlane | null;
+
+declare const index$5_computeSpaceSize: typeof computeSpaceSize;
+declare const index$5_findPage: typeof findPage;
+declare const index$5_getTreePlaneByPlaneID: typeof getTreePlaneByPlaneID;
+declare const index$5_splitIntoGroups: typeof splitIntoGroups;
+declare namespace index$5 {
+  export { index$5_computeSpaceSize as computeSpaceSize, index$5_findPage as findPage, index$5_getTreePlaneByPlaneID as getTreePlaneByPlaneID, index$5_splitIntoGroups as splitIntoGroups };
+}
+
+declare const computeViewTree: (pages: TreePlane[], view: string[] | PluridView[]) => TreePlane[];
+/**
+ * Compute only the view within a given radius around the user.
+ *
+ * @param pages
+ * @param view
+ * @param location
+ */
+declare const computeCulledView: (pages: TreePlane[], view: string[] | PluridView[], location: SpaceLocation, radius?: number) => string[] | undefined;
+declare const checkPageInView: (page: TreePlane, location: SpaceLocation, radius: number) => boolean;
+
+declare const index$4_checkPageInView: typeof checkPageInView;
+declare const index$4_computeCulledView: typeof computeCulledView;
+declare const index$4_computeViewTree: typeof computeViewTree;
+declare namespace index$4 {
+  export { index$4_checkPageInView as checkPageInView, index$4_computeCulledView as computeCulledView, index$4_computeViewTree as computeViewTree };
+}
+
+declare namespace index$3 {
+  export { index$8 as layout, index$7 as location, index$6 as tree, index$5 as utilities, index$4 as view };
+}
+
+declare const compute: <C>(view: PluridApplicationView, configuration: RecursivePartial<PluridConfiguration> | undefined, planesRegistrar: PluridPlanesRegistrar$1<C> | undefined, currentState: PluridState | undefined, localState: PluridState | undefined, precomputedState: Partial<PluridState> | undefined, contextState: PluridMetastateState | undefined, hostname?: string) => PluridState;
+
+/**
+ * Build a focused, versioned snapshot of the persistable space state.
+ */
+declare const serialize: (state: PluridState) => string;
+/**
+ * Persist the focused space snapshot via the storage adapter (default `localStorage`). No-op when
+ * there is no state or no available backend.
+ */
+declare const save: (id: string | undefined, state: PluridState | undefined, adapter?: PluridStorageAdapter) => void;
+/**
+ * Load a previously persisted snapshot. Returns a partial `PluridState` (just `{ space }`)
+ * that `compute`/`resolveSpace` merge over a freshly-computed space. Version mismatch,
+ * missing data, or parse errors all fall back to a fresh space (return `undefined`).
+ */
+declare const load: (id: string | undefined, useLocalStorage: boolean | undefined, adapter?: PluridStorageAdapter) => PluridState | undefined;
+/**
+ * Persist an OPAQUE product content blob (the `onPersistContent` seam). Stored under a sibling key
+ * to the space snapshot, with NO engine version stamp — the content shape (and any migration) is
+ * the product's concern; the engine never inspects it. No-op outside the browser / for `undefined`.
+ */
+declare const saveContent: (id: string | undefined, content: unknown, adapter?: PluridStorageAdapter) => void;
+/**
+ * Load the opaque product content blob, or `undefined` if absent / unparseable.
+ */
+declare const loadContent: (id: string | undefined, adapter?: PluridStorageAdapter) => unknown;
+
+declare const index$2_load: typeof load;
+declare const index$2_loadContent: typeof loadContent;
+declare const index$2_save: typeof save;
+declare const index$2_saveContent: typeof saveContent;
+declare const index$2_serialize: typeof serialize;
+declare namespace index$2 {
+  export { index$2_load as load, index$2_loadContent as loadContent, index$2_save as save, index$2_saveContent as saveContent, index$2_serialize as serialize };
+}
+
+declare const index$1_compute: typeof compute;
+declare namespace index$1 {
+  export { index$1_compute as compute, index$2 as local };
+}
+
+declare const cleanPathElement: (path: string) => string;
+
+declare const index_cleanPathElement: typeof cleanPathElement;
+declare namespace index {
+  export { index_cleanPathElement as cleanPathElement };
+}
+
+declare const cleanTemplate: (template: string) => string;
+
+declare const pluridRouterNavigate: (path: string) => void;
+
+export { IsoMatcher, Parser as RouteParser, cleanTemplate, definePluridConfiguration, index$i as general, index$b as interaction, internatiolate, index$a as planes, pluridRouterNavigate, index$9 as routing, index$3 as space, index$1 as state, index as utilities };