@inweb/viewer-visualize 26.9.2 → 26.9.4

package/dist/viewer-visualize.module.js

@@ -1,20 +1,39 @@
-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);
-            (_a = extView.delete) === null || _a === undefined ? undefined : _a.call(extView);
+            (_a = extView.delete) === null || _a === void 0 ? void 0 : _a.call(extView);
         };
         this.getViewParams = () => {
             var _a;
@@ -25,9 +44,9 @@ class OdaGeAction {
                 upVector: view.upVector,
                 viewFieldWidth: view.viewFieldWidth,
                 viewFieldHeight: view.viewFieldHeight,
-                perspective: view.perspective
+                perspective: view.perspective,
             };
-            (_a = view.delete) === null || _a === undefined ? undefined : _a.call(view);
+            (_a = view.delete) === null || _a === void 0 ? void 0 : _a.call(view);
             return obj;
         };
         this.m_module = module;
@@ -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);
     }
@@ -249,10 +256,10 @@ class OdBaseDragger extends OdaGeAction {
     deleteAll(objects) {
         var _a;
         for (const obj of objects) {
-            (_a = obj === null || obj === undefined ? undefined : obj.delete) === null || _a === undefined ? undefined : _a.call(obj);
+            (_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,11 +596,11 @@ class MeasureLineDragger extends OdBaseDragger {
             Miles: "mi",
             Micrometers: "µm",
             MicroInches: "µin",
-            Default: "unit"
+            Default: "unit",
         };
         this.items = [];
         this.canvasEvents.push("resize");
-        this.oldRulerUnit = (_a = subject.options.rulerUnit) !== null && _a !== undefined ? _a : "Default";
+        this.oldRulerUnit = (_a = subject.options.rulerUnit) !== null && _a !== void 0 ? _a : "Default";
         this.optionsChange = this.optionsChange.bind(this);
     }
     initialize() {
@@ -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;
@@ -727,82 +714,75 @@ class MeasureLineDragger extends OdBaseDragger {
     optionsChange(event) {
         var _a;
         const options = event.data;
-        const toUnitName = (_a = options.rulerUnit) !== null && _a !== undefined ? _a : "Default";
-        if (this.oldRulerUnit === toUnitName) return;
+        const toUnitName = (_a = options.rulerUnit) !== null && _a !== void 0 ? _a : "Default";
+        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;
                 item.setConversionFactor(this.conversionFactor);
             }
-        }));
+        });
     }
     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 = 42.0;
+const calcFocalLength = (lensLength, fieldWidth, fieldHeight) => {
+    return (lensLength / FocalLengthConst) * 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();
@@ -852,7 +831,7 @@ class OdaWalkDragger extends OdBaseDragger {
             const model = this.viewer.getActiveModel();
             model.removeEntity(this.cameraId);
             model.delete();
-            (_a = this.cameraWalker) === null || _a === undefined ? undefined : _a.delete();
+            (_a = this.cameraWalker) === null || _a === void 0 ? void 0 : _a.delete();
         }
         if (this.viewParams) {
             this.setViewParams(this.viewParams);
@@ -864,37 +843,30 @@ 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
-                });
-            }
-            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;
+            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) {
@@ -912,58 +884,45 @@ 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.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;
                 }
             }
             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.cameraWalker.turnDown(dltY * this.deltaAngle);
             this.subject.update();
