three-stdlib 2.22.7 → 2.22.9

package/dist/utils/SkeletonUtils.mjs

@@ -0,0 +1,292 @@
+import { Vector3, Quaternion, Matrix4, AnimationMixer, VectorKeyframeTrack, QuaternionKeyframeTrack, AnimationClip, SkeletonHelper, Vector2, Euler } from "three";
+var SkeletonUtils = {
+  retarget: function() {
+    var pos = new Vector3(), quat = new Quaternion(), scale = new Vector3(), bindBoneMatrix = new Matrix4(), relativeMatrix = new Matrix4(), globalMatrix = new Matrix4();
+    return function(target, source, options) {
+      options = options || {};
+      options.preserveMatrix = options.preserveMatrix !== void 0 ? options.preserveMatrix : true;
+      options.preservePosition = options.preservePosition !== void 0 ? options.preservePosition : true;
+      options.preserveHipPosition = options.preserveHipPosition !== void 0 ? options.preserveHipPosition : false;
+      options.useTargetMatrix = options.useTargetMatrix !== void 0 ? options.useTargetMatrix : false;
+      options.hip = options.hip !== void 0 ? options.hip : "hip";
+      options.names = options.names || {};
+      var sourceBones = source.isObject3D ? source.skeleton.bones : this.getBones(source), bones = target.isObject3D ? target.skeleton.bones : this.getBones(target), bindBones, bone, name, boneTo, bonesPosition, i;
+      if (target.isObject3D) {
+        target.skeleton.pose();
+      } else {
+        options.useTargetMatrix = true;
+        options.preserveMatrix = false;
+      }
+      if (options.preservePosition) {
+        bonesPosition = [];
+        for (i = 0; i < bones.length; i++) {
+          bonesPosition.push(bones[i].position.clone());
+        }
+      }
+      if (options.preserveMatrix) {
+        target.updateMatrixWorld();
+        target.matrixWorld.identity();
+        for (i = 0; i < target.children.length; ++i) {
+          target.children[i].updateMatrixWorld(true);
+        }
+      }
+      if (options.offsets) {
+        bindBones = [];
+        for (i = 0; i < bones.length; ++i) {
+          bone = bones[i];
+          name = options.names[bone.name] || bone.name;
+          if (options.offsets && options.offsets[name]) {
+            bone.matrix.multiply(options.offsets[name]);
+            bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
+            bone.updateMatrixWorld();
+          }
+          bindBones.push(bone.matrixWorld.clone());
+        }
+      }
+      for (i = 0; i < bones.length; ++i) {
+        bone = bones[i];
+        name = options.names[bone.name] || bone.name;
+        boneTo = this.getBoneByName(name, sourceBones);
+        globalMatrix.copy(bone.matrixWorld);
+        if (boneTo) {
+          boneTo.updateMatrixWorld();
+          if (options.useTargetMatrix) {
+            relativeMatrix.copy(boneTo.matrixWorld);
+          } else {
+            relativeMatrix.copy(target.matrixWorld).invert();
+            relativeMatrix.multiply(boneTo.matrixWorld);
+          }
+          scale.setFromMatrixScale(relativeMatrix);
+          relativeMatrix.scale(scale.set(1 / scale.x, 1 / scale.y, 1 / scale.z));
+          globalMatrix.makeRotationFromQuaternion(quat.setFromRotationMatrix(relativeMatrix));
+          if (target.isObject3D) {
+            var boneIndex = bones.indexOf(bone), wBindMatrix = bindBones ? bindBones[boneIndex] : bindBoneMatrix.copy(target.skeleton.boneInverses[boneIndex]).invert();
+            globalMatrix.multiply(wBindMatrix);
+          }
+          globalMatrix.copyPosition(relativeMatrix);
+        }
+        if (bone.parent && bone.parent.isBone) {
+          bone.matrix.copy(bone.parent.matrixWorld).invert();
+          bone.matrix.multiply(globalMatrix);
+        } else {
+          bone.matrix.copy(globalMatrix);
+        }
+        if (options.preserveHipPosition && name === options.hip) {
+          bone.matrix.setPosition(pos.set(0, bone.position.y, 0));
+        }
+        bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
+        bone.updateMatrixWorld();
+      }
+      if (options.preservePosition) {
+        for (i = 0; i < bones.length; ++i) {
+          bone = bones[i];
+          name = options.names[bone.name] || bone.name;
+          if (name !== options.hip) {
+            bone.position.copy(bonesPosition[i]);
+          }
+        }
+      }
+      if (options.preserveMatrix) {
+        target.updateMatrixWorld(true);
+      }
+    };
+  }(),
+  retargetClip: function(target, source, clip, options) {
+    options = options || {};
+    options.useFirstFramePosition = options.useFirstFramePosition !== void 0 ? options.useFirstFramePosition : false;
+    options.fps = options.fps !== void 0 ? options.fps : 30;
+    options.names = options.names || [];
+    if (!source.isObject3D) {
+      source = this.getHelperFromSkeleton(source);
+    }
+    var numFrames = Math.round(clip.duration * (options.fps / 1e3) * 1e3), delta = 1 / options.fps, convertedTracks = [], mixer = new AnimationMixer(source), bones = this.getBones(target.skeleton), boneDatas = [], positionOffset, bone, boneTo, boneData, name, i, j;
+    mixer.clipAction(clip).play();
+    mixer.update(0);
+    source.updateMatrixWorld();
+    for (i = 0; i < numFrames; ++i) {
+      var time = i * delta;
+      this.retarget(target, source, options);
+      for (j = 0; j < bones.length; ++j) {
+        name = options.names[bones[j].name] || bones[j].name;
+        boneTo = this.getBoneByName(name, source.skeleton);
+        if (boneTo) {
+          bone = bones[j];
+          boneData = boneDatas[j] = boneDatas[j] || { bone };
+          if (options.hip === name) {
+            if (!boneData.pos) {
+              boneData.pos = {
+                times: new Float32Array(numFrames),
+                values: new Float32Array(numFrames * 3)
+              };
+            }
+            if (options.useFirstFramePosition) {
+              if (i === 0) {
+                positionOffset = bone.position.clone();
+              }
+              bone.position.sub(positionOffset);
+            }
+            boneData.pos.times[i] = time;
+            bone.position.toArray(boneData.pos.values, i * 3);
+          }
+          if (!boneData.quat) {
+            boneData.quat = {
+              times: new Float32Array(numFrames),
+              values: new Float32Array(numFrames * 4)
+            };
+          }
+          boneData.quat.times[i] = time;
+          bone.quaternion.toArray(boneData.quat.values, i * 4);
+        }
+      }
+      mixer.update(delta);
+      source.updateMatrixWorld();
+    }
+    for (i = 0; i < boneDatas.length; ++i) {
+      boneData = boneDatas[i];
+      if (boneData) {
+        if (boneData.pos) {
+          convertedTracks.push(
+            new VectorKeyframeTrack(
+              ".bones[" + boneData.bone.name + "].position",
+              boneData.pos.times,
+              boneData.pos.values
+            )
+          );
+        }
+        convertedTracks.push(
+          new QuaternionKeyframeTrack(
+            ".bones[" + boneData.bone.name + "].quaternion",
+            boneData.quat.times,
+            boneData.quat.values
+          )
+        );
+      }
+    }
+    mixer.uncacheAction(clip);
+    return new AnimationClip(clip.name, -1, convertedTracks);
+  },
+  getHelperFromSkeleton: function(skeleton) {
+    var source = new SkeletonHelper(skeleton.bones[0]);
+    source.skeleton = skeleton;
+    return source;
+  },
+  getSkeletonOffsets: function() {
+    var targetParentPos = new Vector3(), targetPos = new Vector3(), sourceParentPos = new Vector3(), sourcePos = new Vector3(), targetDir = new Vector2(), sourceDir = new Vector2();
+    return function(target, source, options) {
+      options = options || {};
+      options.hip = options.hip !== void 0 ? options.hip : "hip";
+      options.names = options.names || {};
+      if (!source.isObject3D) {
+        source = this.getHelperFromSkeleton(source);
+      }
+      var nameKeys = Object.keys(options.names), nameValues = Object.values(options.names), sourceBones = source.isObject3D ? source.skeleton.bones : this.getBones(source), bones = target.isObject3D ? target.skeleton.bones : this.getBones(target), offsets = [], bone, boneTo, name, i;
+      target.skeleton.pose();
+      for (i = 0; i < bones.length; ++i) {
+        bone = bones[i];
+        name = options.names[bone.name] || bone.name;
+        boneTo = this.getBoneByName(name, sourceBones);
+        if (boneTo && name !== options.hip) {
+          var boneParent = this.getNearestBone(bone.parent, nameKeys), boneToParent = this.getNearestBone(boneTo.parent, nameValues);
+          boneParent.updateMatrixWorld();
+          boneToParent.updateMatrixWorld();
+          targetParentPos.setFromMatrixPosition(boneParent.matrixWorld);
+          targetPos.setFromMatrixPosition(bone.matrixWorld);
+          sourceParentPos.setFromMatrixPosition(boneToParent.matrixWorld);
+          sourcePos.setFromMatrixPosition(boneTo.matrixWorld);
+          targetDir.subVectors(new Vector2(targetPos.x, targetPos.y), new Vector2(targetParentPos.x, targetParentPos.y)).normalize();
+          sourceDir.subVectors(new Vector2(sourcePos.x, sourcePos.y), new Vector2(sourceParentPos.x, sourceParentPos.y)).normalize();
+          var laterialAngle = targetDir.angle() - sourceDir.angle();
+          var offset = new Matrix4().makeRotationFromEuler(new Euler(0, 0, laterialAngle));
+          bone.matrix.multiply(offset);
+          bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
+          bone.updateMatrixWorld();
+          offsets[name] = offset;
+        }
+      }
+      return offsets;
+    };
+  }(),
+  renameBones: function(skeleton, names) {
+    var bones = this.getBones(skeleton);
+    for (let i = 0; i < bones.length; ++i) {
+      var bone = bones[i];
+      if (names[bone.name]) {
+        bone.name = names[bone.name];
+      }
+    }
+    return this;
+  },
+  getBones: function(skeleton) {
+    return Array.isArray(skeleton) ? skeleton : skeleton.bones;
+  },
+  getBoneByName: function(name, skeleton) {
+    for (let i = 0, bones = this.getBones(skeleton); i < bones.length; i++) {
+      if (name === bones[i].name)
+        return bones[i];
+    }
+  },
+  getNearestBone: function(bone, names) {
+    while (bone.isBone) {
+      if (names.indexOf(bone.name) !== -1) {
+        return bone;
+      }
+      bone = bone.parent;
+    }
+  },
+  findBoneTrackData: function(name, tracks) {
+    var regexp = /\[(.*)\]\.(.*)/, result = { name };
+    for (let i = 0; i < tracks.length; ++i) {
+      var trackData = regexp.exec(tracks[i].name);
+      if (trackData && name === trackData[1]) {
+        result[trackData[2]] = i;
+      }
+    }
+    return result;
+  },
+  getEqualsBonesNames: function(skeleton, targetSkeleton) {
+    var sourceBones = this.getBones(skeleton), targetBones = this.getBones(targetSkeleton), bones = [];
+    search:
+      for (let i = 0; i < sourceBones.length; i++) {
+        var boneName = sourceBones[i].name;
+        for (let j = 0; j < targetBones.length; j++) {
+          if (boneName === targetBones[j].name) {
+            bones.push(boneName);
+            continue search;
+          }
+        }
+      }
+    return bones;
+  },
+  clone: function(source) {
+    var sourceLookup = /* @__PURE__ */ new Map();
+    var cloneLookup = /* @__PURE__ */ new Map();
+    var clone = source.clone();
+    parallelTraverse(source, clone, function(sourceNode, clonedNode) {
+      sourceLookup.set(clonedNode, sourceNode);
+      cloneLookup.set(sourceNode, clonedNode);
+    });
+    clone.traverse(function(node) {
+      if (!node.isSkinnedMesh)
+        return;
+      var clonedMesh = node;
+      var sourceMesh = sourceLookup.get(node);
+      var sourceBones = sourceMesh.skeleton.bones;
+      clonedMesh.skeleton = sourceMesh.skeleton.clone();
+      clonedMesh.bindMatrix.copy(sourceMesh.bindMatrix);
+      clonedMesh.skeleton.bones = sourceBones.map(function(bone) {
+        return cloneLookup.get(bone);
+      });
+      clonedMesh.bind(clonedMesh.skeleton, clonedMesh.bindMatrix);
+    });
+    return clone;
+  }
+};
+function parallelTraverse(a, b, callback) {
+  callback(a, b);
+  for (let i = 0; i < a.children.length; i++) {
+    parallelTraverse(a.children[i], b.children[i], callback);
+  }
+}
+export {
+  SkeletonUtils
+};

