@pixerate/editor 0.113.0 → 0.114.0

package/THIRD_PARTY_NOTICES.md

@@ -12,6 +12,7 @@ reproduced at the end of this file. Paths are relative to each source repository
 
 © 2026 ArtCraft Team and the CadCraft contributors.
 
+- `crates/engine/src/snap/tracking.rs` (`polar_angles`, `MAX_ACQUIRED`, `DWELL`, `Tracker::toggle` / `hover` / `paths` / `find`: acquired points sending alignment paths and an endpoint's extension, then a crossing of two paths, a path crossing the drawing, or the nearest path) and its direct distance entry → `vectorPolarAngles`, `vectorTrackingPaths` and tracking in `snapFrom` in `packages/core/src/vector/snap.ts`, and `acquireTrackingPoint`, `placePenPoint` and `addPathByDimensions` in `packages/core/src/vector/controller.ts`; parallel and apparent-intersection tracking are not ported; test cases re-expressed → `packages/core/tests/vector-tracking.test.ts`
 - `crates/engine/src/spatial.rs` (an R-tree over object bounds used by picking, window selection and snaps, built only above 256 objects, reused while the content is the same and rebuilt from unchanged parts after an edit, returning candidates in draw order for the same exact tests a scan runs) → the approach of `VectorRTree`, `vectorSpatialIndex` and `vectorNodesNear` in `packages/core/src/vector/spatial.ts`, used by `hitTestVectorNodes`, marquee selection and snapping to segments; the tree is our own sort-tile-recursive packing (cadcraft uses the `rstar` crate), and unchanged parts are reused by caching each node's bounds by node object; parity tests are our own → `packages/core/tests/vector-spatial.test.ts`
 - `crates/constraints/src/lm.rs` (damped, weighted minimum-norm Gauss–Newton with a numerical Jacobian, `Δx = −W⁻¹Jᵀ(JW⁻¹Jᵀ + μI)⁻¹r`; Gaussian elimination with partial pivoting; Householder QR with column pivoting on row- and column-balanced matrices for rank and null space), `lib.rs` (constraints grouped into connected components, edited geometry weighted to move least, conflicts located by leaving each constraint out, new constraints refused when they do not raise the Jacobian's rank or when a Fix locks parameters already determined), `residual.rs` (the residual forms: point–point, point on line or circle, collinear, parallel, perpendicular, horizontal / vertical, tangent line–circle and circle–circle, symmetric, equal, distance along an axis, angle with its orientation from the starting geometry, radius, diameter), `dof.rs` (remaining degrees of freedom per component, per object by the null space restricted to its parameters, statuses), `auto.rs` (`infer`: coincident points, concentric and tangent circles, horizontal / vertical lines, collinear, connected perpendicular and parallel pairs, equal lengths and radii, in that order) and `expr.rs` (named expressions with `+ - * /`, parentheses and `pi`, evaluated lazily with cycle detection) → `packages/core/src/vector/constraints/lm.ts`, `solve.ts`, `auto.ts` and `expr.ts`; entities and handles became our anchors with stable ids, segments, handles, G1 / G2 joints at anchors and round closed paths, angle-type residuals are scaled to lengths so one tolerance fits all rows, and a solve after every edit weights what changed since the last solve; test cases re-expressed → `packages/core/tests/vector-constraints.test.ts`
 - `crates/geom/src/region.rs` (`enclosing_loop`, `boundary_at_gap` and `build_gap`: curves split at their crossings, gaps between loose ends bridged to the nearest other loose end within reach, a ray from the point meeting edges in order and the face to the left of each traced by always taking the sharpest left turn until a counter-clockwise loop round the point comes back; islands — pieces nested in that face — as holes; `interior_point`) → `PlanarMap.regionAt` and `closeGaps` in `packages/core/src/canvas/pathops/planar.ts` and `fillRegion` in `packages/core/src/vector/controller.ts`; islands are taken per face (the smallest face of another piece around each outer boundary) rather than every group inside the loop, so islands inside islands are not holes; test cases re-expressed → `packages/core/tests/canvas-pathfinder.test.ts`
@@ -31,6 +32,7 @@ reproduced at the end of this file. Paths are relative to each source repository
 
 © 2026 ArtCraft Team and the DeckCraft contributors.
 
+- `crates/engine/src/connect.rs` (`sites`, `nearest_site`, `reroute` dropping glue to shapes that no longer exist, `set_glue` turning a plain line into a connector) → `packages/core/src/vector/connectors.ts` (`vectorConnectionSites`, `vectorConnectorTargetAt`, `rerouteVectorConnectors`) and `setConnector` in `packages/core/src/vector/controller.ts`; test cases our own → `packages/core/tests/vector-connectors.test.ts`
 - `crates/geom/src/morph.rs` (`contours`: every segment as a cubic, lines with handles at thirds; `align`: contours paired in order, one without a partner meeting a point at the same place relative to the other outline's box (`place`); `turn`: a closed contour restarted at another anchor; `match_pair`: the closed side of a pair turned, open paired with closed) → `subpathToMorphContour`, `turnMorphContour` and `correspondMorphContours` in `packages/core/src/vector/blend.ts`; anchors are inserted by arc length rather than split evenly per curve, and the winding of closed shapes follows their areas (effectcraft) instead of a cost comparison; test cases re-expressed → `packages/core/tests/vector-blend.test.ts`
 - `crates/model/src/anim.rs` (`ANIMATIONS`: PowerPoint's preset IDs per effect class) and `crates/pptx/src/read/timing.rs` (`collect` and `animations`: effects found by their `presetClass`, the target from `p:spTgt`, `nodeType` as on click, with previous or after previous) → `fromPptxAnimation` in `packages/core/src/animation-editor/pptx.ts`; effects map onto the editor's commands, and each click starts a shot
 - `crates/anim/src/morph.rs` (`morph_pairs`: shapes paired in passes, each used once — by name, then by matching content, then by kind — and unpaired shapes faded out) → `matchMotionNodes` and the `match` command in `packages/core/src/animation-editor/match.ts` and `compile.ts`; the passes are name, then id with the groups' own ids taken out, then kind in stacking order, and paired groups pair their own parts
@@ -74,6 +76,7 @@ reproduced at the end of this file. Paths are relative to each source repository
 - `crates/engine/src/snap.rs` (`spacings` / `equal_spacing` / `spacing_guides`: centred between neighbours, repeating the gap of the pair before or after, gap labels; threshold in screen pixels divided by the zoom) → `VectorSnapTargets.snapRect` in `packages/core/src/vector/snap.ts`; its equal-spacing cases re-expressed → `packages/core/tests/vector-snap.test.ts`
 - `crates/layout/src/lib.rs` (`layout_frame`, `distribute`, `main_offsets`, `fit_hug_text`, `enforce_limits`, `item_baseline`, `resize_child`, `grid_place`, `resolve_tracks`, `track_content`, `grid_geometry`, `layout_grid`, `apply_constraints`, `layout_page`, `layout_up`, `coherent_sizing`, `clamp_size`) → `packages/core/src/canvas/autoLayout.ts`
 - `crates/layout/src/{tests.rs,behaviour_tests.rs,nested_tests.rs,content_align_tests.rs}` (test cases re-expressed) → `packages/core/tests/canvas-auto-layout.test.ts`
+- `crates/layout/src/lib.rs` (`apply_constraints`: a child keeps its left / right / both margins, its offset from the centre, or scales with its frame, per axis) → `vectorFrameChildMatrix` in `packages/core/src/vector/frames.ts`, applied when a vector frame is resized (`bakeFrame` in `packages/core/src/vector/geometry.ts`), with text keeping its font size; test cases our own → `packages/core/tests/vector-frames.test.ts`
 - `crates/doc/src/styles.rs` (`Collection`, `Mode`, `Variable`, `VariableValue`, `Variables::resolve`, `default_mode`, `current_mode`, `find_mode`, `scopes_for`, `normalize_scopes`, `in_scope`) → `packages/core/src/tokens/types.ts`, `packages/core/src/tokens/model.ts`
 - `crates/engine/src/cmd/variables.rs` (`alias_target` cycle check, `forget_variables` alias detaching, `remove_mode`, `move_mode`, `rename_collection`, `delete_collection`, `field_scope`) → `packages/core/src/tokens/model.ts`, `packages/core/src/canvas/tokenBindings.ts`
 - `crates/doc/src/lib.rs` (`modes_for`: modes inherited down the tree) → `getEffectiveTokenModes` in `packages/core/src/canvas/tokenBindings.ts`
@@ -189,6 +192,7 @@ GridCraft. Apache POI is © The Apache Software Foundation, licensed under the A
 - `crates/raster/src/lib.rs` (`Surface`: a sparse map of 256 px tiles behind shared pointers with a default pixel, copy-on-write writes that share untouched tiles, uniform tiles stored once, `prune` of tiles equal to the default, `content_bounds`, `translated`, region read / write) → `TiledSurface`, `SurfaceDraft`, `readRegion`, `writeRegion`, `fillRect`, `contentBounds` and `translateSurface` in `packages/core/src/raster/surface.ts`; 8-bit RGBA / 1-byte mask tiles instead of photocraft's pixel formats
 - `crates/paint/src/lib.rs` (`TIP_SHAPE`, `tip_shape`, `soft_exp`, `tip_falloff`, `tip_reach`, `dab_coverage`: Photoshop's measured round tip; `smooth`), `crates/paint/src/dynamics.rs` (`PathWalker`: the first point as a dab, then one every spacing × diameter along the path; `base_diameter` and the Transfer pressure-to-opacity rule) and `crates/paint/src/render.rs` (`rasterize_into` for the round computed tip with a 4 × 4 sub-pixel grid below 3 px; `CoverageMap::accumulate`: flow building up towards each dab's opacity ceiling; `composite`: one composite at the stroke opacity over the pre-stroke pixels, the selection multiplying coverage, the eraser and lock transparency) → `packages/core/src/paint/brush.ts`; only the computed round tip, pressure size and opacity, and simple smoothing are ported (no sampled tips, jitter, texture, dual brush, wet edges or dithering); brush test cases re-expressed → `packages/core/tests/image-layers-paint.test.ts`
 - `crates/paint/src/mixer.rs` (`MixerSettings`, `MixerState`, `PICKUP_RATE`, `apply_mixer_stroke`: per dab, sample the canvas under the footprint by coverage and alpha, move the pickup colour towards it by the pick-up rate × wet, mix the reservoir (weight amount × (1 − mix·wet)) with the pickup (weight mix·wet), deposit at flow × the total weight, drain the reservoir by 8 % × (1 − load) per dab; `load` / `clean`) → `MixerStroke`, `normalizeMixer`, `loadMixer` and `cleanMixer` in `packages/core/src/paint/mixer.ts`; our additions are the pigment mixing model for pickup, paint and deposit, load / clean after each stroke, and tiles in place of photocraft's surfaces (no Sample All Layers or Transfer › Wetness yet); mixer test cases re-expressed → `packages/core/tests/paint-mixer.test.ts`
+- `crates/cms/src` (`math.rs`, `curve.rs`, `clut.rs`, `pipeline.rs`, `profile.rs`, `write.rs`, `transform.rs`, `gamut.rs`, `lut3d.rs`, `builtin.rs`, `synth.rs`: the ICC v2 / v4 reader for matrix/TRC, grey TRC and `mft1` / `mft2` / `mAB ` / `mBA ` profiles, the v4.3 writer, the float stage pipeline with its optimiser, tetrahedral CLUT evaluation, transforms with per-code shaper tables, x^(1/4)-indexed output tables and 33³ / 17⁴ device links, white fixing, absolute-colorimetric media-white scaling, black point compensation after Adobe's published algorithm, soft-proof chains, gamut checks, 3D display tables, the built-in profiles from published primaries and the synthetic coated CMYK model with its Neugebauer printing model, damped least-squares separation with GCR and gamut-boundary compression) → `packages/core/src/cms`; single-threaded, the CMYK profile generated on first use (a 17³ B2A grid and a coarser gamut-boundary sample instead of photocraft's shipped 21³ profile), no `.cube` / LUT files; test cases re-expressed → `packages/core/tests/cms.test.ts`
 - `crates/paint/src/retouch.rs` (the two retouching stroke shapes: accumulate a stroke's coverage and composite paint taken from the pre-stroke state through it, or run dabs in order over a working copy; `Smudge`), `crates/algo/src/retouch.rs` (`tone_curve`, `dodge_burn` with Protect Tones on luma and gamut compression towards luma, `saturation`, `sponge` with vibrance), `crates/algo/src/poisson.rs` (`solve_membrane`: cascadic multigrid with over-relaxed Gauss-Seidel sweeps; `seamless_clone` after Pérez, Gangnet and Blake 2003; `membrane_fill`), `crates/algo/src/inpaint.rs` (`best_offset`: the ring-matched proximity search with a coarse grid and a refinement, a hole summed-area table and a mild distance penalty) and `crates/engine/src/retouch_cmds.rs` (`clone_stamp`, `healing_brush`'s padded coverage and Dirichlet ring, `spot_heal_surface`'s dilated fill domain and heal mask, `tone_stroke`'s tone-once-from-the-original under capped coverage, `per_dab`, the aligned / non-aligned offset) → `packages/core/src/paint/retouch.ts` and `heal.ts`; on 8-bit tiles, translation-only clone sources (no scale, rotation or Clone Source panel), Spot Healing with proximity match or a smooth fill (no content-aware synthesis yet), the Smudge on our `SmudgeTip` and no Blur, Sharpen or History Brush yet; test cases re-expressed → `packages/core/tests/image-retouch.test.ts`
 - `crates/paint/src/procedural.rs` (`smooth`, the tileable `value_noise` on a wrapped lattice, `fbm` doubling the lattice per octave, the `Paper` and `Canvas` pattern styles: fractal noise with per-pixel grain, and an over / under weave of sine threads) and `crates/paint/src/rng.rs` (counter-based randomness: every value a pure hash of seed, index and stream, so a stroke's jitter replays however its points are chunked) → `TileableNoise`, `hash2`, `rand01` in `packages/core/src/paint-editor/noise.ts` and the `cold-pressed` and `canvas` grain patterns in `packages/core/src/paint-editor/paper.ts`; on 32-bit integer hashes instead of SplitMix64, with unequal lattice periods per axis for fibres and streaks; the other paper patterns, the paper library and the grain response of dry media are our own. The paint editor's `PenDabWalker` extends our port of `crates/paint/src/dynamics.rs`'s `PathWalker` (above) with tilt, barrel rotation and velocity
 - `crates/paint/src/symmetry.rs` (`SymmetryMode` vertical / horizontal / dual / diagonal, `PresetSymmetry::directions` with each mode's initial axis and the rotation added, `reflected_passes`: reflection about the centre along each axis plus the point reflection for dual, `segments`: the axes clipped to the document without assuming the centre is inside, and the coordinate limit) → `symmetryAxisAngles`, `symmetryCopies` and `symmetryAxisSegments` in `packages/core/src/paint-editor/guides.ts`, as affine maps of the stroke's points so one stroke paints every copy; our additions are the kaleidoscope (n rotations and the mirrored segments) and perspective guides; symmetry test cases re-expressed → `packages/core/tests/paint-editor-guides.test.ts`
@@ -271,6 +275,7 @@ GridCraft. Apache POI is © The Apache Software Foundation, licensed under the A
 
 © 2026 ArtCraft Team and the WordCraft contributors.
 
+- `crates/doc/src/connector.rs` (`sites` at the middles of the sides through the shape's turn, `site_point`, `nearest_site`, `connector_segs` straight / elbow / curved, `reroute_group`) → `packages/core/src/vector/connectors.ts`, elbows and curves leaving along the sides' normals with a gap, plus `auto` sides; test cases re-expressed → `packages/core/tests/vector-connectors.test.ts`
 - `crates/engine/src/cmd/mailings.rs` (`parse_csv` delimiter auto-detection and blank-row skipping, `table_from_rows`, `header_split` padding / truncation and record caps, `address_map` field aliases) → `packages/core/src/grammar/data-source.ts`
 - `crates/formats/src/sheet.rs` (`field_names`: blank headers as `Column N`, repeated headers numbered) → `packages/core/src/grammar/data-source.ts`
 - `crates/engine/src/cmd/mailings.rs` (`condition` numeric-or-text comparison with `= <> < > <= >=`, `finish` one copy per record with SKIPIF and a merge cap) → `packages/core/src/grammar/variables.ts`, `packages/core/src/grammar/merge.ts`

package/dist/animation-editor/index.cjs

@@ -1,17 +1,17 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
+var _chunk26PGXHY7cjs = require('../chunk-26PGXHY7.cjs');
 
 
 
-var _chunkJLYX4V57cjs = require('../chunk-JLYX4V57.cjs');
 
 
 
 
+var _chunkWAJQKWQUcjs = require('../chunk-WAJQKWQU.cjs');
 
 
 
-var _chunkWAJQKWQUcjs = require('../chunk-WAJQKWQU.cjs');
 
 
 
@@ -30,7 +30,8 @@ var _chunkWAJQKWQUcjs = require('../chunk-WAJQKWQU.cjs');
 
 
 
-var _chunkW3GXSUSQcjs = require('../chunk-W3GXSUSQ.cjs');
+
+var _chunkLPLCWZTMcjs = require('../chunk-LPLCWZTM.cjs');
 
 
 
@@ -558,7 +559,7 @@ function smoothMotionTimes(points, start, duration, pacing = "even") {
 function motionTextLayout(nodes, id) {
   const group = _optionalChain([nodes, 'access', _5 => _5.get, 'call', _6 => _6(id), 'optionalAccess', _7 => _7.node]);
   if (!group || group.type !== "group") return null;
-  const letters = _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, group).map((p) => ({ id: p.id, b: _optionalChain([nodes, 'access', _8 => _8.get, 'call', _9 => _9(p.id), 'optionalAccess', _10 => _10.bounds]) })).filter((l) => !!l.b && l.b.width + l.b.height > 0);
+  const letters = _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, group).map((p) => ({ id: p.id, b: _optionalChain([nodes, 'access', _8 => _8.get, 'call', _9 => _9(p.id), 'optionalAccess', _10 => _10.bounds]) })).filter((l) => !!l.b && l.b.width + l.b.height > 0);
   if (!letters.length) return null;
   const lines = [];
   for (const l of [...letters].sort((a, c) => a.b.y + a.b.height / 2 - (c.b.y + c.b.height / 2))) {
@@ -643,21 +644,21 @@ function indexMotionNodes(nodes) {
   const out = /* @__PURE__ */ new Map();
   const walk = (list, parentWorld, ancestors) => {
     for (const node of list) {
-      const local = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, node);
-      const bounds = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, node, parentWorld);
+      const local = _chunkLPLCWZTMcjs.vectorNodeBounds.call(void 0, node);
+      const bounds = _chunkLPLCWZTMcjs.vectorNodeBounds.call(void 0, node, parentWorld);
       const center = local ? { x: local.x + local.width / 2, y: local.y + local.height / 2 } : { x: 0, y: 0 };
       if (!out.has(node.id)) out.set(node.id, { node, ancestors, parentWorld, center, bounds, box: local });
-      if (node.type === "group") walk(node.children, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, node), parentWorld), [...ancestors, node.id]);
+      if (node.type === "group") walk(node.children, _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _chunkLPLCWZTMcjs.nodeMatrix.call(void 0, node), parentWorld), [...ancestors, node.id]);
     }
   };
-  walk(nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX, []);
+  walk(nodes, _chunkLPLCWZTMcjs.IDENTITY_MATRIX, []);
   indexCache.set(nodes, out);
   return out;
 }
 var solid = (paint) => typeof paint === "string" && paint !== "none" ? paint : void 0;
 function firstPaint(node, key) {
   if (node.type === "path") return solid(node[key]);
-  for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) {
+  for (const p of _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node)) {
     const s = solid(p[key]);
     if (s) return s;
   }
@@ -665,7 +666,7 @@ function firstPaint(node, key) {
 }
 function strokeReach(node) {
   let reach = 0;
-  for (const p of node.type === "path" ? [node] : _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) {
+  for (const p of node.type === "path" ? [node] : _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node)) {
     if (p.stroke == null || p.stroke === "none") continue;
     const width = _nullishCoalesce(p.strokeWidth, () => ( 1));
     reach = Math.max(reach, p.strokeAlign === "outside" ? width : p.strokeAlign === "inside" ? 0 : width / 2);
@@ -735,7 +736,7 @@ function motionRestValue(entry, property, artwork) {
     case "stroke":
       return _nullishCoalesce((node && firstPaint(node, property)), () => ( "transparent"));
     case "strokeWidth": {
-      const path = _optionalChain([node, 'optionalAccess', _13 => _13.type]) === "path" ? node : node ? _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)[0] : void 0;
+      const path = _optionalChain([node, 'optionalAccess', _13 => _13.type]) === "path" ? node : node ? _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node)[0] : void 0;
       return _nullishCoalesce(_optionalChain([path, 'optionalAccess', _14 => _14.strokeWidth]), () => ( 1));
     }
     case "shape":
@@ -846,12 +847,12 @@ function resolveMotionCamera(camera, scene) {
   const r = camera;
   return { x: r.x, y: r.y, width: r.width, height: r.height };
 }
-function motionPathLength(node, parentWorld = _chunkW3GXSUSQcjs.IDENTITY_MATRIX) {
+function motionPathLength(node, parentWorld = _chunkLPLCWZTMcjs.IDENTITY_MATRIX) {
   let longest = 0;
-  const paths = node.type === "path" ? [node] : _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node);
+  const paths = node.type === "path" ? [node] : _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node);
   for (const p of paths) {
     try {
-      longest = Math.max(longest, _chunkXGD3FSNCcjs.bezierPathLength.call(void 0, _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, p, parentWorld, { effects: false })));
+      longest = Math.max(longest, _chunkXGD3FSNCcjs.bezierPathLength.call(void 0, _chunkLPLCWZTMcjs.vectorPathWorldBezier.call(void 0, p, parentWorld, { effects: false })));
     } catch (e2) {
     }
   }
@@ -1104,12 +1105,12 @@ function compileMotionScene(scene) {
       const order2 = _nullishCoalesce(o.order, () => ( "together"));
       const pace = _nullishCoalesce(o.pace, () => ( "time"));
       if (order2 === "together" && pace === "time") return null;
-      const paths = entry.node.type === "path" ? [entry.node] : _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, entry.node);
+      const paths = entry.node.type === "path" ? [entry.node] : _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, entry.node);
       let list = paths.map((p) => {
         const at = nodes.get(p.id);
         let first = { x: 0, y: 0 };
         try {
-          const m = _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, p, _nullishCoalesce(_optionalChain([at, 'optionalAccess', _41 => _41.parentWorld]), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX)), { effects: false })[0];
+          const m = _chunkLPLCWZTMcjs.vectorPathWorldBezier.call(void 0, p, _nullishCoalesce(_optionalChain([at, 'optionalAccess', _41 => _41.parentWorld]), () => ( _chunkLPLCWZTMcjs.IDENTITY_MATRIX)), { effects: false })[0];
           if (m && m.type === "M") first = { x: m.x, y: m.y };
         } catch (e3) {
         }
@@ -1221,17 +1222,17 @@ function compileMotionScene(scene) {
         let dx = _nullishCoalesce(_optionalChain([command3, 'access', _44 => _44.by, 'optionalAccess', _45 => _45.x]), () => ( 0));
         let dy = _nullishCoalesce(_optionalChain([command3, 'access', _46 => _46.by, 'optionalAccess', _47 => _47.y]), () => ( 0));
         if (command3.to) {
-          const inv = _chunkW3GXSUSQcjs.invertMatrix.call(void 0, entry.parentWorld);
-          const target = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, inv, command3.to);
+          const inv = _chunkLPLCWZTMcjs.invertMatrix.call(void 0, entry.parentWorld);
+          const target = _chunkLPLCWZTMcjs.applyMatrix.call(void 0, inv, command3.to);
           dx = target.x - (entry.center.x + num2("x"));
           dy = target.y - (entry.center.y + num2("y"));
         }
         if (_optionalChain([command3, 'access', _48 => _48.via, 'optionalAccess', _49 => _49.length])) {
-          const inv = _chunkW3GXSUSQcjs.invertMatrix.call(void 0, entry.parentWorld);
+          const inv = _chunkLPLCWZTMcjs.invertMatrix.call(void 0, entry.parentWorld);
           const x0 = num2("x");
           const y0 = num2("y");
           const add = command3.blend === "add";
-          const offsets = [{ x: 0, y: 0 }, ...command3.via.map((p) => _chunkW3GXSUSQcjs.applyMatrix.call(void 0, inv, p)).map((p) => ({ x: p.x - entry.center.x - x0, y: p.y - entry.center.y - y0 })), { x: dx, y: dy }];
+          const offsets = [{ x: 0, y: 0 }, ...command3.via.map((p) => _chunkLPLCWZTMcjs.applyMatrix.call(void 0, inv, p)).map((p) => ({ x: p.x - entry.center.x - x0, y: p.y - entry.center.y - y0 })), { x: dx, y: dy }];
           const times = smoothMotionTimes(offsets, start, end - start, _nullishCoalesce(command3.pacing, () => ( "even")));
           for (const axis of ["x", "y"]) {
             const base = add ? 0 : axis === "x" ? x0 : y0;
@@ -1366,6 +1367,7 @@ function fadePaint(paint, alpha) {
 }
 function mapPaths(node, fn) {
   if (node.type === "path") return fn(node);
+  if (node.type === "text" || node.type === "instance") return node;
   return { ...node, children: node.children.map((c) => mapPaths(c, fn)) };
 }
 var morphCache = /* @__PURE__ */ new WeakMap();
@@ -1373,13 +1375,13 @@ function morphBetween(a, b) {
   let inner = morphCache.get(a);
   if (!inner) morphCache.set(a, inner = /* @__PURE__ */ new WeakMap());
   let morph = inner.get(b);
-  if (!morph) inner.set(b, morph = _chunkJLYX4V57cjs.createVectorMorph.call(void 0, a, b, { id: a.id }));
+  if (!morph) inner.set(b, morph = _chunk26PGXHY7cjs.createVectorMorph.call(void 0, a, b, { id: a.id }));
   return morph;
 }
 function shapeIn(entry, shape) {
   if (shape === entry) return entry.node;
-  const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, shape.node), shape.parentWorld), _chunkW3GXSUSQcjs.invertMatrix.call(void 0, entry.parentWorld));
-  return { ...shape.node, ..._chunkW3GXSUSQcjs.isIdentityMatrix.call(void 0, m) ? { transform: void 0 } : { transform: m } };
+  const m = _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _chunkLPLCWZTMcjs.nodeMatrix.call(void 0, shape.node), shape.parentWorld), _chunkLPLCWZTMcjs.invertMatrix.call(void 0, entry.parentWorld));
+  return { ...shape.node, ..._chunkLPLCWZTMcjs.isIdentityMatrix.call(void 0, m) ? { transform: void 0 } : { transform: m } };
 }
 function shapeAt(entry, timeline, nodes, time) {
   const track = timeline.tracks.get(motionTrackKey(entry.node.id, "shape"));
@@ -1399,7 +1401,7 @@ function shapeAt(entry, timeline, nodes, time) {
 function motionFollowRoute(entry, path) {
   if (!path || path.node.type !== "path") return null;
   try {
-    return _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, path.node, path.parentWorld, { effects: false }), _chunkW3GXSUSQcjs.invertMatrix.call(void 0, entry.parentWorld));
+    return _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, _chunkLPLCWZTMcjs.vectorPathWorldBezier.call(void 0, path.node, path.parentWorld, { effects: false }), _chunkLPLCWZTMcjs.invertMatrix.call(void 0, entry.parentWorld));
   } catch (e4) {
     return null;
   }