-            this.subject.emitEvent({
-                type: "changecamera"
-            });
+            this.subject.emitEvent({ type: "changecamera" });
         }
     }
     turnLeft(angle) {
@@ -972,7 +931,7 @@ class OdaWalkDragger extends OdBaseDragger {
         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 +945,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 +955,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 +989,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 +1018,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 +1033,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 +1041,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 +1054,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 +1169,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 +1179,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,26 +1191,26 @@ 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();
         const extView = this.getViewer().getActiveTvExtendedView();
         extView.setView(viewParams.position, viewParams.target, viewParams.upVector, viewParams.viewFieldWidth, viewParams.viewFieldHeight, viewParams.perspective);
         extView.delete();
-        (_b = (_a = this._subject.activeDragger()) === null || _a === undefined ? undefined : _a.updatePreview) === null || _b === undefined ? undefined : _b.call(_a);
+        (_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 +1224,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 +1233,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 +1251,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 +1261,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 +1269,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 +1281,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 +1291,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;
@@ -1324,7 +1320,7 @@ class OrbitAction {
     deleteAll(objects) {
         var _a;
         for (const obj of objects) {
-            (_a = obj === null || obj === undefined ? undefined : obj.delete) === null || _a === undefined ? undefined : _a.call(obj);
+            (_a = obj === null || obj === void 0 ? void 0 : obj.delete) === null || _a === void 0 ? void 0 : _a.call(obj);
         }
     }
 }
@@ -1367,15 +1363,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);
@@ -1391,21 +1384,18 @@ class PanAction {
         targetWithDelta.delete();
         position.delete();
         positionWithDelta.delete();
-        (_b = (_a = this._subject.activeDragger()) === null || _a === undefined ? undefined : _a.updatePreview) === null || _b === undefined ? undefined : _b.call(_a);
+        (_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: "pan",
             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();
@@ -1447,15 +1437,15 @@ class ZoomAction {
         const viewer = this._m_module.getViewer();
         viewer.zoomAt(zoomFactor, x, y);
         this._subject.deviceAutoRegeneration();
-        (_b = (_a = this._subject.activeDragger()) === null || _a === undefined ? undefined : _a.updatePreview) === null || _b === undefined ? undefined : _b.call(_a);
+        (_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: "zoomat",
             data: zoomFactor,
             x: absoluteX,
-            y: absoluteY
+            y: absoluteY,
         });
         this._subject.emitEvent({
-            type: "changecamera"
+            type: "changecamera",
         });
     }
 }
@@ -1479,8 +1469,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 +1482,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 +1496,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;
@@ -1528,11 +1517,11 @@ class OdZoomWheelDragger extends OdBaseDragger {
                 clearTimeout(this._endInteractivityTimeOutId);
             }
             this.subject.update(true);
-            this._endInteractivityTimeOutId = setTimeout((() => {
+            this._endInteractivityTimeOutId = setTimeout(() => {
                 this._endInteractivityTimeOutId = undefined;
                 this.endInteractivity();
                 this._isEnableInteractivityMode = false;
-            }), INTERACTIVITY_TIME_OUT);
+            }, INTERACTIVITY_TIME_OUT);
         }
     }
     dispose() {
@@ -1546,12 +1535,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 +1596,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 +1615,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 +1655,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 +1672,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 +1733,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 +1751,38 @@ 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));
 
 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) {
@@ -1812,7 +1793,7 @@ function applyModelTransform(viewer, model) {
         }
     }
     modelItr.delete();
-    (_a = visViewer.clearViewExtentsCache) === null || _a === undefined ? undefined : _a.call(visViewer);
+    (_a = visViewer.clearViewExtentsCache) === null || _a === void 0 ? void 0 : _a.call(visViewer);
     viewer.update();
 }
 
@@ -1821,75 +1802,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 "";
-    return ((_a = viewer.canvas) === null || _a === undefined ? undefined : _a.toDataURL(type, encoderOptions)) || "";
+    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 +1884,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 +1923,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 +1952,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 +1967,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 === undefined ? undefined : 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 +2003,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);
-    }));
-    (_a = visViewer.zoomToObjects) === null || _a === undefined ? undefined : _a.call(visViewer, selectionSet);
+        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 === undefined ? undefined : _a.call(visViewer, selectionSet);
+    (_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 +2059,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);
@@ -2120,84 +2090,47 @@ async function autoTransformAllModelsToCentralPoint(viewer, model) {
         modelPtr.delete();
     }
     modelItr.delete();
