@inweb/viewer-three 26.5.0 → 26.5.1

package/dist/plugins/loaders/IFCXLoader.js

@@ -0,0 +1,887 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('@inweb/viewer-three'), require('three')) :
+  typeof define === 'function' && define.amd ? define(['@inweb/viewer-three', 'three'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ODA.Three, global.THREE));
+})(this, (function (viewerThree, three) { 'use strict';
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
+  // All rights reserved.
+  //
+  // This software and its documentation and related materials are owned by
+  // the Alliance. The software may only be incorporated into application
+  // programs owned by members of the Alliance, subject to a signed
+  // Membership Agreement and Supplemental Software License Agreement with the
+  // Alliance. The structure and organization of this software are the valuable
+  // trade secrets of the Alliance and its suppliers. The software is also
+  // protected by copyright law and international treaty provisions. Application
+  // programs incorporating this software must include the following statement
+  // with their copyright notices:
+  //
+  //   This application incorporates Open Design Alliance software pursuant to a
+  //   license agreement with Open Design Alliance.
+  //   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
+  //   All rights reserved.
+  //
+  // By use of this software, its documentation or related materials, you
+  // acknowledge and accept the above terms.
+  ///////////////////////////////////////////////////////////////////////////////
+
+
+  const THREE = {
+    Box3: three.Box3,
+    BufferAttribute: three.BufferAttribute,
+    BufferGeometry: three.BufferGeometry,
+    Color: three.Color,
+    Group: three.Group,
+    Line: three.Line,
+    LineBasicMaterial: three.LineBasicMaterial,
+    Matrix4: three.Matrix4,
+    Mesh: three.Mesh,
+    MeshBasicMaterial: three.MeshBasicMaterial,
+    PerspectiveCamera: three.PerspectiveCamera,
+    Scene: three.Scene,
+    Vector3: three.Vector3,
+  };
+
+  // composed-object.ts
+  function getChildByName(root, childName, skip = 0) {
+    let fragments = childName.replace(/^<\/|^\/|>$/g, "").split("/");
+    for (let i = 0; i < skip; ++i) {
+      fragments.shift();
+    }
+    let start = root;
+    while (fragments.length && start && start.children) {
+      // console.log(start, fragments[0]);
+      let f = fragments.shift();
+      start = start.children.find((i) => i.name.split("/").reverse()[0] === f);
+    }
+    if (fragments.length == 0) {
+      return start;
+    }
+  }
+
+  // compose-alpha.ts
+  function GetNode(node, path) {
+    if (path === "") return node;
+    let parts = path.split("/");
+    let child = node.children.get(parts[0]);
+    if (child) {
+      if (parts.length === 1) {
+        return child;
+      }
+      return GetNode(child, GetTail(path));
+    } else {
+      return null;
+    }
+  }
+  function GetHead(path) {
+    return path.split("/")[0];
+  }
+  function GetTail(path) {
+    let parts = path.split("/");
+    parts.shift();
+    return parts.join("/");
+  }
+  function MakeNode(node) {
+    return {
+      node,
+      children: /* @__PURE__ */ new Map(),
+      attributes: /* @__PURE__ */ new Map(),
+    };
+  }
+  function ConvertToCompositionNode(path, inputNodes) {
+    let compositionNode = {
+      path,
+      children: {},
+      inherits: {},
+      attributes: {},
+    };
+    inputNodes.forEach((node) => {
+      Object.keys(node.children).forEach((childName) => {
+        compositionNode.children[childName] = node.children[childName];
+      });
+      Object.keys(node.inherits).forEach((inheritName) => {
+        let ih = node.inherits[inheritName];
+        if (ih === null) {
+          delete compositionNode.inherits[inheritName];
+        } else {
+          compositionNode.inherits[inheritName] = ih;
+        }
+      });
+      Object.keys(node.attributes).forEach((attrName) => {
+        compositionNode.attributes[attrName] = node.attributes[attrName];
+      });
+    });
+    return compositionNode;
+  }
+  function MMSet(map, key, value) {
+    if (map.has(key)) {
+      map.get(key)?.push(value);
+    } else {
+      map.set(key, [value]);
+    }
+  }
+  function FindRootsOrCycles(nodes) {
+    let dependencies = /* @__PURE__ */ new Map();
+    let dependents = /* @__PURE__ */ new Map();
+    nodes.forEach((node, path) => {
+      Object.keys(node.inherits).forEach((inheritName) => {
+        MMSet(dependencies, path, node.inherits[inheritName]);
+        MMSet(dependents, node.inherits[inheritName], path);
+      });
+      Object.keys(node.children).forEach((childName) => {
+        MMSet(dependencies, path, node.children[childName]);
+        MMSet(dependents, node.children[childName], path);
+      });
+    });
+    let paths = [...nodes.keys()];
+    let perm = {};
+    let temp = {};
+    function visit(path) {
+      if (perm[path]) return;
+      if (temp[path]) throw new Error(`CYCLE!`);
+      temp[path] = true;
+      let deps = dependencies.get(path);
+      if (deps) {
+        deps.forEach((dep) => visit(dep));
+      }
+      perm[path] = true;
+    }
+    let roots = /* @__PURE__ */ new Set();
+    try {
+      paths.forEach((path) => {
+        if (!dependents.has(path) && path.indexOf("/") === -1) {
+          roots.add(path);
+        }
+        visit(path);
+      });
+    } catch {
+      return null;
+    }
+    return roots;
+  }
+  function ConvertNodes(input) {
+    let compositionNodes = /* @__PURE__ */ new Map();
+    for (let [path, inputNodes] of input) {
+      compositionNodes.set(path, ConvertToCompositionNode(path, inputNodes));
+    }
+    return compositionNodes;
+  }
+  var CycleError = class extends Error {};
+  function ExpandFirstRootInInput(nodes) {
+    let roots = FindRootsOrCycles(nodes);
+    if (!roots) {
+      throw new CycleError();
+    }
+    return ExpandNewNode([...roots.values()][0], nodes);
+  }
+  function CreateArtificialRoot(nodes) {
+    let roots = FindRootsOrCycles(nodes);
+    if (!roots) {
+      throw new CycleError();
+    }
+    let pseudoRoot = {
+      node: "",
+      attributes: /* @__PURE__ */ new Map(),
+      children: /* @__PURE__ */ new Map(),
+    };
+    roots.forEach((root) => {
+      pseudoRoot.children.set(root, ExpandNewNode(root, nodes));
+    });
+    return pseudoRoot;
+  }
+  function ExpandNewNode(node, nodes) {
+    return ExpandNode(node, MakeNode(node), nodes);
+  }
+  function ExpandNode(path, node, nodes) {
+    let input = nodes.get(path);
+    if (input) {
+      AddDataFromInput(input, node, nodes);
+    }
+    node.children.forEach((child, name) => {
+      ExpandNode(`${path}/${name}`, child, nodes);
+    });
+    return node;
+  }
+  function AddDataFromInput(input, node, nodes) {
+    Object.values(input.inherits).forEach((inherit) => {
+      let classNode = ExpandNewNode(GetHead(inherit), nodes);
+      let subnode = GetNode(classNode, GetTail(inherit));
+      if (!subnode) throw new Error(`Unknown node ${inherit}`);
+      subnode.children.forEach((child, childName) => {
+        node.children.set(childName, child);
+      });
+      for (let [attrID, attr] of subnode.attributes) {
+        node.attributes.set(attrID, attr);
+      }
+    });
+    Object.entries(input.children).forEach(([childName, child]) => {
+      if (child !== null) {
+        let classNode = ExpandNewNode(GetHead(child), nodes);
+        let subnode = GetNode(classNode, GetTail(child));
+        if (!subnode) throw new Error(`Unknown node ${child}`);
+        node.children.set(childName, subnode);
+      } else {
+        node.children.delete(childName);
+      }
+    });
+    Object.entries(input.attributes).forEach(([attrID, attr]) => {
+      node.attributes.set(attrID, attr);
+    });
+  }
+
+  // workflow-alpha.ts
+  function MMSet2(map, key, value) {
+    if (map.has(key)) {
+      map.get(key)?.push(value);
+    } else {
+      map.set(key, [value]);
+    }
+  }
+  function ToInputNodes(data) {
+    let inputNodes = /* @__PURE__ */ new Map();
+    data.forEach((ifcxNode) => {
+      let node = {
+        path: ifcxNode.identifier,
+        children: ifcxNode.children ? ifcxNode.children : {},
+        inherits: ifcxNode.inherits ? ifcxNode.inherits : {},
+        attributes: ifcxNode.attributes ? ifcxNode.attributes : {},
+      };
+      MMSet2(inputNodes, node.path, node);
+    });
+    return inputNodes;
+  }
+  var SchemaValidationError = class extends Error {};
+  function ValidateAttributeValue(desc, value, path, schemas) {
+    if (desc.inherits) {
+      desc.inherits.forEach((inheritedSchemaID) => {
+        let inheritedSchema = schemas[inheritedSchemaID];
+        if (!inheritedSchema) {
+          throw new SchemaValidationError(`Unknown inherited schema id "${desc.inherits}"`);
+        }
+        ValidateAttributeValue(inheritedSchema.value, value, path, schemas);
+      });
+    }
+    if (desc.dataType === "Boolean") {
+      if (typeof value !== "boolean") {
+        throw new SchemaValidationError(`Expected "${value}" to be of type boolean`);
+      }
+    } else if (desc.dataType === "String") {
+      if (typeof value !== "string") {
+        throw new SchemaValidationError(`Expected "${value}" to be of type string`);
+      }
+    } else if (desc.dataType === "DateTime") {
+      if (typeof value !== "string") {
+        throw new SchemaValidationError(`Expected "${value}" to be of type date`);
+      }
+    } else if (desc.dataType === "Enum") {
+      if (typeof value !== "string") {
+        throw new SchemaValidationError(`Expected "${value}" to be of type string`);
+      }
+      let found = desc.enumRestrictions.options.filter((option) => option === value).length === 1;
+      if (!found) {
+        throw new SchemaValidationError(`Expected "${value}" to be one of [${desc.enumRestrictions.options.join(",")}]`);
+      }
+    } else if (desc.dataType === "Integer") {
+      if (typeof value !== "number") {
+        throw new SchemaValidationError(`Expected "${value}" to be of type int`);
+      }
+    } else if (desc.dataType === "Real") {
+      if (typeof value !== "number") {
+        throw new SchemaValidationError(`Expected "${value}" to be of type real`);
+      }
+    } else if (desc.dataType === "Relation") {
+      if (typeof value !== "string") {
+        throw new SchemaValidationError(`Expected "${value}" to be of type string`);
+      }
+    } else if (desc.dataType === "Object") {
+      if (typeof value !== "object") {
+        throw new SchemaValidationError(`Expected "${value}" to be of type object`);
+      }
+      if (desc.objectRestrictions) {
+        Object.keys(desc.objectRestrictions.values).forEach((key) => {
+          if (!Object.hasOwn(value, key)) {
+            throw new SchemaValidationError(`Expected "${value}" to have key ${key}`);
+          }
+          ValidateAttributeValue(desc.objectRestrictions.values[key], value[key], path + "." + key, schemas);
+        });
+      }
+    } else if (desc.dataType === "Array") {
+      if (!Array.isArray(value)) {
+        throw new SchemaValidationError(`Expected "${value}" to be of type array`);
+      }
+      value.forEach((entry) => {
+        ValidateAttributeValue(desc.arrayRestrictions.value, entry, path + ".<array>.", schemas);
+      });
+    } else {
+      throw new SchemaValidationError(`Unexpected datatype ${desc.dataType}`);
+    }
+  }
+  function Validate(schemas, inputNodes) {
+    inputNodes.forEach((node) => {
+      Object.keys(node.attributes).forEach((schemaID) => {
+        if (!schemas[schemaID]) {
+          throw new SchemaValidationError(`Missing schema "${schemaID}" referenced by ["${node.path}"].attributes`);
+        }
+        let schema = schemas[schemaID];
+        let value = node.attributes[schemaID];
+        try {
+          ValidateAttributeValue(schema.value, value, "", schemas);
+        } catch (e) {
+          if (e instanceof SchemaValidationError) {
+            throw new SchemaValidationError(`Error validating ["${node.path}"].attributes["${schemaID}"]: ${e.message}`);
+          } else {
+            throw e;
+          }
+        }
+      });
+    });
+  }
+  function LoadIfcxFile(file, checkSchemas = true, createArtificialRoot = false) {
+    let inputNodes = ToInputNodes(file.data);
+    let compositionNodes = ConvertNodes(inputNodes);
+    try {
+      if (checkSchemas) {
+        Validate(file.schemas, compositionNodes);
+      }
+    } catch (e) {
+      throw e;
+    }
+    if (createArtificialRoot) {
+      return CreateArtificialRoot(compositionNodes);
+    } else {
+      return ExpandFirstRootInInput(compositionNodes);
+    }
+  }
+  function Federate(files) {
+    let result = {
+      header: files[0].header,
+      schemas: {},
+      data: [],
+    };
+    files.forEach((file) => {
+      Object.keys(file.schemas).forEach((schemaID) => (result.schemas[schemaID] = file.schemas[schemaID]));
+    });
+    files.forEach((file) => {
+      file.data.forEach((node) => result.data.push(node));
+    });
+    return Prune(result);
+  }
+  function Collapse(nodes, deleteEmpty = false) {
+    let result = {
+      path: nodes[0].path,
+      children: {},
+      inherits: {},
+      attributes: {},
+    };
+    nodes.forEach((node) => {
+      Object.keys(node.children).forEach((name) => {
+        result.children[name] = node.children[name];
+      });
+      Object.keys(node.inherits).forEach((name) => {
+        result.inherits[name] = node.inherits[name];
+      });
+      Object.keys(node.attributes).forEach((name) => {
+        result.attributes[name] = node.attributes[name];
+      });
+    });
+    if (deleteEmpty) {
+      let empty = true;
+      Object.keys(result.children).forEach((name) => {
+        if (result.children[name] !== null) empty = false;
+      });
+      Object.keys(result.inherits).forEach((name) => {
+        if (result.inherits[name] !== null) empty = false;
+      });
+      Object.keys(result.attributes).forEach((name) => {
+        if (result.attributes[name] !== null) empty = false;
+      });
+      if (empty) return null;
+    }
+    return result;
+  }
+  function Prune(file, deleteEmpty = false) {
+    let result = {
+      header: file.header,
+      schemas: file.schemas,
+      data: [],
+    };
+    let inputNodes = ToInputNodes(file.data);
+    inputNodes.forEach((nodes) => {
+      let collapsed = Collapse(nodes, deleteEmpty);
+      if (collapsed)
+        result.data.push({
+          identifier: collapsed.path,
+          children: collapsed.children,
+          inherits: collapsed.inherits,
+          attributes: collapsed.attributes,
+        });
+    });
+    return result;
+  }
+
+  // compose-flattened.ts
+  function TreeNodeToComposedObject(path, node, schemas) {
+    let co = {
+      name: path,
+      attributes: {},
+      children: [],
+    };
+    node.children.forEach((childNode, childName) => {
+      co.children?.push(TreeNodeToComposedObject(`${path}/${childName}`, childNode, schemas));
+    });
+    node.attributes.forEach((attr, attrName) => {
+      if (attr && typeof attr === "object" && !Array.isArray(attr)) {
+        Object.keys(attr).forEach((compname) => {
+          co.attributes[`${attrName}::${compname}`] = attr[compname];
+        });
+      } else {
+        let schema = schemas[attrName];
+        if (schema && schema.value.quantityKind) {
+          let postfix = "";
+          let quantityKind = schema.value.quantityKind;
+          if (quantityKind === "Length") {
+            postfix = "m";
+          } else if (quantityKind === "Volume") {
+            postfix = "m" + String.fromCodePoint(179);
+          }
+          co.attributes[attrName] = `${attr} ${postfix}`;
+        } else {
+          co.attributes[attrName] = attr;
+        }
+      }
+    });
+    if (Object.keys(co.attributes).length === 0) delete co.attributes;
+    return co;
+  }
+  function compose3(files) {
+    let federated = Federate(files);
+    let tree = LoadIfcxFile(federated, true, true);
+    return TreeNodeToComposedObject("", tree, federated.schemas);
+  }
+
+  // render.ts
+  // var controls;
+  // var renderer;
+  var scene;
+  var camera;
+  var datas = [];
+  var autoCamera = true;
+  // var THREE = window["THREE"];
+  function init() {
+    scene = new THREE.Scene();
+    camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 100);
+    camera.up.set(0, 0, 1);
+    camera.position.set(50, 50, 50);
+    camera.lookAt(0, 0, 0);
+    // const nd = document.querySelector(".viewport");
+    // renderer = new THREE.WebGLRenderer({
+    //  alpha: true,
+    //  logarithmicDepthBuffer: true
+    // });
+    // renderer.setSize(nd.offsetWidth, nd.offsetHeight);
+    // controls = new THREE.OrbitControls(camera, renderer.domElement);
+    // controls.enableDamping = true;
+    // controls.dampingFactor = 0.25;
+    // nd.appendChild(renderer.domElement);
+    scene.add(camera);
+    return scene;
+  }
+  function HasAttr(node, attrName) {
+    if (!node || !node.attributes) return false;
+    return !!node.attributes[attrName];
+  }
+  function FindChildWithAttr(node, attrName) {
+    if (!node || !node.children) return undefined;
+    for (let i = 0; i < node.children.length; i++) {
+      if (HasAttr(node.children[i], attrName)) {
+        return node.children[i];
+      }
+    }
+    return undefined;
+  }
+  function createMaterialFromParent(parent, root) {
+    let reference = parent.attributes["usd::usdshade::materialbindingapi::material::binding"];
+    let material = {
+      color: new THREE.Color(0.6, 0.6, 0.6),
+      transparent: false,
+      opacity: 1,
+    };
+    if (reference) {
+      const materialNode = getChildByName(root, reference.ref);
+      let shader = FindChildWithAttr(materialNode, "usd::materials::inputs::diffuseColor");
+      if (shader) {
+        let color = shader?.attributes["usd::materials::inputs::diffuseColor"];
+        material.color = new THREE.Color(...color);
+        if (shader?.attributes["usd::materials::inputs::opacity"]) {
+          material.transparent = true;
+          material.opacity = shader.attributes["usd::materials::inputs::opacity"];
+        }
+      }
+    }
+    return material;
+  }
+  function createCurveFromJson(node, parent, root) {
+    let points = new Float32Array(node.attributes["usd::usdgeom::basiscurves::points"].flat());
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(points, 3));
+    const material = createMaterialFromParent(parent, root);
+    let lineMaterial = new THREE.LineBasicMaterial({ ...material });
+    lineMaterial.color.multiplyScalar(0.8);
+    return new THREE.Line(geometry, lineMaterial);
+  }
+  function createMeshFromJson(node, parent, root) {
+    let points = new Float32Array(node.attributes["usd::usdgeom::mesh::points"].flat());
+    let indices = new Uint16Array(node.attributes["usd::usdgeom::mesh::faceVertexIndices"]);
+    const geometry = new THREE.BufferGeometry();
+    geometry.setAttribute("position", new THREE.BufferAttribute(points, 3));
+    geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+    geometry.computeVertexNormals();
+    const material = createMaterialFromParent(parent, root);
+    let meshMaterial = new THREE.MeshBasicMaterial({ ...material });
+    return new THREE.Mesh(geometry, meshMaterial);
+  }
+  function traverseTree(node, parent, root, parentNode = undefined) {
+    let elem = new THREE.Group();
+    if (HasAttr(node, "usd::usdgeom::visibility::visibility")) {
+      if (node.attributes["usd::usdgeom::visibility::visibility"] === "invisible") {
+        return;
+      }
+    } else if (HasAttr(node, "usd::usdgeom::mesh::points")) {
+      elem = createMeshFromJson(node, parentNode, root);
+    } else if (HasAttr(node, "usd::usdgeom::basiscurves::points")) {
+      elem = createCurveFromJson(node, parentNode, root);
+    }
+    parent.add(elem);
+    if (node !== root) {
+      elem.matrixAutoUpdate = false;
+      let matrixNode =
+        node.attributes && node.attributes["usd::xformop::transform"]
+          ? node.attributes["usd::xformop::transform"].flat()
+          : null;
+      if (matrixNode) {
+        let matrix = new THREE.Matrix4();
+        matrix.set(...matrixNode);
+        matrix.transpose();
+        elem.matrix = matrix;
+      }
+    }
+    (node.children || []).forEach((child) => traverseTree(child, elem || parent, root, node));
+  }
+  // function encodeHtmlEntities(str) {
+  //   const div = document.createElement("div");
+  //   div.textContent = str;
+  //   return div.innerHTML;
+  // }
+  // var icons = {
+  //   "usd::usdgeom::mesh::points": "deployed_code",
+  //   "usd::usdgeom::basiscurves::points": "line_curve",
+  //   "usd::usdshade::material::outputs::surface.connect": "line_style"
+  // };
+  // function buildDomTree(prim, node) {
+  //   const elem = document.createElement("div");
+  //   let span;
+  //   elem.appendChild(document.createTextNode(prim.name ? prim.name.split("/").reverse()[0] : "root"));
+  //   elem.appendChild(span = document.createElement("span"));
+  //   Object.entries(icons).forEach(([k, v]) => span.innerText += (prim.attributes || {})[k] ? v : " ");
+  //   span.className = "material-symbols-outlined";
+  //   elem.onclick = (evt) => {
+  //     let rows = [["name", prim.name]].concat(Object.entries(prim.attributes)).map(([k, v]) => `<tr><td>${encodeHtmlEntities(k)}</td><td>${encodeHtmlEntities(typeof v === "object" ? JSON.stringify(v) : v)}</td>`).join("");
+  //     document.querySelector(".attributes .table").innerHTML = `<table border="0">${rows}</table>`;
+  //     evt.stopPropagation();
+  //   };
+  //   node.appendChild(elem);
+  //   (prim.children || []).forEach((p) => buildDomTree(p, elem));
+  // }
+  function composeAndRender() {
+    if (scene) {
+      scene.children = [];
+    }
+    // document.querySelector(".tree").innerHTML = "";
+    if (datas.length === 0) {
+      return;
+    }
+    let tree = null;
+    let dataArray = datas.map((arr) => arr[1]);
+    tree = compose3(dataArray);
+    if (!tree) {
+      console.error("No result from composition");
+      return;
+    }
+    traverseTree(tree, scene || init(), tree);
+    if (autoCamera) {
+      const boundingBox = new THREE.Box3();
+      boundingBox.setFromObject(scene);
+      if (!boundingBox.isEmpty()) {
+        let avg = boundingBox.min.clone().add(boundingBox.max).multiplyScalar(0.5);
+        let ext = boundingBox.max.clone().sub(boundingBox.min).length();
+        camera.position.copy(avg.clone().add(new THREE.Vector3(1, 1, 1).normalize().multiplyScalar(ext)));
+        camera.far = ext * 3;
+        camera.updateProjectionMatrix();
+        // controls.target.copy(avg);
+        // controls.update();
+        autoCamera = false;
+      }
+    }
+    // buildDomTree(tree, document.querySelector(".tree"));
+    // animate();
+  }
+  // function createLayerDom() {
+  //   document.querySelector(".layers div").innerHTML = "";
+  //   datas.forEach(([name, _], index) => {
+  //     const elem = document.createElement("div");
+  //     elem.appendChild(document.createTextNode(name));
+  //     ["\u25B3", "\u25BD", "\xD7"].reverse().forEach((lbl, cmd) => {
+  //       const btn = document.createElement("span");
+  //       btn.onclick = (evt) => {
+  //         evt.stopPropagation();
+  //         if (cmd === 2) {
+  //           if (index > 0) {
+  //             [datas[index], datas[index - 1]] = [datas[index - 1], datas[index]];
+  //           }
+  //         } else if (cmd === 1) {
+  //           if (index < datas.length - 1) {
+  //             [datas[index], datas[index + 1]] = [datas[index + 1], datas[index]];
+  //           }
+  //         } else if (cmd === 0) {
+  //           datas.splice(index, 1);
+  //         }
+  //         composeAndRender();
+  //         createLayerDom();
+  //       };
+  //       btn.appendChild(document.createTextNode(lbl));
+  //       elem.appendChild(btn);
+  //     });
+  //     document.querySelector(".layers div").appendChild(elem);
+  //   });
+  // }
+  // function addModel(name, m) {
+  //   datas.push([name, m]);
+  //   createLayerDom();
+  //   composeAndRender();
+  // }
+  // function animate() {
+  //   requestAnimationFrame(animate);
+  //   controls.update();
+  //   renderer.render(scene, camera);
+  // }
+  // export {
+  //   composeAndRender,
+  //   addModel as default
+  // };
+  function parse(m, name) {
+    datas.push([name, m]);
+    composeAndRender();
+    return scene;
+  }
+  function clear() {
+    scene = undefined;
+    datas.length = 0;
+    autoCamera = true;
+  }
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
+  // All rights reserved.
+  //
+  // This software and its documentation and related materials are owned by
+  // the Alliance. The software may only be incorporated into application
+  // programs owned by members of the Alliance, subject to a signed
+  // Membership Agreement and Supplemental Software License Agreement with the
+  // Alliance. The structure and organization of this software are the valuable
+  // trade secrets of the Alliance and its suppliers. The software is also
+  // protected by copyright law and international treaty provisions. Application
+  // programs incorporating this software must include the following statement
+  // with their copyright notices:
+  //
+  //   This application incorporates Open Design Alliance software pursuant to a
+  //   license agreement with Open Design Alliance.
+  //   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
+  //   All rights reserved.
+  //
+  // By use of this software, its documentation or related materials, you
+  // acknowledge and accept the above terms.
+  ///////////////////////////////////////////////////////////////////////////////
+  class IFCXModelLoader extends viewerThree.Loader {
+      constructor(viewer) {
+          super();
+          this.viewer = viewer;
+      }
+      isSupport(file) {
+          return (typeof file === "object" &&
+              typeof file.type === "string" &&
+              typeof file.download === "function" &&
+              /.ifcx$/i.test(file.type));
+      }
+      async load(model) {
+          const progress = (progress) => {
+              this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model });
+          };
+          const arrayBuffer = await model.download(progress, this.abortController.signal);
+          if (!this.viewer.scene)
+              return this;
+          const textDecoder = new TextDecoder();
+          const json = JSON.parse(textDecoder.decode(arrayBuffer));
+          const scene = parse(json);
+          clear();
+          let handle = 0;
+          scene.traverse((object) => {
+              object.userData = { handle, ...object.userData };
+              handle++;
+          });
+          this.viewer.scene.add(scene);
+          this.viewer.models.push(scene);
+          this.viewer.syncOptions();
+          this.viewer.syncOverlay();
+          this.viewer.update();
+          this.viewer.emitEvent({ type: "databasechunk", data: scene, file: model });
+          return this;
+      }
+  }
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Copyright (C) 2002-2024, Open Design Alliance (the "Alliance").
+  // All rights reserved.
+  //
+  // This software and its documentation and related materials are owned by
+  // the Alliance. The software may only be incorporated into application
+  // programs owned by members of the Alliance, subject to a signed
+  // Membership Agreement and Supplemental Software License Agreement with the
+  // Alliance. The structure and organization of this software are the valuable
+  // trade secrets of the Alliance and its suppliers. The software is also
+  // protected by copyright law and international treaty provisions. Application
+  // programs incorporating this software must include the following statement
+  // with their copyright notices:
+  //
+  //   This application incorporates Open Design Alliance software pursuant to a
+  //   license agreement with Open Design Alliance.
+  //   Open Design Alliance Copyright (C) 2002-2024 by Open Design Alliance.
+  //   All rights reserved.
+  //
+  // By use of this software, its documentation or related materials, you
+  // acknowledge and accept the above terms.
+  ///////////////////////////////////////////////////////////////////////////////
+  class IFCXLoader extends three.Loader {
+      load(url, onLoad, onProgress, onError) {
+          const manager = this.manager;
+          manager.itemStart(url);
+          const _onLoad = (scene) => {
+              onLoad(scene);
+              manager.itemEnd(url);
+          };
+          const _onError = (e) => {
+              if (onError)
+                  onError(e);
+              else
+                  console.error(e);
+              manager.itemError(url);
+              manager.itemEnd(url);
+          };
+          const loader = new three.FileLoader(this.manager);
+          loader.setPath(this.path);
+          loader.setResponseType("json");
+          loader.setRequestHeader(this.requestHeader);
+          loader.setWithCredentials(this.withCredentials);
+          loader.load(url, (json) => this.parse(json, _onLoad, _onError), onProgress, onError);
+      }
+      parse(json, onLoad, onError) {
+          try {
+              onLoad(parse(json));
+          }
+          catch (e) {
+              onError(e);
+          }
+          finally {
+              clear();
+          }
+      }
+  }
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
+  // All rights reserved.
+  //
+  // This software and its documentation and related materials are owned by
+  // the Alliance. The software may only be incorporated into application
+  // programs owned by members of the Alliance, subject to a signed
+  // Membership Agreement and Supplemental Software License Agreement with the
+  // Alliance. The structure and organization of this software are the valuable
+  // trade secrets of the Alliance and its suppliers. The software is also
+  // protected by copyright law and international treaty provisions. Application
+  // programs incorporating this software must include the following statement
+  // with their copyright notices:
+  //
+  //   This application incorporates Open Design Alliance software pursuant to a
+  //   license agreement with Open Design Alliance.
+  //   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
+  //   All rights reserved.
+  //
+  // By use of this software, its documentation or related materials, you
+  // acknowledge and accept the above terms.
+  ///////////////////////////////////////////////////////////////////////////////
+  class IFCXFileLoader extends viewerThree.Loader {
+      constructor(viewer) {
+          super();
+          this.viewer = viewer;
+      }
+      isSupport(file, format) {
+          return ((typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) &&
+              /(ifcx)$/i.test(format));
+      }
+      async load(file, format, params) {
+          const manager = new viewerThree.GLTFLoadingManager(file, params);
+          const loader = new IFCXLoader(manager);
+          loader.setPath(manager.path);
+          loader.setCrossOrigin(params.crossOrigin || loader.crossOrigin);
+          loader.setWithCredentials(params.withCredentials || loader.withCredentials);
+          const progress = (event) => {
+              const { lengthComputable, loaded, total } = event;
+              const progress = lengthComputable ? loaded / total : 1;
+              this.viewer.emitEvent({ type: "geometryprogress", data: progress, file });
+          };
+          const scene = await loader.loadAsync(manager.fileURL, progress);
+          if (!this.viewer.scene)
+              return this;
+          let handle = 0;
+          scene.traverse((object) => {
+              object.userData = { handle, ...object.userData };
+              handle++;
+          });
+          this.viewer.scene.add(scene);
+          this.viewer.models.push(scene);
+          this.viewer.syncOptions();
+          this.viewer.syncOverlay();
+          this.viewer.update();
+          this.viewer.emitEvent({ type: "databasechunk", data: scene, file });
+          return this;
+      }
+  }
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
+  // All rights reserved.
+  //
+  // This software and its documentation and related materials are owned by
+  // the Alliance. The software may only be incorporated into application
+  // programs owned by members of the Alliance, subject to a signed
+  // Membership Agreement and Supplemental Software License Agreement with the
+  // Alliance. The structure and organization of this software are the valuable
+  // trade secrets of the Alliance and its suppliers. The software is also
+  // protected by copyright law and international treaty provisions. Application
+  // programs incorporating this software must include the following statement
+  // with their copyright notices:
+  //
+  //   This application incorporates Open Design Alliance software pursuant to a
+  //   license agreement with Open Design Alliance.
+  //   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
+  //   All rights reserved.
+  //
+  // By use of this software, its documentation or related materials, you
+  // acknowledge and accept the above terms.
+  ///////////////////////////////////////////////////////////////////////////////
+  viewerThree.loaders.registerLoader("ifcx", (viewer) => new IFCXModelLoader(viewer));
+  viewerThree.loaders.registerLoader("ifcx-file", (viewer) => new IFCXFileLoader(viewer));
+
+}));
+//# sourceMappingURL=IFCXLoader.js.map