@@ -1433,9 +1435,9 @@ function motionNodeOffset(entry, timeline, time, nodes = indexMotionNodes([entry
   const scaleX = read("scaleX", 1);
   const scaleY = read("scaleY", 1);
   const c = entry.center;
-  let matrix = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.scaleMatrix.call(void 0, scaleX, scaleY, c), _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, rotation, c)), _chunkW3GXSUSQcjs.translateMatrix.call(void 0, dx, dy));
+  let matrix = _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _chunkLPLCWZTMcjs.scaleMatrix.call(void 0, scaleX, scaleY, c), _chunkLPLCWZTMcjs.rotateMatrix.call(void 0, rotation, c)), _chunkLPLCWZTMcjs.translateMatrix.call(void 0, dx, dy));
   const along = follow ? followAt(entry, timeline, nodes, time) : null;
-  if (along) matrix = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, matrix, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.translateMatrix.call(void 0, -c.x, -c.y), _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, along.angle)), _chunkW3GXSUSQcjs.translateMatrix.call(void 0, along.x, along.y)));
+  if (along) matrix = _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, matrix, _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _chunkLPLCWZTMcjs.translateMatrix.call(void 0, -c.x, -c.y), _chunkLPLCWZTMcjs.rotateMatrix.call(void 0, along.angle)), _chunkLPLCWZTMcjs.translateMatrix.call(void 0, along.x, along.y)));
   return { matrix, dx, dy, rotation, scaleX, scaleY, follow: along };
 }
 function motionNodeClips(id, timeline, time) {
@@ -1502,7 +1504,7 @@ function motionFrameAt(scene, time, options = {}) {
           const start = Math.min(1, Math.max(0, typeof drawStart === "number" ? drawStart : 0));
           const end = Math.min(1, Math.max(0, typeof drawEnd === "number" ? drawEnd : 1));
           if (start > 0 || end < 1) {
-            const trim = _chunkW3GXSUSQcjs.createVectorEffect.call(void 0, "trim", MOTION_DRAW_EFFECT_ID, { start: tidy(start * 100), end: tidy(end * 100) });
+            const trim = _chunkLPLCWZTMcjs.createVectorEffect.call(void 0, "trim", MOTION_DRAW_EFFECT_ID, { start: tidy(start * 100), end: tidy(end * 100) });
             p = { ...p, effects: [trim, ...(_nullishCoalesce(p.effects, () => ( []))).filter((e) => e.id !== MOTION_DRAW_EFFECT_ID)] };
           }
         }
@@ -1516,8 +1518,8 @@ function motionFrameAt(scene, time, options = {}) {
       if (o >= 1) delete out.opacity;
     }
     const offset = options.offsets === false ? null : motionNodeOffset(entry, timeline, time, nodes);
-    if (offset && !_chunkW3GXSUSQcjs.isIdentityMatrix.call(void 0, offset.matrix)) {
-      const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, out), offset.matrix).map(tidy);
+    if (offset && !_chunkLPLCWZTMcjs.isIdentityMatrix.call(void 0, offset.matrix)) {
+      const m = _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _chunkLPLCWZTMcjs.nodeMatrix.call(void 0, out), offset.matrix).map(tidy);
       out = { ...out, transform: m };
     }
     return out;