package/dist/utils/UVsDebug.d.ts

@@ -0,0 +1,3 @@
+import { BufferGeometry } from 'three'
+
+export function UVsDebug(geometry: BufferGeometry, size: number): HTMLCanvasElement

package/dist/utils/UVsDebug.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+var UVsDebug = function(geometry, size) {
+  var abc = "abc";
+  var a = new THREE.Vector2();
+  var b = new THREE.Vector2();
+  var uvs = [new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2()];
+  var face = [];
+  var canvas = document.createElement("canvas");
+  var width = size || 1024;
+  var height = size || 1024;
+  canvas.width = width;
+  canvas.height = height;
+  var ctx = canvas.getContext("2d");
+  ctx.lineWidth = 1;
+  ctx.strokeStyle = "rgb( 63, 63, 63 )";
+  ctx.textAlign = "center";
+  ctx.fillStyle = "rgb( 255, 255, 255 )";
+  ctx.fillRect(0, 0, width, height);
+  if (geometry.isGeometry) {
+    console.error("THREE.UVsDebug no longer supports Geometry. Use THREE.BufferGeometry instead.");
+    return;
+  } else {
+    var index = geometry.index;
+    var uvAttribute = geometry.attributes.uv;
+    if (index) {
+      for (let i = 0, il = index.count; i < il; i += 3) {
+        face[0] = index.getX(i);
+        face[1] = index.getX(i + 1);
+        face[2] = index.getX(i + 2);
+        uvs[0].fromBufferAttribute(uvAttribute, face[0]);
+        uvs[1].fromBufferAttribute(uvAttribute, face[1]);
+        uvs[2].fromBufferAttribute(uvAttribute, face[2]);
+        processFace(face, uvs, i / 3);
+      }
+    } else {
+      for (let i = 0, il = uvAttribute.count; i < il; i += 3) {
+        face[0] = i;
+        face[1] = i + 1;
+        face[2] = i + 2;
+        uvs[0].fromBufferAttribute(uvAttribute, face[0]);
+        uvs[1].fromBufferAttribute(uvAttribute, face[1]);
+        uvs[2].fromBufferAttribute(uvAttribute, face[2]);
+        processFace(face, uvs, i / 3);
+      }
+    }
+  }
+  return canvas;
+  function processFace(face2, uvs2, index2) {
+    ctx.beginPath();
+    a.set(0, 0);
+    for (let j2 = 0, jl2 = uvs2.length; j2 < jl2; j2++) {
+      var uv = uvs2[j2];
+      a.x += uv.x;
+      a.y += uv.y;
+      if (j2 === 0) {
+        ctx.moveTo(uv.x * (width - 2) + 0.5, (1 - uv.y) * (height - 2) + 0.5);
+      } else {
+        ctx.lineTo(uv.x * (width - 2) + 0.5, (1 - uv.y) * (height - 2) + 0.5);
+      }
+    }
+    ctx.closePath();
+    ctx.stroke();
+    a.divideScalar(uvs2.length);
+    ctx.font = "18px Arial";
+    ctx.fillStyle = "rgb( 63, 63, 63 )";
+    ctx.fillText(index2, a.x * width, (1 - a.y) * height);
+    if (a.x > 0.95) {
+      ctx.fillText(index2, a.x % 1 * width, (1 - a.y) * height);
+    }
+    ctx.font = "12px Arial";
+    ctx.fillStyle = "rgb( 191, 191, 191 )";
+    for (j = 0, jl = uvs2.length; j < jl; j++) {
+      var uv = uvs2[j];
+      b.addVectors(a, uv).divideScalar(2);
+      var vnum = face2[j];
+      ctx.fillText(abc[j] + vnum, b.x * width, (1 - b.y) * height);
+      if (b.x > 0.95) {
+        ctx.fillText(abc[j] + vnum, b.x % 1 * width, (1 - b.y) * height);
+      }
+    }
+  }
+};
+exports.UVsDebug = UVsDebug;

