@inweb/viewer-visualize 26.9.3 → 26.9.5

package/dist/viewer-visualize.module.js

@@ -1,16 +1,35 @@
-import { CANVAS_EVENTS, draggersRegistry, commandsRegistry, componentsRegistry, Loader, loadersRegistry, Options } from "@inweb/viewer-core";
-
-export * from "@inweb/viewer-core";
-
-import { EventEmitter2 } from "@inweb/eventemitter2";
-
-import { Markup } from "@inweb/markup";
-
-export * from "@inweb/markup";
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
+// All rights reserved.
+// 
+// This software and its documentation and related materials are owned by
+// the Alliance. The software may only be incorporated into application
+// programs owned by members of the Alliance, subject to a signed
+// Membership Agreement and Supplemental Software License Agreement with the
+// Alliance. The structure and organization of this software are the valuable
+// trade secrets of the Alliance and its suppliers. The software is also
+// protected by copyright law and international treaty provisions. Application
+// programs incorporating this software must include the following statement
+// with their copyright notices:
+// 
+//   This application incorporates Open Design Alliance software pursuant to a
+//   license agreement with Open Design Alliance.
+//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
+//   All rights reserved.
+// 
+// By use of this software, its documentation or related materials, you
+// acknowledge and accept the above terms.
+///////////////////////////////////////////////////////////////////////////////
+
+import { CANVAS_EVENTS, draggersRegistry, commandsRegistry, componentsRegistry, Loader, loadersRegistry, Options } from '@inweb/viewer-core';
+export * from '@inweb/viewer-core';
+import { EventEmitter2 } from '@inweb/eventemitter2';
+import { Markup } from '@inweb/markup';
+export * from '@inweb/markup';
 
 class OdaGeAction {
     constructor(module) {
-        this.setViewParams = params => {
+        this.setViewParams = (params) => {
             var _a;
             const extView = this.m_module.getViewer().getActiveTvExtendedView();
             extView.setView(params.position, params.target, params.upVector, params.viewFieldWidth, params.viewFieldHeight, params.perspective);
@@ -25,7 +44,7 @@ class OdaGeAction {
                 upVector: view.upVector,
                 viewFieldWidth: view.viewFieldWidth,
                 viewFieldHeight: view.viewFieldHeight,
-                perspective: view.perspective
+                perspective: view.perspective,
             };
             (_a = view.delete) === null || _a === void 0 ? void 0 : _a.call(view);
             return obj;
@@ -39,30 +58,30 @@ class OdaGeAction {
         return this.getViewer().getMarkupModel();
     }
     copyPoint(point) {
-        const p = new this.m_module.Point3d;
+        const p = new this.m_module.Point3d();
         p.set(point.x, point.y, point.z);
         return p;
     }
     createVector3d() {
-        return new this.m_module.Vector3d;
+        return new this.m_module.Vector3d();
     }
     createPoint3d() {
-        return new this.m_module.Point3d;
+        return new this.m_module.Point3d();
     }
     createMatrix3d() {
-        return new this.m_module.Matrix3d;
+        return new this.m_module.Matrix3d();
     }
     createPlane() {
-        return new this.m_module.OdTvPlane;
+        return new this.m_module.OdTvPlane();
     }
     toVector(geVector) {
         return this.m_module.Vector3d.createFromArray(geVector);
     }
     toGeVector(v) {
-        return [ v.x, v.y, v.z ];
+        return [v.x, v.y, v.z];
     }
     toGePoint(point) {
-        return [ point.x, point.y, point.z ];
+        return [point.x, point.y, point.z];
     }
     toPoint(gePoint) {
         return this.m_module.Point3d.createFromArray(gePoint);
@@ -82,9 +101,14 @@ class OdaGeAction {
     correctCameraTarget() {
         const params = this.getViewParams();
         const ext = this.m_module.getViewer().getActiveExtents();
-        const {min: min, max: max} = ext;
+        const { min, max } = ext;
         const target = this.toPoint(params.target);
-        const contains = target.x >= min.x && target.y >= min.y && target.z >= min.z && target.x <= max.x && target.y <= max.y && target.z <= max.z;
+        const contains = target.x >= min.x &&
+            target.y >= min.y &&
+            target.z >= min.z &&
+            target.x <= max.x &&
+            target.y <= max.y &&
+            target.z <= max.z;
         if (!contains) {
             params.target = ext.center();
             this.setViewParams(params);
@@ -93,9 +117,7 @@ class OdaGeAction {
 }
 
 const CLICK_DELTA = 5;
-
 const INTERACTIVITY_FPS = 24;
-
 class OdBaseDragger extends OdaGeAction {
     constructor(subject) {
         super(subject.visualizeJs);
@@ -115,7 +137,7 @@ class OdBaseDragger extends OdaGeAction {
                 view.endInteractivity();
                 const device = this.getViewer().getActiveDevice();
                 const canvas = this.m_module.canvas;
-                device.invalidate([ 0, 0, canvas.width, canvas.height ]);
+                device.invalidate([0, 0, canvas.width, canvas.height]);
                 device.delete();
                 this.subject.update();
             }
@@ -123,28 +145,22 @@ class OdBaseDragger extends OdaGeAction {
         };
         this.subject = subject;
         this.needInputText = false;
-        this.mouseDownPosition = {
-            x: 0,
-            y: 0
-        };
+        this.mouseDownPosition = { x: 0, y: 0 };
         this.autoSelect = false;
-        this.onmessage = event => this.subject.emitEvent(event);
+        this.onmessage = (event) => this.subject.emitEvent(event);
         this.canvasEvents = CANVAS_EVENTS;
     }
     initialize() {
-        this.canvasEvents = this.canvasEvents.filter(x => typeof this[x] === "function");
-        this.canvasEvents.forEach(x => this[x] = this[x].bind(this));
-        this.canvasEvents.forEach(x => this.subject.on(x, this[x]));
+        this.canvasEvents = this.canvasEvents.filter((x) => typeof this[x] === "function");
+        this.canvasEvents.forEach((x) => (this[x] = this[x].bind(this)));
+        this.canvasEvents.forEach((x) => this.subject.on(x, this[x]));
         this.getViewer().setEnableAutoSelect(!!this.autoSelect);
     }
     dispose() {
-        this.canvasEvents.forEach(x => this.subject.off(x, this[x]));
+        this.canvasEvents.forEach((x) => this.subject.off(x, this[x]));
     }
     relativeCoords(event) {
-        return {
-            x: event.offsetX * window.devicePixelRatio,
-            y: event.offsetY * window.devicePixelRatio
-        };
+        return { x: event.offsetX * window.devicePixelRatio, y: event.offsetY * window.devicePixelRatio };
     }
     pointerdown(ev) {
         if (!ev.isPrimary || OdBaseDragger.isGestureActive) {
@@ -153,10 +169,7 @@ class OdBaseDragger extends OdaGeAction {
         ev.target.setPointerCapture(ev.pointerId);
         const relCoord = this.relativeCoords(ev);
         this.isDragging = true;
-        this.mouseDownPosition = {
-            x: relCoord.x,
-            y: relCoord.y
-        };
+        this.mouseDownPosition = { x: relCoord.x, y: relCoord.y };
         this.start(relCoord.x, relCoord.y, ev.clientX, ev.clientY);
         this.subject.update();
     }
@@ -201,11 +214,7 @@ class OdBaseDragger extends OdaGeAction {
             this.subject.update();
             const selectionSet = viewer.getSelected();
             const handles = this.subject.getSelected();
-            this.onmessage({
-                type: "select",
-                data: selectionSet,
-                handles: handles
-            });
+            this.onmessage({ type: "select", data: selectionSet, handles });
         }
     }
     dblclick(ev) {
@@ -214,32 +223,30 @@ class OdBaseDragger extends OdaGeAction {
         const x = relCoord.x;
         const y = relCoord.y;
         const device = viewer.getActiveDevice();
-        const clickView = device.viewAt([ x, y ]);
+        const clickView = device.viewAt([x, y]);
         if (clickView && !clickView.active) {
             viewer.activeView = clickView;
             clickView.delete();
             this.subject.update();
-        } else {
+        }
+        else {
             if (viewer && viewer.getEnableAutoSelect()) {
                 const pSelected = viewer.getSelected();
                 if (!pSelected.isNull() && pSelected.numItems() !== 0) {
                     const itr = pSelected.getIterator();
                     const entity = itr.getEntity();
                     viewer.zoomToEntity(entity);
-                    this.onmessage({
-                        type: "zoomtoentity",
-                        data: entity
-                    });
+                    this.onmessage({ type: "zoomtoentity", data: entity });
                     this.subject.update();
-                    this.deleteAll([ itr, entity ]);
+                    this.deleteAll([itr, entity]);
                 }
             }
         }
         device.delete();
     }
-    start(x, y, absoluteX = 0, absoluteY = 0) {}
-    drag(x, y, absoluteX = 0, absoluteY = 0) {}
-    end(x, y, absoluteX = 0, absoluteY = 0) {}
+    start(x, y, absoluteX = 0, absoluteY = 0) { }
+    drag(x, y, absoluteX = 0, absoluteY = 0) { }
+    end(x, y, absoluteX = 0, absoluteY = 0) { }
     getActiveMarkupEntity(entityName) {
         return this.subject.addMarkupEntity(entityName);
     }
@@ -252,7 +259,7 @@ class OdBaseDragger extends OdaGeAction {
             (_a = obj === null || obj === void 0 ? void 0 : obj.delete) === null || _a === void 0 ? void 0 : _a.call(obj);
         }
     }
-    updatePreview() {}
+    updatePreview() { }
     static set isGestureActive(value) {
         if (OdBaseDragger._isGestureActive === value) {
             return;
@@ -276,9 +283,7 @@ class OdBaseDragger extends OdaGeAction {
         OdBaseDragger._needSkipPointerUp = value;
     }
 }
-
 OdBaseDragger._isGestureActive = false;
-
 OdBaseDragger._needSkipPointerUp = false;
 
 function createHtmlElementIfNeed(element, targetElement, dataTestId) {
@@ -289,30 +294,24 @@ function createHtmlElementIfNeed(element, targetElement, dataTestId) {
     }
     return element;
 }
-
 function destroyHtmlElement(element, targetElement) {
     if (element) {
         targetElement.removeChild(element);
     }
     return null;
 }
-
 function worldToScreen(gePoint, moduleInstance, viewer) {
     const worldPoint = moduleInstance.Point3d.createFromArray(gePoint);
     const avp = viewer.activeView;
     const mtx = avp.worldToDeviceMatrix;
     const devicePoint = worldPoint.transformBy(mtx);
-    const res = {
-        x: devicePoint.x / window.devicePixelRatio,
-        y: devicePoint.y / window.devicePixelRatio
-    };
+    const res = { x: devicePoint.x / window.devicePixelRatio, y: devicePoint.y / window.devicePixelRatio };
     mtx.delete();
     worldPoint.delete();
     devicePoint.delete();
     avp.delete();
     return res;
 }
-
 function getDistance(gePoint1, gePoint2, moduleInstance) {
     const tvPoint1 = moduleInstance.Point3d.createFromArray(gePoint1);
     const tvPoint2 = moduleInstance.Point3d.createFromArray(gePoint2);
@@ -321,11 +320,9 @@ function getDistance(gePoint1, gePoint2, moduleInstance) {
     tvPoint2.delete();
     return distance;
 }
-
 function normalizeFloat(value) {
     return value < 0 ? Math.ceil(value) : Math.floor(value);
 }
-
 const lineSegmentsIntersect = (p1, p2, p3, p4) => {
     const a_dx = p2.x - p1.x;
     const a_dy = p2.y - p1.y;
@@ -333,40 +330,27 @@ const lineSegmentsIntersect = (p1, p2, p3, p4) => {
     const b_dy = p4.y - p3.y;
     const s = (-a_dy * (p1.x - p3.x) + a_dx * (p1.y - p3.y)) / (-b_dx * a_dy + a_dx * b_dy);
     const t = (+b_dx * (p1.y - p3.y) - b_dy * (p1.x - p3.x)) / (-b_dx * a_dy + a_dx * b_dy);
-    return s >= 0 && s <= 1 && t >= 0 && t <= 1 ? {
-        x: normalizeFloat(p1.x + t * a_dx),
-        y: normalizeFloat(p1.y + t * a_dy)
-    } : false;
+    return s >= 0 && s <= 1 && t >= 0 && t <= 1
+        ? {
+            x: normalizeFloat(p1.x + t * a_dx),
+            y: normalizeFloat(p1.y + t * a_dy),
+        }
+        : false;
 };
-
 function checkSegmentsIntersect(p1, p2, p3, p4, res) {
     const r = lineSegmentsIntersect(p1, p2, p3, p4);
     if (r) {
         res.push(r);
     }
 }
-
 function isInsideRect(p, width, height) {
     return p.x <= width && p.x >= 0 && p.y <= height && p.y >= 0;
 }
-
 function getDataForDrawLineWithFixed(p1, p2, width, height) {
-    const pLU = {
-        x: 0,
-        y: 0
-    };
-    const pRU = {
-        x: width,
-        y: 0
-    };
-    const pLB = {
-        x: 0,
-        y: height
-    };
-    const pRB = {
-        x: width,
-        y: height
-    };
+    const pLU = { x: 0, y: 0 };
+    const pRU = { x: width, y: 0 };
+    const pLB = { x: 0, y: height };
+    const pRB = { x: width, y: height };
     const intersects = [];
     checkSegmentsIntersect(p1, p2, pLU, pRU, intersects);
     checkSegmentsIntersect(p1, p2, pLU, pLB, intersects);
@@ -377,39 +361,35 @@ function getDataForDrawLineWithFixed(p1, p2, width, height) {
     if (intersects.length === 0) {
         fixedP1 = p1;
         fixedP2 = p2;
-    } else if (intersects.length === 1) {
+    }
+    else if (intersects.length === 1) {
         if (isInsideRect(p1, width, height)) {
             fixedP1 = p1;
             fixedP2 = intersects[0];
-        } else {
+        }
+        else {
             fixedP1 = intersects[0];
             fixedP2 = p2;
         }
-    } else {
+    }
+    else {
         fixedP1 = intersects[0];
         fixedP2 = intersects[1];
     }
     const dx = fixedP2.x - fixedP1.x;
     const dy = fixedP2.y - fixedP1.y;
-    let angle = 180 * Math.atan(dy / dx) / Math.PI;
+    let angle = (180 * Math.atan(dy / dx)) / Math.PI;
     if (dx < 0) {
         angle -= 180;
     }
     const size = Math.sqrt(Math.pow(dx, 2) + Math.pow(dy, 2));
-    return {
-        angle: angle,
-        width: size,
-        p1: fixedP1,
-        p2: fixedP2
-    };
+    return { angle, width: size, p1: fixedP1, p2: fixedP2 };
 }
-
 function onSetCallback(element, cb) {
     if (element) {
-        element.onclick = cb ? () => cb() : () => {};
+        element.onclick = cb ? () => cb() : () => { };
     }
 }
-
 function onSetSelectivity(element, enable) {
     element.style.pointerEvents = enable ? "auto" : "none";
 }
@@ -423,14 +403,14 @@ class MeasureLineItem {
         this.startPoint = null;
         this.endPoint = null;
         this.unit = "";
-        this.scale = 1;
-        this.size = 10;
+        this.scale = 1.0;
+        this.size = 10.0;
         this.lineThickness = 2;
         this.style = {
             border: "2px solid #FFFFFF",
             background: "#009bff",
             color: "white",
-            boxShadow: "0 0 10px rgba(0,0,0,0.5)"
+            boxShadow: "0 0 10px rgba(0,0,0,0.5)",
         };
         this.htmlElemStartPoint = createHtmlElementIfNeed(this.htmlElemStartPoint, targetElement, "ruler-start");
         this.htmlElemEndPoint = createHtmlElementIfNeed(this.htmlElemEndPoint, targetElement, "ruler-end");
@@ -460,7 +440,8 @@ class MeasureLineItem {
                 this.htmlElemStartPoint.style.width = `${pointSize}px`;
                 this.htmlElemStartPoint.style.height = `${pointSize}px`;
                 this.htmlElemStartPoint.style.boxShadow = this.style.boxShadow;
-            } else {
+            }
+            else {
                 this.htmlElemStartPoint.style.display = "none";
             }
         }
@@ -480,14 +461,15 @@ class MeasureLineItem {
                 this.htmlElemEndPoint.style.width = `${pointSize}px`;
                 this.htmlElemEndPoint.style.height = `${pointSize}px`;
                 this.htmlElemEndPoint.style.boxShadow = this.style.boxShadow;
-            } else {
+            }
+            else {
                 this.htmlElemEndPoint.style.display = "none";
             }
         }
         if (this.endPoint && this.startPoint) {
             const point1 = worldToScreen(this.startPoint, this.moduleInstance, this.viewer);
             const point2 = worldToScreen(this.endPoint, this.moduleInstance, this.viewer);
-            const {p1: p1, p2: p2, angle: angle, width: width} = getDataForDrawLineWithFixed(point1, point2, rect.width, rect.height);
+            const { p1, p2, angle, width } = getDataForDrawLineWithFixed(point1, point2, rect.width, rect.height);
             const dx = p2.x - p1.x;
             const dy = p2.y - p1.y;
             const height = this.lineThickness;
@@ -528,7 +510,8 @@ class MeasureLineItem {
                 this.htmlElemTitle.style.padding = "2px";
                 this.htmlElemTitle.style.textAlign = "center";
                 this.htmlElemTitle.innerHTML = `${distance}`;
-            } else {
+            }
+            else {
                 this.htmlElemLine.style.display = "none";
                 this.htmlElemTitle.style.display = "none";
             }
@@ -536,7 +519,7 @@ class MeasureLineItem {
     }
     getDistance() {
         let distance = getDistance(this.startPoint, this.endPoint, this.moduleInstance);
-        if (Math.abs(this.scale - 1) > 1e-4) {
+        if (Math.abs(this.scale - 1.0) > 10e-5) {
             distance = (distance / this.scale).toFixed(2);
         }
         return distance;
@@ -593,14 +576,13 @@ class MeasureLineItem {
 function renameUnit(table, unit) {
     return table[unit] || unit;
 }
-
 class MeasureLineDragger extends OdBaseDragger {
     constructor(subject) {
         var _a;
         super(subject);
         this.lineThickness = 2;
         this.press = false;
-        this.gripingRadius = 5;
+        this.gripingRadius = 5.0;
         this.firstPoint = null;
         this.secondPoint = null;
         this.renameUnitTable = {
@@ -614,7 +596,7 @@ class MeasureLineDragger extends OdBaseDragger {
             Miles: "mi",
             Micrometers: "µm",
             MicroInches: "µin",
-            Default: "unit"
+            Default: "unit",
         };
         this.items = [];
         this.canvasEvents.push("resize");
@@ -638,7 +620,7 @@ class MeasureLineDragger extends OdBaseDragger {
         this.subject.removeEventListener("optionschange", this.optionsChange);
     }
     updatePreview() {
-        this.items.forEach(item => item.update());
+        this.items.forEach((item) => item.update());
     }
     resize() {
         const rect = this.m_module.canvas.getBoundingClientRect();
@@ -673,20 +655,24 @@ class MeasureLineDragger extends OdBaseDragger {
                     this.secondPoint = point;
                     this.previewMeasureLine.setStartPoint(this.firstPoint);
                     this.previewMeasureLine.setEndPoint(this.secondPoint, true);
-                } else {
+                }
+                else {
                     this.firstPoint = point;
                     this.previewMeasureLine.setStartPoint(this.firstPoint);
                 }
-            } else {
+            }
+            else {
                 this.secondPoint = null;
                 this.previewMeasureLine.clear();
                 this.previewMeasureLine.setStartPoint(this.firstPoint);
                 this.previewMeasureLine.setEndPoint(this.getViewer().screenToWorld(x, y), false);
             }
-        } else {
+        }
+        else {
             if (point) {
                 this.previewMeasureLine.setStartPoint(point);
-            } else {
+            }
+            else {
                 this.previewMeasureLine.clear();
             }
         }
@@ -718,8 +704,9 @@ class MeasureLineDragger extends OdBaseDragger {
             const multiplier = viewer.getUnitsConversionCoef(fromUnit, toUnit);
             this.conversionFactor = 1 / multiplier;
             item.setConversionFactor(this.conversionFactor);
-        } else {
-            item.setConversionFactor(1);
+        }
+        else {
+            item.setConversionFactor(1.0);
         }
         this.items.push(item);
         return item;
@@ -728,16 +715,18 @@ class MeasureLineDragger extends OdBaseDragger {
         var _a;
         const options = event.data;
         const toUnitName = (_a = options.rulerUnit) !== null && _a !== void 0 ? _a : "Default";
-        if (this.oldRulerUnit === toUnitName) return;
+        if (this.oldRulerUnit === toUnitName)
+            return;
         this.oldRulerUnit = toUnitName;
         const drawingUnit = this.m_module.getViewer().getUnit();
         const eToUnit = this.getKUnitByName(toUnitName);
         const eFromUnit = this.getKUnitByName(drawingUnit);
-        this.items.forEach(item => {
+        this.items.forEach((item) => {
             if (toUnitName === "Default") {
                 item.setUnit(renameUnit(this.renameUnitTable, drawingUnit));
-                item.setConversionFactor(1);
-            } else {
+                item.setConversionFactor(1.0);
+            }
+            else {
                 item.setUnit(renameUnit(this.renameUnitTable, toUnitName));
                 const multiplier = this.m_module.getViewer().getUnitsConversionCoef(eFromUnit, eToUnit);
                 this.conversionFactor = 1 / multiplier;
@@ -748,61 +737,52 @@ class MeasureLineDragger extends OdBaseDragger {
     getKUnitByName(unitName) {
         let eUnit = this.m_module.Units.kUserDefined;
         switch (unitName) {
-          case "Millimeters":
-            eUnit = this.m_module.Units.kMillimeters;
-            break;
-
-          case "Centimeters":
-            eUnit = this.m_module.Units.kCentimeters;
-            break;
-
-          case "Meters":
-            eUnit = this.m_module.Units.kMeters;
-            break;
-
-          case "Feet":
-            eUnit = this.m_module.Units.kFeet;
-            break;
-
-          case "Inches":
-            eUnit = this.m_module.Units.kInches;
-            break;
-
-          case "Yards":
-            eUnit = this.m_module.Units.kYards;
-            break;
-
-          case "Kilometers":
-            eUnit = this.m_module.Units.kKilometers;
-            break;
-
-          case "Miles":
-            eUnit = this.m_module.Units.kMiles;
-            break;
-
-          case "Micrometers":
-            eUnit = this.m_module.Units.kMicrometers;
-            break;
-
-          case "MicroInches":
-            eUnit = this.m_module.Units.kMicroInches;
-            break;
+            case "Millimeters":
+                eUnit = this.m_module.Units.kMillimeters;
+                break;
+            case "Centimeters":
+                eUnit = this.m_module.Units.kCentimeters;
+                break;
+            case "Meters":
+                eUnit = this.m_module.Units.kMeters;
+                break;
+            case "Feet":
+                eUnit = this.m_module.Units.kFeet;
+                break;
+            case "Inches":
+                eUnit = this.m_module.Units.kInches;
+                break;
+            case "Yards":
+                eUnit = this.m_module.Units.kYards;
+                break;
+            case "Kilometers":
+                eUnit = this.m_module.Units.kKilometers;
+                break;
+            case "Miles":
+                eUnit = this.m_module.Units.kMiles;
+                break;
+            case "Micrometers":
+                eUnit = this.m_module.Units.kMicrometers;
+                break;
+            case "MicroInches":
+                eUnit = this.m_module.Units.kMicroInches;
+                break;
         }
         return eUnit;
     }
 }
 
-const FocalLengthConst = 42;
-
-const calcFocalLength = (lensLength, fieldWidth, fieldHeight) => lensLength / FocalLengthConst * Math.sqrt(fieldWidth * fieldWidth + fieldHeight * fieldHeight);
-
+const FocalLengthConst$1 = 42.0;
+const calcFocalLength$1 = (lensLength, fieldWidth, fieldHeight) => {
+    return (lensLength / FocalLengthConst$1) * Math.sqrt(fieldWidth * fieldWidth + fieldHeight * fieldHeight);
+};
 class OdaWalkDragger extends OdBaseDragger {
     constructor(subject) {
         super(subject);
         this.viewer = undefined;
         this.multiplier = 5;
         this.speed = 1;
-        this.keyPressMap = new Set;
+        this.keyPressMap = new Set();
         this.keydown = this.keydown.bind(this);
         this.keyup = this.keyup.bind(this);
         this.lastFrameTS = 0;
@@ -820,17 +800,15 @@ class OdaWalkDragger extends OdBaseDragger {
         this.viewer.setEnableWCS(false);
         const view = this.viewer.activeView;
         const maxDimension = this.getMaxDimension(view);
-        this.speed = maxDimension / 3e4;
-        this.subject.emitEvent({
-            type: "walkstart"
-        });
+        this.speed = maxDimension / 30000;
+        this.subject.emitEvent({ type: "walkstart" });
         this.viewParams = this.getViewParams();
         this.setViewParams(this.viewParams);
         const model = this.viewer.getActiveModel();
         this.cameraId = model.appendCamera("Camera0");
         this.setupCamera(view);
         model.delete();
-        this.cameraWalker = new this.m_module.OdTvCameraWalker;
+        this.cameraWalker = new this.m_module.OdTvCameraWalker();
         this.cameraWalker.setCamera(this.cameraId);
         this.subject.update();
         this.enableZoomWheelPreviousValue = this.subject.options.enableZoomWheel;
@@ -838,7 +816,8 @@ class OdaWalkDragger extends OdBaseDragger {
     }
     dispose() {
         var _a;
-        this.oldWCSEnableValue = this.oldWCSEnableValue !== undefined ? this.oldWCSEnableValue : this.subject.options.showWCS;
+        this.oldWCSEnableValue =
+            this.oldWCSEnableValue !== undefined ? this.oldWCSEnableValue : this.subject.options.showWCS;
         this.viewer.setEnableWCS(this.oldWCSEnableValue);
         super.dispose();
         this.keyPressMap.clear();
@@ -864,37 +843,251 @@ class OdaWalkDragger extends OdBaseDragger {
     }
     keydown(ev) {
         switch (ev.code) {
-          case "NumpadSubtract":
-          case "Minus":
-            if (this.multiplier > 1) {
-                this.multiplier = this.multiplier - 1;
-                this.subject.emitEvent({
-                    type: "walkspeedchange",
-                    data: this.multiplier
-                });
-            }
-            break;
-
-          case "NumpadAdd":
-          case "Equal":
-            if (this.multiplier < 10) {
-                this.multiplier = this.multiplier + 1;
-                this.subject.emitEvent({
-                    type: "walkspeedchange",
-                    data: this.multiplier
-                });
+            case "NumpadSubtract":
+            case "Minus":
+                if (this.multiplier > 1) {
+                    this.multiplier = this.multiplier - 1;
+                    this.subject.emitEvent({ type: "walkspeedchange", data: this.multiplier });
+                }
+                break;
+            case "NumpadAdd":
+            case "Equal":
+                if (this.multiplier < 10) {
+                    this.multiplier = this.multiplier + 1;
+                    this.subject.emitEvent({ type: "walkspeedchange", data: this.multiplier });
+                }
+                break;
+            case "KeyW":
+            case "KeyA":
+            case "KeyS":
+            case "KeyD":
+            case "KeyQ":
+            case "KeyE":
+                this.keyPressMap.add(ev.code);
+                if (!this.animationId)
+                    this.processMovement(0);
+                break;
+        }
+    }
+    keyup(ev) {
+        this.keyPressMap.delete(ev.code);
+        if (this.keyPressMap.size < 1 && this.animationId) {
+            window.cancelAnimationFrame(this.animationId);
+            this.animationId = undefined;
+            this.lastFrameTS = 0;
+        }
+    }
+    processMovement(timestamp) {
+        this.animationId = requestAnimationFrame(this.processMovement);
+        if (this.lastFrameTS !== 0) {
+            const deltaTS = timestamp - this.lastFrameTS;
+            const currentDelta = this.multiplier * deltaTS * this.speed;
+            for (const keyCode of this.keyPressMap) {
+                switch (keyCode) {
+                    case "KeyW":
+                        this.moveForward(currentDelta);
+                        break;
+                    case "KeyS":
+                        this.moveBackward(currentDelta);
+                        break;
+                    case "KeyA":
+                        this.cameraWalker.moveLeft(currentDelta);
+                        break;
+                    case "KeyD":
+                        this.cameraWalker.moveRight(currentDelta);
+                        break;
+                    case "KeyQ":
+                        this.cameraWalker.moveUp(currentDelta);
+                        break;
+                    case "KeyE":
+                        this.cameraWalker.moveDown(currentDelta);
+                        break;
+                }
             }
-            break;
+            this.subject.update();
+            this.subject.emitEvent({ type: "changecamera" });
+        }
+        this.lastFrameTS = timestamp;
+    }
+    start(x, y) {
+        this.dragPosition = { x, y };
+    }
+    drag(x, y) {
+        if (this.cameraId && this.isDragging) {
+            const dltX = x - this.dragPosition.x;
+            const dltY = y - this.dragPosition.y;
+            this.dragPosition = { x, y };
+            if (dltX !== 0.0)
+                this.turnLeft(-dltX * this.deltaAngle);
+            if (dltY !== 0.0)
+                this.cameraWalker.turnDown(dltY * this.deltaAngle);
+            this.subject.update();
+            this.subject.emitEvent({ type: "changecamera" });
+        }
+    }
+    moveForward(currentDelta) {
+        const { Vector3d } = this.m_module;
+        const camera = this.cameraWalker.camera().openObjectAsCamera();
+        const target = Vector3d.createFromArray(camera.target());
+        const dir = Vector3d.createFromArray(camera.direction());
+        const up = Vector3d.createFromArray(camera.upVector());
+        const pos = Vector3d.createFromArray(camera.position());
+        let move = Vector3d.createFromArray([dir.x, dir.y, 0]);
+        if (Math.abs(dir.x) > 0.001 && Math.abs(dir.y) > 0.001) {
+            move.setToProduct(move.normalize(), currentDelta);
+        }
+        else {
+            move = Vector3d.createFromArray([0, currentDelta, 0]);
+        }
+        let newPos = pos.add(move);
+        let newTarget = target.add(move);
+        camera.setupCamera(newPos.toArray(), newTarget.toArray(), up.toArray());
+    }
+    moveBackward(currentDelta) {
+        this.moveForward(-currentDelta);
+    }
+    turnLeft(angle) {
+        const pCamera = this.cameraWalker.camera().openObjectAsCamera();
+        const dir = this.toVector(pCamera.direction());
+        const up = this.toVector(pCamera.upVector());
+        const pos = pCamera.position();
+        const rotMatrix = this.createMatrix3d();
+        const zAxisVector = [0, 0, 1];
+        rotMatrix.setToRotation(angle, zAxisVector, pos);
+        dir.transformBy(rotMatrix);
+        up.transformBy(rotMatrix);
+        pCamera.setupCameraByDirection(pos, dir.toArray(), up.toArray());
+        pCamera.delete();
+    }
+    setupCamera(view) {
+        const pCamera = this.cameraId.openObjectAsCamera();
+        const target = view.viewTarget;
+        pCamera.setDisplayGlyph(false);
+        pCamera.setDisplayTarget(false);
+        pCamera.setAutoAdjust(true);
+        pCamera.setupCamera(view.viewPosition, target, view.upVector);
+        pCamera.setNearClip(false, 1.0);
+        pCamera.setFarClip(false, 0);
+        pCamera.setViewParameters(view.viewFieldWidth, view.viewFieldHeight, true);
+        const focalL = calcFocalLength$1(view.lensLength, view.viewFieldWidth, view.viewFieldHeight);
+        const pTarget = this.toPoint(view.viewTarget);
+        const viewDir = this.toPoint(view.viewPosition);
+        const viewDirSub = viewDir.sub(pTarget);
+        const viewDirVec = viewDirSub.asVector();
+        const viewDirVecNormal = viewDirVec.normalize();
+        const geViewDir = this.toGeVector(viewDirVecNormal);
+        const newGeViewDir = [geViewDir[0] * focalL, geViewDir[1] * focalL, geViewDir[2] * focalL];
+        const pTarget2 = this.toPoint(view.viewTarget);
+        const newGeViewDirPt = this.toPoint(newGeViewDir);
+        const newPos = pTarget2.add(newGeViewDirPt);
+        pCamera.setupCamera(this.toGePoint(newPos), view.viewTarget, view.upVector);
+        this.deleteAll([pTarget, viewDir, viewDirSub, viewDirVec, viewDirVecNormal, pTarget2, newGeViewDirPt, newPos]);
+        pCamera.assignView(view);
+        pCamera.delete();
+    }
+    getMaxDimension(view) {
+        const [xmax, ymax, zmax] = view.sceneExtents.max();
+        const [xmin, ymin, zmin] = view.sceneExtents.min();
+        const volume = [xmax - xmin, ymax - ymin, zmax - zmin];
+        return Math.max(...volume);
+    }
+}
 
-          case "KeyW":
-          case "KeyA":
-          case "KeyS":
-          case "KeyD":
-          case "KeyQ":
-          case "KeyE":
-            this.keyPressMap.add(ev.code);
-            if (!this.animationId) this.processMovement(0);
-            break;
+const FocalLengthConst = 42.0;
+const calcFocalLength = (lensLength, fieldWidth, fieldHeight) => {
+    return (lensLength / FocalLengthConst) * Math.sqrt(fieldWidth * fieldWidth + fieldHeight * fieldHeight);
+};
+class OdaFlyDragger extends OdBaseDragger {
+    constructor(subject) {
+        super(subject);
+        this.viewer = undefined;
+        this.multiplier = 5;
+        this.speed = 1;
+        this.keyPressMap = new Set();
+        this.keydown = this.keydown.bind(this);
+        this.keyup = this.keyup.bind(this);
+        this.lastFrameTS = 0;
+        this.animationId = undefined;
+        this.processMovement = this.processMovement.bind(this);
+        this.deltaAngle = Math.PI / 3600;
+        this.autoSelect = true;
+    }
+    initialize() {
+        super.initialize();
+        this.viewer = this.getViewer();
+        window.addEventListener("keydown", this.keydown, false);
+        window.addEventListener("keyup", this.keyup, false);
+        this.oldWCSEnableValue = this.viewer.getEnableWCS();
+        this.viewer.setEnableWCS(false);
+        const view = this.viewer.activeView;
+        const maxDimension = this.getMaxDimension(view);
+        this.speed = maxDimension / 30000;
+        this.subject.emitEvent({ type: "flystart" });
+        this.viewParams = this.getViewParams();
+        this.setViewParams(this.viewParams);
+        const model = this.viewer.getActiveModel();
+        this.cameraId = model.appendCamera("Camera0");
+        this.setupCamera(view);
+        model.delete();
+        this.cameraFlyer = new this.m_module.OdTvCameraWalker();
+        this.cameraFlyer.setCamera(this.cameraId);
+        this.subject.update();
+        this.enableZoomWheelPreviousValue = this.subject.options.enableZoomWheel;
+        this.subject.options.enableZoomWheel = false;
+    }
+    dispose() {
+        var _a;
+        this.oldWCSEnableValue =
+            this.oldWCSEnableValue !== undefined ? this.oldWCSEnableValue : this.subject.options.showWCS;
+        this.viewer.setEnableWCS(this.oldWCSEnableValue);
+        super.dispose();
+        this.keyPressMap.clear();
+        window.removeEventListener("keydown", this.keydown);
+        window.removeEventListener("keyup", this.keyup);
+        if (this.animationId) {
+            window.cancelAnimationFrame(this.animationId);
+            this.animationId = undefined;
+        }
+        if (this.cameraId) {
+            const model = this.viewer.getActiveModel();
+            model.removeEntity(this.cameraId);
+            model.delete();
+            (_a = this.cameraFlyer) === null || _a === void 0 ? void 0 : _a.delete();
+        }
+        if (this.viewParams) {
+            this.setViewParams(this.viewParams);
+            const avp = this.viewer.activeView;
+            avp.delete();
+        }
+        this.subject.update(true);
+        this.subject.options.enableZoomWheel = this.enableZoomWheelPreviousValue;
+    }
+    keydown(ev) {
+        switch (ev.code) {
+            case "NumpadSubtract":
+            case "Minus":
+                if (this.multiplier > 1) {
+                    this.multiplier = this.multiplier - 1;
+                    this.subject.emitEvent({ type: "flyspeedchange", data: this.multiplier });
+                }
+                break;
+            case "NumpadAdd":
+            case "Equal":
+                if (this.multiplier < 10) {
+                    this.multiplier = this.multiplier + 1;
+                    this.subject.emitEvent({ type: "flyspeedchange", data: this.multiplier });
+                }
+                break;
+            case "KeyW":
+            case "KeyA":
+            case "KeyS":
+            case "KeyD":
+            case "KeyQ":
+            case "KeyE":
+                this.keyPressMap.add(ev.code);
+                if (!this.animationId)
+                    this.processMovement(0);
+                break;
         }
     }
     keyup(ev) {
@@ -912,67 +1105,54 @@ class OdaWalkDragger extends OdBaseDragger {
             const currentDelta = this.multiplier * deltaTS * this.speed;
             for (const keyCode of this.keyPressMap) {
                 switch (keyCode) {
-                  case "KeyW":
-                    this.cameraWalker.moveForward(currentDelta);
-                    break;
-
-                  case "KeyS":
-                    this.cameraWalker.moveBackward(currentDelta);
-                    break;
-
-                  case "KeyA":
-                    this.cameraWalker.moveLeft(currentDelta);
-                    break;
-
-                  case "KeyD":
-                    this.cameraWalker.moveRight(currentDelta);
-                    break;
-
-                  case "KeyQ":
-                    this.cameraWalker.moveUp(currentDelta);
-                    break;
-
-                  case "KeyE":
-                    this.cameraWalker.moveDown(currentDelta);
-                    break;
+                    case "KeyW":
+                        this.cameraFlyer.moveForward(currentDelta);
+                        break;
+                    case "KeyS":
+                        this.cameraFlyer.moveBackward(currentDelta);
+                        break;
+                    case "KeyA":
+                        this.cameraFlyer.moveLeft(currentDelta);
+                        break;
+                    case "KeyD":
+                        this.cameraFlyer.moveRight(currentDelta);
+                        break;
+                    case "KeyQ":
+                        this.cameraFlyer.moveUp(currentDelta);
+                        break;
+                    case "KeyE":
+                        this.cameraFlyer.moveDown(currentDelta);
+                        break;
                 }
             }
             this.subject.update();
-            this.subject.emitEvent({
-                type: "changecamera"
-            });
+            this.subject.emitEvent({ type: "changecamera" });
         }
         this.lastFrameTS = timestamp;
     }
     start(x, y) {
-        this.dragPosition = {
-            x: x,
-            y: y
-        };
+        this.dragPosition = { x, y };
     }
     drag(x, y) {
         if (this.cameraId && this.isDragging) {
             const dltX = x - this.dragPosition.x;
             const dltY = y - this.dragPosition.y;
-            this.dragPosition = {
-                x: x,
-                y: y
-            };
-            if (dltX !== 0) this.turnLeft(-dltX * this.deltaAngle);
-            if (dltY !== 0) this.cameraWalker.turnDown(dltY * this.deltaAngle);
+            this.dragPosition = { x, y };
+            if (dltX !== 0.0)
+                this.turnLeft(-dltX * this.deltaAngle);
+            if (dltY !== 0.0)
+                this.cameraFlyer.turnDown(dltY * this.deltaAngle);
             this.subject.update();
-            this.subject.emitEvent({
-                type: "changecamera"
-            });
+            this.subject.emitEvent({ type: "changecamera" });
         }
     }
     turnLeft(angle) {
-        const pCamera = this.cameraWalker.camera().openObjectAsCamera();
+        const pCamera = this.cameraFlyer.camera().openObjectAsCamera();
         const dir = this.toVector(pCamera.direction());
         const up = this.toVector(pCamera.upVector());
         const pos = pCamera.position();
         const rotMatrix = this.createMatrix3d();
-        const zAxisVector = [ 0, 0, 1 ];
+        const zAxisVector = [0, 0, 1];
         rotMatrix.setToRotation(angle, zAxisVector, pos);
         dir.transformBy(rotMatrix);
         up.transformBy(rotMatrix);
@@ -986,7 +1166,7 @@ class OdaWalkDragger extends OdBaseDragger {
         pCamera.setDisplayTarget(false);
         pCamera.setAutoAdjust(true);
         pCamera.setupCamera(view.viewPosition, target, view.upVector);
-        pCamera.setNearClip(false, 1);
+        pCamera.setNearClip(false, 1.0);
         pCamera.setFarClip(false, 0);
         pCamera.setViewParameters(view.viewFieldWidth, view.viewFieldHeight, true);
         const focalL = calcFocalLength(view.lensLength, view.viewFieldWidth, view.viewFieldHeight);
@@ -996,19 +1176,19 @@ class OdaWalkDragger extends OdBaseDragger {
         const viewDirVec = viewDirSub.asVector();
         const viewDirVecNormal = viewDirVec.normalize();
         const geViewDir = this.toGeVector(viewDirVecNormal);
-        const newGeViewDir = [ geViewDir[0] * focalL, geViewDir[1] * focalL, geViewDir[2] * focalL ];
+        const newGeViewDir = [geViewDir[0] * focalL, geViewDir[1] * focalL, geViewDir[2] * focalL];
         const pTarget2 = this.toPoint(view.viewTarget);
         const newGeViewDirPt = this.toPoint(newGeViewDir);
         const newPos = pTarget2.add(newGeViewDirPt);
         pCamera.setupCamera(this.toGePoint(newPos), view.viewTarget, view.upVector);
-        this.deleteAll([ pTarget, viewDir, viewDirSub, viewDirVec, viewDirVecNormal, pTarget2, newGeViewDirPt, newPos ]);
+        this.deleteAll([pTarget, viewDir, viewDirSub, viewDirVec, viewDirVecNormal, pTarget2, newGeViewDirPt, newPos]);
         pCamera.assignView(view);
         pCamera.delete();
     }
     getMaxDimension(view) {
         const [xmax, ymax, zmax] = view.sceneExtents.max();
         const [xmin, ymin, zmin] = view.sceneExtents.min();
-        const volume = [ xmax - xmin, ymax - ymin, zmax - zmin ];
+        const volume = [xmax - xmin, ymax - ymin, zmax - zmin];
         return Math.max(...volume);
     }
 }
@@ -1030,25 +1210,25 @@ class OdBaseCuttingPlaneDragger extends OdBaseDragger {
         plane.set(this.toGePoint(this.m_center), this.m_normal);
         avp.addCuttingPlane(plane);
         this.index = avp.numCuttingPlanes() - 1;
-        const {red: red, green: green, blue: blue} = this.subject.options.cuttingPlaneFillColor;
+        const { red, green, blue } = this.subject.options.cuttingPlaneFillColor;
         avp.setEnableCuttingPlaneFill(true, red, green, blue);
-        avp.setCuttingPlaneFillPatternEnabled(true, this.m_module.CuttingPlaneFillStyle.kHorizontalBars, 0, 0, 0);
+        avp.setCuttingPlaneFillPatternEnabled(true, this.m_module.CuttingPlaneFillStyle.kHorizontalBars, 0x0, 0x0, 0x0);
         this.m_model = this.getModel();
         this.createPreview();
-        this.deleteAll([ ext, avp, plane ]);
+        this.deleteAll([ext, avp, plane]);
     }
     dispose() {
         super.dispose();
         if (this.m_entity) {
             this.m_model.removeEntity(this.m_entity);
-            this.deleteAll([ this.m_model, this.m_entity, this.planePreview, this.m_center ]);
+            this.deleteAll([this.m_model, this.m_entity, this.planePreview, this.m_center]);
             this.m_entity = null;
             this.planePreview = null;
             this.subject.update();
         }
     }
     createNormal() {
-        return [ 0, 0, 0 ];
+        return [0, 0, 0];
     }
     handleDelta(delta) {
         return delta;
@@ -1059,10 +1239,7 @@ class OdBaseCuttingPlaneDragger extends OdBaseDragger {
     start(x, y) {
         this.press = true;
         this.m_last = this.screenToWorld(x, y);
-        this.m_click = {
-            x: x,
-            y: y
-        };
+        this.m_click = { x, y };
     }
     drag(x, y) {
         if (this.press) {
@@ -1077,7 +1254,7 @@ class OdBaseCuttingPlaneDragger extends OdBaseDragger {
             const newPlane = plane.set(this.toGePoint(this.m_center), this.m_normal);
             const newCutting = avp.updateCuttingPlane(this.index, plane);
             this.drawPreview();
-            this.deleteAll([ avp, plane, oldCenter, delta, oldLast, newPlane, newCutting ]);
+            this.deleteAll([avp, plane, oldCenter, delta, oldLast, newPlane, newCutting]);
             const device = this.getViewer().getActiveDevice();
             device.invalidate(device.getSize());
         }
@@ -1085,12 +1262,12 @@ class OdBaseCuttingPlaneDragger extends OdBaseDragger {
     end(x, y) {
         this.press = false;
         if (x === this.m_click.x && y === this.m_click.y) {
-            this.m_normal = [ this.m_normal[0] * -1, this.m_normal[1] * -1, this.m_normal[2] * -1 ];
+            this.m_normal = [this.m_normal[0] * -1, this.m_normal[1] * -1, this.m_normal[2] * -1];
             const avp = this.getViewer().activeView;
             const plane = this.createPlane();
             plane.set(this.toGePoint(this.m_center), this.m_normal);
             avp.updateCuttingPlane(this.index, plane);
-            this.deleteAll([ avp, plane, this.m_last ]);
+            this.deleteAll([avp, plane, this.m_last]);
             const device = this.getViewer().getActiveDevice();
             device.invalidate(device.getSize());
         }
@@ -1098,70 +1275,109 @@ class OdBaseCuttingPlaneDragger extends OdBaseDragger {
     createPreview() {
         this.m_entity = this.m_model.appendEntity("&CuttingPlanePreview");
         const GeometryTypes = this.m_module.GeometryTypes;
-        const transparencyDef = new this.m_module.OdTvTransparencyDef;
+        const transparencyDef = new this.m_module.OdTvTransparencyDef();
         const colorDef = new this.m_module.OdTvColorDef(112, 112, 112);
-        transparencyDef.setValue(.9);
+        transparencyDef.setValue(0.9);
         const entityPtr = this.m_entity.openObject();
         entityPtr.setColor(colorDef, GeometryTypes.kFaces.value);
         colorDef.setColor(112, 112, 112);
         entityPtr.setColor(colorDef, GeometryTypes.kEdges.value);
         entityPtr.setLineWeight(5);
         entityPtr.setTransparency(transparencyDef, GeometryTypes.kFaces);
-        transparencyDef.setValue(1);
+        transparencyDef.setValue(1.0);
         entityPtr.setTransparency(transparencyDef, GeometryTypes.kEdges);
         this.planePreview = entityPtr.appendPolygon(this.getPlanePreviewCoordinate());
         const polygonPtr = this.planePreview.openAsPolygon();
         polygonPtr.setFilled(true);
-        this.deleteAll([ transparencyDef, colorDef, entityPtr, polygonPtr, GeometryTypes ]);
+        this.deleteAll([transparencyDef, colorDef, entityPtr, polygonPtr, GeometryTypes]);
         this.subject.syncOverlay();
     }
     drawPreview() {
         const polygonPtr = this.planePreview.openAsPolygon();
         polygonPtr.setPoints(this.getPlanePreviewCoordinate());
-        this.deleteAll([ polygonPtr ]);
+        this.deleteAll([polygonPtr]);
         this.subject.syncOverlay();
     }
 }
 
 class OdCuttingPlaneXAxisDragger extends OdBaseCuttingPlaneDragger {
     createNormal() {
-        return [ 1, 0, 0 ];
+        return [1, 0, 0];
     }
     handleDelta(delta) {
-        delta.y = 0;
-        delta.z = 0;
+        delta.y = 0.0;
+        delta.z = 0.0;
         return delta;
     }
     getPlanePreviewCoordinate() {
-        return [ this.m_center.x, this.m_center.y - this.m_size_y, this.m_center.z - this.m_size_z, this.m_center.x, this.m_center.y + this.m_size_y, this.m_center.z - this.m_size_z, this.m_center.x, this.m_center.y + this.m_size_y, this.m_center.z + this.m_size_z, this.m_center.x, this.m_center.y - this.m_size_y, this.m_center.z + this.m_size_z ];
+        return [
+            this.m_center.x,
+            this.m_center.y - this.m_size_y,
+            this.m_center.z - this.m_size_z,
+            this.m_center.x,
+            this.m_center.y + this.m_size_y,
+            this.m_center.z - this.m_size_z,
+            this.m_center.x,
+            this.m_center.y + this.m_size_y,
+            this.m_center.z + this.m_size_z,
+            this.m_center.x,
+            this.m_center.y - this.m_size_y,
+            this.m_center.z + this.m_size_z,
+        ];
     }
 }
 
 class OdCuttingPlaneYAxisDragger extends OdBaseCuttingPlaneDragger {
     createNormal() {
-        return [ 0, 1, 0 ];
+        return [0, 1, 0];
     }
     handleDelta(delta) {
-        delta.x = 0;
-        delta.z = 0;
+        delta.x = 0.0;
+        delta.z = 0.0;
         return delta;
     }
     getPlanePreviewCoordinate() {
-        return [ this.m_center.x - this.m_size_x, this.m_center.y, this.m_center.z - this.m_size_z, this.m_center.x + this.m_size_x, this.m_center.y, this.m_center.z - this.m_size_z, this.m_center.x + this.m_size_x, this.m_center.y, this.m_center.z + this.m_size_z, this.m_center.x - this.m_size_x, this.m_center.y, this.m_center.z + this.m_size_z ];
+        return [
+            this.m_center.x - this.m_size_x,
+            this.m_center.y,
+            this.m_center.z - this.m_size_z,
+            this.m_center.x + this.m_size_x,
+            this.m_center.y,
+            this.m_center.z - this.m_size_z,
+            this.m_center.x + this.m_size_x,
+            this.m_center.y,
+            this.m_center.z + this.m_size_z,
+            this.m_center.x - this.m_size_x,
+            this.m_center.y,
+            this.m_center.z + this.m_size_z,
+        ];
     }
 }
 
 class OdCuttingPlaneZAxisDragger extends OdBaseCuttingPlaneDragger {
     createNormal() {
-        return [ 0, 0, 1 ];
+        return [0, 0, 1];
     }
     handleDelta(delta) {
-        delta.x = 0;
-        delta.y = 0;
+        delta.x = 0.0;
+        delta.y = 0.0;
         return delta;
     }
     getPlanePreviewCoordinate() {
-        return [ this.m_center.x - this.m_size_x, this.m_center.y - this.m_size_y, this.m_center.z, this.m_center.x + this.m_size_x, this.m_center.y - this.m_size_y, this.m_center.z, this.m_center.x + this.m_size_x, this.m_center.y + this.m_size_y, this.m_center.z, this.m_center.x - this.m_size_x, this.m_center.y + this.m_size_y, this.m_center.z ];
+        return [
+            this.m_center.x - this.m_size_x,
+            this.m_center.y - this.m_size_y,
+            this.m_center.z,
+            this.m_center.x + this.m_size_x,
+            this.m_center.y - this.m_size_y,
+            this.m_center.z,
+            this.m_center.x + this.m_size_x,
+            this.m_center.y + this.m_size_y,
+            this.m_center.z,
+            this.m_center.x - this.m_size_x,
+            this.m_center.y + this.m_size_y,
+            this.m_center.z,
+        ];
     }
 }
 
@@ -1174,10 +1390,7 @@ class OrbitAction {
     }
     beginAction(x, y) {
         this.m_viewCenter = this.getCenter();
-        this.m_startPoint = {
-            x: x,
-            y: y
-        };
+        this.m_startPoint = { x, y };
         const view = this.getViewer().activeView;
         view.delete();
         this._beginInteractivity();
@@ -1187,8 +1400,8 @@ class OrbitAction {
         const view = this.getViewer().activeView;
         const corners = view.vportRect;
         const size = Math.max(Math.abs(corners[2] - corners[0]), Math.abs(corners[3] - corners[1]));
-        const distX = (this.m_startPoint.x - x) * Math.PI / size;
-        const distY = (this.m_startPoint.y - y) * Math.PI / size;
+        const distX = ((this.m_startPoint.x - x) * Math.PI) / size;
+        const distY = ((this.m_startPoint.y - y) * Math.PI) / size;
         this.m_startPoint.x = x;
         this.m_startPoint.y = y;
         const xOrbit = distY;
@@ -1199,14 +1412,14 @@ class OrbitAction {
             upVector: view.upVector,
             viewFieldWidth: view.viewFieldWidth,
             viewFieldHeight: view.viewFieldHeight,
-            perspective: view.perspective
+            perspective: view.perspective,
         };
         view.delete();
         const sideVector = this.getSideVector(viewParams);
-        if (xOrbit !== 0) {
+        if (xOrbit !== 0.0) {
             this.calculateXOrbit(viewParams, -xOrbit, sideVector);
         }
-        if (yOrbit !== 0) {
+        if (yOrbit !== 0.0) {
             this.calculateYOrbit(viewParams, yOrbit, sideVector);
         }
         sideVector.delete();
@@ -1215,10 +1428,10 @@ class OrbitAction {
         extView.delete();
         (_b = (_a = this._subject.activeDragger()) === null || _a === void 0 ? void 0 : _a.updatePreview) === null || _b === void 0 ? void 0 : _b.call(_a);
         this._subject.emitEvent({
-            type: "orbit"
+            type: "orbit",
         });
         this._subject.emitEvent({
-            type: "changecamera"
+            type: "changecamera",
         });
     }
     endAction() {
@@ -1232,7 +1445,7 @@ class OrbitAction {
         const vDirect = direct.asVector();
         const vCross = pUpV.crossProduct(vDirect);
         const sideVector = vCross.normalize();
-        this.deleteAll([ direct, pUpV, pTarget, pPosition, vDirect, vCross ]);
+        this.deleteAll([direct, pUpV, pTarget, pPosition, vDirect, vCross]);
         return sideVector;
     }
     calculateXOrbit(viewParams, delta, sideVector) {
@@ -1241,14 +1454,14 @@ class OrbitAction {
             const pCenter = this.toPoint(this.m_viewCenter);
             const rotatePoint = pPoint.rotateByBasePoint(delta, sideVector, pCenter);
             viewParams.position = rotatePoint.toArray();
-            this.deleteAll([ pPoint, pCenter, rotatePoint ]);
+            this.deleteAll([pPoint, pCenter, rotatePoint]);
         }
         {
             const pTarget = this.toPoint(viewParams.target);
             const pCenter = this.toPoint(this.m_viewCenter);
             const rotatePoint = pTarget.rotateByBasePoint(delta, sideVector, pCenter);
             viewParams.target = rotatePoint.toArray();
-            this.deleteAll([ pTarget, pCenter, rotatePoint ]);
+            this.deleteAll([pTarget, pCenter, rotatePoint]);
         }
         {
             const pPoint = this.toPoint(viewParams.position);
@@ -1259,7 +1472,7 @@ class OrbitAction {
             const crossProduct = vUp.crossProduct(sideVector);
             const crossProductNormal = crossProduct.normalize();
             viewParams.upVector = crossProductNormal.toArray();
-            this.deleteAll([ pPoint, pTarget, pCenter, pUp, vUp, crossProduct, crossProductNormal ]);
+            this.deleteAll([pPoint, pTarget, pCenter, pUp, vUp, crossProduct, crossProductNormal]);
         }
     }
     calculateYOrbit(viewParams, delta, sideVector) {
@@ -1269,7 +1482,7 @@ class OrbitAction {
             const zAxis = this.toVector(this._m_module.Vector3d.kZAxis);
             const rotatePoint = pPoint.rotateByBasePoint(delta, zAxis, pCenter);
             viewParams.position = rotatePoint.toArray();
-            this.deleteAll([ zAxis, pPoint, pCenter, rotatePoint ]);
+            this.deleteAll([zAxis, pPoint, pCenter, rotatePoint]);
         }
         {
             const pTarget = this.toPoint(viewParams.target);
@@ -1277,7 +1490,7 @@ class OrbitAction {
             const zAxis = this.toVector(this._m_module.Vector3d.kZAxis);
             const rotatePoint = pTarget.rotateByBasePoint(delta, zAxis, pCenter);
             viewParams.target = rotatePoint.toArray();
-            this.deleteAll([ zAxis, pTarget, pCenter, rotatePoint ]);
+            this.deleteAll([zAxis, pTarget, pCenter, rotatePoint]);
         }
         {
             const zAxis = this.toVector(this._m_module.Vector3d.kZAxis);
@@ -1289,7 +1502,7 @@ class OrbitAction {
             const cross = vUp.crossProduct(side);
             const crossNormal = cross.normalize();
             viewParams.upVector = crossNormal.toArray();
-            this.deleteAll([ zAxis, pTarget, pPoint, side, pUp, vUp, cross, crossNormal ]);
+            this.deleteAll([zAxis, pTarget, pPoint, side, pUp, vUp, cross, crossNormal]);
         }
     }
     getCenter() {
@@ -1299,15 +1512,19 @@ class OrbitAction {
         if (!pSet.isNull() && pSet.numItems() !== 0) {
             const itr = pSet.getIterator();
             let ext, entId, extSelected;
-            for (;!itr.done(); itr.step()) {
+            for (; !itr.done(); itr.step()) {
                 entId = itr.getEntity();
                 ext = entId.getWCSExtents();
-                if (extSelected) extSelected.addExt(ext); else extSelected = ext;
+                if (extSelected)
+                    extSelected.addExt(ext);
+                else
+                    extSelected = ext;
             }
             center = extSelected.center();
             extSelected.delete();
             itr.delete();
-        } else {
+        }
+        else {
             center = viewer.getActiveExtents().center();
         }
         return center;
@@ -1367,15 +1584,12 @@ class PanAction {
     }
     beginAction(x, y, absoluteX, absoluteY) {
         this._m_start = this.screenToWorld(x, y);
-        this._deltaScreenPosition = {
-            x: absoluteX,
-            y: absoluteY
-        };
+        this._deltaScreenPosition = { x: absoluteX, y: absoluteY };
         this._beginInteractivity();
     }
     action(x, y, absoluteX, absoluteY) {
         var _a, _b;
-        const {Vector3d: Vector3d} = this._m_module;
+        const { Vector3d } = this._m_module;
         const params = this._getViewParams();
         const pt = this.screenToWorld(x, y);
         const ptSub = this._m_start.sub(pt);
@@ -1397,15 +1611,12 @@ class PanAction {
             x: absoluteX,
             y: absoluteY,
             dX: absoluteX - this._deltaScreenPosition.x,
-            dY: absoluteY - this._deltaScreenPosition.y
+            dY: absoluteY - this._deltaScreenPosition.y,
         });
         this._subject.emitEvent({
-            type: "changecamera"
+            type: "changecamera",
         });
-        this._deltaScreenPosition = {
-            x: absoluteX,
-            y: absoluteY
-        };
+        this._deltaScreenPosition = { x: absoluteX, y: absoluteY };
     }
     endAction() {
         this._endInteractivity();
@@ -1452,10 +1663,10 @@ class ZoomAction {
             type: "zoomat",
             data: zoomFactor,
             x: absoluteX,
-            y: absoluteY
+            y: absoluteY,
         });
         this._subject.emitEvent({
-            type: "changecamera"
+            type: "changecamera",
         });
     }
 }
@@ -1479,8 +1690,8 @@ class OdZoomDragger extends OdBaseDragger {
     drag(x, y) {
         const dltY = y - this.prevY;
         this.prevY = y;
-        if (this.press && Math.abs(dltY) >= 1e-5) {
-            const ZOOM_SPEED = .975;
+        if (this.press && Math.abs(dltY) >= 10e-6) {
+            const ZOOM_SPEED = 0.975;
             const zoomFactor = dltY > 0 ? 1 / ZOOM_SPEED : ZOOM_SPEED;
             this._zoomAction.action(this.pressX, this.pressY, zoomFactor, this.absoluteX, this.absoluteY);
         }
@@ -1492,11 +1703,10 @@ class OdZoomDragger extends OdBaseDragger {
 }
 
 const INTERACTIVITY_TIME_OUT = 100;
-
 class OdZoomWheelDragger extends OdBaseDragger {
     constructor(subject) {
         super(subject);
-        this.canvasEvents = [ "wheel" ];
+        this.canvasEvents = ["wheel"];
         this._zoomAction = new ZoomAction(this.m_module, this.subject);
         this._endInteractivityTimeOutId = undefined;
         this._isEnableInteractivityMode = false;
@@ -1507,8 +1717,8 @@ class OdZoomWheelDragger extends OdBaseDragger {
         }
         event = event || window.event;
         event.preventDefault();
-        const zoomIn = this.subject.options.reverseZoomWheel ? .925 : 1 / .925;
-        const zoomOut = this.subject.options.reverseZoomWheel ? 1 / .925 : .925;
+        const zoomIn = this.subject.options.reverseZoomWheel ? 0.925 : 1 / 0.925;
+        const zoomOut = this.subject.options.reverseZoomWheel ? 1 / 0.925 : 0.925;
         const viewer = this.getViewer();
         if (viewer) {
             const zoomFactor = event.deltaY > 0 ? zoomIn : zoomOut;
@@ -1546,12 +1756,12 @@ class OdZoomWheelDragger extends OdBaseDragger {
 
 class OdSelectionFrame {
     constructor() {
-        this.m_start = [ 0, 0, 0 ];
-        this.m_end = [ 0, 0, 0 ];
+        this.m_start = [0, 0, 0];
+        this.m_end = [0, 0, 0];
         this.m_model = null;
     }
     createPoint3d() {
-        return new this.m_module.Point3d;
+        return new this.m_module.Point3d();
     }
     init(instance, model) {
         this.m_module = instance;
@@ -1607,7 +1817,8 @@ class OdSelectionFrame {
             entityPtr.setLineWeight(2);
             this.m_frame = entityPtr.appendPolygon(this.toDoubleArray(points));
             entityPtr.delete();
-        } else {
+        }
+        else {
             this.m_frame.openAsPolygon().setPoints(this.toDoubleArray(points));
         }
     }
@@ -1625,7 +1836,7 @@ class OdZoomWindowDragger extends OdBaseDragger {
         this.autoSelect = true;
         this.press = false;
         this.needInputText = false;
-        this.m_frame = new OdSelectionFrame;
+        this.m_frame = new OdSelectionFrame();
         this.m_frame.init(this.m_module, this.getModel());
     }
     start(x, y) {
@@ -1665,10 +1876,7 @@ class OrbitAroundBuildingDragger extends OdBaseDragger {
     start(x, y) {
         this.press = true;
         this.m_viewCenter = this.getCenter();
-        this.m_startPoint = {
-            x: x,
-            y: y
-        };
+        this.m_startPoint = { x, y };
         const view = this.getViewer().activeView;
         this.startCameraParams = this.getViewParams();
         const corners = view.vportRect;
@@ -1685,40 +1893,43 @@ class OrbitAroundBuildingDragger extends OdBaseDragger {
             dX *= Math.PI / this.m_delta;
             dY *= Math.PI / this.m_delta;
             this.setDefaultViewParams();
-            const {Vector3d: Vector3d, Matrix3d: Matrix3d} = this.m_module;
+            const { Vector3d, Matrix3d } = this.m_module;
             const target = Vector3d.createFromArray(this.startCameraParams.target);
             const offset = Vector3d.createFromArray(this.startCameraParams.position).sub(target);
             const dir = offset.normalize();
-            const zMatrix = new Matrix3d;
+            const zMatrix = new Matrix3d();
             zMatrix.setToIdentity();
-            const xMatrix = new Matrix3d;
+            const xMatrix = new Matrix3d();
             xMatrix.setToIdentity();
-            const yAxis = Vector3d.createFromArray([ dir.x, dir.y, dir.z ]);
+            const yAxis = Vector3d.createFromArray([dir.x, dir.y, dir.z]);
             const zAxis = Vector3d.createFromArray(this.startCameraParams.upVector);
             const xAxis = yAxis.crossProduct(zAxis);
-            let xyDir = Vector3d.createFromArray([ yAxis.x, yAxis.y, 0 ]);
-            if (xyDir.length() <= 1e-5) {
+            let xyDir = Vector3d.createFromArray([yAxis.x, yAxis.y, 0]);
+            if (xyDir.length() <= 0.00001) {
                 xyDir.set(-xAxis.y, xAxis.x, 0);
-            } else {
+            }
+            else {
                 xyDir = xyDir.normalize();
             }
-            const xyAngle = Math.sign(xyDir.dotProduct(Vector3d.createFromArray([ -1, 0, 0 ]))) * xyDir.angleTo(Vector3d.createFromArray([ 0, 1, 0 ]));
+            const xyAngle = Math.sign(xyDir.dotProduct(Vector3d.createFromArray([-1, 0, 0]))) *
+                xyDir.angleTo(Vector3d.createFromArray([0, 1, 0]));
             dX -= xyAngle;
-            let yzDir = Vector3d.createFromArray([ dir.x, dir.y, 0 ]);
+            let yzDir = Vector3d.createFromArray([dir.x, dir.y, 0]);
             let yzAngle = 0;
-            if (yzDir.length() <= 1e-5) {
-                yzAngle = -dir.z * Math.PI / 2;
-            } else {
+            if (yzDir.length() <= 0.00001) {
+                yzAngle = (-dir.z * Math.PI) / 2;
+            }
+            else {
                 yzDir = yzDir.normalize();
                 yzAngle = -yzDir.angleTo(dir);
             }
             dY -= yzAngle;
-            zMatrix.setToRotation(-dX, [ 0, 0, 1 ], [ 0, 0, 0 ]);
+            zMatrix.setToRotation(-dX, [0, 0, 1], [0, 0, 0]);
             const xAngle = Math.max(this.minPolarAngle, Math.min(this.maxPolarAngle, dY));
-            xMatrix.setToRotation(xAngle, [ 1, 0, 0 ], [ 0, 0, 0 ]);
+            xMatrix.setToRotation(xAngle, [1, 0, 0], [0, 0, 0]);
             const endMatrix = zMatrix.postMultBy(xMatrix);
-            let pos = Vector3d.createFromArray([ 0, 1, 0 ]).transformBy(endMatrix);
-            const up = Vector3d.createFromArray([ 0, 0, 1 ]).transformBy(endMatrix);
+            let pos = Vector3d.createFromArray([0, 1, 0]).transformBy(endMatrix);
+            const up = Vector3d.createFromArray([0, 0, 1]).transformBy(endMatrix);
             pos.setLength(offset.length());
             pos = target.add(pos);
             const current = this.getViewParams();
@@ -1743,7 +1954,8 @@ class OrbitAroundBuildingDragger extends OdBaseDragger {
                 ext.delete();
                 ext = obj.getExtents();
                 obj.delete();
-            } else if (entId.getType() === 2) {
+            }
+            else if (entId.getType() === 2) {
                 const obj = entId.openObjectAsInsert();
                 const extTuple = obj.getExtents();
                 ext.delete();
@@ -1760,48 +1972,39 @@ class OrbitAroundBuildingDragger extends OdBaseDragger {
 }
 
 const draggers = draggersRegistry("visualizejs");
-
-draggers.registerDragger("Pan", viewer => new OdPanDragger(viewer));
-
-draggers.registerDragger("Orbit", viewer => new OdOrbitDragger(viewer));
-
-draggers.registerDragger("Zoom", viewer => new OdZoomDragger(viewer));
-
-draggers.registerDragger("ZoomWindow", viewer => new OdZoomWindowDragger(viewer));
-
-draggers.registerDragger("ZoomWheel", viewer => new OdZoomWheelDragger(viewer));
-
-draggers.registerDragger("OrbitAroundBuilding", viewer => new OrbitAroundBuildingDragger(viewer));
-
-draggers.registerDragger("MeasureLine", viewer => new MeasureLineDragger(viewer));
-
-draggers.registerDragger("CuttingPlaneXAxis", viewer => new OdCuttingPlaneXAxisDragger(viewer));
-
-draggers.registerDragger("CuttingPlaneYAxis", viewer => new OdCuttingPlaneYAxisDragger(viewer));
-
-draggers.registerDragger("CuttingPlaneZAxis", viewer => new OdCuttingPlaneZAxisDragger(viewer));
-
-draggers.registerDragger("Walk", viewer => new OdaWalkDragger(viewer));
+draggers.registerDragger("Pan", (viewer) => new OdPanDragger(viewer));
+draggers.registerDragger("Orbit", (viewer) => new OdOrbitDragger(viewer));
+draggers.registerDragger("Zoom", (viewer) => new OdZoomDragger(viewer));
+draggers.registerDragger("ZoomWindow", (viewer) => new OdZoomWindowDragger(viewer));
+draggers.registerDragger("ZoomWheel", (viewer) => new OdZoomWheelDragger(viewer));
+draggers.registerDragger("OrbitAroundBuilding", (viewer) => new OrbitAroundBuildingDragger(viewer));
+draggers.registerDragger("MeasureLine", (viewer) => new MeasureLineDragger(viewer));
+draggers.registerDragger("CuttingPlaneXAxis", (viewer) => new OdCuttingPlaneXAxisDragger(viewer));
+draggers.registerDragger("CuttingPlaneYAxis", (viewer) => new OdCuttingPlaneYAxisDragger(viewer));
+draggers.registerDragger("CuttingPlaneZAxis", (viewer) => new OdCuttingPlaneZAxisDragger(viewer));
+draggers.registerDragger("Walk", (viewer) => new OdaWalkDragger(viewer));
+draggers.registerDragger("Fly", (viewer) => new OdaFlyDragger(viewer));
 
 const composeMatrixFromTransform = (transform, modelCenter, visLib) => {
-    const {translate: translate, scale: scale, rotation: rotation} = transform;
-    const translateMatrix = new visLib.Matrix3d;
-    translateMatrix.setTranslation([ translate.x, translate.y, translate.z ]);
-    const rotateMatrix = new visLib.Matrix3d;
-    rotateMatrix.setToRotation(rotation.angle, [ rotation.x, rotation.y, rotation.z ], modelCenter);
-    const scaleMatrix = new visLib.Matrix3d;
+    const { translate, scale, rotation } = transform;
+    const translateMatrix = new visLib.Matrix3d();
+    translateMatrix.setTranslation([translate.x, translate.y, translate.z]);
+    const rotateMatrix = new visLib.Matrix3d();
+    rotateMatrix.setToRotation(rotation.angle, [rotation.x, rotation.y, rotation.z], modelCenter);
+    const scaleMatrix = new visLib.Matrix3d();
     scaleMatrix.setToScaling(scale, modelCenter);
     return rotateMatrix.postMultBy(translateMatrix).postMultBy(scaleMatrix);
 };
-
 function applyModelTransform(viewer, model) {
     var _a;
-    if (!viewer.visualizeJs) return;
-    if (!model.getModelTransformMatrix) return;
+    if (!viewer.visualizeJs)
+        return;
+    if (!model.getModelTransformMatrix)
+        return;
     const visLib = viewer.visLib();
     const visViewer = viewer.visViewer();
     const modelItr = visViewer.getModelIterator();
-    for (;!modelItr.done(); modelItr.step()) {
+    for (; !modelItr.done(); modelItr.step()) {
         const modelPtr = modelItr.getModel();
         const transform = model.getModelTransformMatrix(modelPtr.getDatabaseHandle());
         if (transform) {
@@ -1821,75 +2024,79 @@ function clearMarkup(viewer) {
 }
 
 function clearSelected(viewer) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     visViewer.unselect();
     viewer.update();
-    viewer.emitEvent({
-        type: "select",
-        data: undefined,
-        handles: []
-    });
+    viewer.emitEvent({ type: "select", data: undefined, handles: [] });
 }
 
 function clearSlices(viewer) {
     viewer.clearSlices();
 }
 
-function createPreview(viewer, type = "image/jpeg", encoderOptions = .25) {
+function createPreview(viewer, type = "image/jpeg", encoderOptions = 0.25) {
     var _a;
-    if (!viewer.visualizeJs) return "";
+    if (!viewer.visualizeJs)
+        return "";
     return ((_a = viewer.canvas) === null || _a === void 0 ? void 0 : _a.toDataURL(type, encoderOptions)) || "";
 }
 
 function explode(viewer, index = 0) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     visViewer.explode(index);
     viewer.update();
-    viewer.emitEvent({
-        type: "explode",
-        data: index
-    });
+    viewer.emitEvent({ type: "explode", data: index });
 }
-
 function collect(viewer) {
     explode(viewer, 0);
 }
 
 function getDefaultViewPositions(viewer) {
-    if (!viewer.visualizeJs) return [];
+    if (!viewer.visualizeJs)
+        return [];
     const visLib = viewer.visLib();
     const defViewPos = visLib.DefaultViewPosition;
-    return Object.keys(defViewPos).filter(x => x !== "values");
+    return Object.keys(defViewPos).filter((x) => x !== "values");
 }
 
 function getModels(viewer) {
-    if (!viewer.visualizeJs) return [];
+    if (!viewer.visualizeJs)
+        return [];
     const visViewer = viewer.visViewer();
     const handles = [];
     const modelItr = visViewer.getModelIterator();
-    for (;!modelItr.done(); modelItr.step()) {
+    for (; !modelItr.done(); modelItr.step()) {
         const modelPtr = modelItr.getModel();
-        if (modelPtr.getName()[0] !== "$") handles.push(modelPtr.getDatabaseHandle());
+        if (modelPtr.getName()[0] !== "$")
+            handles.push(modelPtr.getDatabaseHandle());
     }
     modelItr.delete();
     return handles;
 }
 
 function getSelected(viewer) {
-    if (!viewer.visualizeJs) return [];
+    if (!viewer.visualizeJs)
+        return [];
     const visViewer = viewer.visViewer();
     const handles = [];
     const selectionSet = visViewer.getSelected();
     if (!selectionSet.isNull() && selectionSet.numItems() !== 0) {
         const itr = selectionSet.getIterator();
-        for (;!itr.done(); itr.step()) {
+        for (; !itr.done(); itr.step()) {
             const entityId = itr.getEntity();
-            const entityPtr = entityId.getType() === 1 ? entityId.openObject() : entityId.getType() === 2 ? entityId.openObjectAsInsert() : null;
+            const entityPtr = entityId.getType() === 1
+                ? entityId.openObject()
+                : entityId.getType() === 2
+                    ? entityId.openObjectAsInsert()
+                    : null;
             if (entityPtr) {
                 const handle = entityPtr.getNativeDatabaseHandle();
-                if (handle !== "-1") handles.push(handle);
+                if (handle !== "-1")
+                    handles.push(handle);
                 entityPtr.delete();
             }
         }
@@ -1899,42 +2106,36 @@ function getSelected(viewer) {
 }
 
 function hideSelected(viewer) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     visViewer.hideSelectedObjects(false);
     viewer.update();
-    viewer.emitEvent({
-        type: "hide"
-    });
-    viewer.emitEvent({
-        type: "select",
-        data: undefined,
-        handles: []
-    });
+    viewer.emitEvent({ type: "hide" });
+    viewer.emitEvent({ type: "select", data: undefined, handles: [] });
 }
 
 function isolateSelected(viewer) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     visViewer.isolateSelectedObjects(false);
     viewer.update();
-    viewer.emitEvent({
-        type: "isolate"
-    });
+    viewer.emitEvent({ type: "isolate" });
 }
 
 function regenerateAll(viewer) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     visViewer.regenAll();
     viewer.update();
-    viewer.emit({
-        type: "regenerateall"
-    });
+    viewer.emit({ type: "regenerateall" });
 }
 
 function resetView(viewer) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     viewer.executeCommand("setActiveDragger");
     viewer.executeCommand("clearSlices");
     viewer.executeCommand("clearOverlay");
@@ -1944,28 +2145,23 @@ function resetView(viewer) {
     viewer.executeCommand("explode", 0);
     viewer.executeCommand("zoomToExtents", true);
     viewer.executeCommand("k3DViewSW");
-    viewer.emit({
-        type: "resetview"
-    });
+    viewer.emit({ type: "resetview" });
 }
 
 function selectModel(viewer, handle) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     const activeView = visViewer.activeView;
     const modelItr = visViewer.getModelIterator();
-    for (;!modelItr.done(); modelItr.step()) {
+    for (; !modelItr.done(); modelItr.step()) {
         const modelPtr = modelItr.getModel();
         if (modelPtr.getDatabaseHandle() === handle) {
-            const selectionSet = activeView.selectCrossing([ 0, 9999, 9999, 0 ], modelPtr);
+            const selectionSet = activeView.selectCrossing([0, 9999, 9999, 0], modelPtr);
             visViewer.setSelected(selectionSet);
             const handles = viewer.getSelected();
             viewer.update();
-            viewer.emitEvent({
-                type: "select",
-                data: selectionSet,
-                handles: handles
-            });
+            viewer.emitEvent({ type: "select", data: selectionSet, handles });
             selectionSet.delete();
             break;
         }
@@ -1978,16 +2174,14 @@ function setActiveDragger(viewer, dragger = "") {
 }
 
 function setDefaultViewPosition(viewer, position = "") {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visLib = viewer.visLib();
     const visViewer = viewer.visViewer();
     const defViewPos = visLib.DefaultViewPosition;
     visViewer.setDefaultViewPositionWithAnimation(defViewPos[position]);
     viewer.update();
-    viewer.emit({
-        type: "viewposition",
-        data: position
-    });
+    viewer.emit({ type: "viewposition", data: position });
 }
 
 function setMarkupColor(viewer, r = 255, g = 0, b = 0) {
@@ -1995,36 +2189,34 @@ function setMarkupColor(viewer, r = 255, g = 0, b = 0) {
 }
 
 function setSelected(viewer, handles = []) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visLib = viewer.visLib();
     const visViewer = viewer.visViewer();
-    const selectionSet = new visLib.OdTvSelectionSet;
-    handles === null || handles === void 0 ? void 0 : handles.forEach(handle => {
+    const selectionSet = new visLib.OdTvSelectionSet();
+    handles === null || handles === void 0 ? void 0 : handles.forEach((handle) => {
         const entityId = visViewer.getEntityByOriginalHandle(handle + "");
-        if (!entityId.isNull()) selectionSet.appendEntity(entityId);
+        if (!entityId.isNull())
+            selectionSet.appendEntity(entityId);
     });
     visViewer.setSelected(selectionSet);
     viewer.update();
-    viewer.emitEvent({
-        type: "select",
-        data: selectionSet,
-        handles: handles
-    });
+    viewer.emitEvent({ type: "select", data: selectionSet, handles });
     selectionSet.delete();
 }
 
 function showAll(viewer) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     visViewer.unisolateSelectedObjects(false);
     viewer.update();
-    viewer.emitEvent({
-        type: "showall"
-    });
+    viewer.emitEvent({ type: "showall" });
 }
 
 function zoomToExtents(viewer, force = false, animate = viewer.options.cameraAnimation) {
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     const saveEnableAmination = visViewer.getEnableAnimation();
     visViewer.setEnableAnimation(animate);
@@ -2033,57 +2225,55 @@ function zoomToExtents(viewer, force = false, animate = viewer.options.cameraAni
     visViewer.setEnableAnimation(saveEnableAmination);
     viewer.deviceAutoRegeneration();
     viewer.update();
-    viewer.emitEvent({
-        type: "zoom"
-    });
+    viewer.emitEvent({ type: "zoom" });
 }
 
 function zoomToObjects(viewer, handles = []) {
     var _a;
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visLib = viewer.visLib();
     const visViewer = viewer.visViewer();
-    const selectionSet = new visLib.OdTvSelectionSet;
-    handles.forEach(handle => {
+    const selectionSet = new visLib.OdTvSelectionSet();
+    handles.forEach((handle) => {
         const entityId = visViewer.getEntityByOriginalHandle(handle + "");
-        if (!entityId.isNull()) selectionSet.appendEntity(entityId);
+        if (!entityId.isNull())
+            selectionSet.appendEntity(entityId);
     });
     (_a = visViewer.zoomToObjects) === null || _a === void 0 ? void 0 : _a.call(visViewer, selectionSet);
     viewer.deviceAutoRegeneration();
     viewer.update();
-    viewer.emitEvent({
-        type: "zoom"
-    });
+    viewer.emitEvent({ type: "zoom" });
     selectionSet.delete();
 }
 
 function zoomToSelected(viewer) {
     var _a;
-    if (!viewer.visualizeJs) return;
+    if (!viewer.visualizeJs)
+        return;
     const visViewer = viewer.visViewer();
     const selectionSet = visViewer.getSelected();
     (_a = visViewer.zoomToObjects) === null || _a === void 0 ? void 0 : _a.call(visViewer, selectionSet);
     viewer.deviceAutoRegeneration();
     viewer.update();
-    viewer.emitEvent({
-        type: "zoom"
-    });
+    viewer.emitEvent({ type: "zoom" });
 }
 
 function isTemplateModel(modelPtr) {
     return modelPtr.getName()[0] === "$";
 }
-
 async function autoTransformAllModelsToCentralPoint(viewer, model) {
     var _a;
-    if (!viewer.visualizeJs) return;
-    if (!model.getModelTransformMatrix) return;
+    if (!viewer.visualizeJs)
+        return;
+    if (!model.getModelTransformMatrix)
+        return;
     const visLib = viewer.visLib();
     const visViewer = viewer.visViewer();
     const viewExt = visViewer.getActiveExtents();
     const centralPoint = viewExt.center();
     const modelItr = visViewer.getModelIterator();
-    for (;!modelItr.done(); modelItr.step()) {
+    for (; !modelItr.done(); modelItr.step()) {
         const modelPtr = modelItr.getModel();
         if (!isTemplateModel(modelPtr)) {
             const ext = modelPtr.getExtents();
@@ -2091,26 +2281,28 @@ async function autoTransformAllModelsToCentralPoint(viewer, model) {
             ext.transformBy(modelPtr.getUnitsMatrix());
             const unitsMatrixInvert = modelPtr.getUnitsMatrix().invert();
             const center = ext.center();
-            const scale = 1;
-            const scaleMatrix = new visLib.Matrix3d;
-            const translateMatrix = new visLib.Matrix3d;
-            translateMatrix.setTranslation([ centralPoint[0] - center[0], centralPoint[1] - center[1], centralPoint[2] - center[2] ]);
+            const scale = 1.0;
+            const scaleMatrix = new visLib.Matrix3d();
+            const translateMatrix = new visLib.Matrix3d();
+            translateMatrix.setTranslation([
+                centralPoint[0] - center[0],
+                centralPoint[1] - center[1],
+                centralPoint[2] - center[2],
+            ]);
             scaleMatrix.setToScaling(scale, centralPoint);
-            const resMatrixWithUnits = unitsMatrixInvert.postMultBy(scaleMatrix).postMultBy(translateMatrix).postMultBy(unitsMatrix);
+            const resMatrixWithUnits = unitsMatrixInvert
+                .postMultBy(scaleMatrix)
+                .postMultBy(translateMatrix)
+                .postMultBy(unitsMatrix);
             const resScale = resMatrixWithUnits.scale();
             const transform = {
                 translate: {
                     x: resMatrixWithUnits.get(0, 3) - (1 - resScale) * center[0],
                     y: resMatrixWithUnits.get(1, 3) - (1 - resScale) * center[1],
-                    z: resMatrixWithUnits.get(2, 3) - (1 - resScale) * center[2]
+                    z: resMatrixWithUnits.get(2, 3) - (1 - resScale) * center[2],
                 },
-                rotation: {
-                    x: 0,
-                    y: 0,
-                    z: 1,
-                    angle: 0
-                },
-                scale: resScale
+                rotation: { x: 0, y: 0, z: 1, angle: 0.0 },
+                scale: resScale,
             };
             const matrix = composeMatrixFromTransform(transform, center, visLib);
             modelPtr.setModelingMatrix(matrix, true);
@@ -2125,79 +2317,42 @@ async function autoTransformAllModelsToCentralPoint(viewer, model) {
 }
 
 const commands = commandsRegistry("visualizejs");
-
 commands.registerCommand("applyModelTransform", applyModelTransform);
-
 commands.registerCommand("clearMarkup", clearMarkup);
-
 commands.registerCommand("clearSelected", clearSelected);
-
 commands.registerCommand("clearSlices", clearSlices);
-
 commands.registerCommand("createPreview", createPreview);
-
 commands.registerCommand("explode", explode);
-
 commands.registerCommand("collect", collect);
-
 commands.registerCommand("getDefaultViewPositions", getDefaultViewPositions);
-
 commands.registerCommand("getModels", getModels);
-
 commands.registerCommand("getSelected", getSelected);
-
 commands.registerCommand("hideSelected", hideSelected);
-
 commands.registerCommand("isolateSelected", isolateSelected);
-
 commands.registerCommand("regenerateAll", regenerateAll);
-
 commands.registerCommand("resetView", resetView);
-
 commands.registerCommand("selectModel", selectModel);
-
 commands.registerCommand("setActiveDragger", setActiveDragger);
-
 commands.registerCommand("setDefaultViewPosition", setDefaultViewPosition);
-
 commands.registerCommand("setMarkupColor", setMarkupColor);
-
 commands.registerCommand("setSelected", setSelected);
-
 commands.registerCommand("showAll", showAll);
-
 commands.registerCommand("zoomToExtents", zoomToExtents);
-
 commands.registerCommand("zoomToObjects", zoomToObjects);
-
 commands.registerCommand("zoomToSelected", zoomToSelected);
-
 commands.registerCommand("autoTransformAllModelsToCentralPoint", autoTransformAllModelsToCentralPoint);
-
-commands.registerCommand("k3DViewTop", viewer => setDefaultViewPosition(viewer, "k3DViewTop"));
-
-commands.registerCommand("k3DViewBottom", viewer => setDefaultViewPosition(viewer, "k3DViewBottom"));
-
-commands.registerCommand("k3DViewLeft", viewer => setDefaultViewPosition(viewer, "k3DViewLeft"));
-
-commands.registerCommand("k3DViewRight", viewer => setDefaultViewPosition(viewer, "k3DViewRight"));
-
-commands.registerCommand("k3DViewFront", viewer => setDefaultViewPosition(viewer, "k3DViewFront"));
-
-commands.registerCommand("k3DViewBack", viewer => setDefaultViewPosition(viewer, "k3DViewBack"));
-
-commands.registerCommand("k3DViewSE", viewer => setDefaultViewPosition(viewer, "k3DViewSE"));
-
-commands.registerCommand("k3DViewSW", viewer => setDefaultViewPosition(viewer, "k3DViewSW"));
-
-commands.registerCommand("k3DViewNE", viewer => setDefaultViewPosition(viewer, "k3DViewNE"));
-
-commands.registerCommand("k3DViewNW", viewer => setDefaultViewPosition(viewer, "k3DViewNW"));
-
+commands.registerCommand("k3DViewTop", (viewer) => setDefaultViewPosition(viewer, "k3DViewTop"));
+commands.registerCommand("k3DViewBottom", (viewer) => setDefaultViewPosition(viewer, "k3DViewBottom"));
+commands.registerCommand("k3DViewLeft", (viewer) => setDefaultViewPosition(viewer, "k3DViewLeft"));
+commands.registerCommand("k3DViewRight", (viewer) => setDefaultViewPosition(viewer, "k3DViewRight"));
+commands.registerCommand("k3DViewFront", (viewer) => setDefaultViewPosition(viewer, "k3DViewFront"));
+commands.registerCommand("k3DViewBack", (viewer) => setDefaultViewPosition(viewer, "k3DViewBack"));
+commands.registerCommand("k3DViewSE", (viewer) => setDefaultViewPosition(viewer, "k3DViewSE"));
+commands.registerCommand("k3DViewSW", (viewer) => setDefaultViewPosition(viewer, "k3DViewSW"));
+commands.registerCommand("k3DViewNE", (viewer) => setDefaultViewPosition(viewer, "k3DViewNE"));
+commands.registerCommand("k3DViewNW", (viewer) => setDefaultViewPosition(viewer, "k3DViewNW"));
 commands.registerCommandAlias("clearMarkup", "clearOverlay");
-
 commands.registerCommandAlias("clearSelected", "unselect");
-
 commands.registerCommandAlias("zoomToExtents", "zoomExtents");
 
 class RenderLoopComponent {
@@ -2205,10 +2360,7 @@ class RenderLoopComponent {
         this.animate = (time = 0) => {
             this.requestId = requestAnimationFrame(this.animate);
             this.viewer.render(time);
-            this.viewer.emitEvent({
-                type: "animate",
-                time: time
-            });
+            this.viewer.emitEvent({ type: "animate", time });
         };
         this.viewer = viewer;
         this.animate();
@@ -2220,9 +2372,10 @@ class RenderLoopComponent {
 
 class ResizeCanvasComponent {
     constructor(viewer) {
-        this.resizeViewer = entries => {
-            const {width: width, height: height} = entries[0].contentRect;
-            if (!width || !height) return;
+        this.resizeViewer = (entries) => {
+            const { width, height } = entries[0].contentRect;
+            if (!width || !height)
+                return;
             this.viewer.setSize(width, height);
         };
         this.viewer = viewer;
@@ -2248,14 +2401,12 @@ class ZoomWheelComponent {
 }
 
 var GestureAction;
-
-(function(GestureAction) {
+(function (GestureAction) {
     GestureAction[GestureAction["None"] = 0] = "None";
     GestureAction[GestureAction["Orbit"] = 1] = "Orbit";
     GestureAction[GestureAction["Pan"] = 2] = "Pan";
     GestureAction[GestureAction["Zoom"] = 3] = "Zoom";
 })(GestureAction || (GestureAction = {}));
-
 class GestureManager extends OdBaseDragger {
     get isSingleTouchEnabled() {
         return this._isSingleTouchEnabled;
@@ -2265,8 +2416,8 @@ class GestureManager extends OdBaseDragger {
     }
     constructor(subject) {
         super(subject);
-        this._previousEvents = new Map;
-        this._currentEvents = new Map;
+        this._previousEvents = new Map();
+        this._currentEvents = new Map();
         this._lastGestureAction = GestureAction.None;
         this._maxInitialDistanceDifference = 30 * window.devicePixelRatio;
         this._isSingleTouchEnabled = false;
@@ -2283,7 +2434,7 @@ class GestureManager extends OdBaseDragger {
         const point1 = this.relativeCoords(events.get(keys[1]));
         return {
             x: Math.floor((point0.x + point1.x) / 2),
-            y: Math.floor((point0.y + point1.y) / 2)
+            y: Math.floor((point0.y + point1.y) / 2),
         };
     }
     getFirstPoint(events) {
@@ -2333,12 +2484,14 @@ class GestureManager extends OdBaseDragger {
             const currentDistanceEqualsInitialDistance = Math.abs(this._initialDistance - currentDistance) <= this._maxInitialDistanceDifference;
             if (currentDistanceEqualsInitialDistance) {
                 this.executePanAction(this.getMiddlePoint(this._currentEvents));
-            } else {
+            }
+            else {
                 if (previousDistance !== -1 && currentDistance !== previousDistance) {
                     this.executeZoomAction(currentDistance, previousDistance);
                 }
             }
-        } else if (this._currentEvents.size === 1 && this.isSingleTouchEnabled) {
+        }
+        else if (this._currentEvents.size === 1 && this.isSingleTouchEnabled) {
             this.executeOrbitAction(this.getFirstPoint(this._currentEvents));
         }
     }
@@ -2375,12 +2528,14 @@ class GestureManager extends OdBaseDragger {
         this.subject.update();
     }
     executeEndAction(gestureAction) {
-        if (gestureAction === GestureAction.Orbit) this._orbitAction.endAction();
-        if (gestureAction === GestureAction.Pan) this._panAction.endAction();
+        if (gestureAction === GestureAction.Orbit)
+            this._orbitAction.endAction();
+        if (gestureAction === GestureAction.Pan)
+            this._panAction.endAction();
         OdBaseDragger.isGestureActive = false;
     }
     needIgnoreEvent(event) {
-        return !this.subject.options.enableZoomWheel || !this.subject.options.enableGestures || !this.eventIsTouchEvent(event);
+        return (!this.subject.options.enableZoomWheel || !this.subject.options.enableGestures || !this.eventIsTouchEvent(event));
     }
     eventIsTouchEvent(event) {
         return event.pointerType === "touch" || event.pointerType === "";
@@ -2436,14 +2591,10 @@ class GestureManagerComponent {
 }
 
 const components = componentsRegistry("visualizejs");
-
-components.registerComponent("ResizeCanvasComponent", viewer => new ResizeCanvasComponent(viewer));
-
-components.registerComponent("RenderLoopComponent", viewer => new RenderLoopComponent(viewer));
-
-components.registerComponent("ZoomWheelComponent", viewer => new ZoomWheelComponent(viewer));
-
-components.registerComponent("GestureManagerComponent", viewer => new GestureManagerComponent(viewer));
+components.registerComponent("ResizeCanvasComponent", (viewer) => new ResizeCanvasComponent(viewer));
+components.registerComponent("RenderLoopComponent", (viewer) => new RenderLoopComponent(viewer));
+components.registerComponent("ZoomWheelComponent", (viewer) => new ZoomWheelComponent(viewer));
+components.registerComponent("GestureManagerComponent", (viewer) => new GestureManagerComponent(viewer));
 
 class FileLoader {
     constructor() {
@@ -2465,10 +2616,12 @@ class FileLoader {
             const request = new Request(file, {
                 headers: new Headers(this.requestHeader),
                 credentials: this.withCredentials ? "include" : "same-origin",
-                signal: this.abortSignal
+                signal: this.abortSignal,
             });
-            return fetch(request).then(response => {
-                if (!response.ok) throw new Error(`Failed to fetch "${response.url}", status ${response.status}`);
+            return fetch(request)
+                .then((response) => {
+                if (!response.ok)
+                    throw new Error(`Failed to fetch "${response.url}", status ${response.status}`);
                 const contentLength = response.headers.get("X-File-Size") || response.headers.get("Content-Length");
                 const total = parseInt(contentLength || "", 10) || 0;
                 const lengthComputable = total > 0;
@@ -2478,45 +2631,40 @@ class FileLoader {
                         let loaded = 0;
                         try {
                             while (true) {
-                                const {done: done, value: value} = await reader.read();
-                                if (done) break;
+                                const { done, value } = await reader.read();
+                                if (done)
+                                    break;
                                 if (onProgress) {
                                     loaded += value.byteLength;
-                                    onProgress(new ProgressEvent("progress", {
-                                        lengthComputable: lengthComputable,
-                                        loaded: loaded,
-                                        total: total
-                                    }));
+                                    onProgress(new ProgressEvent("progress", { lengthComputable, loaded, total }));
                                 }
                                 controller.enqueue(value);
                             }
                             controller.close();
-                        } catch (e) {
+                        }
+                        catch (e) {
                             controller.error(e);
                         }
-                    }
+                    },
                 });
                 return new Response(stream);
-            }).then(response => response.arrayBuffer());
+            })
+                .then((response) => response.arrayBuffer());
         }
         if (file instanceof globalThis.File) {
             return new Promise((resolve, reject) => {
-                const reader = new FileReader;
+                const reader = new FileReader();
                 reader.onload = () => resolve(reader.result);
                 reader.onerror = () => reject(reader.error);
                 reader.onprogress = onProgress;
-                reader.readAsArrayBuffer(new Blob([ file ]));
+                reader.readAsArrayBuffer(new Blob([file]));
             });
         }
         if (onProgress) {
             const total = file.byteLength;
             const lengthComputable = total > 0;
             const loaded = total;
-            onProgress(new ProgressEvent("progress", {
-                lengthComputable: lengthComputable,
-                loaded: loaded,
-                total: total
-            }));
+            onProgress(new ProgressEvent("progress", { lengthComputable, loaded, total }));
         }
         return Promise.resolve(file);
     }
@@ -2528,41 +2676,37 @@ class VSFFileLoader extends Loader {
         this.viewer = viewer;
     }
     isSupport(file, format) {
-        return (typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) && /vsf$/i.test(format);
+        return ((typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) &&
+            /vsf$/i.test(format));
     }
     async load(file, format, params) {
-        if (!this.viewer.visualizeJs) return this;
+        if (!this.viewer.visualizeJs)
+            return this;
         const visViewer = this.viewer.visViewer();
-        const progress = event => {
-            const {lengthComputable: lengthComputable, loaded: loaded, total: total} = event;
+        const progress = (event) => {
+            const { lengthComputable, loaded, total } = event;
             const progress = lengthComputable ? loaded / total : 1;
-            this.viewer.emitEvent({
-                type: "geometryprogress",
-                data: progress,
-                file: file
-            });
+            this.viewer.emitEvent({ type: "geometryprogress", data: progress, file });
         };
-        const loader = new FileLoader;
+        const loader = new FileLoader();
         loader.setRequestHeader(params.requestHeader);
         loader.setWithCredentials(params.withCredentials);
         loader.setAbortSignal(this.abortController.signal);
         const arrayBuffer = await loader.load(file, progress);
         const data = new Uint8Array(arrayBuffer);
-        if (!this.viewer.visualizeJs) return this;
+        if (!this.viewer.visualizeJs)
+            return this;
         try {
             visViewer.parseFile(data);
-        } catch (error) {
+        }
+        catch (error) {
             console.error("VSF parse error.", error);
             throw error;
         }
         this.viewer.syncOptions();
         this.viewer.syncOverlay();
         this.viewer.update(true);
-        this.viewer.emitEvent({
-            type: "databasechunk",
-            data: data,
-            file: file
-        });
+        this.viewer.emitEvent({ type: "databasechunk", data, file });
         return this;
     }
 }
@@ -2573,30 +2717,31 @@ class VSFCloudLoader extends Loader {
         this.viewer = viewer;
     }
     isSupport(file, format) {
-        return typeof file === "object" && typeof file.database === "string" && typeof file.downloadResource === "function" && /.data$/i.test(file.database);
+        return (typeof file === "object" &&
+            typeof file.database === "string" &&
+            typeof file.downloadResource === "function" &&
+            /.data$/i.test(file.database));
     }
     async load(model, format) {
-        if (!this.viewer.visualizeJs) return this;
+        if (!this.viewer.visualizeJs)
+            return this;
         const visViewer = this.viewer.visViewer();
-        const filesToDownload = [ model.database, ...model.geometry ];
+        const filesToDownload = [model.database, ...model.geometry];
         console.time("File load time");
         for (let i = 0; i < filesToDownload.length; i++) {
             const dataId = filesToDownload[i];
-            const progress = progress => {
+            const progress = (progress) => {
                 const data = (i + progress) / filesToDownload.length;
-                this.viewer.emitEvent({
-                    type: "geometryprogress",
-                    data: data,
-                    file: model.file,
-                    model: model
-                });
+                this.viewer.emitEvent({ type: "geometryprogress", data, file: model.file, model });
             };
             const arrayBuffer = await model.downloadResource(dataId, progress, this.abortController.signal);
             const data = new Uint8Array(arrayBuffer);
-            if (!this.viewer.visualizeJs) return this;
+            if (!this.viewer.visualizeJs)
+                return this;
             try {
                 visViewer.parseStream(data);
-            } catch (error) {
+            }
+            catch (error) {
                 console.error("VSF parse error.", error);
                 throw error;
             }
@@ -2604,20 +2749,11 @@ class VSFCloudLoader extends Loader {
                 this.viewer.syncOptions();
                 this.viewer.syncOverlay();
                 this.viewer.update(true);
-                this.viewer.emitEvent({
-                    type: "databasechunk",
-                    data: data,
-                    file: model.file,
-                    model: model
-                });
-            } else {
+                this.viewer.emitEvent({ type: "databasechunk", data, file: model.file, model });
+            }
+            else {
                 this.viewer.update();
-                this.viewer.emitEvent({
-                    type: "geometrychunk",
-                    data: data,
-                    file: model.file,
-                    model: model
-                });
+                this.viewer.emitEvent({ type: "geometrychunk", data, file: model.file, model });
             }
         }
         console.timeEnd("File load time");
@@ -2631,41 +2767,37 @@ class VSFXFileLoader extends Loader {
         this.viewer = viewer;
     }
     isSupport(file, format) {
-        return (typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) && /vsfx$/i.test(format);
+        return ((typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) &&
+            /vsfx$/i.test(format));
     }
     async load(file, format, params) {
-        if (!this.viewer.visualizeJs) return this;
+        if (!this.viewer.visualizeJs)
+            return this;
         const visViewer = this.viewer.visViewer();
-        const progress = event => {
-            const {lengthComputable: lengthComputable, loaded: loaded, total: total} = event;
+        const progress = (event) => {
+            const { lengthComputable, loaded, total } = event;
             const progress = lengthComputable ? loaded / total : 1;
-            this.viewer.emitEvent({
-                type: "geometryprogress",
-                data: progress,
-                file: file
-            });
+            this.viewer.emitEvent({ type: "geometryprogress", data: progress, file });
         };
-        const loader = new FileLoader;
+        const loader = new FileLoader();
         loader.setRequestHeader(params.requestHeader);
         loader.setWithCredentials(params.withCredentials);
         loader.setAbortSignal(this.abortController.signal);
         const arrayBuffer = await loader.load(file, progress);
         const data = new Uint8Array(arrayBuffer);
-        if (!this.viewer.visualizeJs) return this;
+        if (!this.viewer.visualizeJs)
+            return this;
         try {
             visViewer.parseVsfx(data);
-        } catch (error) {
+        }
+        catch (error) {
             console.error("VSFX parse error.", error);
             throw error;
         }
         this.viewer.syncOptions();
         this.viewer.syncOverlay();
         this.viewer.update(true);
-        this.viewer.emitEvent({
-            type: "databasechunk",
-            data: data,
-            file: file
-        });
+        this.viewer.emitEvent({ type: "databasechunk", data, file });
         return this;
     }
 }
@@ -2676,55 +2808,48 @@ class VSFXCloudLoader extends Loader {
         this.viewer = viewer;
     }
     isSupport(file) {
-        return typeof file === "object" && typeof file.database === "string" && typeof file.downloadResource === "function" && /.vsfx$/i.test(file.database) && this.viewer.options.enableStreamingMode === false;
+        return (typeof file === "object" &&
+            typeof file.database === "string" &&
+            typeof file.downloadResource === "function" &&
+            /.vsfx$/i.test(file.database) &&
+            this.viewer.options.enableStreamingMode === false);
     }
     async load(model, format, params = {}) {
-        if (!this.viewer.visualizeJs) return Promise.resolve(this);
+        if (!this.viewer.visualizeJs)
+            return Promise.resolve(this);
         const visViewer = this.viewer.visViewer();
-        const progress = progress => {
-            this.viewer.emitEvent({
-                type: "geometryprogress",
-                data: progress,
-                file: model.file,
-                model: model
-            });
+        const progress = (progress) => {
+            this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model.file, model });
         };
         console.time("File load time");
         const arrayBuffer = await model.downloadResource(model.database, progress, this.abortController.signal);
         const data = new Uint8Array(arrayBuffer);
-        if (!this.viewer.visualizeJs) return this;
+        if (!this.viewer.visualizeJs)
+            return this;
         try {
             visViewer.parseVsfx(data);
-        } catch (error) {
+        }
+        catch (error) {
             console.error("VSFX parse error.", error);
             throw error;
         }
         this.viewer.syncOptions();
         this.viewer.syncOverlay();
         this.viewer.update(true);
-        this.viewer.emitEvent({
-            type: "databasechunk",
-            data: data,
-            file: model.file,
-            model: model
-        });
+        this.viewer.emitEvent({ type: "databasechunk", data, file: model.file, model });
         console.timeEnd("File load time");
         return this;
     }
 }
 
-const DELAY_TIME_MULTIPLEXER = 2;
-
-const START_UPDATE_TIME = 1e3;
-
+const DELAY_TIME_MULTIPLEXER = 2.0;
+const START_UPDATE_TIME = 1000;
 var UpdateType;
-
-(function(UpdateType) {
+(function (UpdateType) {
     UpdateType[UpdateType["kDelay"] = 0] = "kDelay";
     UpdateType[UpdateType["kNormal"] = 1] = "kNormal";
     UpdateType[UpdateType["kForce"] = 2] = "kForce";
 })(UpdateType || (UpdateType = {}));
-
 class UpdateController {
     constructor() {
         this.lastUpdate = 0;
@@ -2751,32 +2876,37 @@ class VSFXCloudStreamingLoader extends Loader {
         this.viewer = viewer;
     }
     isSupport(file) {
-        return typeof file === "object" && typeof file.database === "string" && typeof file.downloadResource === "function" && /.vsfx$/i.test(file.database) && this.viewer.options.enableStreamingMode === true && this.viewer.options.enablePartialMode === false && !/.rcs$/i.test(file.name);
+        return (typeof file === "object" &&
+            typeof file.database === "string" &&
+            typeof file.downloadResource === "function" &&
+            /.vsfx$/i.test(file.database) &&
+            this.viewer.options.enableStreamingMode === true &&
+            this.viewer.options.enablePartialMode === false &&
+            !/.rcs$/i.test(file.name));
     }
     async load(model) {
-        if (!this.viewer.visualizeJs) return this;
+        if (!this.viewer.visualizeJs)
+            return this;
         const visLib = this.viewer.visLib();
         const visViewer = this.viewer.visViewer();
-        const updateController = new UpdateController;
+        const updateController = new UpdateController();
         updateController.initialize(this.viewer);
         let isFireDatabaseChunk = false;
         const chunkLoadHandler = (progress, chunk) => {
-            if (!this.viewer.visualizeJs) return;
+            if (!this.viewer.visualizeJs)
+                return;
             let status;
             try {
                 status = visViewer.parseVsfx(chunk);
-            } catch (error) {
+            }
+            catch (error) {
                 console.error("VSFX parse error.", error);
                 throw error;
             }
-            this.viewer.emitEvent({
-                type: "geometryprogress",
-                data: progress,
-                file: model.file,
-                model: model
-            });
+            this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model.file, model });
             let isDatabaseChunk = false;
-            if (status === visLib.DatabaseStreamStatus.ReadyServiceData || status === visLib.DatabaseStreamStatus.Complete && !isFireDatabaseChunk) {
+            if (status === visLib.DatabaseStreamStatus.ReadyServiceData ||
+                (status === visLib.DatabaseStreamStatus.Complete && !isFireDatabaseChunk)) {
                 isFireDatabaseChunk = true;
                 isDatabaseChunk = true;
             }
@@ -2784,20 +2914,11 @@ class VSFXCloudStreamingLoader extends Loader {
                 this.viewer.syncOptions();
                 this.viewer.syncOverlay();
                 updateController.update(UpdateType.kForce);
-                this.viewer.emitEvent({
-                    type: "databasechunk",
-                    data: chunk,
-                    file: model.file,
-                    model: model
-                });
-            } else {
+                this.viewer.emitEvent({ type: "databasechunk", data: chunk, file: model.file, model });
+            }
+            else {
                 updateController.update(UpdateType.kDelay);
-                this.viewer.emitEvent({
-                    type: "geometrychunk",
-                    data: chunk,
-                    file: model.file,
-                    model: model
-                });
+                this.viewer.emitEvent({ type: "geometrychunk", data: chunk, file: model.file, model });
             }
         };
         console.time("File load time");
@@ -2809,79 +2930,68 @@ class VSFXCloudStreamingLoader extends Loader {
 }
 
 const PENDING_REQUESTS_SIZE = 50;
-
 const PENDING_REQUESTS_TIMEOUT = 250;
-
 class VSFXCloudPartialLoader extends Loader {
     constructor(viewer) {
         super();
         this.viewer = viewer;
-        this.abortControllerForRequestMap = new Map;
+        this.abortControllerForRequestMap = new Map();
     }
     isSupport(file) {
-        return typeof file === "object" && typeof file.database === "string" && typeof file.downloadResource === "function" && typeof file.downloadResourceRange === "function" && /.vsfx$/i.test(file.database) && (this.viewer.options.enablePartialMode === true || /.rcs$/i.test(file.name));
+        return (typeof file === "object" &&
+            typeof file.database === "string" &&
+            typeof file.downloadResource === "function" &&
+            typeof file.downloadResourceRange === "function" &&
+            /.vsfx$/i.test(file.database) &&
+            (this.viewer.options.enablePartialMode === true || /.rcs$/i.test(file.name)));
     }
     async load(model, format) {
-        if (!this.viewer.visualizeJs) return this;
+        if (!this.viewer.visualizeJs)
+            return this;
         const visViewer = this.viewer.visViewer();
         let servicePartAborted = false;
-        const pendingRequestsMap = new Map;
+        const pendingRequestsMap = new Map();
         let pendingRequestsTimerId = 0;
         const pendingRequestsAbortHandler = () => clearTimeout(pendingRequestsTimerId);
-        const pendingRequestsAbortController = new AbortController;
+        const pendingRequestsAbortController = new AbortController();
         this.abortControllerForRequestMap.set(0, pendingRequestsAbortController);
-        const updateController = new UpdateController;
+        const updateController = new UpdateController();
         updateController.initialize(this.viewer);
         visViewer.memoryLimit = this.viewer.options.memoryLimit;
         const chunkLoadHandler = (progress, chunk, requestId = 0) => {
-            if (!this.viewer.visualizeJs) return;
+            if (!this.viewer.visualizeJs)
+                return;
             let isDatabaseChunk;
             try {
                 isDatabaseChunk = visViewer.parseVsfxInPartialMode(requestId, chunk);
-            } catch (error) {
+            }
+            catch (error) {
                 console.error("VSFX parse error.", error);
                 throw error;
             }
-            this.viewer.emitEvent({
-                type: "geometryprogress",
-                data: progress,
-                file: model.file,
-                model: model
-            });
+            this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model.file, model });
             if (isDatabaseChunk) {
                 this.viewer.syncOptions();
                 this.viewer.syncOverlay();
                 updateController.update(UpdateType.kForce);
-                this.viewer.emitEvent({
-                    type: "databasechunk",
-                    data: chunk,
-                    file: model.file,
-                    model: model
-                });
-            } else {
+                this.viewer.emitEvent({ type: "databasechunk", data: chunk, file: model.file, model });
+            }
+            else {
                 updateController.update(UpdateType.kDelay);
-                this.viewer.emitEvent({
-                    type: "geometrychunk",
-                    data: chunk,
-                    file: model.file,
-                    model: model
-                });
+                this.viewer.emitEvent({ type: "geometrychunk", data: chunk, file: model.file, model });
             }
         };
         const downloadResourceRange = async (dataId, requestId, ranges) => {
-            const abortCtrl = new AbortController;
+            const abortCtrl = new AbortController();
             this.abortControllerForRequestMap.set(requestId, abortCtrl);
             try {
                 await model.downloadResourceRange(dataId, requestId, ranges, chunkLoadHandler, abortCtrl.signal);
-            } catch (error) {
-                this.viewer.emitEvent({
-                    type: "geometryerror",
-                    data: error,
-                    file: model.file,
-                    model: model
-                });
-            } finally {
-                ranges.forEach(range => visViewer.onRequestResponseComplete(range.requestId));
+            }
+            catch (error) {
+                this.viewer.emitEvent({ type: "geometryerror", data: error, file: model.file, model });
+            }
+            finally {
+                ranges.forEach((range) => visViewer.onRequestResponseComplete(range.requestId));
                 this.abortControllerForRequestMap.delete(requestId);
                 updateController.update(UpdateType.kNormal);
             }
@@ -2891,16 +3001,16 @@ class VSFXCloudPartialLoader extends Loader {
             for (let i = 0; i < records.size(); i++) {
                 const record = records.get(i);
                 ranges.push({
-                    requestId: requestId,
+                    requestId,
                     begin: Number(record.begin),
-                    end: Number(record.end) - 1
+                    end: Number(record.end) - 1,
                 });
                 record.delete();
             }
             return ranges;
         };
         const objectHandler = {
-            onServicePartReceived: bHasIndex => {
+            onServicePartReceived: (bHasIndex) => {
                 if (bHasIndex) {
                     servicePartAborted = true;
                     this.abortController.abort();
@@ -2913,13 +3023,14 @@ class VSFXCloudPartialLoader extends Loader {
             onFullLoaded: () => {
                 updateController.update(UpdateType.kNormal);
             },
-            onRequestResponseParsed: requestId => {
+            onRequestResponseParsed: (requestId) => {
                 this.abortControllerForRequestMap.delete(requestId);
                 updateController.update(UpdateType.kNormal);
             },
-            onRequestAborted: requestId => {
+            onRequestAborted: (requestId) => {
                 const abortCtrl = this.abortControllerForRequestMap.get(requestId);
-                if (abortCtrl) abortCtrl.abort();
+                if (abortCtrl)
+                    abortCtrl.abort();
             },
             onRequestResourceFile: (requestId, _, records) => {
                 const dataId = `${model.fileId}${model.file.type}`;
@@ -2932,10 +3043,7 @@ class VSFXCloudPartialLoader extends Loader {
                     requestNumber = pendingRequest.number;
                 }
                 if (requestNumber <= 5) {
-                    pendingRequestsMap.set(dataId, {
-                        ranges: [],
-                        number: requestNumber + 1
-                    });
+                    pendingRequestsMap.set(dataId, { ranges: [], number: requestNumber + 1 });
                     downloadResourceRange(dataId, requestId, ranges);
                     return;
                 }
@@ -2945,65 +3053,50 @@ class VSFXCloudPartialLoader extends Loader {
                         window.clearTimeout(pendingRequestsTimerId);
                         pendingRequestsTimerId = 0;
                     }
-                    pendingRequestsMap.set(dataId, {
-                        ranges: [],
-                        number: requestNumber + 1
-                    });
+                    pendingRequestsMap.set(dataId, { ranges: [], number: requestNumber + 1 });
                     downloadResourceRange(dataId, requestId, pendingRanges);
                     return;
                 }
-                pendingRequestsMap.set(dataId, {
-                    ranges: pendingRanges,
-                    number: requestNumber + 1
-                });
+                pendingRequestsMap.set(dataId, { ranges: pendingRanges, number: requestNumber + 1 });
                 if (pendingRequestsTimerId === 0) {
                     pendingRequestsTimerId = window.setTimeout(() => {
                         pendingRequestsAbortController.signal.removeEventListener("abort", pendingRequestsAbortHandler);
                         pendingRequestsTimerId = 0;
                         pendingRequestsMap.forEach((request, dataId) => {
                             if (request.ranges.length > 0) {
-                                pendingRequestsMap.set(dataId, {
-                                    ranges: [],
-                                    number: request.number + 1
-                                });
+                                pendingRequestsMap.set(dataId, { ranges: [], number: request.number + 1 });
                                 downloadResourceRange(dataId, requestId, request.ranges);
                             }
                         });
                     }, PENDING_REQUESTS_TIMEOUT);
-                    pendingRequestsAbortController.signal.addEventListener("abort", pendingRequestsAbortHandler, {
-                        once: true
-                    });
+                    pendingRequestsAbortController.signal.addEventListener("abort", pendingRequestsAbortHandler, { once: true });
                 }
-            }
+            },
         };
         visViewer.attachPartialResolver(objectHandler);
         try {
             await model.downloadResource(model.database, chunkLoadHandler, this.abortController.signal);
-        } catch (error) {
+        }
+        catch (error) {
             window.clearTimeout(pendingRequestsTimerId);
-            if (!servicePartAborted) throw error;
+            if (!servicePartAborted)
+                throw error;
         }
         return this;
     }
     cancel() {
         super.cancel();
-        this.abortControllerForRequestMap.forEach(controller => controller.abort());
+        this.abortControllerForRequestMap.forEach((controller) => controller.abort());
     }
 }
 
 const loaders = loadersRegistry("visualizejs");
-
-loaders.registerLoader("vsf-file", viewer => new VSFFileLoader(viewer));
-
-loaders.registerLoader("vsf-cloud", viewer => new VSFCloudLoader(viewer));
-
-loaders.registerLoader("vsfx-file", viewer => new VSFXFileLoader(viewer));
-
-loaders.registerLoader("vsfx-cloud", viewer => new VSFXCloudLoader(viewer));
-
-loaders.registerLoader("vsfx-cloud-streaming", viewer => new VSFXCloudStreamingLoader(viewer));
-
-loaders.registerLoader("vsfx-cloud-partial", viewer => new VSFXCloudPartialLoader(viewer));
+loaders.registerLoader("vsf-file", (viewer) => new VSFFileLoader(viewer));
+loaders.registerLoader("vsf-cloud", (viewer) => new VSFCloudLoader(viewer));
+loaders.registerLoader("vsfx-file", (viewer) => new VSFXFileLoader(viewer));
+loaders.registerLoader("vsfx-cloud", (viewer) => new VSFXCloudLoader(viewer));
+loaders.registerLoader("vsfx-cloud-streaming", (viewer) => new VSFXCloudStreamingLoader(viewer));
+loaders.registerLoader("vsfx-cloud-partial", (viewer) => new VSFXCloudPartialLoader(viewer));
 
 function loadScript(url, params = {}) {
     return new Promise((resolve, reject) => {
@@ -3019,26 +3112,25 @@ function loadScript(url, params = {}) {
         document.body.appendChild(script);
     });
 }
-
 function loadVisuazlizeJsScript(url, params) {
     if (window["getVisualizeLibInst"]) {
         const script = window["getVisualizeLibInst"].script;
         if (script) {
-            if (script.src === url) return Promise.resolve(script);
+            if (script.src === url)
+                return Promise.resolve(script);
             script.remove();
         }
         delete window["getVisualizeLibInst"];
     }
     return loadScript(url, params);
 }
-
 const loadVisualizeJs = async (url, onprogress, params = {}) => {
     const script = await loadVisuazlizeJsScript(url, params);
     return await new Promise((resolve, reject) => {
         const options = {
             urlMemFile: url + ".wasm",
             TOTAL_MEMORY: 134217728,
-            onprogress: onprogress
+            onprogress,
         };
         const instance = window["getVisualizeLibInst"](options);
         instance.loadWasmError = reject;
@@ -3050,7 +3142,6 @@ const loadVisualizeJs = async (url, onprogress, params = {}) => {
 };
 
 const MARKUP_ENTITY_LINE = "$MarkupTempEntity_Line";
-
 class OdaLineDragger extends OdBaseDragger {
     constructor(subject) {
         super(subject);
@@ -3064,7 +3155,7 @@ class OdaLineDragger extends OdBaseDragger {
     }
     start(x, y) {
         const point = this.getViewer().screenToWorld(x, y);
-        this.drawPoints = [ point[0], point[1], point[2] ];
+        this.drawPoints = [point[0], point[1], point[2]];
     }
     drag(x, y) {
         if (this.isDragging) {
@@ -3095,7 +3186,6 @@ class OdaLineDragger extends OdBaseDragger {
 }
 
 const MARKUP_ENTITY_TEXT = "$MarkupTempEntity_Text";
-
 class OdaTextDragger extends OdBaseDragger {
     constructor(subject) {
         super(subject);
@@ -3124,7 +3214,7 @@ class OdaTextDragger extends OdBaseDragger {
             this.textRef.style.display = "block";
             this.textRef.style.top = absoluteY + "px";
             this.textRef.style.left = absoluteX + "px";
-            this.textRef.onkeypress = event => {
+            this.textRef.onkeypress = (event) => {
                 if (event.key === "Enter") {
                     event.preventDefault();
                     this._finishInput();
@@ -3134,7 +3224,8 @@ class OdaTextDragger extends OdBaseDragger {
             this.press = true;
             this.m_center = this.screenToWorld(x, y + this.TEXT_HEIGHT_ALIGN);
             this.needInputText = true;
-        } else {
+        }
+        else {
             this._finishInput();
         }
     }
@@ -3146,17 +3237,17 @@ class OdaTextDragger extends OdBaseDragger {
         const target = this.toPoint(view.viewTarget);
         const eyeToWorld = view.eyeToWorldMatrix;
         const eyeDir = pos.sub(target).asVector();
-        const xDir = this.toVector([ 1, 0, 0 ]);
+        const xDir = this.toVector([1.0, 0.0, 0.0]);
         const direction = xDir.transformBy(eyeToWorld);
         const mtrx = this.createMatrix3d();
         mtrx.setToWorldToPlane(this.toGeVector(eyeDir));
         direction.transformBy(mtrx);
         const angel = -Math.atan2(-direction.y, direction.x);
-        const textSize = .02;
-        let textScale = 1;
+        const textSize = 0.02;
+        let textScale = 1.0;
         const projMtrx = view.projectionMatrix;
         const mtrxNumber = projMtrx.get(1, 1);
-        const tol = 1e-6;
+        const tol = 1.0e-6;
         if (!(mtrxNumber < tol && mtrxNumber > -tol)) {
             textScale = 1 / mtrxNumber;
         }
@@ -3173,11 +3264,7 @@ class OdaTextDragger extends OdBaseDragger {
 
 class VisualizeMarkup {
     constructor() {
-        this._markupColor = {
-            r: 255,
-            g: 0,
-            b: 0
-        };
+        this._markupColor = { r: 255, g: 0, b: 0 };
         this.lineWidth = 4;
         this.fontSize = 34;
     }
@@ -3186,10 +3273,11 @@ class VisualizeMarkup {
         this._viewer.registerDragger("Line", OdaLineDragger);
         this._viewer.registerDragger("Text", OdaTextDragger);
     }
-    dispose() {}
-    syncOverlay() {}
+    dispose() { }
+    syncOverlay() { }
     clearOverlay() {
-        if (!this._viewer.visualizeJs) return;
+        if (!this._viewer.visualizeJs)
+            return;
         const visViewer = this._viewer.visViewer();
         const model = visViewer.getMarkupModel();
         model.clearEntities();
@@ -3199,23 +3287,17 @@ class VisualizeMarkup {
         return this._markupColor;
     }
     setMarkupColor(r, g, b) {
-        const color = {
-            r: r,
-            g: g,
-            b: b
-        };
+        const color = { r, g, b };
         this._markupColor = color;
-        this._viewer.emitEvent({
-            type: "changemarkupcolor",
-            data: color
-        });
+        this._viewer.emitEvent({ type: "changemarkupcolor", data: color });
     }
     colorizeAllMarkup(r = 255, g = 0, b = 0) {
-        if (!this._viewer.visualizeJs) return;
+        if (!this._viewer.visualizeJs)
+            return;
         const visViewer = this._viewer.visViewer();
         const model = visViewer.getMarkupModel();
         const itr = model.getEntitiesIterator();
-        for (;!itr.done(); itr.step()) {
+        for (; !itr.done(); itr.step()) {
             const entityId = itr.getEntity();
             const entityPtr = entityId.openObject();
             const entityName = entityPtr.getName();
@@ -3232,21 +3314,18 @@ class VisualizeMarkup {
     }
     setViewpoint(viewpoint) {
         function getLogicalPoint3dAsArray(point3d) {
-            return [ point3d.x, point3d.y, point3d.z ];
+            return [point3d.x, point3d.y, point3d.z];
         }
         function getPoint3d(module, gePoint) {
             return module.Point3d.createFromArray(gePoint);
         }
-        if (!this._viewer.visualizeJs) return;
+        if (!this._viewer.visualizeJs)
+            return;
         const visLib = this._viewer.visLib();
         const visViewer = this._viewer.visViewer();
         const activeView = visViewer.activeView;
         this._viewer.syncOverlay();
-        const markupColor = viewpoint.custom_fields.markup_color || {
-            r: 255,
-            g: 0,
-            b: 0
-        };
+        const markupColor = viewpoint.custom_fields.markup_color || { r: 255, g: 0, b: 0 };
         this.setMarkupColor(markupColor.r, markupColor.g, markupColor.b);
         if (viewpoint.lines) {
             for (const line of viewpoint.lines) {
@@ -3281,22 +3360,20 @@ class VisualizeMarkup {
         this._viewer.update();
     }
     getViewpoint(viewpoint) {
-        if (!this._viewer.visualizeJs) return {};
+        if (!this._viewer.visualizeJs)
+            return {};
         function getLogicalPoint3dFromArray(array) {
-            return {
-                x: array[0],
-                y: array[1],
-                z: array[2]
-            };
+            return { x: array[0], y: array[1], z: array[2] };
         }
         const visLib = this._viewer.visLib();
         const visViewer = this._viewer.visViewer();
-        if (!viewpoint) viewpoint = {};
+        if (!viewpoint)
+            viewpoint = {};
         viewpoint.lines = [];
         viewpoint.texts = [];
         const model = visViewer.getMarkupModel();
         const itr = model.getEntitiesIterator();
-        for (;!itr.done(); itr.step()) {
+        for (; !itr.done(); itr.step()) {
             const entityId = itr.getEntity();
             const entityPtr = entityId.openObject();
             const entityName = entityPtr.getName();
@@ -3310,21 +3387,22 @@ class VisualizeMarkup {
                 const polylinePtr = geometryId.openAsPolyline();
                 const points = polylinePtr.getPoints();
                 const line = {
-                    points: []
+                    points: [],
                 };
                 for (const point of points) {
                     line.points.push(getLogicalPoint3dFromArray(point));
                 }
                 viewpoint.lines.push(line);
                 polylinePtr.delete();
-            } else if (entityName === MARKUP_ENTITY_TEXT) {
+            }
+            else if (entityName === MARKUP_ENTITY_TEXT) {
                 const textPtr = geometryId.openAsText();
                 const position = textPtr.getPosition();
                 const text = {
                     position: getLogicalPoint3dFromArray(position),
                     text: textPtr.getString(),
                     angle: textPtr.getRotation(),
-                    text_size: textPtr.getTextSize()
+                    text_size: textPtr.getTextSize(),
                 };
                 viewpoint.texts.push(text);
                 textPtr.delete();
@@ -3333,10 +3411,10 @@ class VisualizeMarkup {
         }
         itr.delete();
         viewpoint.snapshot = {
-            data: visLib.canvas.toDataURL("image/jpeg", .25)
+            data: visLib.canvas.toDataURL("image/jpeg", 0.25),
         };
         viewpoint.custom_fields = {
-            markup_color: this.getMarkupColor()
+            markup_color: this.getMarkupColor(),
         };
         return viewpoint;
     }
@@ -3352,33 +3430,29 @@ class VisualizeMarkup {
     getSelectedObjects() {
         return [];
     }
-    selectObjects(objects) {}
-    clearSelected() {}
+    selectObjects(objects) { }
+    clearSelected() { }
 }
 
 class MarkupFactory {
     static createMarkup(markupType = "Konva") {
         let markup;
         switch (markupType) {
-          case "Konva":
-            markup = new Markup;
-            break;
-
-          case "Visualize":
-            markup = new VisualizeMarkup;
-            break;
-
-          default:
-            throw new Error("Error during Markup initialization. Unknown Markup type.");
+            case "Konva":
+                markup = new Markup();
+                break;
+            case "Visualize":
+                markup = new VisualizeMarkup();
+                break;
+            default:
+                throw new Error("Error during Markup initialization. Unknown Markup type.");
         }
         return markup;
     }
 }
 
 const OVERLAY_VIEW_NAME = "$OVERLAY_VIEW_NAME";
-
-const isExist = value => value !== undefined && value !== null;
-
+const isExist = (value) => value !== undefined && value !== null;
 class Viewer extends EventEmitter2 {
     constructor(client, params = {}) {
         var _a;
@@ -3392,7 +3466,7 @@ class Viewer extends EventEmitter2 {
         this._components = [];
         this._renderTime = 0;
         this.canvasEvents = CANVAS_EVENTS.slice();
-        this.canvaseventlistener = event => this.emit(event);
+        this.canvaseventlistener = (event) => this.emit(event);
         this._enableAutoUpdate = (_a = params.enableAutoUpdate) !== null && _a !== void 0 ? _a : true;
         this._renderNeeded = false;
         this._isRunAsyncUpdate = false;
@@ -3415,7 +3489,7 @@ class Viewer extends EventEmitter2 {
         return this;
     }
     async initialize(canvas, onProgress) {
-        this.addEventListener("optionschange", event => this.syncOptions(event.data));
+        this.addEventListener("optionschange", (event) => this.syncOptions(event.data));
         const rect = canvas.parentElement.getBoundingClientRect();
         const width = rect.width || 1;
         const height = rect.height || 1;
@@ -3427,29 +3501,20 @@ class Viewer extends EventEmitter2 {
         canvas.style.touchAction = "none";
         this._visualizeTimestamp = Date.now();
         const visualizeTimestamp = this._visualizeTimestamp;
-        const visualizeJs = await loadVisualizeJs(this.visualizeJsUrl, event => {
-            const {loaded: loaded, total: total} = event;
-            if (onProgress) onProgress(new ProgressEvent("progress", {
-                lengthComputable: true,
-                loaded: loaded,
-                total: total
-            }));
-            this.emitEvent({
-                type: "initializeprogress",
-                data: loaded / total,
-                loaded: loaded,
-                total: total
-            });
-        }, {
-            crossOrigin: this._crossOrigin
-        });
-        if (visualizeTimestamp !== this._visualizeTimestamp) throw new Error("Viewer error: dispose() was called before initialize() completed. Are you using React strict mode?");
+        const visualizeJs = await loadVisualizeJs(this.visualizeJsUrl, (event) => {
+            const { loaded, total } = event;
+            if (onProgress)
+                onProgress(new ProgressEvent("progress", { lengthComputable: true, loaded, total }));
+            this.emitEvent({ type: "initializeprogress", data: loaded / total, loaded, total });
+        }, { crossOrigin: this._crossOrigin });
+        if (visualizeTimestamp !== this._visualizeTimestamp)
+            throw new Error("Viewer error: dispose() was called before initialize() completed. Are you using React strict mode?");
         this._visualizeJs = visualizeJs;
         this._visualizeJs.canvas = canvas;
         this._viewer = visualizeJs.Viewer.create();
         this._viewer.resize(0, canvas.width, canvas.height, 0);
         this.canvas = canvas;
-        this.canvasEvents.forEach(x => canvas.addEventListener(x, this.canvaseventlistener));
+        this.canvasEvents.forEach((x) => canvas.addEventListener(x, this.canvaseventlistener));
         this._markup.initialize(this.canvas, this.canvasEvents, this, this);
         for (const name of components.getComponents().keys()) {
             this._components.push(components.createComponent(name, this));
@@ -3458,27 +3523,24 @@ class Viewer extends EventEmitter2 {
         this.syncOverlay();
         this._renderTime = performance.now();
         this.render(this._renderTime);
-        this.emitEvent({
-            type: "initialize"
-        });
+        this.emitEvent({ type: "initialize" });
         return this;
     }
     dispose() {
         this.cancel();
         this.clear();
-        this.emitEvent({
-            type: "dispose"
-        });
+        this.emitEvent({ type: "dispose" });
         this.removeAllListeners();
         this.setActiveDragger();
-        this._components.forEach(component => component.dispose());
+        this._components.forEach((component) => component.dispose());
         this._components = [];
         this._markup.dispose();
         if (this.canvas) {
-            this.canvasEvents.forEach(x => this.canvas.removeEventListener(x, this.canvaseventlistener));
+            this.canvasEvents.forEach((x) => this.canvas.removeEventListener(x, this.canvaseventlistener));
             this.canvas = undefined;
         }
-        if (this._viewer) this._viewer.clear();
+        if (this._viewer)
+            this._viewer.clear();
         this._visualizeJs = undefined;
         this._visualizeTimestamp = undefined;
         this._viewer = undefined;
@@ -3488,7 +3550,8 @@ class Viewer extends EventEmitter2 {
         return !!this.visualizeJs;
     }
     setSize(width, height, updateStyle = true) {
-        if (!this.visualizeJs) return;
+        if (!this.visualizeJs)
+            return;
         this.canvas.width = Math.round(width * window.devicePixelRatio);
         this.canvas.height = Math.round(height * window.devicePixelRatio);
         if (updateStyle) {
@@ -3497,48 +3560,45 @@ class Viewer extends EventEmitter2 {
         }
         this._viewer.resize(0, this.canvas.width, this.canvas.height, 0);
         this.update(true);
-        this.emitEvent({
-            type: "resize",
-            width: width,
-            height: height
-        });
+        this.emitEvent({ type: "resize", width, height });
     }
     render(time) {
         var _a, _b;
-        if (!this.visualizeJs) return;
-        if (this._isRunAsyncUpdate) return;
+        if (!this.visualizeJs)
+            return;
+        if (this._isRunAsyncUpdate)
+            return;
         const renderNeeded = this.visViewer().isRunningAnimation() || this._renderNeeded;
-        if (!renderNeeded) return;
-        if (!time) time = performance.now();
-        const deltaTime = (time - this._renderTime) / 1e3;
+        if (!renderNeeded)
+            return;
+        if (!time)
+            time = performance.now();
+        const deltaTime = (time - this._renderTime) / 1000;
         this._renderTime = time;
         this._renderNeeded = !this.visViewer().getActiveDevice().isValid();
         this.visViewer().update();
         (_b = (_a = this._activeDragger) === null || _a === void 0 ? void 0 : _a.updatePreview) === null || _b === void 0 ? void 0 : _b.call(_a);
-        this.emitEvent({
-            type: "render",
-            time: time,
-            deltaTime: deltaTime
-        });
+        this.emitEvent({ type: "render", time, deltaTime });
     }
     resize() {
         console.warn("Viewer.resize() has been deprecated since 26.9 and will be removed in a future release, use Viewer.setSize() instead.");
-        if (!this.visualizeJs) return this;
-        if (!this.canvas.parentElement) return this;
-        const {width: width, height: height} = this.canvas.parentElement.getBoundingClientRect();
-        if (!width || !height) return this;
+        if (!this.visualizeJs)
+            return this;
+        if (!this.canvas.parentElement)
+            return this;
+        const { width, height } = this.canvas.parentElement.getBoundingClientRect();
+        if (!width || !height)
+            return this;
         this.setSize(width, height);
         return this;
     }
     update(force = false) {
         if (this._enableAutoUpdate) {
             this._renderNeeded = true;
-            if (force) this.render();
+            if (force)
+                this.render();
         }
-        this.emitEvent({
-            type: "update",
-            data: force
-        });
+        this.emitEvent({ type: "update", data: force });
     }
     scheduleUpdateAsync(maxScheduleUpdateTimeInMs = 50) {
         return new Promise((resolve, reject) => {
@@ -3549,12 +3609,10 @@ class Viewer extends EventEmitter2 {
                         (_a = this.visViewer()) === null || _a === void 0 ? void 0 : _a.update(maxScheduleUpdateTimeInMs);
                         (_c = (_b = this._activeDragger) === null || _b === void 0 ? void 0 : _b.updatePreview) === null || _c === void 0 ? void 0 : _c.call(_b);
                     }
-                    this.emitEvent({
-                        type: "update",
-                        data: false
-                    });
+                    this.emitEvent({ type: "update", data: false });
                     resolve();
-                } catch (e) {
+                }
+                catch (e) {
                     console.error(e);
                     reject();
                 }
@@ -3562,7 +3620,8 @@ class Viewer extends EventEmitter2 {
         });
     }
     async updateAsync(maxScheduleUpdateTimeInMs = 50, maxScheduleUpdateCount = 50) {
-        if (!this.visualizeJs) return;
+        if (!this.visualizeJs)
+            return;
         this._isRunAsyncUpdate = true;
         try {
             const device = this.visViewer().getActiveDevice();
@@ -3570,9 +3629,11 @@ class Viewer extends EventEmitter2 {
                 await this.scheduleUpdateAsync(maxScheduleUpdateTimeInMs);
             }
             await this.scheduleUpdateAsync(maxScheduleUpdateTimeInMs);
-        } catch (e) {
+        }
+        catch (e) {
             console.error(e);
-        } finally {
+        }
+        finally {
             this._isRunAsyncUpdate = false;
         }
     }
@@ -3586,18 +3647,21 @@ class Viewer extends EventEmitter2 {
         return this._viewer;
     }
     syncOpenCloudVisualStyle() {
-        if (!this.visualizeJs) return this;
+        if (!this.visualizeJs)
+            return this;
         const visLib = this.visLib();
         const visViewer = this.visViewer();
         const device = visViewer.getActiveDevice();
-        if (device.isNull()) return this;
+        if (device.isNull())
+            return this;
         const view = device.getActiveView();
         view.enableDefaultLighting(true, visLib.DefaultLightingType.kTwoLights);
         view.setDefaultLightingIntensity(1.25);
         let visualStyleId;
         try {
             visualStyleId = visViewer.findVisualStyle("OpenCloud");
-        } catch {
+        }
+        catch {
             visualStyleId = undefined;
         }
         if (!visualStyleId || visualStyleId.isNull()) {
@@ -3620,12 +3684,14 @@ class Viewer extends EventEmitter2 {
         return this;
     }
     syncOptions(options = this.options) {
-        if (!this.visualizeJs) return this;
+        if (!this.visualizeJs)
+            return this;
         this.syncOpenCloudVisualStyle();
         const visLib = this.visLib();
         const visViewer = this.visViewer();
         const device = visViewer.getActiveDevice();
-        if (device.isNull()) return this;
+        if (device.isNull())
+            return this;
         if (options.showWCS !== visViewer.getEnableWCS()) {
             visViewer.setEnableWCS(options.showWCS);
         }
@@ -3640,7 +3706,7 @@ class Viewer extends EventEmitter2 {
         if (options.shadows !== visViewer.shadows) {
             visViewer.shadows = options.shadows;
             const canvas = visLib.canvas;
-            device.invalidate([ 0, canvas.width, canvas.height, 0 ]);
+            device.invalidate([0, canvas.width, canvas.height, 0]);
         }
         if (options.groundShadow !== visViewer.groundShadow) {
             visViewer.groundShadow = options.groundShadow;
@@ -3672,11 +3738,12 @@ class Viewer extends EventEmitter2 {
         return this;
     }
     syncHighlightingOptions(options = this.options) {
-        if (!this.visualizeJs) return this;
+        if (!this.visualizeJs)
+            return this;
         const params = options.enableCustomHighlight ? options : Options.defaults();
         const visLib = this.visLib();
         const visViewer = this.visViewer();
-        const {Entry: Entry, OdTvRGBColorDef: OdTvRGBColorDef} = visLib;
+        const { Entry, OdTvRGBColorDef } = visLib;
         const highlightStyleId = visViewer.findHighlightStyle("Web_Default");
         const highlightStylePtr = highlightStyleId.openObject();
         if (isExist(params.facesColor)) {
@@ -3705,20 +3772,20 @@ class Viewer extends EventEmitter2 {
         const device = visViewer.getActiveDevice();
         if (!device.isNull()) {
             const canvas = visLib.canvas;
-            device.invalidate([ 0, canvas.width, canvas.height, 0 ]);
+            device.invalidate([0, canvas.width, canvas.height, 0]);
             device.delete();
         }
         return this;
     }
     get draggers() {
-        return [ ...draggers.getDraggers().keys() ];
+        return [...draggers.getDraggers().keys()];
     }
     get components() {
-        return [ ...components.getComponents().keys() ];
+        return [...components.getComponents().keys()];
     }
     registerDragger(name, dragger) {
         console.warn("Viewer.registerDragger() has been deprecated since 25.12 and will be removed in a future release, use draggers('visualizejs').registerDragger() instead.");
-        draggers.registerDragger(name, viewer => new dragger(viewer));
+        draggers.registerDragger(name, (viewer) => new dragger(viewer));
     }
     activeDragger() {
         return this._activeDragger;
@@ -3741,13 +3808,12 @@ class Viewer extends EventEmitter2 {
             }
             const canvas = this.canvas;
             if (canvas) {
-                if (oldDragger) canvas.classList.remove(`oda-cursor-${oldDragger.name.toLowerCase()}`);
-                if (newDragger) canvas.classList.add(`oda-cursor-${newDragger.name.toLowerCase()}`);
+                if (oldDragger)
+                    canvas.classList.remove(`oda-cursor-${oldDragger.name.toLowerCase()}`);
+                if (newDragger)
+                    canvas.classList.add(`oda-cursor-${newDragger.name.toLowerCase()}`);
             }
-            this.emitEvent({
-                type: "changeactivedragger",
-                data: name
-            });
+            this.emitEvent({ type: "changeactivedragger", data: name });
             this.update();
         }
         return this._activeDragger;
@@ -3760,10 +3826,11 @@ class Viewer extends EventEmitter2 {
         }
     }
     getComponent(name) {
-        return this._components.find(component => component.name === name);
+        return this._components.find((component) => component.name === name);
     }
     clearSlices() {
-        if (!this.visualizeJs) return;
+        if (!this.visualizeJs)
+            return;
         const visViewer = this.visViewer();
         const activeView = visViewer.activeView;
         activeView.removeCuttingPlanes();
@@ -3771,12 +3838,14 @@ class Viewer extends EventEmitter2 {
         this.update();
     }
     clearOverlay() {
-        if (!this.visualizeJs) return;
+        if (!this.visualizeJs)
+            return;
         this._markup.clearOverlay();
         this.update();
     }
     syncOverlay() {
-        if (!this.visualizeJs) return;
+        if (!this.visualizeJs)
+            return;
         const visViewer = this.visViewer();
         const activeView = visViewer.activeView;
         let overlayView = visViewer.getViewByName(OVERLAY_VIEW_NAME);
@@ -3800,7 +3869,8 @@ class Viewer extends EventEmitter2 {
         this.update();
     }
     is3D() {
-        if (!this.visualizeJs) return false;
+        if (!this.visualizeJs)
+            return false;
         const visViewer = this.visViewer();
         const ext = visViewer.getActiveExtents();
         const min = ext.min();
@@ -3809,49 +3879,36 @@ class Viewer extends EventEmitter2 {
         return extHeight !== 0;
     }
     screenToWorld(position) {
-        if (!this.visualizeJs) return {
-            x: position.x,
-            y: position.y,
-            z: 0
-        };
+        if (!this.visualizeJs)
+            return { x: position.x, y: position.y, z: 0 };
         const activeView = this.visViewer().activeView;
         const worldPoint = activeView.transformScreenToWorld(position.x * window.devicePixelRatio, position.y * window.devicePixelRatio);
-        const result = {
-            x: worldPoint[0],
-            y: worldPoint[1],
-            z: worldPoint[2]
-        };
+        const result = { x: worldPoint[0], y: worldPoint[1], z: worldPoint[2] };
         activeView.delete();
         return result;
     }
     worldToScreen(position) {
-        if (!this.visualizeJs) return {
-            x: position.x,
-            y: position.y
-        };
+        if (!this.visualizeJs)
+            return { x: position.x, y: position.y };
         const activeView = this.visViewer().activeView;
         const devicePoint = activeView.transformWorldToScreen(position.x, position.y, position.z);
-        const result = {
-            x: devicePoint[0] / window.devicePixelRatio,
-            y: devicePoint[1] / window.devicePixelRatio
-        };
+        const result = { x: devicePoint[0] / window.devicePixelRatio, y: devicePoint[1] / window.devicePixelRatio };
         activeView.delete();
         return result;
     }
     getScale() {
-        const result = {
-            x: 1,
-            y: 1,
-            z: 1
-        };
+        const result = { x: 1.0, y: 1.0, z: 1.0 };
         const projMatrix = this.visViewer().activeView.projectionMatrix;
-        const tolerance = 1e-6;
+        const tolerance = 1.0e-6;
         const x = projMatrix.get(0, 0);
-        if (x > tolerance || x < -tolerance) result.x = 1 / x;
+        if (x > tolerance || x < -tolerance)
+            result.x = 1 / x;
         const y = projMatrix.get(1, 1);
-        if (y > tolerance || y < -tolerance) result.y = 1 / y;
+        if (y > tolerance || y < -tolerance)
+            result.y = 1 / y;
         const z = projMatrix.get(2, 2);
-        if (z > tolerance || z < -tolerance) result.z = 1 / z;
+        if (z > tolerance || z < -tolerance)
+            result.z = 1 / z;
         return result;
     }
     getSelected() {
@@ -3880,19 +3937,25 @@ class Viewer extends EventEmitter2 {
     }
     async loadReferences(model) {
         var _a;
-        if (!this.visualizeJs) return this;
-        if (!this.client) return this;
-        if (!model.getReferences) return this;
-        const abortController = new AbortController;
+        if (!this.visualizeJs)
+            return this;
+        if (!this.client)
+            return this;
+        if (!model.getReferences)
+            return this;
+        const abortController = new AbortController();
         (_a = this._abortControllerForReferences) === null || _a === void 0 ? void 0 : _a.abort();
         this._abortControllerForReferences = abortController;
         let references = [];
-        await model.getReferences(abortController.signal).then(data => references = data.references).catch(e => console.error("Cannot load model references.", e));
+        await model
+            .getReferences(abortController.signal)
+            .then((data) => (references = data.references))
+            .catch((e) => console.error("Cannot load model references.", e));
         for (const file of references) {
-            await this.client.downloadFile(file.id, undefined, abortController.signal).then(arrayBuffer => {
-                var _a;
-                return (_a = this.visualizeJs) === null || _a === void 0 ? void 0 : _a.getViewer().addEmbeddedFile(file.name, new Uint8Array(arrayBuffer));
-            }).catch(e => console.error(`Cannot load reference file ${file.name}.`, e));
+            await this.client
+                .downloadFile(file.id, undefined, abortController.signal)
+                .then((arrayBuffer) => { var _a; return (_a = this.visualizeJs) === null || _a === void 0 ? void 0 : _a.getViewer().addEmbeddedFile(file.name, new Uint8Array(arrayBuffer)); })
+                .catch((e) => console.error(`Cannot load reference file ${file.name}.`, e));
         }
         return this;
     }
@@ -3900,7 +3963,8 @@ class Viewer extends EventEmitter2 {
         this.executeCommand("applyModelTransform", model);
     }
     applySceneGraphSettings(options = this.options) {
-        if (!this.visualizeJs) return;
+        if (!this.visualizeJs)
+            return;
         const visLib = this.visLib();
         const visViewer = this.visViewer();
         const device = visViewer.getActiveDevice();
@@ -3911,48 +3975,39 @@ class Viewer extends EventEmitter2 {
         this.update();
     }
     async open(file, params = {}) {
-        if (!this.visualizeJs) return this;
+        if (!this.visualizeJs)
+            return this;
         this.cancel();
         this.clear();
-        this.emitEvent({
-            type: "open",
-            file: file
-        });
+        this.emitEvent({ type: "open", file });
         let model = file;
         if (model && typeof model.getModels === "function") {
             const models = await model.getModels();
-            model = models.find(model => model.default) || models[0] || file;
+            model = models.find((model) => model.default) || models[0] || file;
         }
-        if (!model) throw new Error(`Format not supported`);
+        if (!model)
+            throw new Error(`Format not supported`);
         let format = params.format;
-        if (!format && typeof model.type === "string") format = model.type.split(".").pop();
-        if (!format && typeof file === "string") format = file.split(".").pop();
-        if (!format && file instanceof globalThis.File) format = file.name.split(".").pop();
+        if (!format && typeof model.type === "string")
+            format = model.type.split(".").pop();
+        if (!format && typeof file === "string")
+            format = file.split(".").pop();
+        if (!format && file instanceof globalThis.File)
+            format = file.name.split(".").pop();
         const loader = loaders.createLoader(this, model, format);
-        if (!loader) throw new Error(`Format not supported`);
+        if (!loader)
+            throw new Error(`Format not supported`);
         this.loaders.push(loader);
-        this.emitEvent({
-            type: "geometrystart",
-            file: file,
-            model: model
-        });
+        this.emitEvent({ type: "geometrystart", file, model });
         try {
             await this.loadReferences(model);
             await loader.load(model, format, params);
-        } catch (error) {
-            this.emitEvent({
-                type: "geometryerror",
-                data: error,
-                file: file,
-                model: model
-            });
+        }
+        catch (error) {
+            this.emitEvent({ type: "geometryerror", data: error, file, model });
             throw error;
         }
-        this.emitEvent({
-            type: "geometryend",
-            file: file,
-            model: model
-        });
+        this.emitEvent({ type: "geometryend", file, model });
         if (this.visualizeJs) {
             this.applyModelTransformMatrix(model);
             this.applySceneGraphSettings();
@@ -3961,131 +4016,78 @@ class Viewer extends EventEmitter2 {
     }
     openVsfFile(buffer) {
         console.warn("Viewer.openVsfFile() has been deprecated since 26.4 and will be removed in a future release, use Viewer.open() instead.");
-        if (!this.visualizeJs) return this;
+        if (!this.visualizeJs)
+            return this;
         this.cancel();
         this.clear();
-        this.emitEvent({
-            type: "open",
-            file: "",
-            buffer: buffer
-        });
+        this.emitEvent({ type: "open", file: "", buffer });
         const visViewer = this.visViewer();
-        this.emitEvent({
-            type: "geometrystart",
-            file: "",
-            buffer: buffer
-        });
+        this.emitEvent({ type: "geometrystart", file: "", buffer });
         try {
             const data = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
             visViewer.parseFile(data);
             this.syncOptions();
             this.syncOverlay();
             this.update(true);
-            this.emitEvent({
-                type: "geometryprogress",
-                data: 1,
-                file: "",
-                buffer: buffer
-            });
-            this.emitEvent({
-                type: "databasechunk",
-                data: data,
-                file: "",
-                buffer: buffer
-            });
-        } catch (error) {
-            this.emitEvent({
-                type: "geometryerror",
-                data: error,
-                file: "",
-                buffer: buffer
-            });
+            this.emitEvent({ type: "geometryprogress", data: 1, file: "", buffer });
+            this.emitEvent({ type: "databasechunk", data, file: "", buffer });
+        }
+        catch (error) {
+            this.emitEvent({ type: "geometryerror", data: error, file: "", buffer });
             throw error;
         }
-        this.emitEvent({
-            type: "geometryend",
-            file: "",
-            buffer: buffer
-        });
+        this.emitEvent({ type: "geometryend", file: "", buffer });
         return this;
     }
     openVsfxFile(buffer) {
         console.warn("Viewer.openVsfxFile() has been deprecated since 26.4 and will be removed in a future release, use Viewer.open() instead.");
-        if (!this.visualizeJs) return this;
+        if (!this.visualizeJs)
+            return this;
         this.cancel();
         this.clear();
-        this.emitEvent({
-            type: "open",
-            file: "",
-            buffer: buffer
-        });
+        this.emitEvent({ type: "open", file: "", buffer });
         const visViewer = this.visViewer();
-        this.emitEvent({
-            type: "geometrystart",
-            file: "",
-            buffer: buffer
-        });
+        this.emitEvent({ type: "geometrystart", file: "", buffer });
         try {
             const data = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
             visViewer.parseVsfx(data);
             this.syncOptions();
             this.syncOverlay();
             this.update(true);
-            this.emitEvent({
-                type: "geometryprogress",
-                data: 1,
-                file: "",
-                buffer: buffer
-            });
-            this.emitEvent({
-                type: "databasechunk",
-                data: data,
-                file: "",
-                buffer: buffer
-            });
-        } catch (error) {
-            this.emitEvent({
-                type: "geometryerror",
-                data: error,
-                file: "",
-                buffer: buffer
-            });
+            this.emitEvent({ type: "geometryprogress", data: 1, file: "", buffer });
+            this.emitEvent({ type: "databasechunk", data, file: "", buffer });
+        }
+        catch (error) {
+            this.emitEvent({ type: "geometryerror", data: error, file: "", buffer });
             throw error;
         }
-        this.emitEvent({
-            type: "geometryend",
-            file: "",
-            buffer: buffer
-        });
+        this.emitEvent({ type: "geometryend", file: "", buffer });
         return this;
     }
     cancel() {
         var _a;
         (_a = this._abortControllerForReferences) === null || _a === void 0 ? void 0 : _a.abort();
         this._abortControllerForReferences = undefined;
-        this.loaders.forEach(loader => loader.cancel());
-        this.emitEvent({
-            type: "cancel"
-        });
+        this.loaders.forEach((loader) => loader.cancel());
+        this.emitEvent({ type: "cancel" });
         return this;
     }
     clear() {
-        if (!this.visualizeJs) return this;
+        if (!this.visualizeJs)
+            return this;
         const visViewer = this.visViewer();
         this.setActiveDragger();
         this.clearSlices();
         this.clearOverlay();
         this.clearSelected();
-        this.loaders.forEach(loader => loader.dispose());
+        this.loaders.forEach((loader) => loader.dispose());
         this.loaders = [];
         visViewer.clear();
         visViewer.createLocalDatabase();
         this.syncOptions();
         this.syncOverlay();
         this.update(true);
-        this.emitEvent({
-            type: "clear"
-        });
+        this.emitEvent({ type: "clear" });
         return this;
     }
     getMarkupColor() {
@@ -4104,7 +4106,8 @@ class Viewer extends EventEmitter2 {
         this._markup.colorizeSelectedMarkups(r, g, b);
     }
     addMarkupEntity(entityName) {
-        if (!this.visualizeJs) return null;
+        if (!this.visualizeJs)
+            return null;
         this.syncOverlay();
         const visViewer = this.visViewer();
         const model = visViewer.getMarkupModel();
@@ -4119,7 +4122,8 @@ class Viewer extends EventEmitter2 {
     }
     drawViewpoint(viewpoint) {
         var _a;
-        if (!this.visualizeJs) return;
+        if (!this.visualizeJs)
+            return;
         const draggerName = (_a = this._activeDragger) === null || _a === void 0 ? void 0 : _a.name;
         this.setActiveDragger();
         this.clearSlices();
@@ -4132,35 +4136,26 @@ class Viewer extends EventEmitter2 {
         this.setSelection(viewpoint.selection);
         this._markup.setViewpoint(viewpoint);
         this.setActiveDragger(draggerName);
-        this.emitEvent({
-            type: "drawviewpoint",
-            data: viewpoint
-        });
+        this.emitEvent({ type: "drawviewpoint", data: viewpoint });
         this.update();
     }
     createViewpoint() {
-        if (!this.visualizeJs) return {};
+        if (!this.visualizeJs)
+            return {};
         const viewpoint = {};
         viewpoint.orthogonal_camera = this.getOrthogonalCameraSettings();
         viewpoint.clipping_planes = this.getClippingPlanes();
         viewpoint.selection = this.getSelection();
-        viewpoint.description = (new Date).toDateString();
+        viewpoint.description = new Date().toDateString();
         this._markup.getViewpoint(viewpoint);
-        this.emitEvent({
-            type: "createviewpoint",
-            data: viewpoint
-        });
+        this.emitEvent({ type: "createviewpoint", data: viewpoint });
         return viewpoint;
     }
     getPoint3dFromArray(array) {
-        return {
-            x: array[0],
-            y: array[1],
-            z: array[2]
-        };
+        return { x: array[0], y: array[1], z: array[2] };
     }
     getLogicalPoint3dAsArray(point3d) {
-        return [ point3d.x, point3d.y, point3d.z ];
+        return [point3d.x, point3d.y, point3d.z];
     }
     getOrthogonalCameraSettings() {
         const visViewer = this.visViewer();
@@ -4171,7 +4166,7 @@ class Viewer extends EventEmitter2 {
             up_vector: this.getPoint3dFromArray(activeView.upVector),
             field_width: activeView.viewFieldWidth,
             field_height: activeView.viewFieldHeight,
-            view_to_world_scale: 1
+            view_to_world_scale: 1,
         };
     }
     setOrthogonalCameraSettings(settings) {
@@ -4190,7 +4185,7 @@ class Viewer extends EventEmitter2 {
             const cuttingPlane = activeView.getCuttingPlane(i);
             const clipping_plane = {
                 location: this.getPoint3dFromArray(cuttingPlane.getOrigin()),
-                direction: this.getPoint3dFromArray(cuttingPlane.normal())
+                direction: this.getPoint3dFromArray(cuttingPlane.normal()),
             };
             clipping_planes.push(clipping_plane);
         }
@@ -4201,20 +4196,18 @@ class Viewer extends EventEmitter2 {
             const visViewer = this.visViewer();
             const activeView = visViewer.activeView;
             for (const clipping_plane of clipping_planes) {
-                const cuttingPlane = new (this.visLib().OdTvPlane);
+                const cuttingPlane = new (this.visLib().OdTvPlane)();
                 cuttingPlane.set(this.getLogicalPoint3dAsArray(clipping_plane.location), this.getLogicalPoint3dAsArray(clipping_plane.direction));
                 activeView.addCuttingPlane(cuttingPlane);
-                activeView.setEnableCuttingPlaneFill(true, 102, 102, 102);
+                activeView.setEnableCuttingPlaneFill(true, 0x66, 0x66, 0x66);
             }
         }
     }
     getSelection() {
-        return this.getSelected().map(handle => ({
-            handle: handle
-        }));
+        return this.getSelected().map((handle) => ({ handle }));
     }
     setSelection(selection) {
-        this.setSelected(selection === null || selection === void 0 ? void 0 : selection.map(component => component.handle));
+        this.setSelected(selection === null || selection === void 0 ? void 0 : selection.map((component) => component.handle));
     }
     executeCommand(id, ...args) {
         return commands.executeCommand(id, this, ...args);
@@ -4223,7 +4216,7 @@ class Viewer extends EventEmitter2 {
         const visViewer = this.visViewer();
         const device = visViewer.getActiveDevice();
         const coef = device.getOptionDouble(this.visLib().DeviceOptions.kRegenCoef);
-        if (coef > 1) {
+        if (coef > 1.0) {
             visViewer.regenAll();
             this.update();
         }