@@ -1537,7 +1539,7 @@ function motionFrameToSvg(scene, time, options = {}) {
   const wrap = { ...options.wrap };
   for (const [id, clips] of Object.entries(frame.clips))
     wrap[id] = [..._nullishCoalesce(wrap[id], () => ( [])), ...clips.map((clip, i) => ({ clip: { id: `${prefix}reveal-${id}-${i}`, shape: clip.shape, attrs: motionClipAttrs(clip) } }))];
-  return withViewBox(_chunkJLYX4V57cjs.vectorDocumentToSvg.call(void 0, frame.document, { ...options, wrap }), frame.camera);
+  return withViewBox(_chunkLPLCWZTMcjs.vectorDocumentToSvg.call(void 0, frame.document, { ...options, wrap }), frame.camera);
 }
 function withViewBox(svg, box) {
   const f = (n) => String(Math.round(n * 1e3) / 1e3);
@@ -1720,8 +1722,8 @@ function visibleAt(timeline, id, time, node) {
   if (Array.isArray(rect) && (rect[2] <= 1e-4 || rect[3] <= 1e-4)) return false;
   const circle = clip("clipCircle");
   if (Array.isArray(circle) && circle[2] <= 1e-4) return false;
-  const hasFill = node.type === "path" ? !!node.fill && node.fill !== "none" : _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node).some((p) => p.fill && p.fill !== "none");
-  const drawn = num2("drawEnd", 1) > 0.01 && (node.type === "path" || _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node).length === 0 || _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node).some((p) => {
+  const hasFill = node.type === "path" ? !!node.fill && node.fill !== "none" : _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node).some((p) => p.fill && p.fill !== "none");
+  const drawn = num2("drawEnd", 1) > 0.01 && (node.type === "path" || _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node).length === 0 || _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node).some((p) => {
     const v = trackValue(timeline.tracks.get(motionTrackKey(p.id, "drawEnd")), time);
     return typeof v !== "number" || v > 0.01;
   }));
