presenter 0.9.3 → 0.10.0

package/dist/3d.mjs

@@ -0,0 +1,1055 @@
+const W = {
+  IMAGE: "Image",
+  SLIDE_OBJECT: "SlideObject"
+};
+function y(e) {
+  return {
+    description: null,
+    objectType: W.SLIDE_OBJECT,
+    opacity: 1,
+    ...e
+  };
+}
+function h(e, t = 0, r = 0, n = 1) {
+  if (typeof e == "string") {
+    const a = e.replace("#", ""), o = parseInt(a, 16);
+    return isNaN(o) ? (console.warn("Invalid hex color format:", e), $) : a.length === 6 ? {
+      red: o >> 16 & 255,
+      green: o >> 8 & 255,
+      blue: o & 255,
+      alpha: 1
+    } : a.length === 8 ? {
+      red: o >> 24 & 255,
+      green: o >> 16 & 255,
+      blue: o >> 8 & 255,
+      alpha: (o & 255) / 255
+    } : (console.warn("Invalid hex color format:", e), $);
+  } else if (typeof e == "number")
+    return {
+      red: e,
+      green: t ?? 0,
+      blue: r ?? 0,
+      alpha: n ?? 1
+    };
+  return {
+    red: 0,
+    green: 0,
+    blue: 0,
+    alpha: 1,
+    ...e
+  };
+}
+h.BLACK = h(0, 0, 0);
+h.BLUE = h(0, 0, 255);
+h.GREEN = h(0, 255, 0);
+h.RED = h(255, 0, 0);
+h.TRANSPARENT = h(0, 0, 0, 0);
+h.WHITE = h(255, 255, 255);
+const $ = { red: 0, green: 0, blue: 0, alpha: 1 }, u = {
+  x: 0,
+  y: 0,
+  z: 0,
+  rotationX: 0,
+  rotationY: 0,
+  rotationZ: 0,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1,
+  scaleZ: 1,
+  color: h.WHITE,
+  wireframe: !1
+}, s = {
+  BOX: "ThreeBox",
+  MODEL: "ThreeModel",
+  MODEL_MATERIAL: "ThreeModelMaterial",
+  MODEL_NODE: "ThreeModelNode",
+  PRESENTER_GROUP: "ThreePresenterGroup",
+  SCENE: "ThreeScene",
+  SPHERE: "ThreeSphere"
+};
+function Ve(e = null) {
+  return y({
+    objectType: s.BOX,
+    ...u,
+    width: 1,
+    height: 1,
+    depth: 1,
+    ...e
+  });
+}
+const S = {
+  ORTHOGRAPHIC: "Orthographic",
+  PERSPECTIVE: "Perspective"
+};
+function Je(e = null) {
+  return y({
+    objectType: s.MODEL,
+    ...u,
+    src: "",
+    materialColor: null,
+    nodes: [],
+    materials: [],
+    debugNames: !1,
+    ...e
+  });
+}
+function qe(e = null) {
+  return y({
+    objectType: s.MODEL_MATERIAL,
+    name: null,
+    presenterId: null,
+    materialColor: null,
+    wireframe: !1,
+    ...e
+  });
+}
+function ze(e = null) {
+  return y({
+    objectType: s.MODEL_NODE,
+    name: null,
+    path: null,
+    presenterId: null,
+    x: u.x,
+    y: u.y,
+    z: u.z,
+    rotationX: u.rotationX,
+    rotationY: u.rotationY,
+    rotationZ: u.rotationZ,
+    scale: u.scale,
+    scaleX: u.scaleX,
+    scaleY: u.scaleY,
+    scaleZ: u.scaleZ,
+    materialColor: null,
+    wireframe: u.wireframe,
+    ...e
+  });
+}
+function Qe(e, t = null) {
+  return y({
+    objectType: s.PRESENTER_GROUP,
+    ...u,
+    objects: e,
+    width: 1,
+    height: 1,
+    textureWidth: null,
+    textureHeight: null,
+    doubleSided: !0,
+    ...t
+  });
+}
+const m = {
+  TOP_LEFT: "TopLeft",
+  TOP: "Top",
+  TOP_RIGHT: "TopRight",
+  LEFT: "Left",
+  CENTER: "Center",
+  RIGHT: "Right",
+  BOTTOM_LEFT: "BottomLeft",
+  BOTTOM: "Bottom",
+  BOTTOM_RIGHT: "BottomRight"
+}, K = m.TOP_LEFT;
+function je(e, t = null) {
+  return y({
+    objectType: s.SCENE,
+    anchor: K,
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100,
+    meshes: e,
+    fallbackImageId: null,
+    fallbackImagePath: null,
+    fallbackCornerRadius: 0,
+    fallbackSmooth: !0,
+    cameraType: S.PERSPECTIVE,
+    cameraX: 0,
+    cameraY: 0,
+    cameraZ: 5,
+    cameraFov: 50,
+    cameraOrthographicHeight: null,
+    cameraNear: 0.1,
+    cameraFar: 2e3,
+    targetX: 0,
+    targetY: 0,
+    targetZ: 0,
+    backgroundColor: null,
+    ambientLightColor: h.WHITE,
+    ambientLightIntensity: 1,
+    directionalLightColor: h.WHITE,
+    directionalLightIntensity: 2,
+    directionalLightX: 3,
+    directionalLightY: 4,
+    directionalLightZ: 5,
+    ...t
+  });
+}
+function et(e = null) {
+  return y({
+    objectType: s.SPHERE,
+    ...u,
+    radius: 1,
+    widthSegments: 32,
+    heightSegments: 16,
+    ...e
+  });
+}
+const I = {
+  Browser: "browser",
+  Node: "node"
+};
+function p(e = null) {
+  return {
+    x: 0,
+    y: 0,
+    ...e
+  };
+}
+const ie = p();
+function N(e = null) {
+  return {
+    height: 0,
+    width: 0,
+    ...e
+  };
+}
+const le = N({ width: 0, height: 0 });
+function E(e, t = null) {
+  return e.alpha * (t ?? 1);
+}
+function g(e = null) {
+  return {
+    origin: ie,
+    size: le,
+    ...e
+  };
+}
+g();
+function D(e, t) {
+  throw new Error("Unexpected value: " + e);
+}
+function F(e, t, r) {
+  const { x: n, y: a } = e, { width: o, height: i } = r;
+  switch (t) {
+    case m.TOP_LEFT:
+      return g({
+        origin: p({ x: n, y: a }),
+        size: r
+      });
+    case m.TOP:
+      return g({
+        origin: p({ x: n - o / 2, y: a }),
+        size: r
+      });
+    case m.TOP_RIGHT:
+      return g({
+        origin: p({ x: n - o, y: a }),
+        size: r
+      });
+    case m.LEFT:
+      return g({
+        origin: p({ x: n, y: a - i / 2 }),
+        size: r
+      });
+    case m.CENTER:
+      return g({
+        origin: p({ x: n - o / 2, y: a - i / 2 }),
+        size: r
+      });
+    case m.RIGHT:
+      return g({
+        origin: p({ x: n - o, y: a - i / 2 }),
+        size: r
+      });
+    case m.BOTTOM_LEFT:
+      return g({
+        origin: p({ x: n, y: a - i }),
+        size: r
+      });
+    case m.BOTTOM:
+      return g({
+        origin: p({ x: n - o / 2, y: a - i }),
+        size: r
+      });
+    case m.BOTTOM_RIGHT:
+      return g({
+        origin: p({ x: n - o, y: a - i }),
+        size: r
+      });
+    default:
+      D(t);
+  }
+}
+function M(e) {
+  return (e.red << 16) + (e.green << 8) + e.blue;
+}
+async function V() {
+  try {
+    const [e, t] = await Promise.all([
+      import("three"),
+      import("three/examples/jsm/loaders/GLTFLoader.js")
+    ]);
+    return { THREE: e, GLTFLoader: t.GLTFLoader };
+  } catch (e) {
+    throw new Error(
+      'Presenter 3D rendering requires the "three" package. Install it with: npm install three',
+      { cause: e }
+    );
+  }
+}
+function ce(e) {
+  const t = [], r = e;
+  for (const n of ["objects", "meshes", "nodes", "materials"]) {
+    const a = r[n];
+    Array.isArray(a) && t.push(...se(a));
+  }
+  return t;
+}
+function se(e) {
+  return e.filter(
+    (t) => typeof t == "object" && t !== null && "objectType" in t
+  );
+}
+function J(e) {
+  const t = [];
+  function r(n, a) {
+    const o = n === e && n.name === "" ? a : [...a, n.name];
+    (n !== e || n.name !== "") && t.push({ object: n, path: o });
+    for (const i of n.children)
+      r(i, o);
+  }
+  return r(e, []), t;
+}
+function q(e) {
+  return typeof e == "string" ? e.split("/").filter((t) => t !== "") : e;
+}
+function A(e) {
+  return e.join("/");
+}
+function ue(e) {
+  return "path" in e && e.path !== null ? `path "${A(q(e.path))}"` : e.presenterId !== null ? `presenterId "${e.presenterId}"` : e.name !== null ? `name "${e.name}"` : "empty target";
+}
+function he(e, t) {
+  const r = q(t);
+  if (r.length > e.length)
+    return !1;
+  const n = e.length - r.length;
+  return r.every((a, o) => e[n + o] === a);
+}
+function B(e) {
+  var r, n;
+  const t = ((r = e.userData) == null ? void 0 : r.presenterId) ?? ((n = e.userData) == null ? void 0 : n.presenterID);
+  return typeof t == "string" ? t : null;
+}
+function z(e, t) {
+  const r = /* @__PURE__ */ new Map(), n = J(t).map(({ object: a, path: o }) => {
+    const i = X(a) ? Array.isArray(a.material) ? a.material : [a.material] : [], c = i.map((l) => l.name);
+    for (const l of i) {
+      const d = r.get(l), f = A(o);
+      d === void 0 ? r.set(l, {
+        name: l.name,
+        presenterId: B(l),
+        meshPaths: [f]
+      }) : r.set(l, {
+        ...d,
+        meshPaths: [...d.meshPaths, f]
+      });
+    }
+    return {
+      name: a.name,
+      path: o,
+      pathString: A(o),
+      type: a.type,
+      isMesh: X(a),
+      isBone: de(a),
+      presenterId: B(a),
+      materialNames: c
+    };
+  });
+  return {
+    src: e,
+    nodes: n,
+    materials: [...r.values()]
+  };
+}
+function Q(e) {
+  var n;
+  const t = `ThreeModel ${e.src}`;
+  (console.groupCollapsed ?? console.group).call(console, t), console.table(
+    e.nodes.map((a) => ({
+      path: a.pathString,
+      name: a.name,
+      type: a.type,
+      presenterId: a.presenterId,
+      materials: a.materialNames.join(", ")
+    }))
+  ), console.table(
+    e.materials.map((a) => ({
+      name: a.name,
+      presenterId: a.presenterId,
+      meshes: a.meshPaths.join(", ")
+    }))
+  ), (n = console.groupEnd) == null || n.call(console);
+}
+function X(e) {
+  return "isMesh" in e && e.isMesh === !0;
+}
+function de(e) {
+  return "isBone" in e && e.isBone === !0;
+}
+const x = /* @__PURE__ */ new Map(), Y = /* @__PURE__ */ new Set();
+async function fe(e, t) {
+  const r = /* @__PURE__ */ new Map();
+  for (const n of t.slides)
+    for (const a of n.objects)
+      ee(a, r);
+  await Promise.all(
+    [...r.values()].map(async (n) => {
+      try {
+        await j(e, n.src), n.debugNames && pe(n.src);
+      } catch (a) {
+        throw new Error(`Failed to load 3D model: ${n.src}`, { cause: a });
+      }
+    })
+  );
+}
+function _(e) {
+  const t = x.get(e);
+  return (t == null ? void 0 : t.status) === "loaded" ? t.scene : null;
+}
+function j(e, t) {
+  return me(e, t);
+}
+function ee(e, t) {
+  if (e.objectType === s.MODEL) {
+    const r = e;
+    if (r.src !== "") {
+      const n = t.get(r.src);
+      t.set(r.src, {
+        src: r.src,
+        debugNames: r.debugNames || (n == null ? void 0 : n.debugNames) === !0
+      });
+    }
+  }
+  for (const r of ce(e))
+    ee(r, t);
+}
+function pe(e) {
+  if (Y.has(e))
+    return;
+  const t = _(e);
+  t !== null && (Y.add(e), Q(z(e, t)));
+}
+function me(e, t) {
+  const r = x.get(t);
+  if ((r == null ? void 0 : r.status) === "loaded")
+    return Promise.resolve();
+  if ((r == null ? void 0 : r.status) === "loading")
+    return r.promise;
+  const n = new Promise((a, o) => {
+    e.load(
+      t,
+      (i) => {
+        x.set(t, { status: "loaded", scene: i.scene }), a();
+      },
+      void 0,
+      (i) => {
+        x.delete(t), o(i);
+      }
+    );
+  });
+  return x.set(t, { status: "loading", promise: n }), n;
+}
+const k = /* @__PURE__ */ new WeakMap(), Z = /* @__PURE__ */ new Set();
+async function tt(e) {
+  const t = await V(), r = new t.GLTFLoader();
+  return await fe(r, e), {
+    [s.SCENE]: ye(
+      t
+    )
+  };
+}
+function ge(e) {
+  var t;
+  return ((t = k.get(e)) == null ? void 0 : t.renderer.domElement) ?? null;
+}
+function ye({ THREE: e }) {
+  return (t) => {
+    const { ctx: r, object: n, opacity: a, originalObject: o, getCurrentObject: i } = t;
+    if (r.type !== I.Browser)
+      return;
+    const c = a * n.opacity;
+    if (c === 0 || n.width <= 0 || n.height <= 0)
+      return;
+    const l = we(e, n, o);
+    l.renderer.setPixelRatio(window.devicePixelRatio || 1), l.renderer.setSize(n.width, n.height, !1), xe(l.scene), Me(e, l, n);
+    const d = o.objectType === s.SCENE ? o : n;
+    for (const P of d.meshes) {
+      const C = i(P);
+      if (C === void 0 || C.opacity === 0)
+        continue;
+      const O = Se(e, C, P, t);
+      O !== null && (_e(O, C), l.scene.add(O));
+    }
+    Te(e, l, n), l.camera.position.set(n.cameraX, n.cameraY, n.cameraZ), l.target.set(n.targetX, n.targetY, n.targetZ), l.camera.lookAt(l.target), l.camera.updateProjectionMatrix(), l.renderer.render(l.scene, l.camera);
+    const f = F(
+      p({ x: n.x, y: n.y }),
+      n.anchor,
+      N({ width: n.width, height: n.height })
+    );
+    r.context.save(), r.context.globalAlpha = c, r.context.drawImage(
+      l.renderer.domElement,
+      f.origin.x,
+      f.origin.y,
+      f.size.width,
+      f.size.height
+    ), r.context.restore();
+  };
+}
+function we(e, t, r) {
+  const n = r.objectType === s.SCENE ? r : t, a = k.get(n);
+  if (a !== void 0)
+    return a;
+  const o = document.createElement("canvas"), c = {
+    renderer: new e.WebGLRenderer({
+      alpha: !0,
+      antialias: !0,
+      canvas: o,
+      preserveDrawingBuffer: !0
+    }),
+    scene: new e.Scene(),
+    camera: te(e, t),
+    cameraType: t.cameraType,
+    target: new e.Vector3()
+  };
+  return k.set(n, c), c;
+}
+function Te(e, t, r) {
+  switch (t.cameraType !== r.cameraType && (t.camera = te(e, r), t.cameraType = r.cameraType), r.cameraType) {
+    case S.PERSPECTIVE: {
+      const n = t.camera;
+      n.aspect = r.width / r.height, n.fov = r.cameraFov, n.near = r.cameraNear, n.far = r.cameraFar;
+      break;
+    }
+    case S.ORTHOGRAPHIC: {
+      const n = t.camera, a = re(r), o = a * (r.width / r.height);
+      n.left = -o / 2, n.right = o / 2, n.top = a / 2, n.bottom = -a / 2, n.near = r.cameraNear, n.far = r.cameraFar;
+      break;
+    }
+  }
+}
+function te(e, t) {
+  switch (t.cameraType) {
+    case S.PERSPECTIVE:
+      return new e.PerspectiveCamera(
+        t.cameraFov,
+        t.width / t.height,
+        t.cameraNear,
+        t.cameraFar
+      );
+    case S.ORTHOGRAPHIC:
+      return Ie(e, t);
+  }
+}
+function Ie(e, t) {
+  const r = re(t), n = r * (t.width / t.height);
+  return new e.OrthographicCamera(
+    -n / 2,
+    n / 2,
+    r / 2,
+    -r / 2,
+    t.cameraNear,
+    t.cameraFar
+  );
+}
+function re(e) {
+  if (e.cameraOrthographicHeight !== null && e.cameraOrthographicHeight > 0)
+    return e.cameraOrthographicHeight;
+  const t = Math.hypot(
+    e.cameraX - e.targetX,
+    e.cameraY - e.targetY,
+    e.cameraZ - e.targetZ
+  );
+  return t === 0 ? e.height : 2 * t * Math.tan(w(e.cameraFov) / 2);
+}
+function Me(e, t, r) {
+  r.backgroundColor === null ? t.renderer.setClearColor(0, 0) : t.renderer.setClearColor(
+    M(r.backgroundColor),
+    E(r.backgroundColor)
+  );
+  const n = new e.AmbientLight(
+    M(r.ambientLightColor),
+    r.ambientLightIntensity
+  );
+  t.scene.add(n);
+  const a = new e.DirectionalLight(
+    M(r.directionalLightColor),
+    r.directionalLightIntensity
+  );
+  a.position.set(
+    r.directionalLightX,
+    r.directionalLightY,
+    r.directionalLightZ
+  ), t.scene.add(a);
+}
+function xe(e) {
+  for (; e.children.length > 0; ) {
+    const t = e.children[0];
+    t !== void 0 && (be(t), e.remove(t));
+  }
+}
+function Se(e, t, r, n) {
+  switch (t.objectType) {
+    case s.BOX:
+      return Ee(e, t);
+    case s.SPHERE:
+      return Pe(e, t);
+    case s.MODEL:
+      return Le(
+        e,
+        t,
+        r,
+        n.getCurrentObject
+      );
+    case s.PRESENTER_GROUP:
+      return Ce(e, t, n);
+    default:
+      return null;
+  }
+}
+function Ee(e, t) {
+  const r = new e.BoxGeometry(t.width, t.height, t.depth);
+  return T(r), new e.Mesh(r, ne(e, t));
+}
+function Pe(e, t) {
+  const r = new e.SphereGeometry(
+    t.radius,
+    t.widthSegments,
+    t.heightSegments
+  );
+  return T(r), new e.Mesh(r, ne(e, t));
+}
+function Ce(e, t, r) {
+  const n = t.textureWidth ?? r.slideSize.width, a = t.textureHeight ?? r.slideSize.height;
+  if (t.width <= 0 || t.height <= 0 || n <= 0 || a <= 0)
+    return null;
+  const o = document.createElement("canvas");
+  o.width = Math.ceil(n), o.height = Math.ceil(a);
+  const i = o.getContext("2d");
+  if (i === null)
+    return null;
+  i.clearRect(0, 0, o.width, o.height);
+  const c = {
+    type: I.Browser,
+    context: i
+  };
+  for (const P of t.objects)
+    r.renderObject(P, 1, c);
+  const l = new e.CanvasTexture(o);
+  l.colorSpace = e.SRGBColorSpace, T(l);
+  const d = new e.PlaneGeometry(t.width, t.height);
+  T(d);
+  const f = new e.MeshBasicMaterial({
+    color: M(t.color),
+    map: l,
+    opacity: t.opacity * E(t.color),
+    side: t.doubleSided ? e.DoubleSide : e.FrontSide,
+    transparent: !0,
+    wireframe: t.wireframe
+  });
+  return T(f), new e.Mesh(d, f);
+}
+function Le(e, t, r, n) {
+  if (t.src === "")
+    return null;
+  const a = _(t.src);
+  if (a === null)
+    return console.warn(`3D model was not preloaded: ${t.src}`), null;
+  const o = a.clone(!0);
+  return Be(o, t), ve(o, t, r, n), Ne(o, t, r, n), o;
+}
+function ne(e, t) {
+  const r = new e.MeshStandardMaterial({
+    color: M(t.color),
+    opacity: t.opacity * E(t.color),
+    transparent: t.opacity < 1 || E(t.color) < 1,
+    wireframe: t.wireframe
+  });
+  return T(r), r;
+}
+function Be(e, t) {
+  G(t) && e.traverse((r) => {
+    R(r) && b(r, t, () => !0);
+  });
+}
+function ve(e, t, r, n) {
+  for (const a of r.materials) {
+    const o = n(a) ?? a;
+    if (!G(o))
+      continue;
+    let i = 0;
+    e.traverse((c) => {
+      R(c) && b(c, o, (l) => {
+        const d = Ae(l, o);
+        return d && i++, d;
+      });
+    }), ae(t.src, "material", o, i);
+  }
+}
+function Ne(e, t, r, n) {
+  const a = J(e);
+  for (const o of r.nodes) {
+    const i = n(o) ?? o, c = a.filter((l) => De(l, i));
+    ae(t.src, "node", i, c.length);
+    for (const l of c)
+      Re(l.object, i), G(i) && Oe(l.object, i);
+  }
+}
+function Re(e, t) {
+  e.position.set(
+    e.position.x + t.x,
+    e.position.y + t.y,
+    e.position.z + t.z
+  ), e.rotation.set(
+    e.rotation.x + w(t.rotationX),
+    e.rotation.y + w(t.rotationY),
+    e.rotation.z + w(t.rotationZ)
+  ), e.scale.set(
+    e.scale.x * t.scale * t.scaleX,
+    e.scale.y * t.scale * t.scaleY,
+    e.scale.z * t.scale * t.scaleZ
+  );
+}
+function Oe(e, t) {
+  e.traverse((r) => {
+    R(r) && b(r, t, () => !0);
+  });
+}
+function De(e, t) {
+  return t.path !== null ? he(e.path, t.path) : t.presenterId !== null ? B(e.object) === t.presenterId : t.name !== null ? e.object.name === t.name : !1;
+}
+function Ae(e, t) {
+  return t.presenterId !== null ? B(e) === t.presenterId : t.name !== null ? e.name === t.name : !1;
+}
+function ae(e, t, r, n) {
+  if (n === 1 || t === "material" && n > 1)
+    return;
+  const a = ue(r), o = `${e}:${t}:${a}:${n}`;
+  if (Z.has(o))
+    return;
+  Z.add(o);
+  const i = n === 0 ? `ThreeModel ${e} did not find ${t} target ${a}.` : `ThreeModel ${e} found ${n} ${t} targets for ${a}. Use a path or presenterId to make the target unique.`;
+  console.warn(i);
+}
+function b(e, t, r) {
+  const n = Array.isArray(e.material) ? e.material : [e.material];
+  let a = !1;
+  const o = n.map((i) => {
+    if (!r(i))
+      return i;
+    a = !0;
+    const c = ke(i);
+    return Fe(c, t), c;
+  });
+  if (a)
+    if (Array.isArray(e.material))
+      e.material = o;
+    else {
+      const i = o[0];
+      i !== void 0 && (e.material = i);
+    }
+}
+function ke(e) {
+  if (v(e))
+    return e;
+  const t = e.clone();
+  return T(t), t;
+}
+function Fe(e, t) {
+  t.materialColor !== null && e.color !== void 0 && e.color.setHex(M(t.materialColor));
+  const r = e.opacity * t.opacity * (t.materialColor !== null ? E(t.materialColor) : 1);
+  r !== e.opacity && (e.opacity = r, e.transparent = !0), t.wireframe && (e.wireframe = !0);
+}
+function G(e) {
+  return e.materialColor !== null || e.opacity !== 1 || e.wireframe;
+}
+function _e(e, t) {
+  e.position.set(t.x, t.y, t.z), e.rotation.set(
+    w(t.rotationX),
+    w(t.rotationY),
+    w(t.rotationZ)
+  ), e.scale.set(t.scale * t.scaleX, t.scale * t.scaleY, t.scale * t.scaleZ);
+}
+function w(e) {
+  return e * Math.PI / 180;
+}
+function be(e) {
+  e.traverse((t) => {
+    if (!R(t))
+      return;
+    v(t.geometry) && t.geometry.dispose();
+    const r = Array.isArray(t.material) ? t.material : [t.material];
+    for (const n of r)
+      Ge(n), v(n) && n.dispose();
+  });
+}
+function R(e) {
+  return "isMesh" in e && e.isMesh === !0;
+}
+function Ge(e) {
+  const t = e;
+  t.map !== void 0 && t.map !== null && v(t.map) && t.map.dispose();
+}
+function T(e) {
+  e.userData.presenterRendererOwned = !0;
+}
+function v(e) {
+  var t;
+  return ((t = e.userData) == null ? void 0 : t.presenterRendererOwned) === !0;
+}
+function oe(e = null) {
+  return y({
+    objectType: W.IMAGE,
+    anchor: K,
+    cornerRadius: 0,
+    height: 100,
+    imageId: null,
+    imagePath: null,
+    smooth: !0,
+    width: 100,
+    x: 0,
+    y: 0,
+    ...e
+  });
+}
+function $e(e, t, r, n, a = 0) {
+  const o = n();
+  o.path.moveTo(e.x + r, e.y), o.path.lineTo(e.x + t.width - r, e.y), o.path.arcTo(
+    e.x + t.width,
+    e.y,
+    e.x + t.width,
+    e.y + r,
+    r
+  ), o.path.lineTo(e.x + t.width, e.y + t.height - r), o.path.arcTo(
+    e.x + t.width,
+    e.y + t.height,
+    e.x + t.width - r,
+    e.y + t.height,
+    r
+  ), o.path.lineTo(e.x + r, e.y + t.height), o.path.arcTo(
+    e.x,
+    e.y + t.height,
+    e.x,
+    e.y + t.height - r,
+    r
+  ), o.path.lineTo(e.x, e.y + r), o.path.arcTo(e.x, e.y, e.x + r, e.y, r), a > 0 && o.path.lineTo(e.x + r + a, e.y);
+  const i = 2 * (t.width + t.height - 4 * r) + 2 * Math.PI * r + a;
+  return { path: o, length: i };
+}
+const H = {
+  Browser: "browser",
+  Node: "node"
+}, U = {
+  Browser: "browser",
+  Node: "node"
+}, Xe = ({
+  ctx: e,
+  imageById: t,
+  object: r,
+  opacity: n,
+  createPath2D: a
+}) => {
+  const o = F(
+    p({ x: r.x, y: r.y }),
+    r.anchor,
+    N({ width: r.width, height: r.height })
+  ), i = r.imageId != null && r.imageId.length > 0 ? r.imageId : r.imagePath;
+  if (i == null)
+    return;
+  const c = t[i];
+  if (c !== void 0) {
+    if (e.context.save(), r.cornerRadius > 0) {
+      const l = $e(
+        o.origin,
+        o.size,
+        r.cornerRadius,
+        a
+      );
+      switch (e.type) {
+        case I.Browser:
+          l.path.type === U.Browser ? e.context.clip(l.path.path) : console.warn("Attempted to use Node Path2D in Browser Canvas context");
+          break;
+        case I.Node:
+          l.path.type === U.Node ? e.context.clip(l.path.path) : console.warn("Attempted to use Browser Path2D in Node Canvas context");
+          break;
+        default:
+          D(e);
+      }
+    }
+    switch (e.context.globalAlpha = n * r.opacity, e.context.imageSmoothingEnabled = r.smooth, e.type) {
+      case I.Browser:
+        c.type === H.Browser ? e.context.drawImage(
+          c.image,
+          o.origin.x,
+          o.origin.y,
+          o.size.width,
+          o.size.height
+        ) : console.warn("Attempted to use Node Image in Browser Canvas context");
+        break;
+      case I.Node:
+        c.type === H.Node ? e.context.drawImage(
+          c.image,
+          o.origin.x,
+          o.origin.y,
+          o.size.width,
+          o.size.height
+        ) : console.warn("Attempted to use Browser Image in Node Canvas context");
+        break;
+      default:
+        D(e);
+    }
+    e.context.restore();
+  }
+}, Ye = (e) => {
+  const { object: t } = e;
+  t.fallbackImageId == null && t.fallbackImagePath == null || Xe({
+    ...e,
+    object: oe({
+      anchor: t.anchor,
+      cornerRadius: t.fallbackCornerRadius,
+      description: t.description,
+      height: t.height,
+      imageId: t.fallbackImageId,
+      imagePath: t.fallbackImagePath,
+      opacity: t.opacity,
+      smooth: t.fallbackSmooth,
+      width: t.width,
+      x: t.x,
+      y: t.y
+    })
+  });
+};
+function Ze(e, t, r, n) {
+  return F(
+    {
+      x: e.x * n.scale + n.translateX,
+      y: e.y * n.scale + n.translateY
+    },
+    t,
+    {
+      width: r.width * n.scale,
+      height: r.height * n.scale
+    }
+  );
+}
+function L(e, t) {
+  return e / t;
+}
+const He = ({
+  imagePathById: e,
+  slide: t,
+  object: r,
+  opacity: n,
+  pixelsPerInch: a,
+  transform: o
+}) => {
+  const i = r.opacity * n;
+  if (i === 0)
+    return;
+  const c = r.imageId != null && r.imageId.length > 0 ? r.imageId : r.imagePath;
+  if (c == null)
+    return;
+  const l = e[c];
+  if (l === void 0)
+    return;
+  const { origin: d, size: f } = Ze(
+    p({ x: r.x, y: r.y }),
+    r.anchor,
+    N({ width: r.width, height: r.height }),
+    o
+  );
+  t.addImage({
+    path: l,
+    x: L(d.x, a),
+    y: L(d.y, a),
+    w: L(f.width, a),
+    h: L(f.height, a),
+    transparency: (1 - i) * 100
+  });
+}, Ue = (e) => {
+  const { object: t } = e;
+  t.fallbackImageId == null && t.fallbackImagePath == null || He({
+    ...e,
+    object: oe({
+      anchor: t.anchor,
+      cornerRadius: t.fallbackCornerRadius,
+      description: t.description,
+      height: t.height,
+      imageId: t.fallbackImageId,
+      imagePath: t.fallbackImagePath,
+      opacity: t.opacity,
+      smooth: t.fallbackSmooth,
+      width: t.width,
+      x: t.x,
+      y: t.y
+    })
+  });
+}, rt = {
+  [s.SCENE]: Ye
+}, nt = {
+  [s.SCENE]: Ue
+};
+async function We(e) {
+  const t = await V(), r = new t.GLTFLoader();
+  await j(r, e);
+  const n = _(e);
+  if (n === null)
+    throw new Error(`3D model was not loaded: ${e}`);
+  return z(e, n);
+}
+async function at(e) {
+  const t = await We(e);
+  return Q(t), t;
+}
+function ot({ scenes: e }) {
+  typeof window > "u" || (window.presenterCaptureThreeScene = (t, r = {}) => {
+    const n = e[t];
+    if (n === void 0)
+      return console.warn(`No Presenter 3D scene registered with name "${t}".`), null;
+    const a = ge(n);
+    if (a === null)
+      return console.warn(`Presenter 3D scene "${t}" has not been rendered yet.`), null;
+    const o = r.imageType ?? "image/png", i = a.toDataURL(o, r.quality), c = document.createElement("a");
+    return c.href = i, c.download = r.filename ?? `${t}.${Ke(o)}`, c.click(), null;
+  });
+}
+function Ke(e) {
+  switch (e) {
+    case "image/jpeg":
+      return "jpg";
+    case "image/webp":
+      return "webp";
+    default:
+      return "png";
+  }
+}
+export {
+  rt as THREE_FALLBACK_OBJECT_RENDERERS,
+  nt as THREE_POWERPOINT_FALLBACK_OBJECT_RENDERERS,
+  Ve as ThreeBox,
+  S as ThreeCameraType,
+  Je as ThreeModel,
+  qe as ThreeModelMaterial,
+  ze as ThreeModelNode,
+  s as ThreeObjectType,
+  Qe as ThreePresenterGroup,
+  je as ThreeScene,
+  et as ThreeSphere,
+  ge as getRenderedThreeSceneCanvas,
+  tt as getThreeObjectRenderers,
+  We as inspectThreeModel,
+  ot as installThreeSceneCaptureApi,
+  at as logThreeModelParts,
+  Ye as renderThreeSceneFallback,
+  Ue as renderThreeScenePowerPointFallback
+};
+//# sourceMappingURL=3d.mjs.map