@toolpath/viewer 0.2.0

package/dist/index.js

@@ -0,0 +1,676 @@
+import {
+  CAD_CAMERA_UP,
+  CANDIDATE_WEIGHT,
+  CONE_AXIS,
+  CONTINUES_WITHIN,
+  CadCameraControls,
+  DEFAULT_FIT_MARGIN,
+  DEFAULT_THEME,
+  DIRECTION_COLORS,
+  EXCLUDE_FROM_FRAME,
+  EnginePart,
+  ExtendedCameraControls,
+  FEATURE_TYPE_RANKS,
+  HANDLE_PIXELS,
+  HEAD,
+  HEAD_RADIUS,
+  HIGHLIGHT_COLORS,
+  HIGHLIGHT_WEIGHT,
+  HOVER_WEIGHT,
+  NO_MODIFIERS,
+  PERSPECTIVE_FOV,
+  PICKED_SURFACE_LABEL,
+  PartMesh,
+  PartReportFormatError,
+  REGION_ATTRIBUTE,
+  SECTION_RENDER_ORDER,
+  SHAFT_RADIUS,
+  SectionView,
+  TAP_SLOP,
+  UnsupportedKernelVersionError,
+  Viewer,
+  applyHighlightLayers,
+  applyProjection,
+  arrowPlacement,
+  aspectRatio,
+  bestOwner,
+  boundsFromBox,
+  buildPick,
+  buildRegionAttribute,
+  buildRegionIndex,
+  buildRegionTexels,
+  cadViewDirections,
+  contentBounds,
+  createPart,
+  currentViewDirection,
+  cycleOwner,
+  defaultBounds,
+  directionColor,
+  directionIndexOf,
+  directionLabel,
+  dragPlane,
+  featureTypeRank,
+  fitDistance,
+  focusForPick,
+  groupByDirection,
+  movedFar,
+  normalizePartReport,
+  orthographicHalfHeight,
+  perspectiveFitDistance,
+  pickedStartDepth,
+  rankOwners,
+  regionEdgesGeometry,
+  resolveSectionPlane,
+  resolveTheme,
+  sameDirection,
+  screenLength,
+  sectionBounds,
+  sectionConstant,
+  sectionDepth,
+  sectionDepthConstant,
+  sectionDepthRange,
+  sectionFromPick,
+  sectionOffset,
+  sectionPlane,
+  smoothRegionNormals,
+  startPosition,
+  themesEqual,
+  trackTaps,
+  useContentBox,
+  useTapGuard,
+  useViewerControls,
+  viewDirection,
+  visualSurfaces
+} from "./chunk-7NQBV7EQ.js";
+
+// src/primitives.tsx
+import { GizmoHelper } from "@react-three/drei";
+import { useThree } from "@react-three/fiber";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+// src/render/grid.ts
+import { BufferGeometry, Float32BufferAttribute, Vector3 } from "three";
+var STEPS = [0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 25, 50, 100, 200, 250, 500, 1e3];
+var TARGET_CELLS = 10;
+var OVERHANG = 1.6;
+function gridSpec(box) {
+  const size = box.getSize(new Vector3());
+  const center = box.getCenter(new Vector3());
+  const largest = Math.max(size.x, size.y, 1e-6);
+  const ideal = largest / TARGET_CELLS;
+  const step = [...STEPS].reverse().find((candidate) => candidate <= ideal) ?? STEPS[0];
+  const extent = Math.ceil(largest * OVERHANG / 2 / step) * step;
+  return { step, extent, z: box.min.z, center };
+}
+function gridGeometry(spec) {
+  const { step, extent, z, center } = spec;
+  const positions = [];
+  for (let offset = -extent; offset <= extent + 1e-9; offset += step) {
+    positions.push(
+      center.x + offset,
+      center.y - extent,
+      z,
+      center.x + offset,
+      center.y + extent,
+      z,
+      center.x - extent,
+      center.y + offset,
+      z,
+      center.x + extent,
+      center.y + offset,
+      z
+    );
+  }
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+  return geometry;
+}
+
+// src/render/view-cube.ts
+import {
+  BufferGeometry as BufferGeometry2,
+  CanvasTexture,
+  Float32BufferAttribute as Float32BufferAttribute2,
+  SRGBColorSpace,
+  Vector3 as Vector32
+} from "three";
+var VIEW_NAMES = [
+  // The six faces.
+  "top",
+  "bottom",
+  "front",
+  "back",
+  "left",
+  "right",
+  // The twelve edges.
+  "top-front",
+  "top-back",
+  "top-left",
+  "top-right",
+  "bottom-front",
+  "bottom-back",
+  "bottom-left",
+  "bottom-right",
+  "front-left",
+  "front-right",
+  "back-left",
+  "back-right",
+  // The eight corners.
+  "top-front-left",
+  "top-front-right",
+  "top-back-left",
+  "top-back-right",
+  "bottom-front-left",
+  "bottom-front-right",
+  "bottom-back-left",
+  "bottom-back-right"
+];
+var VIEW_SIGNS = {
+  top: [0, 0, 1],
+  bottom: [0, 0, -1],
+  front: [0, -1, 0],
+  back: [0, 1, 0],
+  left: [-1, 0, 0],
+  right: [1, 0, 0],
+  "top-front": [0, -1, 1],
+  "top-back": [0, 1, 1],
+  "top-left": [-1, 0, 1],
+  "top-right": [1, 0, 1],
+  "bottom-front": [0, -1, -1],
+  "bottom-back": [0, 1, -1],
+  "bottom-left": [-1, 0, -1],
+  "bottom-right": [1, 0, -1],
+  "front-left": [-1, -1, 0],
+  "front-right": [1, -1, 0],
+  "back-left": [-1, 1, 0],
+  "back-right": [1, 1, 0],
+  "top-front-left": [-1, -1, 1],
+  "top-front-right": [1, -1, 1],
+  "top-back-left": [-1, 1, 1],
+  "top-back-right": [1, 1, 1],
+  "bottom-front-left": [-1, -1, -1],
+  "bottom-front-right": [1, -1, -1],
+  "bottom-back-left": [-1, 1, -1],
+  "bottom-back-right": [1, 1, -1]
+};
+function viewKind(name) {
+  const off = VIEW_SIGNS[name].filter((sign) => sign !== 0).length;
+  if (off === 1) return "face";
+  if (off === 2) return "edge";
+  return "corner";
+}
+var DIRECTIONS = new Map(
+  VIEW_NAMES.map((name) => {
+    const [x, y, z] = VIEW_SIGNS[name];
+    const length = Math.hypot(x, y, z);
+    return [name, { x: x / length, y: y / length, z: z / length }];
+  })
+);
+function viewVector(name) {
+  return DIRECTIONS.get(name) ?? { x: 0, y: 0, z: 1 };
+}
+function viewUp(direction) {
+  if (direction.x === 0 && direction.y === 0) {
+    return { x: 0, y: direction.z > 0 ? 1 : -1, z: 0 };
+  }
+  return { x: 0, y: 0, z: 1 };
+}
+var CHAMFER = 0.5834;
+function vec(v) {
+  return { x: v.x, y: v.y, z: v.z };
+}
+function cubeZones(chamfer = CHAMFER) {
+  const AXES = [0, 1, 2];
+  return VIEW_NAMES.map((name) => {
+    const kind = viewKind(name);
+    const direction = viewVector(name);
+    const [sx, sy, sz] = VIEW_SIGNS[name];
+    const sign = (axis) => VIEW_SIGNS[name][axis] ?? 0;
+    const normal = new Vector32(direction.x, direction.y, direction.z);
+    let polygon;
+    if (kind === "face") {
+      const up = viewUp(direction);
+      const upVector = new Vector32(up.x, up.y, up.z);
+      const right = normal.clone().negate().cross(upVector).normalize();
+      const square = [
+        [-1, -1],
+        [1, -1],
+        [1, 1],
+        [-1, 1]
+      ];
+      polygon = square.map(
+        ([u, v]) => normal.clone().addScaledVector(right, u * chamfer).addScaledVector(upVector, v * chamfer)
+      );
+    } else if (kind === "edge") {
+      const a = AXES.find((axis) => sign(axis) !== 0) ?? 0;
+      const b = [...AXES].reverse().find((axis) => sign(axis) !== 0) ?? 0;
+      const c = AXES.find((axis) => sign(axis) === 0) ?? 0;
+      const rectangle = [
+        [1, chamfer, -chamfer],
+        [1, chamfer, chamfer],
+        [chamfer, 1, chamfer],
+        [chamfer, 1, -chamfer]
+      ];
+      polygon = rectangle.map(
+        ([onA, onB, onC]) => new Vector32().setComponent(a, sign(a) * onA).setComponent(b, sign(b) * onB).setComponent(c, onC)
+      );
+    } else {
+      const triangle = [
+        [1, chamfer, chamfer],
+        [chamfer, 1, chamfer],
+        [chamfer, chamfer, 1]
+      ];
+      polygon = triangle.map(([onX, onY, onZ]) => new Vector32(sx * onX, sy * onY, sz * onZ));
+    }
+    const [first, second, third] = polygon;
+    if (first && second && third) {
+      const facing = new Vector32().subVectors(second, first).cross(new Vector32().subVectors(third, first));
+      if (facing.dot(normal) < 0) polygon.reverse();
+    }
+    return { name, kind, direction, polygon: polygon.map(vec) };
+  });
+}
+function panelGeometry(zone) {
+  const positions = [];
+  const normals = [];
+  const [first] = zone.polygon;
+  const geometry = new BufferGeometry2();
+  if (!first) return geometry;
+  for (let index = 1; index + 1 < zone.polygon.length; index += 1) {
+    const b = zone.polygon[index];
+    const c = zone.polygon[index + 1];
+    if (!b || !c) continue;
+    positions.push(first.x, first.y, first.z, b.x, b.y, b.z, c.x, c.y, c.z);
+    for (let vertex = 0; vertex < 3; vertex += 1) {
+      normals.push(zone.direction.x, zone.direction.y, zone.direction.z);
+    }
+  }
+  geometry.setAttribute("position", new Float32BufferAttribute2(positions, 3));
+  geometry.setAttribute("normal", new Float32BufferAttribute2(normals, 3));
+  return geometry;
+}
+function cubeOutlineGeometry(zones) {
+  const positions = [];
+  for (const zone of zones) {
+    for (let index = 0; index < zone.polygon.length; index += 1) {
+      const from = zone.polygon[index];
+      const to = zone.polygon[(index + 1) % zone.polygon.length];
+      if (!from || !to) continue;
+      positions.push(from.x, from.y, from.z, to.x, to.y, to.z);
+    }
+  }
+  const geometry = new BufferGeometry2();
+  geometry.setAttribute("position", new Float32BufferAttribute2(positions, 3));
+  return geometry;
+}
+function labelGeometry(zone) {
+  const positions = [];
+  const uvs = [];
+  const corners = [0, 1, 2, 0, 2, 3];
+  const corner = [
+    [0, 0],
+    [1, 0],
+    [1, 1],
+    [0, 1]
+  ];
+  for (const index of corners) {
+    const point = zone.polygon[index];
+    const uv = corner[index];
+    if (!point || !uv) continue;
+    positions.push(
+      point.x + zone.direction.x * 4e-3,
+      point.y + zone.direction.y * 4e-3,
+      point.z + zone.direction.z * 4e-3
+    );
+    uvs.push(uv[0] ?? 0, uv[1] ?? 0);
+  }
+  const geometry = new BufferGeometry2();
+  geometry.setAttribute("position", new Float32BufferAttribute2(positions, 3));
+  geometry.setAttribute("uv", new Float32BufferAttribute2(uvs, 2));
+  return geometry;
+}
+function labelTexture(label, color) {
+  const size = 128;
+  const canvas = document.createElement("canvas");
+  canvas.width = size;
+  canvas.height = size;
+  const context = canvas.getContext("2d");
+  if (context) {
+    const text = label.toUpperCase();
+    const hex = `#${color.toString(16).padStart(6, "0")}`;
+    context.font = `600 ${size / 4}px system-ui, sans-serif`;
+    const width = context.measureText("BOTTOM").width || 1;
+    const scale = Math.min(1, size * 0.78 / width);
+    context.font = `600 ${size / 4 * scale}px system-ui, sans-serif`;
+    context.textAlign = "center";
+    context.textBaseline = "middle";
+    context.fillStyle = hex;
+    context.fillText(text, size / 2, size / 2);
+  }
+  const texture = new CanvasTexture(canvas);
+  texture.colorSpace = SRGBColorSpace;
+  texture.needsUpdate = true;
+  return texture;
+}
+
+// src/primitives.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var FURNITURE = { [EXCLUDE_FROM_FRAME]: true };
+var Grid = ({ step, extent, color, opacity = 0.35 }) => {
+  const theme = resolveTheme();
+  const box = useContentBox();
+  const geometry = useMemo(() => {
+    const spec = gridSpec(box);
+    const cell = step ?? spec.step;
+    return gridGeometry({
+      ...spec,
+      step: cell,
+      // Snapped outwards to a whole number of cells, so the part sits inside
+      // the grid rather than ending part-way through a square.
+      extent: extent ?? Math.ceil(spec.extent / cell) * cell
+    });
+  }, [box, extent, step]);
+  useEffect(() => () => geometry.dispose(), [geometry]);
+  return /* @__PURE__ */ jsx("lineSegments", { geometry, renderOrder: -1, raycast: () => null, userData: FURNITURE, children: /* @__PURE__ */ jsx("lineBasicMaterial", { color: color ?? theme.cubeEdge, transparent: true, opacity }) });
+};
+var Axes = ({ size = 25 }) => /* @__PURE__ */ jsx("axesHelper", { args: [size], userData: FURNITURE, raycast: () => null });
+var ViewCube = ({
+  alignment = "top-right",
+  margin = [80, 80],
+  theme,
+  onViewChange
+}) => {
+  const resolved = useMemo(() => resolveTheme(theme), [theme]);
+  const zones = useMemo(() => cubeZones(), []);
+  return /* @__PURE__ */ jsx(GizmoHelper, { alignment, margin, children: /* @__PURE__ */ jsx(CubePanels, { zones, theme: resolved, onViewChange }) });
+};
+var CubePanels = ({
+  zones,
+  theme,
+  onViewChange
+}) => {
+  const controls = useViewerControls();
+  const invalidate = useThree((state) => state.invalidate);
+  const groupRef = useRef(null);
+  const [hovered, setHovered] = useState(null);
+  const panels = useMemo(
+    () => zones.map((zone) => ({ zone, geometry: panelGeometry(zone) })),
+    [zones]
+  );
+  const outline = useMemo(() => cubeOutlineGeometry(zones), [zones]);
+  const labels = useMemo(
+    () => zones.filter((zone) => zone.kind === "face").map((zone) => ({
+      zone,
+      geometry: labelGeometry(zone),
+      texture: labelTexture(zone.name, theme.cubeLabel)
+    })),
+    [theme.cubeLabel, zones]
+  );
+  useEffect(
+    () => () => {
+      for (const panel of panels) panel.geometry.dispose();
+      for (const label of labels) {
+        label.geometry.dispose();
+        label.texture.dispose();
+      }
+      outline.dispose();
+    },
+    [labels, outline, panels]
+  );
+  const choose = (zone) => {
+    controls.setViewDirection(zone.direction);
+    onViewChange?.(zone.name);
+  };
+  const hover = (name) => {
+    setHovered(name);
+    invalidate();
+  };
+  return /* @__PURE__ */ jsxs("group", { ref: groupRef, scale: 38, children: [
+    panels.map(({ zone, geometry }) => /* @__PURE__ */ jsx(
+      "mesh",
+      {
+        geometry,
+        onPointerOver: (event) => {
+          event.stopPropagation();
+          hover(zone.name);
+        },
+        onPointerOut: () => hover(null),
+        onClick: (event) => {
+          event.stopPropagation();
+          choose(zone);
+        },
+        children: /* @__PURE__ */ jsx(
+          "meshLambertMaterial",
+          {
+            color: hovered === zone.name ? theme.hover : theme.cube,
+            polygonOffset: true,
+            polygonOffsetFactor: 1,
+            polygonOffsetUnits: 1
+          }
+        )
+      },
+      zone.name
+    )),
+    labels.map(({ zone, geometry, texture }) => /* @__PURE__ */ jsx("mesh", { geometry, raycast: () => null, children: /* @__PURE__ */ jsx("meshBasicMaterial", { map: texture, transparent: true }) }, `${zone.name}-label`)),
+    /* @__PURE__ */ jsx("lineSegments", { geometry: outline, raycast: () => null, children: /* @__PURE__ */ jsx("lineBasicMaterial", { color: theme.cubeEdge }) }),
+    /* @__PURE__ */ jsx("ambientLight", { intensity: 1.4 }),
+    /* @__PURE__ */ jsx("directionalLight", { position: [viewVector("top-front-right").x, 1, 2], intensity: 1.1 })
+  ] });
+};
+
+// src/direction-arrows.tsx
+import { useThree as useThree2 } from "@react-three/fiber";
+import { useMemo as useMemo2 } from "react";
+import { Quaternion, Vector3 as Vector33 } from "three";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FURNITURE2 = { [EXCLUDE_FROM_FRAME]: true };
+var DirectionArrows = ({
+  directions,
+  activeDirection = null,
+  shownDirection,
+  previewDirection = null,
+  namedDirections = [],
+  onPickDirection,
+  theme,
+  visible = true
+}) => {
+  const box = useContentBox();
+  const resolved = useMemo2(() => resolveTheme(theme), [theme]);
+  const shown = shownDirection === void 0 ? activeDirection : shownDirection;
+  if (!visible) return null;
+  return (
+    // Excluded from framing: the arrows are deliberately placed outside the
+    // part, so a Fit that measured them would frame the arrows and leave the
+    // part small in the middle of them.
+    /* @__PURE__ */ jsxs2("group", { userData: FURNITURE2, children: [
+      directions.map((direction, index) => {
+        if (shown !== null && shown !== index) return null;
+        return /* @__PURE__ */ jsx2(
+          Arrow,
+          {
+            direction,
+            box,
+            color: directionColor(index),
+            opacity: 0.9,
+            onPick: onPickDirection ? () => onPickDirection(index) : void 0
+          },
+          `candidate-${index}`
+        );
+      }),
+      namedDirections.map((named) => /* @__PURE__ */ jsx2(
+        Arrow,
+        {
+          direction: named.direction,
+          box,
+          color: named.color,
+          opacity: 0.9,
+          onPick: onPickDirection ? () => onPickDirection(named.index) : void 0
+        },
+        `named-${named.index}`
+      )),
+      previewDirection ? /* @__PURE__ */ jsx2(Arrow, { direction: previewDirection, box, color: resolved.hover, opacity: 0.95, onTop: true }) : null
+    ] })
+  );
+};
+var Arrow = ({ direction, box, color, opacity, onPick, onTop = false }) => {
+  const invalidate = useThree2((state) => state.invalidate);
+  const { tip, length, quaternion } = useMemo2(() => {
+    const placement = arrowPlacement(direction, box);
+    const aim = new Quaternion().setFromUnitVectors(
+      CONE_AXIS,
+      new Vector33(direction.x, direction.y, direction.z).normalize()
+    );
+    return { tip: placement.tip, length: placement.length, quaternion: aim };
+  }, [box, direction]);
+  const head = length * HEAD;
+  const shaft = length * (1 - HEAD);
+  const press = onPick ? {
+    onClick: (event) => {
+      event.stopPropagation();
+      onPick();
+      invalidate();
+    }
+  } : {};
+  return /* @__PURE__ */ jsxs2("group", { position: tip, quaternion, renderOrder: onTop ? 10 : 3, children: [
+    /* @__PURE__ */ jsxs2("mesh", { position: [0, head * 0.5, 0], rotation: [Math.PI, 0, 0], ...press, children: [
+      /* @__PURE__ */ jsx2("coneGeometry", { args: [length * HEAD_RADIUS, head, 20] }),
+      /* @__PURE__ */ jsx2("meshBasicMaterial", { color, transparent: true, opacity, depthTest: !onTop })
+    ] }),
+    /* @__PURE__ */ jsxs2("mesh", { position: [0, head + shaft * 0.5, 0], ...press, children: [
+      /* @__PURE__ */ jsx2("cylinderGeometry", { args: [length * SHAFT_RADIUS, length * SHAFT_RADIUS, shaft, 12] }),
+      /* @__PURE__ */ jsx2("meshBasicMaterial", { color, transparent: true, opacity, depthTest: !onTop })
+    ] })
+  ] });
+};
+
+// src/model/normals.ts
+function regionNormals(geometry, regions) {
+  const position = geometry.getAttribute("position");
+  const index = geometry.getIndex();
+  const normals = /* @__PURE__ */ new Map();
+  if (!position) return normals;
+  const vertexAt = (at) => {
+    const vertex = index ? index.getX(at) : at;
+    return [position.getX(vertex), position.getY(vertex), position.getZ(vertex)];
+  };
+  for (const region of regions) {
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    for (let triangle = region.triangles.start; triangle < region.triangles.end; triangle++) {
+      const [ax, ay, az] = vertexAt(triangle * 3);
+      const [bx, by, bz] = vertexAt(triangle * 3 + 1);
+      const [cx, cy, cz] = vertexAt(triangle * 3 + 2);
+      const ux = bx - ax;
+      const uy = by - ay;
+      const uz = bz - az;
+      const vx = cx - ax;
+      const vy = cy - ay;
+      const vz = cz - az;
+      x += uy * vz - uz * vy;
+      y += uz * vx - ux * vz;
+      z += ux * vy - uy * vx;
+    }
+    const length = Math.sqrt(x * x + y * y + z * z);
+    if (length > 1e-9) normals.set(region.idx, { x: x / length, y: y / length, z: z / length });
+  }
+  return normals;
+}
+export {
+  Axes,
+  CAD_CAMERA_UP,
+  CANDIDATE_WEIGHT,
+  CHAMFER,
+  CONTINUES_WITHIN,
+  CadCameraControls,
+  DEFAULT_FIT_MARGIN,
+  DEFAULT_THEME,
+  DIRECTION_COLORS,
+  DirectionArrows,
+  EXCLUDE_FROM_FRAME,
+  EnginePart,
+  ExtendedCameraControls,
+  FEATURE_TYPE_RANKS,
+  Grid,
+  HANDLE_PIXELS,
+  HIGHLIGHT_COLORS,
+  HIGHLIGHT_WEIGHT,
+  HOVER_WEIGHT,
+  NO_MODIFIERS,
+  PERSPECTIVE_FOV,
+  PICKED_SURFACE_LABEL,
+  PartMesh,
+  PartReportFormatError,
+  REGION_ATTRIBUTE,
+  SECTION_RENDER_ORDER,
+  SectionView,
+  TAP_SLOP,
+  UnsupportedKernelVersionError,
+  VIEW_NAMES,
+  VIEW_SIGNS,
+  ViewCube,
+  Viewer,
+  applyHighlightLayers,
+  applyProjection,
+  arrowPlacement,
+  aspectRatio,
+  bestOwner,
+  boundsFromBox,
+  buildPick,
+  buildRegionAttribute,
+  buildRegionIndex,
+  buildRegionTexels,
+  cadViewDirections,
+  contentBounds,
+  createPart,
+  cubeOutlineGeometry,
+  cubeZones,
+  currentViewDirection,
+  cycleOwner,
+  defaultBounds,
+  directionColor,
+  directionIndexOf,
+  directionLabel,
+  dragPlane,
+  featureTypeRank,
+  fitDistance,
+  focusForPick,
+  gridGeometry,
+  gridSpec,
+  groupByDirection,
+  labelGeometry,
+  labelTexture,
+  movedFar,
+  normalizePartReport,
+  orthographicHalfHeight,
+  panelGeometry,
+  perspectiveFitDistance,
+  pickedStartDepth,
+  rankOwners,
+  regionEdgesGeometry,
+  regionNormals,
+  resolveSectionPlane,
+  resolveTheme,
+  sameDirection,
+  screenLength,
+  sectionBounds,
+  sectionConstant,
+  sectionDepth,
+  sectionDepthConstant,
+  sectionDepthRange,
+  sectionFromPick,
+  sectionOffset,
+  sectionPlane,
+  smoothRegionNormals,
+  startPosition,
+  themesEqual,
+  trackTaps,
+  useContentBox,
+  useTapGuard,
+  useViewerControls,
+  viewDirection,
+  viewKind,
+  viewUp,
+  viewVector,
+  visualSurfaces
+};