@remotion/svg-3d-engine 4.0.363 → 4.0.365

package/dist/esm/index.mjs

@@ -0,0 +1,1378 @@
+// src/truthy.ts
+function truthy(value) {
+  return Boolean(value);
+}
+
+// src/matrix.ts
+var stride = function({
+  v,
+  m,
+  width,
+  offset,
+  colStride
+}) {
+  for (let i = 0;i < v.length; i++) {
+    m[i * width + (i * colStride + offset + width) % width] = v[i];
+  }
+  return m;
+};
+var identity4 = function() {
+  const n = 4;
+  let size = n * n;
+  const m = new Array(size);
+  while (size--) {
+    m[size] = size % (n + 1) === 0 ? 1 : 0;
+  }
+  return m;
+};
+var rotated = function(axisVec, radians) {
+  return rotatedUnitSinCos(normalize(axisVec), Math.sin(radians), Math.cos(radians));
+};
+var rotateX = (radians) => {
+  return rotated([1, 0, 0], radians);
+};
+var rotateY = (radians) => {
+  return rotated([0, 1, 0], radians);
+};
+var rotateZ = (radians) => {
+  return rotated([0, 0, 1], radians);
+};
+var multiplyMatrices = (matrix1, matrix2) => {
+  const result = new Array(16).fill(0);
+  for (let i = 0;i < 4; i++) {
+    for (let j = 0;j < 4; j++) {
+      for (let k = 0;k < 4; k++) {
+        result[i * 4 + j] += matrix1[i * 4 + k] * matrix2[k * 4 + j];
+      }
+    }
+  }
+  return result;
+};
+var reduceMatrices = (matrices) => {
+  return matrices.filter(truthy).slice().reverse().reduce((acc, cur) => {
+    return multiplyMatrices(acc, cur);
+  }, identity4());
+};
+var aroundCenterPoint = ({
+  matrix,
+  x,
+  y,
+  z
+}) => {
+  return reduceMatrices([
+    translateX(-x),
+    translateY(-y),
+    translateZ(-z),
+    matrix,
+    translateX(x),
+    translateY(y),
+    translateZ(z)
+  ]);
+};
+var makeMatrix3dTransform = function(matrix) {
+  return `matrix3d(${[
+    matrix[0],
+    matrix[4],
+    matrix[8],
+    matrix[12],
+    matrix[1],
+    matrix[5],
+    matrix[9],
+    matrix[13],
+    matrix[2],
+    matrix[6],
+    matrix[10],
+    matrix[14],
+    matrix[3],
+    matrix[7],
+    matrix[11],
+    matrix[15]
+  ].join(", ")}`;
+};
+var interpolate = (a, b, t) => {
+  return a + (b - a) * t;
+};
+var interpolateMatrix4d = (input, matrix1, matrix2) => {
+  return [
+    interpolate(matrix1[0], matrix2[0], input),
+    interpolate(matrix1[1], matrix2[1], input),
+    interpolate(matrix1[2], matrix2[2], input),
+    interpolate(matrix1[3], matrix2[3], input),
+    interpolate(matrix1[4], matrix2[4], input),
+    interpolate(matrix1[5], matrix2[5], input),
+    interpolate(matrix1[6], matrix2[6], input),
+    interpolate(matrix1[7], matrix2[7], input),
+    interpolate(matrix1[8], matrix2[8], input),
+    interpolate(matrix1[9], matrix2[9], input),
+    interpolate(matrix1[10], matrix2[10], input),
+    interpolate(matrix1[11], matrix2[11], input),
+    interpolate(matrix1[12], matrix2[12], input),
+    interpolate(matrix1[13], matrix2[13], input),
+    interpolate(matrix1[14], matrix2[14], input),
+    interpolate(matrix1[15], matrix2[15], input)
+  ];
+};
+var scaled = function(value) {
+  const vec = typeof value === "number" ? [value, value, value] : value;
+  return stride({ v: vec, m: identity4(), width: 4, offset: 0, colStride: 1 });
+};
+var scaleX = (x) => {
+  return scaled([x, 1, 1]);
+};
+var scaleY = (y) => {
+  return scaled([1, y, 1]);
+};
+var rotatedUnitSinCos = function(axisVec, sinAngle, cosAngle) {
+  const x = axisVec[0];
+  const y = axisVec[1];
+  const z = axisVec[2];
+  const c = cosAngle;
+  const s = sinAngle;
+  const t = 1 - c;
+  return [
+    t * x * x + c,
+    t * x * y - s * z,
+    t * x * z + s * y,
+    0,
+    t * x * y + s * z,
+    t * y * y + c,
+    t * y * z - s * x,
+    0,
+    t * x * z - s * y,
+    t * y * z + s * x,
+    t * z * z + c,
+    0,
+    0,
+    0,
+    0,
+    1
+  ];
+};
+var normalize = function(v) {
+  return mulScalar(v, 1 / vectorLength(v));
+};
+var vectorLength = function(v) {
+  return Math.sqrt(lengthSquared(v));
+};
+var lengthSquared = function(v) {
+  return dot(v, v);
+};
+var dot = function(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Cannot perform dot product on arrays of different length (${a.length} vs ${b.length})`);
+  }
+  return a.map((v, i) => {
+    return v * b[i];
+  }).reduce((acc, cur) => {
+    return acc + cur;
+  });
+};
+var translated = function(vec) {
+  return stride({
+    v: vec,
+    m: identity4(),
+    width: 4,
+    offset: 3,
+    colStride: 0
+  });
+};
+var translateX = (x) => {
+  return translated([x, 0, 0]);
+};
+var translateY = (y) => {
+  return translated([0, y, 0]);
+};
+var translateZ = (z) => {
+  return translated([0, 0, z]);
+};
+var mulScalar = function(v, s) {
+  return v.map((i) => {
+    return i * s;
+  });
+};
+function multiplyMatrixAndSvgInstruction(matrix, point) {
+  if (point.type === "C") {
+    return {
+      type: "C",
+      cp1: multiplyMatrix(matrix, point.cp1),
+      cp2: multiplyMatrix(matrix, point.cp2),
+      point: multiplyMatrix(matrix, point.point)
+    };
+  }
+  if (point.type === "Q") {
+    return {
+      type: "Q",
+      cp: multiplyMatrix(matrix, point.cp),
+      point: multiplyMatrix(matrix, point.point)
+    };
+  }
+  if (point.type === "M") {
+    return {
+      type: "M",
+      point: multiplyMatrix(matrix, point.point)
+    };
+  }
+  if (point.type === "L") {
+    return {
+      type: "L",
+      point: multiplyMatrix(matrix, point.point)
+    };
+  }
+  if (point.type === "Z") {
+    return {
+      type: "Z",
+      point: multiplyMatrix(matrix, point.point)
+    };
+  }
+  throw new Error("Unknown instruction type: " + JSON.stringify(point));
+}
+var multiplyMatrix = (matrix, point) => {
+  if (matrix.length !== 16 || point.length !== 4) {
+    throw new Error("Invalid matrix or vector dimension");
+  }
+  const result = [0, 0, 0, 0];
+  for (let i = 0;i < 4; i++) {
+    for (let j = 0;j < 4; j++) {
+      result[i] += matrix[i * 4 + j] * point[j];
+    }
+  }
+  return result;
+};
+// src/3d-svg.ts
+var serializeThreeDReducedInstruction = (instruction) => {
+  if (instruction.type === "M") {
+    return `M ${instruction.point[0]} ${instruction.point[1]}`;
+  }
+  if (instruction.type === "L") {
+    return `L ${instruction.point[0]} ${instruction.point[1]}`;
+  }
+  if (instruction.type === "C") {
+    return `C ${instruction.cp1[0]} ${instruction.cp1[1]} ${instruction.cp2[0]} ${instruction.cp2[1]} ${instruction.point[0]} ${instruction.point[1]}`;
+  }
+  if (instruction.type === "Q") {
+    return `Q ${instruction.cp[0]} ${instruction.cp[1]} ${instruction.point[0]} ${instruction.point[1]}`;
+  }
+  if (instruction.type === "Z") {
+    return "Z";
+  }
+  throw new Error("Unknown instruction type");
+};
+var threeDIntoSvgPath = (instructions) => instructions.map((instruction) => serializeThreeDReducedInstruction(instruction)).join(" ");
+// ../paths/dist/esm/index.mjs
+var length = {
+  a: 7,
+  A: 7,
+  C: 6,
+  c: 6,
+  H: 1,
+  h: 1,
+  L: 2,
+  l: 2,
+  M: 2,
+  m: 2,
+  Q: 4,
+  q: 4,
+  S: 4,
+  s: 4,
+  T: 2,
+  t: 2,
+  V: 1,
+  v: 1,
+  Z: 0,
+  z: 0
+};
+var chunkExact = (array, instruction) => {
+  const chunks = [];
+  const expectedSize = length[instruction];
+  if (array.length % expectedSize !== 0) {
+    throw new Error(`Expected number of arguments of SVG instruction "${instruction} ${array.join(" ")}" to be a multiple of ${expectedSize}`);
+  }
+  for (let i = 0;i < array.length; i += expectedSize) {
+    chunks.push(array.slice(i, i + expectedSize));
+  }
+  return chunks;
+};
+var makeInstructions = (arr, instruction, cb) => {
+  return chunkExact(arr, instruction).map((args) => {
+    return cb(args);
+  });
+};
+var segmentRegExp = /([astvzqmhlc])([^astvzqmhlc]*)/gi;
+var numberRegExp = /-?[0-9]*\.?[0-9]+(?:e[-+]?\d+)?/gi;
+var parseValues = (args, instructionType) => {
+  const numbers = args.match(numberRegExp);
+  if (!numbers) {
+    if (instructionType === "Z" || instructionType === "z") {
+      return [];
+    }
+    throw new Error(`Malformed path data: ${instructionType} was expected to have numbers afterwards`);
+  }
+  const expectedArguments = length[instructionType];
+  if (numbers.length % expectedArguments !== 0) {
+    throw new Error(`Malformed path data: ${instructionType} was expected to have a multiple of ${expectedArguments} numbers, but got "${instructionType} ${numbers.join(" ")} instead"`);
+  }
+  return numbers.map(Number);
+};
+var parsePath = (path) => {
+  if (!path) {
+    throw new Error("No path provided");
+  }
+  const segments = path.match(segmentRegExp);
+  if (!segments) {
+    throw new Error(`No path elements found in string ${path}`);
+  }
+  return segments.map((segmentString) => {
+    const command = segmentString.charAt(0);
+    const args = parseValues(segmentString.substring(1), command);
+    if (command === "M" && args.length > 2) {
+      const segmentsArray = [];
+      segmentsArray.push({
+        type: command,
+        x: args[0],
+        y: args[1]
+      });
+      segmentsArray.push(...makeInstructions(args.slice(2), "L", (numbers) => ({
+        type: "L",
+        x: numbers[0],
+        y: numbers[1]
+      })));
+      return segmentsArray;
+    }
+    if (command === "m" && args.length > 2) {
+      const segmentsArray = [];
+      segmentsArray.push({
+        type: command,
+        dx: args[0],
+        dy: args[1]
+      });
+      segmentsArray.push(...makeInstructions(args.slice(2), "l", (numbers) => ({
+        type: "l",
+        dx: numbers[0],
+        dy: numbers[1]
+      })));
+      return segmentsArray;
+    }
+    if (command === "Z" || command === "z") {
+      return [
+        {
+          type: "Z"
+        }
+      ];
+    }
+    if (command === "A") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        rx: numbers[0],
+        ry: numbers[1],
+        xAxisRotation: numbers[2],
+        largeArcFlag: numbers[3] === 1,
+        sweepFlag: numbers[4] === 1,
+        x: numbers[5],
+        y: numbers[6]
+      }));
+    }
+    if (command === "a") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        rx: numbers[0],
+        ry: numbers[1],
+        xAxisRotation: numbers[2],
+        largeArcFlag: numbers[3] === 1,
+        sweepFlag: numbers[4] === 1,
+        dx: numbers[5],
+        dy: numbers[6]
+      }));
+    }
+    if (command === "C") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        cp1x: numbers[0],
+        cp1y: numbers[1],
+        cp2x: numbers[2],
+        cp2y: numbers[3],
+        x: numbers[4],
+        y: numbers[5]
+      }));
+    }
+    if (command === "c") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        cp1dx: numbers[0],
+        cp1dy: numbers[1],
+        cp2dx: numbers[2],
+        cp2dy: numbers[3],
+        dx: numbers[4],
+        dy: numbers[5]
+      }));
+    }
+    if (command === "S") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        cpx: numbers[0],
+        cpy: numbers[1],
+        x: numbers[2],
+        y: numbers[3]
+      }));
+    }
+    if (command === "s") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        cpdx: numbers[0],
+        cpdy: numbers[1],
+        dx: numbers[2],
+        dy: numbers[3]
+      }));
+    }
+    if (command === "H") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        x: numbers[0]
+      }));
+    }
+    if (command === "h") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        dx: numbers[0]
+      }));
+    }
+    if (command === "V") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        y: numbers[0]
+      }));
+    }
+    if (command === "v") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        dy: numbers[0]
+      }));
+    }
+    if (command === "L") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        x: numbers[0],
+        y: numbers[1]
+      }));
+    }
+    if (command === "M") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        x: numbers[0],
+        y: numbers[1]
+      }));
+    }
+    if (command === "m") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        dx: numbers[0],
+        dy: numbers[1]
+      }));
+    }
+    if (command === "l") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        dx: numbers[0],
+        dy: numbers[1]
+      }));
+    }
+    if (command === "Q") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        cpx: numbers[0],
+        cpy: numbers[1],
+        x: numbers[2],
+        y: numbers[3]
+      }));
+    }
+    if (command === "q") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        cpdx: numbers[0],
+        cpdy: numbers[1],
+        dx: numbers[2],
+        dy: numbers[3]
+      }));
+    }
+    if (command === "T") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        x: numbers[0],
+        y: numbers[1]
+      }));
+    }
+    if (command === "t") {
+      return makeInstructions(args, command, (numbers) => ({
+        type: command,
+        dx: numbers[0],
+        dy: numbers[1]
+      }));
+    }
+    throw new Error(`Invalid path element ${segmentString}`);
+  }, []).flat(1);
+};
+var convertQToCInstruction = (instruction, startPoint) => {
+  const cp1x = startPoint.x + 2 / 3 * (instruction.cpx - startPoint.x);
+  const cp1y = startPoint.y + 2 / 3 * (instruction.cpy - startPoint.y);
+  const cp2x = instruction.x + 2 / 3 * (instruction.cpx - instruction.x);
+  const cp2y = instruction.y + 2 / 3 * (instruction.cpy - instruction.y);
+  return {
+    type: "C",
+    cp1x,
+    cp1y,
+    cp2x,
+    cp2y,
+    x: instruction.x,
+    y: instruction.y
+  };
+};
+var iterateOverSegments = ({
+  segments,
+  iterate
+}) => {
+  let x = 0;
+  let y = 0;
+  let initialX = 0;
+  let initialY = 0;
+  let cpX = null;
+  let cpY = null;
+  const newSegments = segments.map((s, i) => {
+    const newSeg = iterate({
+      segment: s,
+      x,
+      y,
+      prevSegment: segments[i - 1] ?? null,
+      initialX,
+      initialY,
+      cpX,
+      cpY
+    });
+    switch (s.type) {
+      case "M":
+        initialX = s.x;
+        initialY = s.y;
+        x = s.x;
+        y = s.y;
+        cpX = null;
+        cpY = null;
+        break;
+      case "Q":
+        x = s.x;
+        y = s.y;
+        cpX = s.cpx;
+        cpY = s.cpy;
+        break;
+      case "A":
+        x = s.x;
+        y = s.y;
+        cpX = null;
+        cpY = null;
+        break;
+      case "C":
+        x = s.x;
+        y = s.y;
+        cpX = s.cp2x;
+        cpY = s.cp2y;
+        break;
+      case "S":
+        x = s.x;
+        y = s.y;
+        cpX = s.cpx;
+        cpY = s.cpy;
+        break;
+      case "T":
+        if (cpX !== null && cpY !== null) {
+          cpX = x - (cpX - x);
+          cpY = y - (cpY - y);
+        }
+        x = s.x;
+        y = s.y;
+        break;
+      case "L":
+        x = s.x;
+        y = s.y;
+        cpX = null;
+        cpY = null;
+        break;
+      case "V":
+        y = s.y;
+        cpX = null;
+        cpY = null;
+        break;
+      case "H":
+        x = s.x;
+        cpX = null;
+        cpY = null;
+        break;
+      case "Z":
+        x = initialX;
+        y = initialY;
+        cpX = null;
+        cpY = null;
+        break;
+      default:
+        throw new Error(`Unexpected instruction ${s.type}`);
+    }
+    return newSeg;
+  });
+  return newSegments.flat(1);
+};
+var TAU = Math.PI * 2;
+function approximate_unit_arc(theta1, delta_theta) {
+  const alpha = 4 / 3 * Math.tan(delta_theta / 4);
+  const x1 = Math.cos(theta1);
+  const y1 = Math.sin(theta1);
+  const x2 = Math.cos(theta1 + delta_theta);
+  const y2 = Math.sin(theta1 + delta_theta);
+  return [
+    x1,
+    y1,
+    x1 - y1 * alpha,
+    y1 + x1 * alpha,
+    x2 + y2 * alpha,
+    y2 - x2 * alpha,
+    x2,
+    y2
+  ];
+}
+function unit_vector_angle(ux, uy, vx, vy) {
+  const sign = ux * vy - uy * vx < 0 ? -1 : 1;
+  let dot2 = ux * vx + uy * vy;
+  if (dot2 > 1) {
+    dot2 = 1;
+  }
+  if (dot2 < -1) {
+    dot2 = -1;
+  }
+  return sign * Math.acos(dot2);
+}
+function get_arc_center({
+  x1,
+  y1,
+  x2,
+  y2,
+  largeArcFlag,
+  sweepFlag,
+  rx,
+  ry,
+  sin_phi,
+  cos_phi
+}) {
+  const x1p = cos_phi * (x1 - x2) / 2 + sin_phi * (y1 - y2) / 2;
+  const y1p = -sin_phi * (x1 - x2) / 2 + cos_phi * (y1 - y2) / 2;
+  const rx_sq = rx * rx;
+  const ry_sq = ry * ry;
+  const x1p_sq = x1p * x1p;
+  const y1p_sq = y1p * y1p;
+  let radicant = rx_sq * ry_sq - rx_sq * y1p_sq - ry_sq * x1p_sq;
+  if (radicant < 0) {
+    radicant = 0;
+  }
+  radicant /= rx_sq * y1p_sq + ry_sq * x1p_sq;
+  radicant = Math.sqrt(radicant) * (largeArcFlag === sweepFlag ? -1 : 1);
+  const cxp = radicant * rx / ry * y1p;
+  const cyp = radicant * -ry / rx * x1p;
+  const cx = cos_phi * cxp - sin_phi * cyp + (x1 + x2) / 2;
+  const cy = sin_phi * cxp + cos_phi * cyp + (y1 + y2) / 2;
+  const v1x = (x1p - cxp) / rx;
+  const v1y = (y1p - cyp) / ry;
+  const v2x = (-x1p - cxp) / rx;
+  const v2y = (-y1p - cyp) / ry;
+  const theta1 = unit_vector_angle(1, 0, v1x, v1y);
+  let delta_theta = unit_vector_angle(v1x, v1y, v2x, v2y);
+  if (sweepFlag === false && delta_theta > 0) {
+    delta_theta -= TAU;
+  }
+  if (sweepFlag === true && delta_theta < 0) {
+    delta_theta += TAU;
+  }
+  return [cx, cy, theta1, delta_theta];
+}
+function arcToCircle({
+  x1,
+  y1,
+  x2,
+  y2,
+  largeArcFlag,
+  sweepFlag,
+  rx,
+  ry,
+  phi
+}) {
+  const sin_phi = Math.sin(phi * TAU / 360);
+  const cos_phi = Math.cos(phi * TAU / 360);
+  const x1p = cos_phi * (x1 - x2) / 2 + sin_phi * (y1 - y2) / 2;
+  const y1p = -sin_phi * (x1 - x2) / 2 + cos_phi * (y1 - y2) / 2;
+  if (x1p === 0 && y1p === 0) {
+    return [];
+  }
+  if (rx === 0 || ry === 0) {
+    return [];
+  }
+  rx = Math.abs(rx);
+  ry = Math.abs(ry);
+  const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+  if (lambda > 1) {
+    rx *= Math.sqrt(lambda);
+    ry *= Math.sqrt(lambda);
+  }
+  const cc = get_arc_center({
+    x1,
+    y1,
+    x2,
+    y2,
+    largeArcFlag,
+    sweepFlag,
+    rx,
+    ry,
+    sin_phi,
+    cos_phi
+  });
+  const result = [];
+  let theta1 = cc[2];
+  let delta_theta = cc[3];
+  const segments = Math.max(Math.ceil(Math.abs(delta_theta) / (TAU / 4)), 1);
+  delta_theta /= segments;
+  for (let i = 0;i < segments; i++) {
+    result.push(approximate_unit_arc(theta1, delta_theta));
+    theta1 += delta_theta;
+  }
+  return result.map((curve) => {
+    for (let i = 0;i < curve.length; i += 2) {
+      let x = curve[i + 0];
+      let y = curve[i + 1];
+      x *= rx;
+      y *= ry;
+      const xp = cos_phi * x - sin_phi * y;
+      const yp = sin_phi * x + cos_phi * y;
+      curve[i + 0] = xp + cc[0];
+      curve[i + 1] = yp + cc[1];
+    }
+    return curve;
+  });
+}
+var removeATSHVQInstructions = (segments) => {
+  return iterateOverSegments({
+    segments,
+    iterate: ({ segment, prevSegment, x, y, cpX, cpY }) => {
+      if (segment.type === "H") {
+        return [{ type: "L", x: segment.x, y }];
+      }
+      if (segment.type === "V") {
+        return [{ type: "L", x, y: segment.y }];
+      }
+      if (segment.type === "A") {
+        const nextX = segment.x;
+        const nextY = segment.y;
+        const new_segments = arcToCircle({
+          x1: x,
+          y1: y,
+          x2: nextX,
+          y2: nextY,
+          largeArcFlag: segment.largeArcFlag,
+          sweepFlag: segment.sweepFlag,
+          rx: segment.rx,
+          ry: segment.ry,
+          phi: segment.xAxisRotation
+        });
+        if (new_segments.length === 0) {
+          return [
+            {
+              type: "L",
+              x: segment.x,
+              y: segment.y
+            }
+          ];
+        }
+        const result = new_segments.map((_s) => {
+          return {
+            type: "C",
+            cp1x: _s[2],
+            cp1y: _s[3],
+            cp2x: _s[4],
+            cp2y: _s[5],
+            x: _s[6],
+            y: _s[7]
+          };
+        });
+        return result;
+      }
+      if (segment.type === "T") {
+        let prevControlX = 0;
+        let prevControlY = 0;
+        if (prevSegment && (prevSegment.type === "Q" || prevSegment.type === "T")) {
+          prevControlX = cpX;
+          prevControlY = cpY;
+        } else {
+          prevControlX = x;
+          prevControlY = y;
+        }
+        const vectorX = prevControlX - x;
+        const vectorY = prevControlY - y;
+        const newControlX = x - vectorX;
+        const newControlY = y - vectorY;
+        return [
+          convertQToCInstruction({
+            type: "Q",
+            cpx: newControlX,
+            cpy: newControlY,
+            x: segment.x,
+            y: segment.y
+          }, { x, y })
+        ];
+      }
+      if (segment.type === "S") {
+        let prevControlX = 0;
+        let prevControlY = 0;
+        if (prevSegment && prevSegment.type === "C") {
+          prevControlX = prevSegment.cp2x;
+          prevControlY = prevSegment.cp2y;
+        } else if (prevSegment && prevSegment.type === "S") {
+          prevControlX = prevSegment.cpx;
+          prevControlY = prevSegment.cpy;
+        } else {
+          prevControlX = x;
+          prevControlY = y;
+        }
+        const vectorX = prevControlX - x;
+        const vectorY = prevControlY - y;
+        const newControlX = x - vectorX;
+        const newControlY = y - vectorY;
+        return [
+          {
+            type: "C",
+            cp1x: newControlX,
+            cp1y: newControlY,
+            cp2x: segment.cpx,
+            cp2y: segment.cpy,
+            x: segment.x,
+            y: segment.y
+          }
+        ];
+      }
+      if (segment.type === "Q") {
+        return [convertQToCInstruction(segment, { x, y })];
+      }
+      return [segment];
+    }
+  });
+};
+var normalizeInstructions = (instructions) => {
+  const normalized = [];
+  let x = 0;
+  let y = 0;
+  let moveX = 0;
+  let moveY = 0;
+  for (let i = 0;i < instructions.length; i++) {
+    const instruction = instructions[i];
+    if (instruction.type === "M") {
+      moveX = instruction.x;
+      moveY = instruction.y;
+    } else if (instruction.type === "m") {
+      moveX += instruction.dx;
+      moveY += instruction.dy;
+    }
+    if (instruction.type === "A" || instruction.type === "C" || instruction.type === "L" || instruction.type === "M" || instruction.type === "Q" || instruction.type === "S" || instruction.type === "T") {
+      normalized.push(instruction);
+      x = instruction.x;
+      y = instruction.y;
+      continue;
+    }
+    if (instruction.type === "a" || instruction.type === "c" || instruction.type === "l" || instruction.type === "m" || instruction.type === "q" || instruction.type === "s" || instruction.type === "t") {
+      const currentX = x;
+      const currentY = y;
+      x += instruction.dx;
+      y += instruction.dy;
+      if (instruction.type === "a") {
+        normalized.push({
+          type: "A",
+          largeArcFlag: instruction.largeArcFlag,
+          rx: instruction.rx,
+          ry: instruction.ry,
+          sweepFlag: instruction.sweepFlag,
+          xAxisRotation: instruction.xAxisRotation,
+          x,
+          y
+        });
+        continue;
+      }
+      if (instruction.type === "c") {
+        normalized.push({
+          type: "C",
+          cp1x: instruction.cp1dx + currentX,
+          cp1y: instruction.cp1dy + currentY,
+          cp2x: instruction.cp2dx + currentX,
+          cp2y: instruction.cp2dy + currentY,
+          x,
+          y
+        });
+        continue;
+      }
+      if (instruction.type === "l") {
+        normalized.push({
+          type: "L",
+          x,
+          y
+        });
+        continue;
+      }
+      if (instruction.type === "m") {
+        normalized.push({
+          type: "M",
+          x,
+          y
+        });
+        continue;
+      }
+      if (instruction.type === "q") {
+        normalized.push({
+          type: "Q",
+          cpx: instruction.cpdx + currentX,
+          cpy: instruction.cpdy + currentY,
+          x,
+          y
+        });
+        continue;
+      }
+      if (instruction.type === "s") {
+        normalized.push({
+          type: "S",
+          cpx: instruction.cpdx + currentX,
+          cpy: instruction.cpdy + currentY,
+          x,
+          y
+        });
+        continue;
+      }
+      if (instruction.type === "t") {
+        normalized.push({
+          type: "T",
+          x,
+          y
+        });
+        continue;
+      }
+    }
+    if (instruction.type === "H") {
+      normalized.push(instruction);
+      x = instruction.x;
+      continue;
+    }
+    if (instruction.type === "V") {
+      normalized.push(instruction);
+      y = instruction.y;
+      continue;
+    }
+    if (instruction.type === "Z") {
+      normalized.push(instruction);
+      x = moveX;
+      y = moveY;
+      continue;
+    }
+    if (instruction.type === "h") {
+      x += instruction.dx;
+      normalized.push({
+        type: "H",
+        x
+      });
+      continue;
+    }
+    if (instruction.type === "v") {
+      y += instruction.dy;
+      normalized.push({
+        type: "V",
+        y
+      });
+      continue;
+    }
+    throw new Error("Unknown instruction type: " + instruction.type);
+  }
+  return normalized;
+};
+var reduceInstructions = (instruction) => {
+  const simplified = normalizeInstructions(instruction);
+  return removeATSHVQInstructions(simplified);
+};
+
+// src/fix-z.ts
+var turnInto3D = (instructions) => {
+  let lastMove = [0, 0, 0, 1];
+  const newInstructions = [];
+  const reduced = reduceInstructions(instructions);
+  for (let i = 0;i < reduced.length; i++) {
+    const instruction = reduced[i];
+    if (instruction.type === "Z") {
+      newInstructions.push({
+        type: "Z",
+        point: lastMove
+      });
+    } else if (instruction.type === "M") {
+      lastMove = [instruction.x, instruction.y, 0, 1];
+      newInstructions.push({
+        point: [instruction.x, instruction.y, 0, 1],
+        type: "M"
+      });
+    } else if (instruction.type === "L") {
+      newInstructions.push({
+        type: "L",
+        point: [instruction.x, instruction.y, 0, 1]
+      });
+    } else if (instruction.type === "C") {
+      newInstructions.push({
+        type: "C",
+        point: [instruction.x, instruction.y, 0, 1],
+        cp1: [instruction.cp1x, instruction.cp1y, 0, 1],
+        cp2: [instruction.cp2x, instruction.cp2y, 0, 1]
+      });
+    } else {
+      throw new Error("unknown");
+    }
+  }
+  return newInstructions;
+};
+
+// src/map-face.ts
+var translateSvgInstruction = (instruction, x, y, z) => {
+  if (instruction.type === "M") {
+    return {
+      type: "M",
+      point: [
+        instruction.point[0] + x,
+        instruction.point[1] + y,
+        instruction.point[2] + z,
+        instruction.point[3]
+      ]
+    };
+  }
+  if (instruction.type === "L") {
+    return {
+      type: "L",
+      point: [
+        instruction.point[0] + x,
+        instruction.point[1] + y,
+        instruction.point[2] + z,
+        instruction.point[3]
+      ]
+    };
+  }
+  if (instruction.type === "C") {
+    return {
+      type: "C",
+      point: [
+        instruction.point[0] + x,
+        instruction.point[1] + y,
+        instruction.point[2] + z,
+        instruction.point[3]
+      ],
+      cp1: [
+        instruction.cp1[0] + x,
+        instruction.cp1[1] + y,
+        instruction.cp1[2] + z,
+        instruction.cp1[3]
+      ],
+      cp2: [
+        instruction.cp2[0] + x,
+        instruction.cp2[1] + y,
+        instruction.cp2[2] + z,
+        instruction.cp2[3]
+      ]
+    };
+  }
+  if (instruction.type === "Q") {
+    return {
+      type: "Q",
+      point: [
+        instruction.point[0] + x,
+        instruction.point[1] + y,
+        instruction.point[2] + z,
+        instruction.point[3]
+      ],
+      cp: [
+        instruction.cp[0] + x,
+        instruction.cp[1] + y,
+        instruction.cp[2] + z,
+        instruction.cp[3]
+      ]
+    };
+  }
+  if (instruction.type === "Z") {
+    return {
+      type: "Z",
+      point: [
+        instruction.point[0] + x,
+        instruction.point[1] + y,
+        instruction.point[2] + z,
+        instruction.point[3]
+      ]
+    };
+  }
+  throw new Error("Unknown instruction type: " + JSON.stringify(instruction));
+};
+var transformPath = ({
+  path,
+  transformation
+}) => {
+  const parsed = parsePath(path);
+  const reduced = reduceInstructions(parsed);
+  const threeD = turnInto3D(reduced);
+  return threeDIntoSvgPath(threeD.map((p) => {
+    return multiplyMatrixAndSvgInstruction(transformation, p);
+  }));
+};
+var transformFace = (face, transformations) => {
+  return {
+    ...face,
+    points: face.points.map((p) => {
+      return transformations.reduce((acc, t) => {
+        return multiplyMatrixAndSvgInstruction(t, acc);
+      }, p);
+    }),
+    centerPoint: transformations.reduce((acc, t) => {
+      const result = multiplyMatrix(t, acc);
+      return result;
+    }, face.centerPoint)
+  };
+};
+
+// src/subdivide-instructions.ts
+var subdivideLOrMInstruction = (from, instruction) => {
+  if (instruction.type !== "L" && instruction.type !== "M") {
+    throw new Error("Expected L or M instruction");
+  }
+  const t = 0.5;
+  const q0 = [
+    (1 - t) * from[0] + t * instruction.point[0],
+    (1 - t) * from[1] + t * instruction.point[1],
+    (1 - t) * from[2] + t * instruction.point[2],
+    (1 - t) * from[3] + t * instruction.point[3]
+  ];
+  const curves = [
+    { type: instruction.type, point: q0 },
+    { type: instruction.type, point: instruction.point }
+  ];
+  return curves;
+};
+var subdivide3DCInstruction = (from, instruction) => {
+  if (instruction.type !== "C") {
+    throw new Error("Expected C instruction");
+  }
+  const t = 0.5;
+  const q0 = [
+    (1 - t) * from[0] + t * instruction.cp1[0],
+    (1 - t) * from[1] + t * instruction.cp1[1],
+    (1 - t) * from[2] + t * instruction.cp1[2],
+    (1 - t) * from[3] + t * instruction.cp1[3]
+  ];
+  const q1 = [
+    (1 - t) * instruction.cp1[0] + t * instruction.cp2[0],
+    (1 - t) * instruction.cp1[1] + t * instruction.cp2[1],
+    (1 - t) * instruction.cp1[2] + t * instruction.cp2[2],
+    (1 - t) * instruction.cp1[3] + t * instruction.cp2[3]
+  ];
+  const q2 = [
+    (1 - t) * instruction.cp2[0] + t * instruction.point[0],
+    (1 - t) * instruction.cp2[1] + t * instruction.point[1],
+    (1 - t) * instruction.cp2[2] + t * instruction.point[2],
+    (1 - t) * instruction.cp2[3] + t * instruction.point[3]
+  ];
+  const r0 = [
+    (1 - t) * q0[0] + t * q1[0],
+    (1 - t) * q0[1] + t * q1[1],
+    (1 - t) * q0[2] + t * q1[2],
+    (1 - t) * q0[3] + t * q1[3]
+  ];
+  const r1 = [
+    (1 - t) * q1[0] + t * q2[0],
+    (1 - t) * q1[1] + t * q2[1],
+    (1 - t) * q1[2] + t * q2[2],
+    (1 - t) * q1[3] + t * q2[3]
+  ];
+  const s0 = [
+    (1 - t) * r0[0] + t * r1[0],
+    (1 - t) * r0[1] + t * r1[1],
+    (1 - t) * r0[2] + t * r1[2],
+    (1 - t) * r0[3] + t * r1[3]
+  ];
+  const curves = [
+    { type: "C", point: s0, cp1: q0, cp2: r0 },
+    { type: "C", point: instruction.point, cp1: r1, cp2: q2 }
+  ];
+  return curves;
+};
+var subdivideQInstruction = (from, instruction) => {
+  if (instruction.type !== "Q") {
+    throw new Error("Expected Q instruction");
+  }
+  const t = 0.5;
+  const q0 = [
+    (1 - t) * from[0] + t * instruction.cp[0],
+    (1 - t) * from[1] + t * instruction.cp[1],
+    (1 - t) * from[2] + t * instruction.cp[2],
+    (1 - t) * from[3] + t * instruction.cp[3]
+  ];
+  const q1 = [
+    (1 - t) * instruction.cp[0] + t * instruction.point[0],
+    (1 - t) * instruction.cp[1] + t * instruction.point[1],
+    (1 - t) * instruction.cp[2] + t * instruction.point[2],
+    (1 - t) * instruction.cp[3] + t * instruction.point[3]
+  ];
+  const r0 = [
+    (1 - t) * q0[0] + t * q1[0],
+    (1 - t) * q0[1] + t * q1[1],
+    (1 - t) * q0[2] + t * q1[2],
+    (1 - t) * q0[3] + t * q1[3]
+  ];
+  const newInstructions = [
+    { type: "Q", point: r0, cp: q0 },
+    { type: "Q", point: instruction.point, cp: q1 }
+  ];
+  return newInstructions;
+};
+var subdivideInstruction = (from, instruction) => {
+  if (instruction.type === "C") {
+    return subdivide3DCInstruction(from, instruction);
+  }
+  if (instruction.type === "L" || instruction.type === "M") {
+    return subdivideLOrMInstruction(from, instruction);
+  }
+  if (instruction.type === "Q") {
+    return subdivideQInstruction(from, instruction);
+  }
+  if (instruction.type === "Z") {
+    return [instruction];
+  }
+  throw new Error("Cannot subdivide instruction");
+};
+var subdivideInstructions = (instructions) => {
+  const newInstructions = [];
+  instructions.forEach((instruction, i) => {
+    if (instruction.type === "M") {
+      newInstructions.push(instruction);
+      return;
+    }
+    if (instruction.type === "Z") {
+      newInstructions.push(instruction);
+      return;
+    }
+    const previousInstruction = instructions[i - 1];
+    const subdivided = subdivideInstruction(previousInstruction.point, instruction);
+    newInstructions.push(...subdivided);
+  });
+  return newInstructions;
+};
+
+// src/extrude-element.ts
+var inverseInstruction = (instruction, comingFrom) => {
+  if (instruction.type === "M") {
+    return {
+      type: "M",
+      point: comingFrom
+    };
+  }
+  if (instruction.type === "L") {
+    return {
+      type: "L",
+      point: comingFrom
+    };
+  }
+  if (instruction.type === "C") {
+    return {
+      type: "C",
+      point: comingFrom,
+      cp1: instruction.cp2,
+      cp2: instruction.cp1
+    };
+  }
+  if (instruction.type === "Q") {
+    return {
+      type: "Q",
+      point: comingFrom,
+      cp: instruction.cp
+    };
+  }
+  if (instruction.type === "Z") {
+    return {
+      type: "L",
+      point: comingFrom
+    };
+  }
+  throw new Error("Unknown instruction type");
+};
+var extrudeElement = ({
+  depth,
+  sideColor,
+  points,
+  crispEdges
+}) => {
+  const threeD = turnInto3D(points);
+  const instructions = {
+    centerPoint: [0, 0, 0, 1],
+    points: subdivideInstructions(subdivideInstructions(subdivideInstructions(threeD))),
+    color: "black",
+    crispEdges
+  };
+  const unscaledBackFace = transformFace(instructions, [translateZ(depth / 2)]);
+  const inbetween = unscaledBackFace.points.map((t, i) => {
+    const nextInstruction = i === unscaledBackFace.points.length - 1 ? unscaledBackFace.points[0] : unscaledBackFace.points[i + 1];
+    const currentPoint = t.point;
+    const nextPoint = nextInstruction.point;
+    const movingOver = [
+      nextPoint[0],
+      nextPoint[1],
+      nextPoint[2] - depth,
+      nextPoint[3]
+    ];
+    const translatedInstruction = translateSvgInstruction(inverseInstruction(nextInstruction, currentPoint), 0, 0, -depth);
+    const newInstructions = [
+      {
+        type: "M",
+        point: currentPoint
+      },
+      nextInstruction,
+      nextInstruction.type === "Z" ? {
+        type: "M",
+        point: nextInstruction.point
+      } : null,
+      {
+        type: "L",
+        point: movingOver
+      },
+      translatedInstruction,
+      {
+        type: "L",
+        point: currentPoint
+      }
+    ].filter(truthy);
+    return {
+      points: newInstructions,
+      color: sideColor,
+      centerPoint: [0, 0, 0, 1],
+      crispEdges: true
+    };
+  });
+  return inbetween;
+};
+var extrudeAndTransformElement = (options) => {
+  const inbetween = extrudeElement(options);
+  return inbetween.map((face) => ({
+    ...transformFace(face, [options.transformations])
+  }));
+};
+export {
+  translateZ,
+  translateY,
+  translateX,
+  transformPath,
+  threeDIntoSvgPath,
+  scaled,
+  scaleY,
+  scaleX,
+  rotateZ,
+  rotateY,
+  rotateX,
+  reduceMatrices,
+  makeMatrix3dTransform,
+  interpolateMatrix4d,
+  extrudeElement,
+  extrudeAndTransformElement,
+  aroundCenterPoint
+};