@@ -1807,7 +1809,7 @@ function checkMotionScene(scene) {
           }
           for (const id of targets) {
             const node = nodes.get(id).node;
-            const paths = node.type === "path" ? [node] : _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node);
+            const paths = node.type === "path" ? [node] : _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node);
             if (paths.some((p) => p[key] !== void 0 && p[key] !== null && typeof p[key] !== "string"))
               issues.push(_chunkWAJQKWQUcjs.motionIssue.call(void 0, "paint-not-color", `"${id}" has a gradient ${key}; it switches to ${color} at the end instead of blending.`, { ...where, ids: [id] }));
           }
@@ -1820,7 +1822,7 @@ function checkMotionScene(scene) {
         else
           for (const id of targets) {
             const node = nodes.get(id).node;
-            const paths = node.type === "path" ? [node] : _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node);
+            const paths = node.type === "path" ? [node] : _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node);
             if (paths.some((p) => typeof p[key] !== "string"))
               issues.push(_chunkWAJQKWQUcjs.motionIssue.call(void 0, "paint-not-color", `"${id}" has a gradient or no ${key}, so a colour pulse cannot tint it; give it a solid ${key} or pulse the ${key === "fill" ? "stroke" : "fill"}.`, { ...where, ids: [id] }));
           }
@@ -2404,7 +2406,7 @@ function toFlairSvgMotion(scene, options = {}) {
         raw: (t) => transformAt(t, true)
       });
     }