-    (_a = visViewer.clearViewExtentsCache) === null || _a === undefined ? undefined : _a.call(visViewer);
+    (_a = visViewer.clearViewExtentsCache) === null || _a === void 0 ? void 0 : _a.call(visViewer);
     viewer.update();
 }
 
 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 +2138,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 +2150,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 +2179,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 +2194,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 +2212,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 +2262,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 +2306,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 +2369,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 +2394,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 +2409,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;
+            return new Promise((resolve, reject) => {
+                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 +2454,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 +2495,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 +2527,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 +2545,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 +2586,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 +2654,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 +2692,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 +2708,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 +2779,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 +2801,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 +2821,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,68 +2831,53 @@ 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((() => {
+                    pendingRequestsTimerId = window.setTimeout(() => {
                         pendingRequestsAbortController.signal.removeEventListener("abort", pendingRequestsAbortHandler);
                         pendingRequestsTimerId = 0;
-                        pendingRequestsMap.forEach(((request, dataId) => {
+                        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
-                    });
+                        });
+                    }, PENDING_REQUESTS_TIMEOUT);
+                    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) => {
+    return new Promise((resolve, reject) => {
         const script = document.createElement("script");
         script.src = url;
         script.async = true;
@@ -3017,40 +2888,38 @@ function loadScript(url, params = {}) {
             reject(new Error(`GET ${url} failed to load script`));
         };
         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) => {
+    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;
-        instance.postRun.push((() => {
+        instance.postRun.push(() => {
             window["getVisualizeLibInst"].script = script;
             resolve(instance);
-        }));
-    }));
+        });
+    });
 };
 
 const MARKUP_ENTITY_LINE = "$MarkupTempEntity_Line";
-
 class OdaLineDragger extends OdBaseDragger {
     constructor(subject) {
         super(subject);
@@ -3064,7 +2933,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 +2964,6 @@ class OdaLineDragger extends OdBaseDragger {
 }
 
 const MARKUP_ENTITY_TEXT = "$MarkupTempEntity_Text";
-
 class OdaTextDragger extends OdBaseDragger {
     constructor(subject) {
         super(subject);
@@ -3105,7 +2973,7 @@ class OdaTextDragger extends OdBaseDragger {
     dispose() {
         var _a;
         super.dispose();
-        (_a = this.textRef) === null || _a === undefined ? undefined : _a.remove();
+        (_a = this.textRef) === null || _a === void 0 ? void 0 : _a.remove();
         this.textRef = null;
     }
     _finishInput() {
@@ -3113,7 +2981,7 @@ class OdaTextDragger extends OdBaseDragger {
         if (this.textRef && this.textRef.value.trimLeft()) {
             this._updateFrame();
         }
-        (_a = this.textRef) === null || _a === undefined ? undefined : _a.remove();
+        (_a = this.textRef) === null || _a === void 0 ? void 0 : _a.remove();
         this.textRef = null;
     }
     start(x, y, absoluteX, absoluteY) {
@@ -3124,7 +2992,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 +3002,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,18 +3015,18 @@ 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;
-        if (!(mtrxNumber < tol && mtrxNumber > -1e-6)) {
+        const tol = 1.0e-6;
+        if (!(mtrxNumber < tol && mtrxNumber > -tol)) {
             textScale = 1 / mtrxNumber;
         }
         const geomData = entityPtr.appendText(this.toGePoint(this.m_center), this.textRef.value.trimLeft());
@@ -3173,11 +3042,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 +3051,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 +3065,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 +3092,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 +3138,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 +3165,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 +3189,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 +3208,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,8 +3244,8 @@ class Viewer extends EventEmitter2 {
         this._components = [];
         this._renderTime = 0;
         this.canvasEvents = CANVAS_EVENTS.slice();
-        this.canvaseventlistener = event => this.emit(event);
-        this._enableAutoUpdate = (_a = params.enableAutoUpdate) !== null && _a !== undefined ? _a : true;
+        this.canvaseventlistener = (event) => this.emit(event);
+        this._enableAutoUpdate = (_a = params.enableAutoUpdate) !== null && _a !== void 0 ? _a : true;
         this._renderNeeded = false;
         this._isRunAsyncUpdate = false;
         this.render = this.render.bind(this);
@@ -3415,7 +3267,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 +3279,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 +3301,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 +3328,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,72 +3338,68 @@ 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 === undefined ? undefined : _a.updatePreview) === null || _b === undefined ? undefined : _b.call(_a);
-        this.emitEvent({
-            type: "render",
-            time: time,
-            deltaTime: deltaTime
-        });
+        (_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, 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) => {
-            setTimeout((() => {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
                 var _a, _b, _c;
                 try {
                     if (this._enableAutoUpdate) {
                         (_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();
                 }
-            }), 0);
-        }));
+            }, 0);
+        });
     }
     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 +3407,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 +3425,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 +3462,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 +3484,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 +3516,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 +3550,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;
@@ -3736,18 +3581,17 @@ class Viewer extends EventEmitter2 {
                 newDragger = draggers.createDragger(name, this);
                 if (newDragger) {
                     this._activeDragger = newDragger;
-                    (_b = (_a = this._activeDragger).initialize) === null || _b === undefined ? undefined : _b.call(_a);
+                    (_b = (_a = this._activeDragger).initialize) === null || _b === void 0 ? void 0 : _b.call(_a);
                 }
             }
             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 +3604,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 +3616,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 +3647,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 +3657,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 < -1e-6) result.x = 1 / x;
+        if (x > tolerance || x < -tolerance)
+            result.x = 1 / x;
         const y = projMatrix.get(1, 1);
-        if (y > tolerance || y < -1e-6) result.y = 1 / y;
+        if (y > tolerance || y < -tolerance)
+            result.y = 1 / y;
         const z = projMatrix.get(2, 2);
-        if (z > tolerance || z < -1e-6) result.z = 1 / z;
+        if (z > tolerance || z < -tolerance)
+            result.z = 1 / z;
         return result;
     }
     getSelected() {
@@ -3880,19 +3715,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;
-        (_a = this._abortControllerForReferences) === null || _a === undefined ? undefined : _a.abort();
+        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 === undefined ? undefined : _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 +3741,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 +3753,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,119 +3794,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
-        });
+        this.emitEvent({ type: "open", file: "", buffer });
         const visViewer = this.visViewer();
