@glyphcss/react 0.0.1

package/dist/index.js

@@ -0,0 +1,766 @@
+// src/index.ts
+import {
+  CAMERA_BACKFACE_CULL_EPS,
+  VOXEL_CAMERA_CULL_AXIS_EPS,
+  VOXEL_CAMERA_CULL_NORMAL_LIMIT,
+  normalizePolygons,
+  mergePolygons,
+  coverPlanarPolygons,
+  optimizeMeshPolygons,
+  cullInteriorPolygons,
+  cameraCullNormalGroups,
+  cameraCullNormalGroupsFromPolygons,
+  cameraCullNormalKey,
+  cameraCullVisibleSignature,
+  cameraFacingDepth,
+  isAxisAlignedSurfaceNormal,
+  isVoxelCameraCullableNormalGroups,
+  normalFacesCamera,
+  polygonCssSurfaceNormal,
+  polygonFacesCamera,
+  parseObj,
+  parseMtl,
+  parseGltf,
+  bakeSolidTextureSamples,
+  bakeSolidTextureSampledPolygons,
+  loadMesh,
+  createIsometricCamera,
+  parseVox,
+  polygonFaces,
+  computeShapeLighting,
+  parseColor,
+  parsePureColor,
+  parseHexColor,
+  parseRgbColor,
+  formatColor,
+  clampChannel,
+  shadeColor,
+  rotateVec3,
+  inverseRotateVec3,
+  axesHelperPolygons,
+  arrowPolygons,
+  ringPolygons,
+  octahedronPolygons,
+  buildSceneContext,
+  computeSceneBbox,
+  BASE_TILE,
+  DEFAULT_CAMERA_STATE,
+  DEFAULT_PROJECTION,
+  normalizeInvertMultiplier,
+  createGlyphcssAnimationMixer as createGlyphcssAnimationMixer2,
+  LoopOnce,
+  LoopRepeat,
+  LoopPingPong
+} from "@glyphcss/core";
+
+// src/glyphcss/scene/GlyphcssScene.tsx
+import { memo, useCallback, useEffect, useMemo, useRef } from "react";
+import { createGlyphcssScene, injectGlyphcssBaseStyles } from "glyphcss";
+
+// src/glyphcss/scene/context.ts
+import { createContext, useContext } from "react";
+var GlyphcssSceneContext = createContext(null);
+function useGlyphcssSceneContext() {
+  const ctx = useContext(GlyphcssSceneContext);
+  if (!ctx) {
+    throw new Error("glyphcss: GlyphcssMesh must be used inside a GlyphcssScene.");
+  }
+  return ctx;
+}
+var GlyphcssMeshContext = createContext(null);
+
+// src/glyphcss/scene/GlyphcssScene.tsx
+import { jsx } from "react/jsx-runtime";
+function GlyphcssSceneInner({
+  mode,
+  glyphPalette,
+  useColors,
+  cols,
+  rows,
+  cellAspect,
+  directionalLight,
+  ambientLight,
+  className,
+  style,
+  children
+}) {
+  const hostRef = useRef(null);
+  const sceneRef = useRef(null);
+  const initialOpts = useMemo(() => ({
+    mode,
+    glyphPalette,
+    useColors,
+    cols,
+    rows,
+    cellAspect,
+    directionalLight,
+    ambientLight
+  }), []);
+  const hostCallbackRef = useCallback((el) => {
+    if (el && !sceneRef.current) {
+      hostRef.current = el;
+      injectGlyphcssBaseStyles(el.ownerDocument ?? void 0);
+      sceneRef.current = createGlyphcssScene(el, initialOpts);
+    } else if (!el && sceneRef.current) {
+      sceneRef.current.destroy();
+      sceneRef.current = null;
+      hostRef.current = null;
+    }
+  }, [initialOpts]);
+  useEffect(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const partial = {};
+    if (mode !== void 0) partial.mode = mode;
+    if (glyphPalette !== void 0) partial.glyphPalette = glyphPalette;
+    if (useColors !== void 0) partial.useColors = useColors;
+    if (cols !== void 0) partial.cols = cols;
+    if (rows !== void 0) partial.rows = rows;
+    if (cellAspect !== void 0) partial.cellAspect = cellAspect;
+    if (directionalLight !== void 0) partial.directionalLight = directionalLight;
+    if (ambientLight !== void 0) partial.ambientLight = ambientLight;
+    if (Object.keys(partial).length > 0) {
+      scene.setOptions(partial);
+    }
+  }, [mode, glyphPalette, useColors, cols, rows, cellAspect, directionalLight, ambientLight]);
+  const ctxValue = useMemo(() => ({ sceneRef }), [sceneRef]);
+  const computedClassName = `glyphcss-host${className ? ` ${className}` : ""}`;
+  return /* @__PURE__ */ jsx(GlyphcssSceneContext.Provider, { value: ctxValue, children: /* @__PURE__ */ jsx("div", { ref: hostCallbackRef, className: computedClassName, style, children }) });
+}
+var GlyphcssScene = memo(GlyphcssSceneInner);
+
+// src/glyphcss/scene/GlyphcssMesh.tsx
+import { memo as memo2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2 } from "react";
+
+// src/glyphcss/scene/events.ts
+var MESH_REGISTRY = /* @__PURE__ */ new WeakMap();
+function registerMeshElement(el, handle) {
+  MESH_REGISTRY.set(el, handle);
+}
+function unregisterMeshElement(el) {
+  MESH_REGISTRY.delete(el);
+}
+function findGlyphcssMeshHandle(el) {
+  let cur = el;
+  while (cur) {
+    if (cur instanceof HTMLElement) {
+      const h = MESH_REGISTRY.get(cur);
+      if (h) return h;
+    }
+    cur = cur.parentElement;
+  }
+  return null;
+}
+
+// src/glyphcss/scene/GlyphcssMesh.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function GlyphcssMeshInner({
+  id,
+  triangles: trianglesProp,
+  position,
+  scale,
+  rotation,
+  className,
+  style,
+  children
+}) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const meshRef = useRef2(null);
+  const wrapperRef = useRef2(null);
+  const triangles = useMemo2(() => trianglesProp ?? [], [trianglesProp]);
+  const transform = useMemo2(() => ({
+    position,
+    scale,
+    rotation
+  }), [position, scale, rotation]);
+  useEffect2(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const handle = scene.add(triangles, transform);
+    meshRef.current = handle;
+    return () => {
+      handle.dispose();
+      meshRef.current = null;
+    };
+  }, [sceneRef, triangles]);
+  useEffect2(() => {
+    const mesh = meshRef.current;
+    if (!mesh) return;
+    mesh.setTransform(transform);
+    sceneRef.current?.rerender();
+  }, [sceneRef, transform]);
+  useEffect2(() => {
+    const el = wrapperRef.current;
+    const handle = meshRef.current;
+    if (!el || !handle) return;
+    registerMeshElement(el, handle);
+    return () => unregisterMeshElement(el);
+  });
+  const computedClassName = `glyphcss-mesh${className ? ` ${className}` : ""}`;
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      ref: wrapperRef,
+      "data-glyphcss-mesh-id": id,
+      className: computedClassName,
+      style,
+      children
+    }
+  );
+}
+var GlyphcssMesh = memo2(GlyphcssMeshInner);
+
+// src/glyphcss/scene/GlyphcssHotspot.tsx
+import { memo as memo3, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef3 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function GlyphcssHotspotInner({
+  id,
+  at,
+  size,
+  onClick,
+  className,
+  children
+}) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const hotspotRef = useRef3(null);
+  const onClickRef = useRef3(onClick);
+  onClickRef.current = onClick;
+  const atKey = useMemo3(() => at.join(","), [at]);
+  const sizeKey = size ? size.join(",") : "";
+  useEffect3(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const handle = scene.addHotspot(
+      { id, at, size },
+      () => {
+      }
+    );
+    hotspotRef.current = handle;
+    return () => {
+      handle.remove();
+      hotspotRef.current = null;
+    };
+  }, [sceneRef, id, atKey, sizeKey]);
+  if (!children && !onClick && !className) return null;
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      "data-glyphcss-hotspot-id": id,
+      className,
+      style: { display: "contents" },
+      onClick,
+      children
+    }
+  );
+}
+var GlyphcssHotspot = memo3(GlyphcssHotspotInner);
+
+// src/glyphcss/scene/useGlyphcssMesh.ts
+import { useEffect as useEffect4, useRef as useRef4, useState } from "react";
+function useGlyphcssMesh(triangles, options) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const meshRef = useRef4(null);
+  const [loading] = useState(false);
+  useEffect4(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const handle = scene.add(triangles, options?.transform);
+    meshRef.current = handle;
+    return () => {
+      handle.dispose();
+      meshRef.current = null;
+    };
+  }, [sceneRef, triangles]);
+  useEffect4(() => {
+    const mesh = meshRef.current;
+    if (!mesh) return;
+    if (options?.transform) {
+      mesh.setTransform(options.transform);
+      sceneRef.current?.rerender();
+    }
+  }, [sceneRef, options?.transform]);
+  return { meshRef, loading };
+}
+
+// src/glyphcss/camera/GlyphcssPerspectiveCamera.tsx
+import { memo as memo4, useEffect as useEffect5, useMemo as useMemo4, useRef as useRef5 } from "react";
+import { createGlyphcssPerspectiveCamera } from "glyphcss";
+
+// src/glyphcss/camera/context.ts
+import { createContext as createContext2, useContext as useContext2 } from "react";
+var GlyphcssCameraContext = createContext2(null);
+function useGlyphcssCamera() {
+  const ctx = useContext2(GlyphcssCameraContext);
+  if (!ctx) {
+    throw new Error("glyphcss: camera hook must be used inside a GlyphcssCamera.");
+  }
+  return ctx;
+}
+
+// src/glyphcss/camera/GlyphcssPerspectiveCamera.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function GlyphcssPerspectiveCameraInner({
+  rotX,
+  rotY,
+  distance,
+  scale,
+  stretch,
+  center,
+  children
+}) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const cameraRef = useRef5(null);
+  if (!cameraRef.current) {
+    const opts = {};
+    if (rotX !== void 0) opts.rotX = rotX;
+    if (rotY !== void 0) opts.rotY = rotY;
+    if (distance !== void 0) opts.distance = distance;
+    if (scale !== void 0) opts.scale = scale;
+    if (stretch !== void 0) opts.stretch = stretch;
+    if (center !== void 0) opts.center = center;
+    cameraRef.current = createGlyphcssPerspectiveCamera(opts);
+  }
+  useEffect5(() => {
+    const scene = sceneRef.current;
+    if (!scene || !cameraRef.current) return;
+    scene.setOptions({ camera: cameraRef.current });
+    scene.rerender();
+  }, [sceneRef]);
+  useEffect5(() => {
+    const camera = cameraRef.current;
+    if (!camera) return;
+    let dirty = false;
+    if (rotX !== void 0 && camera.rotX !== rotX) {
+      camera.rotX = rotX;
+      dirty = true;
+    }
+    if (rotY !== void 0 && camera.rotY !== rotY) {
+      camera.rotY = rotY;
+      dirty = true;
+    }
+    if (distance !== void 0 && camera.distance !== distance) {
+      camera.distance = distance;
+      dirty = true;
+    }
+    if (scale !== void 0 && camera.scale !== scale) {
+      camera.scale = scale;
+      dirty = true;
+    }
+    if (stretch !== void 0 && camera.stretch !== stretch) {
+      camera.stretch = stretch;
+      dirty = true;
+    }
+    if (dirty) {
+      sceneRef.current?.rerender();
+    }
+  });
+  const rerender = () => sceneRef.current?.rerender();
+  const ctxValue = useMemo4(() => ({ cameraRef, rerender }), [cameraRef]);
+  return /* @__PURE__ */ jsx4(GlyphcssCameraContext.Provider, { value: ctxValue, children });
+}
+var GlyphcssPerspectiveCamera = memo4(GlyphcssPerspectiveCameraInner);
+
+// src/glyphcss/camera/GlyphcssOrthographicCamera.tsx
+import { memo as memo5, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef6 } from "react";
+import { createGlyphcssOrthographicCamera } from "glyphcss";
+import { jsx as jsx5 } from "react/jsx-runtime";
+function GlyphcssOrthographicCameraInner({
+  rotX,
+  rotY,
+  zoom,
+  center,
+  children
+}) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const cameraRef = useRef6(null);
+  if (!cameraRef.current) {
+    const opts = {};
+    if (rotX !== void 0) opts.rotX = rotX;
+    if (rotY !== void 0) opts.rotY = rotY;
+    if (zoom !== void 0) opts.zoom = zoom;
+    if (center !== void 0) opts.center = center;
+    cameraRef.current = createGlyphcssOrthographicCamera(opts);
+  }
+  useEffect6(() => {
+    const scene = sceneRef.current;
+    if (!scene || !cameraRef.current) return;
+    scene.setOptions({ camera: cameraRef.current });
+    scene.rerender();
+  }, [sceneRef]);
+  useEffect6(() => {
+    const camera = cameraRef.current;
+    if (!camera) return;
+    let dirty = false;
+    if (rotX !== void 0 && camera.rotX !== rotX) {
+      camera.rotX = rotX;
+      dirty = true;
+    }
+    if (rotY !== void 0 && camera.rotY !== rotY) {
+      camera.rotY = rotY;
+      dirty = true;
+    }
+    if (zoom !== void 0 && camera.scale !== zoom) {
+      camera.scale = zoom;
+      dirty = true;
+    }
+    if (dirty) sceneRef.current?.rerender();
+  });
+  const rerender = () => sceneRef.current?.rerender();
+  const ctxValue = useMemo5(() => ({ cameraRef, rerender }), [cameraRef]);
+  return /* @__PURE__ */ jsx5(GlyphcssCameraContext.Provider, { value: ctxValue, children });
+}
+var GlyphcssOrthographicCamera = memo5(GlyphcssOrthographicCameraInner);
+
+// src/glyphcss/camera/useGlyphcssCamera.ts
+import { useCallback as useCallback2, useEffect as useEffect7, useRef as useRef7 } from "react";
+import { createGlyphcssPerspectiveCamera as createGlyphcssPerspectiveCamera2 } from "glyphcss";
+
+// src/glyphcss/controls/GlyphcssOrbitControls.tsx
+import { useEffect as useEffect8, useRef as useRef8 } from "react";
+import { createGlyphcssOrbitControls } from "glyphcss";
+function GlyphcssOrbitControls({
+  drag = true,
+  wheel = true,
+  invert = false,
+  animate = false
+}) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const controlsRef = useRef8(null);
+  const propsRef = useRef8({ drag, wheel, invert, animate });
+  propsRef.current = { drag, wheel, invert, animate };
+  useEffect8(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const opts = {
+      drag: propsRef.current.drag,
+      wheel: propsRef.current.wheel,
+      invert: propsRef.current.invert,
+      animate: propsRef.current.animate === false ? false : propsRef.current.animate
+    };
+    const controls = createGlyphcssOrbitControls(scene, opts);
+    controlsRef.current = controls;
+    return () => {
+      controls.destroy();
+      controlsRef.current = null;
+    };
+  }, [sceneRef]);
+  useEffect8(() => {
+    const controls = controlsRef.current;
+    if (!controls) return;
+    controls.update({ drag, wheel, invert, animate: animate === false ? false : animate });
+  });
+  return null;
+}
+
+// src/glyphcss/controls/GlyphcssMapControls.tsx
+import { useEffect as useEffect9, useRef as useRef9 } from "react";
+import { createGlyphcssMapControls } from "glyphcss";
+function GlyphcssMapControls({
+  drag = true,
+  wheel = true,
+  invert = false,
+  animate = false
+}) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const controlsRef = useRef9(null);
+  const propsRef = useRef9({ drag, wheel, invert, animate });
+  propsRef.current = { drag, wheel, invert, animate };
+  useEffect9(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const opts = {
+      drag: propsRef.current.drag,
+      wheel: propsRef.current.wheel,
+      invert: propsRef.current.invert,
+      animate: propsRef.current.animate === false ? false : propsRef.current.animate
+    };
+    const controls = createGlyphcssMapControls(scene, opts);
+    controlsRef.current = controls;
+    return () => {
+      controls.destroy();
+      controlsRef.current = null;
+    };
+  }, [sceneRef]);
+  useEffect9(() => {
+    const controls = controlsRef.current;
+    if (!controls) return;
+    controls.update({ drag, wheel, invert, animate: animate === false ? false : animate });
+  });
+  return null;
+}
+
+// src/glyphcss/controls/GlyphcssFirstPersonControls.tsx
+import { useEffect as useEffect10, useRef as useRef10 } from "react";
+import { createGlyphcssFirstPersonControls } from "glyphcss";
+function GlyphcssFirstPersonControls({
+  drag = true,
+  keyboard = true,
+  moveSpeed = 0.05,
+  lookSpeed = 4e-3,
+  invert = false
+}) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const controlsRef = useRef10(null);
+  const propsRef = useRef10({ drag, keyboard, moveSpeed, lookSpeed, invert });
+  propsRef.current = { drag, keyboard, moveSpeed, lookSpeed, invert };
+  useEffect10(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const opts = {
+      drag: propsRef.current.drag,
+      keyboard: propsRef.current.keyboard,
+      moveSpeed: propsRef.current.moveSpeed,
+      lookSpeed: propsRef.current.lookSpeed,
+      invert: propsRef.current.invert
+    };
+    const controls = createGlyphcssFirstPersonControls(scene, opts);
+    controlsRef.current = controls;
+    return () => {
+      controls.destroy();
+      controlsRef.current = null;
+    };
+  }, [sceneRef]);
+  useEffect10(() => {
+    const controls = controlsRef.current;
+    if (!controls) return;
+    controls.update({ drag, keyboard, moveSpeed, lookSpeed, invert });
+  });
+  return null;
+}
+
+// src/glyphcss/helpers/GlyphcssAxesHelper.tsx
+import { memo as memo6, useEffect as useEffect11, useMemo as useMemo7, useRef as useRef11 } from "react";
+function axisTriangles(size) {
+  const s = size;
+  const t = s * 0.05;
+  const triangles = [];
+  function addBar(a, b, color) {
+    const v0 = [a[0] - t, a[1] - t, a[2]];
+    const v1 = [b[0] - t, b[1] - t, b[2]];
+    const v2 = [b[0] + t, b[1] + t, b[2]];
+    const v3 = [a[0] + t, a[1] + t, a[2]];
+    triangles.push({ vertices: [v0, v1, v2], color });
+    triangles.push({ vertices: [v0, v2, v3], color });
+  }
+  addBar([0, 0, 0], [s, 0, 0], "#ff0000");
+  addBar([0, 0, 0], [0, s, 0], "#00ff00");
+  addBar([0, 0, 0], [0, 0, s], "#0000ff");
+  return triangles;
+}
+function GlyphcssAxesHelperInner({ size = 1 }) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const meshRef = useRef11(null);
+  const triangles = useMemo7(() => axisTriangles(size), [size]);
+  useEffect11(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const handle = scene.add(triangles);
+    meshRef.current = handle;
+    return () => {
+      handle.dispose();
+      meshRef.current = null;
+    };
+  }, [sceneRef, triangles]);
+  return null;
+}
+var GlyphcssAxesHelper = memo6(GlyphcssAxesHelperInner);
+
+// src/glyphcss/helpers/GlyphcssDirectionalLightHelper.tsx
+import { memo as memo7, useEffect as useEffect12, useMemo as useMemo8, useRef as useRef12 } from "react";
+function lightMarkerTriangles(position, color, size) {
+  const [px, py, pz] = position;
+  const s = size;
+  const top = [px, py, pz + s];
+  const bot = [px, py, pz - s];
+  const right = [px + s, py, pz];
+  const left = [px - s, py, pz];
+  const front = [px, py + s, pz];
+  const back = [px, py - s, pz];
+  return [
+    { vertices: [top, right, front], color },
+    { vertices: [top, front, left], color },
+    { vertices: [top, left, back], color },
+    { vertices: [top, back, right], color },
+    { vertices: [bot, front, right], color },
+    { vertices: [bot, left, front], color },
+    { vertices: [bot, back, left], color },
+    { vertices: [bot, right, back], color }
+  ];
+}
+function GlyphcssDirectionalLightHelperInner({
+  position = [1, 1, 1],
+  color = "#ffff00",
+  size = 0.1
+}) {
+  const { sceneRef } = useGlyphcssSceneContext();
+  const meshRef = useRef12(null);
+  const triangles = useMemo8(
+    () => lightMarkerTriangles(position, color, size),
+    [position, color, size]
+  );
+  useEffect12(() => {
+    const scene = sceneRef.current;
+    if (!scene) return;
+    const handle = scene.add(triangles);
+    meshRef.current = handle;
+    return () => {
+      handle.dispose();
+      meshRef.current = null;
+    };
+  }, [sceneRef, triangles]);
+  return null;
+}
+var GlyphcssDirectionalLightHelper = memo7(GlyphcssDirectionalLightHelperInner);
+
+// src/glyphcss/styles/index.ts
+import { injectGlyphcssBaseStyles as injectGlyphcssBaseStyles2 } from "glyphcss";
+
+// src/animation/useGlyphcssAnimation.ts
+import { useEffect as useEffect13, useRef as useRef13, useMemo as useMemo9 } from "react";
+import { createGlyphcssAnimationMixer } from "@glyphcss/core";
+function resolveRoot(rootArg) {
+  if (!rootArg) return null;
+  if ("current" in rootArg) return rootArg.current;
+  return rootArg;
+}
+function useGlyphcssAnimation(clips, controller, root) {
+  const internalRef = useRef13(null);
+  const mixerRef = useRef13(null);
+  useEffect13(() => {
+    if (!clips || clips.length === 0 || !controller) {
+      mixerRef.current = null;
+      return;
+    }
+    const resolvedRoot = resolveRoot(root) ?? internalRef.current;
+    if (!resolvedRoot) {
+      mixerRef.current = null;
+      return;
+    }
+    mixerRef.current = createGlyphcssAnimationMixer(resolvedRoot, controller);
+    return () => {
+      mixerRef.current?.stopAllAction();
+      mixerRef.current?.uncacheRoot();
+      mixerRef.current = null;
+    };
+  }, [clips, controller]);
+  useEffect13(() => {
+    if (!clips || clips.length === 0 || !controller) return;
+    let rafId;
+    let lastTime = null;
+    function tick(now) {
+      if (lastTime === null) {
+        lastTime = now;
+        rafId = requestAnimationFrame(tick);
+        return;
+      }
+      const dt = (now - lastTime) / 1e3;
+      lastTime = now;
+      mixerRef.current?.update(dt);
+      rafId = requestAnimationFrame(tick);
+    }
+    rafId = requestAnimationFrame(tick);
+    return () => {
+      cancelAnimationFrame(rafId);
+      lastTime = null;
+    };
+  }, [clips, controller]);
+  const resolvedClips = clips ?? [];
+  const resolvedNames = resolvedClips.map((c) => c.name);
+  const actions = useMemo9(() => {
+    const target = {};
+    for (const clip of resolvedClips) {
+      Object.defineProperty(target, clip.name, {
+        enumerable: true,
+        get() {
+          const m = mixerRef.current;
+          if (!m) return null;
+          try {
+            return m.clipAction(clip.name);
+          } catch {
+            return null;
+          }
+        }
+      });
+    }
+    return target;
+  }, [resolvedClips]);
+  return {
+    ref: internalRef,
+    mixer: mixerRef.current,
+    clips: resolvedClips,
+    names: resolvedNames,
+    actions
+  };
+}
+export {
+  BASE_TILE,
+  CAMERA_BACKFACE_CULL_EPS,
+  DEFAULT_CAMERA_STATE,
+  DEFAULT_PROJECTION,
+  GlyphcssAxesHelper,
+  GlyphcssPerspectiveCamera as GlyphcssCamera,
+  GlyphcssCameraContext,
+  GlyphcssDirectionalLightHelper,
+  GlyphcssFirstPersonControls,
+  GlyphcssHotspot,
+  GlyphcssMapControls,
+  GlyphcssMesh,
+  GlyphcssOrbitControls,
+  GlyphcssOrthographicCamera,
+  GlyphcssPerspectiveCamera,
+  GlyphcssScene,
+  GlyphcssSceneContext,
+  LoopOnce,
+  LoopPingPong,
+  LoopRepeat,
+  VOXEL_CAMERA_CULL_AXIS_EPS,
+  VOXEL_CAMERA_CULL_NORMAL_LIMIT,
+  arrowPolygons,
+  axesHelperPolygons,
+  bakeSolidTextureSampledPolygons,
+  bakeSolidTextureSamples,
+  buildSceneContext,
+  cameraCullNormalGroups,
+  cameraCullNormalGroupsFromPolygons,
+  cameraCullNormalKey,
+  cameraCullVisibleSignature,
+  cameraFacingDepth,
+  clampChannel,
+  computeSceneBbox,
+  computeShapeLighting,
+  coverPlanarPolygons,
+  createGlyphcssAnimationMixer2 as createGlyphcssAnimationMixer,
+  createIsometricCamera,
+  cullInteriorPolygons,
+  findGlyphcssMeshHandle,
+  formatColor,
+  injectGlyphcssBaseStyles2 as injectGlyphcssBaseStyles,
+  inverseRotateVec3,
+  isAxisAlignedSurfaceNormal,
+  isVoxelCameraCullableNormalGroups,
+  loadMesh,
+  mergePolygons,
+  normalFacesCamera,
+  normalizeInvertMultiplier,
+  normalizePolygons,
+  octahedronPolygons,
+  optimizeMeshPolygons,
+  parseColor,
+  parseGltf,
+  parseHexColor,
+  parseMtl,
+  parseObj,
+  parsePureColor,
+  parseRgbColor,
+  parseVox,
+  polygonCssSurfaceNormal,
+  polygonFaces,
+  polygonFacesCamera,
+  ringPolygons,
+  rotateVec3,
+  shadeColor,
+  useGlyphcssAnimation,
+  useGlyphcssCamera,
+  useGlyphcssMesh,
+  useGlyphcssSceneContext
+};