-    const paths = node.type === "path" ? [node] : _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node);
+    const paths = node.type === "path" ? [node] : _chunkLPLCWZTMcjs.collectPathNodes.call(void 0, node);
     for (const path of paths) {
       if (pathsSeen.has(path.id)) continue;
       pathsSeen.add(path.id);
@@ -2426,7 +2428,7 @@ function toFlairSvgMotion(scene, options = {}) {
     if (shapeSegments.length) {
       if (node.type !== "path") notes.push(`"${id}" is a group: its morph or effect animation is not exported (Flair tweens one path's "d").`);
       else {
-        const inverse = _chunkW3GXSUSQcjs.invertMatrix.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, node));
+        const inverse = _chunkLPLCWZTMcjs.invertMatrix.call(void 0, _chunkLPLCWZTMcjs.nodeMatrix.call(void 0, node));
         channels.push({
           id,
           kind: "attr",
@@ -2435,9 +2437,9 @@ function toFlairSvgMotion(scene, options = {}) {
           exact: () => false,
           value: (t) => {
             const frame = motionFrameAt(scene, t, { draw: false, offsets: false });
-            const now = _chunkW3GXSUSQcjs.expandVectorAppearance.call(void 0, _optionalChain([indexMotionNodes, 'call', _108 => _108(frame.document.nodes), 'access', _109 => _109.get, 'call', _110 => _110(id), 'optionalAccess', _111 => _111.node]));
+            const now = _chunkLPLCWZTMcjs.expandVectorAppearance.call(void 0, _optionalChain([indexMotionNodes, 'call', _108 => _108(frame.document.nodes), 'access', _109 => _109.get, 'call', _110 => _110(id), 'optionalAccess', _111 => _111.node]));
             if (!now || now.type !== "path") return "";
-            const bezier = _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, now, _chunkW3GXSUSQcjs.IDENTITY_MATRIX, { effects: false }), inverse);
+            const bezier = _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, _chunkLPLCWZTMcjs.vectorPathWorldBezier.call(void 0, now, _chunkLPLCWZTMcjs.IDENTITY_MATRIX, { effects: false }), inverse);
             return _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, bezier, { precision: Math.min(precision, 2) });
           }
         });
