ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/view-scene-GHBN7QMR.mjs

@@ -0,0 +1,904 @@
+import { smartArt3DCameraMatrix, smartArt3DEyeInDiagram, resolveSmartArt3DLightModel, hexToRgb, shadeSmartArt3DVertices, smartArt3DGradientCoordinate, smartArt3DGradientColor } from './chunk-RQJOOXRG.mjs';
+import { NO_THREE_VIEW_OVERFLOW, hasThreeViewOverflow, overflowViewOffset, threeViewOverflowFromNdc } from './chunk-2V5ATMMB.mjs';
+
+// src/pptx/render/smartart-3d-translucency.ts
+var CLEAR_FACE_ALPHA = 0.2;
+var CLEAR_EDGE_GAIN = 2;
+var CLEAR_EDGE_EXPONENT = 1;
+function isSmartArt3DGlassMaterial(material) {
+  return material === "clear";
+}
+function smartArt3DSurfaceAlpha(material, opacity, facing) {
+  if (!isSmartArt3DGlassMaterial(material)) {
+    return opacity;
+  }
+  const tilt = 1 - Math.max(0, Math.min(1, facing));
+  const share = CLEAR_FACE_ALPHA + CLEAR_EDGE_GAIN * tilt ** CLEAR_EDGE_EXPONENT;
+  return Math.max(0, Math.min(1, opacity * share));
+}
+function smartArt3DVertexAlphas(positions, normals, material, opacity, eye) {
+  const out = new Float32Array(positions.length / 3);
+  for (let i = 0, v = 0; i < positions.length; i += 3, v++) {
+    let view = { x: 0, y: 0, z: 1 };
+    if (eye) {
+      const dx = eye.x - positions[i];
+      const dy = eye.y - positions[i + 1];
+      const dz = eye.z - positions[i + 2];
+      const len = Math.hypot(dx, dy, dz) || 1;
+      view = { x: dx / len, y: dy / len, z: dz / len };
+    }
+    const facing = normals[i] * view.x + normals[i + 1] * view.y + normals[i + 2] * view.z;
+    out[v] = smartArt3DSurfaceAlpha(material, opacity, facing);
+  }
+  return out;
+}
+function orientSmartArt3DTriangles(triangles) {
+  const { positions: p, normals: n } = triangles;
+  for (let t = 0; t + 9 <= p.length; t += 9) {
+    const ux = p[t + 3] - p[t];
+    const uy = p[t + 4] - p[t + 1];
+    const uz = p[t + 5] - p[t + 2];
+    const vx = p[t + 6] - p[t];
+    const vy = p[t + 7] - p[t + 1];
+    const vz = p[t + 8] - p[t + 2];
+    const cx = uy * vz - uz * vy;
+    const cy = uz * vx - ux * vz;
+    const cz = ux * vy - uy * vx;
+    const nx = n[t] + n[t + 3] + n[t + 6];
+    const ny = n[t + 1] + n[t + 4] + n[t + 7];
+    const nz = n[t + 2] + n[t + 5] + n[t + 8];
+    if (cx * nx + cy * ny + cz * nz < 0) {
+      for (const arr of [p, n]) {
+        for (let c = 0; c < 3; c++) {
+          const b = arr[t + 3 + c];
+          arr[t + 3 + c] = arr[t + 6 + c];
+          arr[t + 6 + c] = b;
+        }
+      }
+    }
+  }
+}
+function isSmartArt3DTranslucentMesh(mesh) {
+  return !mesh.fillNone && (mesh.opacity < 1 || isSmartArt3DGlassMaterial(mesh.solid?.material));
+}
+function smartArt3DGlassLightModel(model) {
+  return { ...model, ambient: 1, diffuse: 0 };
+}
+
+// src/pptx/smartart-3d/connector-object.ts
+var CONNECTOR_Z_LIFT = 0.02;
+function buildConnectorLines(three, connectors, disposables) {
+  return connectors.flatMap((connector) => {
+    if (connector.points.length < 2) {
+      return [];
+    }
+    const geometry = new three.BufferGeometry().setFromPoints(
+      connector.points.map((p) => new three.Vector3(p.x, p.y, p.z + CONNECTOR_Z_LIFT))
+    );
+    const material = new three.LineBasicMaterial({ color: connector.color });
+    disposables.push(geometry, material);
+    return [new three.Line(geometry, material)];
+  });
+}
+
+// src/pptx/smartart-3d/text-block-layout.ts
+var MAX_TEXTURE_SIDE = 4096;
+var MIN_SCALE = 3;
+var MAX_SCALE = 6;
+var LINE_HALF_EM = 0.75;
+var PAD_EM = 0.25;
+function textureScale(devicePixelRatio) {
+  const wanted = Math.ceil((Number.isFinite(devicePixelRatio) ? devicePixelRatio : 1) * 2);
+  return Math.min(MAX_SCALE, Math.max(MIN_SCALE, wanted));
+}
+function layoutTextBlock(block, measure, devicePixelRatio) {
+  const fontSize = Math.max(6, block.fontSize);
+  let halfWidth = Math.max(1, block.maxWidth) / 2;
+  let halfHeight = Math.max(1, block.maxHeight) / 2;
+  for (const line of block.lines) {
+    if (!line.text) continue;
+    halfWidth = Math.max(halfWidth, measure(line.text) / 2 + fontSize * PAD_EM);
+    halfHeight = Math.max(halfHeight, Math.abs(line.dy) + fontSize * (LINE_HALF_EM + PAD_EM));
+  }
+  const worldWidth = halfWidth * 2;
+  const worldHeight = halfHeight * 2;
+  const scale = Math.min(
+    textureScale(devicePixelRatio),
+    MAX_TEXTURE_SIDE / worldWidth,
+    MAX_TEXTURE_SIDE / worldHeight
+  );
+  return {
+    worldWidth,
+    worldHeight,
+    scale,
+    pixelWidth: Math.max(8, Math.round(worldWidth * scale)),
+    pixelHeight: Math.max(8, Math.round(worldHeight * scale))
+  };
+}
+
+// src/pptx/smartart-3d/text-block-texture.ts
+var ANISOTROPY = 8;
+function buildTextBlockTexture(three, block) {
+  if (typeof document === "undefined" || block.lines.every((l) => l.text.length === 0)) {
+    return null;
+  }
+  const canvas = document.createElement("canvas");
+  const ctx2d = canvas.getContext("2d");
+  if (!ctx2d) {
+    return null;
+  }
+  const weight = block.fontWeight ?? 400;
+  const italic = block.fontStyle === "italic" ? "italic " : "";
+  const family = block.fontFamily ? `${block.fontFamily}, system-ui, sans-serif` : "system-ui, -apple-system, Segoe UI, Roboto, sans-serif";
+  const fontSize = Math.max(6, block.fontSize);
+  const fontAt = (scale2) => `${italic}${weight} ${fontSize * scale2}px ${family}`;
+  const MEASURE = 4;
+  ctx2d.font = fontAt(MEASURE);
+  const layout = layoutTextBlock(
+    block,
+    (text) => ctx2d.measureText(text).width / MEASURE,
+    typeof window === "undefined" ? 1 : window.devicePixelRatio
+  );
+  const { worldWidth, worldHeight, scale } = layout;
+  canvas.width = layout.pixelWidth;
+  canvas.height = layout.pixelHeight;
+  ctx2d.clearRect(0, 0, canvas.width, canvas.height);
+  ctx2d.fillStyle = block.color;
+  ctx2d.textAlign = "center";
+  ctx2d.textBaseline = "middle";
+  ctx2d.font = fontAt(scale);
+  const centerX = canvas.width / 2;
+  const centerY = canvas.height / 2;
+  for (const line of block.lines) {
+    if (!line.text) {
+      continue;
+    }
+    ctx2d.fillText(line.text, centerX, centerY - line.dy * scale);
+  }
+  const texture = new three.CanvasTexture(canvas);
+  texture.colorSpace = three.SRGBColorSpace;
+  texture.generateMipmaps = true;
+  texture.minFilter = three.LinearMipmapLinearFilter;
+  texture.magFilter = three.LinearFilter;
+  texture.anisotropy = ANISOTROPY;
+  texture.flipY = false;
+  texture.premultiplyAlpha = false;
+  texture.wrapT = three.RepeatWrapping;
+  texture.repeat.set(1, -1);
+  texture.offset.set(0, 1);
+  texture.needsUpdate = true;
+  return { texture, worldWidth, worldHeight };
+}
+
+// src/pptx/smartart-3d/flat-mesh-object.ts
+var STROKE_Z_LIFT = 0.05;
+function buildShape(three, mesh) {
+  const shape = new three.Shape(mesh.outline.map((p) => new three.Vector2(p.x, p.y)));
+  for (const hole of mesh.holes ?? []) {
+    shape.holes.push(new three.Path(hole.map((p) => new three.Vector2(p.x, p.y))));
+  }
+  return shape;
+}
+function buildFlatFill(three, mesh, shape, disposables) {
+  if (mesh.fillNone) {
+    return null;
+  }
+  const geometry = new three.ShapeGeometry(shape);
+  const material = new three.MeshBasicMaterial({
+    color: mesh.fill,
+    side: three.DoubleSide,
+    transparent: mesh.opacity < 1,
+    opacity: mesh.opacity
+  });
+  disposables.push(geometry, material);
+  return new three.Mesh(geometry, material);
+}
+function buildStrokeLines(three, mesh, disposables) {
+  if (mesh.strokeWidth <= 0 || mesh.stroke === "transparent") {
+    return [];
+  }
+  const material = new three.LineBasicMaterial({ color: mesh.stroke });
+  disposables.push(material);
+  const loops = [mesh.outline, ...mesh.holes ?? []];
+  return loops.map((loop) => {
+    const geometry = new three.BufferGeometry().setFromPoints(
+      loop.map((p) => new three.Vector3(p.x, p.y, STROKE_Z_LIFT))
+    );
+    disposables.push(geometry);
+    return new three.LineLoop(geometry, material);
+  });
+}
+function buildTextPlane(three, mesh, group, disposables) {
+  if (!mesh.textBlock) {
+    return;
+  }
+  const built = buildTextBlockTexture(three, mesh.textBlock);
+  if (!built) {
+    return;
+  }
+  disposables.push(built.texture);
+  const geometry = new three.PlaneGeometry(built.worldWidth, built.worldHeight);
+  const material = new three.MeshBasicMaterial({
+    map: built.texture,
+    transparent: true,
+    depthWrite: false
+  });
+  disposables.push(geometry, material);
+  const plane = new three.Mesh(geometry, material);
+  plane.position.set(
+    mesh.textBlock.x - mesh.position.x,
+    mesh.textBlock.y - mesh.position.y,
+    mesh.textBlock.z - mesh.position.z
+  );
+  group.add(plane);
+}
+function buildFlatMeshObject(three, mesh) {
+  const disposables = [];
+  const group = new three.Group();
+  group.position.set(mesh.position.x, mesh.position.y, mesh.position.z);
+  const shape = buildShape(three, mesh);
+  const fill = buildFlatFill(three, mesh, shape, disposables);
+  if (fill) {
+    group.add(fill);
+  }
+  for (const line of buildStrokeLines(three, mesh, disposables)) {
+    group.add(line);
+  }
+  buildTextPlane(three, mesh, group, disposables);
+  return { group, disposables };
+}
+
+// src/pptx/render/smartart-3d-ring.ts
+var EPSILON = 1e-6;
+var MITER_LIMIT = 4;
+function cleanRing(points) {
+  const out = [];
+  for (const p of points) {
+    const last = out[out.length - 1];
+    if (!last || Math.hypot(p.x - last.x, p.y - last.y) > EPSILON) {
+      out.push({ x: p.x, y: p.y });
+    }
+  }
+  while (out.length > 1) {
+    const first = out[0];
+    const last = out[out.length - 1];
+    if (Math.hypot(first.x - last.x, first.y - last.y) > EPSILON) {
+      break;
+    }
+    out.pop();
+  }
+  return out;
+}
+function ringSignedArea(ring) {
+  let area = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % ring.length];
+    area += a.x * b.y - b.x * a.y;
+  }
+  return area / 2;
+}
+function toCcwRing(points) {
+  const ring = cleanRing(points);
+  return ringSignedArea(ring) < 0 ? ring.reverse() : ring;
+}
+function ringEdgeNormals(ring) {
+  return ring.map((a, i) => {
+    const b = ring[(i + 1) % ring.length];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len = Math.hypot(dx, dy) || 1;
+    return { x: -dy / len, y: dx / len };
+  });
+}
+function offsetRing(ring, distance) {
+  if (distance === 0) {
+    return ring.map((p) => ({ x: p.x, y: p.y }));
+  }
+  const normals = ringEdgeNormals(ring);
+  const n = ring.length;
+  return ring.map((p, i) => {
+    const prev = normals[(i - 1 + n) % n];
+    const next = normals[i];
+    const denom = Math.max(0.05, 1 + prev.x * next.x + prev.y * next.y);
+    let ox = (prev.x + next.x) / denom * distance;
+    let oy = (prev.y + next.y) / denom * distance;
+    const len = Math.hypot(ox, oy);
+    const max = Math.abs(distance) * MITER_LIMIT;
+    if (len > max) {
+      ox = ox / len * max;
+      oy = oy / len * max;
+    }
+    return { x: p.x + ox, y: p.y + oy };
+  });
+}
+function ringShadingNormals(ring, smoothDeg = 30) {
+  const normals = ringEdgeNormals(ring);
+  const n = ring.length;
+  const cosLimit = Math.cos(smoothDeg * Math.PI / 180);
+  const vertexNormal = (own, other) => {
+    if (own.x * other.x + own.y * other.y < cosLimit) {
+      return own;
+    }
+    const x = own.x + other.x;
+    const y = own.y + other.y;
+    const len = Math.hypot(x, y) || 1;
+    return { x: x / len, y: y / len };
+  };
+  return normals.map((own, i) => [
+    vertexNormal(own, normals[(i - 1 + n) % n]),
+    vertexNormal(own, normals[(i + 1) % n])
+  ]);
+}
+
+// src/pptx/render/smartart-3d-bevel-profile.ts
+var CURVE_SEGMENTS = 8;
+function sampleCurve(fn) {
+  const points = [];
+  for (let i = 0; i <= CURVE_SEGMENTS; i++) {
+    points.push(fn(i / CURVE_SEGMENTS));
+  }
+  return points;
+}
+var QUARTER = Math.PI / 2;
+var PROFILES = {
+  // Quarter round: vertical at the outline, flat where it meets the face.
+  circle: () => sampleCurve((u) => ({ s: 1 - Math.cos(u * QUARTER), t: Math.sin(u * QUARTER) })),
+  // Round, but reaching the outline at a slant instead of vertically.
+  convex: () => sampleCurve((u) => ({ s: u, t: Math.sin(u * QUARTER) })),
+  softRound: () => sampleCurve((u) => ({ s: u, t: 1 - (1 - u) * (1 - u) })),
+  // A groove next to the outline, then a rounded rise onto the face.
+  relaxedInset: () => sampleCurve((u) => ({
+    s: u,
+    t: u * u * (3 - 2 * u) - 0.3 * Math.sin(Math.PI * u) * (1 - u)
+  })),
+  divot: () => sampleCurve((u) => ({
+    s: u,
+    t: u - 0.5 * Math.sin(Math.PI * u)
+  })),
+  angle: () => [
+    { s: 0, t: 0 },
+    { s: 1, t: 1 }
+  ],
+  slope: () => [
+    { s: 0, t: 0 },
+    { s: 1, t: 1 }
+  ],
+  coolSlant: () => [
+    { s: 0, t: 0 },
+    { s: 0.3, t: 0.75 },
+    { s: 1, t: 1 }
+  ],
+  hardEdge: () => [
+    { s: 0, t: 0 },
+    { s: 0.2, t: 0.9 },
+    { s: 1, t: 1 }
+  ],
+  cross: () => [
+    { s: 0, t: 0 },
+    { s: 0.5, t: 1 },
+    { s: 1, t: 1 }
+  ],
+  riblet: () => [
+    { s: 0, t: 0 },
+    { s: 0.33, t: 1 },
+    { s: 0.66, t: 0.5 },
+    { s: 1, t: 1 }
+  ],
+  artDeco: () => [
+    { s: 0, t: 0 },
+    { s: 0.25, t: 0.5 },
+    { s: 0.5, t: 0.5 },
+    { s: 0.75, t: 1 },
+    { s: 1, t: 1 }
+  ]
+};
+function getSmartArtBevelProfile(profile) {
+  const build = profile && PROFILES[profile] || PROFILES.circle;
+  return build();
+}
+
+// src/pptx/render/smartart-3d-solid-geometry.ts
+var CONTOUR_Z_LIFT = 0.05;
+var VERTICAL_SLOPE = 1e3;
+function emptyTriangles() {
+  return { positions: [], normals: [] };
+}
+function pushVertex(out, p, z, n) {
+  out.positions.push(p.x, p.y, z);
+  out.normals.push(n[0], n[1], n[2]);
+}
+function normalize(x, y, z) {
+  const len = Math.hypot(x, y, z) || 1;
+  return [x / len, y / len, z / len];
+}
+function pushQuad(out, corners) {
+  const [a, b, c, d] = corners;
+  for (const v of [a, b, c, a, c, d]) {
+    pushVertex(out, v.p, v.z, v.n);
+  }
+}
+function addBand(out, ring, bevel, zOuter, facing) {
+  const profile = getSmartArtBevelProfile(bevel.profile);
+  const rings = profile.map((pt) => offsetRing(ring, bevel.width * pt.s));
+  const shading = ringShadingNormals(ring);
+  const n = ring.length;
+  for (let k = 0; k < profile.length - 1; k++) {
+    const ds = profile[k + 1].s - profile[k].s;
+    const dt = profile[k + 1].t - profile[k].t;
+    const slope = Math.abs(ds) < 1e-6 ? Math.sign(dt || 1) * VERTICAL_SLOPE : bevel.height * dt / (bevel.width * ds);
+    const z0 = zOuter + facing * bevel.height * profile[k].t;
+    const z1 = zOuter + facing * bevel.height * profile[k + 1].t;
+    for (let i = 0; i < n; i++) {
+      const j = (i + 1) % n;
+      const [mi, mj] = shading[i];
+      const ni = normalize(-slope * mi.x, -slope * mi.y, facing);
+      const nj = normalize(-slope * mj.x, -slope * mj.y, facing);
+      pushQuad(out, [
+        { p: rings[k][i], z: z0, n: ni },
+        { p: rings[k][j], z: z0, n: nj },
+        { p: rings[k + 1][j], z: z1, n: nj },
+        { p: rings[k + 1][i], z: z1, n: ni }
+      ]);
+    }
+  }
+  return rings[rings.length - 1];
+}
+function addWalls(out, ring, zTop, zBottom) {
+  if (zTop - zBottom <= 0) {
+    return;
+  }
+  const shading = ringShadingNormals(ring);
+  const n = ring.length;
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    const [mi, mj] = shading[i];
+    const ni = normalize(-mi.x, -mi.y, 0);
+    const nj = normalize(-mj.x, -mj.y, 0);
+    pushQuad(out, [
+      { p: ring[i], z: zTop, n: ni },
+      { p: ring[j], z: zTop, n: nj },
+      { p: ring[j], z: zBottom, n: nj },
+      { p: ring[i], z: zBottom, n: ni }
+    ]);
+  }
+}
+function buildSmartArt3DSolidGeometry(outline, holes, solid) {
+  const ring = toCcwRing(outline);
+  const body = emptyTriangles();
+  const sides = emptyTriangles();
+  const topHeight = solid.bevelTop?.height ?? 0;
+  const zShoulder = -topHeight;
+  const zBackShoulder = zShoulder - solid.extrusion;
+  const backHeight = solid.bevelBottom?.height ?? 0;
+  const zBack = zBackShoulder - backHeight;
+  const holeRings = holes.map((hole) => toCcwRing(hole)).filter((hole) => hole.length >= 3);
+  const frontRing = solid.bevelTop ? addBand(body, ring, solid.bevelTop, zShoulder, 1) : ring;
+  addWalls(sides, ring, zShoulder, zBackShoulder);
+  const hasDepth = zBack < 0;
+  const backRing = hasDepth && solid.bevelBottom ? addBand(sides, ring, solid.bevelBottom, zBackShoulder, -1) : ring;
+  const contourCaps = [];
+  if (solid.contourWidth > 0) {
+    const rim = offsetRing(ring, -solid.contourWidth);
+    const inner = [...ring].reverse();
+    contourCaps.push({ ring: rim, holes: [inner], z: zShoulder + CONTOUR_Z_LIFT, facing: 1 });
+    if (hasDepth) {
+      contourCaps.push({ ring: rim, holes: [inner], z: zBack - CONTOUR_Z_LIFT, facing: -1 });
+    }
+  }
+  return {
+    body,
+    sides,
+    frontCap: { ring: frontRing, holes: holeRings, z: 0, facing: 1 },
+    ...hasDepth ? { backCap: { ring: backRing, holes: holeRings, z: zBack, facing: -1 } } : {},
+    contourCaps
+  };
+}
+
+// src/pptx/render/smartart-3d-text-extrusion.ts
+var TEXT_LAYER_STEP = 0.4;
+var MAX_TEXT_LAYERS = 32;
+var TEXT_SIDE_SHADE = 0.69;
+function shadeHex(hex, factor) {
+  const match = /^#?([0-9a-f]{6})$/iu.exec(hex.trim());
+  if (!match) {
+    return hex;
+  }
+  const n = Number.parseInt(match[1], 16);
+  const channel = (shift) => Math.round((n >> shift & 255) * factor).toString(16).padStart(2, "0");
+  return `#${channel(16)}${channel(8)}${channel(0)}`;
+}
+function smartArt3DTextLayers(block) {
+  const depth = block.extrusion ?? 0;
+  if (!(depth > 0)) {
+    return void 0;
+  }
+  const count = Math.max(1, Math.min(MAX_TEXT_LAYERS, Math.ceil(depth / TEXT_LAYER_STEP)));
+  const sideZ = [];
+  for (let i = 0; i < count; i++) {
+    sideZ.push(block.z + depth * i / count);
+  }
+  return {
+    sideZ,
+    frontZ: block.z + depth,
+    sideColor: shadeHex(block.extrusionColor ?? block.color, TEXT_SIDE_SHADE)
+  };
+}
+
+// src/pptx/smartart-3d/lit-text-object.ts
+function textPlanes(three, mesh, block, zs, light, disposables) {
+  const built = zs.length > 0 ? buildTextBlockTexture(three, block) : null;
+  if (!built) {
+    return [];
+  }
+  const geometry = new three.PlaneGeometry(built.worldWidth, built.worldHeight);
+  const material = new three.MeshBasicMaterial({
+    map: built.texture,
+    transparent: true,
+    depthWrite: false
+  });
+  material.color.setRGB(light.tint[0], light.tint[1], light.tint[2]);
+  disposables.push(built.texture, geometry, material);
+  return zs.map((z) => {
+    const plane = new three.Mesh(geometry, material);
+    plane.position.set(block.x - mesh.position.x, block.y - mesh.position.y, z - mesh.position.z);
+    return plane;
+  });
+}
+function buildLitTextObject(three, mesh, group, light, disposables) {
+  const block = mesh.textBlock;
+  if (!block) {
+    return;
+  }
+  const layers = smartArt3DTextLayers(block);
+  const planes = [
+    ...layers ? textPlanes(
+      three,
+      mesh,
+      { ...block, color: layers.sideColor },
+      layers.sideZ,
+      light,
+      disposables
+    ) : [],
+    ...textPlanes(three, mesh, block, [layers?.frontZ ?? block.z], light, disposables)
+  ];
+  for (const plane of planes) {
+    group.add(plane);
+  }
+}
+
+// src/pptx/smartart-3d/lit-mesh-object.ts
+var LABEL_RENDER_ORDER = 3;
+var GRADIENT_TEXELS = 256;
+function appendCap(three, out, cap) {
+  if (cap.ring.length < 3) {
+    return;
+  }
+  const contour = cap.ring.map((p) => new three.Vector2(p.x, p.y));
+  const holes = cap.holes.map((hole) => hole.map((p) => new three.Vector2(p.x, p.y)));
+  const all = [...contour, ...holes.flat()];
+  for (const face of three.ShapeUtils.triangulateShape(contour, holes)) {
+    for (const index of face) {
+      const p = all[index];
+      out.positions.push(p.x, p.y, cap.z);
+      out.normals.push(0, 0, cap.facing);
+    }
+  }
+}
+function buildGradientTexture(three, gradient) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = GRADIENT_TEXELS;
+  canvas.height = 1;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    return null;
+  }
+  const paint = ctx.createLinearGradient(0, 0, GRADIENT_TEXELS, 0);
+  for (const stop of gradient.stops) {
+    paint.addColorStop(stop.offset, stop.color);
+  }
+  ctx.fillStyle = paint;
+  ctx.fillRect(0, 0, GRADIENT_TEXELS, 1);
+  const texture = new three.CanvasTexture(canvas);
+  texture.colorSpace = three.SRGBColorSpace;
+  texture.wrapS = three.ClampToEdgeWrapping;
+  texture.needsUpdate = true;
+  return texture;
+}
+function withAlpha(rgb, alpha) {
+  const out = new Float32Array(alpha.length * 4);
+  for (let v = 0; v < alpha.length; v++) {
+    out.set(rgb.subarray(v * 3, v * 3 + 3), v * 4);
+    out[v * 4 + 3] = alpha[v];
+  }
+  return out;
+}
+function buildPart(three, part, light, eye, disposables) {
+  if (part.triangles.positions.length === 0) {
+    return null;
+  }
+  const glass = isSmartArt3DGlassMaterial(part.material);
+  const translucent = part.opacity < 1 || glass;
+  if (translucent) {
+    orientSmartArt3DTriangles(part.triangles);
+  }
+  const { positions, normals } = part.triangles;
+  const gradient = part.gradient;
+  const flatColor = hexToRgb(part.color);
+  const baseAt = (p) => gradient ? smartArt3DGradientColor(gradient, p) : flatColor;
+  const geometry = new three.BufferGeometry();
+  geometry.setAttribute("position", new three.Float32BufferAttribute(positions, 3));
+  const shading = shadeSmartArt3DVertices(
+    positions,
+    normals,
+    baseAt,
+    glass ? smartArt3DGlassLightModel(light) : light,
+    eye
+  );
+  geometry.setAttribute(
+    "color",
+    glass ? new three.BufferAttribute(
+      withAlpha(
+        shading,
+        smartArt3DVertexAlphas(positions, normals, part.material, part.opacity, eye)
+      ),
+      4
+    ) : new three.BufferAttribute(shading, 3)
+  );
+  const texture = gradient ? buildGradientTexture(three, gradient) : null;
+  if (gradient && texture) {
+    const uv = [];
+    for (let i = 0; i < positions.length; i += 3) {
+      uv.push(
+        smartArt3DGradientCoordinate({ x: positions[i], y: positions[i + 1] }, gradient),
+        0.5
+      );
+    }
+    geometry.setAttribute("uv", new three.Float32BufferAttribute(uv, 2));
+    disposables.push(texture);
+  }
+  const material = new three.MeshBasicMaterial({
+    color: texture ? "#ffffff" : part.color,
+    map: texture,
+    vertexColors: true,
+    side: translucent ? three.FrontSide : three.DoubleSide,
+    transparent: translucent,
+    // A glass carries its alpha per vertex; the material then stays at 1.
+    opacity: glass ? 1 : part.opacity,
+    // Translucent solids are layered in paint order, like PowerPoint's
+    // per-shape compositing, rather than hiding one another.
+    depthWrite: !translucent
+  });
+  disposables.push(geometry, material);
+  return new three.Mesh(geometry, material);
+}
+function buildLitMeshObject(three, mesh, light, eye) {
+  const localEye = eye ? { x: eye.x - mesh.position.x, y: eye.y - mesh.position.y, z: eye.z - mesh.position.z } : void 0;
+  const disposables = [];
+  const group = new three.Group();
+  group.position.set(mesh.position.x, mesh.position.y, mesh.position.z);
+  if (!mesh.fillNone && mesh.outline.length >= 3) {
+    const holes = mesh.holes ?? [];
+    const geometry = mesh.solid ? buildSmartArt3DSolidGeometry(mesh.outline, holes, mesh.solid) : void 0;
+    const body = geometry?.body ?? { positions: [], normals: [] };
+    appendCap(
+      three,
+      body,
+      geometry?.frontCap ?? { ring: toCcwRing(mesh.outline), holes, z: 0, facing: 1 }
+    );
+    const sides = geometry?.sides ?? { positions: [], normals: [] };
+    if (geometry?.backCap) {
+      appendCap(three, sides, geometry.backCap);
+    }
+    const contour = { positions: [], normals: [] };
+    for (const cap of geometry?.contourCaps ?? []) {
+      appendCap(three, contour, cap);
+    }
+    const material = mesh.solid?.material;
+    const parts = [
+      {
+        triangles: body,
+        color: mesh.fill,
+        gradient: mesh.gradient,
+        opacity: mesh.opacity,
+        material
+      },
+      {
+        triangles: sides,
+        color: mesh.solid?.extrusionColor ?? mesh.fill,
+        opacity: mesh.opacity,
+        material
+      },
+      {
+        triangles: contour,
+        color: mesh.solid?.contourColor ?? mesh.fill,
+        opacity: mesh.opacity
+      }
+    ];
+    parts.forEach((part, order) => {
+      const built = buildPart(three, part, light, localEye, disposables);
+      if (built) {
+        built.renderOrder = order;
+        group.add(built);
+      }
+    });
+  }
+  for (const line of buildStrokeLines(three, mesh, disposables)) {
+    group.add(line);
+  }
+  const labelsFrom = group.children.length;
+  buildLitTextObject(three, mesh, group, light, disposables);
+  for (const label of group.children.slice(labelsFrom)) {
+    label.renderOrder = LABEL_RENDER_ORDER;
+  }
+  return { group, disposables };
+}
+
+// src/pptx/smartart-3d/view-camera.ts
+var ORTHO_DISTANCE = 1e3;
+function frameHalfExtents(bounds, size) {
+  const halfW = Math.max(1, bounds.width) / 2;
+  const halfH = Math.max(1, bounds.height) / 2;
+  const aspect = Math.max(1, size.pixelWidth) / Math.max(1, size.pixelHeight);
+  const fitHalfH = Math.max(halfH, halfW / aspect);
+  return { halfW: fitHalfH * aspect, halfH: fitHalfH };
+}
+function buildSmartArtViewCamera(three, bounds, sceneCamera, size) {
+  let camera;
+  if (sceneCamera?.projection === "perspective") {
+    const distance = Math.max(1, sceneCamera.distance);
+    camera = new three.PerspectiveCamera(30, 1, distance / 20, distance * 20);
+    camera.position.set(0, 0, distance);
+  } else {
+    camera = new three.OrthographicCamera(-1, 1, 1, -1, -ORTHO_DISTANCE * 2, ORTHO_DISTANCE * 2);
+    camera.position.set(0, 0, ORTHO_DISTANCE);
+  }
+  camera.zoom = sceneCamera?.zoom ?? 1;
+  camera.lookAt(0, 0, 0);
+  fitSmartArtViewCamera(camera, bounds, size);
+  return camera;
+}
+function fitSmartArtViewCamera(camera, bounds, size) {
+  const { halfW, halfH } = frameHalfExtents(bounds, size);
+  if ("isPerspectiveCamera" in camera && camera.isPerspectiveCamera) {
+    camera.aspect = halfW / halfH;
+    camera.fov = 2 * Math.atan(halfH / camera.position.length()) * 180 / Math.PI;
+  } else {
+    const ortho = camera;
+    ortho.left = -halfW;
+    ortho.right = halfW;
+    ortho.top = halfH;
+    ortho.bottom = -halfH;
+  }
+  camera.updateProjectionMatrix();
+}
+
+// src/pptx/smartart-3d/view-overflow.ts
+function measureOverflow(three, root, camera) {
+  root.updateMatrixWorld(true);
+  camera.updateMatrixWorld(true);
+  const points = [];
+  const corner = new three.Vector3();
+  root.traverse((object) => {
+    const geometry = object.geometry;
+    if (!geometry?.getAttribute?.("position")) {
+      return;
+    }
+    if (!geometry.boundingBox) {
+      geometry.computeBoundingBox();
+    }
+    const box = geometry.boundingBox;
+    if (!box || box.isEmpty()) {
+      return;
+    }
+    for (let i = 0; i < 8; i++) {
+      corner.set(
+        i & 1 ? box.max.x : box.min.x,
+        i & 2 ? box.max.y : box.min.y,
+        i & 4 ? box.max.z : box.min.z
+      ).applyMatrix4(object.matrixWorld).project(camera);
+      points.push({ x: corner.x, y: corner.y });
+    }
+  });
+  return threeViewOverflowFromNdc(points);
+}
+function frameSmartArtOverflow(three, root, camera, size, turned) {
+  camera.clearViewOffset();
+  if (!turned) {
+    return NO_THREE_VIEW_OVERFLOW;
+  }
+  const overflow = measureOverflow(three, root, camera);
+  if (hasThreeViewOverflow(overflow)) {
+    const offset = overflowViewOffset(size, overflow);
+    camera.setViewOffset(
+      offset.fullWidth,
+      offset.fullHeight,
+      offset.x,
+      offset.y,
+      offset.width,
+      offset.height
+    );
+  }
+  return overflow;
+}
+
+// src/pptx/smartart-3d/view-scene.ts
+async function mountSmartArt3DView(model, ctx) {
+  const { three } = ctx;
+  const scene = new three.Scene();
+  if (model.background) {
+    scene.background = new three.Color(model.background);
+  }
+  const disposables = [];
+  const lit = model.styleCategory === "bevel" || model.styleCategory === "scene";
+  const view = model.camera ? smartArt3DCameraMatrix(model.camera) : void 0;
+  const eye = model.camera ? smartArt3DEyeInDiagram(model.camera) : void 0;
+  const root = new three.Group();
+  if (view) {
+    root.matrixAutoUpdate = false;
+    root.matrix.set(
+      view[0],
+      view[1],
+      view[2],
+      0,
+      view[3],
+      view[4],
+      view[5],
+      0,
+      view[6],
+      view[7],
+      view[8],
+      0,
+      0,
+      0,
+      0,
+      1
+    );
+  }
+  scene.add(root);
+  model.meshes.forEach((mesh, index) => {
+    const built = lit ? buildLitMeshObject(
+      three,
+      mesh,
+      resolveSmartArt3DLightModel(
+        model.lighting,
+        mesh.solid?.material,
+        eye !== void 0,
+        model.camera !== void 0
+      ),
+      eye
+    ) : buildFlatMeshObject(three, mesh);
+    if (lit && isSmartArt3DTranslucentMesh(mesh)) {
+      built.group.renderOrder = index + 1;
+    }
+    root.add(built.group);
+    disposables.push(...built.disposables);
+  });
+  for (const line of buildConnectorLines(three, model.connectors, disposables)) {
+    root.add(line);
+  }
+  const camera = buildSmartArtViewCamera(three, model.bounds, model.camera, ctx.size);
+  let overflow = frameSmartArtOverflow(three, root, camera, ctx.size, Boolean(model.camera));
+  return {
+    render(renderer) {
+      renderer.render(scene, camera);
+    },
+    resize(size) {
+      fitSmartArtViewCamera(camera, model.bounds, size);
+      overflow = frameSmartArtOverflow(three, root, camera, size, Boolean(model.camera));
+    },
+    overflow() {
+      return overflow;
+    },
+    dispose() {
+      for (const d of disposables) {
+        d.dispose();
+      }
+    }
+  };
+}
+
+export { mountSmartArt3DView };