@navaramap/core 0.0.0

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2026 MapLibre contributors
+
+This project is dual-licensed under either of
+
+- Apache License, Version 2.0 (see LICENSE-APACHE)
+- MIT license (see LICENSE-MIT)
+
+at your option.

package/README.md

@@ -0,0 +1,3 @@
+# @navaramap/core
+
+This is a core module for Navara for Web platform.

package/dist/index.d.ts

@@ -0,0 +1,605 @@
+import { CachedMeshHandle } from '@navaramap/engine';
+import { CameraFrustum as CameraFrustum_2 } from '@navaramap/engine-api';
+import { CameraOrientation as CameraOrientation_2 } from '@navaramap/engine';
+import { ConstructedPolygonGeometry } from '@navaramap/engine';
+import { ConstructedPolylineGeometry } from '@navaramap/engine';
+import { CRS } from '@navaramap/engine';
+import { ElevationDecoder } from '@navaramap/engine';
+import { EntityEvent } from '@navaramap/engine';
+import { Events } from '@navaramap/engine';
+import { ExtentRadianF32 } from '@navaramap/engine';
+import { Globe as Globe_2 } from '@navaramap/engine';
+import { LLE } from '@navaramap/engine';
+import { Plane as Plane_2 } from '@navaramap/engine-api';
+import { PolygonInternalMaterial } from '@navaramap/engine';
+import { PolygonMaterial } from '@navaramap/engine';
+import { PolylineInternalMaterial } from '@navaramap/engine';
+import { PolylineMaterial } from '@navaramap/engine';
+import { Ray as Ray_2 } from '@navaramap/engine-api';
+import { ReturnedConstructedTerrainMesh } from '@navaramap/engine';
+import { ReturnedTransferablePolygonBatchedFeature } from '@navaramap/engine';
+import { ReturnedTransferablePolylineBatchedFeature } from '@navaramap/engine';
+import { TileXYZ } from '@navaramap/engine';
+import { TransferableMartini } from '@navaramap/engine';
+import { TransferablePolygonBatchedFeature } from '@navaramap/engine';
+import { TransferablePolylineBatchedFeature } from '@navaramap/engine';
+import { TransferableRasterDEMData } from '@navaramap/engine';
+import { TransferableTile } from '@navaramap/engine';
+import { Transform as Transform_2 } from '@navaramap/engine-api';
+import { UpsamplableTerrainGeometry } from '@navaramap/engine';
+import { Vec2 as Vec2_2 } from '@navaramap/engine-api';
+import { Vec3 as Vec3_2 } from '@navaramap/engine';
+import { Vec3 as Vec3_3 } from '@navaramap/engine-api';
+import { Window as Window_3 } from '@navaramap/engine';
+
+export declare function assertType<T>(_value: unknown): asserts _value is T;
+
+export declare abstract class BaseAbstractedVec3 {
+    value: Vec3_2;
+    constructor(x: number, y: number, z: number);
+    copy(x: number, y: number, z: number): void;
+}
+
+export declare type BaseEventMap = Record<string, (...args: any[]) => unknown>;
+
+export declare class CachedMeshHandleLike {
+    vertices: number;
+    uvs: number;
+    indices: number;
+    heights?: number | undefined;
+    constructor(t: CachedMeshHandle);
+    free(): void;
+}
+
+export declare type CameraFrustum = Required<NormalizeWASMClass<CameraFrustum_2>>;
+
+export declare type CameraOrientation = Partial<NormalizeWASMClass<CameraOrientation_2>>;
+
+export declare type CameraPosition = Partial<LatLngHeight> & CameraOrientation & {
+    /** Distance from the target point (lng/lat/height) along the camera forward direction (meters).
+     *  When specified, the camera is placed so its forward ray reaches the target point from this distance.
+     *  If `height` is omitted, the target elevation defaults to 0 (sea level). */
+    distance?: number;
+};
+
+export declare abstract class Color {
+    abstract setRGB(r: number, g: number, b: number): this;
+    abstract setHex(hex: number): this;
+    abstract setStyle(style: string): this;
+    abstract copy(color: this): this;
+    abstract clone(): this;
+    abstract srgb(): this;
+    abstract toArray(): [r: number, g: number, b: number];
+    abstract toHex(): number;
+}
+
+export declare class ColorMap<T extends ColorMapType = ColorMapType> {
+    #private;
+    readonly type: T;
+    readonly name: string;
+    lut: ColorTuple[];
+    constructor(type: T, name: string, lut: LUT);
+    linear(value: number): ColorTuple;
+    buildLinear(): void;
+    get count(): number;
+    ticks(range: [min: number, max: number], count: number): number[];
+    quantize(count: number): ColorTuple[];
+    createImage(): HTMLCanvasElement;
+    /**
+     * Flatten the color map LUT into a Float32Array for WASM/GPU usage.
+     * Each color tuple [r, g, b] is flattened into consecutive array elements.
+     * @returns A Float32Array with length = lut.length * 3
+     */
+    flatten(): Float32Array;
+}
+
+export declare type ColorMapType = "sequential" | "diverging";
+
+export declare type ColorTuple = [number, number, number];
+
+export declare class ConstructedPolygonGeometryLike {
+    extent: ExtentRadianF32Like | undefined;
+    position_3d_high: Float32Array | undefined;
+    position_3d_high_size: number | undefined;
+    position_3d_low: Float32Array | undefined;
+    position_3d_low_size: number | undefined;
+    position: Float32Array | undefined;
+    position_size: number | undefined;
+    normal: Float32Array | undefined;
+    normal_size: number | undefined;
+    scale_normal_and_cap: Float32Array | undefined;
+    scale_normal_and_cap_size: number | undefined;
+    batch_id: Float32Array | undefined;
+    batch_id_size: number | undefined;
+    batch_index: Uint32Array | undefined;
+    batch_index_size: number | undefined;
+    indices: Uint32Array;
+    /** RTC (Relative-To-Center) translation vector in world-space ECEF coordinates */
+    rtc_translation: Vec3Like | undefined;
+    outline_position: Float32Array | undefined;
+    outline_position_size: number | undefined;
+    outline_scale_normal_and_cap: Float32Array | undefined;
+    outline_scale_normal_and_cap_size: number | undefined;
+    outline_skip_indices: Uint32Array | undefined;
+    outline_batch_index: Float32Array | undefined;
+    outline_batch_index_size: number | undefined;
+    constructor(t: ConstructedPolygonGeometry);
+}
+
+export declare class ConstructedPolylineGeometryLike {
+    extent: ExtentRadianF32Like | undefined;
+    position: Float32Array;
+    position_size: number;
+    position_high: Float32Array | undefined;
+    position_high_size: number | undefined;
+    position_low: Float32Array | undefined;
+    position_low_size: number | undefined;
+    start: Float32Array | undefined;
+    start_size: number | undefined;
+    start_high: Float32Array | undefined;
+    start_high_size: number | undefined;
+    start_low: Float32Array | undefined;
+    start_low_size: number | undefined;
+    forward_offset: Float32Array | undefined;
+    forward_offset_size: number | undefined;
+    end_high: Float32Array | undefined;
+    end_high_size: number | undefined;
+    end_low: Float32Array | undefined;
+    end_low_size: number | undefined;
+    start_normals: Float32Array | undefined;
+    start_normals_size: number | undefined;
+    end_normal_and_texture_coordinate_normalization_x: Float32Array | undefined;
+    end_normal_and_texture_coordinate_normalization_x_size: number | undefined;
+    right_normal_and_texture_coordinate_normalization_y: Float32Array;
+    right_normal_and_texture_coordinate_normalization_y_size: number;
+    batch_id: Float32Array | undefined;
+    batch_id_size: number | undefined;
+    batch_index: Uint32Array | undefined;
+    batch_index_size: number | undefined;
+    indices: Uint32Array;
+    constructor(t: ConstructedPolylineGeometry);
+}
+
+export declare class ElevationDecoderLike implements RemoveFreeRecursively<ElevationDecoder> {
+    b_scaler: number;
+    boundary: number;
+    epsilon: number;
+    g_scaler: number;
+    max_offset: number;
+    min_offset: number;
+    offset: number;
+    r_scaler: number;
+    constructor(t: ElevationDecoder);
+}
+
+export declare class EventHandler<T extends BaseEventMap = BaseEventMap, K extends keyof T = keyof T> {
+    events: {
+        [E in K]?: Set<T[E]>;
+    };
+    onceEvents: {
+        [E in K]?: Set<T[E]>;
+    };
+    on<E extends K>(k: E, f: T[E]): void;
+    off<E extends K>(k: E, f: T[E]): void;
+    clear<E extends K>(k: E): void;
+    size<E extends K>(k: E): number | undefined;
+    /**
+     * Register a callback that will be executed only once and then removed
+     */
+    once<E extends K>(k: E, f: T[E]): void;
+    emit<E extends K>(k: E, ...args: Parameters<T[E]>): void;
+}
+
+export declare class EventManager {
+    stacks: EventsStacks;
+    addedEventIds: Map<string, Set<unknown>>;
+    private transactionManager;
+    needsUpdate(): boolean;
+    pushEvents(events: Events | undefined): void;
+    forEachStack<Key extends JsEventsKey>(key: Key, cb: (value: GetJsEventValue<Key>) => void, max?: number): void;
+    forEachStackAsync<Key extends JsEventsKey>(key: Key, cb: (value: GetJsEventValue<Key>) => Promise<void>, max?: number, shouldProcess?: (value: GetJsEventValue<Key>) => boolean): Promise<void>;
+    removeDuplicatedTransactionEvents<AddKey extends JsEventsKey, RemoveKey extends JsEventsKey, ChangeKey extends JsEventsKey>(options: TransactionProcessOption<AddKey, RemoveKey, ChangeKey>): void;
+    removeStacksByIndices(key: JsEventsKey, removedIndices: Set<number>): void;
+    processTransactionEvents<AddKey extends JsEventsKey, RemoveKey extends JsEventsKey, ChangeKey extends JsEventsKey>(transactionKey: string, options: TransactionProcessOption<AddKey, RemoveKey, ChangeKey>, cb: (ev: TransactionCallbackParams<AddKey, RemoveKey, ChangeKey>) => Promise<void>, handlers?: {
+        shouldProcess?: (ev: TransactionCallbackParams<AddKey, RemoveKey, ChangeKey>) => boolean;
+        generateEventId?: (ev: TransactionCallbackParams<AddKey, RemoveKey, ChangeKey>) => string;
+        onAbort?: (ev: GetJsEventValue<RemoveKey>) => void | Promise<void>;
+    }): void;
+}
+
+declare type EventsStacks = {
+    [K in JsEventsKey]-?: JsEvents[K] extends unknown[] ? JsEvents[K] : JsEvents[K][];
+};
+
+export declare class ExtentRadianF32Like implements RemoveFreeRecursively<ExtentRadianF32> {
+    east: number;
+    north: number;
+    south: number;
+    west: number;
+    constructor(t: ExtentRadianF32);
+}
+
+export declare type ExtractProperties<T> = {
+    [K in keyof T]?: T[K] extends (...args: any) => any ? ReturnType<T[K]> extends (...args: any) => any ? ExtractProperties<ReturnType<T[K]>> : ReturnType<T[K]> : Partial<T[K]>;
+};
+
+export declare type FeatureSetId = bigint;
+
+export declare function generate_id_from_entity(entity: EntityEvent): string;
+
+declare type GetJsEventValue<K extends JsEventsKey> = EventsStacks[K] extends unknown[] ? EventsStacks[K][number] : EventsStacks[K];
+
+/**
+ * Globe configuration manager.
+ *
+ * Provides an interface for accessing and modifying globe properties
+ * that are shared across different material types (VectorTile, RasterTile, RasterTerrain).
+ */
+export declare class Globe implements Omit<RemoveFreeRecursively<Globe_2>, "elevationColormap" | "color"> {
+    private handler;
+    private _elevationColormap?;
+    constructor(handler: GlobeHandler, options?: GlobeOptions);
+    setOptions(options?: GlobeOptions): void;
+    get maxSse(): number;
+    set maxSse(value: number);
+    get segments(): number;
+    set segments(value: number);
+    get color(): Color | undefined;
+    set color(value: Color);
+    get hideUnderground(): boolean;
+    set hideUnderground(value: boolean);
+    get useNormal(): boolean;
+    set useNormal(value: boolean);
+    get transparent(): boolean;
+    set transparent(value: boolean);
+    get opacity(): number;
+    set opacity(value: number);
+    get wireframe(): boolean;
+    set wireframe(value: boolean);
+    get elevationColormap(): ColorMap | undefined;
+    set elevationColormap(value: ColorMap);
+}
+
+/**
+ * Handler for accessing individual Globe properties from WASM.
+ * This provides a reference-based interface instead of copying the entire Globe object.
+ */
+export declare type GlobeHandler = {
+    getTransparent: () => boolean | undefined;
+    getMaxSse: () => number | undefined;
+    getSegments: () => number | undefined;
+    getColor: () => Color | undefined;
+    getHideUnderground: () => boolean | undefined;
+    getUseNormal: () => boolean | undefined;
+    getOpacity: () => number | undefined;
+    getWireframe: () => boolean | undefined;
+    getElevationColormap: () => Float32Array | undefined;
+    setTransparent: (value: boolean) => void;
+    setMaxSse: (value: number) => void;
+    setSegments: (value: number) => void;
+    setColor: (value: Color) => void;
+    setHideUnderground: (value: boolean) => void;
+    setUseNormal: (value: boolean) => void;
+    setOpacity: (value: number) => void;
+    setWireframe: (value: boolean) => void;
+    setElevationColormap: (value: ColorMap) => void;
+};
+
+export declare type GlobeOptions = Partial<Omit<Globe_2, "constructor" | "free" | "elevationColormap" | "color">> & {
+    elevationColormap?: ColorMap;
+    color?: Color;
+};
+
+export declare const IMAGE_EXTENSIONS: string[];
+
+export declare function isEntityEvent(v: unknown): v is EntityEvent;
+
+export declare function isNotFalse<T>(value: T | false): value is T;
+
+export declare function isNotNullish<T>(value: T | null | undefined): value is T;
+
+export declare function isNotUndefined<T>(value: T | undefined): value is T;
+
+export declare type JsEvents = {
+    [K in keyof Events as K extends `take_${infer P}` ? P : never]: Events[K] extends (...args: never[]) => infer R ? R : never;
+};
+
+export declare type JsEventsKey = keyof JsEvents;
+
+export declare type LatLng = Omit<LatLngHeight, "height">;
+
+export declare type LatLngHeight = Required<NormalizeWASMClass<LLE>>;
+
+export declare type LayerId = string;
+
+export declare type LUT = readonly (ColorTuple | Color)[];
+
+export declare class NamedIndexMap<T extends {
+    name: string;
+}> {
+    list: T[];
+    indexMap: Record<string, number>;
+    add(v: T): void;
+    insertBefore(targetName: string, v: T): number;
+    insertAfter(targetName: string, v: T): number;
+    private insertAt;
+    private findIndex;
+    private assertUnique;
+}
+
+export declare type NormalizeWASMClass<C> = ExtractProperties<RemoveFreeRecursively<C>>;
+
+export declare type Nullable<T> = T | null | undefined;
+
+export declare class Observed<T> extends EventHandler<ObservedEvent<T>> {
+    private _value;
+    constructor(v: T);
+    get value(): T;
+    set value(v: T);
+    changed(f: (v: T) => void): void;
+}
+
+export declare type ObservedEvent<T> = {
+    changed: (v: T) => void;
+};
+
+export declare type Plane = Required<NormalizeWASMClass<Plane_2>>;
+
+/**
+ * Base `Plugin` abstract class.
+ * This class doesn't have a logic, but has interfaces.
+ * ```
+ * class MyPlugin extends Plugin<ThreeView<MyCustomDescriptions>, ViewContext> {
+ *   async init(view, ctx) {
+ *     // ...
+ *   }
+ * }
+ * ```
+ */
+declare abstract class Plugin_2<TView = unknown, TCtx = unknown> {
+    abstract init(view: TView, ctx: TCtx): Promise<void>;
+}
+export { Plugin_2 as Plugin }
+
+export declare class PolygonMaterialLike {
+    clampToGround?: boolean;
+    tiled?: boolean;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+    color?: number;
+    extrudedHeight?: number;
+    height?: number;
+    show?: boolean;
+    perPositionHeight?: boolean;
+    wireframe?: boolean;
+    outline?: boolean;
+    __internal__?: PolygonInternalMaterial | undefined;
+    constructor(material: PolygonMaterial);
+    free(): void;
+}
+
+export declare class PolylineMaterialLike {
+    clampToGround?: boolean;
+    tiled?: boolean;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+    color?: number;
+    height?: number;
+    width?: number;
+    maxWidth?: number;
+    show?: boolean;
+    __internal__?: PolylineInternalMaterial;
+    constructor(material: PolylineMaterial);
+    free(): void;
+}
+
+export declare type Ray = Required<NormalizeWASMClass<Ray_2>>;
+
+export declare type RemoveFreeRecursively<T> = T extends {
+    free: unknown;
+} ? {
+    [K in keyof T as K extends "free" | symbol | number ? never : K]: RemoveFreeRecursively<T[K]>;
+} : T;
+
+export declare class ReturnedConstructedTerrainMeshLike implements RemoveFreeRecursively<ReturnedConstructedTerrainMesh> {
+    vertices: Float32Array;
+    uvs: Float32Array;
+    indices: Uint32Array;
+    heights: Float32Array;
+    max_height: number;
+    min_height: number;
+    rtc_translation: Vec3Like | undefined;
+    normals: Float32Array | undefined;
+    skirt_vertices: Float32Array | undefined;
+    skirt_uvs: Float32Array | undefined;
+    skirt_indices: Uint32Array | undefined;
+    skirt_normals: Float32Array | undefined;
+    watermask: Uint8Array | undefined;
+    constructor(t: ReturnedConstructedTerrainMesh);
+    transferVertices(): Float32Array;
+    transferUvs(): Float32Array;
+    transferIndices(): Uint32Array;
+    transferHeights(): Float32Array;
+    transferNormals(): Float32Array | undefined;
+    transferSkirtVertices(): Float32Array | undefined;
+    transferSkirtUvs(): Float32Array | undefined;
+    transferSkirtIndices(): Uint32Array | undefined;
+    transferSkirtNormals(): Float32Array | undefined;
+    transferWatermask(): Uint8Array | undefined;
+    hasSkirt(): boolean;
+    hasNormals(): boolean;
+    hasWatermask(): boolean;
+}
+
+export declare const setBatchedValuesToBatchedAttribute: (values: TypedArrayLike, batchIds: TypedArrayLike, attr: TypedArrayLike) => void;
+
+export declare type TileHandle = bigint;
+
+export declare class TileXYZLike implements RemoveFreeRecursively<TileXYZ> {
+    x: number;
+    y: number;
+    z: number;
+    constructor(t: TileXYZ);
+}
+
+export declare class Transaction {
+    id: string;
+    continuable: boolean;
+    currentPending?: Promise<void>;
+    next?: Transaction;
+    parent?: Transaction;
+    constructor(id: string, continuable?: boolean);
+    then(cb: () => Promise<void>): Transaction;
+    end(): void;
+}
+
+declare type TransactionCallbackParams<AddKey extends JsEventsKey, RemoveKey extends JsEventsKey, ChangeKey extends JsEventsKey> = {
+    type: "add";
+    event: GetJsEventValue<AddKey>;
+} | {
+    type: "remove";
+    event: GetJsEventValue<RemoveKey>;
+} | {
+    type: "change";
+    event: GetJsEventValue<ChangeKey>;
+};
+
+export declare class TransactionManager {
+    private record;
+    getOrInsert(id: string): Transaction;
+}
+
+declare type TransactionProcessOption<AddKey extends JsEventsKey, RemoveKey extends JsEventsKey, ChangeKey extends JsEventsKey> = {
+    add: {
+        key: AddKey;
+        max?: number;
+    };
+    remove: {
+        key: RemoveKey;
+        max?: number;
+    };
+    change?: {
+        key: ChangeKey;
+        max?: number;
+    };
+};
+
+export declare class TransferableMartiniLike implements RemoveFreeRecursively<TransferableMartini> {
+    coords: Uint32Array;
+    size: number;
+    constructor(coords: Uint32Array, size: number);
+    transfer_coords(): Uint32Array;
+    clone(): TransferableMartiniLike;
+}
+
+export declare class TransferablePolygonBatchedFeatureLike implements RemoveFreeRecursively<TransferablePolygonBatchedFeature> {
+    batch_ids: Uint32Array;
+    batch_indices: Uint32Array;
+    crs: CRS;
+    expected_winding_orders: Uint8Array;
+    holes: Float64Array;
+    holes_boundaries: Uint32Array;
+    holes_sizes: Uint32Array;
+    holes_total_sizes: Uint32Array;
+    length: number;
+    outer_ring: Float64Array;
+    outer_ring_sizes: Uint32Array;
+    constructor(t: ReturnedTransferablePolygonBatchedFeature);
+    setBatchIds(_length: number, _f: () => void): void;
+    setBatchIndices(_length: number, _f: () => void): void;
+    setExpectedWindingOrders(_length: number, _f: () => void): void;
+    setOuterRing(_length: number, _f: () => void): void;
+    setOuterRingSizes(_length: number, _f: () => void): void;
+    setHoles(_length: number, _f: () => void): void;
+    setHolesBoundaries(_length: number, _f: () => void): void;
+    setHolesSizes(_length: number, _f: () => void): void;
+    setHolesTotalSizes(_length: number, _f: () => void): void;
+    transferBatchIds(): Uint32Array;
+    transferBatchIndices(): Uint32Array;
+    transferExpectedWindingOrders(): Uint8Array;
+    transferOuterRing(): Float64Array;
+    transferOuterRingSizes(): Uint32Array;
+    transferHoles(): Float64Array;
+    transferHolesBoundaries(): Uint32Array;
+    transferHolesSizes(): Uint32Array;
+    transferHolesTotalSizes(): Uint32Array;
+}
+
+export declare class TransferablePolylineBatchedFeatureLike implements RemoveFreeRecursively<TransferablePolylineBatchedFeature> {
+    points: Float64Array;
+    points_sizes: Uint32Array;
+    batch_ids: Uint32Array;
+    batch_indices: Uint32Array;
+    crs: CRS;
+    length: number;
+    constructor(t: ReturnedTransferablePolylineBatchedFeature);
+    setPoints(_byte_length: number, _f: () => void): void;
+    setPointsSizes(_byte_length: number, _f: () => void): void;
+    setBatchIds(_byte_length: number, _f: () => void): void;
+    setBatchIndices(_length: number, _f: () => void): void;
+    transferPoints(): Float64Array;
+    transferPointsSizes(): Uint32Array;
+    transferBatchIds(): Uint32Array;
+    transferBatchIndices(): Uint32Array;
+}
+
+export declare class TransferableRasterDEMDataLike implements RemoveFreeRecursively<TransferableRasterDEMData> {
+    decoder: ElevationDecoderLike;
+    constructor(decoder: ElevationDecoder);
+}
+
+export declare class TransferableTileLike {
+    cached_mesh_handle?: CachedMeshHandleLike | undefined;
+    coords: TileXYZLike;
+    max_height: number;
+    min_height: number;
+    constructor(t: TransferableTile);
+    free(): void;
+}
+
+export declare type Transform = Required<NormalizeWASMClass<Transform_2>>;
+
+export declare type TypedArrayLike = {
+    [index: number]: number;
+    readonly length: number;
+};
+
+export declare class Unimplemented extends Error {
+    constructor(message?: string);
+}
+
+export declare class Unreachable extends Error {
+    constructor(message?: string);
+}
+
+export declare class UpsamplableTerrainGeometryLike implements RemoveFreeRecursively<UpsamplableTerrainGeometry> {
+    uvs: Float32Array;
+    indices: Uint32Array;
+    heights: Float32Array;
+    normals: Float32Array | undefined;
+    /** Parent quantized-mesh watermask (1 byte uniform or 65536 byte 256x256 grid). */
+    watermask: Uint8Array | undefined;
+    constructor(uvs: Float32Array, indices: Uint32Array, heights: Float32Array, normals?: Float32Array, watermask?: Uint8Array);
+}
+
+export declare type Vec2 = Required<NormalizeWASMClass<Vec2_2>>;
+
+export declare type Vec3 = Required<NormalizeWASMClass<Vec3_3>>;
+
+export declare class Vec3Like implements RemoveFreeRecursively<Vec3_2> {
+    x: number;
+    y: number;
+    z: number;
+    constructor(t: Vec3_2);
+}
+
+declare type Window_2 = Required<NormalizeWASMClass<Window_3>>;
+export { Window_2 as Window }
+
+export declare type XYZ = {
+    x: number;
+    y: number;
+    z: number;
+};
+
+export { }