合并router下index.js和scss文件

public/libs/online-3d-viewer/LICENSE.md

+MIT License
+
+Copyright (c) 2023 Viktor Kovacs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

public/libs/online-3d-viewer/README.md

+# Online 3D Viewer
+
+[![Build status](https://github.com/kovacsv/Online3DViewer/actions/workflows/build.yml/badge.svg)](https://github.com/kovacsv/Online3DViewer/actions/workflows/build.yml)
+[![npm version](https://badge.fury.io/js/online-3d-viewer.svg)](https://badge.fury.io/js/online-3d-viewer)
+[![DeepScan grade](https://deepscan.io/api/teams/16586/projects/19893/branches/524595/badge/grade.svg)](https://deepscan.io/dashboard#view=project&tid=16586&pid=19893&bid=524595)
+
+Online 3D Viewer (https://3dviewer.net) is a free and open source web solution to visualize and explore 3D models in your browser. This repository contains the source code of the website and the library behind it.
+
+[Live website](https://3dviewer.net)  -  [Website documentation](https://3dviewer.net/info)  -  [Developer documentation](https://kovacsv.github.io/Online3DViewer)  -  [Discord server](https://discord.gg/C7x9u833yN)
+
+## Example
+
+![Start Page](assets/images/3dviewer_net_start_page.png?raw=true)
+
+[Check the live version!](https://3dviewer.net/#model=https://raw.githubusercontent.com/kovacsv/Online3DViewer/dev/test/testfiles/gltf/DamagedHelmet/glTF-Binary/DamagedHelmet.glb)
+
+## Supported file formats
+
+* **Import**: obj, 3ds, stl, ply, gltf, glb, off, 3dm, fbx, dae, wrl, 3mf, amf, ifc, brep, step, iges, fcstd, bim.
+* **Export**: obj, stl, ply, gltf, glb, off, 3dm, bim.
+
+## External Libraries
+
+Online 3D Viewer uses these wonderful libraries: [three.js](https://github.com/mrdoob/three.js), [pickr](https://github.com/Simonwep/pickr), [fflate](https://github.com/101arrowz/fflate), [draco](https://github.com/google/draco), [rhino3dm](https://github.com/mcneel/rhino3dm), [web-ifc](https://github.com/tomvandig/web-ifc), [occt-import-js](https://github.com/kovacsv/occt-import-js).

public/libs/online-3d-viewer/build/engine/o3dv.module.d.ts

+export function AddCoord2D(a: any, b: any): Coord2D;
+export function AddCoord3D(a: any, b: any): Coord3D;
+export function AddDiv(parentElement: any, className: any, innerHTML: any): any;
+export function AddDomElement(parentElement: any, elementType: any, className: any, innerHTML: any): any;
+export function ArrayBufferToAsciiString(buffer: any): string;
+export function ArrayBufferToUtf8String(buffer: any): string;
+export function ArrayToCoord3D(arr: any): Coord3D;
+export function ArrayToQuaternion(arr: any): Quaternion;
+export function ArrayToRGBColor(arr: any): RGBColor;
+export function AsciiStringToArrayBuffer(str: any): ArrayBuffer;
+export function Base64DataURIToArrayBuffer(uri: any): {
+    mimeType: any;
+    buffer: ArrayBuffer;
+};
+export function BezierTweenFunction(distance: any, index: any, count: any): number;
+export const BigEps: 0.0001;
+export class BinaryReader {
+    constructor(arrayBuffer: any, isLittleEndian: any);
+    arrayBuffer: any;
+    dataView: DataView;
+    isLittleEndian: any;
+    position: number;
+    GetPosition(): number;
+    SetPosition(position: any): void;
+    GetByteLength(): any;
+    Skip(bytes: any): void;
+    End(): boolean;
+    ReadArrayBuffer(byteLength: any): ArrayBuffer;
+    ReadBoolean8(): boolean;
+    ReadCharacter8(): number;
+    ReadUnsignedCharacter8(): number;
+    ReadInteger16(): number;
+    ReadUnsignedInteger16(): number;
+    ReadInteger32(): number;
+    ReadUnsignedInteger32(): number;
+    ReadFloat32(): number;
+    ReadDouble64(): number;
+}
+export class BinaryWriter {
+    constructor(byteLength: any, isLittleEndian: any);
+    arrayBuffer: ArrayBuffer;
+    dataView: DataView;
+    isLittleEndian: any;
+    position: number;
+    GetPosition(): number;
+    SetPosition(position: any): void;
+    End(): boolean;
+    GetBuffer(): ArrayBuffer;
+    WriteArrayBuffer(arrayBuffer: any): void;
+    WriteBoolean8(val: any): void;
+    WriteCharacter8(val: any): void;
+    WriteUnsignedCharacter8(val: any): void;
+    WriteInteger16(val: any): void;
+    WriteUnsignedInteger16(val: any): void;
+    WriteInteger32(val: any): void;
+    WriteUnsignedInteger32(val: any): void;
+    WriteFloat32(val: any): void;
+    WriteDouble64(val: any): void;
+}
+export class BoundingBoxCalculator3D {
+    box: Box3D;
+    isValid: boolean;
+    GetBox(): Box3D;
+    AddPoint(point: any): void;
+}
+export class Box3D {
+    constructor(min: any, max: any);
+    min: any;
+    max: any;
+    GetMin(): any;
+    GetMax(): any;
+    GetCenter(): Coord3D;
+}
+export function CalculateSurfaceArea(object3D: any): number;
+export function CalculateTriangleNormal(v0: any, v1: any, v2: any): Coord3D;
+export function CalculateVolume(object3D: any): number;
+/**
+ * Camera object.
+ */
+export class Camera {
+    /**
+     * @param {Coord3D} eye Eye position.
+     * @param {Coord3D} center Center position. Sometimes it's called target or look at position.
+     * @param {Coord3D} up Up vector.
+     * @param {number} fov Field of view in degrees.
+     */
+    constructor(eye: Coord3D, center: Coord3D, up: Coord3D, fov: number);
+    eye: Coord3D;
+    center: Coord3D;
+    up: Coord3D;
+    fov: number;
+    /**
+     * Creates a clone of the object.
+     * @returns {Camera}
+     */
+    Clone(): Camera;
+}
+export function CameraIsEqual3D(a: any, b: any): boolean;
+/**
+ * Camera projection mode.
+ */
+export type CameraMode = any;
+export namespace CameraMode {
+    let Perspective: number;
+    let Orthographic: number;
+}
+export class CameraValidator {
+    eyeCenterDistance: number;
+    forceUpdate: boolean;
+    ForceUpdate(): void;
+    ValidatePerspective(): boolean;
+    ValidateOrthographic(eyeCenterDistance: any): boolean;
+}
+export function CheckModel(model: any): boolean;
+export function ClearDomElement(element: any): void;
+export class ClickDetector {
+    isClick: boolean;
+    startPosition: any;
+    Start(startPosition: any): void;
+    Move(currentPosition: any): void;
+    End(): void;
+    Cancel(): void;
+    IsClick(): boolean;
+}
+export function ColorComponentFromFloat(component: any): number;
+export function ColorComponentToFloat(component: any): number;
+export class ColorToMaterialConverter {
+    constructor(model: any);
+    model: any;
+    colorToMaterialIndex: Map<any, any>;
+    GetMaterialIndex(r: any, g: any, b: any, a: any): any;
+}
+export function ConvertColorToThreeColor(color: any): any;
+export function ConvertMeshToMeshBuffer(mesh: any): MeshBuffer;
+export function ConvertModelToThreeObject(model: any, params: any, output: any, callbacks: any): void;
+export function ConvertThreeColorToColor(threeColor: any): RGBColor;
+export function ConvertThreeGeometryToMesh(threeGeometry: any, materialIndex: any, colorConverter: any): Mesh;
+export class Coord2D {
+    constructor(x: any, y: any);
+    x: any;
+    y: any;
+    Clone(): Coord2D;
+}
+export class Coord3D {
+    constructor(x: any, y: any, z: any);
+    x: any;
+    y: any;
+    z: any;
+    Length(): number;
+    MultiplyScalar(scalar: any): this;
+    Normalize(): this;
+    Offset(direction: any, distance: any): this;
+    Rotate(axis: any, angle: any, origo: any): this;
+    Clone(): Coord3D;
+}
+export class Coord4D {
+    constructor(x: any, y: any, z: any, w: any);
+    x: any;
+    y: any;
+    z: any;
+    w: any;
+    Clone(): Coord4D;
+}
+export function CoordDistance2D(a: any, b: any): number;
+export function CoordDistance3D(a: any, b: any): number;
+export function CoordIsEqual2D(a: any, b: any): boolean;
+export function CoordIsEqual3D(a: any, b: any): boolean;
+export function CopyObjectAttributes(src: any, dest: any): void;
+export function CreateDiv(className: any, innerHTML: any): any;
+export function CreateDomElement(elementType: any, className: any, innerHTML: any): any;
+export function CreateModelUrlParameters(urls: any): string;
+export function CreateObjectUrl(content: any): string;
+export function CreateObjectUrlWithMimeType(content: any, mimeType: any): string;
+export function CreateUrlBuilder(): ParameterListBuilder;
+export function CreateUrlParser(urlParams: any): ParameterListParser;
+export function CrossVector3D(a: any, b: any): Coord3D;
+export const DegRad: 0.017453292519943;
+export namespace Direction {
+    let X: number;
+    let Y: number;
+    let Z: number;
+}
+export function DisposeThreeObjects(mainObject: any): void;
+export function DotVector3D(a: any, b: any): number;
+/**
+ * Edge settings object.
+ */
+export class EdgeSettings {
+    /**
+     * @param {boolean} showEdges Show edges.
+     * @param {RGBColor} edgeColor Color of the edges.
+     * @param {number} edgeThreshold Minimum angle between faces to show edges between them in.
+     * The value must be in degrees.
+     */
+    constructor(showEdges: boolean, edgeColor: RGBColor, edgeThreshold: number);
+    showEdges: boolean;
+    edgeColor: RGBColor;
+    edgeThreshold: number;
+    /**
+     * Creates a clone of the object.
+     * @returns {EdgeSettings}
+     */
+    Clone(): EdgeSettings;
+}
+/**
+ * This is the main object for embedding the viewer on a website.
+ */
+export class EmbeddedViewer {
+    /**
+     * @param {HTMLElement} parentElement The parent element for the viewer canvas. It must be an
+     * existing DOM element and it will be the container for the canvas. The size of the viewer will
+     * be automatically adjusted to the size of the parent element.
+     * @param {object} parameters Parameters for embedding.
+     * @param {Camera} [parameters.camera] Camera to use. If not specified, the default camera will
+     * be used and the model will be fitted to the window.
+     * @param {CameraMode} [parameters.cameraMode] Camera projection mode.
+     * @param {RGBAColor} [parameters.backgroundColor] Background color of the canvas.
+     * @param {RGBColor} [parameters.defaultColor] Default color of the model. It has effect only
+     * if the imported model doesn't specify any color.
+     * @param {EdgeSettings} [parameters.edgeSettings] Edge settings.
+     * @param {EnvironmentSettings} [parameters.environmentSettings] Environment settings.
+     * @param {function} [parameters.onModelLoaded] Callback that is called when the model with all
+     * of the textures is fully loaded.
+    */
+    constructor(parentElement: HTMLElement, parameters: {
+        camera?: Camera;
+        cameraMode?: CameraMode;
+        backgroundColor?: RGBAColor;
+        defaultColor?: RGBColor;
+        edgeSettings?: EdgeSettings;
+        environmentSettings?: EnvironmentSettings;
+        onModelLoaded?: Function;
+    });
+    parentElement: HTMLElement;
+    parameters: {
+        camera?: Camera;
+        cameraMode?: any;
+        backgroundColor?: RGBAColor;
+        defaultColor?: RGBColor;
+        edgeSettings?: EdgeSettings;
+        environmentSettings?: EnvironmentSettings;
+        onModelLoaded?: Function;
+    };
+    canvas: HTMLCanvasElement;
+    viewer: Viewer;
+    model: any;
+    modelLoader: ThreeModelLoader;
+    /**
+     * Loads the model based on a list of urls. The list must contain the main model file and all
+     * of the referenced files. For example in case of an obj file the list must contain the
+     * corresponding mtl and texture files, too.
+     * @param {string[]} modelUrls Url list of model files.
+     */
+    LoadModelFromUrlList(modelUrls: string[]): void;
+    /**
+     * Loads the model based on a list of {@link File} objects. The list must contain the main model
+     * file and all of the referenced files. You must use this method when you are using a file picker
+     * or drag and drop to select files from a computer.
+     * @param {File[]} fileList File object list of model files.
+     */
+    LoadModelFromFileList(fileList: File[]): void;
+    /**
+     * Loads the model based on a list of {@link InputFile} objects. This method is used
+     * internally, you should use LoadModelFromUrlList or LoadModelFromFileList instead.
+     * @param {InputFile[]} inputFiles List of model files.
+     */
+    LoadModelFromInputFiles(inputFiles: InputFile[]): void;
+    /**
+     * Returns the underlying Viewer object.
+     * @returns {Viewer}
+     */
+    GetViewer(): Viewer;
+    /**
+     * Returns the underlying Model object.
+     * @returns {Model}
+     */
+    GetModel(): Model;
+    /**
+     * This method must be called when the size of the parent element changes to make sure that the
+     * context has the same dimensions as the parent element.
+     */
+    Resize(): void;
+    /**
+     * Frees up all the memory that is allocated by the viewer. You should call this function if
+     * yo don't need the viewer anymore.
+     */
+    Destroy(): void;
+}
+/**
+ * Environment settings object.
+ */
+export class EnvironmentSettings {
+    /**
+     * @param {string[]} textureNames Urls of the environment map images in this order:
+     * posx, negx, posy, negy, posz, negz.
+     * @param {boolean} backgroundIsEnvMap Use the environment map as background.
+     */
+    constructor(textureNames: string[], backgroundIsEnvMap: boolean);
+    textureNames: string[];
+    backgroundIsEnvMap: boolean;
+    /**
+     * Creates a clone of the object.
+     * @returns {EnvironmentSettings}
+     */
+    Clone(): EnvironmentSettings;
+}
+export const Eps: 1e-8;
+export function EscapeHtmlChars(str: any): any;
+export class EventNotifier {
+    eventListeners: Map<any, any>;
+    AddEventListener(eventId: any, listener: any): void;
+    HasEventListener(eventId: any): boolean;
+    GetEventNotifier(eventId: any): () => void;
+    NotifyEventListeners(eventId: any, ...args: any[]): void;
+}
+export class ExportedFile {
+    constructor(name: any);
+    name: any;
+    content: any;
+    GetName(): any;
+    SetName(name: any): void;
+    GetTextContent(): string;
+    GetBufferContent(): any;
+    SetTextContent(content: any): void;
+    SetBufferContent(content: any): void;
+}
+export class Exporter {
+    exporters: (Exporter3dm | ExporterBim | ExporterGltf | ExporterObj | ExporterOff | ExporterPly | ExporterStl)[];
+    AddExporter(exporter: any): void;
+    Export(model: any, settings: any, format: any, extension: any, callbacks: any): void;
+}
+export class Exporter3dm extends ExporterBase {
+    rhino: any;
+    ExportRhinoContent(exporterModel: any, files: any, onFinish: any): void;
+}
+export class ExporterBase {
+    CanExport(format: any, extension: any): boolean;
+    Export(exporterModel: any, format: any, onFinish: any): void;
+    ExportContent(exporterModel: any, format: any, files: any, onFinish: any): void;
+    GetExportedMaterialName(originalName: any): any;
+    GetExportedMeshName(originalName: any): any;
+    GetExportedName(originalName: any, defaultName: any): any;
+}
+export class ExporterBim extends ExporterBase {
+    ExportProperties(element: any, targetObject: any): void;
+}
+export class ExporterGltf extends ExporterBase {
+    components: {
+        index: {
+            type: number;
+            size: number;
+        };
+        number: {
+            type: number;
+            size: number;
+        };
+    };
+    ExportAsciiContent(exporterModel: any, files: any): void;
+    ExportBinaryContent(exporterModel: any, files: any): void;
+    GetMeshData(exporterModel: any): any[];
+    GetMainBuffer(meshDataArr: any): ArrayBuffer;
+    GetMainJson(exporterModel: any, meshDataArr: any): {
+        asset: {
+            generator: string;
+            version: string;
+        };
+        scene: number;
+        scenes: {
+            nodes: any[];
+        }[];
+        nodes: any[];
+        materials: any[];
+        meshes: any[];
+        buffers: any[];
+        bufferViews: any[];
+        accessors: any[];
+    };
+    ExportMaterials(exporterModel: any, mainJson: any, addTexture: any): void;
+}
+export class ExporterModel {
+    constructor(model: any, settings: any);
+    model: any;
+    settings: any;
+    visibleMeshes: Set<any>;
+    meshToVisibleMeshIndex: Map<any, any>;
+    GetModel(): any;
+    MaterialCount(): any;
+    GetMaterial(index: any): any;
+    VertexCount(): number;
+    TriangleCount(): number;
+    MeshCount(): number;
+    EnumerateMeshes(onMesh: any): void;
+    MapMeshIndex(meshIndex: any): any;
+    IsMeshInstanceVisible(meshInstanceId: any): any;
+    MeshInstanceCount(): number;
+    EnumerateMeshInstances(onMeshInstance: any): void;
+    EnumerateTransformedMeshInstances(onMesh: any): void;
+    EnumerateVerticesAndTriangles(callbacks: any): void;
+    EnumerateTrianglesWithNormals(onTriangle: any): void;
+    FillVisibleMeshCache(): void;
+}
+export class ExporterObj extends ExporterBase {
+    GetHeaderText(): string;
+}
+export class ExporterOff extends ExporterBase {
+}
+export class ExporterPly extends ExporterBase {
+    ExportText(exporterModel: any, files: any): void;
+    ExportBinary(exporterModel: any, files: any): void;
+    GetHeaderText(format: any, vertexCount: any, triangleCount: any): string;
+}
+export class ExporterSettings {
+    constructor(settings: any);
+    transformation: Transformation;
+    isMeshVisible: (meshInstanceId: any) => boolean;
+}
+export class ExporterStl extends ExporterBase {
+    ExportText(exporterModel: any, files: any): void;
+    ExportBinary(exporterModel: any, files: any): void;
+}
+export class FaceMaterial extends MaterialBase {
+    emissive: RGBColor;
+    opacity: number;
+    transparent: boolean;
+    diffuseMap: any;
+    bumpMap: any;
+    normalMap: any;
+    emissiveMap: any;
+    alphaTest: number;
+    multiplyDiffuseMap: boolean;
+}
+export namespace FileFormat {
+    let Text: number;
+    let Binary: number;
+}
+/**
+ * File source identifier for import.
+ */
+export type FileSource = any;
+export namespace FileSource {
+    export let Url: number;
+    let File_1: number;
+    export { File_1 as File };
+    export let Decompressed: number;
+}
+export function FinalizeModel(model: any, params: any): void;
+export function FlipMeshTrianglesOrientation(mesh: any): void;
+export function GenerateCone(genParams: any, topRadius: any, bottomRadius: any, height: any, segments: any, smooth: any): Mesh;
+export function GenerateCuboid(genParams: any, xSize: any, ySize: any, zSize: any): Mesh;
+export function GenerateCylinder(genParams: any, radius: any, height: any, segments: any, smooth: any): Mesh;
+export function GeneratePlatonicSolid(genParams: any, type: any, radius: any): Mesh;
+export function GenerateSphere(genParams: any, radius: any, segments: any, smooth: any): Mesh;
+export class Generator {
+    constructor(params: any);
+    params: any;
+    mesh: Mesh;
+    curve: any;
+    GetMesh(): Mesh;
+    AddVertex(x: any, y: any, z: any): number;
+    AddVertices(vertices: any): number[];
+    SetCurve(curve: any): void;
+    ResetCurve(): void;
+    AddTriangle(v0: any, v1: any, v2: any): number;
+    AddTriangleInverted(v0: any, v1: any, v2: any): void;
+    AddConvexPolygon(vertices: any): void;
+    AddConvexPolygonInverted(vertices: any): void;
+}
+export class GeneratorHelper {
+    constructor(generator: any);
+    generator: any;
+    GenerateSurfaceBetweenPolygons(startIndices: any, endIndices: any): void;
+    GenerateTriangleFan(startIndices: any, endIndex: any): void;
+}
+export class GeneratorParams {
+    name: any;
+    material: any;
+    SetName(name: any): this;
+    SetMaterial(material: any): this;
+}
+export function GetBoundingBox(object3D: any): Box3D;
+export function GetDefaultCamera(direction: any): Camera;
+export function GetDomElementClientCoordinates(element: any, clientX: any, clientY: any): Coord2D;
+export function GetDomElementExternalHeight(style: any): number;
+export function GetDomElementExternalWidth(style: any): number;
+export function GetDomElementInnerDimensions(element: any, outerWidth: any, outerHeight: any): {
+    width: number;
+    height: number;
+};
+export function GetDomElementOuterHeight(element: any): any;
+export function GetDomElementOuterWidth(element: any): any;
+export function GetExternalLibPath(libName: any): string;
+export function GetFileExtension(filePath: any): string;
+export function GetFileExtensionFromMimeType(mimeType: any): any;
+export function GetFileName(filePath: any): string;
+export function GetIntegerFromStyle(parameter: any): number;
+export function GetMeshType(mesh: any): number;
+export function GetShadingType(model: any): number;
+export function GetShadingTypeOfObject(mainObject: any): any;
+export function GetTetrahedronSignedVolume(v0: any, v1: any, v2: any): number;
+export function GetTopology(object3D: any): Topology;
+export function GetTriangleArea(v0: any, v1: any, v2: any): number;
+export function HasDefaultMaterial(model: any): boolean;
+export function HasHighpDriverIssue(): boolean;
+export function HexStringToRGBAColor(hexString: any): RGBAColor;
+export function HexStringToRGBColor(hexString: any): RGBColor;
+export class ImportError {
+    constructor(code: any);
+    code: any;
+    mainFile: any;
+    message: any;
+}
+export namespace ImportErrorCode {
+    let NoImportableFile: number;
+    let FailedToLoadFile: number;
+    let ImportFailed: number;
+    let UnknownError: number;
+}
+export class ImportResult {
+    model: any;
+    mainFile: any;
+    upVector: any;
+    usedFiles: any;
+    missingFiles: any;
+}
+export class ImportSettings {
+    defaultColor: RGBColor;
+}
+export class Importer {
+    importers: (Importer3dm | Importer3ds | ImporterGltf | ImporterIfc | ImporterObj | ImporterOff | ImporterPly | ImporterOcct | ImporterStl | ImporterBim | ImporterThreeFbx | ImporterThreeDae | ImporterThreeWrl | ImporterThree3mf | ImporterThreeAmf | ImporterFcstd)[];
+    fileList: ImporterFileList;
+    model: any;
+    usedFiles: any[];
+    missingFiles: any[];
+    AddImporter(importer: any): void;
+    ImportFiles(inputFiles: any, settings: any, callbacks: any): void;
+    LoadFiles(inputFiles: any, callbacks: any): void;
+    ImportLoadedFiles(settings: any, callbacks: any): void;
+    ImportLoadedMainFile(mainFile: any, settings: any, callbacks: any): void;
+    DecompressArchives(fileList: any, onReady: any): void;
+    GetFileList(): ImporterFileList;
+    HasImportableFile(fileList: any): boolean;
+    GetImportableFiles(fileList: any): {
+        file: any;
+        importer: any;
+    }[];
+}
+export class Importer3dm extends ImporterBase {
+    rhino: any;
+    instanceIdToObject: Map<any, any>;
+    instanceIdToDefinition: Map<any, any>;
+    ImportRhinoContent(fileContent: any): void;
+    ImportRhinoDocument(rhinoDoc: any): void;
+    InitRhinoInstances(rhinoDoc: any): void;
+    ImportRhinoUserStrings(rhinoDoc: any): void;
+    ImportRhinoGeometry(rhinoDoc: any): void;
+    ImportRhinoGeometryObject(rhinoDoc: any, rhinoObject: any, rhinoInstanceReferences: any): void;
+    ImportRhinoMesh(rhinoDoc: any, rhinoMesh: any, rhinoObject: any, rhinoInstanceReferences: any): void;
+    GetMaterialIndex(rhinoDoc: any, rhinoObject: any, rhinoInstanceReferences: any): any;
+}
+export class Importer3ds extends ImporterBase {
+    materialNameToIndex: Map<any, any>;
+    meshNameToIndex: Map<any, any>;
+    nodeList: Importer3dsNodeList;
+    ProcessBinary(fileContent: any): void;
+    ReadMainChunk(reader: any, length: any): void;
+    ReadEditorChunk(reader: any, length: any): void;
+    ReadMaterialChunk(reader: any, length: any): void;
+    ReadTextureMapChunk(reader: any, length: any): TextureMap;
+    ReadColorChunk(reader: any, length: any): RGBColor;
+    ReadPercentageChunk(reader: any, length: any): number;
+    ReadObjectChunk(reader: any, length: any): void;
+    ReadMeshChunk(reader: any, length: any, objectName: any): void;
+    ReadVerticesChunk(mesh: any, reader: any): void;
+    ReadTextureVerticesChunk(mesh: any, reader: any): void;
+    ReadFacesChunk(mesh: any, reader: any, length: any): void;
+    ReadFaceMaterialsChunk(mesh: any, reader: any): void;
+    ReadFaceSmoothingGroupsChunk(mesh: any, faceCount: any, reader: any): void;
+    ReadTransformationChunk(reader: any): any[];
+    ReadKeyFrameChunk(reader: any, length: any): void;
+    BuildNodeHierarchy(): void;
+    ReadObjectNodeChunk(reader: any, length: any): void;
+    ReadName(reader: any): string;
+    ReadVector(reader: any): any[];
+    ReadChunks(reader: any, endByte: any, onChunk: any): void;
+    GetChunkEnd(reader: any, length: any): number;
+    SkipChunk(reader: any, length: any): void;
+}
+export class ImporterBase {
+    name: any;
+    extension: any;
+    callbacks: any;
+    model: Model;
+    error: boolean;
+    message: any;
+    Import(name: any, extension: any, content: any, callbacks: any): void;
+    Clear(): void;
+    CreateResult(callbacks: any): void;
+    CanImportExtension(extension: any): boolean;
+    GetUpDirection(): number;
+    ClearContent(): void;
+    ResetContent(): void;
+    ImportContent(fileContent: any, onFinish: any): void;
+    GetModel(): Model;
+    SetError(message: any): void;
+    WasError(): boolean;
+    GetErrorMessage(): any;
+}
+export class ImporterBim extends ImporterBase {
+    meshIdToMesh: Map<any, any>;
+    colorToMaterial: ColorToMaterialConverter;
+    ImportElement(bimElement: any): Mesh;
+    ImportMesh(bimMesh: any, getMaterialIndex: any): Mesh;
+    ImportProperties(source: any, target: any): void;
+}
+export class ImporterFcstd extends ImporterBase {
+    worker: Worker;
+    document: FreeCadDocument;
+    ConvertObjects(objects: any, onFinish: any): void;
+    OnFileConverted(object: any, resultContent: any, colorToMaterial: any): void;
+}
+export class ImporterFile {
+    constructor(name: any, source: any, data: any);
+    name: string;
+    extension: string;
+    source: any;
+    data: any;
+    content: any;
+    SetContent(content: any): void;
+}
+export class ImporterFileAccessor {
+    constructor(getBufferCallback: any);
+    getBufferCallback: any;
+    fileBuffers: Map<any, any>;
+    GetFileBuffer(filePath: any): any;
+}
+export class ImporterFileList {
+    files: any[];
+    FillFromInputFiles(inputFiles: any): void;
+    ExtendFromFileList(fileList: any): void;
+    GetFiles(): any[];
+    GetContent(callbacks: any): void;
+    ContainsFileByPath(filePath: any): boolean;
+    FindFileByPath(filePath: any): any;
+    IsOnlyUrlSource(): boolean;
+    AddFile(file: any): void;
+    GetFileContent(file: any, callbacks: any): void;
+}
+export class ImporterGltf extends ImporterBase {
+    gltfExtensions: GltfExtensions;
+    bufferContents: any[];
+    imageIndexToTextureParams: Map<any, any>;
+    ProcessGltf(fileContent: any, onFinish: any): void;
+    ProcessBinaryGltf(fileContent: any, onFinish: any): void;
+    ProcessMainFile(gltf: any, onFinish: any): void;
+    ImportModel(gltf: any): void;
+    ImportProperties(modelObject: any, gltfObject: any, propertyGroupName: any): void;
+    GetDefaultScene(gltf: any): any;
+    ImportMaterial(gltf: any, gltfMaterial: any): void;
+    ImportTexture(gltf: any, gltfTextureRef: any): TextureMap;
+    ImportMesh(gltf: any, gltfMesh: any): void;
+    ImportPrimitive(gltf: any, primitive: any, mesh: any): void;
+    AddTriangle(primitive: any, mesh: any, v0: any, v1: any, v2: any, hasVertexColors: any, hasNormals: any, hasUVs: any, vertexOffset: any, vertexColorOffset: any, normalOffset: any, uvOffset: any): void;
+    ImportScene(gltf: any): void;
+    ImportNode(gltf: any, gltfNode: any, parentNode: any): void;
+    GetReaderFromBufferView(bufferView: any): GltfBufferReader;
+    GetReaderFromAccessor(gltf: any, accessor: any): GltfBufferReader;
+    GetReaderFromSparseAccessor(gltf: any, sparseAccessor: any, componentType: any, type: any, count: any): GltfBufferReader;
+}
+export class ImporterIfc extends ImporterBase {
+    ifc: any;
+    expressIDToMesh: Map<any, any>;
+    colorToMaterial: ColorToMaterialConverter;
+    ImportIfcContent(fileContent: any): void;
+    ImportIfcMesh(modelID: any, ifcMesh: any): void;
+    ImportProperties(modelID: any): void;
+    GetMaterialIndexByColor(ifcColor: any): any;
+    GetIFCString(ifcString: any): any;
+    DecodeIFCString(ifcString: any): any;
+}
+export class ImporterObj extends ImporterBase {
+    globalVertices: any[];
+    globalVertexColors: any[];
+    globalNormals: any[];
+    globalUvs: any[];
+    currentMeshConverter: any;
+    currentMaterial: PhongMaterial;
+    currentMaterialIndex: any;
+    meshNameToConverter: Map<any, any>;
+    materialNameToIndex: Map<any, any>;
+    ProcessLine(line: any): void;
+    AddNewMesh(name: any): void;
+    ProcessMeshParameter(keyword: any, parameters: any, line: any): boolean;
+    ProcessMaterialParameter(keyword: any, parameters: any, line: any): boolean;
+    ProcessFace(parameters: any): void;
+}
+export class ImporterOcct extends ImporterBase {
+    worker: Worker;
+    ImportResultJson(resultContent: any, onFinish: any): void;
+    ImportNode(resultContent: any, occtNode: any, parentNode: any, colorToMaterial: any): void;
+    ImportMesh(occtMesh: any, colorToMaterial: any): Mesh;
+}
+export class ImporterOff extends ImporterBase {
+    mesh: Mesh;
+    status: {
+        vertexCount: number;
+        faceCount: number;
+        foundVertex: number;
+        foundFace: number;
+    };
+    colorToMaterial: ColorToMaterialConverter;
+    ProcessLine(line: any): void;
+}
+export class ImporterPly extends ImporterBase {
+    mesh: Mesh;
+    GetHeaderContent(fileContent: any): string;
+    ReadHeader(headerContent: any): PlyHeader;
+    ReadAsciiContent(header: any, fileContent: any): void;
+    ReadBinaryContent(header: any, fileContent: any, headerLength: any): void;
+}
+export class ImporterStl extends ImporterBase {
+    mesh: Mesh;
+    triangle: Triangle;
+    IsBinaryStlFile(fileContent: any): boolean;
+    ProcessLine(line: any): void;
+    ProcessBinary(fileContent: any): void;
+}
+export class ImporterThree3mf extends ImporterThreeBase {
+    colorConverter: ThreeSRGBToLinearColorConverter;
+}
+export class ImporterThreeAmf extends ImporterThreeBase {
+}
+export class ImporterThreeBase extends ImporterBase {
+    colorConverter: any;
+    CreateLoader(manager: any): any;
+    GetMainObject(loadedObject: any): any;
+    IsMeshVisible(mesh: any): boolean;
+    loader: any;
+    materialIdToIndex: Map<any, any>;
+    objectUrlToFileName: Map<any, any>;
+    LoadModel(fileContent: any, onFinish: any): void;
+    OnThreeObjectsLoaded(loadedObject: any, onFinish: any): void;
+    ConvertThreeMesh(threeMesh: any): Mesh;
+    FindOrCreateMaterial(threeMaterial: any): any;
+    ConvertThreeMaterial(threeMaterial: any): PhongMaterial;
+    ConvertThreeColor(threeColor: any): RGBColor;
+}
+export class ImporterThreeDae extends ImporterThreeBase {
+}
+export class ImporterThreeFbx extends ImporterThreeBase {
+    colorConverter: ThreeLinearToSRGBColorConverter;
+}
+export class ImporterThreeSvg extends ImporterThreeBase {
+}
+export class ImporterThreeWrl extends ImporterThreeBase {
+    colorConverter: ThreeLinearToSRGBColorConverter;
+}
+/**
+ * Loads all the models on the page. This function looks for all the elements with online_3d_viewer
+ * class name, and loads the model according to the tag's parameters. It must be called after the
+ * document is loaded.
+ * @returns {EmbeddedViewer[]} Array of the created {@link EmbeddedViewer} objects.
+ */
+export function Init3DViewerElements(onReady: any): EmbeddedViewer[];
+/**
+ * Loads the model specified by File objects.
+ * @param {HTMLElement} parentElement The parent element for the viewer canvas.
+ * @param {File[]} models File object list of model files.
+ * @param {object} parameters See {@link EmbeddedViewer} constructor for details.
+ * @returns {EmbeddedViewer}
+ */
+export function Init3DViewerFromFileList(parentElement: HTMLElement, models: File[], parameters: object): EmbeddedViewer;
+/**
+ * Loads the model specified by urls.
+ * @param {HTMLElement} parentElement The parent element for the viewer canvas.
+ * @param {string[]} modelUrls Url list of model files.
+ * @param {object} parameters See {@link EmbeddedViewer} constructor for details.
+ * @returns {EmbeddedViewer}
+ */
+export function Init3DViewerFromUrlList(parentElement: HTMLElement, modelUrls: string[], parameters: object): EmbeddedViewer;
+/**
+ * File representation class for importers.
+ */
+export class InputFile {
+    /**
+     * @param {string} name Name of the file.
+     * @param {FileSource} source Source of the file.
+     * @param {string|File} data If the file source is url, this must be the url string. If the file source
+     * is file, this must be a {@link File} object.
+     */
+    constructor(name: string, source: any, data: string | File);
+    name: string;
+    source: any;
+    data: string | File;
+}
+export function InputFilesFromFileObjects(fileObjects: any): InputFile[];
+export function InputFilesFromUrls(urls: any): InputFile[];
+export function InsertDomElementAfter(newElement: any, existingElement: any): void;
+export function InsertDomElementBefore(newElement: any, existingElement: any): void;
+export function IntegerToHexString(intVal: any): string;
+export function IsDefined(val: any): boolean;
+export function IsDomElementVisible(element: any): boolean;
+export function IsEqual(a: any, b: any): boolean;
+export function IsEqualEps(a: any, b: any, eps: any): boolean;
+export function IsGreater(a: any, b: any): boolean;
+export function IsGreaterOrEqual(a: any, b: any): boolean;
+export function IsLower(a: any, b: any): boolean;
+export function IsLowerOrEqual(a: any, b: any): boolean;
+export function IsModelEmpty(model: any): boolean;
+export function IsNegative(a: any): boolean;
+export function IsObjectEmpty(obj: any): boolean;
+export function IsPositive(a: any): boolean;
+export function IsPowerOfTwo(x: any): boolean;
+export function IsTwoManifold(object3D: any): boolean;
+export function IsUrl(str: any): boolean;
+export function IsZero(a: any): boolean;
+export function LinearToSRGB(component: any): number;
+export function LinearTweenFunction(distance: any, index: any, count: any): number;
+export function LoadExternalLibrary(libName: any): Promise<any>;
+export class MaterialBase {
+    constructor(type: any);
+    type: any;
+    isDefault: boolean;
+    name: string;
+    color: RGBColor;
+    vertexColors: boolean;
+    IsEqual(rhs: any): boolean;
+}
+export namespace MaterialType {
+    let Phong: number;
+    let Physical: number;
+}
+export class Matrix {
+    constructor(matrix: any);
+    matrix: any;
+    IsValid(): boolean;
+    Set(matrix: any): this;
+    Get(): any;
+    Clone(): Matrix;
+    CreateIdentity(): this;
+    IsIdentity(): boolean;
+    CreateTranslation(x: any, y: any, z: any): this;
+    CreateRotation(x: any, y: any, z: any, w: any): this;
+    CreateRotationAxisAngle(axis: any, angle: any): this;
+    CreateScale(x: any, y: any, z: any): this;
+    ComposeTRS(translation: any, rotation: any, scale: any): this;
+    DecomposeTRS(): {
+        translation: Coord3D;
+        rotation: Quaternion;
+        scale: Coord3D;
+    };
+    Determinant(): number;
+    Invert(): Matrix;
+    Transpose(): Matrix;
+    InvertTranspose(): Matrix;
+    MultiplyVector(vector: any): Coord4D;
+    MultiplyMatrix(matrix: any): Matrix;
+}
+export function MatrixIsEqual(a: any, b: any): boolean;
+export class Mesh extends ModelObject3D {
+    vertices: any[];
+    vertexColors: any[];
+    normals: any[];
+    uvs: any[];
+    triangles: any[];
+    AddVertex(vertex: any): number;
+    SetVertex(index: any, vertex: any): void;
+    GetVertex(index: any): any;
+    AddVertexColor(color: any): number;
+    SetVertexColor(index: any, color: any): void;
+    GetVertexColor(index: any): any;
+    AddNormal(normal: any): number;
+    SetNormal(index: any, normal: any): void;
+    GetNormal(index: any): any;
+    AddTextureUV(uv: any): number;
+    SetTextureUV(index: any, uv: any): void;
+    GetTextureUV(index: any): any;
+    AddTriangle(triangle: any): number;
+    GetTriangle(index: any): any;
+    Clone(): Mesh;
+}
+export class MeshBuffer {
+    primitives: any[];
+    PrimitiveCount(): number;
+    GetPrimitive(index: any): any;
+    GetByteLength(indexTypeSize: any, numberTypeSize: any): number;
+}
+export class MeshInstance extends ModelObject3D {
+    constructor(id: any, node: any, mesh: any);
+    id: any;
+    node: any;
+    mesh: any;
+    GetId(): any;
+    GetTransformation(): any;
+    GetMesh(): any;
+    VertexCount(): any;
+    VertexColorCount(): any;
+    NormalCount(): any;
+    TextureUVCount(): any;
+    TriangleCount(): any;
+    PropertyGroupCount(): any;
+    AddPropertyGroup(propertyGroup: any): any;
+    GetTransformedMesh(): any;
+}
+export class MeshInstanceId {
+    constructor(nodeId: any, meshIndex: any);
+    nodeId: any;
+    meshIndex: any;
+    IsEqual(rhs: any): boolean;
+    GetKey(): string;
+}
+export class MeshPrimitiveBuffer {
+    indices: any[];
+    vertices: any[];
+    colors: any[];
+    normals: any[];
+    uvs: any[];
+    material: any;
+    GetBounds(): {
+        min: number[];
+        max: number[];
+    };
+    GetByteLength(indexTypeSize: any, numberTypeSize: any): number;
+}
+export namespace MeshType {
+    let Empty: number;
+    let TriangleMesh: number;
+}
+export class Model extends ModelObject3D {
+    unit: number;
+    root: Node;
+    materials: any[];
+    meshes: any[];
+    GetUnit(): number;
+    SetUnit(unit: any): void;
+    GetRootNode(): Node;
+    NodeCount(): number;
+    MaterialCount(): number;
+    MeshCount(): number;
+    MeshInstanceCount(): number;
+    AddMaterial(material: any): number;
+    GetMaterial(index: any): any;
+    AddMesh(mesh: any): number;
+    AddMeshToRootNode(mesh: any): number;
+    RemoveMesh(index: any): void;
+    GetMesh(index: any): any;
+    GetMeshInstance(instanceId: any): MeshInstance;
+    EnumerateMeshes(onMesh: any): void;
+    EnumerateMeshInstances(onMeshInstance: any): void;
+    EnumerateTransformedMeshInstances(onMesh: any): void;
+}
+export class ModelObject3D extends Object3D {
+    name: string;
+    propertyGroups: any[];
+    GetName(): string;
+    SetName(name: any): void;
+    PropertyGroupCount(): number;
+    AddPropertyGroup(propertyGroup: any): number;
+    GetPropertyGroup(index: any): any;
+    CloneProperties(target: any): void;
+}
+export class ModelToThreeConversionOutput {
+    defaultMaterial: any;
+    objectUrls: any[];
+}
+export class ModelToThreeConversionParams {
+    forceMediumpForMaterials: boolean;
+}
+export class MouseInteraction {
+    prev: Coord2D;
+    curr: Coord2D;
+    diff: Coord2D;
+    buttons: any[];
+    Down(canvas: any, ev: any): void;
+    Move(canvas: any, ev: any): void;
+    Up(canvas: any, ev: any): void;
+    Leave(canvas: any, ev: any): void;
+    IsButtonDown(): boolean;
+    GetButton(): any;
+    GetPosition(): Coord2D;
+    GetMoveDiff(): Coord2D;
+    GetPositionFromEvent(canvas: any, ev: any): Coord2D;
+}
+export function NameFromLine(line: any, startIndex: any, commentChar: any): any;
+export class Navigation {
+    constructor(canvas: any, camera: any, callbacks: any);
+    canvas: any;
+    camera: any;
+    callbacks: any;
+    fixUpVector: boolean;
+    mouse: MouseInteraction;
+    touch: TouchInteraction;
+    clickDetector: ClickDetector;
+    onMouseClick: any;
+    onMouseMove: any;
+    onContext: any;
+    SetMouseClickHandler(onMouseClick: any): void;
+    SetMouseMoveHandler(onMouseMove: any): void;
+    SetContextMenuHandler(onContext: any): void;
+    IsFixUpVector(): boolean;
+    SetFixUpVector(isFixUpVector: any): void;
+    GetCamera(): any;
+    SetCamera(camera: any): void;
+    MoveCamera(newCamera: any, stepCount: any): void;
+    GetFitToSphereCamera(center: any, radius: any): any;
+    OnMouseDown(ev: any): void;
+    OnMouseMove(ev: any): void;
+    OnMouseUp(ev: any): void;
+    OnMouseLeave(ev: any): void;
+    OnTouchStart(ev: any): void;
+    OnTouchMove(ev: any): void;
+    OnTouchEnd(ev: any): void;
+    OnMouseWheel(ev: any): void;
+    OnContextMenu(ev: any): void;
+    Orbit(angleX: any, angleY: any): void;
+    Pan(moveX: any, moveY: any): void;
+    Zoom(ratio: any): void;
+    Update(): void;
+    Click(button: any, mouseCoords: any): void;
+    Context(clientX: any, clientY: any): void;
+}
+export namespace NavigationType {
+    let None: number;
+    let Orbit: number;
+    let Pan: number;
+    let Zoom: number;
+}
+export function NextPowerOfTwo(x: any): any;
+export class Node {
+    name: string;
+    parent: any;
+    transformation: Transformation;
+    childNodes: any[];
+    meshIndices: any[];
+    idGenerator: NodeIdGenerator;
+    id: number;
+    IsEmpty(): boolean;
+    IsMeshNode(): boolean;
+    GetId(): number;
+    GetName(): string;
+    SetName(name: any): void;
+    HasParent(): boolean;
+    GetParent(): any;
+    GetTransformation(): Transformation;
+    GetWorldTransformation(): Transformation;
+    SetTransformation(transformation: any): void;
+    AddChildNode(node: any): number;
+    RemoveChildNode(node: any): void;
+    GetChildNodes(): any[];
+    ChildNodeCount(): number;
+    GetChildNode(index: any): any;
+    AddMeshIndex(index: any): number;
+    MeshIndexCount(): number;
+    GetMeshIndex(index: any): any;
+    GetMeshIndices(): any[];
+    Enumerate(processor: any): void;
+    EnumerateChildren(processor: any): void;
+    EnumerateMeshIndices(processor: any): void;
+}
+export class Object3D {
+    VertexCount(): number;
+    VertexColorCount(): number;
+    NormalCount(): number;
+    TextureUVCount(): number;
+    TriangleCount(): number;
+    EnumerateVertices(onVertex: any): void;
+    EnumerateTriangleVertexIndices(onTriangleVertexIndices: any): void;
+    EnumerateTriangleVertices(onTriangleVertices: any): void;
+}
+export class Octree {
+    constructor(boundingBox: any, options: any);
+    options: {
+        maxPointsPerNode: number;
+        maxTreeDepth: number;
+    };
+    rootNode: OctreeNode;
+    AddPoint(point: any, data: any): any;
+    FindPoint(point: any): any;
+}
+export class OctreeNode {
+    constructor(boundingBox: any, level: any);
+    boundingBox: any;
+    level: any;
+    pointItems: any[];
+    childNodes: any[];
+    AddPoint(point: any, data: any, options: any): any;
+    FindPoint(point: any): any;
+    AddPointDirectly(point: any, data: any): void;
+    FindPointDirectly(point: any): any;
+    FindNodeForPoint(point: any): any;
+    CreateChildNodes(): void;
+    IsPointInBounds(point: any): boolean;
+}
+export function ParabolicTweenFunction(distance: any, index: any, count: any): number;
+export namespace ParameterConverter {
+    function IntegerToString(integer: any): any;
+    function StringToInteger(str: any): number;
+    function NumberToString(number: any): any;
+    function StringToNumber(str: any): number;
+    function ModelUrlsToString(urls: any): any;
+    function StringToModelUrls(str: any): any;
+    function CameraToString(camera: any): string;
+    function CameraModeToString(cameraMode: any): "perspective" | "orthographic";
+    function StringToCamera(str: any): Camera;
+    function StringToCameraMode(str: any): number;
+    function RGBColorToString(color: any): string;
+    function RGBAColorToString(color: any): string;
+    function StringToRGBColor(str: any): RGBColor;
+    function StringToRGBAColor(str: any): RGBAColor;
+    function EnvironmentSettingsToString(environmentSettings: any): string;
+    function StringToEnvironmentSettings(str: any): {
+        environmentMapName: any;
+        backgroundIsEnvMap: boolean;
+    };
+    function EdgeSettingsToString(edgeSettings: any): string;
+    function StringToEdgeSettings(str: any): EdgeSettings;
+}
+export class ParameterListBuilder {
+    constructor(separator: any);
+    separator: any;
+    paramList: string;
+    AddModelUrls(urls: any): this;
+    AddCamera(camera: any): this;
+    AddCameraMode(cameraMode: any): this;
+    AddEnvironmentSettings(envSettings: any): this;
+    AddBackgroundColor(background: any): this;
+    AddDefaultColor(color: any): this;
+    AddEdgeSettings(edgeSettings: any): this;
+    AddUrlPart(keyword: any, urlPart: any): void;
+    GetParameterList(): string;
+}
+export class ParameterListParser {
+    constructor(paramList: any, separator: any);
+    separator: any;
+    paramList: any;
+    GetModelUrls(): any;
+    GetCamera(): Camera;
+    GetCameraMode(): number;
+    GetEnvironmentSettings(): {
+        environmentMapName: any;
+        backgroundIsEnvMap: boolean;
+    };
+    GetBackgroundColor(): RGBAColor;
+    GetDefaultColor(): RGBColor;
+    GetEdgeSettings(): EdgeSettings;
+    GetKeywordParams(keyword: any): any;
+}
+export function ParametersFromLine(line: any, commentChar: any): any;
+export class PhongMaterial extends FaceMaterial {
+    constructor();
+    ambient: RGBColor;
+    specular: RGBColor;
+    shininess: number;
+    specularMap: any;
+}
+export class PhysicalMaterial extends FaceMaterial {
+    constructor();
+    metalness: number;
+    roughness: number;
+    metalnessMap: any;
+}
+export class Property {
+    constructor(type: any, name: any, value: any);
+    type: any;
+    name: any;
+    value: any;
+    Clone(): Property;
+}
+export class PropertyGroup {
+    constructor(name: any);
+    name: any;
+    properties: any[];
+    PropertyCount(): number;
+    AddProperty(property: any): void;
+    GetProperty(index: any): any;
+    Clone(): PropertyGroup;
+}
+export function PropertyToString(property: any): any;
+export namespace PropertyType {
+    let Text_1: number;
+    export { Text_1 as Text };
+    export let Integer: number;
+    export let Number: number;
+    export let Boolean: number;
+    export let Percent: number;
+    export let Color: number;
+}
+export class Quaternion {
+    constructor(x: any, y: any, z: any, w: any);
+    x: any;
+    y: any;
+    z: any;
+    w: any;
+}
+export function QuaternionFromAxisAngle(axis: any, angle: any): Quaternion;
+export function QuaternionFromXYZ(x: any, y: any, z: any, mode: any): Quaternion;
+export function QuaternionIsEqual(a: any, b: any): boolean;
+/**
+ * RGBA color object. Components are integers in the range of 0..255.
+ */
+export class RGBAColor {
+    /**
+     * @param {integer} r Red component.
+     * @param {integer} g Green component.
+     * @param {integer} b Blue component.
+     * @param {integer} a Alpha component.
+     */
+    constructor(r: integer, g: integer, b: integer, a: integer);
+    r: integer;
+    g: integer;
+    b: integer;
+    a: integer;
+    /**
+     * Sets the value of all components.
+     * @param {integer} r Red component.
+     * @param {integer} g Green component.
+     * @param {integer} b Blue component.
+     * @param {integer} a Alpha component.
+     */
+    Set(r: integer, g: integer, b: integer, a: integer): void;
+    /**
+     * Creates a clone of the object.
+     * @returns {RGBAColor}
+     */
+    Clone(): RGBAColor;
+}
+export function RGBAColorToHexString(color: any): string;
+/**
+ * RGB color object. Components are integers in the range of 0..255.
+ */
+export class RGBColor {
+    /**
+     * @param {integer} r Red component.
+     * @param {integer} g Green component.
+     * @param {integer} b Blue component.
+     */
+    constructor(r: integer, g: integer, b: integer);
+    r: integer;
+    g: integer;
+    b: integer;
+    /**
+     * Sets the value of all components.
+     * @param {integer} r Red component.
+     * @param {integer} g Green component.
+     * @param {integer} b Blue component.
+     */
+    Set(r: integer, g: integer, b: integer): void;
+    /**
+     * Creates a clone of the object.
+     * @returns {RGBColor}
+     */
+    Clone(): RGBColor;
+}
+export function RGBColorFromFloatComponents(r: any, g: any, b: any): RGBColor;
+export function RGBColorIsEqual(a: any, b: any): boolean;
+export function RGBColorToHexString(color: any): string;
+export const RadDeg: 57.29577951308232;
+export function ReadFile(file: any, onProgress: any): Promise<any>;
+export function ReadLines(str: any, onLine: any): void;
+export function ReplaceDefaultMaterialColor(model: any, color: any): void;
+export function RequestUrl(url: any, onProgress: any): Promise<any>;
+export function RevokeObjectUrl(url: any): void;
+export function RunTaskAsync(task: any): void;
+export function RunTasks(count: any, callbacks: any): void;
+export function RunTasksBatch(count: any, batchCount: any, callbacks: any): void;
+export function SRGBToLinear(component: any): number;
+export function SetDomElementHeight(element: any, height: any): void;
+export function SetDomElementOuterHeight(element: any, height: any): void;
+export function SetDomElementOuterWidth(element: any, width: any): void;
+export function SetDomElementWidth(element: any, width: any): void;
+/**
+ * Sets the location of the external libraries used by the engine. This is the content of the libs
+ * folder in the package. The location must be relative to the main file.
+ * @param {string} newExternalLibLocation Relative path to the libs folder.
+ */
+export function SetExternalLibLocation(newExternalLibLocation: string): void;
+export function SetThreeMeshPolygonOffset(mesh: any, offset: any): void;
+export class ShadingModel {
+    constructor(scene: any);
+    scene: any;
+    type: number;
+    cameraMode: number;
+    ambientLight: any;
+    directionalLight: any;
+    environmentSettings: EnvironmentSettings;
+    environment: any;
+    SetShadingType(type: any): void;
+    SetCameraMode(cameraMode: any): void;
+    UpdateShading(): void;
+    SetEnvironmentMapSettings(environmentSettings: any, onLoaded: any): void;
+    UpdateByCamera(camera: any): void;
+    CreateHighlightMaterial(highlightColor: any, withOffset: any): any;
+}
+export namespace ShadingType {
+    let Phong_1: number;
+    export { Phong_1 as Phong };
+    let Physical_1: number;
+    export { Physical_1 as Physical };
+}
+export function ShowDomElement(element: any, show: any): void;
+export function SubCoord2D(a: any, b: any): Coord2D;
+export function SubCoord3D(a: any, b: any): Coord3D;
+export class TaskRunner {
+    count: any;
+    current: number;
+    callbacks: any;
+    Run(count: any, callbacks: any): void;
+    RunBatch(count: any, batchCount: any, callbacks: any): void;
+    RunOnce(): void;
+    TaskReady(): void;
+}
+export class TextWriter {
+    text: string;
+    indentation: number;
+    GetText(): string;
+    Indent(diff: any): void;
+    WriteArrayLine(arr: any): void;
+    WriteLine(str: any): void;
+    WriteIndentation(): void;
+    Write(str: any): void;
+}
+export function TextureIsEqual(a: any, b: any): boolean;
+export class TextureMap {
+    name: any;
+    mimeType: any;
+    buffer: any;
+    offset: Coord2D;
+    scale: Coord2D;
+    rotation: number;
+    IsValid(): boolean;
+    HasTransformation(): boolean;
+    IsEqual(rhs: any): boolean;
+}
+export function TextureMapIsEqual(aTex: any, bTex: any): any;
+export class ThreeColorConverter {
+    Convert(color: any): any;
+}
+export class ThreeConversionStateHandler {
+    constructor(callbacks: any);
+    callbacks: any;
+    texturesNeeded: number;
+    texturesLoaded: number;
+    threeObject: any;
+    OnTextureNeeded(): void;
+    OnTextureLoaded(): void;
+    OnModelLoaded(threeObject: any): void;
+    Finish(): void;
+}
+export class ThreeLinearToSRGBColorConverter extends ThreeColorConverter {
+}
+export class ThreeModelLoader {
+    importer: Importer;
+    inProgress: boolean;
+    defaultMaterial: any;
+    objectUrls: any[];
+    hasHighpDriverIssue: boolean;
+    InProgress(): boolean;
+    LoadModel(inputFiles: any, settings: any, callbacks: any): void;
+    GetImporter(): Importer;
+    GetDefaultMaterial(): any;
+    ReplaceDefaultMaterialColor(defaultColor: any): void;
+    RevokeObjectUrls(): void;
+    Destroy(): void;
+}
+export class ThreeNodeTree {
+    constructor(model: any, threeRootNode: any);
+    model: any;
+    threeNodeItems: any[];
+    AddNode(node: any, threeNode: any): void;
+    GetNodeItems(): any[];
+}
+export class ThreeSRGBToLinearColorConverter extends ThreeColorConverter {
+}
+export class Topology {
+    vertices: any[];
+    edges: any[];
+    triangleEdges: any[];
+    triangles: any[];
+    edgeStartToEndVertexMap: Map<any, any>;
+    AddVertex(): number;
+    AddTriangle(vertex1: any, vertex2: any, vertex3: any): void;
+    AddTriangleEdge(vertex1: any, vertex2: any): number;
+    AddEdge(startVertex: any, endVertex: any): any;
+}
+export class TopologyEdge {
+    constructor(vertex1: any, vertex2: any);
+    vertex1: any;
+    vertex2: any;
+    triangles: any[];
+}
+export class TopologyTriangle {
+    triEdge1: any;
+    triEdge2: any;
+    triEdge3: any;
+}
+export class TopologyTriangleEdge {
+    constructor(edge: any, reversed: any);
+    edge: any;
+    reversed: any;
+}
+export class TopologyVertex {
+    edges: any[];
+    triangles: any[];
+}
+export class TouchInteraction {
+    prevPos: Coord2D;
+    currPos: Coord2D;
+    diffPos: Coord2D;
+    prevDist: number;
+    currDist: number;
+    diffDist: number;
+    fingers: number;
+    Start(canvas: any, ev: any): void;
+    Move(canvas: any, ev: any): void;
+    End(canvas: any, ev: any): void;
+    IsFingerDown(): boolean;
+    GetFingerCount(): number;
+    GetPosition(): Coord2D;
+    GetMoveDiff(): Coord2D;
+    GetDistanceDiff(): number;
+    GetPositionFromEvent(canvas: any, ev: any): Coord2D;
+    GetTouchDistanceFromEvent(canvas: any, ev: any): number;
+}
+export function TransformFileHostUrls(urls: any): void;
+export function TransformMesh(mesh: any, transformation: any): void;
+export class Transformation {
+    constructor(matrix: any);
+    matrix: any;
+    SetMatrix(matrix: any): this;
+    GetMatrix(): any;
+    IsIdentity(): any;
+    AppendMatrix(matrix: any): this;
+    Append(transformation: any): this;
+    TransformCoord3D(coord: any): Coord3D;
+    Clone(): Transformation;
+}
+export function TransformationIsEqual(a: any, b: any): boolean;
+export function TraverseThreeObject(object: any, processor: any): boolean;
+export class Triangle {
+    constructor(v0: any, v1: any, v2: any);
+    v0: any;
+    v1: any;
+    v2: any;
+    c0: any;
+    c1: any;
+    c2: any;
+    n0: any;
+    n1: any;
+    n2: any;
+    u0: any;
+    u1: any;
+    u2: any;
+    mat: any;
+    curve: any;
+    HasVertices(): boolean;
+    HasVertexColors(): boolean;
+    HasNormals(): boolean;
+    HasTextureUVs(): boolean;
+    SetVertices(v0: any, v1: any, v2: any): this;
+    SetVertexColors(c0: any, c1: any, c2: any): this;
+    SetNormals(n0: any, n1: any, n2: any): this;
+    SetTextureUVs(u0: any, u1: any, u2: any): this;
+    SetMaterial(mat: any): this;
+    SetCurve(curve: any): this;
+    Clone(): Triangle;
+}
+export function TweenCoord3D(a: any, b: any, count: any, tweenFunc: any): any[];
+export namespace Unit {
+    let Unknown: number;
+    let Millimeter: number;
+    let Centimeter: number;
+    let Meter: number;
+    let Inch: number;
+    let Foot: number;
+}
+export class UpVector {
+    direction: number;
+    isFixed: boolean;
+    isFlipped: boolean;
+    SetDirection(newDirection: any, oldCamera: any): any;
+    SetFixed(isFixed: any, oldCamera: any): any;
+    Flip(oldCamera: any): any;
+}
+export function UpdateMaterialTransparency(material: any): void;
+export function Utf8StringToArrayBuffer(str: any): ArrayBufferLike;
+export function ValueOrDefault(val: any, def: any): any;
+export function VectorAngle3D(a: any, b: any): number;
+export function VectorLength3D(x: any, y: any, z: any): number;
+export class Viewer {
+    canvas: any;
+    renderer: any;
+    scene: any;
+    mainModel: ViewerMainModel;
+    extraModel: ViewerModel;
+    camera: any;
+    cameraMode: any;
+    cameraValidator: CameraValidator;
+    shadingModel: ShadingModel;
+    navigation: Navigation;
+    upVector: UpVector;
+    settings: {
+        animationSteps: number;
+    };
+    Init(canvas: any): void;
+    SetMouseClickHandler(onMouseClick: any): void;
+    SetMouseMoveHandler(onMouseMove: any): void;
+    SetContextMenuHandler(onContext: any): void;
+    SetEdgeSettings(edgeSettings: any): void;
+    SetEnvironmentMapSettings(environmentSettings: any): void;
+    SetBackgroundColor(color: any): void;
+    GetCanvas(): any;
+    GetCamera(): any;
+    GetCameraMode(): any;
+    SetCamera(camera: any): void;
+    SetCameraMode(cameraMode: any): void;
+    Resize(width: any, height: any): void;
+    ResizeRenderer(width: any, height: any): void;
+    FitSphereToWindow(boundingSphere: any, animation: any): void;
+    AdjustClippingPlanes(): void;
+    AdjustClippingPlanesToSphere(boundingSphere: any): void;
+    IsFixUpVector(): boolean;
+    SetFixUpVector(isFixUpVector: any): void;
+    SetUpVector(upDirection: any, animate: any): void;
+    FlipUpVector(): void;
+    Render(): void;
+    SetMainObject(object: any): void;
+    AddExtraObject(object: any): void;
+    Clear(): void;
+    ClearExtra(): void;
+    SetMeshesVisibility(isVisible: any): void;
+    SetMeshesHighlight(highlightColor: any, isHighlighted: any): void;
+    CreateHighlightMaterial(highlightColor: any): any;
+    GetMeshUserDataUnderMouse(mouseCoords: any): any;
+    GetMeshIntersectionUnderMouse(mouseCoords: any): any;
+    GetBoundingBox(needToProcess: any): any;
+    GetBoundingSphere(needToProcess: any): any;
+    EnumerateMeshesUserData(enumerator: any): void;
+    InitNavigation(): void;
+    InitShading(): void;
+    GetShadingType(): number;
+    GetImageSize(): {
+        width: number;
+        height: number;
+    };
+    GetCanvasSize(): {
+        width: any;
+        height: any;
+    };
+    GetImageAsDataUrl(width: any, height: any, isTransparent: any): any;
+    Destroy(): void;
+}
+export class ViewerMainModel {
+    constructor(scene: any);
+    scene: any;
+    mainModel: ViewerModel;
+    edgeModel: ViewerModel;
+    edgeSettings: EdgeSettings;
+    SetMainObject(mainObject: any): void;
+    UpdateWorldMatrix(): void;
+    SetEdgeSettings(edgeSettings: any): void;
+    GenerateEdgeModel(): void;
+    GetBoundingBox(needToProcess: any): any;
+    GetBoundingSphere(needToProcess: any): any;
+    Clear(): void;
+    ClearEdgeModel(): void;
+    EnumerateMeshes(enumerator: any): void;
+    EnumerateEdges(enumerator: any): void;
+    GetMeshIntersectionUnderMouse(mouseCoords: any, camera: any, width: any, height: any): any;
+}
+export class ViewerModel {
+    constructor(scene: any);
+    scene: any;
+    rootObject: any;
+    IsEmpty(): boolean;
+    SetRootObject(rootObject: any): void;
+    GetRootObject(): any;
+    AddObject(object: any): void;
+    Traverse(enumerator: any): void;
+    UpdateWorldMatrix(): void;
+    Clear(): void;
+}
+export function WaitWhile(expression: any): void;
+declare class Importer3dsNodeList {
+    nodes: any[];
+    nodeIdToNode: Map<any, any>;
+    IsEmpty(): boolean;
+    AddNode(node: any): void;
+    GetNodes(): any[];
+}
+declare class FreeCadDocument {
+    files: fflate.Unzipped;
+    properties: PropertyGroup;
+    objectNames: any[];
+    objectData: Map<any, any>;
+    Init(fileContent: any): number;
+    GetObjectListToConvert(): any[];
+    IsSupportedType(type: any): boolean;
+    HasFile(fileName: any): boolean;
+    LoadDocumentXml(): boolean;
+    LoadGuiDocumentXml(): boolean;
+    GetPropertiesFromElement(propertiesElement: any, propertyGroup: any): void;
+    GetXMLContent(xmlFileName: any): Document;
+    GetFirstChildValue(element: any, childTagName: any, childAttribute: any): any;
+}
+declare class GltfExtensions {
+    supportedExtensions: string[];
+    draco: any;
+    LoadLibraries(extensionsRequired: any, callbacks: any): void;
+    GetUnsupportedExtensions(extensionsRequired: any): any[];
+    ProcessMaterial(gltfMaterial: any, material: any, imporTextureFn: any): PhongMaterial;
+    ProcessTexture(gltfTexture: any, texture: any): void;
+    ProcessPrimitive(importer: any, gltf: any, primitive: any, mesh: any): boolean;
+}
+declare class GltfBufferReader {
+    constructor(buffer: any);
+    reader: BinaryReader;
+    componentType: any;
+    dataType: number;
+    byteStride: any;
+    dataCount: any;
+    sparseReader: {
+        indexReader: any;
+        valueReader: any;
+    };
+    SetComponentType(componentType: any): void;
+    SetDataType(dataType: any): void;
+    SetByteStride(byteStride: any): void;
+    SetDataCount(dataCount: any): void;
+    SetSparseReader(indexReader: any, valueReader: any): void;
+    ReadArrayBuffer(byteLength: any): ArrayBuffer;
+    GetDataCount(): any;
+    ReadData(): number | Coord2D | Coord3D | Coord4D;
+    EnumerateData(onData: any): void;
+    SkipBytes(bytes: any): void;
+    ReadComponent(): number;
+    SkipBytesByStride(componentCount: any): void;
+    GetComponentSize(): 0 | 1 | 2 | 4;
+}
+declare class PlyHeader {
+    format: any;
+    elements: any[];
+    SetFormat(format: any): void;
+    AddElement(name: any, count: any): void;
+    GetElements(): any[];
+    AddSingleFormat(elemType: any, name: any): void;
+    AddListFormat(countType: any, elemType: any, name: any): void;
+    GetElement(name: any): any;
+    Check(): number;
+}
+declare class NodeIdGenerator {
+    nextId: number;
+    GenerateId(): number;
+}
+import * as fflate from 'fflate';
+export {};

public/libs/online-3d-viewer/libs/loaders/draco.license.md

+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+--------------------------------------------------------------------------------
+Files: docs/assets/js/ASCIIMathML.js
+
+Copyright (c) 2014 Peter Jipsen and other ASCIIMathML.js contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--------------------------------------------------------------------------------
+Files: docs/assets/css/pygments/*
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>

public/libs/online-3d-viewer/libs/loaders/draco_decoder.js

+var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.arrayIteratorImpl=function(k){var n=0;return function(){return n<k.length?{done:!1,value:k[n++]}:{done:!0}}};$jscomp.arrayIterator=function(k){return{next:$jscomp.arrayIteratorImpl(k)}};$jscomp.makeIterator=function(k){var n="undefined"!=typeof Symbol&&Symbol.iterator&&k[Symbol.iterator];return n?n.call(k):$jscomp.arrayIterator(k)};$jscomp.ASSUME_ES5=!1;$jscomp.ASSUME_NO_NATIVE_MAP=!1;$jscomp.ASSUME_NO_NATIVE_SET=!1;$jscomp.SIMPLE_FROUND_POLYFILL=!1;
+$jscomp.ISOLATE_POLYFILLS=!1;$jscomp.FORCE_POLYFILL_PROMISE=!1;$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION=!1;$jscomp.getGlobal=function(k){k=["object"==typeof globalThis&&globalThis,k,"object"==typeof window&&window,"object"==typeof self&&self,"object"==typeof global&&global];for(var n=0;n<k.length;++n){var l=k[n];if(l&&l.Math==Math)return l}throw Error("Cannot find global object");};$jscomp.global=$jscomp.getGlobal(this);
+$jscomp.defineProperty=$jscomp.ASSUME_ES5||"function"==typeof Object.defineProperties?Object.defineProperty:function(k,n,l){if(k==Array.prototype||k==Object.prototype)return k;k[n]=l.value;return k};$jscomp.IS_SYMBOL_NATIVE="function"===typeof Symbol&&"symbol"===typeof Symbol("x");$jscomp.TRUST_ES6_POLYFILLS=!$jscomp.ISOLATE_POLYFILLS||$jscomp.IS_SYMBOL_NATIVE;$jscomp.polyfills={};$jscomp.propertyToPolyfillSymbol={};$jscomp.POLYFILL_PREFIX="$jscp$";
+var $jscomp$lookupPolyfilledValue=function(k,n){var l=$jscomp.propertyToPolyfillSymbol[n];if(null==l)return k[n];l=k[l];return void 0!==l?l:k[n]};$jscomp.polyfill=function(k,n,l,p){n&&($jscomp.ISOLATE_POLYFILLS?$jscomp.polyfillIsolated(k,n,l,p):$jscomp.polyfillUnisolated(k,n,l,p))};
+$jscomp.polyfillUnisolated=function(k,n,l,p){l=$jscomp.global;k=k.split(".");for(p=0;p<k.length-1;p++){var h=k[p];if(!(h in l))return;l=l[h]}k=k[k.length-1];p=l[k];n=n(p);n!=p&&null!=n&&$jscomp.defineProperty(l,k,{configurable:!0,writable:!0,value:n})};
+$jscomp.polyfillIsolated=function(k,n,l,p){var h=k.split(".");k=1===h.length;p=h[0];p=!k&&p in $jscomp.polyfills?$jscomp.polyfills:$jscomp.global;for(var A=0;A<h.length-1;A++){var f=h[A];if(!(f in p))return;p=p[f]}h=h[h.length-1];l=$jscomp.IS_SYMBOL_NATIVE&&"es6"===l?p[h]:null;n=n(l);null!=n&&(k?$jscomp.defineProperty($jscomp.polyfills,h,{configurable:!0,writable:!0,value:n}):n!==l&&(void 0===$jscomp.propertyToPolyfillSymbol[h]&&(l=1E9*Math.random()>>>0,$jscomp.propertyToPolyfillSymbol[h]=$jscomp.IS_SYMBOL_NATIVE?
+$jscomp.global.Symbol(h):$jscomp.POLYFILL_PREFIX+l+"$"+h),$jscomp.defineProperty(p,$jscomp.propertyToPolyfillSymbol[h],{configurable:!0,writable:!0,value:n})))};
+$jscomp.polyfill("Promise",function(k){function n(){this.batch_=null}function l(f){return f instanceof h?f:new h(function(q,v){q(f)})}if(k&&(!($jscomp.FORCE_POLYFILL_PROMISE||$jscomp.FORCE_POLYFILL_PROMISE_WHEN_NO_UNHANDLED_REJECTION&&"undefined"===typeof $jscomp.global.PromiseRejectionEvent)||!$jscomp.global.Promise||-1===$jscomp.global.Promise.toString().indexOf("[native code]")))return k;n.prototype.asyncExecute=function(f){if(null==this.batch_){this.batch_=[];var q=this;this.asyncExecuteFunction(function(){q.executeBatch_()})}this.batch_.push(f)};
+var p=$jscomp.global.setTimeout;n.prototype.asyncExecuteFunction=function(f){p(f,0)};n.prototype.executeBatch_=function(){for(;this.batch_&&this.batch_.length;){var f=this.batch_;this.batch_=[];for(var q=0;q<f.length;++q){var v=f[q];f[q]=null;try{v()}catch(z){this.asyncThrow_(z)}}}this.batch_=null};n.prototype.asyncThrow_=function(f){this.asyncExecuteFunction(function(){throw f;})};var h=function(f){this.state_=0;this.result_=void 0;this.onSettledCallbacks_=[];this.isRejectionHandled_=!1;var q=this.createResolveAndReject_();
+try{f(q.resolve,q.reject)}catch(v){q.reject(v)}};h.prototype.createResolveAndReject_=function(){function f(z){return function(O){v||(v=!0,z.call(q,O))}}var q=this,v=!1;return{resolve:f(this.resolveTo_),reject:f(this.reject_)}};h.prototype.resolveTo_=function(f){if(f===this)this.reject_(new TypeError("A Promise cannot resolve to itself"));else if(f instanceof h)this.settleSameAsPromise_(f);else{a:switch(typeof f){case "object":var q=null!=f;break a;case "function":q=!0;break a;default:q=!1}q?this.resolveToNonPromiseObj_(f):
+this.fulfill_(f)}};h.prototype.resolveToNonPromiseObj_=function(f){var q=void 0;try{q=f.then}catch(v){this.reject_(v);return}"function"==typeof q?this.settleSameAsThenable_(q,f):this.fulfill_(f)};h.prototype.reject_=function(f){this.settle_(2,f)};h.prototype.fulfill_=function(f){this.settle_(1,f)};h.prototype.settle_=function(f,q){if(0!=this.state_)throw Error("Cannot settle("+f+", "+q+"): Promise already settled in state"+this.state_);this.state_=f;this.result_=q;2===this.state_&&this.scheduleUnhandledRejectionCheck_();
+this.executeOnSettledCallbacks_()};h.prototype.scheduleUnhandledRejectionCheck_=function(){var f=this;p(function(){if(f.notifyUnhandledRejection_()){var q=$jscomp.global.console;"undefined"!==typeof q&&q.error(f.result_)}},1)};h.prototype.notifyUnhandledRejection_=function(){if(this.isRejectionHandled_)return!1;var f=$jscomp.global.CustomEvent,q=$jscomp.global.Event,v=$jscomp.global.dispatchEvent;if("undefined"===typeof v)return!0;"function"===typeof f?f=new f("unhandledrejection",{cancelable:!0}):
+"function"===typeof q?f=new q("unhandledrejection",{cancelable:!0}):(f=$jscomp.global.document.createEvent("CustomEvent"),f.initCustomEvent("unhandledrejection",!1,!0,f));f.promise=this;f.reason=this.result_;return v(f)};h.prototype.executeOnSettledCallbacks_=function(){if(null!=this.onSettledCallbacks_){for(var f=0;f<this.onSettledCallbacks_.length;++f)A.asyncExecute(this.onSettledCallbacks_[f]);this.onSettledCallbacks_=null}};var A=new n;h.prototype.settleSameAsPromise_=function(f){var q=this.createResolveAndReject_();
+f.callWhenSettled_(q.resolve,q.reject)};h.prototype.settleSameAsThenable_=function(f,q){var v=this.createResolveAndReject_();try{f.call(q,v.resolve,v.reject)}catch(z){v.reject(z)}};h.prototype.then=function(f,q){function v(t,x){return"function"==typeof t?function(D){try{z(t(D))}catch(R){O(R)}}:x}var z,O,ba=new h(function(t,x){z=t;O=x});this.callWhenSettled_(v(f,z),v(q,O));return ba};h.prototype.catch=function(f){return this.then(void 0,f)};h.prototype.callWhenSettled_=function(f,q){function v(){switch(z.state_){case 1:f(z.result_);
+break;case 2:q(z.result_);break;default:throw Error("Unexpected state: "+z.state_);}}var z=this;null==this.onSettledCallbacks_?A.asyncExecute(v):this.onSettledCallbacks_.push(v);this.isRejectionHandled_=!0};h.resolve=l;h.reject=function(f){return new h(function(q,v){v(f)})};h.race=function(f){return new h(function(q,v){for(var z=$jscomp.makeIterator(f),O=z.next();!O.done;O=z.next())l(O.value).callWhenSettled_(q,v)})};h.all=function(f){var q=$jscomp.makeIterator(f),v=q.next();return v.done?l([]):new h(function(z,
+O){function ba(D){return function(R){t[D]=R;x--;0==x&&z(t)}}var t=[],x=0;do t.push(void 0),x++,l(v.value).callWhenSettled_(ba(t.length-1),O),v=q.next();while(!v.done)})};return h},"es6","es3");$jscomp.owns=function(k,n){return Object.prototype.hasOwnProperty.call(k,n)};$jscomp.assign=$jscomp.TRUST_ES6_POLYFILLS&&"function"==typeof Object.assign?Object.assign:function(k,n){for(var l=1;l<arguments.length;l++){var p=arguments[l];if(p)for(var h in p)$jscomp.owns(p,h)&&(k[h]=p[h])}return k};
+$jscomp.polyfill("Object.assign",function(k){return k||$jscomp.assign},"es6","es3");$jscomp.checkStringArgs=function(k,n,l){if(null==k)throw new TypeError("The 'this' value for String.prototype."+l+" must not be null or undefined");if(n instanceof RegExp)throw new TypeError("First argument to String.prototype."+l+" must not be a regular expression");return k+""};
+$jscomp.polyfill("String.prototype.startsWith",function(k){return k?k:function(n,l){var p=$jscomp.checkStringArgs(this,n,"startsWith");n+="";var h=p.length,A=n.length;l=Math.max(0,Math.min(l|0,p.length));for(var f=0;f<A&&l<h;)if(p[l++]!=n[f++])return!1;return f>=A}},"es6","es3");
+$jscomp.polyfill("Array.prototype.copyWithin",function(k){function n(l){l=Number(l);return Infinity===l||-Infinity===l?l:l|0}return k?k:function(l,p,h){var A=this.length;l=n(l);p=n(p);h=void 0===h?A:n(h);l=0>l?Math.max(A+l,0):Math.min(l,A);p=0>p?Math.max(A+p,0):Math.min(p,A);h=0>h?Math.max(A+h,0):Math.min(h,A);if(l<p)for(;p<h;)p in this?this[l++]=this[p++]:(delete this[l++],p++);else for(h=Math.min(h,A+p-l),l+=h-p;h>p;)--h in this?this[--l]=this[h]:delete this[--l];return this}},"es6","es3");
+$jscomp.typedArrayCopyWithin=function(k){return k?k:Array.prototype.copyWithin};$jscomp.polyfill("Int8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint8ClampedArray.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
+$jscomp.polyfill("Uint16Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Int32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Uint32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float32Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");$jscomp.polyfill("Float64Array.prototype.copyWithin",$jscomp.typedArrayCopyWithin,"es6","es5");
+var DracoDecoderModule=function(){var k="undefined"!==typeof document&&document.currentScript?document.currentScript.src:void 0;"undefined"!==typeof __filename&&(k=k||__filename);return function(n){function l(e){return a.locateFile?a.locateFile(e,U):U+e}function p(e,b,c){var d=b+c;for(c=b;e[c]&&!(c>=d);)++c;if(16<c-b&&e.buffer&&va)return va.decode(e.subarray(b,c));for(d="";b<c;){var g=e[b++];if(g&128){var u=e[b++]&63;if(192==(g&224))d+=String.fromCharCode((g&31)<<6|u);else{var X=e[b++]&63;g=224==
+(g&240)?(g&15)<<12|u<<6|X:(g&7)<<18|u<<12|X<<6|e[b++]&63;65536>g?d+=String.fromCharCode(g):(g-=65536,d+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else d+=String.fromCharCode(g)}return d}function h(e,b){return e?p(ea,e,b):""}function A(){var e=ja.buffer;a.HEAP8=Y=new Int8Array(e);a.HEAP16=new Int16Array(e);a.HEAP32=ca=new Int32Array(e);a.HEAPU8=ea=new Uint8Array(e);a.HEAPU16=new Uint16Array(e);a.HEAPU32=V=new Uint32Array(e);a.HEAPF32=new Float32Array(e);a.HEAPF64=new Float64Array(e)}function f(e){if(a.onAbort)a.onAbort(e);
+e="Aborted("+e+")";da(e);wa=!0;e=new WebAssembly.RuntimeError(e+". Build with -sASSERTIONS for more info.");ka(e);throw e;}function q(e){try{if(e==P&&fa)return new Uint8Array(fa);if(ma)return ma(e);throw"both async and sync fetching of the wasm failed";}catch(b){f(b)}}function v(){if(!fa&&(xa||ha)){if("function"==typeof fetch&&!P.startsWith("file://"))return fetch(P,{credentials:"same-origin"}).then(function(e){if(!e.ok)throw"failed to load wasm binary file at '"+P+"'";return e.arrayBuffer()}).catch(function(){return q(P)});
+if(na)return new Promise(function(e,b){na(P,function(c){e(new Uint8Array(c))},b)})}return Promise.resolve().then(function(){return q(P)})}function z(e){for(;0<e.length;)e.shift()(a)}function O(e){this.excPtr=e;this.ptr=e-24;this.set_type=function(b){V[this.ptr+4>>2]=b};this.get_type=function(){return V[this.ptr+4>>2]};this.set_destructor=function(b){V[this.ptr+8>>2]=b};this.get_destructor=function(){return V[this.ptr+8>>2]};this.set_refcount=function(b){ca[this.ptr>>2]=b};this.set_caught=function(b){Y[this.ptr+
+12>>0]=b?1:0};this.get_caught=function(){return 0!=Y[this.ptr+12>>0]};this.set_rethrown=function(b){Y[this.ptr+13>>0]=b?1:0};this.get_rethrown=function(){return 0!=Y[this.ptr+13>>0]};this.init=function(b,c){this.set_adjusted_ptr(0);this.set_type(b);this.set_destructor(c);this.set_refcount(0);this.set_caught(!1);this.set_rethrown(!1)};this.add_ref=function(){ca[this.ptr>>2]+=1};this.release_ref=function(){var b=ca[this.ptr>>2];ca[this.ptr>>2]=b-1;return 1===b};this.set_adjusted_ptr=function(b){V[this.ptr+
+16>>2]=b};this.get_adjusted_ptr=function(){return V[this.ptr+16>>2]};this.get_exception_ptr=function(){if(ya(this.get_type()))return V[this.excPtr>>2];var b=this.get_adjusted_ptr();return 0!==b?b:this.excPtr}}function ba(){function e(){if(!la&&(la=!0,a.calledRun=!0,!wa)){za=!0;z(oa);Aa(a);if(a.onRuntimeInitialized)a.onRuntimeInitialized();if(a.postRun)for("function"==typeof a.postRun&&(a.postRun=[a.postRun]);a.postRun.length;)Ba.unshift(a.postRun.shift());z(Ba)}}if(!(0<aa)){if(a.preRun)for("function"==
+typeof a.preRun&&(a.preRun=[a.preRun]);a.preRun.length;)Ca.unshift(a.preRun.shift());z(Ca);0<aa||(a.setStatus?(a.setStatus("Running..."),setTimeout(function(){setTimeout(function(){a.setStatus("")},1);e()},1)):e())}}function t(){}function x(e){return(e||t).__cache__}function D(e,b){var c=x(b),d=c[e];if(d)return d;d=Object.create((b||t).prototype);d.ptr=e;return c[e]=d}function R(e){if("string"===typeof e){for(var b=0,c=0;c<e.length;++c){var d=e.charCodeAt(c);127>=d?b++:2047>=d?b+=2:55296<=d&&57343>=
+d?(b+=4,++c):b+=3}b=Array(b+1);c=0;d=b.length;if(0<d){d=c+d-1;for(var g=0;g<e.length;++g){var u=e.charCodeAt(g);if(55296<=u&&57343>=u){var X=e.charCodeAt(++g);u=65536+((u&1023)<<10)|X&1023}if(127>=u){if(c>=d)break;b[c++]=u}else{if(2047>=u){if(c+1>=d)break;b[c++]=192|u>>6}else{if(65535>=u){if(c+2>=d)break;b[c++]=224|u>>12}else{if(c+3>=d)break;b[c++]=240|u>>18;b[c++]=128|u>>12&63}b[c++]=128|u>>6&63}b[c++]=128|u&63}}b[c]=0}e=r.alloc(b,Y);r.copy(b,Y,e);return e}return e}function pa(e){if("object"===typeof e){var b=
+r.alloc(e,Y);r.copy(e,Y,b);return b}return e}function Z(){throw"cannot construct a VoidPtr, no constructor in IDL";}function S(){this.ptr=Da();x(S)[this.ptr]=this}function Q(){this.ptr=Ea();x(Q)[this.ptr]=this}function W(){this.ptr=Fa();x(W)[this.ptr]=this}function w(){this.ptr=Ga();x(w)[this.ptr]=this}function C(){this.ptr=Ha();x(C)[this.ptr]=this}function F(){this.ptr=Ia();x(F)[this.ptr]=this}function G(){this.ptr=Ja();x(G)[this.ptr]=this}function E(){this.ptr=Ka();x(E)[this.ptr]=this}function T(){this.ptr=
+La();x(T)[this.ptr]=this}function B(){throw"cannot construct a Status, no constructor in IDL";}function H(){this.ptr=Ma();x(H)[this.ptr]=this}function I(){this.ptr=Na();x(I)[this.ptr]=this}function J(){this.ptr=Oa();x(J)[this.ptr]=this}function K(){this.ptr=Pa();x(K)[this.ptr]=this}function L(){this.ptr=Qa();x(L)[this.ptr]=this}function M(){this.ptr=Ra();x(M)[this.ptr]=this}function N(){this.ptr=Sa();x(N)[this.ptr]=this}function y(){this.ptr=Ta();x(y)[this.ptr]=this}function m(){this.ptr=Ua();x(m)[this.ptr]=
+this}n=void 0===n?{}:n;var a="undefined"!=typeof n?n:{},Aa,ka;a.ready=new Promise(function(e,b){Aa=e;ka=b});var Va=!1,Wa=!1;a.onRuntimeInitialized=function(){Va=!0;if(Wa&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.onModuleParsed=function(){Wa=!0;if(Va&&"function"===typeof a.onModuleLoaded)a.onModuleLoaded(a)};a.isVersionSupported=function(e){if("string"!==typeof e)return!1;e=e.split(".");return 2>e.length||3<e.length?!1:1==e[0]&&0<=e[1]&&5>=e[1]?!0:0!=e[0]||10<e[1]?!1:!0};var Xa=
+Object.assign({},a),xa="object"==typeof window,ha="function"==typeof importScripts,Ya="object"==typeof process&&"object"==typeof process.versions&&"string"==typeof process.versions.node,U="";if(Ya){var Za=require("fs"),qa=require("path");U=ha?qa.dirname(U)+"/":__dirname+"/";var $a=function(e,b){e=e.startsWith("file://")?new URL(e):qa.normalize(e);return Za.readFileSync(e,b?void 0:"utf8")};var ma=function(e){e=$a(e,!0);e.buffer||(e=new Uint8Array(e));return e};var na=function(e,b,c){e=e.startsWith("file://")?
+new URL(e):qa.normalize(e);Za.readFile(e,function(d,g){d?c(d):b(g.buffer)})};1<process.argv.length&&process.argv[1].replace(/\\/g,"/");process.argv.slice(2);a.inspect=function(){return"[Emscripten Module object]"}}else if(xa||ha)ha?U=self.location.href:"undefined"!=typeof document&&document.currentScript&&(U=document.currentScript.src),k&&(U=k),U=0!==U.indexOf("blob:")?U.substr(0,U.replace(/[?#].*/,"").lastIndexOf("/")+1):"",$a=function(e){var b=new XMLHttpRequest;b.open("GET",e,!1);b.send(null);
+return b.responseText},ha&&(ma=function(e){var b=new XMLHttpRequest;b.open("GET",e,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)}),na=function(e,b,c){var d=new XMLHttpRequest;d.open("GET",e,!0);d.responseType="arraybuffer";d.onload=function(){200==d.status||0==d.status&&d.response?b(d.response):c()};d.onerror=c;d.send(null)};var ud=a.print||console.log.bind(console),da=a.printErr||console.warn.bind(console);Object.assign(a,Xa);Xa=null;var fa;a.wasmBinary&&(fa=a.wasmBinary);
+"object"!=typeof WebAssembly&&f("no native wasm support detected");var ja,wa=!1,va="undefined"!=typeof TextDecoder?new TextDecoder("utf8"):void 0,Y,ea,ca,V,Ca=[],oa=[],Ba=[],za=!1,aa=0,ra=null,ia=null;var P="draco_decoder.wasm";P.startsWith("data:application/octet-stream;base64,")||(P=l(P));var vd=0,wd=[null,[],[]],xd={b:function(e,b,c){(new O(e)).init(b,c);vd++;throw e;},a:function(){f("")},g:function(e,b,c){ea.copyWithin(e,b,b+c)},e:function(e){var b=ea.length;e>>>=0;if(2147483648<e)return!1;for(var c=
+1;4>=c;c*=2){var d=b*(1+.2/c);d=Math.min(d,e+100663296);var g=Math;d=Math.max(e,d);g=g.min.call(g,2147483648,d+(65536-d%65536)%65536);a:{d=ja.buffer;try{ja.grow(g-d.byteLength+65535>>>16);A();var u=1;break a}catch(X){}u=void 0}if(u)return!0}return!1},f:function(e){return 52},d:function(e,b,c,d,g){return 70},c:function(e,b,c,d){for(var g=0,u=0;u<c;u++){var X=V[b>>2],ab=V[b+4>>2];b+=8;for(var sa=0;sa<ab;sa++){var ta=ea[X+sa],ua=wd[e];0===ta||10===ta?((1===e?ud:da)(p(ua,0)),ua.length=0):ua.push(ta)}g+=
+ab}V[d>>2]=g;return 0}};(function(){function e(g,u){a.asm=g.exports;ja=a.asm.h;A();oa.unshift(a.asm.i);aa--;a.monitorRunDependencies&&a.monitorRunDependencies(aa);0==aa&&(null!==ra&&(clearInterval(ra),ra=null),ia&&(g=ia,ia=null,g()))}function b(g){e(g.instance)}function c(g){return v().then(function(u){return WebAssembly.instantiate(u,d)}).then(function(u){return u}).then(g,function(u){da("failed to asynchronously prepare wasm: "+u);f(u)})}var d={a:xd};aa++;a.monitorRunDependencies&&a.monitorRunDependencies(aa);
+if(a.instantiateWasm)try{return a.instantiateWasm(d,e)}catch(g){da("Module.instantiateWasm callback failed with error: "+g),ka(g)}(function(){return fa||"function"!=typeof WebAssembly.instantiateStreaming||P.startsWith("data:application/octet-stream;base64,")||P.startsWith("file://")||Ya||"function"!=typeof fetch?c(b):fetch(P,{credentials:"same-origin"}).then(function(g){return WebAssembly.instantiateStreaming(g,d).then(b,function(u){da("wasm streaming compile failed: "+u);da("falling back to ArrayBuffer instantiation");
+return c(b)})})})().catch(ka);return{}})();var bb=a._emscripten_bind_VoidPtr___destroy___0=function(){return(bb=a._emscripten_bind_VoidPtr___destroy___0=a.asm.k).apply(null,arguments)},Da=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=function(){return(Da=a._emscripten_bind_DecoderBuffer_DecoderBuffer_0=a.asm.l).apply(null,arguments)},cb=a._emscripten_bind_DecoderBuffer_Init_2=function(){return(cb=a._emscripten_bind_DecoderBuffer_Init_2=a.asm.m).apply(null,arguments)},db=a._emscripten_bind_DecoderBuffer___destroy___0=
+function(){return(db=a._emscripten_bind_DecoderBuffer___destroy___0=a.asm.n).apply(null,arguments)},Ea=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=function(){return(Ea=a._emscripten_bind_AttributeTransformData_AttributeTransformData_0=a.asm.o).apply(null,arguments)},eb=a._emscripten_bind_AttributeTransformData_transform_type_0=function(){return(eb=a._emscripten_bind_AttributeTransformData_transform_type_0=a.asm.p).apply(null,arguments)},fb=a._emscripten_bind_AttributeTransformData___destroy___0=
+function(){return(fb=a._emscripten_bind_AttributeTransformData___destroy___0=a.asm.q).apply(null,arguments)},Fa=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=function(){return(Fa=a._emscripten_bind_GeometryAttribute_GeometryAttribute_0=a.asm.r).apply(null,arguments)},gb=a._emscripten_bind_GeometryAttribute___destroy___0=function(){return(gb=a._emscripten_bind_GeometryAttribute___destroy___0=a.asm.s).apply(null,arguments)},Ga=a._emscripten_bind_PointAttribute_PointAttribute_0=function(){return(Ga=
+a._emscripten_bind_PointAttribute_PointAttribute_0=a.asm.t).apply(null,arguments)},hb=a._emscripten_bind_PointAttribute_size_0=function(){return(hb=a._emscripten_bind_PointAttribute_size_0=a.asm.u).apply(null,arguments)},ib=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=function(){return(ib=a._emscripten_bind_PointAttribute_GetAttributeTransformData_0=a.asm.v).apply(null,arguments)},jb=a._emscripten_bind_PointAttribute_attribute_type_0=function(){return(jb=a._emscripten_bind_PointAttribute_attribute_type_0=
+a.asm.w).apply(null,arguments)},kb=a._emscripten_bind_PointAttribute_data_type_0=function(){return(kb=a._emscripten_bind_PointAttribute_data_type_0=a.asm.x).apply(null,arguments)},lb=a._emscripten_bind_PointAttribute_num_components_0=function(){return(lb=a._emscripten_bind_PointAttribute_num_components_0=a.asm.y).apply(null,arguments)},mb=a._emscripten_bind_PointAttribute_normalized_0=function(){return(mb=a._emscripten_bind_PointAttribute_normalized_0=a.asm.z).apply(null,arguments)},nb=a._emscripten_bind_PointAttribute_byte_stride_0=
+function(){return(nb=a._emscripten_bind_PointAttribute_byte_stride_0=a.asm.A).apply(null,arguments)},ob=a._emscripten_bind_PointAttribute_byte_offset_0=function(){return(ob=a._emscripten_bind_PointAttribute_byte_offset_0=a.asm.B).apply(null,arguments)},pb=a._emscripten_bind_PointAttribute_unique_id_0=function(){return(pb=a._emscripten_bind_PointAttribute_unique_id_0=a.asm.C).apply(null,arguments)},qb=a._emscripten_bind_PointAttribute___destroy___0=function(){return(qb=a._emscripten_bind_PointAttribute___destroy___0=
+a.asm.D).apply(null,arguments)},Ha=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=function(){return(Ha=a._emscripten_bind_AttributeQuantizationTransform_AttributeQuantizationTransform_0=a.asm.E).apply(null,arguments)},rb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=function(){return(rb=a._emscripten_bind_AttributeQuantizationTransform_InitFromAttribute_1=a.asm.F).apply(null,arguments)},sb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=
+function(){return(sb=a._emscripten_bind_AttributeQuantizationTransform_quantization_bits_0=a.asm.G).apply(null,arguments)},tb=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=function(){return(tb=a._emscripten_bind_AttributeQuantizationTransform_min_value_1=a.asm.H).apply(null,arguments)},ub=a._emscripten_bind_AttributeQuantizationTransform_range_0=function(){return(ub=a._emscripten_bind_AttributeQuantizationTransform_range_0=a.asm.I).apply(null,arguments)},vb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=
+function(){return(vb=a._emscripten_bind_AttributeQuantizationTransform___destroy___0=a.asm.J).apply(null,arguments)},Ia=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=function(){return(Ia=a._emscripten_bind_AttributeOctahedronTransform_AttributeOctahedronTransform_0=a.asm.K).apply(null,arguments)},wb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=function(){return(wb=a._emscripten_bind_AttributeOctahedronTransform_InitFromAttribute_1=a.asm.L).apply(null,
+arguments)},xb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=function(){return(xb=a._emscripten_bind_AttributeOctahedronTransform_quantization_bits_0=a.asm.M).apply(null,arguments)},yb=a._emscripten_bind_AttributeOctahedronTransform___destroy___0=function(){return(yb=a._emscripten_bind_AttributeOctahedronTransform___destroy___0=a.asm.N).apply(null,arguments)},Ja=a._emscripten_bind_PointCloud_PointCloud_0=function(){return(Ja=a._emscripten_bind_PointCloud_PointCloud_0=a.asm.O).apply(null,
+arguments)},zb=a._emscripten_bind_PointCloud_num_attributes_0=function(){return(zb=a._emscripten_bind_PointCloud_num_attributes_0=a.asm.P).apply(null,arguments)},Ab=a._emscripten_bind_PointCloud_num_points_0=function(){return(Ab=a._emscripten_bind_PointCloud_num_points_0=a.asm.Q).apply(null,arguments)},Bb=a._emscripten_bind_PointCloud___destroy___0=function(){return(Bb=a._emscripten_bind_PointCloud___destroy___0=a.asm.R).apply(null,arguments)},Ka=a._emscripten_bind_Mesh_Mesh_0=function(){return(Ka=
+a._emscripten_bind_Mesh_Mesh_0=a.asm.S).apply(null,arguments)},Cb=a._emscripten_bind_Mesh_num_faces_0=function(){return(Cb=a._emscripten_bind_Mesh_num_faces_0=a.asm.T).apply(null,arguments)},Db=a._emscripten_bind_Mesh_num_attributes_0=function(){return(Db=a._emscripten_bind_Mesh_num_attributes_0=a.asm.U).apply(null,arguments)},Eb=a._emscripten_bind_Mesh_num_points_0=function(){return(Eb=a._emscripten_bind_Mesh_num_points_0=a.asm.V).apply(null,arguments)},Fb=a._emscripten_bind_Mesh___destroy___0=function(){return(Fb=
+a._emscripten_bind_Mesh___destroy___0=a.asm.W).apply(null,arguments)},La=a._emscripten_bind_Metadata_Metadata_0=function(){return(La=a._emscripten_bind_Metadata_Metadata_0=a.asm.X).apply(null,arguments)},Gb=a._emscripten_bind_Metadata___destroy___0=function(){return(Gb=a._emscripten_bind_Metadata___destroy___0=a.asm.Y).apply(null,arguments)},Hb=a._emscripten_bind_Status_code_0=function(){return(Hb=a._emscripten_bind_Status_code_0=a.asm.Z).apply(null,arguments)},Ib=a._emscripten_bind_Status_ok_0=function(){return(Ib=
+a._emscripten_bind_Status_ok_0=a.asm._).apply(null,arguments)},Jb=a._emscripten_bind_Status_error_msg_0=function(){return(Jb=a._emscripten_bind_Status_error_msg_0=a.asm.$).apply(null,arguments)},Kb=a._emscripten_bind_Status___destroy___0=function(){return(Kb=a._emscripten_bind_Status___destroy___0=a.asm.aa).apply(null,arguments)},Ma=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=function(){return(Ma=a._emscripten_bind_DracoFloat32Array_DracoFloat32Array_0=a.asm.ba).apply(null,arguments)},
+Lb=a._emscripten_bind_DracoFloat32Array_GetValue_1=function(){return(Lb=a._emscripten_bind_DracoFloat32Array_GetValue_1=a.asm.ca).apply(null,arguments)},Mb=a._emscripten_bind_DracoFloat32Array_size_0=function(){return(Mb=a._emscripten_bind_DracoFloat32Array_size_0=a.asm.da).apply(null,arguments)},Nb=a._emscripten_bind_DracoFloat32Array___destroy___0=function(){return(Nb=a._emscripten_bind_DracoFloat32Array___destroy___0=a.asm.ea).apply(null,arguments)},Na=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=
+function(){return(Na=a._emscripten_bind_DracoInt8Array_DracoInt8Array_0=a.asm.fa).apply(null,arguments)},Ob=a._emscripten_bind_DracoInt8Array_GetValue_1=function(){return(Ob=a._emscripten_bind_DracoInt8Array_GetValue_1=a.asm.ga).apply(null,arguments)},Pb=a._emscripten_bind_DracoInt8Array_size_0=function(){return(Pb=a._emscripten_bind_DracoInt8Array_size_0=a.asm.ha).apply(null,arguments)},Qb=a._emscripten_bind_DracoInt8Array___destroy___0=function(){return(Qb=a._emscripten_bind_DracoInt8Array___destroy___0=
+a.asm.ia).apply(null,arguments)},Oa=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=function(){return(Oa=a._emscripten_bind_DracoUInt8Array_DracoUInt8Array_0=a.asm.ja).apply(null,arguments)},Rb=a._emscripten_bind_DracoUInt8Array_GetValue_1=function(){return(Rb=a._emscripten_bind_DracoUInt8Array_GetValue_1=a.asm.ka).apply(null,arguments)},Sb=a._emscripten_bind_DracoUInt8Array_size_0=function(){return(Sb=a._emscripten_bind_DracoUInt8Array_size_0=a.asm.la).apply(null,arguments)},Tb=a._emscripten_bind_DracoUInt8Array___destroy___0=
+function(){return(Tb=a._emscripten_bind_DracoUInt8Array___destroy___0=a.asm.ma).apply(null,arguments)},Pa=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=function(){return(Pa=a._emscripten_bind_DracoInt16Array_DracoInt16Array_0=a.asm.na).apply(null,arguments)},Ub=a._emscripten_bind_DracoInt16Array_GetValue_1=function(){return(Ub=a._emscripten_bind_DracoInt16Array_GetValue_1=a.asm.oa).apply(null,arguments)},Vb=a._emscripten_bind_DracoInt16Array_size_0=function(){return(Vb=a._emscripten_bind_DracoInt16Array_size_0=
+a.asm.pa).apply(null,arguments)},Wb=a._emscripten_bind_DracoInt16Array___destroy___0=function(){return(Wb=a._emscripten_bind_DracoInt16Array___destroy___0=a.asm.qa).apply(null,arguments)},Qa=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=function(){return(Qa=a._emscripten_bind_DracoUInt16Array_DracoUInt16Array_0=a.asm.ra).apply(null,arguments)},Xb=a._emscripten_bind_DracoUInt16Array_GetValue_1=function(){return(Xb=a._emscripten_bind_DracoUInt16Array_GetValue_1=a.asm.sa).apply(null,arguments)},
+Yb=a._emscripten_bind_DracoUInt16Array_size_0=function(){return(Yb=a._emscripten_bind_DracoUInt16Array_size_0=a.asm.ta).apply(null,arguments)},Zb=a._emscripten_bind_DracoUInt16Array___destroy___0=function(){return(Zb=a._emscripten_bind_DracoUInt16Array___destroy___0=a.asm.ua).apply(null,arguments)},Ra=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=function(){return(Ra=a._emscripten_bind_DracoInt32Array_DracoInt32Array_0=a.asm.va).apply(null,arguments)},$b=a._emscripten_bind_DracoInt32Array_GetValue_1=
+function(){return($b=a._emscripten_bind_DracoInt32Array_GetValue_1=a.asm.wa).apply(null,arguments)},ac=a._emscripten_bind_DracoInt32Array_size_0=function(){return(ac=a._emscripten_bind_DracoInt32Array_size_0=a.asm.xa).apply(null,arguments)},bc=a._emscripten_bind_DracoInt32Array___destroy___0=function(){return(bc=a._emscripten_bind_DracoInt32Array___destroy___0=a.asm.ya).apply(null,arguments)},Sa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=function(){return(Sa=a._emscripten_bind_DracoUInt32Array_DracoUInt32Array_0=
+a.asm.za).apply(null,arguments)},cc=a._emscripten_bind_DracoUInt32Array_GetValue_1=function(){return(cc=a._emscripten_bind_DracoUInt32Array_GetValue_1=a.asm.Aa).apply(null,arguments)},dc=a._emscripten_bind_DracoUInt32Array_size_0=function(){return(dc=a._emscripten_bind_DracoUInt32Array_size_0=a.asm.Ba).apply(null,arguments)},ec=a._emscripten_bind_DracoUInt32Array___destroy___0=function(){return(ec=a._emscripten_bind_DracoUInt32Array___destroy___0=a.asm.Ca).apply(null,arguments)},Ta=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=
+function(){return(Ta=a._emscripten_bind_MetadataQuerier_MetadataQuerier_0=a.asm.Da).apply(null,arguments)},fc=a._emscripten_bind_MetadataQuerier_HasEntry_2=function(){return(fc=a._emscripten_bind_MetadataQuerier_HasEntry_2=a.asm.Ea).apply(null,arguments)},gc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=function(){return(gc=a._emscripten_bind_MetadataQuerier_GetIntEntry_2=a.asm.Fa).apply(null,arguments)},hc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=function(){return(hc=a._emscripten_bind_MetadataQuerier_GetIntEntryArray_3=
+a.asm.Ga).apply(null,arguments)},ic=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=function(){return(ic=a._emscripten_bind_MetadataQuerier_GetDoubleEntry_2=a.asm.Ha).apply(null,arguments)},jc=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=function(){return(jc=a._emscripten_bind_MetadataQuerier_GetStringEntry_2=a.asm.Ia).apply(null,arguments)},kc=a._emscripten_bind_MetadataQuerier_NumEntries_1=function(){return(kc=a._emscripten_bind_MetadataQuerier_NumEntries_1=a.asm.Ja).apply(null,arguments)},
+lc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=function(){return(lc=a._emscripten_bind_MetadataQuerier_GetEntryName_2=a.asm.Ka).apply(null,arguments)},mc=a._emscripten_bind_MetadataQuerier___destroy___0=function(){return(mc=a._emscripten_bind_MetadataQuerier___destroy___0=a.asm.La).apply(null,arguments)},Ua=a._emscripten_bind_Decoder_Decoder_0=function(){return(Ua=a._emscripten_bind_Decoder_Decoder_0=a.asm.Ma).apply(null,arguments)},nc=a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=function(){return(nc=
+a._emscripten_bind_Decoder_DecodeArrayToPointCloud_3=a.asm.Na).apply(null,arguments)},oc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=function(){return(oc=a._emscripten_bind_Decoder_DecodeArrayToMesh_3=a.asm.Oa).apply(null,arguments)},pc=a._emscripten_bind_Decoder_GetAttributeId_2=function(){return(pc=a._emscripten_bind_Decoder_GetAttributeId_2=a.asm.Pa).apply(null,arguments)},qc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=function(){return(qc=a._emscripten_bind_Decoder_GetAttributeIdByName_2=
+a.asm.Qa).apply(null,arguments)},rc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=function(){return(rc=a._emscripten_bind_Decoder_GetAttributeIdByMetadataEntry_3=a.asm.Ra).apply(null,arguments)},sc=a._emscripten_bind_Decoder_GetAttribute_2=function(){return(sc=a._emscripten_bind_Decoder_GetAttribute_2=a.asm.Sa).apply(null,arguments)},tc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=function(){return(tc=a._emscripten_bind_Decoder_GetAttributeByUniqueId_2=a.asm.Ta).apply(null,arguments)},
+uc=a._emscripten_bind_Decoder_GetMetadata_1=function(){return(uc=a._emscripten_bind_Decoder_GetMetadata_1=a.asm.Ua).apply(null,arguments)},vc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=function(){return(vc=a._emscripten_bind_Decoder_GetAttributeMetadata_2=a.asm.Va).apply(null,arguments)},wc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=function(){return(wc=a._emscripten_bind_Decoder_GetFaceFromMesh_3=a.asm.Wa).apply(null,arguments)},xc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=
+function(){return(xc=a._emscripten_bind_Decoder_GetTriangleStripsFromMesh_2=a.asm.Xa).apply(null,arguments)},yc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=function(){return(yc=a._emscripten_bind_Decoder_GetTrianglesUInt16Array_3=a.asm.Ya).apply(null,arguments)},zc=a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=function(){return(zc=a._emscripten_bind_Decoder_GetTrianglesUInt32Array_3=a.asm.Za).apply(null,arguments)},Ac=a._emscripten_bind_Decoder_GetAttributeFloat_3=function(){return(Ac=
+a._emscripten_bind_Decoder_GetAttributeFloat_3=a.asm._a).apply(null,arguments)},Bc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=function(){return(Bc=a._emscripten_bind_Decoder_GetAttributeFloatForAllPoints_3=a.asm.$a).apply(null,arguments)},Cc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=function(){return(Cc=a._emscripten_bind_Decoder_GetAttributeIntForAllPoints_3=a.asm.ab).apply(null,arguments)},Dc=a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=function(){return(Dc=
+a._emscripten_bind_Decoder_GetAttributeInt8ForAllPoints_3=a.asm.bb).apply(null,arguments)},Ec=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=function(){return(Ec=a._emscripten_bind_Decoder_GetAttributeUInt8ForAllPoints_3=a.asm.cb).apply(null,arguments)},Fc=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=function(){return(Fc=a._emscripten_bind_Decoder_GetAttributeInt16ForAllPoints_3=a.asm.db).apply(null,arguments)},Gc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=
+function(){return(Gc=a._emscripten_bind_Decoder_GetAttributeUInt16ForAllPoints_3=a.asm.eb).apply(null,arguments)},Hc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=function(){return(Hc=a._emscripten_bind_Decoder_GetAttributeInt32ForAllPoints_3=a.asm.fb).apply(null,arguments)},Ic=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=function(){return(Ic=a._emscripten_bind_Decoder_GetAttributeUInt32ForAllPoints_3=a.asm.gb).apply(null,arguments)},Jc=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=
+function(){return(Jc=a._emscripten_bind_Decoder_GetAttributeDataArrayForAllPoints_5=a.asm.hb).apply(null,arguments)},Kc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=function(){return(Kc=a._emscripten_bind_Decoder_SkipAttributeTransform_1=a.asm.ib).apply(null,arguments)},Lc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=function(){return(Lc=a._emscripten_bind_Decoder_GetEncodedGeometryType_Deprecated_1=a.asm.jb).apply(null,arguments)},Mc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=
+function(){return(Mc=a._emscripten_bind_Decoder_DecodeBufferToPointCloud_2=a.asm.kb).apply(null,arguments)},Nc=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=function(){return(Nc=a._emscripten_bind_Decoder_DecodeBufferToMesh_2=a.asm.lb).apply(null,arguments)},Oc=a._emscripten_bind_Decoder___destroy___0=function(){return(Oc=a._emscripten_bind_Decoder___destroy___0=a.asm.mb).apply(null,arguments)},Pc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=function(){return(Pc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_INVALID_TRANSFORM=
+a.asm.nb).apply(null,arguments)},Qc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=function(){return(Qc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_NO_TRANSFORM=a.asm.ob).apply(null,arguments)},Rc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=function(){return(Rc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_QUANTIZATION_TRANSFORM=a.asm.pb).apply(null,arguments)},Sc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=
+function(){return(Sc=a._emscripten_enum_draco_AttributeTransformType_ATTRIBUTE_OCTAHEDRON_TRANSFORM=a.asm.qb).apply(null,arguments)},Tc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=function(){return(Tc=a._emscripten_enum_draco_GeometryAttribute_Type_INVALID=a.asm.rb).apply(null,arguments)},Uc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=function(){return(Uc=a._emscripten_enum_draco_GeometryAttribute_Type_POSITION=a.asm.sb).apply(null,arguments)},Vc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=
+function(){return(Vc=a._emscripten_enum_draco_GeometryAttribute_Type_NORMAL=a.asm.tb).apply(null,arguments)},Wc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=function(){return(Wc=a._emscripten_enum_draco_GeometryAttribute_Type_COLOR=a.asm.ub).apply(null,arguments)},Xc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=function(){return(Xc=a._emscripten_enum_draco_GeometryAttribute_Type_TEX_COORD=a.asm.vb).apply(null,arguments)},Yc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=
+function(){return(Yc=a._emscripten_enum_draco_GeometryAttribute_Type_GENERIC=a.asm.wb).apply(null,arguments)},Zc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=function(){return(Zc=a._emscripten_enum_draco_EncodedGeometryType_INVALID_GEOMETRY_TYPE=a.asm.xb).apply(null,arguments)},$c=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=function(){return($c=a._emscripten_enum_draco_EncodedGeometryType_POINT_CLOUD=a.asm.yb).apply(null,arguments)},ad=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=
+function(){return(ad=a._emscripten_enum_draco_EncodedGeometryType_TRIANGULAR_MESH=a.asm.zb).apply(null,arguments)},bd=a._emscripten_enum_draco_DataType_DT_INVALID=function(){return(bd=a._emscripten_enum_draco_DataType_DT_INVALID=a.asm.Ab).apply(null,arguments)},cd=a._emscripten_enum_draco_DataType_DT_INT8=function(){return(cd=a._emscripten_enum_draco_DataType_DT_INT8=a.asm.Bb).apply(null,arguments)},dd=a._emscripten_enum_draco_DataType_DT_UINT8=function(){return(dd=a._emscripten_enum_draco_DataType_DT_UINT8=
+a.asm.Cb).apply(null,arguments)},ed=a._emscripten_enum_draco_DataType_DT_INT16=function(){return(ed=a._emscripten_enum_draco_DataType_DT_INT16=a.asm.Db).apply(null,arguments)},fd=a._emscripten_enum_draco_DataType_DT_UINT16=function(){return(fd=a._emscripten_enum_draco_DataType_DT_UINT16=a.asm.Eb).apply(null,arguments)},gd=a._emscripten_enum_draco_DataType_DT_INT32=function(){return(gd=a._emscripten_enum_draco_DataType_DT_INT32=a.asm.Fb).apply(null,arguments)},hd=a._emscripten_enum_draco_DataType_DT_UINT32=
+function(){return(hd=a._emscripten_enum_draco_DataType_DT_UINT32=a.asm.Gb).apply(null,arguments)},id=a._emscripten_enum_draco_DataType_DT_INT64=function(){return(id=a._emscripten_enum_draco_DataType_DT_INT64=a.asm.Hb).apply(null,arguments)},jd=a._emscripten_enum_draco_DataType_DT_UINT64=function(){return(jd=a._emscripten_enum_draco_DataType_DT_UINT64=a.asm.Ib).apply(null,arguments)},kd=a._emscripten_enum_draco_DataType_DT_FLOAT32=function(){return(kd=a._emscripten_enum_draco_DataType_DT_FLOAT32=a.asm.Jb).apply(null,
+arguments)},ld=a._emscripten_enum_draco_DataType_DT_FLOAT64=function(){return(ld=a._emscripten_enum_draco_DataType_DT_FLOAT64=a.asm.Kb).apply(null,arguments)},md=a._emscripten_enum_draco_DataType_DT_BOOL=function(){return(md=a._emscripten_enum_draco_DataType_DT_BOOL=a.asm.Lb).apply(null,arguments)},nd=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=function(){return(nd=a._emscripten_enum_draco_DataType_DT_TYPES_COUNT=a.asm.Mb).apply(null,arguments)},od=a._emscripten_enum_draco_StatusCode_OK=function(){return(od=
+a._emscripten_enum_draco_StatusCode_OK=a.asm.Nb).apply(null,arguments)},pd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=function(){return(pd=a._emscripten_enum_draco_StatusCode_DRACO_ERROR=a.asm.Ob).apply(null,arguments)},qd=a._emscripten_enum_draco_StatusCode_IO_ERROR=function(){return(qd=a._emscripten_enum_draco_StatusCode_IO_ERROR=a.asm.Pb).apply(null,arguments)},rd=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=function(){return(rd=a._emscripten_enum_draco_StatusCode_INVALID_PARAMETER=
+a.asm.Qb).apply(null,arguments)},sd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=function(){return(sd=a._emscripten_enum_draco_StatusCode_UNSUPPORTED_VERSION=a.asm.Rb).apply(null,arguments)},td=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=function(){return(td=a._emscripten_enum_draco_StatusCode_UNKNOWN_VERSION=a.asm.Sb).apply(null,arguments)};a._malloc=function(){return(a._malloc=a.asm.Tb).apply(null,arguments)};a._free=function(){return(a._free=a.asm.Ub).apply(null,arguments)};
+var ya=function(){return(ya=a.asm.Vb).apply(null,arguments)};a.___start_em_js=15856;a.___stop_em_js=15954;var la;ia=function b(){la||ba();la||(ia=b)};if(a.preInit)for("function"==typeof a.preInit&&(a.preInit=[a.preInit]);0<a.preInit.length;)a.preInit.pop()();ba();t.prototype=Object.create(t.prototype);t.prototype.constructor=t;t.prototype.__class__=t;t.__cache__={};a.WrapperObject=t;a.getCache=x;a.wrapPointer=D;a.castObject=function(b,c){return D(b.ptr,c)};a.NULL=D(0);a.destroy=function(b){if(!b.__destroy__)throw"Error: Cannot destroy object. (Did you create it yourself?)";
+b.__destroy__();delete x(b.__class__)[b.ptr]};a.compare=function(b,c){return b.ptr===c.ptr};a.getPointer=function(b){return b.ptr};a.getClass=function(b){return b.__class__};var r={buffer:0,size:0,pos:0,temps:[],needed:0,prepare:function(){if(r.needed){for(var b=0;b<r.temps.length;b++)a._free(r.temps[b]);r.temps.length=0;a._free(r.buffer);r.buffer=0;r.size+=r.needed;r.needed=0}r.buffer||(r.size+=128,r.buffer=a._malloc(r.size),r.buffer||f(void 0));r.pos=0},alloc:function(b,c){r.buffer||f(void 0);b=
+b.length*c.BYTES_PER_ELEMENT;b=b+7&-8;r.pos+b>=r.size?(0<b||f(void 0),r.needed+=b,c=a._malloc(b),r.temps.push(c)):(c=r.buffer+r.pos,r.pos+=b);return c},copy:function(b,c,d){d>>>=0;switch(c.BYTES_PER_ELEMENT){case 2:d>>>=1;break;case 4:d>>>=2;break;case 8:d>>>=3}for(var g=0;g<b.length;g++)c[d+g]=b[g]}};Z.prototype=Object.create(t.prototype);Z.prototype.constructor=Z;Z.prototype.__class__=Z;Z.__cache__={};a.VoidPtr=Z;Z.prototype.__destroy__=Z.prototype.__destroy__=function(){bb(this.ptr)};S.prototype=
+Object.create(t.prototype);S.prototype.constructor=S;S.prototype.__class__=S;S.__cache__={};a.DecoderBuffer=S;S.prototype.Init=S.prototype.Init=function(b,c){var d=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);cb(d,b,c)};S.prototype.__destroy__=S.prototype.__destroy__=function(){db(this.ptr)};Q.prototype=Object.create(t.prototype);Q.prototype.constructor=Q;Q.prototype.__class__=Q;Q.__cache__={};a.AttributeTransformData=Q;Q.prototype.transform_type=Q.prototype.transform_type=
+function(){return eb(this.ptr)};Q.prototype.__destroy__=Q.prototype.__destroy__=function(){fb(this.ptr)};W.prototype=Object.create(t.prototype);W.prototype.constructor=W;W.prototype.__class__=W;W.__cache__={};a.GeometryAttribute=W;W.prototype.__destroy__=W.prototype.__destroy__=function(){gb(this.ptr)};w.prototype=Object.create(t.prototype);w.prototype.constructor=w;w.prototype.__class__=w;w.__cache__={};a.PointAttribute=w;w.prototype.size=w.prototype.size=function(){return hb(this.ptr)};w.prototype.GetAttributeTransformData=
+w.prototype.GetAttributeTransformData=function(){return D(ib(this.ptr),Q)};w.prototype.attribute_type=w.prototype.attribute_type=function(){return jb(this.ptr)};w.prototype.data_type=w.prototype.data_type=function(){return kb(this.ptr)};w.prototype.num_components=w.prototype.num_components=function(){return lb(this.ptr)};w.prototype.normalized=w.prototype.normalized=function(){return!!mb(this.ptr)};w.prototype.byte_stride=w.prototype.byte_stride=function(){return nb(this.ptr)};w.prototype.byte_offset=
+w.prototype.byte_offset=function(){return ob(this.ptr)};w.prototype.unique_id=w.prototype.unique_id=function(){return pb(this.ptr)};w.prototype.__destroy__=w.prototype.__destroy__=function(){qb(this.ptr)};C.prototype=Object.create(t.prototype);C.prototype.constructor=C;C.prototype.__class__=C;C.__cache__={};a.AttributeQuantizationTransform=C;C.prototype.InitFromAttribute=C.prototype.InitFromAttribute=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!rb(c,b)};C.prototype.quantization_bits=
+C.prototype.quantization_bits=function(){return sb(this.ptr)};C.prototype.min_value=C.prototype.min_value=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return tb(c,b)};C.prototype.range=C.prototype.range=function(){return ub(this.ptr)};C.prototype.__destroy__=C.prototype.__destroy__=function(){vb(this.ptr)};F.prototype=Object.create(t.prototype);F.prototype.constructor=F;F.prototype.__class__=F;F.__cache__={};a.AttributeOctahedronTransform=F;F.prototype.InitFromAttribute=F.prototype.InitFromAttribute=
+function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return!!wb(c,b)};F.prototype.quantization_bits=F.prototype.quantization_bits=function(){return xb(this.ptr)};F.prototype.__destroy__=F.prototype.__destroy__=function(){yb(this.ptr)};G.prototype=Object.create(t.prototype);G.prototype.constructor=G;G.prototype.__class__=G;G.__cache__={};a.PointCloud=G;G.prototype.num_attributes=G.prototype.num_attributes=function(){return zb(this.ptr)};G.prototype.num_points=G.prototype.num_points=function(){return Ab(this.ptr)};
+G.prototype.__destroy__=G.prototype.__destroy__=function(){Bb(this.ptr)};E.prototype=Object.create(t.prototype);E.prototype.constructor=E;E.prototype.__class__=E;E.__cache__={};a.Mesh=E;E.prototype.num_faces=E.prototype.num_faces=function(){return Cb(this.ptr)};E.prototype.num_attributes=E.prototype.num_attributes=function(){return Db(this.ptr)};E.prototype.num_points=E.prototype.num_points=function(){return Eb(this.ptr)};E.prototype.__destroy__=E.prototype.__destroy__=function(){Fb(this.ptr)};T.prototype=
+Object.create(t.prototype);T.prototype.constructor=T;T.prototype.__class__=T;T.__cache__={};a.Metadata=T;T.prototype.__destroy__=T.prototype.__destroy__=function(){Gb(this.ptr)};B.prototype=Object.create(t.prototype);B.prototype.constructor=B;B.prototype.__class__=B;B.__cache__={};a.Status=B;B.prototype.code=B.prototype.code=function(){return Hb(this.ptr)};B.prototype.ok=B.prototype.ok=function(){return!!Ib(this.ptr)};B.prototype.error_msg=B.prototype.error_msg=function(){return h(Jb(this.ptr))};
+B.prototype.__destroy__=B.prototype.__destroy__=function(){Kb(this.ptr)};H.prototype=Object.create(t.prototype);H.prototype.constructor=H;H.prototype.__class__=H;H.__cache__={};a.DracoFloat32Array=H;H.prototype.GetValue=H.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Lb(c,b)};H.prototype.size=H.prototype.size=function(){return Mb(this.ptr)};H.prototype.__destroy__=H.prototype.__destroy__=function(){Nb(this.ptr)};I.prototype=Object.create(t.prototype);I.prototype.constructor=
+I;I.prototype.__class__=I;I.__cache__={};a.DracoInt8Array=I;I.prototype.GetValue=I.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Ob(c,b)};I.prototype.size=I.prototype.size=function(){return Pb(this.ptr)};I.prototype.__destroy__=I.prototype.__destroy__=function(){Qb(this.ptr)};J.prototype=Object.create(t.prototype);J.prototype.constructor=J;J.prototype.__class__=J;J.__cache__={};a.DracoUInt8Array=J;J.prototype.GetValue=J.prototype.GetValue=function(b){var c=
+this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Rb(c,b)};J.prototype.size=J.prototype.size=function(){return Sb(this.ptr)};J.prototype.__destroy__=J.prototype.__destroy__=function(){Tb(this.ptr)};K.prototype=Object.create(t.prototype);K.prototype.constructor=K;K.prototype.__class__=K;K.__cache__={};a.DracoInt16Array=K;K.prototype.GetValue=K.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Ub(c,b)};K.prototype.size=K.prototype.size=function(){return Vb(this.ptr)};
+K.prototype.__destroy__=K.prototype.__destroy__=function(){Wb(this.ptr)};L.prototype=Object.create(t.prototype);L.prototype.constructor=L;L.prototype.__class__=L;L.__cache__={};a.DracoUInt16Array=L;L.prototype.GetValue=L.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Xb(c,b)};L.prototype.size=L.prototype.size=function(){return Yb(this.ptr)};L.prototype.__destroy__=L.prototype.__destroy__=function(){Zb(this.ptr)};M.prototype=Object.create(t.prototype);M.prototype.constructor=
+M;M.prototype.__class__=M;M.__cache__={};a.DracoInt32Array=M;M.prototype.GetValue=M.prototype.GetValue=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return $b(c,b)};M.prototype.size=M.prototype.size=function(){return ac(this.ptr)};M.prototype.__destroy__=M.prototype.__destroy__=function(){bc(this.ptr)};N.prototype=Object.create(t.prototype);N.prototype.constructor=N;N.prototype.__class__=N;N.__cache__={};a.DracoUInt32Array=N;N.prototype.GetValue=N.prototype.GetValue=function(b){var c=
+this.ptr;b&&"object"===typeof b&&(b=b.ptr);return cc(c,b)};N.prototype.size=N.prototype.size=function(){return dc(this.ptr)};N.prototype.__destroy__=N.prototype.__destroy__=function(){ec(this.ptr)};y.prototype=Object.create(t.prototype);y.prototype.constructor=y;y.prototype.__class__=y;y.__cache__={};a.MetadataQuerier=y;y.prototype.HasEntry=y.prototype.HasEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return!!fc(d,b,c)};y.prototype.GetIntEntry=
+y.prototype.GetIntEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return gc(d,b,c)};y.prototype.GetIntEntryArray=y.prototype.GetIntEntryArray=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);d&&"object"===typeof d&&(d=d.ptr);hc(g,b,c,d)};y.prototype.GetDoubleEntry=y.prototype.GetDoubleEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=
+c&&"object"===typeof c?c.ptr:R(c);return ic(d,b,c)};y.prototype.GetStringEntry=y.prototype.GetStringEntry=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);return h(jc(d,b,c))};y.prototype.NumEntries=y.prototype.NumEntries=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return kc(c,b)};y.prototype.GetEntryName=y.prototype.GetEntryName=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=
+c.ptr);return h(lc(d,b,c))};y.prototype.__destroy__=y.prototype.__destroy__=function(){mc(this.ptr)};m.prototype=Object.create(t.prototype);m.prototype.constructor=m;m.prototype.__class__=m;m.__cache__={};a.Decoder=m;m.prototype.DecodeArrayToPointCloud=m.prototype.DecodeArrayToPointCloud=function(b,c,d){var g=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return D(nc(g,b,c,d),B)};m.prototype.DecodeArrayToMesh=m.prototype.DecodeArrayToMesh=
+function(b,c,d){var g=this.ptr;r.prepare();"object"==typeof b&&(b=pa(b));c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return D(oc(g,b,c,d),B)};m.prototype.GetAttributeId=m.prototype.GetAttributeId=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return pc(d,b,c)};m.prototype.GetAttributeIdByName=m.prototype.GetAttributeIdByName=function(b,c){var d=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?
+c.ptr:R(c);return qc(d,b,c)};m.prototype.GetAttributeIdByMetadataEntry=m.prototype.GetAttributeIdByMetadataEntry=function(b,c,d){var g=this.ptr;r.prepare();b&&"object"===typeof b&&(b=b.ptr);c=c&&"object"===typeof c?c.ptr:R(c);d=d&&"object"===typeof d?d.ptr:R(d);return rc(g,b,c,d)};m.prototype.GetAttribute=m.prototype.GetAttribute=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(sc(d,b,c),w)};m.prototype.GetAttributeByUniqueId=m.prototype.GetAttributeByUniqueId=
+function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(tc(d,b,c),w)};m.prototype.GetMetadata=m.prototype.GetMetadata=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return D(uc(c,b),T)};m.prototype.GetAttributeMetadata=m.prototype.GetAttributeMetadata=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(vc(d,b,c),T)};m.prototype.GetFaceFromMesh=m.prototype.GetFaceFromMesh=function(b,
+c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!wc(g,b,c,d)};m.prototype.GetTriangleStripsFromMesh=m.prototype.GetTriangleStripsFromMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return xc(d,b,c)};m.prototype.GetTrianglesUInt16Array=m.prototype.GetTrianglesUInt16Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);
+d&&"object"===typeof d&&(d=d.ptr);return!!yc(g,b,c,d)};m.prototype.GetTrianglesUInt32Array=m.prototype.GetTrianglesUInt32Array=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!zc(g,b,c,d)};m.prototype.GetAttributeFloat=m.prototype.GetAttributeFloat=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ac(g,b,c,d)};m.prototype.GetAttributeFloatForAllPoints=
+m.prototype.GetAttributeFloatForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Bc(g,b,c,d)};m.prototype.GetAttributeIntForAllPoints=m.prototype.GetAttributeIntForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Cc(g,b,c,d)};m.prototype.GetAttributeInt8ForAllPoints=m.prototype.GetAttributeInt8ForAllPoints=
+function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Dc(g,b,c,d)};m.prototype.GetAttributeUInt8ForAllPoints=m.prototype.GetAttributeUInt8ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ec(g,b,c,d)};m.prototype.GetAttributeInt16ForAllPoints=m.prototype.GetAttributeInt16ForAllPoints=function(b,c,d){var g=this.ptr;
+b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Fc(g,b,c,d)};m.prototype.GetAttributeUInt16ForAllPoints=m.prototype.GetAttributeUInt16ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Gc(g,b,c,d)};m.prototype.GetAttributeInt32ForAllPoints=m.prototype.GetAttributeInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&
+(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Hc(g,b,c,d)};m.prototype.GetAttributeUInt32ForAllPoints=m.prototype.GetAttributeUInt32ForAllPoints=function(b,c,d){var g=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);return!!Ic(g,b,c,d)};m.prototype.GetAttributeDataArrayForAllPoints=m.prototype.GetAttributeDataArrayForAllPoints=function(b,c,d,g,u){var X=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&
+"object"===typeof c&&(c=c.ptr);d&&"object"===typeof d&&(d=d.ptr);g&&"object"===typeof g&&(g=g.ptr);u&&"object"===typeof u&&(u=u.ptr);return!!Jc(X,b,c,d,g,u)};m.prototype.SkipAttributeTransform=m.prototype.SkipAttributeTransform=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);Kc(c,b)};m.prototype.GetEncodedGeometryType_Deprecated=m.prototype.GetEncodedGeometryType_Deprecated=function(b){var c=this.ptr;b&&"object"===typeof b&&(b=b.ptr);return Lc(c,b)};m.prototype.DecodeBufferToPointCloud=
+m.prototype.DecodeBufferToPointCloud=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(Mc(d,b,c),B)};m.prototype.DecodeBufferToMesh=m.prototype.DecodeBufferToMesh=function(b,c){var d=this.ptr;b&&"object"===typeof b&&(b=b.ptr);c&&"object"===typeof c&&(c=c.ptr);return D(Nc(d,b,c),B)};m.prototype.__destroy__=m.prototype.__destroy__=function(){Oc(this.ptr)};(function(){function b(){a.ATTRIBUTE_INVALID_TRANSFORM=Pc();a.ATTRIBUTE_NO_TRANSFORM=Qc();
+a.ATTRIBUTE_QUANTIZATION_TRANSFORM=Rc();a.ATTRIBUTE_OCTAHEDRON_TRANSFORM=Sc();a.INVALID=Tc();a.POSITION=Uc();a.NORMAL=Vc();a.COLOR=Wc();a.TEX_COORD=Xc();a.GENERIC=Yc();a.INVALID_GEOMETRY_TYPE=Zc();a.POINT_CLOUD=$c();a.TRIANGULAR_MESH=ad();a.DT_INVALID=bd();a.DT_INT8=cd();a.DT_UINT8=dd();a.DT_INT16=ed();a.DT_UINT16=fd();a.DT_INT32=gd();a.DT_UINT32=hd();a.DT_INT64=id();a.DT_UINT64=jd();a.DT_FLOAT32=kd();a.DT_FLOAT64=ld();a.DT_BOOL=md();a.DT_TYPES_COUNT=nd();a.OK=od();a.DRACO_ERROR=pd();a.IO_ERROR=qd();
+a.INVALID_PARAMETER=rd();a.UNSUPPORTED_VERSION=sd();a.UNKNOWN_VERSION=td()}za?b():oa.unshift(b)})();if("function"===typeof a.onModuleParsed)a.onModuleParsed();a.Decoder.prototype.GetEncodedGeometryType=function(b){if(b.__class__&&b.__class__===a.DecoderBuffer)return a.Decoder.prototype.GetEncodedGeometryType_Deprecated(b);if(8>b.byteLength)return a.INVALID_GEOMETRY_TYPE;switch(b[7]){case 0:return a.POINT_CLOUD;case 1:return a.TRIANGULAR_MESH;default:return a.INVALID_GEOMETRY_TYPE}};return n.ready}}();
+"object"===typeof exports&&"object"===typeof module?module.exports=DracoDecoderModule:"function"===typeof define&&define.amd?define([],function(){return DracoDecoderModule}):"object"===typeof exports&&(exports.DracoDecoderModule=DracoDecoderModule);

public/libs/online-3d-viewer/libs/loaders/occt-import-js-worker.js

+importScripts ('occt-import-js.js');
+
+onmessage = async function (ev)
+{
+	let occt = await occtimportjs ();
+	let result = null;
+	if (ev.data.format === 'step') {
+		result = occt.ReadStepFile (ev.data.buffer, ev.data.params);
+	} else if (ev.data.format === 'iges') {
+		result = occt.ReadIgesFile (ev.data.buffer, ev.data.params);
+	} else if (ev.data.format === 'brep') {
+		result = occt.ReadBrepFile (ev.data.buffer, ev.data.params);
+	}
+	postMessage (result);
+};

public/libs/online-3d-viewer/libs/loaders/occt-import-js.license.md

+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+    USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random
+  Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

public/libs/online-3d-viewer/libs/loaders/rhino3dm.license.md

+MIT License
+
+Copyright (c) 2020 Robert McNeel & Associates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.