@vertexvis/viewer 0.18.2-testing.0 → 0.18.2-testing.1

package/dist/components/scene.js

@@ -1,1508 +0,0 @@
-/*!
- * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
- */
-import { c as color, u as uri, a as async, b as uuid } from './browser.esm.js';
-import { I as InvalidResourceUrnError, a as InvalidCameraError, b as InvalidArgumentError } from './errors.js';
-import { v as vector3, b as boundingBox, a as boundingSphere, m as matrix4, q as quaternion, r as ray, p as point, d as dimensions } from './bundle.esm.js';
-import { v as vertexvis, t as toProtobuf, e as FramePerspectiveCamera, g as constrainViewVector, d as FrameOrthographicCamera, w as withPositionAndViewVector, h as fromBoundingBoxAndLookAtCamera } from './streamAttributes.js';
-import { t as toProtoDuration } from './bundle.esm2.js';
-
-const defaultColor = {
-  opacity: 255,
-  glossiness: 4,
-  diffuse: {
-    r: 0,
-    g: 0,
-    b: 0,
-    a: 0,
-  },
-  ambient: {
-    r: 0,
-    g: 0,
-    b: 0,
-    a: 0,
-  },
-  specular: {
-    r: 0,
-    g: 0,
-    b: 0,
-    a: 0,
-  },
-  emissive: {
-    r: 0,
-    g: 0,
-    b: 0,
-    a: 0,
-  },
-};
-/**
- * This helper creats an rgb value color
- * @param hex
- * @param opacity
- */
-const create = (r, g, b, opacity) => {
-  return Object.assign(Object.assign({}, defaultColor), { opacity: opacity !== null && opacity !== void 0 ? opacity : defaultColor.opacity, diffuse: {
-      r,
-      g,
-      b,
-      a: 0,
-    } });
-};
-/**
- * This helper converts a hex string to a ColorMaterial object
- * @param hex
- * @param opacity
- */
-const fromHex = (hex, opacity) => {
-  const color$1 = color.fromHexString(hex);
-  return Object.assign(Object.assign({}, defaultColor), { opacity: opacity !== null && opacity !== void 0 ? opacity : defaultColor.opacity, diffuse: color$1 != null ? Object.assign({}, color$1) : Object.assign({}, defaultColor.diffuse) });
-};
-
-const colorMaterial = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  defaultColor: defaultColor,
-  create: create,
-  fromHex: fromHex
-});
-
-function fromUrn(urn) {
-  var _a;
-  const uri$1 = uri.parse(urn);
-  if (uri$1.scheme !== 'urn' || uri$1.path == null) {
-    throw new Error('Invalid URN. Expected URN scheme.');
-  }
-  const [nid, resourceType, resourceId, ...subResourcePath] = uri$1.path.split(/[:/]/);
-  if (nid !== 'vertexvis' && nid !== 'vertex') {
-    throw new Error('Invalid URN. Expected URN to be vertex namespace');
-  }
-  if (nid === 'vertexvis') {
-    console.warn("vertexvis namespace is deprecated. Use 'vertex' for the namespace urn instead");
-  }
-  switch (resourceType) {
-    case 'stream-key':
-      const queries = fromQuery(uri$1.query);
-      const subResource = (_a = fromSubResourcePath(subResourcePath.join('/'))) !== null && _a !== void 0 ? _a : queries.find((q) => q.type === 'scene-view-state');
-      return {
-        resource: { type: 'stream-key', id: resourceId },
-        subResource,
-        queries: queries.filter((q) => q.type !== 'scene-view-state'),
-      };
-    default:
-      throw new InvalidResourceUrnError(`Invalid URN. Unknown resource type ${resourceType}`);
-  }
-}
-function fromSubResourcePath(path) {
-  if (path != null) {
-    const [subResourceType, subResourceId] = path.split('/');
-    switch (subResourceType) {
-      case 'scene-view-states':
-        return {
-          type: 'scene-view-state',
-          id: subResourceId,
-        };
-      default:
-        return undefined;
-    }
-  }
-}
-function fromQuery(query) {
-  if (query != null) {
-    return query.split('&').map((queryFragment) => {
-      const [resourceType, resourceId] = queryFragment.split('=');
-      switch (resourceType) {
-        case 'supplied-id':
-          return { type: 'supplied-id', id: resourceId };
-        case 'scene-view-state':
-          return { type: 'scene-view-state', id: resourceId };
-        default:
-          throw new Error('Invalid URN. Unknown query value type');
-      }
-    });
-  }
-  else {
-    return [];
-  }
-}
-
-const loadableResource = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  fromUrn: fromUrn
-});
-
-function isSceneViewStateId(identifier) {
-  return identifier.id != null;
-}
-function isSceneViewStateSuppliedId(identifier) {
-  return identifier.suppliedId != null;
-}
-
-/**
- * A `SynchronizedClock` allows for approximating the time on a remote machine.
- *
- * During initialization, a known time of the remote host must be supplied. Once
- * the remote time is known, this class can approximate the time on the remote
- * machine from a date or duration.
- *
- * @example
- * ```
- * const knownRemoteTime = await getRemoteTime();
- * const clock = new SynchronizedClock(knownRemoteTime);
- *
- * const localDate = new Date();
- * const serverTime = clock.remoteTime(localDate);
- *
- * const remoteDate = await getRemoteTime();
- * const localTime = clock.localTime(remoteDate);
- *
- * const currentRemoteTime = clock.remoteNow();
- * ```
- */
-class SynchronizedClock {
-  constructor(knownRemoteTime, knownLocalTime = new Date()) {
-    this.knownRemoteTime = knownRemoteTime;
-    this.knownLocalTime = knownLocalTime;
-  }
-  /**
-   * Computes an offset duration from when this clock was instantiated.
-   */
-  localOffset() {
-    return this.duration(this.knownLocalTime, this.localNow());
-  }
-  /**
-   * Approximates the local time from a remote timestamp or duration.
-   *
-   * @param remoteTimeOrDurationInMs A remote timestamp or duration.
-   */
-  localTime(remoteTimeOrDurationInMs) {
-    const remoteTime = typeof remoteTimeOrDurationInMs === 'number'
-      ? new Date(this.knownLocalTime.getTime() + remoteTimeOrDurationInMs)
-      : remoteTimeOrDurationInMs;
-    const duration = this.duration(this.knownRemoteTime, remoteTime);
-    return this.addDuration(this.knownLocalTime, duration);
-  }
-  /**
-   * Approximates an offset duration on the remote machine.
-   *
-   * @param localTime A local timestamp. Defaults to the current local time.
-   */
-  remoteOffset(localTime = new Date()) {
-    return this.duration(this.remoteTime(this.knownLocalTime), this.remoteTime(localTime));
-  }
-  /**
-   * Approximates the current time on the remote machine.
-   */
-  remoteNow() {
-    return this.remoteTime(this.localNow());
-  }
-  /**
-   * Approximates the remote time from either a local timestamp or duration.
-   *
-   * @param localTimeOrDurationInMs A local timestamp or duration.
-   */
-  remoteTime(localTimeOrDurationInMs) {
-    const localTime = typeof localTimeOrDurationInMs === 'number'
-      ? new Date(this.knownLocalTime.getTime() + localTimeOrDurationInMs)
-      : localTimeOrDurationInMs;
-    const duration = this.duration(this.knownLocalTime, localTime);
-    return this.addDuration(this.knownRemoteTime, duration);
-  }
-  addDuration(start, duration) {
-    return new Date(start.getTime() + duration);
-  }
-  duration(start, end) {
-    return end.getTime() - start.getTime();
-  }
-  localNow() {
-    return new Date(Date.now());
-  }
-}
-
-const DEFAULT_TIMEOUT_IN_MS = 1000 * 10;
-class StreamApiEventDispatcher {
-  constructor(stream, predicate, transform, timeout = DEFAULT_TIMEOUT_IN_MS) {
-    this.stream = stream;
-    this.predicate = predicate;
-    this.transform = transform;
-    this.timeout = timeout;
-    this.listeners = [];
-    this.handleMessage = this.handleMessage.bind(this);
-  }
-  on(listener) {
-    this.listeners = [...this.listeners, listener];
-    if (this.eventDisposable == null || this.requestDisposable == null) {
-      this.addListeners();
-    }
-  }
-  off(listener) {
-    this.listeners = this.listeners.filter((l) => l !== listener);
-    if (this.listeners.length === 0) {
-      this.removeListeners();
-    }
-  }
-  once() {
-    let handler;
-    return async.timeout(this.timeout, new Promise((resolve) => {
-      handler = (data) => {
-        resolve(data);
-        this.off(handler);
-      };
-      this.on(handler);
-    })).finally(() => {
-      this.off(handler);
-    });
-  }
-  handleMessage(msg) {
-    if (this.predicate(msg)) {
-      const transformed = this.transform(msg);
-      if (transformed != null) {
-        this.listeners.forEach((l) => l(transformed));
-      }
-    }
-  }
-  addListeners() {
-    this.eventDisposable = this.stream.onEvent(this.handleMessage);
-    this.requestDisposable = this.stream.onRequest(this.handleMessage);
-  }
-  removeListeners() {
-    var _a, _b;
-    (_a = this.eventDisposable) === null || _a === void 0 ? void 0 : _a.dispose();
-    (_b = this.requestDisposable) === null || _b === void 0 ? void 0 : _b.dispose();
-  }
-}
-
-class CameraRenderResult {
-  constructor(stream, decodeFrame, { animationId, correlationId }, timeout) {
-    this.data = undefined;
-    this.onAnimationCompleted = new StreamApiEventDispatcher(stream, (msg) => { var _a, _b, _c; return ((_c = (_b = (_a = msg.event) === null || _a === void 0 ? void 0 : _a.animationCompleted) === null || _b === void 0 ? void 0 : _b.animationId) === null || _c === void 0 ? void 0 : _c.hex) === animationId; }, (msg) => { var _a, _b, _c; return ((_c = (_b = (_a = msg.event) === null || _a === void 0 ? void 0 : _a.animationCompleted) === null || _b === void 0 ? void 0 : _b.animationId) === null || _c === void 0 ? void 0 : _c.hex) || undefined; }, timeout);
-    this.onFrameReceived = new StreamApiEventDispatcher(stream, (msg) => {
-      var _a, _b, _c;
-      return !!((_c = (_b = (_a = msg.request) === null || _a === void 0 ? void 0 : _a.drawFrame) === null || _b === void 0 ? void 0 : _b.frameCorrelationIds) === null || _c === void 0 ? void 0 : _c.some((id) => id === correlationId));
-    }, (msg) => {
-      var _a;
-      return ((_a = msg.request) === null || _a === void 0 ? void 0 : _a.drawFrame) != null
-        ? decodeFrame(msg.request.drawFrame)
-        : undefined;
-    }, timeout);
-  }
-}
-
-function buildSceneViewStateIdentifier(identifier) {
-  if (typeof identifier === 'string') {
-    return { sceneViewStateId: { hex: identifier } };
-  }
-  else if (isSceneViewStateId(identifier)) {
-    return { sceneViewStateId: { hex: identifier.id } };
-  }
-  else if (isSceneViewStateSuppliedId(identifier)) {
-    return { sceneViewStateSuppliedId: { value: identifier.suppliedId } };
-  }
-  else {
-    throw new Error('Unable to build scene view state identifier, input must be a string or `SceneViewStateIdentifier`.');
-  }
-}
-function buildQueryExpression(query, context) {
-  switch (query.type) {
-    case 'and':
-    case 'or':
-      return {
-        operand: {
-          itemCollection: {
-            queries: query.expressions.map((exp) => ({
-              sceneItemQuery: buildSceneItemQuery(exp),
-            })),
-          },
-        },
-      };
-    case 'not':
-      return {
-        not: {
-          expression: buildQueryExpression(query.query, context),
-        },
-      };
-    case 'item-id':
-    case 'supplied-id':
-      return {
-        operand: {
-          item: {
-            sceneItemQuery: buildSceneItemQuery(query),
-          },
-        },
-      };
-    case 'all':
-      return {
-        operand: {
-          root: {},
-        },
-      };
-    case 'scene-tree-range':
-      return {
-        operand: {
-          sceneTreeRange: {
-            start: query.range.start,
-            end: query.range.end,
-          },
-        },
-      };
-    case 'metadata':
-      return {
-        operand: {
-          metadata: {
-            valueFilter: query.filter,
-            keys: query.keys,
-            exactMatch: query.exactMatch,
-          },
-        },
-      };
-    case 'all-selected':
-      return {
-        operand: {
-          override: {
-            selection: {},
-          },
-        },
-      };
-    case 'point':
-      return {
-        operand: {
-          point: {
-            point: query.point,
-            viewport: context.dimensions,
-          },
-        },
-      };
-    case 'volume-intersection':
-      return {
-        operand: {
-          volume: {
-            frustumByRectangle: {
-              rectangle: query.rectangle,
-            },
-            exclusive: query.exclusive,
-            viewport: context.dimensions,
-          },
-        },
-      };
-    default:
-      return {};
-  }
-}
-function buildSceneOperation(query, operations, context) {
-  const operationTypes = buildOperationTypes(operations);
-  const queryExpression = buildQueryExpression(query, context);
-  return {
-    queryExpression,
-    operationTypes,
-  };
-}
-function buildSceneItemQuery(item) {
-  switch (item.type) {
-    case 'item-id':
-      return {
-        id: new vertexvis.protobuf.core.Uuid({
-          hex: item.value,
-        }),
-      };
-    case 'supplied-id':
-      return {
-        suppliedId: item.value,
-      };
-    default:
-      return {};
-  }
-}
-function buildFlyToOperation(frameCorrelationId, options, animation) {
-  const payload = {
-    frameCorrelationId: {
-      value: frameCorrelationId,
-    },
-    animation: animation
-      ? {
-        duration: toProtoDuration(animation.milliseconds),
-      }
-      : undefined,
-  };
-  switch (options.flyTo.type) {
-    case 'supplied': {
-      return Object.assign(Object.assign({}, payload), { itemSuppliedId: options.flyTo.data });
-    }
-    case 'internal': {
-      return Object.assign(Object.assign({}, payload), { itemId: new vertexvis.protobuf.core.Uuid({
-          hex: options.flyTo.data,
-        }) });
-    }
-    case 'camera': {
-      return Object.assign(Object.assign({}, payload), { camera: toProtobuf(options.flyTo.data) });
-    }
-    case 'bounding-box': {
-      return Object.assign(Object.assign({}, payload), { boundingBox: {
-          xmin: options.flyTo.data.min.x,
-          xmax: options.flyTo.data.max.x,
-          ymin: options.flyTo.data.min.y,
-          ymax: options.flyTo.data.max.y,
-          zmin: options.flyTo.data.min.z,
-          zmax: options.flyTo.data.max.z,
-        } });
-    }
-    default:
-      return {};
-  }
-}
-function buildOperationTypes(operations) {
-  return operations.map((op) => {
-    var _a, _b;
-    switch (op.type) {
-      case 'change-material':
-        return {
-          changeMaterial: {
-            material: {
-              d: op.material.opacity,
-              ns: op.material.glossiness,
-              ka: op.material.ambient,
-              kd: op.material.diffuse,
-              ks: op.material.specular,
-              ke: op.material.emissive,
-            },
-          },
-        };
-      case 'clear-override':
-        return {
-          changeMaterial: {},
-        };
-      case 'change-transform':
-        return {
-          changeTransform: {
-            transform: Object.assign({}, op.transform),
-          },
-        };
-      case 'clear-transform':
-        return {
-          clearTransform: {
-            cascade: op.cascade,
-          },
-        };
-      case 'hide':
-        return {
-          changeVisibility: {
-            visible: false,
-          },
-        };
-      case 'show':
-        return {
-          changeVisibility: {
-            visible: true,
-          },
-        };
-      case 'select':
-        return {
-          changeSelection: { selected: true },
-        };
-      case 'deselect':
-        return {
-          changeSelection: { selected: false },
-        };
-      case 'change-phantom':
-        return {
-          changePhantom: { phantom: (_a = op.phantomState) !== null && _a !== void 0 ? _a : true },
-        };
-      case 'clear-phantom':
-        return {
-          changePhantom: { phantom: false },
-        };
-      case 'change-end-item':
-        return {
-          changeEndItem: { endItem: (_b = op.endItemState) !== null && _b !== void 0 ? _b : true },
-        };
-      case 'clear-end-item':
-        return {
-          changeEndItem: { endItem: false },
-        };
-      default:
-        return {};
-    }
-  });
-}
-function toPbSceneViewStateFeatures(features) {
-  return features.map((feature) => {
-    switch (feature) {
-      case 'camera':
-        return vertexvis.protobuf.stream.SceneViewStateFeature
-          .SCENE_VIEW_STATE_FEATURE_CAMERA;
-      case 'material_overrides':
-        return vertexvis.protobuf.stream.SceneViewStateFeature
-          .SCENE_VIEW_STATE_FEATURE_MATERIAL_OVERRIDE;
-      case 'selection':
-        return vertexvis.protobuf.stream.SceneViewStateFeature
-          .SCENE_VIEW_STATE_FEATURE_SELECTION;
-      case 'visibility':
-        return vertexvis.protobuf.stream.SceneViewStateFeature
-          .SCENE_VIEW_STATE_FEATURE_VISIBILITY;
-      case 'transforms':
-        return vertexvis.protobuf.stream.SceneViewStateFeature
-          .SCENE_VIEW_STATE_FEATURE_TRANSFORM;
-      case 'cross_section':
-        return vertexvis.protobuf.stream.SceneViewStateFeature
-          .SCENE_VIEW_STATE_FEATURE_CROSS_SECTION;
-      default:
-        return vertexvis.protobuf.stream.SceneViewStateFeature
-          .SCENE_VIEW_STATE_FEATURE_INVALID;
-    }
-  });
-}
-
-const PI_OVER_360 = 0.008726646259972;
-class TerminalFlyToExecutor {
-  constructor(flyToOptions) {
-    this.flyToOptions = flyToOptions;
-  }
-  build() {
-    return this.flyToOptions;
-  }
-}
-class FlyToExecutor {
-  withItemId(id) {
-    return new TerminalFlyToExecutor({
-      flyTo: {
-        type: 'internal',
-        data: id,
-      },
-    });
-  }
-  withSuppliedId(id) {
-    return new TerminalFlyToExecutor({
-      flyTo: {
-        type: 'supplied',
-        data: id,
-      },
-    });
-  }
-  withCamera(camera) {
-    return new TerminalFlyToExecutor({
-      flyTo: {
-        type: 'camera',
-        data: camera,
-      },
-    });
-  }
-  withBoundingBox(boundingBox) {
-    return new TerminalFlyToExecutor({
-      flyTo: {
-        type: 'bounding-box',
-        data: boundingBox,
-      },
-    });
-  }
-  build() {
-    return this.flyToOptions;
-  }
-}
-/**
- * The `Camera` class contains properties that reflect a world space position, a
- * view direction (lookAt), and normalized vector representing the up direction.
- *
- * It also provides utility methods to update orientation of the camera and
- * rerender the scene.
- *
- * This class in intended to treated as an immutable type. Any mutations return
- * a new instance of the class with the updated properties.
- */
-class Camera {
-  constructor(stream, aspect, data, boundingBox, decodeFrame, flyToOptions) {
-    this.stream = stream;
-    this.aspect = aspect;
-    this.data = data;
-    this.boundingBox = boundingBox;
-    this.decodeFrame = decodeFrame;
-    this.flyToOptions = flyToOptions;
-  }
-  fitCameraToBoundingBox(boundingBox$1, distance, viewVector) {
-    const vvec = vector3.scale(distance, vector3.normalize(viewVector));
-    const lookAt = boundingBox.center(boundingBox$1);
-    const position = vector3.subtract(lookAt, vvec);
-    return this.update({ lookAt, position, viewVector: vvec });
-  }
-  /**
-   * Returns the distance from the camera's position to the center
-   * of the provided bounding box (or the scene's visible bounding box if not provided).
-   *
-   * @param boundingBox - The bounding box to determine distance from.
-   */
-  signedDistanceToBoundingBoxCenter(boundingBox$1) {
-    const { position, viewVector } = withPositionAndViewVector(this.data);
-    const boundingBoxCenter = boundingBox.center(boundingBox$1 !== null && boundingBox$1 !== void 0 ? boundingBox$1 : this.boundingBox);
-    const cameraToCenter = vector3.subtract(boundingBoxCenter, position);
-    return (vector3.dot(viewVector, cameraToCenter) / vector3.magnitude(viewVector));
-  }
-  /**
-   * Specifies that the next render of the camera will be repositioned to one of
-   * the options specified in `options`.
-   *
-   * @param paramsOrQuery An object or query describing how the camera should
-   * be positioned.
-   */
-  flyTo(paramsOrQuery) {
-    if (typeof paramsOrQuery !== 'function') {
-      return this.updateFlyToOptions({
-        flyTo: this.buildFlyToType(paramsOrQuery),
-      });
-    }
-    else {
-      return this.updateFlyToOptions(paramsOrQuery(new FlyToExecutor()).build());
-    }
-  }
-  viewAll() {
-    return this.fitToBoundingBox(this.boundingBox);
-  }
-  /**
-   * Queues the rendering for a new frame using this camera. The returned
-   * promise will resolve when a frame is received that contains this camera.
-   */
-  async render(renderOptions) {
-    var _a, _b, _c;
-    if (this.flyToOptions == null && renderOptions != null) {
-      this.flyToOptions = {
-        flyTo: {
-          type: 'camera',
-          data: this.data,
-        },
-      };
-    }
-    try {
-      const corrId = uuid.create();
-      if (this.flyToOptions != null) {
-        const payload = buildFlyToOperation(corrId, this.flyToOptions, renderOptions === null || renderOptions === void 0 ? void 0 : renderOptions.animation);
-        const flyToResponse = await this.stream.flyTo(payload, true);
-        return new CameraRenderResult(this.stream, this.decodeFrame, {
-          correlationId: corrId,
-          animationId: ((_b = (_a = flyToResponse.flyTo) === null || _a === void 0 ? void 0 : _a.animationId) === null || _b === void 0 ? void 0 : _b.hex) || undefined,
-        }, ((_c = renderOptions === null || renderOptions === void 0 ? void 0 : renderOptions.animation) === null || _c === void 0 ? void 0 : _c.milliseconds) != null
-          ? renderOptions.animation.milliseconds + DEFAULT_TIMEOUT_IN_MS
-          : undefined);
-      }
-      else {
-        this.stream.replaceCamera({
-          camera: toProtobuf(this.data),
-          frameCorrelationId: { value: corrId },
-        });
-        return new CameraRenderResult(this.stream, this.decodeFrame, {
-          correlationId: corrId,
-        });
-      }
-    }
-    catch (e) {
-      console.warn('Error when performing render: ', e);
-      throw e;
-    }
-  }
-  /**
-   * Repositions the camera by rotating its current position around an axis.
-   *
-   * @param angleInRadians The angle, in radians, to rotate.
-   * @param axis A normalized vector to rotate around.
-   */
-  rotateAroundAxis(angleInRadians, axis) {
-    return this.rotateAroundAxisAtPoint(angleInRadians, this.data.lookAt, axis);
-  }
-  /**
-   * Aligns the camera to the plane defined by the provided position and normal.
-   * This will place the camera at the provided position, set the up vector to
-   * the provided normal, and place the lookAt on the defined plane. The point
-   * chosen for the lookAt will be determined using the current view vector.
-   *
-   * @param position The position to place the camera at.
-   * @param normal The normal of the plane to align to.
-   */
-  alignTo(position, normal) {
-    const worldX = vector3.normalize(vector3.cross(this.up, vector3.normalize(this.viewVector)));
-    const positiveWorldY = vector3.normalize(vector3.cross(vector3.normalize(this.viewVector), worldX));
-    // Invert the world y axis if the provided normal is more than 90 degrees from it
-    // to compute a proper angle to rotate the view vector by
-    const worldY = vector3.angleTo(normal, positiveWorldY) > Math.PI / 2
-      ? vector3.negate(positiveWorldY)
-      : positiveWorldY;
-    const localX = vector3.isEqual(worldY, normal)
-      ? worldX
-      : vector3.normalize(vector3.cross(worldY, normal));
-    const transformedViewVector = vector3.transformMatrix(this.viewVector, matrix4.makeRotation(quaternion.fromAxisAngle(localX, vector3.angleTo(normal, worldY))));
-    const lookAtRay = ray.create({
-      origin: position,
-      direction: vector3.normalize(transformedViewVector),
-    });
-    const lookAt = ray.at(lookAtRay, vector3.magnitude(this.viewVector));
-    return this.update({
-      position,
-      lookAt,
-      up: normal,
-    });
-  }
-  /**
-   * Updates the `position` and `up` vectors of the camera to the given standard
-   * view.
-   *
-   * @param standardView The standard view to apply.
-   * @returns A new camera.
-   */
-  standardView(standardView) {
-    return this.update({
-      position: standardView.position,
-      viewVector: vector3.subtract(vector3.origin(), standardView.position),
-      lookAt: vector3.origin(),
-      up: standardView.up,
-    });
-  }
-  buildFlyToType(options) {
-    if (options.boundingBox != null) {
-      return { type: 'bounding-box', data: options.boundingBox };
-    }
-    else if (options.camera != null) {
-      return { type: 'camera', data: options.camera };
-    }
-    else if (options.itemId != null) {
-      return { type: 'internal', data: options.itemId };
-    }
-    else if (options.itemSuppliedId != null) {
-      return { type: 'supplied', data: options.itemSuppliedId };
-    }
-    else {
-      throw new Error('Fly to must specify at least one option.');
-    }
-  }
-  computeClippingPlanes(camera) {
-    return fromBoundingBoxAndLookAtCamera(this.boundingBox, camera);
-  }
-}
-class PerspectiveCamera extends Camera {
-  constructor(stream, aspect, perspectiveData, boundingBox, decodeFrame, flyToOptions) {
-    super(stream, aspect, perspectiveData, boundingBox, decodeFrame, flyToOptions);
-    this.perspectiveData = perspectiveData;
-  }
-  /**
-   * Shifts the position of the camera by the given delta.
-   *
-   * @param delta The number of units to shift the camera on the X, Y, and Z
-   * axis.
-   */
-  moveBy(delta) {
-    return this.update({
-      position: vector3.add(this.position, delta),
-      lookAt: vector3.add(this.lookAt, delta),
-    });
-  }
-  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
-    return this.update({
-      position: vector3.rotateAboutAxis(angleInRadians, this.position, axis, point),
-      lookAt: vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point),
-      up: vector3.rotateAboutAxis(angleInRadians, this.up, axis, vector3.origin()),
-    });
-  }
-  fitToBoundingBox(boundingBox$1) {
-    var _a;
-    const radius = 1.1 *
-      vector3.magnitude(vector3.subtract(boundingBox$1.max, boundingBox.center(boundingBox$1)));
-    // ratio of the height of the frustum to the distance along the view vector
-    let hOverD = Math.tan(((_a = this.fovY) !== null && _a !== void 0 ? _a : 45) * PI_OVER_360);
-    if (this.aspect < 1.0) {
-      hOverD *= this.aspect;
-    }
-    const distance = Math.abs(radius / hOverD);
-    return super.fitCameraToBoundingBox(boundingBox$1, distance, this.viewVector);
-  }
-  update(camera) {
-    var _a;
-    const fovY = (_a = camera.fovY) !== null && _a !== void 0 ? _a : this.fovY;
-    return new PerspectiveCamera(this.stream, this.aspect, Object.assign(Object.assign(Object.assign({}, this.perspectiveData), camera), { fovY }), this.boundingBox, this.decodeFrame, this.flyToOptions);
-  }
-  toFrameCamera() {
-    var _a;
-    return new FramePerspectiveCamera(this.position, this.lookAt, this.up, this.near, this.far, this.aspectRatio, (_a = this.fovY) !== null && _a !== void 0 ? _a : 45);
-  }
-  get viewVector() {
-    return vector3.subtract(this.lookAt, this.position);
-  }
-  /**
-   * The position vector for the camera, in world space coordinates.
-   */
-  get position() {
-    return Object.assign({}, this.perspectiveData.position);
-  }
-  /**
-   * A normalized vector representing the up direction.
-   */
-  get up() {
-    return Object.assign({}, this.perspectiveData.up);
-  }
-  /**
-   * A vector, in world space coordinates, of where the camera is pointed at.
-   */
-  get lookAt() {
-    return Object.assign({}, this.perspectiveData.lookAt);
-  }
-  /**
-   * The camera's field of view.
-   */
-  get fovY() {
-    return this.perspectiveData.fovY;
-  }
-  /**
-   * The aspect ratio of the camera.
-   */
-  get aspectRatio() {
-    return this.aspect;
-  }
-  /**
-   * The camera's near clipping plane.
-   */
-  get near() {
-    const { near } = this.computeClippingPlanes(this.perspectiveData);
-    return near;
-  }
-  /**
-   * The camera's far clipping plane.
-   */
-  get far() {
-    const { far } = this.computeClippingPlanes(this.perspectiveData);
-    return far;
-  }
-  updateFlyToOptions(flyToOptions) {
-    return new PerspectiveCamera(this.stream, this.aspect, this.perspectiveData, this.boundingBox, this.decodeFrame, flyToOptions);
-  }
-}
-class OrthographicCamera extends Camera {
-  constructor(stream, aspect, orthographicData, boundingBox, decodeFrame, flyToOptions) {
-    super(stream, aspect, orthographicData, boundingBox, decodeFrame, flyToOptions);
-    this.orthographicData = orthographicData;
-  }
-  /**
-   * Shifts the position of the camera by the given delta.
-   *
-   * @param delta The number of units to shift the camera on the X, Y, and Z
-   * axis.
-   */
-  moveBy(delta) {
-    return this.update({
-      lookAt: vector3.add(this.lookAt, delta),
-    });
-  }
-  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
-    const updatedLookAt = vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point);
-    const updatedPosition = vector3.rotateAboutAxis(angleInRadians, this.position, axis, point);
-    const viewVector = constrainViewVector(vector3.subtract(updatedLookAt, updatedPosition), boundingSphere.create(this.boundingBox));
-    return this.update({
-      viewVector: viewVector,
-      lookAt: updatedLookAt,
-      up: vector3.rotateAboutAxis(angleInRadians, this.up, axis, vector3.origin()),
-    });
-  }
-  fitToBoundingBox(boundingBox) {
-    const boundingSphere$1 = boundingSphere.create(boundingBox);
-    const fitAll = super.fitCameraToBoundingBox(boundingBox, boundingSphere$1.radius, this.viewVector);
-    return this.update({
-      lookAt: fitAll.lookAt,
-      viewVector: fitAll.viewVector,
-      fovHeight: boundingSphere$1.radius * 2,
-    });
-  }
-  update(camera) {
-    return new OrthographicCamera(this.stream, this.aspect, Object.assign(Object.assign({}, this.orthographicData), camera), this.boundingBox, this.decodeFrame, this.flyToOptions);
-  }
-  toFrameCamera() {
-    return new FrameOrthographicCamera(constrainViewVector(this.viewVector, boundingSphere.create(this.boundingBox)), this.lookAt, this.up, this.near, this.far, this.aspectRatio, this.fovHeight);
-  }
-  get viewVector() {
-    return Object.assign({}, this.orthographicData.viewVector);
-  }
-  get position() {
-    return vector3.add(this.lookAt, vector3.negate(this.viewVector));
-  }
-  /**
-   * A normalized vector representing the up direction.
-   */
-  get up() {
-    return Object.assign({}, this.orthographicData.up);
-  }
-  /**
-   * A vector, in world space coordinates, of where the camera is pointed at.
-   */
-  get lookAt() {
-    return Object.assign({}, this.orthographicData.lookAt);
-  }
-  /**
-   * The camera's field of view.
-   */
-  get fovHeight() {
-    return this.orthographicData.fovHeight;
-  }
-  /**
-   * The aspect ratio of the camera.
-   */
-  get aspectRatio() {
-    return this.aspect;
-  }
-  /**
-   * The camera's near clipping plane.
-   */
-  get near() {
-    const { near } = this.computeClippingPlanes(this.orthographicData);
-    return near;
-  }
-  /**
-   * The camera's far clipping plane.
-   */
-  get far() {
-    const { far } = this.computeClippingPlanes(this.orthographicData);
-    return far;
-  }
-  updateFlyToOptions(flyToOptions) {
-    return new OrthographicCamera(this.stream, this.aspect, this.orthographicData, this.boundingBox, this.decodeFrame, flyToOptions);
-  }
-}
-
-/**
- * The `Raycaster` class is here.
- */
-class Raycaster {
-  constructor(stream, imageScaleProvider) {
-    this.stream = stream;
-    this.imageScaleProvider = imageScaleProvider;
-  }
-  /**
-   * Performs request on the stream to find items that intersect
-   * the given point.
-   *
-   * @param point The point to cast from looking for intersections.
-   */
-  async hitItems(point$1, options) {
-    const scale = this.imageScaleProvider();
-    const res = await this.stream.hitItems({
-      point: point.scale(point$1, (scale === null || scale === void 0 ? void 0 : scale.x) || 1, (scale === null || scale === void 0 ? void 0 : scale.y) || 1),
-      includeMetadata: options === null || options === void 0 ? void 0 : options.includeMetadata,
-    }, true);
-    return res.hitItems || undefined;
-  }
-}
-
-/**
- * The `CrossSectioner` class is here.
- */
-class CrossSectioner {
-  constructor(stream, data) {
-    this.stream = stream;
-    this.data = data;
-  }
-  /**
-   * Performs request on the stream to update the cross sectioning config.
-   *
-   * @param crossSectioning The new cross sectioning.
-   */
-  async update(crossSectioning) {
-    const res = await this.stream.updateCrossSectioning({
-      crossSectioning: {
-        sectionPlanes: crossSectioning.sectionPlanes,
-        highlightColor: crossSectioning.highlightColor,
-        lineWidth: (crossSectioning === null || crossSectioning === void 0 ? void 0 : crossSectioning.lineWidth) != null
-          ? { value: crossSectioning.lineWidth }
-          : null,
-      },
-    }, true);
-    return res.updateCrossSectioning || undefined;
-  }
-  current() {
-    return this.data;
-  }
-}
-
-/**
- * A class to handle the building of operations for a scene.
- */
-class SceneOperationBuilder {
-  constructor(operations = []) {
-    this.operations = operations;
-  }
-  /**
-   * Constructs the scene operations and returns a definition describing each
-   * operation.
-   */
-  build() {
-    return this.operations.concat();
-  }
-  materialOverride(material) {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'change-material', material }]));
-  }
-  show() {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'show' }]));
-  }
-  hide() {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'hide' }]));
-  }
-  select() {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'select' }]));
-  }
-  deselect() {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'deselect' }]));
-  }
-  clearMaterialOverrides() {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'clear-override' }]));
-  }
-  transform(matrix) {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'change-transform', transform: matrix }]));
-  }
-  clearTransforms(cascade = true) {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'clear-transform', cascade }]));
-  }
-  setPhantom(phantomState) {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'change-phantom', phantomState }]));
-  }
-  clearPhantom() {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'clear-phantom' }]));
-  }
-  setEndItem(endItemState) {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'change-end-item', endItemState }]));
-  }
-  clearEndItem() {
-    return new SceneOperationBuilder(this.operations.concat([{ type: 'clear-end-item' }]));
-  }
-}
-
-/**
- * An interface that represents a query is "complete" and can be turned into an
- * expression.
- */
-class TerminalQuery {
-  constructor(inverted) {
-    this.inverted = inverted;
-  }
-  build() {
-    if (this.inverted) {
-      return {
-        type: 'not',
-        query: this.queryExpressionBuilder(),
-      };
-    }
-    else {
-      return this.queryExpressionBuilder();
-    }
-  }
-}
-class RootQuery {
-  constructor(inverted = false) {
-    this.inverted = inverted;
-  }
-  all() {
-    return new AllQuery();
-  }
-  not() {
-    return new NotQuery(!this.inverted);
-  }
-  withItemIds(ids) {
-    return new BulkQuery(ids, 'item-id', this.inverted);
-  }
-  withSuppliedIds(ids) {
-    return new BulkQuery(ids, 'supplied-id', this.inverted);
-  }
-  withItemId(id) {
-    return new SingleQuery({ type: 'item-id', value: id }, this.inverted);
-  }
-  withSuppliedId(id) {
-    return new SingleQuery({ type: 'supplied-id', value: id }, this.inverted);
-  }
-  withSceneTreeRange(range) {
-    return new SceneTreeRangeQuery(range, this.inverted);
-  }
-  withMetadata(filter, keys, exactMatch) {
-    return new MetadataQuery(filter, keys, exactMatch, this.inverted);
-  }
-  withSelected() {
-    return new AllSelectedQuery(this.inverted);
-  }
-  withPoint(point) {
-    return new PointQuery(point, this.inverted);
-  }
-  withVolumeIntersection(rectangle, exclusive) {
-    return new VolumeIntersectionQuery(rectangle, this.inverted, exclusive);
-  }
-}
-class NotQuery extends RootQuery {
-  constructor(inverted) {
-    super(inverted);
-  }
-}
-class AllQuery extends TerminalQuery {
-  constructor(inverted = false) {
-    super(inverted);
-  }
-  queryExpressionBuilder() {
-    return { type: 'all' };
-  }
-}
-class SceneTreeRangeQuery extends TerminalQuery {
-  constructor(range, inverted) {
-    super(inverted);
-    this.range = range;
-  }
-  queryExpressionBuilder() {
-    return {
-      type: 'scene-tree-range',
-      range: this.range,
-    };
-  }
-}
-class MetadataQuery extends TerminalQuery {
-  constructor(filter, keys, exactMatch, inverted) {
-    super(inverted);
-    this.filter = filter;
-    this.keys = keys;
-    this.exactMatch = exactMatch;
-  }
-  queryExpressionBuilder() {
-    return {
-      type: 'metadata',
-      filter: this.filter,
-      keys: this.keys,
-      exactMatch: this.exactMatch,
-    };
-  }
-}
-class AllSelectedQuery extends TerminalQuery {
-  constructor(inverted) {
-    super(inverted);
-  }
-  queryExpressionBuilder() {
-    return {
-      type: 'all-selected',
-    };
-  }
-}
-class PointQuery extends TerminalQuery {
-  constructor(point, inverted) {
-    super(inverted);
-    this.point = point;
-  }
-  queryExpressionBuilder() {
-    return {
-      type: 'point',
-      point: this.point,
-    };
-  }
-}
-class VolumeIntersectionQuery extends TerminalQuery {
-  constructor(rectangle, inverted, exclusive) {
-    super(inverted);
-    this.rectangle = rectangle;
-    this.exclusive = exclusive;
-  }
-  queryExpressionBuilder() {
-    return {
-      type: 'volume-intersection',
-      rectangle: this.rectangle,
-      exclusive: !!this.exclusive,
-    };
-  }
-}
-class BulkQuery extends TerminalQuery {
-  constructor(ids, type, inverted) {
-    super(inverted);
-    this.ids = ids;
-    this.type = type;
-  }
-  queryExpressionBuilder() {
-    return {
-      type: 'or',
-      expressions: this.ids.map((id) => {
-        return {
-          type: this.type,
-          value: id,
-        };
-      }),
-    };
-  }
-}
-class SingleQuery extends TerminalQuery {
-  constructor(query, inverted) {
-    super(inverted);
-    this.query = query;
-  }
-  queryExpressionBuilder() {
-    return Object.assign({}, this.query);
-  }
-  and() {
-    return new AndQuery([this.query], this.inverted);
-  }
-  or() {
-    return new OrQuery([this.query], this.inverted);
-  }
-}
-class OrQuery extends TerminalQuery {
-  constructor(expressions, inverted) {
-    super(inverted);
-    this.expressions = expressions;
-  }
-  queryExpressionBuilder() {
-    return { type: 'or', expressions: [...this.expressions] };
-  }
-  withItemId(id) {
-    return new OrQuery([...this.expressions, { type: 'item-id', value: id }], this.inverted);
-  }
-  withSuppliedId(id) {
-    return new OrQuery([...this.expressions, { type: 'supplied-id', value: id }], this.inverted);
-  }
-  or() {
-    return this;
-  }
-}
-class AndQuery extends TerminalQuery {
-  constructor(expressions, inverted) {
-    super(inverted);
-    this.expressions = expressions;
-  }
-  queryExpressionBuilder() {
-    return { type: 'and', expressions: [...this.expressions] };
-  }
-  withItemId(id) {
-    return new AndQuery([...this.expressions, { type: 'item-id', value: id }], this.inverted);
-  }
-  withSuppliedId(id) {
-    return new AndQuery([...this.expressions, { type: 'supplied-id', value: id }], this.inverted);
-  }
-  and() {
-    return this;
-  }
-}
-class SceneItemQueryExecutor {
-  where(query) {
-    const expression = query(new RootQuery()).build();
-    return new SceneItemOperationsBuilder(expression);
-  }
-}
-
-/**
- * A class that is responsible for building operations for a specific scene.
- * This executor requires a query, and expects `execute()` to be invoked in order
- * for the changes to take effect.
- */
-class SceneItemOperationsBuilder {
-  constructor(query, givenBuilder) {
-    this.query = query;
-    this.builder =
-      givenBuilder != null ? givenBuilder : new SceneOperationBuilder();
-  }
-  materialOverride(color) {
-    if (typeof color === 'string') {
-      return new SceneItemOperationsBuilder(this.query, this.builder.materialOverride(fromHex(color)));
-    }
-    else {
-      return new SceneItemOperationsBuilder(this.query, this.builder.materialOverride(color));
-    }
-  }
-  hide() {
-    return new SceneItemOperationsBuilder(this.query, this.builder.hide());
-  }
-  show() {
-    return new SceneItemOperationsBuilder(this.query, this.builder.show());
-  }
-  select() {
-    return new SceneItemOperationsBuilder(this.query, this.builder.select());
-  }
-  deselect() {
-    return new SceneItemOperationsBuilder(this.query, this.builder.deselect());
-  }
-  clearMaterialOverrides() {
-    return new SceneItemOperationsBuilder(this.query, this.builder.clearMaterialOverrides());
-  }
-  transform(matrix) {
-    if (Array.isArray(matrix)) {
-      if (matrix.length !== 16) {
-        throw new InvalidArgumentError('Matrix provided must contain exactly 16 values (4x4).');
-      }
-      return new SceneItemOperationsBuilder(this.query, this.builder.transform({
-        r0: {
-          x: matrix[0],
-          y: matrix[1],
-          z: matrix[2],
-          w: matrix[3],
-        },
-        r1: {
-          x: matrix[4],
-          y: matrix[5],
-          z: matrix[6],
-          w: matrix[7],
-        },
-        r2: {
-          x: matrix[8],
-          y: matrix[9],
-          z: matrix[10],
-          w: matrix[11],
-        },
-        r3: {
-          x: matrix[12],
-          y: matrix[13],
-          z: matrix[14],
-          w: matrix[15],
-        },
-      }));
-    }
-    else {
-      return new SceneItemOperationsBuilder(this.query, this.builder.transform(matrix));
-    }
-  }
-  clearTransforms(cascade = true) {
-    return new SceneItemOperationsBuilder(this.query, this.builder.clearTransforms(cascade));
-  }
-  setPhantom(phantomState) {
-    return new SceneItemOperationsBuilder(this.query, this.builder.setPhantom(phantomState));
-  }
-  clearPhantom() {
-    return new SceneItemOperationsBuilder(this.query, this.builder.clearPhantom());
-  }
-  setEndItem(endItemState) {
-    return new SceneItemOperationsBuilder(this.query, this.builder.setEndItem(endItemState));
-  }
-  clearEndItem() {
-    return new SceneItemOperationsBuilder(this.query, this.builder.clearEndItem());
-  }
-  build() {
-    return {
-      query: this.query,
-      operations: this.builder.build(),
-    };
-  }
-}
-class ItemsOperationExecutor {
-  constructor(sceneViewId, stream, dimensions, queryOperations) {
-    this.sceneViewId = sceneViewId;
-    this.stream = stream;
-    this.dimensions = dimensions;
-    this.queryOperations = queryOperations;
-  }
-  async execute(executionOptions) {
-    const pbOperations = this.queryOperations.map((op) => buildSceneOperation(op.query, op.operations, {
-      dimensions: this.dimensions,
-    }));
-    const request = {
-      sceneViewId: {
-        hex: this.sceneViewId,
-      },
-      operations: pbOperations,
-      suppliedCorrelationId: (executionOptions === null || executionOptions === void 0 ? void 0 : executionOptions.suppliedCorrelationId) != null
-        ? {
-          value: executionOptions === null || executionOptions === void 0 ? void 0 : executionOptions.suppliedCorrelationId,
-        }
-        : undefined,
-    };
-    await this.stream.createSceneAlteration(request);
-  }
-}
-/**
- * A class that represents the `Scene` that has been loaded into the viewer. On
- * it, you can retrieve attributes of the scene, such as the camera. It also
- * contains methods for updating the scene and performing requests to rerender
- * the scene.
- */
-class Scene {
-  constructor(stream, frame, decodeFrame, imageScaleProvider, dimensions, sceneId, sceneViewId) {
-    this.stream = stream;
-    this.frame = frame;
-    this.decodeFrame = decodeFrame;
-    this.imageScaleProvider = imageScaleProvider;
-    this.dimensions = dimensions;
-    this.sceneId = sceneId;
-    this.sceneViewId = sceneViewId;
-  }
-  /**
-   * Applies the provided scene view state to the scene.
-   */
-  async applySceneViewState(sceneViewStateId, opts = {}) {
-    const pbIdField = buildSceneViewStateIdentifier(sceneViewStateId);
-    return await this.stream.loadSceneViewState(Object.assign(Object.assign({}, pbIdField), { frameCorrelationId: opts.suppliedCorrelationId
-        ? { value: opts.suppliedCorrelationId }
-        : undefined }), true);
-  }
-  /**
-   * Applies the specified features of the provided scene view state to the scene.
-   */
-  async applyPartialSceneViewState(sceneViewStateId, featuresToApply, opts = {}) {
-    const pbIdField = buildSceneViewStateIdentifier(sceneViewStateId);
-    const pbFeatures = toPbSceneViewStateFeatures(featuresToApply);
-    return await this.stream.loadSceneViewState(Object.assign(Object.assign({}, pbIdField), { frameCorrelationId: opts.suppliedCorrelationId
-        ? { value: opts.suppliedCorrelationId }
-        : undefined, sceneViewStateFeatureSubset: pbFeatures }), true);
-  }
-  /**
-   * Resets the view to its default state, with the ability to reset the camera to that of the base scene.
-   */
-  async reset(opts = {}) {
-    return await this.stream.resetSceneView({
-      includeCamera: opts.includeCamera,
-      frameCorrelationId: opts.suppliedCorrelationId
-        ? { value: opts.suppliedCorrelationId }
-        : undefined,
-    }, true);
-  }
-  /**
-   * Returns an executor that accepts a function as a parameter that contains one or many operations to apply
-   * to the scene view. The operations will be applied transactionally.
-   * @param operations
-   */
-  items(operations) {
-    const sceneOperations = operations(new SceneItemQueryExecutor());
-    const ops = Array.isArray(sceneOperations)
-      ? sceneOperations
-      : [sceneOperations];
-    const operationList = ops.reduce((acc, builder) => acc.concat(builder.build()), []);
-    return new ItemsOperationExecutor(this.sceneViewId, this.stream, this.dimensions, operationList);
-  }
-  /**
-   * An instance of the current camera of the scene.
-   */
-  camera() {
-    const { scene } = this.frame;
-    if (scene.camera.isOrthographic()) {
-      return new OrthographicCamera(this.stream, dimensions.aspectRatio(this.viewport()), {
-        viewVector: scene.camera.viewVector,
-        lookAt: scene.camera.lookAt,
-        up: scene.camera.up,
-        fovHeight: scene.camera.fovHeight,
-      }, this.frame.scene.boundingBox, this.decodeFrame);
-    }
-    else if (scene.camera.isPerspective()) {
-      return new PerspectiveCamera(this.stream, dimensions.aspectRatio(this.viewport()), {
-        position: scene.camera.position,
-        lookAt: scene.camera.lookAt,
-        up: scene.camera.up,
-        fovY: scene.camera.fovY,
-      }, this.frame.scene.boundingBox, this.decodeFrame);
-    }
-    else {
-      throw new InvalidCameraError('Cannot retrieve camera. Scene has an unknown or invalid camera type.');
-    }
-  }
-  boundingBox() {
-    return this.frame.scene.boundingBox;
-  }
-  /**
-   * CrossSectioner to update cross sectioning planes and get current configuration.
-   */
-  crossSectioning() {
-    return new CrossSectioner(this.stream, this.frame.scene.crossSection);
-  }
-  /**
-   * Raycaster to request items that intersect a point.
-   */
-  raycaster() {
-    return new Raycaster(this.stream, this.imageScaleProvider);
-  }
-  /**
-   * The current viewport of the scene, in pixels.
-   */
-  viewport() {
-    return this.frame.dimensions;
-  }
-  /**
-   * The current x and y scale of the rendered image.
-   */
-  scale() {
-    return this.imageScaleProvider() || point.create(1, 1);
-  }
-}
-
-export { Scene as S, SynchronizedClock as a, colorMaterial as c, fromUrn as f, loadableResource as l };
-
-//# sourceMappingURL=scene.js.map