worldorbit 3.2.0 → 3.2.2

package/dist/unpkg/worldorbit.js

@@ -30712,6 +30712,7 @@ void main() {
     createEmbedPayload: () => createEmbedPayload,
     createEmptyAtlasDocument: () => createEmptyAtlasDocument,
     createInteractiveViewer: () => createInteractiveViewer,
+    createInteractiveViewer2D: () => createInteractiveViewer2D,
     createWorldOrbitEmbedMarkup: () => createWorldOrbitEmbedMarkup,
     defineWorldOrbitViewerElement: () => defineWorldOrbitViewerElement,
     deserializeViewerAtlasState: () => deserializeViewerAtlasState,
@@ -31873,11 +31874,12 @@ void main() {
     const schemaProjection = resolveProjection(document2, options.projection);
     const camera = normalizeViewCamera(options.camera ?? null);
     const renderProjection = resolveRenderProjection(schemaProjection, camera);
-    const scaleModel = resolveScaleModel(layoutPreset, options.scaleModel);
     const spacingFactor = layoutPresetSpacing(layoutPreset);
+    const scaleModel = resolveScaleModel(layoutPreset, options.scaleModel, options.bodyScaleMode);
     const systemId = document2.system?.id ?? null;
     const activeEventId = options.activeEventId ?? null;
     const effectiveObjects = createEffectiveObjects(document2.objects, document2.events ?? [], activeEventId);
+    const sceneMetricScale = resolveSceneMetricScale(effectiveObjects, width, height, padding, spacingFactor, scaleModel);
     const objectMap = new Map(effectiveObjects.map((object) => [object.id, object]));
     const relationships = buildSceneRelationships(effectiveObjects, objectMap);
     const positions = /* @__PURE__ */ new Map();
@@ -31916,7 +31918,8 @@ void main() {
       objectMap,
       spacingFactor,
       projection: renderProjection,
-      scaleModel
+      scaleModel,
+      sceneMetricScale
     };
     const primaryRoot = rootObjects.find((object) => object.type === "star") ?? rootObjects[0] ?? null;
     if (primaryRoot) {
@@ -31932,14 +31935,14 @@ void main() {
       });
     }
     freeObjects.forEach((object, index) => {
-      const x = width - padding - 140 - freePlacementOffsetPx(object.placement?.mode === "free" ? object.placement.distance : void 0, scaleModel);
+      const x = width - padding - 140 - freePlacementOffsetPx(object.placement?.mode === "free" ? object.placement.distance : void 0, scaleModel, sceneMetricScale);
       const rowStep = Math.max(76, (height - padding * 2 - 180) / Math.max(1, freeObjects.length) * spacingFactor) * scaleModel.freePlacementMultiplier;
       const y = padding + 92 + index * rowStep;
       positions.set(object.id, {
         object,
         x,
         y,
-        radius: visualRadiusFor(object, 0, scaleModel),
+        radius: visualRadiusFor(object, 0, scaleModel, sceneMetricScale),
         sortKey: computeSortKey(x, y, 0)
       });
       leaderDrafts.push({
@@ -31962,7 +31965,7 @@ void main() {
         object,
         x: resolved.x,
         y: resolved.y,
-        radius: visualRadiusFor(object, 2, scaleModel),
+        radius: visualRadiusFor(object, 2, scaleModel, sceneMetricScale),
         sortKey: computeSortKey(resolved.x, resolved.y, 2),
         anchorX: resolved.anchorX,
         anchorY: resolved.anchorY
@@ -32013,6 +32016,7 @@ void main() {
         scale: String(document2.system?.properties.scale ?? layoutPreset),
         units: String(document2.system?.properties.units ?? "mixed"),
         preset: frame.preset ?? "custom",
+        "body.scaleMode": scaleModel.bodyScaleMode,
         ...camera?.azimuth !== null ? { "camera.azimuth": String(camera?.azimuth) } : {},
         ...camera?.elevation !== null ? { "camera.elevation": String(camera?.elevation) } : {},
         ...camera?.roll !== null ? { "camera.roll": String(camera?.roll) } : {},
@@ -32183,10 +32187,11 @@ void main() {
     }
     return parts.join(" - ");
   }
-  function resolveScaleModel(layoutPreset, overrides) {
+  function resolveScaleModel(layoutPreset, overrides, bodyScaleMode) {
     const defaults = defaultScaleModel(layoutPreset);
     return {
       ...defaults,
+      ...bodyScaleMode ? { bodyScaleMode } : {},
       ...overrides
     };
   }
@@ -32200,7 +32205,8 @@ void main() {
           freePlacementMultiplier: 0.9,
           ringThicknessMultiplier: 0.92,
           minBodyRadius: 4,
-          maxBodyRadius: 36
+          maxBodyRadius: 36,
+          bodyScaleMode: "readable"
         };
       case "presentation":
         return {
@@ -32210,7 +32216,8 @@ void main() {
           freePlacementMultiplier: 1.05,
           ringThicknessMultiplier: 1.16,
           minBodyRadius: 5,
-          maxBodyRadius: 48
+          maxBodyRadius: 48,
+          bodyScaleMode: "readable"
         };
       default:
         return {
@@ -32220,7 +32227,8 @@ void main() {
           freePlacementMultiplier: 1,
           ringThicknessMultiplier: 1,
           minBodyRadius: 4,
-          maxBodyRadius: 40
+          maxBodyRadius: 40,
+          bodyScaleMode: "readable"
         };
     }
   }
@@ -32234,6 +32242,48 @@ void main() {
         return 1;
     }
   }
+  function resolveSceneMetricScale(objects, width, height, padding, spacingFactor, scaleModel) {
+    const orbitMetrics = [];
+    const bodyMetrics = [];
+    for (const object of objects) {
+      const radiusMetric = objectRadiusMetric(object);
+      if (radiusMetric !== null && radiusMetric > 0) {
+        bodyMetrics.push(radiusMetric);
+      }
+      const placement = object.placement;
+      if (!placement) {
+        continue;
+      }
+      if (placement.mode === "orbit") {
+        const orbitMetricValue = toDistanceMetric(placement.semiMajor ?? placement.distance ?? null);
+        if (orbitMetricValue !== null && orbitMetricValue > 0) {
+          orbitMetrics.push(orbitMetricValue);
+        }
+        continue;
+      }
+      if (placement.mode === "free") {
+        const freeMetric = toDistanceMetric(placement.distance ?? null);
+        if (freeMetric !== null && freeMetric > 0) {
+          orbitMetrics.push(freeMetric);
+        }
+      }
+    }
+    const maxDistanceMetric = Math.max(...orbitMetrics, 0);
+    const maxBodyMetric = Math.max(...bodyMetrics, 0);
+    const baseMetric = Math.max(maxDistanceMetric, maxBodyMetric * 6, 0);
+    const referenceMetric = baseMetric + Math.max(Math.sqrt(baseMetric), maxBodyMetric * 2, maxDistanceMetric > 0 ? 0.25 : 0);
+    if (referenceMetric <= 0) {
+      return {
+        pixelsPerMetric: null,
+        hasExplicitScale: false
+      };
+    }
+    const availableRadius = Math.max(Math.min(width, height) / 2 - padding - 24, 120) * spacingFactor * scaleModel.orbitDistanceMultiplier;
+    return {
+      pixelsPerMetric: availableRadius / referenceMetric,
+      hasExplicitScale: true
+    };
+  }
   function createSceneObject(position, scaleModel, relationships) {
     const { object, x, y, radius, sortKey, anchorX, anchorY } = position;
     const renderPriority = object.renderHints?.renderPriority ?? 0;
@@ -32958,7 +33008,7 @@ void main() {
       object,
       x,
       y,
-      radius: visualRadiusFor(object, depth, context.scaleModel),
+      radius: visualRadiusFor(object, depth, context.scaleModel, context.sceneMetricScale),
       sortKey: computeSortKey(x, y, depth)
     });
     placeOrbitingChildren(object, positions, orbitDrafts, leaderDrafts, context, depth + 1);
@@ -32969,7 +33019,7 @@ void main() {
       return;
     }
     const orbiting = [...context.orbitChildren.get(object.id) ?? []].sort(compareOrbiting);
-    const orbitMetricContext = computeOrbitMetricContext(orbiting, parent.radius, context.spacingFactor, context.scaleModel);
+    const orbitMetricContext = computeOrbitMetricContext(orbiting, parent.radius, context.spacingFactor, context.scaleModel, context.sceneMetricScale);
     const orbitRadiiPx = resolveOrbitRadiiPx(orbiting, orbitMetricContext);
     orbiting.forEach((child, index) => {
       const orbitGeometry = resolveOrbitGeometry(child, index, orbiting.length, parent, orbitMetricContext, orbitRadiiPx[index] ?? orbitMetricContext.innerPx, context);
@@ -33004,7 +33054,7 @@ void main() {
         object: child,
         x,
         y,
-        radius: visualRadiusFor(child, depth + 1, context.scaleModel),
+        radius: visualRadiusFor(child, depth + 1, context.scaleModel, context.sceneMetricScale),
         sortKey: computeSortKey(x, y, depth + 1),
         anchorX,
         anchorY
@@ -33033,10 +33083,11 @@ void main() {
       return 1;
     return left.id.localeCompare(right.id);
   }
-  function computeOrbitMetricContext(objects, parentRadius, spacingFactor, scaleModel) {
+  function computeOrbitMetricContext(objects, parentRadius, spacingFactor, scaleModel, sceneMetricScale) {
     const metrics = objects.map((object) => orbitMetric(object));
     const presentMetrics = metrics.filter((value) => value !== null);
-    const innerPx = parentRadius + 56 * spacingFactor * scaleModel.orbitDistanceMultiplier;
+    const minimumGapPx = scaleModel.bodyScaleMode === "strict" ? Math.max(2, 8 * spacingFactor * scaleModel.orbitDistanceMultiplier) : (objects.length > 2 ? 54 : 64) * spacingFactor * scaleModel.orbitDistanceMultiplier * 0.42;
+    const innerPx = parentRadius + Math.max(minimumGapPx * 1.2, 24 * spacingFactor);
     const stepPx = (objects.length > 2 ? 54 : 64) * spacingFactor * scaleModel.orbitDistanceMultiplier;
     if (presentMetrics.length === 0) {
       return {
@@ -33047,7 +33098,8 @@ void main() {
         innerPx,
         stepPx,
         pixelSpread: Math.max(stepPx * Math.max(objects.length - 1, 1), stepPx),
-        minimumGapPx: stepPx * 0.42
+        minimumGapPx,
+        pixelsPerMetric: sceneMetricScale.pixelsPerMetric
       };
     }
     const minMetric = Math.min(...presentMetrics);
@@ -33061,7 +33113,8 @@ void main() {
       innerPx,
       stepPx,
       pixelSpread: Math.max(stepPx * Math.max(objects.length - 1, 1), stepPx),
-      minimumGapPx: stepPx * 0.42
+      minimumGapPx,
+      pixelsPerMetric: sceneMetricScale.pixelsPerMetric
     };
   }
   function resolveOrbitGeometry(object, index, count, parent, metricContext, orbitRadiusPx, context) {
@@ -33113,6 +33166,9 @@ void main() {
     };
   }
   function resolveOrbitRadiusPx(metric, metricContext) {
+    if (metricContext.pixelsPerMetric !== null) {
+      return metric * metricContext.pixelsPerMetric;
+    }
     return metricContext.innerPx + metricContext.stepPx * log2(Math.max(metric, 0) + 1);
   }
   function resolveOrbitRadiiPx(objects, metricContext) {
@@ -33147,6 +33203,10 @@ void main() {
     const outerMetric = toDistanceMetric(toUnitValue(object.properties.outer));
     if (innerMetric !== null && outerMetric !== null) {
       const thicknessMetric = Math.abs(outerMetric - innerMetric);
+      if (metricContext.pixelsPerMetric !== null) {
+        const thicknessPx = thicknessMetric * metricContext.pixelsPerMetric;
+        return scaleModel.bodyScaleMode === "strict" ? Math.max(thicknessPx * scaleModel.ringThicknessMultiplier, 1) : clampNumber(Math.max(thicknessPx * scaleModel.ringThicknessMultiplier, 8), 8, 54);
+      }
       if (metricContext.metricSpread > 0) {
         return clampNumber(thicknessMetric / metricContext.metricSpread * metricContext.pixelSpread * scaleModel.ringThicknessMultiplier, 8, 54);
       }
@@ -33426,8 +33486,8 @@ void main() {
     }
     return positions.get(object.placement.target);
   }
-  function visualRadiusFor(object, depth, scaleModel) {
-    const explicitRadius = toVisualSizeMetric(object.properties.radius, scaleModel);
+  function visualRadiusFor(object, depth, scaleModel, sceneMetricScale) {
+    const explicitRadius = toVisualSizeMetric(object.properties.radius, scaleModel, sceneMetricScale);
     if (explicitRadius !== null) {
       return explicitRadius;
     }
@@ -33492,18 +33552,27 @@ void main() {
         return value.value;
     }
   }
-  function freePlacementOffsetPx(distance, scaleModel) {
+  function freePlacementOffsetPx(distance, scaleModel, sceneMetricScale) {
     const metric = toDistanceMetric(distance ?? null);
     if (metric === null || metric <= 0) {
       return 0;
     }
+    if (sceneMetricScale.pixelsPerMetric !== null) {
+      const scaled = metric * sceneMetricScale.pixelsPerMetric * scaleModel.freePlacementMultiplier;
+      return scaleModel.bodyScaleMode === "strict" ? Math.max(scaled, 0) : clampNumber(scaled, 0, 420);
+    }
     return clampNumber(metric * 96 * scaleModel.freePlacementMultiplier, 0, 420);
   }
-  function toVisualSizeMetric(value, scaleModel) {
+  function toVisualSizeMetric(value, scaleModel, sceneMetricScale) {
     const unitValue = toUnitValue(value);
     if (!unitValue) {
       return null;
     }
+    const physicalMetric = toDistanceMetric(unitValue);
+    if (sceneMetricScale.pixelsPerMetric !== null && physicalMetric !== null && physicalMetric > 0) {
+      const scaled = physicalMetric * sceneMetricScale.pixelsPerMetric * scaleModel.bodyRadiusMultiplier;
+      return scaleModel.bodyScaleMode === "strict" ? Math.max(scaled, 0.1) : clampNumber(Math.max(scaled, scaleModel.minBodyRadius), scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
+    }
     let size;
     switch (unitValue.unit) {
       case "sol":
@@ -33521,6 +33590,9 @@ void main() {
     }
     return clampNumber(size * scaleModel.bodyRadiusMultiplier, scaleModel.minBodyRadius, scaleModel.maxBodyRadius);
   }
+  function objectRadiusMetric(object) {
+    return toDistanceMetric(toUnitValue(object.properties.radius));
+  }
   function toUnitValue(value) {
     if (!value || typeof value !== "object" || !("value" in value)) {
       return null;
@@ -33629,6 +33701,7 @@ void main() {
       projection: options.projection,
       camera: options.camera,
       scaleModel: options.scaleModel,
+      bodyScaleMode: options.bodyScaleMode,
       activeEventId: options.activeEventId
     };
     const scene = renderDocumentToScene(document2, renderOptions);
@@ -38040,6 +38113,7 @@ void main() {
         camera: renderOptions.camera ? { ...renderOptions.camera } : null,
         layers: renderOptions.layers ? { ...renderOptions.layers } : void 0,
         scaleModel: renderOptions.scaleModel ? { ...renderOptions.scaleModel } : void 0,
+        bodyScaleMode: renderOptions.bodyScaleMode,
         activeEventId: renderOptions.activeEventId ?? null,
         viewMode: renderOptions.viewMode ?? "2d"
       },
@@ -38068,6 +38142,7 @@ void main() {
         camera: raw.renderOptions?.camera ? { ...raw.renderOptions.camera } : null,
         layers: raw.renderOptions?.layers ? { ...raw.renderOptions.layers } : void 0,
         scaleModel: raw.renderOptions?.scaleModel ? { ...raw.renderOptions.scaleModel } : void 0,
+        bodyScaleMode: raw.renderOptions?.bodyScaleMode,
         activeEventId: raw.activeEventId ?? raw.renderOptions?.activeEventId ?? null,
         viewMode: raw.renderOptions?.viewMode ?? "2d"
       },
@@ -38087,6 +38162,7 @@ void main() {
           camera: atlasState.renderOptions.camera ? { ...atlasState.renderOptions.camera } : null,
           layers: atlasState.renderOptions.layers ? { ...atlasState.renderOptions.layers } : void 0,
           scaleModel: atlasState.renderOptions.scaleModel ? { ...atlasState.renderOptions.scaleModel } : void 0,
+          bodyScaleMode: atlasState.renderOptions.bodyScaleMode,
           activeEventId: atlasState.renderOptions.activeEventId ?? null,
           viewMode: atlasState.renderOptions.viewMode ?? "2d"
         },
@@ -39922,6 +39998,7 @@ void main() {
       padding: options.padding,
       preset: options.preset,
       projection: options.projection,
+      bodyScaleMode: options.bodyScaleMode,
       viewMode: options.viewMode ?? "2d",
       quality: options.quality ?? "balanced",
       style3d: options.style3d ?? "symbolic",
@@ -41346,7 +41423,7 @@ void main() {
     };
   }
   function hasSceneAffectingRenderOptions(options) {
-    return options.width !== void 0 || options.height !== void 0 || options.padding !== void 0 || options.preset !== void 0 || options.projection !== void 0 || options.camera !== void 0 || options.scaleModel !== void 0 || options.activeEventId !== void 0;
+    return options.width !== void 0 || options.height !== void 0 || options.padding !== void 0 || options.preset !== void 0 || options.projection !== void 0 || options.camera !== void 0 || options.scaleModel !== void 0 || options.bodyScaleMode !== void 0 || options.activeEventId !== void 0;
   }
   function resolveSourceRenderOptions2(loaded, renderOptions) {
     const atlasDocument = loaded.atlasDocument ?? loaded.draftDocument;
@@ -42427,6 +42504,205 @@ void main() {
   function parseSource(source) {
     return loadWorldOrbitSource(source).document;
   }
+
+  // packages/viewer/dist/interactive-2d.js
+  var DEFAULT_VIEWER_LIMITS2 = {
+    minScale: 0.2,
+    maxScale: 8,
+    fitPadding: 48
+  };
+  function createInteractiveViewer2D(container, scene, options = {}) {
+    const constraints = {
+      minScale: options.minScale ?? DEFAULT_VIEWER_LIMITS2.minScale,
+      maxScale: options.maxScale ?? DEFAULT_VIEWER_LIMITS2.maxScale,
+      fitPadding: options.fitPadding ?? DEFAULT_VIEWER_LIMITS2.fitPadding
+    };
+    const behavior = {
+      pointer: options.pointer ?? true,
+      touch: options.touch ?? true,
+      selection: options.selection ?? true
+    };
+    let renderOptions = {
+      width: options.width,
+      height: options.height,
+      padding: options.padding,
+      preset: options.preset,
+      theme: options.theme,
+      layers: options.layers,
+      subtitle: options.subtitle,
+      pointer: behavior.pointer,
+      touch: behavior.touch,
+      selection: behavior.selection,
+      minScale: constraints.minScale,
+      maxScale: constraints.maxScale,
+      fitPadding: constraints.fitPadding
+    };
+    let state = fitViewerState(scene, DEFAULT_VIEWER_STATE, constraints);
+    let svgElement = null;
+    let cameraRoot = null;
+    let destroyed = false;
+    let activePointerId = null;
+    let lastPointerClientPoint = null;
+    let dragDistance = 0;
+    const previousTabIndex = container.getAttribute("tabindex");
+    const previousTouchAction = container.style.touchAction;
+    if (previousTabIndex === null) {
+      container.tabIndex = 0;
+    }
+    container.classList.add("wo-viewer-container");
+    container.style.touchAction = behavior.touch ? "none" : previousTouchAction;
+    const handleWheel = (event) => {
+      if (!behavior.pointer || destroyed || !svgElement) {
+        return;
+      }
+      event.preventDefault();
+      container.focus();
+      const anchor = getScenePointFromClient(event.clientX, event.clientY);
+      const factor = clamp2(Math.exp(-event.deltaY * 2e-3), 0.6, 1.6);
+      updateState(zoomViewerStateAt(scene, state, factor, anchor, constraints));
+    };
+    const handlePointerDown = (event) => {
+      if (destroyed) {
+        return;
+      }
+      const isTouch = event.pointerType === "touch";
+      if (isTouch && !behavior.touch || !isTouch && !behavior.pointer) {
+        return;
+      }
+      if (!isTouch && event.button !== 0) {
+        return;
+      }
+      activePointerId = event.pointerId;
+      lastPointerClientPoint = { x: event.clientX, y: event.clientY };
+      dragDistance = 0;
+      container.setPointerCapture?.(event.pointerId);
+      container.focus();
+    };
+    const handlePointerMove = (event) => {
+      if (destroyed || activePointerId !== event.pointerId || !lastPointerClientPoint) {
+        return;
+      }
+      const rect = svgElement?.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) {
+        return;
+      }
+      const dx = event.clientX - lastPointerClientPoint.x;
+      const dy = event.clientY - lastPointerClientPoint.y;
+      lastPointerClientPoint = { x: event.clientX, y: event.clientY };
+      dragDistance += Math.hypot(dx, dy);
+      updateState(panViewerState(state, dx * (scene.width / rect.width), dy * (scene.height / rect.height)));
+    };
+    const stopPointer = (event) => {
+      if (activePointerId !== event.pointerId) {
+        return;
+      }
+      activePointerId = null;
+      lastPointerClientPoint = null;
+      container.releasePointerCapture?.(event.pointerId);
+    };
+    const handleClick = (event) => {
+      if (destroyed || !behavior.selection || dragDistance > 6) {
+        return;
+      }
+      const objectEl = event.target?.closest(".wo-object[data-object-id]");
+      if (!objectEl) {
+        return;
+      }
+      updateState({
+        ...state,
+        selectedObjectId: objectEl.dataset.objectId ?? null
+      });
+      renderSvg();
+    };
+    container.addEventListener("wheel", handleWheel, { passive: false });
+    container.addEventListener("pointerdown", handlePointerDown);
+    container.addEventListener("pointermove", handlePointerMove);
+    container.addEventListener("pointerup", stopPointer);
+    container.addEventListener("pointercancel", stopPointer);
+    container.addEventListener("click", handleClick);
+    renderSvg();
+    return {
+      getState() {
+        return { ...state };
+      },
+      setState(nextState) {
+        updateState({
+          ...state,
+          ...nextState
+        });
+        if ("selectedObjectId" in nextState) {
+          renderSvg();
+        }
+      },
+      setRenderOptions(nextOptions) {
+        renderOptions = {
+          ...renderOptions,
+          ...nextOptions
+        };
+        renderSvg();
+      },
+      fitToSystem() {
+        updateState(fitViewerState(scene, state, constraints));
+      },
+      destroy() {
+        if (destroyed) {
+          return;
+        }
+        destroyed = true;
+        container.removeEventListener("wheel", handleWheel);
+        container.removeEventListener("pointerdown", handlePointerDown);
+        container.removeEventListener("pointermove", handlePointerMove);
+        container.removeEventListener("pointerup", stopPointer);
+        container.removeEventListener("pointercancel", stopPointer);
+        container.removeEventListener("click", handleClick);
+        if (previousTabIndex === null) {
+          container.removeAttribute("tabindex");
+        }
+        container.style.touchAction = previousTouchAction;
+        container.replaceChildren();
+        svgElement = null;
+        cameraRoot = null;
+      }
+    };
+    function renderSvg() {
+      if (destroyed) {
+        return;
+      }
+      container.innerHTML = renderSceneToSvg(scene, {
+        width: renderOptions.width,
+        height: renderOptions.height,
+        padding: renderOptions.padding,
+        preset: renderOptions.preset,
+        theme: renderOptions.theme,
+        layers: renderOptions.layers,
+        subtitle: renderOptions.subtitle,
+        selectedObjectId: state.selectedObjectId
+      });
+      svgElement = container.querySelector("svg");
+      cameraRoot = container.querySelector(`[data-worldorbit-camera-root="${WORLD_LAYER_ID}"]`);
+      applyTransform();
+    }
+    function applyTransform() {
+      cameraRoot?.setAttribute("transform", composeViewerTransform(scene, state));
+    }
+    function updateState(nextState) {
+      state = nextState;
+      applyTransform();
+    }
+    function getScenePointFromClient(clientX, clientY) {
+      const rect = svgElement?.getBoundingClientRect();
+      if (!rect || rect.width <= 0 || rect.height <= 0) {
+        return { x: scene.width / 2, y: scene.height / 2 };
+      }
+      return {
+        x: (clientX - rect.left) / rect.width * scene.width,
+        y: (clientY - rect.top) / rect.height * scene.height
+      };
+    }
+  }
+  function clamp2(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+  }
   return __toCommonJS(worldorbit_esm_exports);
 })();
 /**