package/dist/utils/UVsDebug.mjs

@@ -0,0 +1,85 @@
+import { Vector2 } from "three";
+var UVsDebug = function(geometry, size) {
+  var abc = "abc";
+  var a = new Vector2();
+  var b = new Vector2();
+  var uvs = [new Vector2(), new Vector2(), new Vector2()];
+  var face = [];
+  var canvas = document.createElement("canvas");
+  var width = size || 1024;
+  var height = size || 1024;
+  canvas.width = width;
+  canvas.height = height;
+  var ctx = canvas.getContext("2d");
+  ctx.lineWidth = 1;
+  ctx.strokeStyle = "rgb( 63, 63, 63 )";
+  ctx.textAlign = "center";
+  ctx.fillStyle = "rgb( 255, 255, 255 )";
+  ctx.fillRect(0, 0, width, height);
+  if (geometry.isGeometry) {
+    console.error("THREE.UVsDebug no longer supports Geometry. Use THREE.BufferGeometry instead.");
+    return;
+  } else {
+    var index = geometry.index;
+    var uvAttribute = geometry.attributes.uv;
+    if (index) {
+      for (let i = 0, il = index.count; i < il; i += 3) {
+        face[0] = index.getX(i);
+        face[1] = index.getX(i + 1);
+        face[2] = index.getX(i + 2);
+        uvs[0].fromBufferAttribute(uvAttribute, face[0]);
+        uvs[1].fromBufferAttribute(uvAttribute, face[1]);
+        uvs[2].fromBufferAttribute(uvAttribute, face[2]);
+        processFace(face, uvs, i / 3);
+      }
+    } else {
+      for (let i = 0, il = uvAttribute.count; i < il; i += 3) {
+        face[0] = i;
+        face[1] = i + 1;
+        face[2] = i + 2;
+        uvs[0].fromBufferAttribute(uvAttribute, face[0]);
+        uvs[1].fromBufferAttribute(uvAttribute, face[1]);
+        uvs[2].fromBufferAttribute(uvAttribute, face[2]);
+        processFace(face, uvs, i / 3);
+      }
+    }
+  }
+  return canvas;
+  function processFace(face2, uvs2, index2) {
+    ctx.beginPath();
+    a.set(0, 0);
+    for (let j2 = 0, jl2 = uvs2.length; j2 < jl2; j2++) {
+      var uv = uvs2[j2];
+      a.x += uv.x;
+      a.y += uv.y;
+      if (j2 === 0) {
+        ctx.moveTo(uv.x * (width - 2) + 0.5, (1 - uv.y) * (height - 2) + 0.5);
+      } else {
+        ctx.lineTo(uv.x * (width - 2) + 0.5, (1 - uv.y) * (height - 2) + 0.5);
+      }
+    }
+    ctx.closePath();
+    ctx.stroke();
+    a.divideScalar(uvs2.length);
+    ctx.font = "18px Arial";
+    ctx.fillStyle = "rgb( 63, 63, 63 )";
+    ctx.fillText(index2, a.x * width, (1 - a.y) * height);
+    if (a.x > 0.95) {
+      ctx.fillText(index2, a.x % 1 * width, (1 - a.y) * height);
+    }
+    ctx.font = "12px Arial";
+    ctx.fillStyle = "rgb( 191, 191, 191 )";
+    for (j = 0, jl = uvs2.length; j < jl; j++) {
+      var uv = uvs2[j];
+      b.addVectors(a, uv).divideScalar(2);
+      var vnum = face2[j];
+      ctx.fillText(abc[j] + vnum, b.x * width, (1 - b.y) * height);
+      if (b.x > 0.95) {
+        ctx.fillText(abc[j] + vnum, b.x % 1 * width, (1 - b.y) * height);
+      }
+    }
+  }
+};
+export {
+  UVsDebug
+};

