@a-company/atelier 0.17.3 → 0.18.0

package/dist/{chunk-LL2EJ6YE.js → chunk-H4A6HRMY.js}

@@ -153,6 +153,30 @@ var ShadowSchema = z6.object({
   offsetX: z6.number().optional(),
   offsetY: z6.number().optional()
 });
+var BlendModeSchema = z7.enum([
+  "normal",
+  "multiply",
+  "screen",
+  "overlay",
+  "darken",
+  "lighten",
+  "color-dodge",
+  "color-burn",
+  "hard-light",
+  "soft-light",
+  "difference",
+  "exclusion",
+  "hue",
+  "saturation",
+  "color",
+  "luminosity"
+]);
+var MotionPathSchema = z7.object({
+  points: z7.array(PathPointSchema).min(2, "Motion path must have at least 2 points"),
+  closed: z7.boolean().optional(),
+  autoRotate: z7.boolean().optional(),
+  autoRotateOffset: z7.number().optional()
+});
 var ShapeVisualSchema = z7.object({
   type: z7.literal("shape"),
   shape: ShapeSchema,
@@ -196,7 +220,10 @@ var LayerSchema = z7.object({
   rotation: z7.number().optional(),
   scale: z7.object({ x: z7.number(), y: z7.number() }).optional(),
   visible: z7.boolean().optional(),
-  shadow: ShadowSchema.optional()
+  shadow: ShadowSchema.optional(),
+  blendMode: BlendModeSchema.optional(),
+  motionPath: MotionPathSchema.optional(),
+  clipPath: ShapeSchema.optional()
 });
 var AnimatablePropertySchema = z8.enum([
   "frame.x",
@@ -220,7 +247,12 @@ var AnimatablePropertySchema = z8.enum([
   "shadow.color",
   "shadow.blur",
   "shadow.offsetX",
-  "shadow.offsetY"
+  "shadow.offsetY",
+  "motionPath.progress",
+  "visual.fill.angle",
+  "visual.fill.center.x",
+  "visual.fill.center.y",
+  "visual.fill.radius"
 ]);
 var FrameRangeSchema = z8.tuple([
   z8.number().int().min(0, "Frame start must be >= 0"),
@@ -240,11 +272,19 @@ var DeltaSchema = z8.object({
   description: z8.string().optional(),
   tags: z8.array(z8.string()).optional()
 });
+var AudioSchema = z9.object({
+  src: z9.string().min(1, "Audio src is required"),
+  offset: z9.number().min(0, "Audio offset must be non-negative").optional(),
+  volume: z9.number().min(0).max(1, "Audio volume must be 0\u20131").optional(),
+  loop: z9.boolean().optional(),
+  startFrame: z9.number().int().min(0, "Audio startFrame must be a non-negative integer").optional()
+});
 var StateSchema = z9.object({
   description: z9.string().optional(),
   tags: z9.array(z9.string()).optional(),
   duration: z9.number().int().positive("State duration must be a positive integer (frames)"),
-  deltas: z9.array(DeltaSchema)
+  deltas: z9.array(DeltaSchema),
+  audio: AudioSchema.optional()
 });
 var PresetDeltaSchema = z10.object({
   property: AnimatablePropertySchema,
@@ -264,7 +304,7 @@ var VariableSchema = z11.object({
   default: z11.unknown().optional(),
   description: z11.string().optional()
 });
-var AssetTypeSchema = z12.enum(["image", "svg", "font", "animation"]);
+var AssetTypeSchema = z12.enum(["image", "svg", "font", "animation", "audio"]);
 var AssetSchema = z12.object({
   type: AssetTypeSchema,
   src: z12.string().min(1, "Asset src is required"),
@@ -426,6 +466,75 @@ function lerpRgba(a, b, t) {
     a: lerp(a.a, b.a, t)
   };
 }
+function bezierSegmentLength(p0x, p0y, c0x, c0y, c1x, c1y, p1x, p1y, steps = 32) {
+  let length = 0;
+  let prevX = p0x;
+  let prevY = p0y;
+  for (let i = 1; i <= steps; i++) {
+    const t = i / steps;
+    const mt = 1 - t;
+    const x = mt * mt * mt * p0x + 3 * mt * mt * t * c0x + 3 * mt * t * t * c1x + t * t * t * p1x;
+    const y = mt * mt * mt * p0y + 3 * mt * mt * t * c0y + 3 * mt * t * t * c1y + t * t * t * p1y;
+    const dx = x - prevX;
+    const dy = y - prevY;
+    length += Math.sqrt(dx * dx + dy * dy);
+    prevX = x;
+    prevY = y;
+  }
+  return length;
+}
+function evalBezier(p0x, p0y, c0x, c0y, c1x, c1y, p1x, p1y, t) {
+  const mt = 1 - t;
+  const x = mt * mt * mt * p0x + 3 * mt * mt * t * c0x + 3 * mt * t * t * c1x + t * t * t * p1x;
+  const y = mt * mt * mt * p0y + 3 * mt * mt * t * c0y + 3 * mt * t * t * c1y + t * t * t * p1y;
+  const tx = 3 * mt * mt * (c0x - p0x) + 6 * mt * t * (c1x - c0x) + 3 * t * t * (p1x - c1x);
+  const ty = 3 * mt * mt * (c0y - p0y) + 6 * mt * t * (c1y - c0y) + 3 * t * t * (p1y - c1y);
+  const angle = Math.atan2(ty, tx) * (180 / Math.PI);
+  return { x, y, angle };
+}
+function buildSegmentLengths(points, closed) {
+  const segCount = closed ? points.length : points.length - 1;
+  const lengths = [];
+  for (let i = 0; i < segCount; i++) {
+    const p0 = points[i];
+    const p1 = points[(i + 1) % points.length];
+    const c0x = p0.x + (p0.out?.x ?? 0);
+    const c0y = p0.y + (p0.out?.y ?? 0);
+    const c1x = p1.x + (p1.in?.x ?? 0);
+    const c1y = p1.y + (p1.in?.y ?? 0);
+    lengths.push(bezierSegmentLength(p0.x, p0.y, c0x, c0y, c1x, c1y, p1.x, p1.y));
+  }
+  return lengths;
+}
+function evaluatePathAtProgress(points, progress, closed = false) {
+  if (points.length < 2) {
+    return { x: points[0]?.x ?? 0, y: points[0]?.y ?? 0, angle: 0 };
+  }
+  const t = Math.max(0, Math.min(1, progress));
+  const segLengths = buildSegmentLengths(points, closed);
+  const totalLength = segLengths.reduce((a, b) => a + b, 0);
+  if (totalLength === 0) {
+    return { x: points[0].x, y: points[0].y, angle: 0 };
+  }
+  const targetLength = t * totalLength;
+  let accumulated = 0;
+  for (let i = 0; i < segLengths.length; i++) {
+    const segLen = segLengths[i];
+    if (accumulated + segLen >= targetLength || i === segLengths.length - 1) {
+      const segProgress = segLen === 0 ? 0 : (targetLength - accumulated) / segLen;
+      const p0 = points[i];
+      const p1 = points[(i + 1) % points.length];
+      const c0x = p0.x + (p0.out?.x ?? 0);
+      const c0y = p0.y + (p0.out?.y ?? 0);
+      const c1x = p1.x + (p1.in?.x ?? 0);
+      const c1y = p1.y + (p1.in?.y ?? 0);
+      return evalBezier(p0.x, p0.y, c0x, c0y, c1x, c1y, p1.x, p1.y, segProgress);
+    }
+    accumulated += segLen;
+  }
+  const last = points[points.length - 1];
+  return { x: last.x, y: last.y, angle: 0 };
+}
 
 // ../core/dist/index.js
 function resolveEasing(easing) {
@@ -460,6 +569,261 @@ function resolveEasing(easing) {
       return linear;
   }
 }
+function tokenize(expr) {
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch >= "0" && ch <= "9" || ch === ".") {
+      let num = "";
+      while (i < expr.length && (expr[i] >= "0" && expr[i] <= "9" || expr[i] === ".")) {
+        num += expr[i++];
+      }
+      tokens.push({ type: "number", value: num });
+      continue;
+    }
+    if (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_") {
+      let id = "";
+      while (i < expr.length && (expr[i] >= "a" && expr[i] <= "z" || expr[i] >= "A" && expr[i] <= "Z" || expr[i] >= "0" && expr[i] <= "9" || expr[i] === "_")) {
+        id += expr[i++];
+      }
+      tokens.push({ type: "ident", value: id });
+      continue;
+    }
+    if (ch === "<" || ch === ">" || ch === "!" || ch === "=") {
+      if (i + 1 < expr.length && expr[i + 1] === "=") {
+        tokens.push({ type: "compare", value: ch + "=" });
+        i += 2;
+        continue;
+      }
+      if (ch === "<" || ch === ">") {
+        tokens.push({ type: "compare", value: ch });
+        i++;
+        continue;
+      }
+    }
+    if (ch === "*" && i + 1 < expr.length && expr[i + 1] === "*") {
+      tokens.push({ type: "op", value: "**" });
+      i += 2;
+      continue;
+    }
+    if (ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%") {
+      tokens.push({ type: "op", value: ch });
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      tokens.push({ type: "lparen", value: "(" });
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ type: "rparen", value: ")" });
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ type: "comma", value: "," });
+      i++;
+      continue;
+    }
+    if (ch === "?") {
+      tokens.push({ type: "question", value: "?" });
+      i++;
+      continue;
+    }
+    if (ch === ":") {
+      tokens.push({ type: "colon", value: ":" });
+      i++;
+      continue;
+    }
+    throw new Error(`Expression: unexpected character '${ch}' at position ${i}`);
+  }
+  tokens.push({ type: "eof", value: "" });
+  return tokens;
+}
+var CONSTANTS = {
+  pi: Math.PI,
+  PI: Math.PI,
+  tau: Math.PI * 2,
+  TAU: Math.PI * 2,
+  e: Math.E,
+  E: Math.E
+};
+var FUNCTIONS = {
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan,
+  abs: Math.abs,
+  floor: Math.floor,
+  ceil: Math.ceil,
+  round: Math.round,
+  sqrt: Math.sqrt,
+  sign: Math.sign,
+  log: Math.log,
+  min: (...args) => Math.min(...args),
+  max: (...args) => Math.max(...args),
+  pow: (a, b) => Math.pow(a, b),
+  clamp: (v, lo, hi) => Math.min(Math.max(v, lo), hi)
+};
+var Parser = class {
+  tokens;
+  pos = 0;
+  ctx;
+  constructor(tokens, ctx) {
+    this.tokens = tokens;
+    this.ctx = ctx;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  consume(expectedType) {
+    const tok = this.tokens[this.pos++];
+    if (expectedType && tok.type !== expectedType) {
+      throw new Error(`Expression: expected ${expectedType} but got ${tok.type} '${tok.value}'`);
+    }
+    return tok;
+  }
+  /** Entry: ternary (lowest precedence) */
+  parse() {
+    const result = this.parseTernary();
+    if (this.peek().type !== "eof") {
+      throw new Error(`Expression: unexpected token '${this.peek().value}'`);
+    }
+    return result;
+  }
+  /** ternary: comparison ? expr : expr */
+  parseTernary() {
+    const condition = this.parseComparison();
+    if (this.peek().type === "question") {
+      this.consume();
+      const trueVal = this.parseTernary();
+      this.consume("colon");
+      const falseVal = this.parseTernary();
+      return condition ? trueVal : falseVal;
+    }
+    return condition;
+  }
+  /** comparison: additive (< | > | <= | >= | == | !=) additive */
+  parseComparison() {
+    let left = this.parseAdditive();
+    while (this.peek().type === "compare") {
+      const op = this.consume().value;
+      const right = this.parseAdditive();
+      switch (op) {
+        case "<":
+          left = left < right ? 1 : 0;
+          break;
+        case ">":
+          left = left > right ? 1 : 0;
+          break;
+        case "<=":
+          left = left <= right ? 1 : 0;
+          break;
+        case ">=":
+          left = left >= right ? 1 : 0;
+          break;
+        case "==":
+          left = left === right ? 1 : 0;
+          break;
+        case "!=":
+          left = left !== right ? 1 : 0;
+          break;
+      }
+    }
+    return left;
+  }
+  /** additive: multiplicative (('+' | '-') multiplicative)* */
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    while (this.peek().type === "op" && (this.peek().value === "+" || this.peek().value === "-")) {
+      const op = this.consume().value;
+      const right = this.parseMultiplicative();
+      left = op === "+" ? left + right : left - right;
+    }
+    return left;
+  }
+  /** multiplicative: power (('*' | '/' | '%') power)* */
+  parseMultiplicative() {
+    let left = this.parsePower();
+    while (this.peek().type === "op" && (this.peek().value === "*" || this.peek().value === "/" || this.peek().value === "%")) {
+      const op = this.consume().value;
+      const right = this.parsePower();
+      if (op === "*") left = left * right;
+      else if (op === "/") left = right !== 0 ? left / right : 0;
+      else left = left % right;
+    }
+    return left;
+  }
+  /** power: unary ('**' unary)* (right-associative) */
+  parsePower() {
+    const base = this.parseUnary();
+    if (this.peek().type === "op" && this.peek().value === "**") {
+      this.consume();
+      const exp = this.parsePower();
+      return Math.pow(base, exp);
+    }
+    return base;
+  }
+  /** unary: ('-' | '+') unary | primary */
+  parseUnary() {
+    if (this.peek().type === "op" && (this.peek().value === "-" || this.peek().value === "+")) {
+      const op = this.consume().value;
+      const val = this.parseUnary();
+      return op === "-" ? -val : val;
+    }
+    return this.parsePrimary();
+  }
+  /** primary: number | ident | function(args) | '(' expr ')' */
+  parsePrimary() {
+    const tok = this.peek();
+    if (tok.type === "number") {
+      this.consume();
+      return parseFloat(tok.value);
+    }
+    if (tok.type === "ident") {
+      this.consume();
+      const name = tok.value;
+      if (this.peek().type === "lparen") {
+        this.consume();
+        const args = [];
+        if (this.peek().type !== "rparen") {
+          args.push(this.parseTernary());
+          while (this.peek().type === "comma") {
+            this.consume();
+            args.push(this.parseTernary());
+          }
+        }
+        this.consume("rparen");
+        const fn = FUNCTIONS[name];
+        if (!fn) throw new Error(`Expression: unknown function '${name}'`);
+        return fn(...args);
+      }
+      if (name in CONSTANTS) return CONSTANTS[name];
+      if (name in this.ctx) return this.ctx[name];
+      throw new Error(`Expression: unknown variable '${name}'`);
+    }
+    if (tok.type === "lparen") {
+      this.consume();
+      const val = this.parseTernary();
+      this.consume("rparen");
+      return val;
+    }
+    throw new Error(`Expression: unexpected token '${tok.value}'`);
+  }
+};
+function isExpression(value) {
+  return typeof value === "object" && value !== null && "expr" in value && typeof value.expr === "string";
+}
+function evaluateExpression(expr, ctx) {
+  const tokens = tokenize(expr);
+  const parser = new Parser(tokens, ctx);
+  return parser.parse();
+}
 function isFrameInRange(frame, range) {
   return frame >= range[0] && frame <= range[1];
 }
@@ -475,7 +839,15 @@ function resolveDeltaValue(delta, frame) {
   const progress = computeProgress(frame, delta.range);
   const easingFn = resolveEasing(delta.easing);
   const easedProgress = easingFn(progress);
-  return interpolateValue(delta.from, delta.to, easedProgress);
+  const exprCtx = {
+    t: easedProgress,
+    progress,
+    frame,
+    duration: delta.range[1] - delta.range[0]
+  };
+  const from = isExpression(delta.from) ? evaluateExpression(delta.from.expr, exprCtx) : delta.from;
+  const to = isExpression(delta.to) ? evaluateExpression(delta.to.expr, exprCtx) : delta.to;
+  return interpolateValue(from, to, easedProgress);
 }
 function interpolateValue(from, to, t) {
   if (typeof from === "number" && typeof to === "number") {
@@ -503,7 +875,16 @@ function resolvePropertyAtFrame(deltas, frame) {
       }
     }
   }
-  return lastCompleted?.to;
+  if (!lastCompleted) return void 0;
+  if (isExpression(lastCompleted.to)) {
+    return evaluateExpression(lastCompleted.to.expr, {
+      t: 1,
+      progress: 1,
+      frame,
+      duration: lastCompleted.range[1] - lastCompleted.range[0]
+    });
+  }
+  return lastCompleted.to;
 }
 function resolveFrame(doc, stateName, frame) {
   const state = doc.states[stateName];
@@ -844,11 +1225,23 @@ function buildEffectiveLayer(resolved, parentWidth, parentHeight) {
   const { layer, computedProperties } = resolved;
   const cp = computedProperties;
   const hasShadow = layer.shadow || cp["shadow.blur"] !== void 0 || cp["shadow.color"] !== void 0;
+  let x = resolveUnit(cp["frame.x"] ?? layer.frame.x, parentWidth);
+  let y = resolveUnit(cp["frame.y"] ?? layer.frame.y, parentHeight);
+  let motionPathAngle = 0;
+  const motionProgress = cp["motionPath.progress"];
+  if (motionProgress !== void 0 && layer.motionPath && layer.motionPath.points.length >= 2) {
+    const pos = evaluatePathAtProgress(layer.motionPath.points, motionProgress, layer.motionPath.closed);
+    x = pos.x;
+    y = pos.y;
+    if (layer.motionPath.autoRotate) {
+      motionPathAngle = pos.angle + (layer.motionPath.autoRotateOffset ?? 0);
+    }
+  }
   return {
     layer,
     visual: buildEffectiveVisual(layer.visual, cp),
-    x: resolveUnit(cp["frame.x"] ?? layer.frame.x, parentWidth),
-    y: resolveUnit(cp["frame.y"] ?? layer.frame.y, parentHeight),
+    x,
+    y,
     width: resolveUnit(cp["bounds.width"] ?? layer.bounds.width, parentWidth),
     height: resolveUnit(cp["bounds.height"] ?? layer.bounds.height, parentHeight),
     opacity: cp["opacity"] ?? layer.opacity ?? 1,
@@ -862,19 +1255,42 @@ function buildEffectiveLayer(resolved, parentWidth, parentHeight) {
       blur: cp["shadow.blur"] ?? layer.shadow?.blur ?? 0,
       offsetX: cp["shadow.offsetX"] ?? layer.shadow?.offsetX ?? 0,
       offsetY: cp["shadow.offsetY"] ?? layer.shadow?.offsetY ?? 0
-    } : void 0
+    } : void 0,
+    blendMode: layer.blendMode ?? "normal",
+    motionPathAngle
   };
 }
 function buildEffectiveVisual(visual, cp) {
-  const hasVisualOverride = cp["visual.fill.color"] !== void 0 || cp["visual.stroke.color"] !== void 0 || cp["visual.stroke.width"] !== void 0 || cp["visual.stroke.start"] !== void 0 || cp["visual.stroke.end"] !== void 0 || cp["visual.shape.cornerRadius"] !== void 0 || cp["visual.style.fontSize"] !== void 0 || cp["visual.style.color"] !== void 0;
+  const hasVisualOverride = cp["visual.fill.color"] !== void 0 || cp["visual.fill.angle"] !== void 0 || cp["visual.fill.center.x"] !== void 0 || cp["visual.fill.center.y"] !== void 0 || cp["visual.fill.radius"] !== void 0 || cp["visual.stroke.color"] !== void 0 || cp["visual.stroke.width"] !== void 0 || cp["visual.stroke.start"] !== void 0 || cp["visual.stroke.end"] !== void 0 || cp["visual.shape.cornerRadius"] !== void 0 || cp["visual.style.fontSize"] !== void 0 || cp["visual.style.color"] !== void 0;
   if (!hasVisualOverride) return visual;
   if (visual.type === "shape") {
     const v = { ...visual };
     if (cp["visual.shape.cornerRadius"] !== void 0 && v.shape.type === "rect") {
       v.shape = { ...v.shape, cornerRadius: cp["visual.shape.cornerRadius"] };
     }
-    if (v.fill && cp["visual.fill.color"] !== void 0) {
-      v.fill = v.fill.type === "solid" ? { ...v.fill, color: cp["visual.fill.color"] } : v.fill;
+    if (v.fill) {
+      if (cp["visual.fill.color"] !== void 0 && v.fill.type === "solid") {
+        v.fill = { ...v.fill, color: cp["visual.fill.color"] };
+      }
+      if (cp["visual.fill.angle"] !== void 0 && v.fill.type === "linear-gradient") {
+        v.fill = { ...v.fill, angle: cp["visual.fill.angle"] };
+      }
+      if (v.fill.type === "radial-gradient") {
+        const cx = cp["visual.fill.center.x"];
+        const cy = cp["visual.fill.center.y"];
+        const r = cp["visual.fill.radius"];
+        if (cx !== void 0 || cy !== void 0 || r !== void 0) {
+          const f = v.fill;
+          v.fill = {
+            ...f,
+            center: {
+              x: cx !== void 0 ? cx : f.center.x,
+              y: cy !== void 0 ? cy : f.center.y
+            },
+            radius: r !== void 0 ? r : f.radius
+          };
+        }
+      }
     }
     if (v.stroke) {
       const strokeColor = cp["visual.stroke.color"] ?? v.stroke.color;
@@ -1088,13 +1504,17 @@ function renderFrame(ctx, resolvedFrame, doc, imageCache) {
     ctx.save();
     applyAncestorTransforms(ctx, layer.id, effMap, doc);
     ctx.globalAlpha = eff.opacity;
+    if (eff.blendMode !== "normal") {
+      ctx.globalCompositeOperation = blendModeToComposite(eff.blendMode);
+    }
     ctx.translate(eff.x, eff.y);
     const anchorPixelX = eff.anchorX * eff.width;
     const anchorPixelY = eff.anchorY * eff.height;
-    if (eff.rotation !== 0 || eff.scaleX !== 1 || eff.scaleY !== 1) {
+    const totalRotation = eff.rotation + eff.motionPathAngle;
+    if (totalRotation !== 0 || eff.scaleX !== 1 || eff.scaleY !== 1) {
       ctx.translate(anchorPixelX, anchorPixelY);
-      if (eff.rotation !== 0) {
-        ctx.rotate(eff.rotation * Math.PI / 180);
+      if (totalRotation !== 0) {
+        ctx.rotate(totalRotation * Math.PI / 180);
       }
       if (eff.scaleX !== 1 || eff.scaleY !== 1) {
         ctx.scale(eff.scaleX, eff.scaleY);
@@ -1107,6 +1527,9 @@ function renderFrame(ctx, resolvedFrame, doc, imageCache) {
       ctx.shadowOffsetX = eff.shadow.offsetX;
       ctx.shadowOffsetY = eff.shadow.offsetY;
     }
+    if (layer.clipPath) {
+      applyClipPath(ctx, layer.clipPath, eff.width, eff.height);
+    }
     switch (layer.visual.type) {
       case "shape":
         renderShape(ctx, eff);
@@ -1126,6 +1549,68 @@ function renderFrame(ctx, resolvedFrame, doc, imageCache) {
     ctx.restore();
   }
 }
+function applyClipPath(ctx, shape, width, height) {
+  ctx.beginPath();
+  switch (shape.type) {
+    case "rect":
+      if (shape.cornerRadius && ctx.roundRect) {
+        ctx.roundRect(0, 0, width, height, shape.cornerRadius);
+      } else {
+        ctx.moveTo(0, 0);
+        ctx.lineTo(width, 0);
+        ctx.lineTo(width, height);
+        ctx.lineTo(0, height);
+        ctx.closePath();
+      }
+      break;
+    case "ellipse":
+      ctx.ellipse(width / 2, height / 2, width / 2, height / 2, 0, 0, Math.PI * 2);
+      break;
+    case "path":
+      if (shape.points.length >= 2) {
+        ctx.moveTo(shape.points[0].x, shape.points[0].y);
+        for (let i = 1; i < shape.points.length; i++) {
+          const prev = shape.points[i - 1];
+          const curr = shape.points[i];
+          if (prev.out && curr.in) {
+            ctx.bezierCurveTo(
+              prev.x + prev.out.x,
+              prev.y + prev.out.y,
+              curr.x + curr.in.x,
+              curr.y + curr.in.y,
+              curr.x,
+              curr.y
+            );
+          } else {
+            ctx.lineTo(curr.x, curr.y);
+          }
+        }
+        if (shape.closed) ctx.closePath();
+      }
+      break;
+  }
+  ctx.clip();
+}
+function blendModeToComposite(mode) {
+  const map = {
+    "multiply": "multiply",
+    "screen": "screen",
+    "overlay": "overlay",
+    "darken": "darken",
+    "lighten": "lighten",
+    "color-dodge": "color-dodge",
+    "color-burn": "color-burn",
+    "hard-light": "hard-light",
+    "soft-light": "soft-light",
+    "difference": "difference",
+    "exclusion": "exclusion",
+    "hue": "hue",
+    "saturation": "saturation",
+    "color": "color",
+    "luminosity": "luminosity"
+  };
+  return map[mode] ?? "source-over";
+}
 function applyAncestorTransforms(ctx, layerId, effMap, doc) {
   const chain = [];
   const layer = doc.layers.find((l) => l.id === layerId);
@@ -1462,4 +1947,4 @@ export {
   renderDocument,
   renderCommand
 };
-//# sourceMappingURL=chunk-LL2EJ6YE.js.map
+//# sourceMappingURL=chunk-H4A6HRMY.js.map