@remotion/svg-3d-engine 4.0.528 → 4.0.529

package/dist/esm/index.mjs

@@ -258,764 +258,8 @@ var serializeThreeDReducedInstruction = (instruction) => {
   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 arcNumberRegExp = /[\s,]*([-+]?(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:e[-+]?\d+)?)/iy;
-var arcFlagRegExp = /[\s,]*([01])/y;
-var parseValues = (args, instructionType) => {
-  let numbers;
-  if (instructionType === "A" || instructionType === "a") {
-    numbers = [];
-    let match;
-    let lastIndex = 0;
-    do {
-      const regExp = numbers.length % 7 === 3 || numbers.length % 7 === 4 ? arcFlagRegExp : arcNumberRegExp;
-      regExp.lastIndex = lastIndex;
-      match = regExp.exec(args);
-      if (match) {
-        numbers.push(match[1]);
-        lastIndex = regExp.lastIndex;
-      }
-    } while (match);
-    const rest = args.slice(lastIndex);
-    if (!/^[\s,]*$/.test(rest)) {
-      throw new Error(`Malformed path data: ${instructionType} has an invalid value at "${rest.trim()}"`);
-    }
-  } else {
-    numbers = args.match(numberRegExp);
-  }
-  if (!numbers || numbers.length === 0) {
-    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 = x + instruction.dx;
-      moveY = y + 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
+import { reduceInstructions } from "@remotion/paths";
 var turnInto3D = (instructions) => {
   let lastMove = [0, 0, 0, 1];
   const newInstructions = [];
@@ -1053,6 +297,7 @@ var turnInto3D = (instructions) => {
 };
 
 // src/map-face.ts
+import { parsePath, reduceInstructions as reduceInstructions2 } from "@remotion/paths";
 var translateSvgInstruction = (instruction, x, y, z) => {
   if (instruction.type === "M") {
     return {
@@ -1134,7 +379,7 @@ var transformPath = ({
   transformation
 }) => {
   const parsed = parsePath(path);
-  const reduced = reduceInstructions(parsed);
+  const reduced = reduceInstructions2(parsed);
   const threeD = turnInto3D(reduced);
   return threeDIntoSvgPath(threeD.map((p) => {
     return multiplyMatrixAndSvgInstruction(transformation, p);

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@remotion/svg-3d-engine",
 	"dependencies": {
-		"@remotion/paths": "4.0.528"
+		"@remotion/paths": "4.0.529"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.528",
+		"@remotion/eslint-config-internal": "4.0.529",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},
@@ -24,7 +24,7 @@
 			"require": "./dist/cjs/index.js"
 		}
 	},
-	"version": "4.0.528",
+	"version": "4.0.529",
 	"repository": {
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/svg-3d-engine"
 	},