package/dist/utils/WorkerPool.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class WorkerPool {
+  constructor(pool = 4) {
+    this.pool = pool;
+    this.queue = [];
+    this.workers = [];
+    this.workersResolve = [];
+    this.workerStatus = 0;
+  }
+  _initWorker(workerId) {
+    if (!this.workers[workerId]) {
+      const worker = this.workerCreator();
+      worker.addEventListener("message", this._onMessage.bind(this, workerId));
+      this.workers[workerId] = worker;
+    }
+  }
+  _getIdleWorker() {
+    for (let i = 0; i < this.pool; i++)
+      if (!(this.workerStatus & 1 << i))
+        return i;
+    return -1;
+  }
+  _onMessage(workerId, msg) {
+    const resolve = this.workersResolve[workerId];
+    resolve && resolve(msg);
+    if (this.queue.length) {
+      const { resolve: resolve2, msg: msg2, transfer } = this.queue.shift();
+      this.workersResolve[workerId] = resolve2;
+      this.workers[workerId].postMessage(msg2, transfer);
+    } else {
+      this.workerStatus ^= 1 << workerId;
+    }
+  }
+  setWorkerCreator(workerCreator) {
+    this.workerCreator = workerCreator;
+  }
+  setWorkerLimit(pool) {
+    this.pool = pool;
+  }
+  postMessage(msg, transfer) {
+    return new Promise((resolve) => {
+      const workerId = this._getIdleWorker();
+      if (workerId !== -1) {
+        this._initWorker(workerId);
+        this.workerStatus |= 1 << workerId;
+        this.workersResolve[workerId] = resolve;
+        this.workers[workerId].postMessage(msg, transfer);
+      } else {
+        this.queue.push({ resolve, msg, transfer });
+      }
+    });
+  }
+  dispose() {
+    this.workers.forEach((worker) => worker.terminate());
+    this.workersResolve.length = 0;
+    this.workers.length = 0;
+    this.queue.length = 0;
+    this.workerStatus = 0;
+  }
+}
+exports.WorkerPool = WorkerPool;