-        this.emitEvent({
-            type: "geometrystart",
-            file: 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
-            });
-            this.emitEvent({
-                type: "databasechunk",
-                data: data,
-                file: buffer
-            });
-        } catch (error) {
-            this.emitEvent({
-                type: "geometryerror",
-                data: error,
-                file: 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
-        });
+        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
-        });
+        this.emitEvent({ type: "open", file: "", buffer });
         const visViewer = this.visViewer();
-        this.emitEvent({
-            type: "geometrystart",
-            file: 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
-            });
-            this.emitEvent({
-                type: "databasechunk",
-                data: data,
-                file: buffer
-            });
-        } catch (error) {
-            this.emitEvent({
-                type: "geometryerror",
-                data: error,
-                file: 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
-        });
+        this.emitEvent({ type: "geometryend", file: "", buffer });
         return this;
     }
     cancel() {
         var _a;
-        (_a = this._abortControllerForReferences) === null || _a === undefined ? undefined : _a.abort();
+        (_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() {
@@ -4092,7 +3884,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();
@@ -4107,8 +3900,9 @@ class Viewer extends EventEmitter2 {
     }
     drawViewpoint(viewpoint) {
         var _a;
-        if (!this.visualizeJs) return;
-        const draggerName = (_a = this._activeDragger) === null || _a === undefined ? undefined : _a.name;
+        if (!this.visualizeJs)
+            return;
+        const draggerName = (_a = this._activeDragger) === null || _a === void 0 ? void 0 : _a.name;
         this.setActiveDragger();
         this.clearSlices();
         this.clearOverlay();
@@ -4120,35 +3914,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();
@@ -4159,7 +3944,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) {
@@ -4178,7 +3963,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);
         }
@@ -4189,20 +3974,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 === undefined ? undefined : 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);
@@ -4211,7 +3994,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();
         }