@@ -2544,7 +2546,7 @@ function toFlairSvgMotion(scene, options = {}) {
   }
   if (scene.motionBlur) notes.push("Motion blur is drawn on the stage only; Flair plays the scene sharp.");
   if (trigger && (_nullishCoalesce(scene.loop, () => ( "none"))) !== "none") notes.push(`The scene plays on ${trigger}, so its loop does not apply in Flair.`);
-  let svg = _chunkJLYX4V57cjs.vectorDocumentToSvg.call(void 0, { ...scene.artwork, nodes: _chunkW3GXSUSQcjs.expandVectorAppearances.call(void 0, scene.artwork.nodes) }, { pretty: false, precision, wrap });
+  let svg = _chunkLPLCWZTMcjs.vectorDocumentToSvg.call(void 0, { ...scene.artwork, nodes: _chunkLPLCWZTMcjs.expandVectorAppearances.call(void 0, scene.artwork.nodes) }, { pretty: false, precision, wrap });
   if (routes.length) svg = svg.replace(/^(<svg[^>]*>)/, `$1<defs>${routes.join("")}</defs>`);
   let motion = { svg, animate };
   if (_optionalChain([scene, 'access', _114 => _114.controls, 'optionalAccess', _115 => _115.length])) {
@@ -2628,14 +2630,14 @@ function easingOf(ease, fallback) {
   return fallback;
 }
 function poseOf(value, entry) {
-  const t = _chunkJLYX4V57cjs.parseSvgTransform.call(void 0, String(value));
-  const o = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _nullishCoalesce(_chunkW3GXSUSQcjs.invertMatrix.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, entry.node)), () => ( [1, 0, 0, 1, 0, 0])), t);
+  const t = _chunkLPLCWZTMcjs.parseSvgTransform.call(void 0, String(value));
+  const o = _chunkLPLCWZTMcjs.multiplyMatrices.call(void 0, _nullishCoalesce(_chunkLPLCWZTMcjs.invertMatrix.call(void 0, _chunkLPLCWZTMcjs.nodeMatrix.call(void 0, entry.node)), () => ( [1, 0, 0, 1, 0, 0])), t);
   const sx = Math.hypot(o[0], o[1]);
   if (!(sx > 1e-9)) return null;
   const sy = (o[0] * o[3] - o[1] * o[2]) / sx;
   if (Math.abs(o[2] + o[1] / sx * sy) > 1e-6 || Math.abs(o[3] - o[0] / sx * sy) > 1e-6) return null;
   const c = entry.center;