package/dist/utils/WorkerPool.mjs

@@ -0,0 +1,62 @@
+class WorkerPool {
+  constructor(pool = 4) {
+    this.pool = pool;
+    this.queue = [];
+    this.workers = [];
+    this.workersResolve = [];
+    this.workerStatus = 0;
+  }
+  _initWorker(workerId) {
+    if (!this.workers[workerId]) {
+      const worker = this.workerCreator();
+      worker.addEventListener("message", this._onMessage.bind(this, workerId));
+      this.workers[workerId] = worker;
+    }
+  }
+  _getIdleWorker() {
+    for (let i = 0; i < this.pool; i++)
+      if (!(this.workerStatus & 1 << i))
+        return i;
+    return -1;
+  }
+  _onMessage(workerId, msg) {
+    const resolve = this.workersResolve[workerId];
+    resolve && resolve(msg);
+    if (this.queue.length) {
+      const { resolve: resolve2, msg: msg2, transfer } = this.queue.shift();
+      this.workersResolve[workerId] = resolve2;
+      this.workers[workerId].postMessage(msg2, transfer);
+    } else {
+      this.workerStatus ^= 1 << workerId;
+    }
+  }
+  setWorkerCreator(workerCreator) {
+    this.workerCreator = workerCreator;
+  }
+  setWorkerLimit(pool) {
+    this.pool = pool;
+  }
+  postMessage(msg, transfer) {
+    return new Promise((resolve) => {
+      const workerId = this._getIdleWorker();
+      if (workerId !== -1) {
+        this._initWorker(workerId);
+        this.workerStatus |= 1 << workerId;
+        this.workersResolve[workerId] = resolve;
+        this.workers[workerId].postMessage(msg, transfer);
+      } else {
+        this.queue.push({ resolve, msg, transfer });
+      }
+    });
+  }
+  dispose() {
+    this.workers.forEach((worker) => worker.terminate());
+    this.workersResolve.length = 0;
+    this.workers.length = 0;
+    this.queue.length = 0;
+    this.workerStatus = 0;
+  }
+}
+export {
+  WorkerPool
+};

package/dist/webxr/ARButton.d.ts

@@ -0,0 +1,5 @@
+import { WebGLRenderer, XRSessionInit } from 'three';
+declare class ARButton {
+    static createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLButtonElement | HTMLAnchorElement;
+}
+export { ARButton };