@viamrobotics/motion-tools 1.31.0 → 1.32.0

package/dist/ecs/traits.js

@@ -6,6 +6,7 @@ import { ColorFormat } from '../buf/draw/v1/metadata_pb';
 import { createBox, createCapsule, createSphere } from '../geometry';
 import { parsePcdInWorker } from '../loaders/pcd';
 import { parsePlyInput } from '../ply';
+import { createPose, matrixToPose, poseToMatrix } from '../transform';
 export const Name = trait(() => '');
 export const UUID = trait(() => '');
 /**
@@ -61,6 +62,13 @@ export const InstancedMatrix = trait(() => ({
 }));
 export const Hovered = trait(() => true);
 export const Invisible = trait(() => true);
+/**
+ * Suppresses the default frame-style world/local pose and parent-frame blocks
+ * in the details panel. Entities that render their own pose UI via the
+ * `details-extensions` portal target (e.g. gizmo plugin entities) opt in by
+ * adding this trait.
+ */
+export const CustomDetails = trait(() => true);
 /**
  * True when the entity itself, or any of its parents up the `ChildOf`
  * chain, has `Invisible`. Maintained by `provideInheritedInvisible`;
@@ -72,11 +80,14 @@ export const InheritedInvisible = trait(() => true);
  * Represents that an entity is composed of many instances, so that the treeview and
  * details panel may display all instances
  */
-export const Instanced = trait(() => true);
+export const InstanceId = trait(() => -1);
 export const Instance = trait({
     meshID: -1,
     instanceID: -1,
 });
+export const Instances = trait({
+    count: 0,
+});
 export const RenderOrder = trait(() => 0);
 export const Opacity = trait(() => 1);
 /**
@@ -100,9 +111,6 @@ export const Colors = trait(() => new Uint8Array());
  * Per-vertex opacity values packed as uint8 (0-255).
  */
 export const Opacities = trait(() => new Uint8Array());
-export const Instances = trait({
-    count: 0,
-});
 export const Arrows = trait({
     headAtPose: true,
 });
@@ -175,6 +183,10 @@ export const ReferenceFrame = trait(() => true);
  */
 export const ChunkProgress = trait({ loaded: 0, total: 0 });
 export const SelectToolInteractionLayer = trait(() => true);
+/**
+ * This entity is selected by the user
+ */
+export const Selected = trait();
 /**
  * This entity can be safely removed from the scene by the user
  */
@@ -250,6 +262,23 @@ export const updateGeometryTrait = (entity, geometry) => {
         updatePointCloud(entity, geometry.geometryType.value.pointCloud);
     }
 };
