@inweb/viewer-three 27.1.1 → 27.1.2

package/dist/viewer-three.js

@@ -171,6 +171,11 @@
         cancel() {
             this.abortController.abort();
         }
+        yield() {
+            return new Promise((resolve) => {
+                setTimeout(resolve, 0);
+            });
+        }
         extractFileName(file) {
             const regex = /[^/\\?#:]+(?=\?|#|$)/;
             if (typeof file === "string")
@@ -33865,7 +33870,7 @@ void main() {
                 this.orbit.enabled = !event.value;
             };
             this.updatePlaneSize = () => {
-                this.planeHelper.size = this.viewer.extents.getSize(new Vector3()).length();
+                this.planeHelper.size = this.viewer.extents.getSize(new Vector3()).length() || 1;
                 this.viewer.update();
             };
             this.updateTransformCamera = () => {
@@ -33876,17 +33881,17 @@ void main() {
                 this.plane.negate();
                 this.viewer.update();
             };
-            const size = viewer.extents.getSize(new Vector3()).length();
-            const center = viewer.extents.getCenter(new Vector3());
-            const constant = -center.dot(normal);
+            const extentsSize = viewer.extents.getSize(new Vector3()).length() || 1;
+            const extentsCenter = viewer.extents.getCenter(new Vector3());
+            const constant = -extentsCenter.dot(normal);
             this.plane = new Plane(normal, constant);
             if (!viewer.renderer.clippingPlanes)
                 viewer.renderer.clippingPlanes = [];
             viewer.renderer.clippingPlanes.push(this.plane);
-            this.planeHelper = new PlaneHelper(this.plane, size, color, center);
+            this.planeHelper = new PlaneHelper(this.plane, extentsSize, color, extentsCenter);
             this.viewer.helpers.add(this.planeHelper);
             this.planeCenter = new Object3D();
-            this.planeCenter.position.copy(viewer.extents.getCenter(new Vector3()));
+            this.planeCenter.position.copy(extentsCenter);
             this.viewer.helpers.add(this.planeCenter);
             this.transform = new TransformControls(viewer.camera, viewer.canvas);
             this.transform.showX = !!normal.x;
@@ -34197,7 +34202,11 @@ void main() {
                 const model = this.viewer.models[0];
                 const units = (_a = this.viewer.options.rulerUnit) !== null && _a !== void 0 ? _a : "Default";
                 const precision = (_b = this.viewer.options.rulerPrecision) !== null && _b !== void 0 ? _b : "Default";
-                if (units === "Default") {
+                if (!model) {
+                    this.scale = 1;
+                    this.units = "";
+                }
+                else if (units === "Default") {
                     this.scale = model.getUnitScale();
                     this.units = model.getUnitString();
                 }
@@ -34205,20 +34214,21 @@ void main() {
                     this.scale = convertUnits(model.getUnits(), units, 1);
                     this.units = units;
                 }
-                if (precision === "Default") {
+                if (!model)
+                    this.precision = 2;
+                else if (precision === "Default")
                     this.precision = model.getPrecision();
-                }
-                else {
+                else
                     this.precision = precision;
-                }
                 this.overlay.updateLineUnits(this.scale, this.units, this.precision);
             };
             this.overlay = new MeasureOverlay(viewer.camera, viewer.canvas);
             this.overlay.attach();
             this.line = new MeasureLine(this.overlay, this.scale, this.units, this.precision);
             this.overlay.addLine(this.line);
+            const extentsSize = this.viewer.extents.getSize(new Vector3()).length() || 1;
             this.snapper = new Snapper(viewer.camera, viewer.renderer, viewer.canvas);
-            this.snapper.threshold = viewer.extents.getSize(new Vector3()).length() / 10000;
+            this.snapper.threshold = extentsSize / 10000;
             this.objects = [];
             this.updateObjects();
             this.updateUnits();
@@ -34917,7 +34927,7 @@ void main() {
         constructor(viewer) {
             this.updateControls = () => {
                 const size = this.viewer.extents.getSize(new Vector3());
-                this.controls.movementSpeed = Math.min(size.x, size.y, size.z) / 2;
+                this.controls.movementSpeed = Math.min(size.x, size.y, size.z) / 2 || 1;
                 this.joyStickControls.movementSpeed = this.controls.movementSpeed;
                 this.joyStickControls.multiplier = this.controls.multiplier;
             };
@@ -35123,7 +35133,7 @@ void main() {
         constructor(viewer) {
             this.updateControls = () => {
                 const size = this.viewer.extents.getSize(new Vector3());
-                this.controls.movementSpeed = Math.min(size.x, size.y, size.z) / 2;
+                this.controls.movementSpeed = Math.min(size.x, size.y, size.z) / 2 || 1;
                 this.joyStickControls.movementSpeed = this.controls.movementSpeed;
                 this.joyStickControls.multiplier = this.controls.multiplier;
             };
@@ -35228,27 +35238,27 @@ void main() {
         if (box.isEmpty())
             return;
         const boxCenter = box.getCenter(new Vector3());
-        const boxSize = box.getBoundingSphere(new Sphere()).radius;
+        const boxSize = box.getSize(new Vector3()).length() || 1;
         const rendererSize = viewer.renderer.getSize(new Vector2());
         const aspectRatio = rendererSize.x / rendererSize.y;
         const camera = viewer.camera;
         if (camera.isPerspectiveCamera) {
             const offset = new Vector3(0, 0, 1)
                 .applyQuaternion(camera.quaternion)
-                .multiplyScalar(boxSize / Math.tan(MathUtils.degToRad(camera.fov * 0.5)));
+                .multiplyScalar(boxSize / (2 * Math.tan(MathUtils.degToRad(camera.fov * 0.5))));
             camera.position.copy(offset).add(boxCenter);
             camera.updateMatrixWorld();
         }
         if (camera.isOrthographicCamera) {
-            camera.top = boxSize;
-            camera.bottom = -boxSize;
+            camera.top = boxSize / 2;
+            camera.bottom = -boxSize / 2;
             camera.left = camera.bottom * aspectRatio;
             camera.right = camera.top * aspectRatio;
             camera.zoom = 1;
             camera.updateProjectionMatrix();
             const offset = new Vector3(0, 0, 1)
                 .applyQuaternion(camera.quaternion)
-                .multiplyScalar(viewer.extents.getBoundingSphere(new Sphere()).radius * 3);
+                .multiplyScalar(viewer.extents.getSize(new Vector3()).length() || 1);
             camera.position.copy(offset).add(boxCenter);
             camera.updateMatrixWorld();
         }
@@ -35269,9 +35279,9 @@ void main() {
         ne: new Vector3(-1, 1, 1).normalize(),
         nw: new Vector3(1, 1, 1).normalize(),
     };
-    function setDefaultViewPosition(viewer, position) {
+    function setDefaultViewPosition(viewer, position = "sw") {
         const extentsCenter = viewer.extents.getCenter(new Vector3());
-        const extentsSize = viewer.extents.getBoundingSphere(new Sphere()).radius * 2;
+        const extentsSize = viewer.extents.getSize(new Vector3()).length() || 1;
         const upY = new Vector3(0, 1, 0);
         const offsetY = defaultViewPositions[position] || defaultViewPositions["sw"];
         const up = new Vector3().copy(viewer.camera.up);
@@ -35528,7 +35538,7 @@ void main() {
             return camera.isOrthographicCamera ? "orthographic" : "perspective";
         }
         switchCamera(camera) {
-            const extentsSize = this.viewer.extents.getBoundingSphere(new Sphere()).radius * 2 || 1;
+            const extentsSize = this.viewer.extents.getSize(new Vector3()).length() || 1;
             const rendererSize = this.viewer.renderer.getSize(new Vector2());
             const aspectRatio = rendererSize.x / rendererSize.y;
             if (camera.isPerspectiveCamera) {
@@ -35568,7 +35578,7 @@ void main() {
             if (currentCamera.isPerspectiveCamera) {
                 const fov = currentCamera.fov;
                 const distance = currentCamera.position.distanceTo(target);
-                const fieldHeight = 2 * Math.tan(MathUtils.degToRad(fov) / 2) * distance;
+                const fieldHeight = 2 * Math.tan(MathUtils.degToRad(fov * 0.5)) * distance;
                 camera = new OrthographicCamera();
                 camera.top = fieldHeight / 2;
                 camera.bottom = -fieldHeight / 2;
@@ -35626,7 +35636,7 @@ void main() {
                 if (this.viewer.extents.isEmpty())
                     return;
                 const extentsCenter = this.viewer.extents.getCenter(new Vector3());
-                const extentsSize = this.viewer.extents.getBoundingSphere(new Sphere()).radius;
+                const extentsSize = this.viewer.extents.getSize(new Vector3()).length() || 1;
                 const upY = new Vector3(0, 1, 0);
                 const frontY = new Vector3(0, 0, -1);
                 const up = new Vector3().copy(this.viewer.camera.up);
@@ -35635,17 +35645,14 @@ void main() {
                 this.directionalLight.position
                     .copy(up)
                     .applyAxisAngle(front, (-Math.PI * 30) / 180)
-                    .multiplyScalar(extentsSize * 2)
+                    .multiplyScalar(extentsSize)
                     .add(extentsCenter);
                 this.directionalLight.target.position.copy(extentsCenter);
-                this.frontLight.position
-                    .copy(front)
-                    .multiplyScalar(extentsSize * 2)
-                    .add(extentsCenter);
+                this.frontLight.position.copy(front).multiplyScalar(extentsSize).add(extentsCenter);
                 this.frontLight.target.position.copy(extentsCenter);
                 this.hemisphereLight.position
                     .copy(front)
-                    .multiplyScalar(extentsSize * 3)
+                    .multiplyScalar(extentsSize * 1.5)
                     .add(extentsCenter);
                 this.viewer.scene.add(this.ambientLight);
                 this.viewer.scene.add(this.directionalLight);
@@ -36690,8 +36697,9 @@ void main() {
                 const upPosition = this.getMousePosition(event, new Vector2());
                 if (upPosition.distanceTo(this.downPosition) !== 0)
                     return;
+                const extentsSize = this.viewer.extents.getSize(new Vector3()).length() || 1;
                 const snapper = new Snapper(this.viewer.camera, this.viewer.renderer, this.viewer.canvas);
-                snapper.threshold = this.viewer.extents.getSize(new Vector3()).length() / 10000;
+                snapper.threshold = extentsSize / 10000;
                 let intersections = [];
                 this.viewer.models.forEach((model) => {
                     const objects = model.getVisibleObjects();
@@ -37460,7 +37468,11 @@ void main() {
         this.criticalError = null;
       }
       async initialize(loader) {
-        this.json = await this.loadController.loadJson();
+        const json = await this.loadController.loadJson();
+        if (json.asset === undefined || json.asset.version[0] < 2) {
+          throw new Error("GltfStructure: Unsupported asset. glTF versions >=2.0 are supported.");
+        }
+        this.json = json;
         this.loader = loader;
         this.uri = this.json.buffers[0].uri || "";
       }
@@ -40105,48 +40117,1302 @@ void main() {
 
     const BINARY_EXTENSION_HEADER_MAGIC = "glTF";
     const BINARY_EXTENSION_HEADER_LENGTH = 12;
-    const BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4e4f534a, BIN: 0x004e4042 };
-    class GLTFBinaryExtension {
+    const BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4e4f534a, BIN: 0x004e4942 };
+    class GLTFBinaryParser {
         constructor(data) {
-            const headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH);
+            const dataView = new DataView(data, 0);
             const textDecoder = new TextDecoder();
-            const magic = textDecoder.decode(new Uint8Array(data.slice(0, 4)));
+            const magic = textDecoder.decode(new Uint8Array(data, 0, Math.min(4, data.byteLength)));
             if (magic !== BINARY_EXTENSION_HEADER_MAGIC) {
-                this.content = textDecoder.decode(data);
+                this.content = new Uint8Array(data);
                 return;
             }
-            const header = {
+            this.header = {
                 magic,
-                version: headerView.getUint32(4, true),
-                length: headerView.getUint32(8, true),
+                version: dataView.getUint32(4, true),
+                length: dataView.getUint32(8, true),
             };
-            if (header.magic !== BINARY_EXTENSION_HEADER_MAGIC) {
-                throw new Error("Unsupported glTF-Binary header.");
-            }
-            if (header.version < 2.0) {
-                throw new Error("Legacy binary file detected.");
-            }
-            const chunkContentsLength = header.length - BINARY_EXTENSION_HEADER_LENGTH;
-            const chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH);
-            let chunkIndex = 0;
-            while (chunkIndex < chunkContentsLength) {
-                const chunkLength = chunkView.getUint32(chunkIndex, true);
-                chunkIndex += 4;
-                const chunkType = chunkView.getUint32(chunkIndex, true);
-                chunkIndex += 4;
+            if (this.header.length !== data.byteLength) {
+                throw new Error("GLTFBinaryParser: Invalid binary file header.");
+            }
+            if (this.header.version < 2.0) {
+                throw new Error("GLTFBinaryParser: Legacy binary file detected.");
+            }
+            let offset = BINARY_EXTENSION_HEADER_LENGTH;
+            while (offset < this.header.length) {
+                const chunkLength = dataView.getUint32(offset, true);
+                offset += 4;
+                const chunkType = dataView.getUint32(offset, true);
+                offset += 4;
                 if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
-                    const contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength);
-                    this.content = textDecoder.decode(contentArray);
+                    this.content = new Uint8Array(data, offset, chunkLength);
                 }
                 else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
-                    const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
-                    this.body = data.slice(byteOffset, byteOffset + chunkLength);
+                    this.body = data.slice(offset, offset + chunkLength);
                 }
-                chunkIndex += chunkLength;
+                offset += chunkLength;
             }
             if (typeof this.content === "undefined") {
-                throw new Error("JSON content not found.");
+                throw new Error("GLTFBinaryParser: JSON content not found.");
+            }
+            if (typeof this.body === "undefined") {
+                throw new Error("GLTFBinaryParser: Binary buffer chunk not found or type not supported.");
+            }
+        }
+    }
+
+    var charset;
+    (function (charset) {
+        charset[charset["BACKSPACE"] = 8] = "BACKSPACE";
+        charset[charset["FORM_FEED"] = 12] = "FORM_FEED";
+        charset[charset["NEWLINE"] = 10] = "NEWLINE";
+        charset[charset["CARRIAGE_RETURN"] = 13] = "CARRIAGE_RETURN";
+        charset[charset["TAB"] = 9] = "TAB";
+        charset[charset["SPACE"] = 32] = "SPACE";
+        charset[charset["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK";
+        charset[charset["QUOTATION_MARK"] = 34] = "QUOTATION_MARK";
+        charset[charset["NUMBER_SIGN"] = 35] = "NUMBER_SIGN";
+        charset[charset["DOLLAR_SIGN"] = 36] = "DOLLAR_SIGN";
+        charset[charset["PERCENT_SIGN"] = 37] = "PERCENT_SIGN";
+        charset[charset["AMPERSAND"] = 38] = "AMPERSAND";
+        charset[charset["APOSTROPHE"] = 39] = "APOSTROPHE";
+        charset[charset["LEFT_PARENTHESIS"] = 40] = "LEFT_PARENTHESIS";
+        charset[charset["RIGHT_PARENTHESIS"] = 41] = "RIGHT_PARENTHESIS";
+        charset[charset["ASTERISK"] = 42] = "ASTERISK";
+        charset[charset["PLUS_SIGN"] = 43] = "PLUS_SIGN";
+        charset[charset["COMMA"] = 44] = "COMMA";
+        charset[charset["HYPHEN_MINUS"] = 45] = "HYPHEN_MINUS";
+        charset[charset["FULL_STOP"] = 46] = "FULL_STOP";
+        charset[charset["SOLIDUS"] = 47] = "SOLIDUS";
+        charset[charset["DIGIT_ZERO"] = 48] = "DIGIT_ZERO";
+        charset[charset["DIGIT_ONE"] = 49] = "DIGIT_ONE";
+        charset[charset["DIGIT_TWO"] = 50] = "DIGIT_TWO";
+        charset[charset["DIGIT_THREE"] = 51] = "DIGIT_THREE";
+        charset[charset["DIGIT_FOUR"] = 52] = "DIGIT_FOUR";
+        charset[charset["DIGIT_FIVE"] = 53] = "DIGIT_FIVE";
+        charset[charset["DIGIT_SIX"] = 54] = "DIGIT_SIX";
+        charset[charset["DIGIT_SEVEN"] = 55] = "DIGIT_SEVEN";
+        charset[charset["DIGIT_EIGHT"] = 56] = "DIGIT_EIGHT";
+        charset[charset["DIGIT_NINE"] = 57] = "DIGIT_NINE";
+        charset[charset["COLON"] = 58] = "COLON";
+        charset[charset["SEMICOLON"] = 59] = "SEMICOLON";
+        charset[charset["LESS_THAN_SIGN"] = 60] = "LESS_THAN_SIGN";
+        charset[charset["EQUALS_SIGN"] = 61] = "EQUALS_SIGN";
+        charset[charset["GREATER_THAN_SIGN"] = 62] = "GREATER_THAN_SIGN";
+        charset[charset["QUESTION_MARK"] = 63] = "QUESTION_MARK";
+        charset[charset["COMMERCIAL_AT"] = 64] = "COMMERCIAL_AT";
+        charset[charset["LATIN_CAPITAL_LETTER_A"] = 65] = "LATIN_CAPITAL_LETTER_A";
+        charset[charset["LATIN_CAPITAL_LETTER_B"] = 66] = "LATIN_CAPITAL_LETTER_B";
+        charset[charset["LATIN_CAPITAL_LETTER_C"] = 67] = "LATIN_CAPITAL_LETTER_C";
+        charset[charset["LATIN_CAPITAL_LETTER_D"] = 68] = "LATIN_CAPITAL_LETTER_D";
+        charset[charset["LATIN_CAPITAL_LETTER_E"] = 69] = "LATIN_CAPITAL_LETTER_E";
+        charset[charset["LATIN_CAPITAL_LETTER_F"] = 70] = "LATIN_CAPITAL_LETTER_F";
+        charset[charset["LATIN_CAPITAL_LETTER_G"] = 71] = "LATIN_CAPITAL_LETTER_G";
+        charset[charset["LATIN_CAPITAL_LETTER_H"] = 72] = "LATIN_CAPITAL_LETTER_H";
+        charset[charset["LATIN_CAPITAL_LETTER_I"] = 73] = "LATIN_CAPITAL_LETTER_I";
+        charset[charset["LATIN_CAPITAL_LETTER_J"] = 74] = "LATIN_CAPITAL_LETTER_J";
+        charset[charset["LATIN_CAPITAL_LETTER_K"] = 75] = "LATIN_CAPITAL_LETTER_K";
+        charset[charset["LATIN_CAPITAL_LETTER_L"] = 76] = "LATIN_CAPITAL_LETTER_L";
+        charset[charset["LATIN_CAPITAL_LETTER_M"] = 77] = "LATIN_CAPITAL_LETTER_M";
+        charset[charset["LATIN_CAPITAL_LETTER_N"] = 78] = "LATIN_CAPITAL_LETTER_N";
+        charset[charset["LATIN_CAPITAL_LETTER_O"] = 79] = "LATIN_CAPITAL_LETTER_O";
+        charset[charset["LATIN_CAPITAL_LETTER_P"] = 80] = "LATIN_CAPITAL_LETTER_P";
+        charset[charset["LATIN_CAPITAL_LETTER_Q"] = 81] = "LATIN_CAPITAL_LETTER_Q";
+        charset[charset["LATIN_CAPITAL_LETTER_R"] = 82] = "LATIN_CAPITAL_LETTER_R";
+        charset[charset["LATIN_CAPITAL_LETTER_S"] = 83] = "LATIN_CAPITAL_LETTER_S";
+        charset[charset["LATIN_CAPITAL_LETTER_T"] = 84] = "LATIN_CAPITAL_LETTER_T";
+        charset[charset["LATIN_CAPITAL_LETTER_U"] = 85] = "LATIN_CAPITAL_LETTER_U";
+        charset[charset["LATIN_CAPITAL_LETTER_V"] = 86] = "LATIN_CAPITAL_LETTER_V";
+        charset[charset["LATIN_CAPITAL_LETTER_W"] = 87] = "LATIN_CAPITAL_LETTER_W";
+        charset[charset["LATIN_CAPITAL_LETTER_X"] = 88] = "LATIN_CAPITAL_LETTER_X";
+        charset[charset["LATIN_CAPITAL_LETTER_Y"] = 89] = "LATIN_CAPITAL_LETTER_Y";
+        charset[charset["LATIN_CAPITAL_LETTER_Z"] = 90] = "LATIN_CAPITAL_LETTER_Z";
+        charset[charset["LEFT_SQUARE_BRACKET"] = 91] = "LEFT_SQUARE_BRACKET";
+        charset[charset["REVERSE_SOLIDUS"] = 92] = "REVERSE_SOLIDUS";
+        charset[charset["RIGHT_SQUARE_BRACKET"] = 93] = "RIGHT_SQUARE_BRACKET";
+        charset[charset["CIRCUMFLEX_ACCENT"] = 94] = "CIRCUMFLEX_ACCENT";
+        charset[charset["LOW_LINE"] = 95] = "LOW_LINE";
+        charset[charset["GRAVE_ACCENT"] = 96] = "GRAVE_ACCENT";
+        charset[charset["LATIN_SMALL_LETTER_A"] = 97] = "LATIN_SMALL_LETTER_A";
+        charset[charset["LATIN_SMALL_LETTER_B"] = 98] = "LATIN_SMALL_LETTER_B";
+        charset[charset["LATIN_SMALL_LETTER_C"] = 99] = "LATIN_SMALL_LETTER_C";
+        charset[charset["LATIN_SMALL_LETTER_D"] = 100] = "LATIN_SMALL_LETTER_D";
+        charset[charset["LATIN_SMALL_LETTER_E"] = 101] = "LATIN_SMALL_LETTER_E";
+        charset[charset["LATIN_SMALL_LETTER_F"] = 102] = "LATIN_SMALL_LETTER_F";
+        charset[charset["LATIN_SMALL_LETTER_G"] = 103] = "LATIN_SMALL_LETTER_G";
+        charset[charset["LATIN_SMALL_LETTER_H"] = 104] = "LATIN_SMALL_LETTER_H";
+        charset[charset["LATIN_SMALL_LETTER_I"] = 105] = "LATIN_SMALL_LETTER_I";
+        charset[charset["LATIN_SMALL_LETTER_J"] = 106] = "LATIN_SMALL_LETTER_J";
+        charset[charset["LATIN_SMALL_LETTER_K"] = 107] = "LATIN_SMALL_LETTER_K";
+        charset[charset["LATIN_SMALL_LETTER_L"] = 108] = "LATIN_SMALL_LETTER_L";
+        charset[charset["LATIN_SMALL_LETTER_M"] = 109] = "LATIN_SMALL_LETTER_M";
+        charset[charset["LATIN_SMALL_LETTER_N"] = 110] = "LATIN_SMALL_LETTER_N";
+        charset[charset["LATIN_SMALL_LETTER_O"] = 111] = "LATIN_SMALL_LETTER_O";
+        charset[charset["LATIN_SMALL_LETTER_P"] = 112] = "LATIN_SMALL_LETTER_P";
+        charset[charset["LATIN_SMALL_LETTER_Q"] = 113] = "LATIN_SMALL_LETTER_Q";
+        charset[charset["LATIN_SMALL_LETTER_R"] = 114] = "LATIN_SMALL_LETTER_R";
+        charset[charset["LATIN_SMALL_LETTER_S"] = 115] = "LATIN_SMALL_LETTER_S";
+        charset[charset["LATIN_SMALL_LETTER_T"] = 116] = "LATIN_SMALL_LETTER_T";
+        charset[charset["LATIN_SMALL_LETTER_U"] = 117] = "LATIN_SMALL_LETTER_U";
+        charset[charset["LATIN_SMALL_LETTER_V"] = 118] = "LATIN_SMALL_LETTER_V";
+        charset[charset["LATIN_SMALL_LETTER_W"] = 119] = "LATIN_SMALL_LETTER_W";
+        charset[charset["LATIN_SMALL_LETTER_X"] = 120] = "LATIN_SMALL_LETTER_X";
+        charset[charset["LATIN_SMALL_LETTER_Y"] = 121] = "LATIN_SMALL_LETTER_Y";
+        charset[charset["LATIN_SMALL_LETTER_Z"] = 122] = "LATIN_SMALL_LETTER_Z";
+        charset[charset["LEFT_CURLY_BRACKET"] = 123] = "LEFT_CURLY_BRACKET";
+        charset[charset["VERTICAL_LINE"] = 124] = "VERTICAL_LINE";
+        charset[charset["RIGHT_CURLY_BRACKET"] = 125] = "RIGHT_CURLY_BRACKET";
+        charset[charset["TILDE"] = 126] = "TILDE";
+    })(charset || (charset = {}));
+    const escapedSequences = {
+        [charset.QUOTATION_MARK]: charset.QUOTATION_MARK,
+        [charset.REVERSE_SOLIDUS]: charset.REVERSE_SOLIDUS,
+        [charset.SOLIDUS]: charset.SOLIDUS,
+        [charset.LATIN_SMALL_LETTER_B]: charset.BACKSPACE,
+        [charset.LATIN_SMALL_LETTER_F]: charset.FORM_FEED,
+        [charset.LATIN_SMALL_LETTER_N]: charset.NEWLINE,
+        [charset.LATIN_SMALL_LETTER_R]: charset.CARRIAGE_RETURN,
+        [charset.LATIN_SMALL_LETTER_T]: charset.TAB,
+    };
+
+    class NonBufferedString {
+        constructor() {
+            this.decoder = new TextDecoder("utf-8");
+            this.strings = [];
+            this.byteLength = 0;
+        }
+        appendChar(char) {
+            this.strings.push(String.fromCharCode(char));
+            this.byteLength += 1;
+        }
+        appendBuf(buf, start = 0, end = buf.length) {
+            this.strings.push(this.decoder.decode(buf.subarray(start, end)));
+            this.byteLength += end - start;
+        }
+        reset() {
+            this.strings = [];
+            this.byteLength = 0;
+        }
+        toString() {
+            return this.strings.join("");
+        }
+    }
+    class BufferedString {
+        constructor(bufferSize) {
+            this.decoder = new TextDecoder("utf-8");
+            this.bufferOffset = 0;
+            this.string = "";
+            this.byteLength = 0;
+            this.buffer = new Uint8Array(bufferSize);
+        }
+        appendChar(char) {
+            if (this.bufferOffset >= this.buffer.length)
+                this.flushStringBuffer();
+            this.buffer[this.bufferOffset++] = char;
+            this.byteLength += 1;
+        }
+        appendBuf(buf, start = 0, end = buf.length) {
+            const size = end - start;
+            if (this.bufferOffset + size > this.buffer.length)
+                this.flushStringBuffer();
+            this.buffer.set(buf.subarray(start, end), this.bufferOffset);
+            this.bufferOffset += size;
+            this.byteLength += size;
+        }
+        flushStringBuffer() {
+            this.string += this.decoder.decode(this.buffer.subarray(0, this.bufferOffset));
+            this.bufferOffset = 0;
+        }
+        reset() {
+            this.string = "";
+            this.bufferOffset = 0;
+            this.byteLength = 0;
+        }
+        toString() {
+            this.flushStringBuffer();
+            return this.string;
+        }
+    }
+
+    var TokenType$1;
+    (function (TokenType) {
+        TokenType[TokenType["LEFT_BRACE"] = 0] = "LEFT_BRACE";
+        TokenType[TokenType["RIGHT_BRACE"] = 1] = "RIGHT_BRACE";
+        TokenType[TokenType["LEFT_BRACKET"] = 2] = "LEFT_BRACKET";
+        TokenType[TokenType["RIGHT_BRACKET"] = 3] = "RIGHT_BRACKET";
+        TokenType[TokenType["COLON"] = 4] = "COLON";
+        TokenType[TokenType["COMMA"] = 5] = "COMMA";
+        TokenType[TokenType["TRUE"] = 6] = "TRUE";
+        TokenType[TokenType["FALSE"] = 7] = "FALSE";
+        TokenType[TokenType["NULL"] = 8] = "NULL";
+        TokenType[TokenType["STRING"] = 9] = "STRING";
+        TokenType[TokenType["NUMBER"] = 10] = "NUMBER";
+        TokenType[TokenType["SEPARATOR"] = 11] = "SEPARATOR";
+    })(TokenType$1 || (TokenType$1 = {}));
+    var TokenType = TokenType$1;
+
+    var TokenizerStates;
+    (function (TokenizerStates) {
+        TokenizerStates[TokenizerStates["START"] = 0] = "START";
+        TokenizerStates[TokenizerStates["ENDED"] = 1] = "ENDED";
+        TokenizerStates[TokenizerStates["ERROR"] = 2] = "ERROR";
+        TokenizerStates[TokenizerStates["TRUE1"] = 3] = "TRUE1";
+        TokenizerStates[TokenizerStates["TRUE2"] = 4] = "TRUE2";
+        TokenizerStates[TokenizerStates["TRUE3"] = 5] = "TRUE3";
+        TokenizerStates[TokenizerStates["FALSE1"] = 6] = "FALSE1";
+        TokenizerStates[TokenizerStates["FALSE2"] = 7] = "FALSE2";
+        TokenizerStates[TokenizerStates["FALSE3"] = 8] = "FALSE3";
+        TokenizerStates[TokenizerStates["FALSE4"] = 9] = "FALSE4";
+        TokenizerStates[TokenizerStates["NULL1"] = 10] = "NULL1";
+        TokenizerStates[TokenizerStates["NULL2"] = 11] = "NULL2";
+        TokenizerStates[TokenizerStates["NULL3"] = 12] = "NULL3";
+        TokenizerStates[TokenizerStates["STRING_DEFAULT"] = 13] = "STRING_DEFAULT";
+        TokenizerStates[TokenizerStates["STRING_AFTER_BACKSLASH"] = 14] = "STRING_AFTER_BACKSLASH";
+        TokenizerStates[TokenizerStates["STRING_UNICODE_DIGIT_1"] = 15] = "STRING_UNICODE_DIGIT_1";
+        TokenizerStates[TokenizerStates["STRING_UNICODE_DIGIT_2"] = 16] = "STRING_UNICODE_DIGIT_2";
+        TokenizerStates[TokenizerStates["STRING_UNICODE_DIGIT_3"] = 17] = "STRING_UNICODE_DIGIT_3";
+        TokenizerStates[TokenizerStates["STRING_UNICODE_DIGIT_4"] = 18] = "STRING_UNICODE_DIGIT_4";
+        TokenizerStates[TokenizerStates["STRING_INCOMPLETE_CHAR"] = 19] = "STRING_INCOMPLETE_CHAR";
+        TokenizerStates[TokenizerStates["NUMBER_AFTER_INITIAL_MINUS"] = 20] = "NUMBER_AFTER_INITIAL_MINUS";
+        TokenizerStates[TokenizerStates["NUMBER_AFTER_INITIAL_ZERO"] = 21] = "NUMBER_AFTER_INITIAL_ZERO";
+        TokenizerStates[TokenizerStates["NUMBER_AFTER_INITIAL_NON_ZERO"] = 22] = "NUMBER_AFTER_INITIAL_NON_ZERO";
+        TokenizerStates[TokenizerStates["NUMBER_AFTER_FULL_STOP"] = 23] = "NUMBER_AFTER_FULL_STOP";
+        TokenizerStates[TokenizerStates["NUMBER_AFTER_DECIMAL"] = 24] = "NUMBER_AFTER_DECIMAL";
+        TokenizerStates[TokenizerStates["NUMBER_AFTER_E"] = 25] = "NUMBER_AFTER_E";
+        TokenizerStates[TokenizerStates["NUMBER_AFTER_E_AND_SIGN"] = 26] = "NUMBER_AFTER_E_AND_SIGN";
+        TokenizerStates[TokenizerStates["NUMBER_AFTER_E_AND_DIGIT"] = 27] = "NUMBER_AFTER_E_AND_DIGIT";
+        TokenizerStates[TokenizerStates["SEPARATOR"] = 28] = "SEPARATOR";
+        TokenizerStates[TokenizerStates["BOM_OR_START"] = 29] = "BOM_OR_START";
+        TokenizerStates[TokenizerStates["BOM"] = 30] = "BOM";
+    })(TokenizerStates || (TokenizerStates = {}));
+    function TokenizerStateToString(tokenizerState) {
+        return [
+            "START",
+            "ENDED",
+            "ERROR",
+            "TRUE1",
+            "TRUE2",
+            "TRUE3",
+            "FALSE1",
+            "FALSE2",
+            "FALSE3",
+            "FALSE4",
+            "NULL1",
+            "NULL2",
+            "NULL3",
+            "STRING_DEFAULT",
+            "STRING_AFTER_BACKSLASH",
+            "STRING_UNICODE_DIGIT_1",
+            "STRING_UNICODE_DIGIT_2",
+            "STRING_UNICODE_DIGIT_3",
+            "STRING_UNICODE_DIGIT_4",
+            "STRING_INCOMPLETE_CHAR",
+            "NUMBER_AFTER_INITIAL_MINUS",
+            "NUMBER_AFTER_INITIAL_ZERO",
+            "NUMBER_AFTER_INITIAL_NON_ZERO",
+            "NUMBER_AFTER_FULL_STOP",
+            "NUMBER_AFTER_DECIMAL",
+            "NUMBER_AFTER_E",
+            "NUMBER_AFTER_E_AND_SIGN",
+            "NUMBER_AFTER_E_AND_DIGIT",
+            "SEPARATOR",
+            "BOM_OR_START",
+            "BOM",
+        ][tokenizerState];
+    }
+    const defaultOpts$1 = {
+        stringBufferSize: 0,
+        numberBufferSize: 0,
+        separator: undefined,
+        emitPartialTokens: false,
+    };
+    class TokenizerError extends Error {
+        constructor(message) {
+            super(message);
+            Object.setPrototypeOf(this, TokenizerError.prototype);
+        }
+    }
+    class Tokenizer {
+        constructor(opts) {
+            this.state = TokenizerStates.BOM_OR_START;
+            this.bomIndex = 0;
+            this.separatorIndex = 0;
+            this.escapedCharsByteLength = 0;
+            this.bytes_remaining = 0;
+            this.bytes_in_sequence = 0;
+            this.char_split_buffer = new Uint8Array(4);
+            this.encoder = new TextEncoder();
+            this.offset = -1;
+            opts = Object.assign(Object.assign({}, defaultOpts$1), opts);
+            this.emitPartialTokens = opts.emitPartialTokens === true;
+            this.bufferedString =
+                opts.stringBufferSize && opts.stringBufferSize > 4
+                    ? new BufferedString(opts.stringBufferSize)
+                    : new NonBufferedString();
+            this.bufferedNumber =
+                opts.numberBufferSize && opts.numberBufferSize > 0
+                    ? new BufferedString(opts.numberBufferSize)
+                    : new NonBufferedString();
+            this.separator = opts.separator;
+            this.separatorBytes = opts.separator
+                ? this.encoder.encode(opts.separator)
+                : undefined;
+        }
+        get isEnded() {
+            return this.state === TokenizerStates.ENDED;
+        }
+        write(input) {
+            try {
+                let buffer;
+                if (input instanceof Uint8Array) {
+                    buffer = input;
+                }
+                else if (typeof input === "string") {
+                    buffer = this.encoder.encode(input);
+                }
+                else if (Array.isArray(input)) {
+                    buffer = Uint8Array.from(input);
+                }
+                else if (ArrayBuffer.isView(input)) {
+                    buffer = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+                }
+                else {
+                    throw new TypeError("Unexpected type. The `write` function only accepts Arrays, TypedArrays and Strings.");
+                }
+                for (let i = 0; i < buffer.length; i += 1) {
+                    const n = buffer[i];
+                    switch (this.state) {
+                        case TokenizerStates.BOM_OR_START:
+                            if (input instanceof Uint8Array && n === 0xef) {
+                                this.bom = [0xef, 0xbb, 0xbf];
+                                this.bomIndex += 1;
+                                this.state = TokenizerStates.BOM;
+                                continue;
+                            }
+                            if (input instanceof Uint16Array) {
+                                if (n === 0xfe) {
+                                    this.bom = [0xfe, 0xff];
+                                    this.bomIndex += 1;
+                                    this.state = TokenizerStates.BOM;
+                                    continue;
+                                }
+                                if (n === 0xff) {
+                                    this.bom = [0xff, 0xfe];
+                                    this.bomIndex += 1;
+                                    this.state = TokenizerStates.BOM;
+                                    continue;
+                                }
+                            }
+                            if (input instanceof Uint32Array) {
+                                if (n === 0x00) {
+                                    this.bom = [0x00, 0x00, 0xfe, 0xff];
+                                    this.bomIndex += 1;
+                                    this.state = TokenizerStates.BOM;
+                                    continue;
+                                }
+                                if (n === 0xff) {
+                                    this.bom = [0xff, 0xfe, 0x00, 0x00];
+                                    this.bomIndex += 1;
+                                    this.state = TokenizerStates.BOM;
+                                    continue;
+                                }
+                            }
+                        case TokenizerStates.START:
+                            this.offset += 1;
+                            if (this.separatorBytes && n === this.separatorBytes[0]) {
+                                if (this.separatorBytes.length === 1) {
+                                    this.state = TokenizerStates.START;
+                                    this.onToken({
+                                        token: TokenType.SEPARATOR,
+                                        value: this.separator,
+                                        offset: this.offset + this.separatorBytes.length - 1,
+                                    });
+                                    continue;
+                                }
+                                this.state = TokenizerStates.SEPARATOR;
+                                continue;
+                            }
+                            if (n === charset.SPACE ||
+                                n === charset.NEWLINE ||
+                                n === charset.CARRIAGE_RETURN ||
+                                n === charset.TAB) {
+                                continue;
+                            }
+                            if (n === charset.LEFT_CURLY_BRACKET) {
+                                this.onToken({
+                                    token: TokenType.LEFT_BRACE,
+                                    value: "{",
+                                    offset: this.offset,
+                                });
+                                continue;
+                            }
+                            if (n === charset.RIGHT_CURLY_BRACKET) {
+                                this.onToken({
+                                    token: TokenType.RIGHT_BRACE,
+                                    value: "}",
+                                    offset: this.offset,
+                                });
+                                continue;
+                            }
+                            if (n === charset.LEFT_SQUARE_BRACKET) {
+                                this.onToken({
+                                    token: TokenType.LEFT_BRACKET,
+                                    value: "[",
+                                    offset: this.offset,
+                                });
+                                continue;
+                            }
+                            if (n === charset.RIGHT_SQUARE_BRACKET) {
+                                this.onToken({
+                                    token: TokenType.RIGHT_BRACKET,
+                                    value: "]",
+                                    offset: this.offset,
+                                });
+                                continue;
+                            }
+                            if (n === charset.COLON) {
+                                this.onToken({
+                                    token: TokenType.COLON,
+                                    value: ":",
+                                    offset: this.offset,
+                                });
+                                continue;
+                            }
+                            if (n === charset.COMMA) {
+                                this.onToken({
+                                    token: TokenType.COMMA,
+                                    value: ",",
+                                    offset: this.offset,
+                                });
+                                continue;
+                            }
+                            if (n === charset.LATIN_SMALL_LETTER_T) {
+                                this.state = TokenizerStates.TRUE1;
+                                continue;
+                            }
+                            if (n === charset.LATIN_SMALL_LETTER_F) {
+                                this.state = TokenizerStates.FALSE1;
+                                continue;
+                            }
+                            if (n === charset.LATIN_SMALL_LETTER_N) {
+                                this.state = TokenizerStates.NULL1;
+                                continue;
+                            }
+                            if (n === charset.QUOTATION_MARK) {
+                                this.bufferedString.reset();
+                                this.escapedCharsByteLength = 0;
+                                this.state = TokenizerStates.STRING_DEFAULT;
+                                continue;
+                            }
+                            if (n >= charset.DIGIT_ONE && n <= charset.DIGIT_NINE) {
+                                this.bufferedNumber.reset();
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO;
+                                continue;
+                            }
+                            if (n === charset.DIGIT_ZERO) {
+                                this.bufferedNumber.reset();
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_INITIAL_ZERO;
+                                continue;
+                            }
+                            if (n === charset.HYPHEN_MINUS) {
+                                this.bufferedNumber.reset();
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_INITIAL_MINUS;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.STRING_DEFAULT:
+                            if (n === charset.QUOTATION_MARK) {
+                                const string = this.bufferedString.toString();
+                                this.state = TokenizerStates.START;
+                                this.onToken({
+                                    token: TokenType.STRING,
+                                    value: string,
+                                    offset: this.offset,
+                                });
+                                this.offset +=
+                                    this.escapedCharsByteLength +
+                                        this.bufferedString.byteLength +
+                                        1;
+                                continue;
+                            }
+                            if (n === charset.REVERSE_SOLIDUS) {
+                                this.state = TokenizerStates.STRING_AFTER_BACKSLASH;
+                                continue;
+                            }
+                            if (n >= 128) {
+                                if (n >= 194 && n <= 223) {
+                                    this.bytes_in_sequence = 2;
+                                }
+                                else if (n <= 239) {
+                                    this.bytes_in_sequence = 3;
+                                }
+                                else {
+                                    this.bytes_in_sequence = 4;
+                                }
+                                if (this.bytes_in_sequence <= buffer.length - i) {
+                                    this.bufferedString.appendBuf(buffer, i, i + this.bytes_in_sequence);
+                                    i += this.bytes_in_sequence - 1;
+                                    continue;
+                                }
+                                this.bytes_remaining = i + this.bytes_in_sequence - buffer.length;
+                                this.char_split_buffer.set(buffer.subarray(i));
+                                i = buffer.length - 1;
+                                this.state = TokenizerStates.STRING_INCOMPLETE_CHAR;
+                                continue;
+                            }
+                            if (n >= charset.SPACE) {
+                                this.bufferedString.appendChar(n);
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.STRING_INCOMPLETE_CHAR:
+                            this.char_split_buffer.set(buffer.subarray(i, i + this.bytes_remaining), this.bytes_in_sequence - this.bytes_remaining);
+                            this.bufferedString.appendBuf(this.char_split_buffer, 0, this.bytes_in_sequence);
+                            i = this.bytes_remaining - 1;
+                            this.state = TokenizerStates.STRING_DEFAULT;
+                            continue;
+                        case TokenizerStates.STRING_AFTER_BACKSLASH:
+                            const controlChar = escapedSequences[n];
+                            if (controlChar) {
+                                this.bufferedString.appendChar(controlChar);
+                                this.escapedCharsByteLength += 1;
+                                this.state = TokenizerStates.STRING_DEFAULT;
+                                continue;
+                            }
+                            if (n === charset.LATIN_SMALL_LETTER_U) {
+                                this.unicode = "";
+                                this.state = TokenizerStates.STRING_UNICODE_DIGIT_1;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.STRING_UNICODE_DIGIT_1:
+                        case TokenizerStates.STRING_UNICODE_DIGIT_2:
+                        case TokenizerStates.STRING_UNICODE_DIGIT_3:
+                            if ((n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) ||
+                                (n >= charset.LATIN_CAPITAL_LETTER_A &&
+                                    n <= charset.LATIN_CAPITAL_LETTER_F) ||
+                                (n >= charset.LATIN_SMALL_LETTER_A &&
+                                    n <= charset.LATIN_SMALL_LETTER_F)) {
+                                this.unicode += String.fromCharCode(n);
+                                this.state += 1;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.STRING_UNICODE_DIGIT_4:
+                            if ((n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) ||
+                                (n >= charset.LATIN_CAPITAL_LETTER_A &&
+                                    n <= charset.LATIN_CAPITAL_LETTER_F) ||
+                                (n >= charset.LATIN_SMALL_LETTER_A &&
+                                    n <= charset.LATIN_SMALL_LETTER_F)) {
+                                const intVal = parseInt(this.unicode + String.fromCharCode(n), 16);
+                                let unicodeString;
+                                if (this.highSurrogate === undefined) {
+                                    if (intVal >= 0xd800 && intVal <= 0xdbff) {
+                                        this.highSurrogate = intVal;
+                                        this.state = TokenizerStates.STRING_DEFAULT;
+                                        continue;
+                                    }
+                                    else {
+                                        unicodeString = String.fromCharCode(intVal);
+                                    }
+                                }
+                                else {
+                                    if (intVal >= 0xdc00 && intVal <= 0xdfff) {
+                                        unicodeString = String.fromCharCode(this.highSurrogate, intVal);
+                                    }
+                                    else {
+                                        unicodeString = String.fromCharCode(this.highSurrogate);
+                                    }
+                                    this.highSurrogate = undefined;
+                                }
+                                const unicodeBuffer = this.encoder.encode(unicodeString);
+                                this.bufferedString.appendBuf(unicodeBuffer);
+                                this.escapedCharsByteLength += 6 - unicodeBuffer.byteLength;
+                                this.state = TokenizerStates.STRING_DEFAULT;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.NUMBER_AFTER_INITIAL_MINUS:
+                            if (n === charset.DIGIT_ZERO) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_INITIAL_ZERO;
+                                continue;
+                            }
+                            if (n >= charset.DIGIT_ONE && n <= charset.DIGIT_NINE) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.NUMBER_AFTER_INITIAL_ZERO:
+                            if (n === charset.FULL_STOP) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_FULL_STOP;
+                                continue;
+                            }
+                            if (n === charset.LATIN_SMALL_LETTER_E ||
+                                n === charset.LATIN_CAPITAL_LETTER_E) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_E;
+                                continue;
+                            }
+                            i -= 1;
+                            this.state = TokenizerStates.START;
+                            this.emitNumber();
+                            continue;
+                        case TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO:
+                            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
+                                this.bufferedNumber.appendChar(n);
+                                continue;
+                            }
+                            if (n === charset.FULL_STOP) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_FULL_STOP;
+                                continue;
+                            }
+                            if (n === charset.LATIN_SMALL_LETTER_E ||
+                                n === charset.LATIN_CAPITAL_LETTER_E) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_E;
+                                continue;
+                            }
+                            i -= 1;
+                            this.state = TokenizerStates.START;
+                            this.emitNumber();
+                            continue;
+                        case TokenizerStates.NUMBER_AFTER_FULL_STOP:
+                            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_DECIMAL;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.NUMBER_AFTER_DECIMAL:
+                            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
+                                this.bufferedNumber.appendChar(n);
+                                continue;
+                            }
+                            if (n === charset.LATIN_SMALL_LETTER_E ||
+                                n === charset.LATIN_CAPITAL_LETTER_E) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_E;
+                                continue;
+                            }
+                            i -= 1;
+                            this.state = TokenizerStates.START;
+                            this.emitNumber();
+                            continue;
+                        case TokenizerStates.NUMBER_AFTER_E:
+                            if (n === charset.PLUS_SIGN || n === charset.HYPHEN_MINUS) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_E_AND_SIGN;
+                                continue;
+                            }
+                        case TokenizerStates.NUMBER_AFTER_E_AND_SIGN:
+                            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
+                                this.bufferedNumber.appendChar(n);
+                                this.state = TokenizerStates.NUMBER_AFTER_E_AND_DIGIT;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.NUMBER_AFTER_E_AND_DIGIT:
+                            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
+                                this.bufferedNumber.appendChar(n);
+                                continue;
+                            }
+                            i -= 1;
+                            this.state = TokenizerStates.START;
+                            this.emitNumber();
+                            continue;
+                        case TokenizerStates.TRUE1:
+                            if (n === charset.LATIN_SMALL_LETTER_R) {
+                                this.state = TokenizerStates.TRUE2;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.TRUE2:
+                            if (n === charset.LATIN_SMALL_LETTER_U) {
+                                this.state = TokenizerStates.TRUE3;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.TRUE3:
+                            if (n === charset.LATIN_SMALL_LETTER_E) {
+                                this.state = TokenizerStates.START;
+                                this.onToken({
+                                    token: TokenType.TRUE,
+                                    value: true,
+                                    offset: this.offset,
+                                });
+                                this.offset += 3;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.FALSE1:
+                            if (n === charset.LATIN_SMALL_LETTER_A) {
+                                this.state = TokenizerStates.FALSE2;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.FALSE2:
+                            if (n === charset.LATIN_SMALL_LETTER_L) {
+                                this.state = TokenizerStates.FALSE3;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.FALSE3:
+                            if (n === charset.LATIN_SMALL_LETTER_S) {
+                                this.state = TokenizerStates.FALSE4;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.FALSE4:
+                            if (n === charset.LATIN_SMALL_LETTER_E) {
+                                this.state = TokenizerStates.START;
+                                this.onToken({
+                                    token: TokenType.FALSE,
+                                    value: false,
+                                    offset: this.offset,
+                                });
+                                this.offset += 4;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.NULL1:
+                            if (n === charset.LATIN_SMALL_LETTER_U) {
+                                this.state = TokenizerStates.NULL2;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.NULL2:
+                            if (n === charset.LATIN_SMALL_LETTER_L) {
+                                this.state = TokenizerStates.NULL3;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.NULL3:
+                            if (n === charset.LATIN_SMALL_LETTER_L) {
+                                this.state = TokenizerStates.START;
+                                this.onToken({
+                                    token: TokenType.NULL,
+                                    value: null,
+                                    offset: this.offset,
+                                });
+                                this.offset += 3;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.SEPARATOR:
+                            this.separatorIndex += 1;
+                            if (!this.separatorBytes ||
+                                n !== this.separatorBytes[this.separatorIndex]) {
+                                break;
+                            }
+                            if (this.separatorIndex === this.separatorBytes.length - 1) {
+                                this.state = TokenizerStates.START;
+                                this.onToken({
+                                    token: TokenType.SEPARATOR,
+                                    value: this.separator,
+                                    offset: this.offset + this.separatorIndex,
+                                });
+                                this.separatorIndex = 0;
+                            }
+                            continue;
+                        case TokenizerStates.BOM:
+                            if (n === this.bom[this.bomIndex]) {
+                                if (this.bomIndex === this.bom.length - 1) {
+                                    this.state = TokenizerStates.START;
+                                    this.bom = undefined;
+                                    this.bomIndex = 0;
+                                    continue;
+                                }
+                                this.bomIndex += 1;
+                                continue;
+                            }
+                            break;
+                        case TokenizerStates.ENDED:
+                            if (n === charset.SPACE ||
+                                n === charset.NEWLINE ||
+                                n === charset.CARRIAGE_RETURN ||
+                                n === charset.TAB) {
+                                continue;
+                            }
+                    }
+                    throw new TokenizerError(`Unexpected "${String.fromCharCode(n)}" at position "${i}" in state ${TokenizerStateToString(this.state)}`);
+                }
+                if (this.emitPartialTokens) {
+                    switch (this.state) {
+                        case TokenizerStates.TRUE1:
+                        case TokenizerStates.TRUE2:
+                        case TokenizerStates.TRUE3:
+                            this.onToken({
+                                token: TokenType.TRUE,
+                                value: true,
+                                offset: this.offset,
+                                partial: true,
+                            });
+                            break;
+                        case TokenizerStates.FALSE1:
+                        case TokenizerStates.FALSE2:
+                        case TokenizerStates.FALSE3:
+                        case TokenizerStates.FALSE4:
+                            this.onToken({
+                                token: TokenType.FALSE,
+                                value: false,
+                                offset: this.offset,
+                                partial: true,
+                            });
+                            break;
+                        case TokenizerStates.NULL1:
+                        case TokenizerStates.NULL2:
+                        case TokenizerStates.NULL3:
+                            this.onToken({
+                                token: TokenType.NULL,
+                                value: null,
+                                offset: this.offset,
+                                partial: true,
+                            });
+                            break;
+                        case TokenizerStates.STRING_DEFAULT: {
+                            const string = this.bufferedString.toString();
+                            this.onToken({
+                                token: TokenType.STRING,
+                                value: string,
+                                offset: this.offset,
+                                partial: true,
+                            });
+                            break;
+                        }
+                        case TokenizerStates.NUMBER_AFTER_INITIAL_ZERO:
+                        case TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO:
+                        case TokenizerStates.NUMBER_AFTER_DECIMAL:
+                        case TokenizerStates.NUMBER_AFTER_E_AND_DIGIT:
+                            try {
+                                this.onToken({
+                                    token: TokenType.NUMBER,
+                                    value: this.parseNumber(this.bufferedNumber.toString()),
+                                    offset: this.offset,
+                                    partial: true,
+                                });
+                            }
+                            catch (_a) {
+                            }
+                    }
+                }
+            }
+            catch (err) {
+                this.error(err);
+            }
+        }
+        emitNumber() {
+            this.onToken({
+                token: TokenType.NUMBER,
+                value: this.parseNumber(this.bufferedNumber.toString()),
+                offset: this.offset,
+            });
+            this.offset += this.bufferedNumber.byteLength - 1;
+        }
+        parseNumber(numberStr) {
+            return Number(numberStr);
+        }
+        error(err) {
+            if (this.state !== TokenizerStates.ENDED) {
+                this.state = TokenizerStates.ERROR;
+            }
+            this.onError(err);
+        }
+        end() {
+            switch (this.state) {
+                case TokenizerStates.NUMBER_AFTER_INITIAL_ZERO:
+                case TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO:
+                case TokenizerStates.NUMBER_AFTER_DECIMAL:
+                case TokenizerStates.NUMBER_AFTER_E_AND_DIGIT:
+                    this.state = TokenizerStates.ENDED;
+                    this.emitNumber();
+                    this.onEnd();
+                    break;
+                case TokenizerStates.BOM_OR_START:
+                case TokenizerStates.START:
+                case TokenizerStates.ERROR:
+                case TokenizerStates.SEPARATOR:
+                    this.state = TokenizerStates.ENDED;
+                    this.onEnd();
+                    break;
+                default:
+                    this.error(new TokenizerError(`Tokenizer ended in the middle of a token (state: ${TokenizerStateToString(this.state)}). Either not all the data was received or the data was invalid.`));
+            }
+        }
+        onToken(parsedToken) {
+            throw new TokenizerError('Can\'t emit tokens before the "onToken" callback has been set up.');
+        }
+        onError(err) {
+            throw err;
+        }
+        onEnd() {
+        }
+    }
+
+    var TokenParserMode;
+    (function (TokenParserMode) {
+        TokenParserMode[TokenParserMode["OBJECT"] = 0] = "OBJECT";
+        TokenParserMode[TokenParserMode["ARRAY"] = 1] = "ARRAY";
+    })(TokenParserMode || (TokenParserMode = {}));
+
+    var TokenParserState;
+    (function (TokenParserState) {
+        TokenParserState[TokenParserState["VALUE"] = 0] = "VALUE";
+        TokenParserState[TokenParserState["KEY"] = 1] = "KEY";
+        TokenParserState[TokenParserState["COLON"] = 2] = "COLON";
+        TokenParserState[TokenParserState["COMMA"] = 3] = "COMMA";
+        TokenParserState[TokenParserState["ENDED"] = 4] = "ENDED";
+        TokenParserState[TokenParserState["ERROR"] = 5] = "ERROR";
+        TokenParserState[TokenParserState["SEPARATOR"] = 6] = "SEPARATOR";
+    })(TokenParserState || (TokenParserState = {}));
+    function TokenParserStateToString(state) {
+        return ["VALUE", "KEY", "COLON", "COMMA", "ENDED", "ERROR", "SEPARATOR"][state];
+    }
+    const defaultOpts = {
+        paths: undefined,
+        keepStack: true,
+        separator: undefined,
+        emitPartialValues: false,
+    };
+    class TokenParserError extends Error {
+        constructor(message) {
+            super(message);
+            Object.setPrototypeOf(this, TokenParserError.prototype);
+        }
+    }
+    class TokenParser {
+        constructor(opts) {
+            this.state = TokenParserState.VALUE;
+            this.mode = undefined;
+            this.key = undefined;
+            this.value = undefined;
+            this.stack = [];
+            opts = Object.assign(Object.assign({}, defaultOpts), opts);
+            if (opts.paths) {
+                this.paths = opts.paths.map((path) => {
+                    if (path === undefined || path === "$*")
+                        return undefined;
+                    if (!path.startsWith("$"))
+                        throw new TokenParserError(`Invalid selector "${path}". Should start with "$".`);
+                    const pathParts = path.split(".").slice(1);
+                    if (pathParts.includes(""))
+                        throw new TokenParserError(`Invalid selector "${path}". ".." syntax not supported.`);
+                    return pathParts;
+                });
+            }
+            this.keepStack = opts.keepStack || false;
+            this.separator = opts.separator;
+            if (!opts.emitPartialValues) {
+                this.emitPartial = () => { };
+            }
+        }
+        shouldEmit() {
+            if (!this.paths)
+                return true;
+            return this.paths.some((path) => {
+                var _a;
+                if (path === undefined)
+                    return true;
+                if (path.length !== this.stack.length)
+                    return false;
+                for (let i = 0; i < path.length - 1; i++) {
+                    const selector = path[i];
+                    const key = this.stack[i + 1].key;
+                    if (selector === "*")
+                        continue;
+                    if (selector !== (key === null || key === void 0 ? void 0 : key.toString()))
+                        return false;
+                }
+                const selector = path[path.length - 1];
+                if (selector === "*")
+                    return true;
+                return selector === ((_a = this.key) === null || _a === void 0 ? void 0 : _a.toString());
+            });
+        }
+        push() {
+            this.stack.push({
+                key: this.key,
+                value: this.value,
+                mode: this.mode,
+                emit: this.shouldEmit(),
+            });
+        }
+        pop() {
+            const value = this.value;
+            let emit;
+            ({
+                key: this.key,
+                value: this.value,
+                mode: this.mode,
+                emit,
+            } = this.stack.pop());
+            this.state =
+                this.mode !== undefined ? TokenParserState.COMMA : TokenParserState.VALUE;
+            this.emit(value, emit);
+        }
+        emit(value, emit) {
+            if (!this.keepStack &&
+                this.value &&
+                this.stack.every((item) => !item.emit)) {
+                delete this.value[this.key];
+            }
+            if (emit) {
+                this.onValue({
+                    value: value,
+                    key: this.key,
+                    parent: this.value,
+                    stack: this.stack,
+                });
+            }
+            if (this.stack.length === 0) {
+                if (this.separator) {
+                    this.state = TokenParserState.SEPARATOR;
+                }
+                else if (this.separator === undefined) {
+                    this.end();
+                }
+            }
+        }
+        emitPartial(value) {
+            if (!this.shouldEmit())
+                return;
+            if (this.state === TokenParserState.KEY) {
+                this.onValue({
+                    value: undefined,
+                    key: value,
+                    parent: this.value,
+                    stack: this.stack,
+                    partial: true,
+                });
+                return;
             }
+            this.onValue({
+                value: value,
+                key: this.key,
+                parent: this.value,
+                stack: this.stack,
+                partial: true,
+            });
+        }
+        get isEnded() {
+            return this.state === TokenParserState.ENDED;
+        }
+        write({ token, value, partial, }) {
+            try {
+                if (partial) {
+                    this.emitPartial(value);
+                    return;
+                }
+                if (this.state === TokenParserState.VALUE) {
+                    if (token === TokenType.STRING ||
+                        token === TokenType.NUMBER ||
+                        token === TokenType.TRUE ||
+                        token === TokenType.FALSE ||
+                        token === TokenType.NULL) {
+                        if (this.mode === TokenParserMode.OBJECT) {
+                            this.value[this.key] = value;
+                            this.state = TokenParserState.COMMA;
+                        }
+                        else if (this.mode === TokenParserMode.ARRAY) {
+                            this.value.push(value);
+                            this.state = TokenParserState.COMMA;
+                        }
+                        this.emit(value, this.shouldEmit());
+                        return;
+                    }
+                    if (token === TokenType.LEFT_BRACE) {
+                        this.push();
+                        if (this.mode === TokenParserMode.OBJECT) {
+                            this.value = this.value[this.key] = {};
+                        }
+                        else if (this.mode === TokenParserMode.ARRAY) {
+                            const val = {};
+                            this.value.push(val);
+                            this.value = val;
+                        }
+                        else {
+                            this.value = {};
+                        }
+                        this.mode = TokenParserMode.OBJECT;
+                        this.state = TokenParserState.KEY;
+                        this.key = undefined;
+                        this.emitPartial();
+                        return;
+                    }
+                    if (token === TokenType.LEFT_BRACKET) {
+                        this.push();
+                        if (this.mode === TokenParserMode.OBJECT) {
+                            this.value = this.value[this.key] = [];
+                        }
+                        else if (this.mode === TokenParserMode.ARRAY) {
+                            const val = [];
+                            this.value.push(val);
+                            this.value = val;
+                        }
+                        else {
+                            this.value = [];
+                        }
+                        this.mode = TokenParserMode.ARRAY;
+                        this.state = TokenParserState.VALUE;
+                        this.key = 0;
+                        this.emitPartial();
+                        return;
+                    }
+                    if (this.mode === TokenParserMode.ARRAY &&
+                        token === TokenType.RIGHT_BRACKET &&
+                        this.value.length === 0) {
+                        this.pop();
+                        return;
+                    }
+                }
+                if (this.state === TokenParserState.KEY) {
+                    if (token === TokenType.STRING) {
+                        this.key = value;
+                        this.state = TokenParserState.COLON;
+                        this.emitPartial();
+                        return;
+                    }
+                    if (token === TokenType.RIGHT_BRACE &&
+                        Object.keys(this.value).length === 0) {
+                        this.pop();
+                        return;
+                    }
+                }
+                if (this.state === TokenParserState.COLON) {
+                    if (token === TokenType.COLON) {
+                        this.state = TokenParserState.VALUE;
+                        return;
+                    }
+                }
+                if (this.state === TokenParserState.COMMA) {
+                    if (token === TokenType.COMMA) {
+                        if (this.mode === TokenParserMode.ARRAY) {
+                            this.state = TokenParserState.VALUE;
+                            this.key += 1;
+                            return;
+                        }
+                        if (this.mode === TokenParserMode.OBJECT) {
+                            this.state = TokenParserState.KEY;
+                            return;
+                        }
+                    }
+                    if ((token === TokenType.RIGHT_BRACE &&
+                        this.mode === TokenParserMode.OBJECT) ||
+                        (token === TokenType.RIGHT_BRACKET &&
+                            this.mode === TokenParserMode.ARRAY)) {
+                        this.pop();
+                        return;
+                    }
+                }
+                if (this.state === TokenParserState.SEPARATOR) {
+                    if (token === TokenType.SEPARATOR && value === this.separator) {
+                        this.state = TokenParserState.VALUE;
+                        return;
+                    }
+                }
+                if (token === TokenType.SEPARATOR &&
+                    this.state !== TokenParserState.SEPARATOR &&
+                    Array.from(value)
+                        .map((n) => n.charCodeAt(0))
+                        .every((n) => n === charset.SPACE ||
+                        n === charset.NEWLINE ||
+                        n === charset.CARRIAGE_RETURN ||
+                        n === charset.TAB)) {
+                    return;
+                }
+                throw new TokenParserError(`Unexpected ${TokenType[token]} (${JSON.stringify(value)}) in state ${TokenParserStateToString(this.state)}`);
+            }
+            catch (err) {
+                this.error(err);
+            }
+        }
+        error(err) {
+            if (this.state !== TokenParserState.ENDED) {
+                this.state = TokenParserState.ERROR;
+            }
+            this.onError(err);
+        }
+        end() {
+            if ((this.state !== TokenParserState.VALUE &&
+                this.state !== TokenParserState.SEPARATOR) ||
+                this.stack.length > 0) {
+                this.error(new Error(`Parser ended in mid-parsing (state: ${TokenParserStateToString(this.state)}). Either not all the data was received or the data was invalid.`));
+            }
+            else {
+                this.state = TokenParserState.ENDED;
+                this.onEnd();
+            }
+        }
+        onValue(parsedElementInfo) {
+            throw new TokenParserError('Can\'t emit data before the "onValue" callback has been set up.');
+        }
+        onError(err) {
+            throw err;
+        }
+        onEnd() {
+        }
+    }
+
+    class JSONParser {
+        constructor(opts = {}) {
+            this.tokenizer = new Tokenizer(opts);
+            this.tokenParser = new TokenParser(opts);
+            this.tokenizer.onToken = this.tokenParser.write.bind(this.tokenParser);
+            this.tokenizer.onEnd = () => {
+                if (!this.tokenParser.isEnded)
+                    this.tokenParser.end();
+            };
+            this.tokenParser.onError = this.tokenizer.error.bind(this.tokenizer);
+            this.tokenParser.onEnd = () => {
+                if (!this.tokenizer.isEnded)
+                    this.tokenizer.end();
+            };
+        }
+        get isEnded() {
+            return this.tokenizer.isEnded && this.tokenParser.isEnded;
+        }
+        write(input) {
+            this.tokenizer.write(input);
+        }
+        end() {
+            this.tokenizer.end();
+        }
+        set onToken(cb) {
+            this.tokenizer.onToken = (parsedToken) => {
+                cb(parsedToken);
+                this.tokenParser.write(parsedToken);
+            };
+        }
+        set onValue(cb) {
+            this.tokenParser.onValue = cb;
+        }
+        set onError(cb) {
+            this.tokenizer.onError = cb;
+        }
+        set onEnd(cb) {
+            this.tokenParser.onEnd = () => {
+                if (!this.tokenizer.isEnded)
+                    this.tokenizer.end();
+                cb.call(this.tokenParser);
+            };
+        }
+    }
+
+    class JSONStreamParser extends JSONParser {
+        constructor(data) {
+            super();
+            this.onValue = ({ value, stack }) => {
+                if (stack.length === 0)
+                    this.json = value;
+            };
+            if (data)
+                this.write(data);
         }
     }
 
@@ -40255,13 +41521,13 @@ void main() {
                         this.viewer.emitEvent({ type: "geometryprogress", data: progress, file });
                     };
                     const data = await loader.loadAsync(this.manager.fileURL, progress);
-                    const extension = new GLTFBinaryExtension(data);
-                    this.gltf = JSON.parse(extension.content);
-                    this.glb = extension.body;
-                    if (/\.glb$/i.test(this.manager.fileURL) && !this.glb) {
-                        throw new Error("GLTFFileDynamicLoader: Binary buffer chunk not found or type not supported.");
+                    const binaryParser = new GLTFBinaryParser(data);
+                    const jsonParser = new JSONStreamParser(binaryParser.content);
+                    if (!jsonParser.json) {
+                        throw new Error("GLTFFileDynamicLoader: JSON content not found or invalid.");
                     }
-                    return this.gltf;
+                    this.glb = binaryParser.body;
+                    return jsonParser.json;
                 },
                 loadBinaryData: (ranges, uri = "") => {
                     const loader = new RangesLoader();
@@ -40332,13 +41598,16 @@ void main() {
             });
             const loadController = {
                 loadJson: async () => {
-                    const progress = (progress) => {
+                    const jsonParser = new JSONStreamParser();
+                    const progress = (progress, chunk) => {
+                        jsonParser.write(chunk);
                         this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model.file, model });
                     };
-                    const arrayBuffer = await model.downloadResource(model.database, progress, this.gltfLoader.getAbortController().signal);
-                    const text = new TextDecoder().decode(arrayBuffer);
-                    const json = JSON.parse(text);
-                    return json;
+                    await model.downloadResource(model.database, progress, this.gltfLoader.getAbortController().signal);
+                    if (!jsonParser.json) {
+                        throw new Error("GLTFCloudDynamicLoader: JSON content not found or invalid.");
+                    }
+                    return jsonParser.json;
                 },
                 loadBinaryData: (requests) => {
                     const ranges = requests.map((request) => ({
@@ -55588,10 +56857,8 @@ js: import "konva/skia-backend";
             if (model && typeof model.database === "string") {
                 file = model.file;
             }
-            if (!model)
-                throw new Error(`Format not supported`);
             let format = params.format;
-            if (!format && typeof file["type"] === "string")
+            if (!format && file && typeof file["type"] === "string")
                 format = file["type"].split(".").pop();
             if (!format && typeof file === "string")
                 format = file.split(".").pop();
@@ -55599,7 +56866,7 @@ js: import "konva/skia-backend";
                 format = file.name.split(".").pop();
             const loader = loaders.createLoader(this, model, format);
             if (!loader)
-                throw new Error(`Format not supported`);
+                throw new Error(`Format not supported (${format})`);
             this.loaders.push(loader);
             this.emitEvent({ type: "geometrystart", file, model });
             try {
@@ -55641,7 +56908,6 @@ js: import "konva/skia-backend";
             this.scene.clear();
             this.helpers.clear();
             this.extents.makeEmpty();
-            this.target.set(0, 0, 0);
             this.syncOptions();
             this.syncOverlay();
             this.emitEvent({ type: "clear" });
@@ -55757,7 +57023,7 @@ js: import "konva/skia-backend";
             const getVector3FromPoint3d = ({ x, y, z }) => new Vector3(x, y, z);
             const setOrthogonalCamera = (orthogonal_camera) => {
                 if (orthogonal_camera) {
-                    const extentsSize = this.extents.getBoundingSphere(new Sphere()).radius * 2;
+                    const extentsSize = this.extents.getSize(new Vector3()).length() || 1;
                     const rendererSize = this.renderer.getSize(new Vector2());
                     const aspectRatio = rendererSize.x / rendererSize.y;
                     const camera = new OrthographicCamera();
@@ -55783,7 +57049,7 @@ js: import "konva/skia-backend";
             };
             const setPerspectiveCamera = (perspective_camera) => {
                 if (perspective_camera) {
-                    const extentsSize = this.extents.getBoundingSphere(new Sphere()).radius * 2;
+                    const extentsSize = this.extents.getSize(new Vector3()).length() || 1;
                     const rendererSize = this.renderer.getSize(new Vector2());
                     const aspectRatio = rendererSize.x / rendererSize.y;
                     const camera = new PerspectiveCamera();