-  const moved = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, o, c);
+  const moved = _chunkLPLCWZTMcjs.applyMatrix.call(void 0, o, c);
   return { dx: moved.x - c.x, dy: moved.y - c.y, rotation: Math.atan2(o[1], o[0]) * 180 / Math.PI, sx, sy };
 }
 var near = (a, b, eps = 1e-6) => Math.abs(a - b) < eps;
@@ -2720,7 +2722,7 @@ function fromFlairSvgMotion(input, options = {}) {
   const notes = [];
   if (!input || typeof input.svg !== "string") throw new Error('Give a Flair SvgMotion: { svg: "<svg \u2026>", animate: [ \u2026 ] }.');
   const { motion, controls } = resolvePlaceholders(input, notes);
-  const artwork = _chunkJLYX4V57cjs.parseVectorSvg.call(void 0, motion.svg);
+  const artwork = _chunkLPLCWZTMcjs.parseVectorSvg.call(void 0, motion.svg);
   const nodes = indexMotionNodes(artwork.nodes);
   const byStep = /* @__PURE__ */ new Map();
   for (const anim of _nullishCoalesce(motion.animate, () => ( []))) {
@@ -2967,9 +2969,9 @@ function toLottie(scene, options = {}) {
     const items = [];
     const shapeSegments = [...timeline.tracks.entries()].filter(([k]) => k.startsWith(`${path.id}\0`) && (k.endsWith("\0shape") || k.includes("\0effect:"))).flatMap(([, v]) => v);
     const geometryAt = (t) => {
-      if (!shapeSegments.length) return _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, path);
+      if (!shapeSegments.length) return _chunkLPLCWZTMcjs.vectorPathWorldBezier.call(void 0, path);
       const now = _optionalChain([indexMotionNodes, 'call', _124 => _124(motionFrameAt(scene, t, { draw: false, offsets: false }).document.nodes), 'access', _125 => _125.get, 'call', _126 => _126(path.id), 'optionalAccess', _127 => _127.node]);
-      return now && now.type === "path" ? _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, _chunkW3GXSUSQcjs.expandVectorAppearances.call(void 0, [now])[0]) : _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, path);
+      return now && now.type === "path" ? _chunkLPLCWZTMcjs.vectorPathWorldBezier.call(void 0, _chunkLPLCWZTMcjs.expandVectorAppearances.call(void 0, [now])[0]) : _chunkLPLCWZTMcjs.vectorPathWorldBezier.call(void 0, path);
     };
     const rest = lottieContours(_chunkXGD3FSNCcjs.toBezierPath.call(void 0, geometryAt(0)), round2);
     rest.forEach((contour, n) => {
@@ -3041,10 +3043,14 @@ function toLottie(scene, options = {}) {
     let inner;
     const innerTr = STATIC_TR();
     if (node.type === "path") inner = [...pathShapes(node)];
-    else {
+    else if (node.type === "text" || node.type === "instance") {
+      const drawn = _chunkLPLCWZTMcjs.expandVectorAppearance.call(void 0, node);
+      inner = drawn.type === "path" ? [...pathShapes(drawn)] : drawn.children.filter((c) => c.type === "path").reverse().flatMap((c) => [...pathShapes(c)]);
+      notes.push(`"${node.id}": text is exported as its outlines${_chunkLPLCWZTMcjs.vectorTextHasOutlines.call(void 0, ) ? "" : " (glyph boxes: set an outline text shaper for real glyphs)"}.`);
+    } else {
       inner = shown(node.children).reverse().map(nodeGroup);
-      const m = _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, node);
-      if (m !== _chunkW3GXSUSQcjs.IDENTITY_MATRIX) {
+      const m = _chunkLPLCWZTMcjs.nodeMatrix.call(void 0, node);
+      if (m !== _chunkLPLCWZTMcjs.IDENTITY_MATRIX) {
         const parts = staticParts(m);
         if (!parts) notes.push(`"${node.id}": its transform skews, which is not exported; it is drawn without the skew.`);
         else {
@@ -3057,7 +3063,7 @@ function toLottie(scene, options = {}) {
     const body = { ty: "gr", nm: `${node.id} (own)`, it: [...inner, innerTr] };
     return { ty: "gr", nm: _nullishCoalesce(node.name, () => ( node.id)), it: [body, poseTransform(entry)] };
   };
-  const artwork = { ...scene.artwork, nodes: _chunkW3GXSUSQcjs.expandVectorAppearances.call(void 0, scene.artwork.nodes) };
+  const artwork = { ...scene.artwork, nodes: _chunkLPLCWZTMcjs.expandVectorAppearances.call(void 0, scene.artwork.nodes) };
   const content = shown(artwork.nodes).reverse().map(nodeGroup);
   if (artwork.background && rgba(artwork.background))
     content.push({ ty: "gr", nm: "Background", it: [{ ty: "rc", nm: "Background", p: { a: 0, k: [artwork.width / 2, artwork.height / 2] }, s: { a: 0, k: [artwork.width, artwork.height] }, r: { a: 0, k: 0 } }, { ty: "fl", c: { a: 0, k: rgba(artwork.background).map(round2) }, o: { a: 0, k: 100 }, r: 1 }, STATIC_TR()] });
@@ -3156,11 +3162,11 @@ function preset(prst, w, h) {
   const poly = (pts) => [{ closed: true, anchors: pts.map(([x, y]) => ({ x, y })) }];
   switch (prst) {
     case "rect":
-      return [_chunkW3GXSUSQcjs.rectSubpath.call(void 0, { x: 0, y: 0, width: w, height: h })];
+      return [_chunkLPLCWZTMcjs.rectSubpath.call(void 0, { x: 0, y: 0, width: w, height: h })];
     case "roundRect":
-      return [_chunkW3GXSUSQcjs.rectSubpath.call(void 0, { x: 0, y: 0, width: w, height: h }, Math.min(w, h) * 0.16667)];
+      return [_chunkLPLCWZTMcjs.rectSubpath.call(void 0, { x: 0, y: 0, width: w, height: h }, Math.min(w, h) * 0.16667)];
     case "ellipse":
-      return [_chunkW3GXSUSQcjs.ellipseSubpath.call(void 0, { x: 0, y: 0, width: w, height: h })];
+      return [_chunkLPLCWZTMcjs.ellipseSubpath.call(void 0, { x: 0, y: 0, width: w, height: h })];
     case "triangle":
       return poly([[w / 2, 0], [w, h], [0, h]]);
     case "rtTriangle":
@@ -3268,7 +3274,7 @@ function shapes(ctx, tree, map) {
     let subpaths = cust ? custom(cust, w, h) : prst ? preset(prst, w, h) : null;
     if (!subpaths) {
       if (prst) ctx.notes.push(`"${name}" is a ${prst}, drawn as its bounding rectangle.`);
-      subpaths = [_chunkW3GXSUSQcjs.rectSubpath.call(void 0, { x: 0, y: 0, width: w, height: h })];
+      subpaths = [_chunkLPLCWZTMcjs.rectSubpath.call(void 0, { x: 0, y: 0, width: w, height: h })];
     }
     const style = kid(el, "style");
     const fill = kid(spPr, "noFill") ? null : _nullishCoalesce(colour(ctx, kid(spPr, "solidFill")), () => ( (el.localName === "cxnSp" ? null : colour(ctx, kid(style, "fillRef")))));
@@ -4253,7 +4259,7 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     handler: ({ svg }) => {
       let artwork;
       try {
-        artwork = _chunkJLYX4V57cjs.parseVectorSvg.call(void 0, svg);
+        artwork = _chunkLPLCWZTMcjs.parseVectorSvg.call(void 0, svg);
       } catch (error) {
         throw new Error(`The SVG could not be read: ${error.message}. Nothing was changed.`);
       }