+/**
+ * Patches an entity's `Matrix` trait in-place via the `Pose` round-trip
+ * (`matrixToPose` → merge → `poseToMatrix`), then signals `entity.changed(Matrix)`.
+ * No-ops silently if the entity has no `Matrix` trait.
+ */
+export const writeMatrix = (entity, patch) => {
+    const matrix = entity.get(Matrix);
+    if (!matrix)
+        return;
+    const pose = matrixToPose(matrix, createPose());
+    const filtered = Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== undefined));
+    if (Object.keys(filtered).length === 0)
+        return;
+    Object.assign(pose, filtered);
+    poseToMatrix(pose, matrix);
+    entity.changed(Matrix);
+};
 const updatePointCloud = (entity, pointCloud) => {
     parsePcdInWorker(new Uint8Array(pointCloud))
         .then((parsed) => {

package/dist/ecs/useTag.svelte.d.ts

@@ -0,0 +1,5 @@
+import { type Entity, type TagTrait, type World } from 'koota';
+export declare function isWorld(target: Entity | World): target is World;
+export declare function useTag(target: () => Entity | World | undefined | null, tag: TagTrait): {
+    readonly current: boolean;
+};

package/dist/ecs/useTag.svelte.js

@@ -0,0 +1,43 @@
+import { $internal as internal } from 'koota';
+import { useWorld } from './useWorld';
+export function isWorld(target) {
+    return typeof target?.spawn === 'function';
+}
+export function useTag(target, tag) {
+    const contextWorld = useWorld();
+    let value = $state(false);
+    $effect(() => {
+        const t = target();
+        if (!t) {
+            value = false;
+            return;
+        }
+        const world = isWorld(t) ? t : contextWorld;
+        // ???
+        // eslint-disable-next-line prefer-const
+        let entity;
+        /**
+         * Subscribe before reading worldEntity: world.onAdd triggers lazy
+         * registration so worldEntity is guaranteed to exist after this.
+         */
+        const onAddUnsub = world.onAdd(tag, (e) => {
+            if (e === entity)
+                value = true;
+        });
+        const onRemoveUnsub = world.onRemove(tag, (e) => {
+            if (e === entity)
+                value = false;
+        });
+        entity = isWorld(t) ? t[internal].worldEntity : t;
+        value = entity.has(tag);
+        return () => {
+            onAddUnsub();
+            onRemoveUnsub();
+        };
+    });
+    return {
+        get current() {
+            return value;
+        },
+    };
+}

package/dist/hooks/useEnvironment.svelte.d.ts

@@ -1,6 +1,6 @@
 export declare const ENVIRONMENT_CONTEXT_KEY: unique symbol;
 interface Environemnt {
-    viewerMode: 'edit' | 'monitor' | 'focus';
+    viewerMode: 'edit' | 'monitor';
     isStandalone: boolean;
     inputBindingsEnabled: boolean;
 }

package/dist/hooks/useLinked.svelte.js

@@ -1,20 +1,19 @@
 import { getContext, setContext } from 'svelte';
-import { relations, useWorld } from '../ecs';
-import { useFocusedEntity, useSelectedEntity } from './useSelection.svelte';
+import { relations, traits, useQuery, useWorld } from '../ecs';
 const linkedKey = Symbol('linked-context');
 export const provideLinkedEntities = () => {
     const world = useWorld();
-    const selectedEntity = useSelectedEntity();
-    const focusedEntity = useFocusedEntity();
-    const displayEntity = $derived(selectedEntity.current ?? focusedEntity.current);
-    let linkedEntities = $derived(displayEntity?.targetsFor(relations.SubEntityLink) ?? []);
+    const selected = useQuery(traits.Selected);
+    let linkedEntities = $derived(selected.current
+        .flatMap((entity) => entity.targetFor(relations.SubEntityLink))
+        .filter((entity) => entity !== undefined));
     const unsubAdd = world.onAdd(relations.SubEntityLink, (entity, target) => {
-        if (entity === displayEntity) {
+        if (selected.current.includes(entity)) {
             linkedEntities = [...linkedEntities, target];
         }
     });
     const unsubRemove = world.onRemove(relations.SubEntityLink, (entity, target) => {
-        if (entity === displayEntity) {
+        if (selected.current.includes(entity)) {
             linkedEntities = linkedEntities.filter((e) => e !== target);
         }
     });

package/dist/hooks/useMouseRaycaster.svelte.d.ts

@@ -5,9 +5,10 @@ interface RaycastEvent<T extends EventNames> {
     intersections: Intersection[];
 }
 type Callback<T extends EventNames> = (event: RaycastEvent<T>) => void;
-export declare const useMouseRaycaster: (getOptions?: () => {
-    enabled: boolean;
-}) => {
+interface MouseRaycasterOptions {
+    enabled?: boolean;
+}
+export declare const useMouseRaycaster: (getOptions?: () => MouseRaycasterOptions) => {
     raycaster: Raycaster;
     onclick: (cb: Callback<"click">) => void;
     onmove: (cb: Callback<"move">) => void;

package/dist/hooks/useMouseRaycaster.svelte.js

@@ -69,6 +69,7 @@ export const useMouseRaycaster = (getOptions) => {
         if (!options.enabled) {
             return;
         }
+        raycaster.firstHitOnly = true;
         dom.addEventListener('pointermove', onPointerMove, { passive: true });
         dom.addEventListener('pointerdown', onPointerDown, { passive: true });
         dom.addEventListener('pointerup', onPointerUp, { passive: true });

package/dist/hooks/useSettings.svelte.d.ts

@@ -1,7 +1,7 @@
 import type { ColorRepresentation } from 'three';
 export interface Settings {
     cameraMode: 'orthographic' | 'perspective';
-    interactionMode: 'navigate' | 'measure' | 'select';
+    interactionMode: 'navigate' | 'measure' | 'select' | 'gizmo';
     refreshRates: {
         poses: number;
         pointclouds: number;

package/dist/plugins/Focus/Focus.svelte

@@ -0,0 +1,45 @@
+<script lang="ts">
+	import { Portal } from '@threlte/extras'
+	import { PressedKeys } from 'runed'
+
+	import Button from '../../components/overlay/dashboard/Button.svelte'
+	import { traits, useQuery } from '../../ecs'
+
+	import FocusBox from './FocusBox.svelte'
+	import { provideFocus } from './provideFocus.svelte'
+
+	let focusing = $state(false)
+
+	provideFocus(() => focusing)
+
+	const selected = useQuery(traits.Selected)
+
+	const canFocus = $derived(selected.current.length > 0 || focusing)
+
+	const keys = new PressedKeys()
+
+	keys.onKeys('/', () => {
+		if (selected.current.length > 0 && !focusing) {
+			focusing = true
+		} else if (focusing) {
+			focusing = false
+		}
+	})
+</script>
+
+<Portal id="dashboard">
+	<fieldset class="flex">
+		<Button
+			icon="focus"
+			active={focusing}
+			disabled={!canFocus}
+			description="Focus selection"
+			hotkey="/"
+			onclick={() => (focusing = !focusing)}
+		/>
+	</fieldset>
+</Portal>
+
+{#if focusing}
+	<FocusBox />
+{/if}

package/dist/plugins/Focus/Focus.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const Focus: import("svelte").Component<Record<string, never>, {}, "">;
+type Focus = ReturnType<typeof Focus>;
+export default Focus;

package/dist/plugins/Focus/FocusBox.svelte

@@ -0,0 +1,75 @@
+<script lang="ts">
+	import { T, useThrelte } from '@threlte/core'
+	import { Gizmo, TrackballControls } from '@threlte/extras'
+	import { untrack } from 'svelte'
+	import { Box3, Vector3 } from 'three'
+
+	import Camera from '../../components/Camera.svelte'
+	import { traits, useQuery } from '../../ecs'
+	import { useCameraControls } from '../../hooks/useControls.svelte'
+
+	const { scene } = useThrelte()
+	const cameraControls = useCameraControls()
+	const selected = useQuery(traits.Selected)
+
+	/**
+	 * Save the main camera controls and their state the instant focus begins —
+	 * this runs before the TrackballControls below swaps the shared context, so
+	 * `current` is still the main controls. On teardown we hand `current` back to
+	 * them (the trackball never restores it) and reset them to the saved view, so
+	 * exiting focus returns the camera to where it was. camera-controls exposes
+	 * saveState()/reset(); TrackballControls does not, which also narrows the type.
+	 */
+	$effect.pre(() => {
+		const previousControls = untrack(() => cameraControls.current)
+		const restorableControls =
+			previousControls && 'saveState' in previousControls ? previousControls : undefined
+		restorableControls?.saveState()
+
+		return () => {
+			if (!restorableControls) return
+			cameraControls.set(restorableControls)
+			restorableControls.reset(false)
+		}
+	})
+
+	const box = new Box3()
+	const vec = new Vector3()
+
+	let center = $state.raw<[number, number, number]>([0, 0, 0])
+	let size = $state.raw<[number, number, number]>([0, 0, 0])
+
+	/**
+	 * Frame the camera on the selection captured when focus was entered. Reading
+	 * the selection untracked leaves this effect with no reactive dependencies,
+	 * so it runs once on mount and the framing stays put — changing the selection
+	 * while focused must not re-frame or reset the camera.
+	 */
+	$effect(() => {
+		box.makeEmpty()
+		for (const entity of untrack(() => selected.current)) {
+			const object3d = scene.getObjectByName(entity as unknown as string)
+			if (object3d) {
+				box.expandByObject(object3d)
+			}
+		}
+
+		size = box.getSize(vec).toArray()
+		center = box.getCenter(vec).toArray()
+	})
+</script>
+
+<Camera position={[size[0] + 1, size[0] + 1, size[0] + 1]}>
+	<TrackballControls
+		target={center}
+		oncreate={(ref) => cameraControls.set(ref)}
+	>
+		<Gizmo placement="bottom-right" />
+	</TrackballControls>
+</Camera>
+
+<T.Box3Helper
+	args={[box, 'red']}
+	bvh={{ enabled: false }}
+	raycast={() => null}
+/>

package/dist/plugins/Focus/FocusBox.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const FocusBox: import("svelte").Component<Record<string, never>, {}, "">;
+type FocusBox = ReturnType<typeof FocusBox>;
+export default FocusBox;

package/dist/plugins/Focus/provideFocus.svelte.d.ts

@@ -0,0 +1 @@
+export declare const provideFocus: (focusing: () => boolean) => void;

package/dist/plugins/Focus/provideFocus.svelte.js

@@ -0,0 +1,61 @@
+import { trait } from 'koota';
+import { untrack } from 'svelte';
+import { relations, traits, useQuery, useWorld } from '../../ecs';
+const HiddenByFocus = trait();
+export const provideFocus = (focusing) => {
+    const world = useWorld();
+    const selected = useQuery(traits.Selected);
+    $effect(() => {
+        if (!focusing()) {
+            for (const entity of world.query(HiddenByFocus)) {
+                entity.remove(HiddenByFocus, traits.Invisible);
+            }
+            return;
+        }
+        /**
+         * Snapshot the selection at the moment focus is entered. Reading it
+         * untracked makes `focusing()` this effect's only dependency, so the
+         * focused view stays frozen: selecting or deselecting entities while
+         * focused must not change what's hidden. Everything is restored when
+         * focus exits.
+         */
+        const selectedEntities = untrack(() => selected.current);
+        /**
+         * Entities only render when their `InheritedInvisible` is unset, and that
+         * trait is computed by walking `ChildOf` ancestors (see
+         * `useInheritedInvisible`). So hiding a selected entity's parent — or its
+         * renderable sub-entities, which are `ChildOf` children that never carry
+         * `Selected` — makes the selection itself disappear. Keep the whole
+         * connected subtree of each selection visible: its ancestors (so the
+         * cascade can't reach it) and its descendants (so its geometry shows).
+         */
+        const keep = new Set();
+        const keepSubtree = (entity) => {
+            if (keep.has(entity))
+                return;
+            keep.add(entity);
+            for (const child of world.query(relations.ChildOf(entity))) {
+                keepSubtree(child);
+            }
+        };
+        for (const entity of selectedEntities) {
+            let ancestor = entity.targetFor(relations.ChildOf);
+            while (ancestor?.isAlive()) {
+                keep.add(ancestor);
+                ancestor = ancestor.targetFor(relations.ChildOf);
+            }
+            keepSubtree(entity);
+        }
+        /**
+         * Hide the rest. Skip already-invisible entities so we don't take
+         * ownership of — and later wrongly reveal — user-hidden entities.
+         */
+        for (const entity of world.query(traits.Name)) {
+            if (keep.has(entity))
+                continue;
+            if (!entity.has(traits.Invisible)) {
+                entity.add(HiddenByFocus, traits.Invisible);
+            }
+        }
+    });
+};

package/dist/{components → plugins}/MeasureTool/MeasureTool.svelte

@@ -4,16 +4,14 @@
 	import { untrack } from 'svelte'
 	import { type Intersection, Vector3 } from 'three'
 
-	import Button from '../overlay/dashboard/Button.svelte'
+	import Button from '../../components/overlay/dashboard/Button.svelte'
+	import Popover from '../../components/overlay/Popover.svelte'
+	import ToggleGroup from '../../components/overlay/ToggleGroup.svelte'
 	import { useMouseRaycaster } from '../../hooks/useMouseRaycaster.svelte'
-	import { useFocusedEntity } from '../../hooks/useSelection.svelte'
 	import { useSettings } from '../../hooks/useSettings.svelte'
 
-	import Popover from '../overlay/Popover.svelte'
-	import ToggleGroup from '../overlay/ToggleGroup.svelte'
 	import MeasurePoint from './MeasurePoint.svelte'
 
-	const focusedEntity = useFocusedEntity()
 	const settings = useSettings()
 
 	const htmlPosition = new Vector3()
@@ -73,9 +71,9 @@
 	}
 
 	$effect(() => {
-		// eslint-disable-next-line @typescript-eslint/no-unused-expressions
-		;(focusedEntity.current, enabled)
-		untrack(() => clear())
+		if (!enabled) {
+			untrack(() => clear())
+		}
 	})
 </script>
 

package/dist/plugins/Selection/SelectionTool.svelte

@@ -9,7 +9,7 @@
 	import DashboardButton from '../../components/overlay/dashboard/Button.svelte'
 	import Popover from '../../components/overlay/Popover.svelte'
 	import ToggleGroup from '../../components/overlay/ToggleGroup.svelte'
-	import { useSelectedEntity } from '../../hooks/useSelection.svelte'
+	import { traits, useWorld } from '../../ecs'
 	import { useSettings } from '../../hooks/useSettings.svelte'
 
 	import Ellipse from './Ellipse.svelte'
@@ -29,11 +29,12 @@
 	let { enabled = false, autoSelectNewEntities = false, children }: Props = $props()
 
 	const { dom } = useThrelte()
+	const world = useWorld()
 	const settings = useSettings()
 	const isSelectionMode = $derived(settings.current.interactionMode === 'select')
 
 	const selectionPlugin = provideSelectionPlugin()
-	const selectedEntity = useSelectedEntity()
+
 	let selectionType = $state<SelectionType>('lasso')
 
 	$effect(() => {
@@ -58,7 +59,13 @@
 
 		const newest = newEntities.at(-1)
 		if (newest === undefined) return
-		selectedEntity.set(newest)
+
+		const selected = world.query(traits.Selected)
+		for (const entity of selected) {
+			entity.remove(traits.Selected)
+		}
+
+		newest.add(traits.Selected)
 	})
 
 	const rect = new ElementRect(() => dom)

package/dist/plugins/index.d.ts

@@ -2,6 +2,8 @@ export { default as SelectionTool } from './Selection/SelectionTool.svelte';
 export * as selectionTraits from './Selection/traits';
 export * as selectionRelations from './Selection/relations';
 export { useSelectionPlugin } from './Selection/useSelectionPlugin.svelte';
+export { default as MeasureTool } from './MeasureTool/MeasureTool.svelte';
 export { default as DrawService } from './DrawService/DrawService.svelte';
 export { default as Skybox } from './Skybox/Skybox.svelte';
 export { default as Debug } from './Debug/Debug.svelte';
+export { default as Focus } from './Focus/Focus.svelte';

package/dist/plugins/index.js

@@ -3,9 +3,11 @@ export { default as SelectionTool } from './Selection/SelectionTool.svelte';
 export * as selectionTraits from './Selection/traits';
 export * as selectionRelations from './Selection/relations';
 export { useSelectionPlugin } from './Selection/useSelectionPlugin.svelte';
+export { default as MeasureTool } from './MeasureTool/MeasureTool.svelte';
 // DrawService
 export { default as DrawService } from './DrawService/DrawService.svelte';
 // Skybox
 export { default as Skybox } from './Skybox/Skybox.svelte';
 // Debug
 export { default as Debug } from './Debug/Debug.svelte';
+export { default as Focus } from './Focus/Focus.svelte';

package/dist/three/arrow.d.ts

@@ -1,4 +1,6 @@
 import { type BufferGeometry } from 'three';
+/** Total length of the geometry produced by `createArrowGeometry`, in meters. */
+export declare const ARROW_LENGTH = 0.1;
 /**
  * Returns one merged geometry for an arrow (box tail + cone head)
  *

package/dist/three/arrow.js

@@ -1,12 +1,14 @@
 import { BoxGeometry, ConeGeometry } from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+/** Total length of the geometry produced by `createArrowGeometry`, in meters. */
+export const ARROW_LENGTH = 0.1;
 /**
  * Returns one merged geometry for an arrow (box tail + cone head)
  *
  * Arrow points along +Y with its base at y = 0
  */
 export const createArrowGeometry = () => {
-    const length = 0.1;
+    const length = ARROW_LENGTH;
     const headLength = length * 0.3;
     const headWidth = headLength * 0.3;
     const tailLength = length - headLength;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viamrobotics/motion-tools",
-  "version": "1.31.0",
+  "version": "1.32.0",
   "description": "Motion visualization with Viam",
   "license": "Apache-2.0",
   "type": "module",
@@ -9,6 +9,8 @@
     "@ag-grid-community/core": "32.3.9",
     "@ag-grid-community/styles": "32.3.9",
     "@changesets/cli": "2.29.6",
+    "@connectrpc/connect": "1.7.0",
+    "@connectrpc/connect-web": "1.7.0",
     "@dimforge/rapier3d-compat": "0.18.2",
     "@eslint/compat": "2.0.2",
     "@eslint/js": "10.0.1",
@@ -52,6 +54,7 @@
     "@zag-js/tree-view": "1.22.1",
     "camera-controls": "3.1.0",
     "concurrently": "^9.2.1",
+    "earcut": "^3.0.2",
     "esbuild": "^0.27.3",
     "eslint": "10.0.2",
     "eslint-config-prettier": "10.1.8",
@@ -87,6 +90,8 @@
     "@ag-grid-community/client-side-row-model": ">=32.3.0",
     "@ag-grid-community/core": ">=32.3.0",
     "@ag-grid-community/styles": ">=32.3.0",
+    "@connectrpc/connect": ">=1",
+    "@connectrpc/connect-web": ">=1",
     "@dimforge/rapier3d-compat": ">=0.17",
     "@tanstack/svelte-query-devtools": ">=6",
     "@threlte/core": ">=8",
@@ -105,6 +110,7 @@
     "@zag-js/toggle-group": ">=1",
     "@zag-js/tree-view": ">=1",
     "camera-controls": ">=3",
+    "earcut": ">=3",
     "idb-keyval": ">=6",
     "lucide-svelte": ">=0.511",
     "runed": ">=0.28",
@@ -113,8 +119,17 @@
     "svelte-virtuallists": ">=1"
   },
   "peerDependenciesMeta": {
+    "@connectrpc/connect": {
+      "optional": true
+    },
+    "@connectrpc/connect-web": {
+      "optional": true
+    },
     "@tanstack/svelte-query-devtools": {
       "optional": true
+    },
+    "earcut": {
+      "optional": true
     }
   },
   "engines": {
@@ -147,10 +162,7 @@
   ],
   "dependencies": {
     "@bufbuild/protobuf": "1.10.1",
-    "@connectrpc/connect": "1.7.0",
-    "@connectrpc/connect-web": "1.7.0",
     "@neodrag/svelte": "^2.3.3",
-    "earcut": "^3.0.2",
     "filtrex": "^3.1.0",
     "koota": "0.6.5",
     "lodash-es": "4.18.1",

package/dist/components/Focus.svelte

@@ -1,46 +0,0 @@
-<script lang="ts">
-	import { T } from '@threlte/core'
-	import { Gizmo, TrackballControls } from '@threlte/extras'
-	import { Box3, type Object3D, Vector3 } from 'three'
-
-	import { useCameraControls } from '../hooks/useControls.svelte'
-
-	import Camera from './Camera.svelte'
-
-	interface Props {
-		object3d: Object3D
-	}
-
-	let { object3d }: Props = $props()
-
-	const cameraControls = useCameraControls()
-
-	const box = new Box3()
-	const vec = new Vector3()
-
-	let center = $state.raw<[number, number, number]>([0, 0, 0])
-	let size = $state.raw<[number, number, number]>([0, 0, 0])
-
-	$effect.pre(() => {
-		box.setFromObject(object3d)
-		size = box.getSize(vec).toArray()
-		center = box.getCenter(vec).toArray()
-	})
-</script>
-
-<Camera position={[size[0] + 1, size[0] + 1, size[0] + 1]}>
-	<TrackballControls
-		target={center}
-		oncreate={(ref) => cameraControls.set(ref)}
-	>
-		<Gizmo placement="bottom-right" />
-	</TrackballControls>
-</Camera>
-
-<T is={object3d} />
-
-<T.BoxHelper
-	args={[object3d, 'red']}
-	bvh={{ enabled: false }}
-	raycast={() => null}
-/>

package/dist/components/Focus.svelte.d.ts

@@ -1,7 +0,0 @@
-import { type Object3D } from 'three';
-interface Props {
-    object3d: Object3D;
-}
-declare const Focus: import("svelte").Component<Props, {}, "">;
-type Focus = ReturnType<typeof Focus>;
-export default Focus;