svg_path

Core SVG path data structures and constructors.

This module models paths as a list of subpaths, and subpaths as continuous segment lists. Use svg_path/parse and svg_path/serialize when working directly with SVG path data strings.

Types

BoundingBox

</>

An axis-aligned bounding box.

pub type BoundingBox {
  BoundingBox(min: vec2.Vec2(Float), max: vec2.Vec2(Float))
}

Constructors

BoundingBox(min: vec2.Vec2(Float), max: vec2.Vec2(Float))

ContainmentOptions

</>

Options for classifying a point relative to a subpath’s fill area.

pub type ContainmentOptions {
  ContainmentOptions(
    tolerance: Float,
    samples: Int,
    max_iterations: Int,
  )
}

Constructors

ContainmentOptions(
  tolerance: Float,
  samples: Int,
  max_iterations: Int,
)

CrossingOptions

</>

Options for detecting scalar zero crossings along a segment.

pub type CrossingOptions {
  CrossingOptions(
    samples: Int,
    tolerance: Float,
    max_iterations: Int,
  )
}

Constructors

CrossingOptions(
  samples: Int,
  tolerance: Float,
  max_iterations: Int,
)

DistanceOptions

</>

Options for finding the distance from a point to a segment.

pub type DistanceOptions {
  DistanceOptions(
    samples: Int,
    tolerance: Float,
    max_iterations: Int,
  )
}

Constructors

DistanceOptions(
  samples: Int,
  tolerance: Float,
  max_iterations: Int,
)

EndpointPolicy

</>

How construction and editing helpers reconcile segment endpoints.

pub type EndpointPolicy {
  Strict
  Wiggle
  Bridge
  WiggleThenBridge
  Custom(fn(Segment, Segment) -> #(Segment, Segment))
}

Constructors

```
Strict
```
Endpoints must already match exactly.
```
Wiggle
```
Move nearby endpoints together within the default wiggle tolerance.
```
Bridge
```
Keep endpoints unchanged and insert a straight line if needed.
```
WiggleThenBridge
```
Try Wiggle; if that fails, use Bridge.
```
Custom(fn(Segment, Segment) -> #(Segment, Segment))
```
Reconcile non-matching adjacent segments with a caller-provided function.

Error

</>

Errors returned by path construction and editing helpers.

pub type Error {
  AlreadyClosed
  Discontinuous(
    previous_index: Int,
    next_index: Int,
    expected: vec2.Vec2(Float),
    got: vec2.Vec2(Float),
    distance: Float,
  )
  EmptySubpath
  NotClosed
  EmptyPath
  EmptySubpaths
  DegenerateArc
  CannotMapArcNonlinearly
  IncompatibleHorizontalWiggle(
    previous_end: vec2.Vec2(Float),
    next_start: vec2.Vec2(Float),
  )
  IncompatibleVerticalWiggle(
    previous_end: vec2.Vec2(Float),
    next_start: vec2.Vec2(Float),
  )
  InvalidSplice(start: Int, delete: Int, length: Int)
  InvalidSubpathParameter(
    segment_index: Int,
    t: Float,
    length: Int,
  )
  InvalidPathParameter(subpath_index: Int, length: Int)
  InvalidSubpathInterval(
    from: SubpathParameter,
    to: SubpathParameter,
  )
  InvalidCrossingSamples(samples: Int)
  InvalidCrossingTolerance(tolerance: Float)
  InvalidCrossingMaxIterations(max_iterations: Int)
  CrossingMaxIterationsReached(estimate: Float, value: Float)
  InvalidMinimizeSamples(samples: Int)
  InvalidMinimizeTolerance(tolerance: Float)
  InvalidMinimizeMaxIterations(max_iterations: Int)
  MinimizeMaxIterationsReached(estimate: Float, value: Float)
  InvalidLengthTolerance(tolerance: Float)
  InvalidLengthMaxDepth(max_depth: Int)
  LengthMaxDepthReached(estimate: Float, error: Float)
  InvalidLengthDistance(distance: Float, length: Float)
  InvalidLinearizeTolerance(tolerance: Float)
  InvalidLinearizeMaxDepth(max_depth: Int)
  LinearizeMaxDepthReached(error: Float)
  InvalidDistanceSamples(samples: Int)
  InvalidDistanceTolerance(tolerance: Float)
  InvalidDistanceMaxIterations(max_iterations: Int)
  DistanceMaxIterationsReached(estimate: Float, value: Float)
  InvalidContainmentTolerance(tolerance: Float)
  InvalidContainmentSamples(samples: Int)
  InvalidContainmentMaxIterations(max_iterations: Int)
  InvalidIntersectionTolerance(tolerance: Float)
  InvalidIntersectionMaxDepth(max_depth: Int)
  InvalidSelfIntersectionMinimumArcLengthSeparation(Float)
  InvalidSelfIntersectionDistanceTolerance(Float)
  OverlappingSegments
  MultipleNonemptySubpaths
  NotCloseEnough(
    expected: vec2.Vec2(Float),
    got: vec2.Vec2(Float),
    tolerance: Float,
  )
  SplitOutsideSegment
}

Constructors

```
AlreadyClosed
```
The subpath is already closed and cannot accept more segments.
```
Discontinuous(
  previous_index: Int,
  next_index: Int,
  expected: vec2.Vec2(Float),
  got: vec2.Vec2(Float),
  distance: Float,
)
```
A segment starts somewhere other than the previous segment’s end point.

previous_index is the segment whose end point was expected. next_index is the segment whose start point did not match. distance is the distance between expected and got.
```
EmptySubpath
```
The operation requires a non-empty subpath.
```
NotClosed
```
The operation requires a closed subpath.
```
EmptyPath
```
The operation requires a path with at least one subpath.
```
EmptySubpaths
```
The operation requires a path with at least one non-empty subpath.
```
DegenerateArc
```
The arc cannot be converted to center-parameter form.
```
CannotMapArcNonlinearly
```
Nonlinear point mapping cannot preserve an SVG arc segment.

IncompatibleHorizontalWiggle(
  previous_end: vec2.Vec2(Float),
  next_start: vec2.Vec2(Float),
)

A wiggle operation could not reconcile two horizontal line segments.

IncompatibleVerticalWiggle(
  previous_end: vec2.Vec2(Float),
  next_start: vec2.Vec2(Float),
)

A wiggle operation could not reconcile two vertical line segments.

```
InvalidSplice(start: Int, delete: Int, length: Int)
```
A splice was requested with invalid bounds.

This is returned when start is negative, delete is negative, or start is greater than the subpath length.

InvalidSubpathParameter(
  segment_index: Int,
  t: Float,
  length: Int,
)

A subpath parameter was outside the valid segment index or 0.0..1.0 range.

```
InvalidPathParameter(subpath_index: Int, length: Int)
```
A path parameter was outside the valid subpath index range.

InvalidSubpathInterval(
  from: SubpathParameter,
  to: SubpathParameter,
)

A subpath interval would not produce a positive-length piece.

```
InvalidCrossingSamples(samples: Int)
```
The number of crossing scan samples must be greater than zero.
```
InvalidCrossingTolerance(tolerance: Float)
```
The crossing tolerance must be greater than zero.
```
InvalidCrossingMaxIterations(max_iterations: Int)
```
The crossing bisection iteration limit must be greater than zero.
```
CrossingMaxIterationsReached(estimate: Float, value: Float)
```
A bracketed crossing could not be refined within the iteration limit.
```
InvalidMinimizeSamples(samples: Int)
```
The number of minimization scan samples must be greater than zero.
```
InvalidMinimizeTolerance(tolerance: Float)
```
The minimization tolerance must be greater than zero.
```
InvalidMinimizeMaxIterations(max_iterations: Int)
```
The minimization iteration limit must be greater than zero.
```
MinimizeMaxIterationsReached(estimate: Float, value: Float)
```
A minimization window could not be refined within the iteration limit.
```
InvalidLengthTolerance(tolerance: Float)
```
The length approximation tolerance must be greater than zero.
```
InvalidLengthMaxDepth(max_depth: Int)
```
The length approximation recursion limit must be greater than zero.
```
LengthMaxDepthReached(estimate: Float, error: Float)
```
A length approximation could not be refined within the recursion limit.

InvalidLengthDistance(distance: Float, length: Float)

A requested arc-length distance was outside 0.0..length.

```
InvalidLinearizeTolerance(tolerance: Float)
```
The line approximation tolerance must be greater than zero.
```
InvalidLinearizeMaxDepth(max_depth: Int)
```
The line approximation recursion limit must be greater than zero.
```
LinearizeMaxDepthReached(error: Float)
```
A segment could not be approximated within the recursion limit.
```
InvalidDistanceSamples(samples: Int)
```
The number of distance scan samples must be greater than zero.
```
InvalidDistanceTolerance(tolerance: Float)
```
The distance tolerance must be greater than zero.
```
InvalidDistanceMaxIterations(max_iterations: Int)
```
The distance bisection iteration limit must be greater than zero.
```
DistanceMaxIterationsReached(estimate: Float, value: Float)
```
A bracketed distance candidate could not be refined within the iteration limit.
```
InvalidContainmentTolerance(tolerance: Float)
```
The containment tolerance must be greater than zero.
```
InvalidContainmentSamples(samples: Int)
```
The number of containment samples must be greater than zero.
```
InvalidContainmentMaxIterations(max_iterations: Int)
```
The containment iteration limit must be greater than zero.
```
InvalidIntersectionTolerance(tolerance: Float)
```
The intersection tolerance must be greater than zero.
```
InvalidIntersectionMaxDepth(max_depth: Int)
```
The intersection subdivision depth must be greater than zero.
```
InvalidSelfIntersectionMinimumArcLengthSeparation(Float)
```
The self-intersection minimum arc length separation must be greater than zero.
```
InvalidSelfIntersectionDistanceTolerance(Float)
```
The self-intersection distance tolerance must be greater than zero.
```
OverlappingSegments
```
The two segments overlap in more than a single point.
```
MultipleNonemptySubpaths
```
The path contains more than one non-empty subpath.

NotCloseEnough(
  expected: vec2.Vec2(Float),
  got: vec2.Vec2(Float),
  tolerance: Float,
)

Two points were too far apart for a wiggle operation to merge them.

```
SplitOutsideSegment
```
The requested split point is outside the segment’s 0.0..1.0 parameter range.

IntersectionOptions

</>

Options for finding segment intersections.

pub type IntersectionOptions {
  IntersectionOptions(tolerance: Float, max_depth: Int)
}

Constructors

IntersectionOptions(tolerance: Float, max_depth: Int)

LengthOptions

</>

Options for approximating the length of a segment or subpath.

pub type LengthOptions {
  LengthOptions(tolerance: Float, max_depth: Int)
}

Constructors

LengthOptions(tolerance: Float, max_depth: Int)

LinearizeOptions

</>

Options for approximating segments with straight lines.

pub type LinearizeOptions {
  LinearizeOptions(tolerance: Float, max_depth: Int)
}

Constructors

LinearizeOptions(tolerance: Float, max_depth: Int)

MinimizeOptions

</>

Options for minimizing a scalar function along a segment.

pub type MinimizeOptions {
  MinimizeOptions(
    samples: Int,
    tolerance: Float,
    max_iterations: Int,
  )
}

Constructors

MinimizeOptions(
  samples: Int,
  tolerance: Float,
  max_iterations: Int,
)

PathIntersection

</>

A point intersection between two paths.

Multiple parameters are retained on both paths because a single point can be represented by multiple subpaths or by both sides of a segment boundary.

pub type PathIntersection {
  PathIntersection(
    point: vec2.Vec2(Float),
    left_parameters: List(PathParameter),
    right_parameters: List(PathParameter),
  )
}

Constructors

PathIntersection(
  point: vec2.Vec2(Float),
  left_parameters: List(PathParameter),
  right_parameters: List(PathParameter),
)

PathParameter

</>

A local address on a path.

subpath_index addresses a subpath in the path, and at addresses a segment parameter inside that subpath.

pub type PathParameter {
  PathParameter(subpath_index: Int, at: SubpathParameter)
}

Constructors

PathParameter(subpath_index: Int, at: SubpathParameter)

PathProjection

</>

The nearest point on a path to an input point.

Move-only subpaths are skipped. When multiple path points are equally nearest, this records one valid nearest point. The chosen point and parameter are not guaranteed to be canonical for ties or flat minima.

pub type PathProjection {
  PathProjection(
    at: PathParameter,
    point: vec2.Vec2(Float),
    distance: Float,
  )
}

Constructors

PathProjection(
  at: PathParameter,
  point: vec2.Vec2(Float),
  distance: Float,
)

PathWinding

</>

The signed winding number of a path around a point.

pub type PathWinding {
  Winding(Int)
  BoundaryWinding
}

Constructors

```
Winding(Int)
```
```
BoundaryWinding
```

Point

</>

A 2D point.

This is a vec.Vec2(Float), so its coordinates are available as .x and .y.

pub type Point =
  vec2.Vec2(Float)

PointContainment

</>

The position of a point relative to a filled subpath.

pub type PointContainment {
  Inside
  Outside
  Boundary
}

Constructors

```
Inside
```
```
Outside
```
```
Boundary
```

Segment

</>

A single SVG path segment.

pub type Segment {
  Line(start: vec2.Vec2(Float), end: vec2.Vec2(Float))
  QuadraticBezier(
    start: vec2.Vec2(Float),
    control: vec2.Vec2(Float),
    end: vec2.Vec2(Float),
  )
  CubicBezier(
    start: vec2.Vec2(Float),
    control1: vec2.Vec2(Float),
    control2: vec2.Vec2(Float),
    end: vec2.Vec2(Float),
  )
  Arc(
    start: vec2.Vec2(Float),
    radius: vec2.Vec2(Float),
    x_axis_rotation: Float,
    large_arc: Bool,
    sweep: Bool,
    end: vec2.Vec2(Float),
  )
}

Constructors

Line(start: vec2.Vec2(Float), end: vec2.Vec2(Float))

A straight line segment.

QuadraticBezier(
  start: vec2.Vec2(Float),
  control: vec2.Vec2(Float),
  end: vec2.Vec2(Float),
)

A quadratic Bezier curve segment.

CubicBezier(
  start: vec2.Vec2(Float),
  control1: vec2.Vec2(Float),
  control2: vec2.Vec2(Float),
  end: vec2.Vec2(Float),
)

A cubic Bezier curve segment.

Arc(
  start: vec2.Vec2(Float),
  radius: vec2.Vec2(Float),
  x_axis_rotation: Float,
  large_arc: Bool,
  sweep: Bool,
  end: vec2.Vec2(Float),
)

An elliptical arc segment. x_axis_rotation is in degrees.

SegmentIntersection

</>

A point intersection between two segments.

pub type SegmentIntersection {
  SegmentIntersection(
    left_t: Float,
    right_t: Float,
    point: vec2.Vec2(Float),
  )
}

Constructors

SegmentIntersection(
  left_t: Float,
  right_t: Float,
  point: vec2.Vec2(Float),
)

SegmentProjection

</>

The nearest point on a segment to an input point.

When multiple segment points are equally nearest, this records one valid nearest point. The chosen point and parameter are not guaranteed to be canonical for ties or flat minima.

pub type SegmentProjection {
  SegmentProjection(
    t: Float,
    point: vec2.Vec2(Float),
    distance: Float,
  )
}

Constructors

SegmentProjection(
  t: Float,
  point: vec2.Vec2(Float),
  distance: Float,
)

SelfIntersectionOptions

</>

Options for finding self-intersections in one subpath.

pub type SelfIntersectionOptions {
  SelfIntersectionOptions(
    minimum_arc_length_separation: Float,
    distance_tolerance: Float,
  )
}

Constructors

SelfIntersectionOptions(
  minimum_arc_length_separation: Float,
  distance_tolerance: Float,
)

Subpath

opaque </>

A positioned sequence of path segments, optionally closed.

The first segment, when present, starts at the subpath start point. The last segment of a closed subpath, when present, also ends at the subpath start point. Empty subpaths may be open or closed.

The constructor is opaque so that these invariants are maintained. Use subpath, empty_subpath, append_segment, or their _with variants to build values.

pub opaque type Subpath

SubpathIntersection

</>

A point intersection between two subpaths.

Multiple parameters are retained on both subpaths because a single point can be represented by both sides of a segment boundary, or by multiple segments of a self-intersecting subpath.

pub type SubpathIntersection {
  SubpathIntersection(
    point: vec2.Vec2(Float),
    left_parameters: List(SubpathParameter),
    right_parameters: List(SubpathParameter),
  )
}

Constructors

SubpathIntersection(
  point: vec2.Vec2(Float),
  left_parameters: List(SubpathParameter),
  right_parameters: List(SubpathParameter),
)

SubpathParameter

</>

A local address on a subpath segment.

segment_index addresses a segment in the subpath, and t is that segment’s local parameter. Subpath APIs require t to be inside 0.0..1.0; unlike segment APIs, subpath parameters do not extrapolate.

pub type SubpathParameter {
  SubpathParameter(segment_index: Int, t: Float)
}

Constructors

SubpathParameter(segment_index: Int, t: Float)

SubpathProjection

</>

The nearest point on a subpath to an input point.

When multiple subpath points are equally nearest, this records one valid nearest point. The chosen point and parameter are not guaranteed to be canonical for ties or flat minima.

pub type SubpathProjection {
  SubpathProjection(
    at: SubpathParameter,
    point: vec2.Vec2(Float),
    distance: Float,
  )
}

Constructors

SubpathProjection(
  at: SubpathParameter,
  point: vec2.Vec2(Float),
  distance: Float,
)

SubpathSelfIntersection

</>

A point where a subpath intersects itself.

pub type SubpathSelfIntersection {
  SubpathSelfIntersection(
    point: vec2.Vec2(Float),
    parameters: #(SubpathParameter, SubpathParameter),
  )
}

Constructors

SubpathSelfIntersection(
  point: vec2.Vec2(Float),
  parameters: #(SubpathParameter, SubpathParameter),
)

Values

append_segment

</>

pub fn append_segment(
  subpath: Subpath,
  segment: Segment,
) -> Result(Subpath, Error)

Append a segment to an open subpath.

The new segment must start exactly at the current end point.

append_segment_with

</>

pub fn append_segment_with(
  subpath: Subpath,
  segment: Segment,
  policy endpoint_policy: EndpointPolicy,
) -> Result(Subpath, Error)

Append a segment to an open subpath using the given endpoint policy.

append_subpath

</>

pub fn append_subpath(path: Path, subpath: Subpath) -> Path

Append a subpath to the end of a path.

arc_center_data

</>

pub fn arc_center_data(
  segment: Segment,
) -> Result(ellipse.CenterArcData, Error)

Return an elliptical arc segment as center-parameter arc data.

arc_from_center_data

</>

pub fn arc_from_center_data(
  data: ellipse.CenterArcData,
) -> Segment

Create an elliptical arc segment from center-parameter arc data.

arc_from_endpoint_data

</>

pub fn arc_from_endpoint_data(
  data: ellipse.EndpointArcData,
) -> Segment

Create an elliptical arc segment from endpoint-parameter arc data.

as_subpath

</>

pub fn as_subpath(path: Path) -> Result(Subpath, Error)

Convert a path with zero or one non-empty subpaths into a subpath.

Empty subpaths are ignored. If more than one non-empty subpath is present, this returns MultipleNonemptySubpaths. If a path has only empty subpaths, the first empty subpath is returned.

assert_append_segment

</>

pub fn assert_append_segment(
  subpath: Subpath,
  segment: Segment,
) -> Subpath

Append a segment to an open subpath, panicking if invalid.

assert_append_segment_with

</>

pub fn assert_append_segment_with(
  subpath: Subpath,
  segment: Segment,
  policy endpoint_policy: EndpointPolicy,
) -> Subpath

Append a segment with an endpoint policy, panicking if invalid.

assert_join

</>

pub fn assert_join(subpaths: List(Subpath)) -> Subpath

Join open subpaths, panicking if invalid.

assert_join_with

</>

pub fn assert_join_with(
  subpaths: List(Subpath),
  policy endpoint_policy: EndpointPolicy,
) -> Subpath

Join open subpaths with an endpoint policy, panicking if invalid.

assert_polygon

</>

pub fn assert_polygon(points: List(vec2.Vec2(Float))) -> Subpath

Create a closed polygon subpath, panicking if the point list is invalid.

assert_polyline

</>

pub fn assert_polyline(points: List(vec2.Vec2(Float))) -> Subpath

Create an open polyline subpath, panicking if the point list is invalid.

assert_set_closed

</>

pub fn assert_set_closed(
  subpath: Subpath,
  closed closed: Bool,
) -> Subpath

Set a subpath’s semantic closed state, panicking if invalid.

assert_set_closed_with

</>

pub fn assert_set_closed_with(
  subpath: Subpath,
  closed closed: Bool,
  policy endpoint_policy: EndpointPolicy,
) -> Subpath

Set a subpath’s semantic closed state with an endpoint policy, panicking if invalid.

assert_splice

</>

pub fn assert_splice(
  subpath: Subpath,
  start start: Int,
  delete delete: Int,
  insert insert: List(Segment),
) -> Subpath

Replace a range of segments, panicking if the splice is invalid.

assert_splice_with

</>

pub fn assert_splice_with(
  subpath: Subpath,
  start start: Int,
  delete delete: Int,
  insert insert: List(Segment),
  policy endpoint_policy: EndpointPolicy,
) -> Subpath

Replace a range of segments with an endpoint policy, panicking if invalid.

assert_subpath

</>

pub fn assert_subpath(segments: List(Segment)) -> Subpath

Create an open subpath from a non-empty continuous list of segments, panicking if the segments are invalid.

This is useful for hand-authored paths where invalid continuity would be a programmer error. Use subpath when you want to handle construction errors.

assert_subpath_with

</>

pub fn assert_subpath_with(
  segments: List(Segment),
  policy endpoint_policy: EndpointPolicy,
) -> Subpath

Create an open subpath with an endpoint policy, panicking if construction fails.

bounding_box_center

</>

pub fn bounding_box_center(box: BoundingBox) -> vec2.Vec2(Float)

Return the center point of a bounding box.

bounding_box_diameter

</>

pub fn bounding_box_diameter(box: BoundingBox) -> Float

Return the taxicab diameter of a bounding box.

This is the box width plus the box height.

bounding_box_height

</>

pub fn bounding_box_height(box: BoundingBox) -> Float

Return the height of a bounding box.

bounding_box_union

</>

pub fn bounding_box_union(
  first: BoundingBox,
  second: BoundingBox,
) -> BoundingBox

Return the smallest axis-aligned bounding box containing both boxes.

bounding_box_union_many

</>

pub fn bounding_box_union_many(
  boxes: List(BoundingBox),
) -> Result(BoundingBox, Nil)

Return the smallest axis-aligned bounding box containing every box.

bounding_box_width

</>

pub fn bounding_box_width(box: BoundingBox) -> Float

Return the width of a bounding box.

clean_subpath

</>

pub fn clean_subpath(subpath: Subpath) -> Subpath

Remove zero-length line segments from a subpath.

If cleanup would remove every segment, one zero-length line is preserved so a zero-length drawing subpath does not become a move-only subpath.

combine_paths

</>

pub fn combine_paths(paths: List(Path)) -> Path

Combine paths by concatenating their subpaths.

compare_path_parameters

</>

pub fn compare_path_parameters(
  a: PathParameter,
  b: PathParameter,
) -> order.Order

Compare two path parameters by subpath index, then subpath parameter.

compare_subpath_parameters

</>

pub fn compare_subpath_parameters(
  a: SubpathParameter,
  b: SubpathParameter,
) -> order.Order

Compare two subpath parameters by segment index and then local t.

default_containment_options

</>

pub fn default_containment_options() -> ContainmentOptions

Return the default options for point containment.

default_crossing_options

</>

pub fn default_crossing_options() -> CrossingOptions

Return the default options for segment crossing detection.

default_distance_options

</>

pub fn default_distance_options() -> DistanceOptions

Return the default options for point-to-segment distance measurement.

default_intersection_options

</>

pub fn default_intersection_options() -> IntersectionOptions

Return the default options for segment intersection detection.

default_length_options

</>

pub fn default_length_options() -> LengthOptions

Return the default options for segment and subpath length approximation.

default_linearize_options

</>

pub fn default_linearize_options() -> LinearizeOptions

Return the default options for straight-line approximation.

default_minimize_options

</>

pub fn default_minimize_options() -> MinimizeOptions

Return the default options for segment minimization.

default_self_intersection_options

</>

pub fn default_self_intersection_options() -> SelfIntersectionOptions

Return the default options for subpath self-intersection detection.

empty_path

</>

pub fn empty_path() -> Path

Create an empty path.

empty_subpath

</>

pub fn empty_subpath(at start: vec2.Vec2(Float)) -> Subpath

Create an empty open subpath at a start point.

This represents a move-only subpath such as M 0 0.

end

</>

pub fn end(subpath: Subpath) -> Result(vec2.Vec2(Float), Error)

Return the end point of a subpath.

from_end_parameter

</>

pub fn from_end_parameter(
  subpath: Subpath,
  segment_index segment_index: Int,
  t t: Float,
) -> Result(SubpathParameter, Error)

Return a validated subpath parameter addressed as if the subpath were reversed.

segment_index addresses the reversed segment list. t is also measured in the reversed segment’s direction, then converted back into the original subpath’s coordinates.

from_subpath

</>

pub fn from_subpath(subpath: Subpath) -> Path

Create a path containing a single subpath.

is_closed

</>

pub fn is_closed(subpath: Subpath) -> Bool

Check whether a subpath is closed.

join

</>

pub fn join(subpaths: List(Subpath)) -> Result(Subpath, Error)

Join open subpaths into one open subpath.

Each subpath’s end point must exactly match the next subpath’s start point. Empty open subpaths can act as identity values when their start points line up with their neighbors.

join_with

</>

pub fn join_with(
  subpaths: List(Subpath),
  policy endpoint_policy: EndpointPolicy,
) -> Result(Subpath, Error)

Join open subpaths using the given endpoint policy.

map_path_points

</>

pub fn map_path_points(
  path: Path,
  with f: fn(vec2.Vec2(Float)) -> vec2.Vec2(Float),
) -> Result(Path, Error)

Map the defining points of every segment in a path.

Each subpath’s closed state is preserved. For nonlinear functions, this maps endpoints and control points, not the exact image of every point on each rendered curve. If any segment is an arc, this returns CannotMapArcNonlinearly.

map_segment_points

</>

pub fn map_segment_points(
  segment: Segment,
  with f: fn(vec2.Vec2(Float)) -> vec2.Vec2(Float),
) -> Result(Segment, Error)

Map the defining points of a segment.

Lines, quadratic Beziers, and cubic Beziers are mapped by applying f to their endpoints and control points. For nonlinear functions, this is not the exact image of every point on the rendered curve. Arc segments return CannotMapArcNonlinearly because an arbitrary nonlinear mapping does not generally preserve SVG arc parameters.

map_subpath_points

</>

pub fn map_subpath_points(
  subpath: Subpath,
  with f: fn(vec2.Vec2(Float)) -> vec2.Vec2(Float),
) -> Result(Subpath, Error)

Map the defining points of every segment in a subpath.

The subpath’s closed state is preserved. For nonlinear functions, this maps endpoints and control points, not the exact image of every point on each rendered curve. If any segment is an arc, this returns CannotMapArcNonlinearly.

open_at

</>

pub fn open_at(
  subpath: Subpath,
  at parameter: SubpathParameter,
) -> Result(Subpath, Error)

Break open a closed subpath at the given subpath parameter.

The returned subpath is open and traverses the whole loop from the split point back to itself. The parameter must address a segment in the closed subpath, with t inside 0.0..1.0.

path_arcs_to_cubic_beziers

</>

pub fn path_arcs_to_cubic_beziers(path: Path) -> Path

Convert every arc in a path to cubic Bezier curves.

This applies subpath_arcs_to_cubic_beziers to each subpath.

path_bounding_box

</>

pub fn path_bounding_box(
  path: Path,
) -> Result(BoundingBox, Error)

Return the exact axis-aligned bounding box of all non-empty subpaths.

path_containment

</>

pub fn path_containment(
  point: vec2.Vec2(Float),
  within path: Path,
  using fill_rule: FillRule,
) -> Result(PointContainment, Error)

Classify a point relative to a path’s combined fill area.

Winding and crossing counts are accumulated across all non-move-only subpaths. Each open subpath is implicitly closed independently. A boundary match on any subpath takes precedence. Empty and move-only paths are Outside.

path_containment_with

</>

pub fn path_containment_with(
  point: vec2.Vec2(Float),
  within path: Path,
  using fill_rule: FillRule,
  options options: ContainmentOptions,
) -> Result(PointContainment, Error)

Classify a point relative to a path’s combined fill area using explicit options.

path_derivative

</>

pub fn path_derivative(
  path: Path,
  at parameter: PathParameter,
) -> Result(vec2.Vec2(Float), Error)

Return a path’s subpath derivative at a path parameter.

path_derivative_at_length

</>

pub fn path_derivative_at_length(
  path: Path,
  distance distance: Float,
) -> Result(vec2.Vec2(Float), Error)

Return the path derivative at a traveled distance from the path start.

path_derivative_at_length_with

</>

pub fn path_derivative_at_length_with(
  path: Path,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(vec2.Vec2(Float), Error)

Return the path derivative at a traveled distance using explicit options.

path_distance

</>

pub fn path_distance(
  point: vec2.Vec2(Float),
  to path: Path,
) -> Result(Float, Error)

Return the shortest distance from a point to a path.

Move-only subpaths are skipped.

path_distance_with

</>

pub fn path_distance_with(
  point: vec2.Vec2(Float),
  to path: Path,
  options options: DistanceOptions,
) -> Result(Float, Error)

Return the shortest distance from a point to a path using explicit options.

path_end

</>

pub fn path_end(path: Path) -> Result(vec2.Vec2(Float), Error)

Return the end point of the last subpath in a path.

path_filter_subpaths

</>

pub fn path_filter_subpaths(
  path: Path,
  keeping predicate: fn(Subpath) -> Bool,
) -> Path

Keep only the subpaths that satisfy a predicate.

path_intersections

</>

pub fn path_intersections(
  left: Path,
  right: Path,
) -> Result(List(PathIntersection), Error)

Return the point intersections between two paths.

Each result contains an intersection point and every corresponding parameter on both paths. Results are ordered by the first left parameter. Parameters at both sides of subpath segment boundaries are retained.

path_intersections_with

</>

pub fn path_intersections_with(
  left: Path,
  right: Path,
  options options: IntersectionOptions,
) -> Result(List(PathIntersection), Error)

Return the point intersections between two paths using explicit options.

path_length

</>

pub fn path_length(path: Path) -> Result(Float, Error)

Return the approximate length of a path.

Empty paths have length 0.0. Move-only subpaths contribute 0.0.

path_length_with

</>

pub fn path_length_with(
  path: Path,
  options options: LengthOptions,
) -> Result(Float, Error)

Return the approximate length of a path using explicit options.

path_map_subpaths

</>

pub fn path_map_subpaths(
  path: Path,
  with f: fn(Subpath) -> Subpath,
) -> Path

Map over the subpaths in a path.

path_parameter_at_length

</>

pub fn path_parameter_at_length(
  path: Path,
  distance distance: Float,
) -> Result(PathParameter, Error)

Return the path parameter at a traveled distance from the path start.

The distance is measured across subpaths in path order. Move-only subpaths contribute no length and are skipped for lookup. The returned value is an ordinary public PathParameter.

path_parameter_at_length_with

</>

pub fn path_parameter_at_length_with(
  path: Path,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(PathParameter, Error)

Return the path parameter at a traveled distance using explicit options.

path_point

</>

pub fn path_point(
  path: Path,
  at parameter: PathParameter,
) -> Result(vec2.Vec2(Float), Error)

Evaluate a path at a path parameter.

path_point_at_length

</>

pub fn path_point_at_length(
  path: Path,
  distance distance: Float,
) -> Result(vec2.Vec2(Float), Error)

Return the path point at a traveled distance from the path start.

path_point_at_length_with

</>

pub fn path_point_at_length_with(
  path: Path,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(vec2.Vec2(Float), Error)

Return the path point at a traveled distance using explicit options.

path_projection

</>

pub fn path_projection(
  point: vec2.Vec2(Float),
  to path: Path,
) -> Result(PathProjection, Error)

Return the nearest point on a path to an input point.

Move-only subpaths are skipped. An empty path returns EmptyPath; a path containing only move-only subpaths returns EmptySubpaths.

path_projection_with

</>

pub fn path_projection_with(
  point: vec2.Vec2(Float),
  to path: Path,
  options options: DistanceOptions,
) -> Result(PathProjection, Error)

Return the nearest point on a path to an input point using explicit options.

path_start

</>

pub fn path_start(path: Path) -> Result(vec2.Vec2(Float), Error)

Return the start point of the first subpath in a path.

path_to_cubic_beziers

</>

pub fn path_to_cubic_beziers(path: Path) -> Path

Convert every segment in a path to cubic Bezier curves.

This applies subpath_to_cubic_beziers to each subpath.

path_to_lines

</>

pub fn path_to_lines(path: Path) -> Result(Path, Error)

Approximate every segment in a path with straight lines.

Subpath order, move-only subpaths, and closed states are preserved.

path_to_lines_with

</>

pub fn path_to_lines_with(
  path: Path,
  options options: LinearizeOptions,
) -> Result(Path, Error)

Approximate every segment in a path with straight lines using explicit options.

path_winding

</>

pub fn path_winding(
  point: vec2.Vec2(Float),
  within path: Path,
) -> Result(PathWinding, Error)

Return the signed winding number of a path around a point.

Open subpaths are implicitly closed, matching path_containment. If the point is within the boundary tolerance of any non-empty subpath, the result is BoundaryWinding because the winding number is not numerically stable at that point.

path_winding_with

</>

pub fn path_winding_with(
  point: vec2.Vec2(Float),
  within path: Path,
  options options: ContainmentOptions,
) -> Result(PathWinding, Error)

Return the signed winding number of a path around a point using explicit containment options.

point

</>

pub fn point(x: Float, y: Float) -> vec2.Vec2(Float)

Create a point from x and y coordinates.

points_bounding_box

</>

pub fn points_bounding_box(
  points: List(vec2.Vec2(Float)),
) -> Result(BoundingBox, Nil)

Return the smallest axis-aligned bounding box containing every point.

polygon

</>

pub fn polygon(
  points: List(vec2.Vec2(Float)),
) -> Result(Subpath, Error)

Create a closed subpath connecting the given points with line segments.

The input must contain at least two points. If the last point equals the first point, no extra zero-length closing line is added.

This is equivalent to constructing a polyline from the same points and closing it with set_closed_with(..., policy: Bridge).

polyline

</>

pub fn polyline(
  points: List(vec2.Vec2(Float)),
) -> Result(Subpath, Error)

Create an open subpath connecting the given points with line segments.

The input must contain at least two points.

reverse_path

</>

pub fn reverse_path(path: Path) -> Path

Reverse the traversal direction of a path.

This reverses each subpath and reverses the path’s subpath order.

reverse_segment

</>

pub fn reverse_segment(segment: Segment) -> Segment

Reverse the traversal direction of a segment.

reverse_subpath

</>

pub fn reverse_subpath(subpath: Subpath) -> Subpath

Reverse the traversal direction of every segment in a subpath.

The subpath’s closed state is preserved.

segment_arcs_to_cubic_beziers

</>

pub fn segment_arcs_to_cubic_beziers(
  segment: Segment,
) -> List(Segment)

Convert an arc segment to cubic Bezier curves, preserving other segments.

Non-arc segments are returned unchanged as a single-item list. An arc may become several cubic Bezier segments.

segment_between

</>

pub fn segment_between(
  segment: Segment,
  from from: Float,
  to to: Float,
) -> Result(Segment, Error)

Return the portion of a segment between two parameters.

from and to are not clamped. Values outside 0.0..1.0 extrapolate along the same segment. If from is greater than to, the returned segment traverses the interval in reverse.

segment_between_inside

</>

pub fn segment_between_inside(
  segment: Segment,
  from from: Float,
  to to: Float,
) -> Result(Segment, Error)

Return the portion of a segment between two parameters.

from and to must be inside 0.0..1.0, inclusive. If from is greater than to, the returned segment traverses the interval in reverse.

segment_between_lengths

</>

pub fn segment_between_lengths(
  segment: Segment,
  from from: Float,
  to to: Float,
) -> Result(Segment, Error)

Return the portion of a segment between two traveled distances.

Distances are measured in path coordinate units from the segment start and must be inside 0.0..length, inclusive. If from is greater than to, the returned segment traverses the interval in reverse.

segment_between_lengths_with

</>

pub fn segment_between_lengths_with(
  segment: Segment,
  from from: Float,
  to to: Float,
  options options: LengthOptions,
) -> Result(Segment, Error)

Return the portion of a segment between two traveled distances using explicit length options.

segment_bounding_box

</>

pub fn segment_bounding_box(
  segment: Segment,
) -> Result(BoundingBox, Error)

Return a segment’s exact axis-aligned bounding box.

segment_crossings

</>

pub fn segment_crossings(
  segment: Segment,
  where f: fn(vec2.Vec2(Float)) -> Float,
) -> Result(List(Float), Error)

Find scalar sign-change crossings along a segment using default options.

This samples t in 0.0..1.0, detects sign changes of f(segment_point(t)), and refines each bracket with bisection. It finds crossings visible at the configured sampling resolution; tangent roots and pairs of crossings inside one sample window may be missed.

segment_crossings_with

</>

pub fn segment_crossings_with(
  segment: Segment,
  where f: fn(vec2.Vec2(Float)) -> Float,
  options options: CrossingOptions,
) -> Result(List(Float), Error)

Find scalar sign-change crossings along a segment using explicit options.

segment_derivative

</>

pub fn segment_derivative(
  segment: Segment,
  at t: Float,
) -> Result(vec2.Vec2(Float), Error)

Return a segment’s derivative with respect to parameter t.

t is not clamped.

segment_derivative_at_length

</>

pub fn segment_derivative_at_length(
  segment: Segment,
  distance distance: Float,
) -> Result(vec2.Vec2(Float), Error)

Return the segment derivative at a traveled distance from the segment start.

segment_derivative_at_length_with

</>

pub fn segment_derivative_at_length_with(
  segment: Segment,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(vec2.Vec2(Float), Error)

Return the segment derivative at a traveled distance using explicit options.

segment_distance

</>

pub fn segment_distance(
  point: vec2.Vec2(Float),
  to segment: Segment,
) -> Result(Float, Error)

Return the shortest distance from a point to a segment.

Lines are measured exactly. Quadratic Beziers, cubic Beziers, and arcs are measured by finding stationary points of squared distance in 0.0..1.0.

segment_distance_with

</>

pub fn segment_distance_with(
  point: vec2.Vec2(Float),
  to segment: Segment,
  options options: DistanceOptions,
) -> Result(Float, Error)

Return the shortest distance from a point to a segment using explicit options.

segment_end

</>

pub fn segment_end(segment: Segment) -> vec2.Vec2(Float)

Return the end point of a segment.

segment_intersections

</>

pub fn segment_intersections(
  left: Segment,
  right: Segment,
) -> Result(List(SegmentIntersection), Error)

Return point intersections between two segments.

Overlapping segments return OverlappingSegments, since they have more than a finite list of point intersections.

segment_intersections_with

</>

pub fn segment_intersections_with(
  left: Segment,
  right: Segment,
  options options: IntersectionOptions,
) -> Result(List(SegmentIntersection), Error)

Return point intersections between two segments using explicit options.

segment_length

</>

pub fn segment_length(segment: Segment) -> Result(Float, Error)

Return the approximate length of a segment.

Lines are measured exactly. Quadratic Beziers, cubic Beziers, and arcs are approximated by adaptive Simpson integration of segment speed.

segment_length_with

</>

pub fn segment_length_with(
  segment: Segment,
  options options: LengthOptions,
) -> Result(Float, Error)

Return the approximate length of a segment using explicit options.

segment_minimize

</>

pub fn segment_minimize(
  segment: Segment,
  measure f: fn(vec2.Vec2(Float)) -> Float,
) -> Result(Float, Error)

Return the segment parameter where a scalar function is minimized.

This numerically minimizes f(segment_point(t)) for t in 0.0..1.0.

segment_minimize_with

</>

pub fn segment_minimize_with(
  segment: Segment,
  measure f: fn(vec2.Vec2(Float)) -> Float,
  options options: MinimizeOptions,
) -> Result(Float, Error)

Return the segment parameter where a scalar function is minimized using explicit options.

segment_parameter_at_length

</>

pub fn segment_parameter_at_length(
  segment: Segment,
  distance distance: Float,
) -> Result(Float, Error)

Return the segment parameter at a traveled distance from the segment start.

The distance is measured in path coordinate units, not normalized. Lines are inverted exactly. Quadratic Beziers, cubic Beziers, and arcs are inverted numerically using the same length options as segment_length_with.

segment_parameter_at_length_with

</>

pub fn segment_parameter_at_length_with(
  segment: Segment,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(Float, Error)

Return the segment parameter at a traveled distance using explicit options.

segment_point

</>

pub fn segment_point(
  segment: Segment,
  at t: Float,
) -> Result(vec2.Vec2(Float), Error)

Evaluate a segment at parameter t.

t is not clamped. Values outside 0.0..1.0 extrapolate along the same segment.

segment_point_at_length

</>

pub fn segment_point_at_length(
  segment: Segment,
  distance distance: Float,
) -> Result(vec2.Vec2(Float), Error)

Return the segment point at a traveled distance from the segment start.

segment_point_at_length_with

</>

pub fn segment_point_at_length_with(
  segment: Segment,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(vec2.Vec2(Float), Error)

Return the segment point at a traveled distance using explicit options.

segment_projection

</>

pub fn segment_projection(
  point: vec2.Vec2(Float),
  to segment: Segment,
) -> Result(SegmentProjection, Error)

Return the nearest point on a segment to an input point.

segment_projection_with

</>

pub fn segment_projection_with(
  point: vec2.Vec2(Float),
  to segment: Segment,
  options options: DistanceOptions,
) -> Result(SegmentProjection, Error)

Return the nearest point on a segment to an input point using explicit options.

segment_start

</>

pub fn segment_start(segment: Segment) -> vec2.Vec2(Float)

Return the start point of a segment.

segment_subpath_intersections

</>

pub fn segment_subpath_intersections(
  segment: Segment,
  subpath: Subpath,
) -> Result(
  List(#(vec2.Vec2(Float), Float, List(SubpathParameter))),
  Error,
)

Return the intersections between a segment and a subpath.

Each result contains an intersection point, its local parameter on the standalone segment, and every corresponding parameter on the subpath. Results are ordered by the standalone segment parameter. Parameters at both sides of a subpath segment boundary are retained.

segment_subpath_intersections_with

</>

pub fn segment_subpath_intersections_with(
  segment: Segment,
  subpath: Subpath,
  options options: IntersectionOptions,
) -> Result(
  List(#(vec2.Vec2(Float), Float, List(SubpathParameter))),
  Error,
)

Return the intersections between a segment and a subpath using explicit options.

segment_to_cubic_beziers

</>

pub fn segment_to_cubic_beziers(
  segment: Segment,
) -> List(Segment)

Convert a segment to one or more cubic Bezier curves.

Lines and quadratic Beziers are converted exactly. Cubic Beziers are returned unchanged. Arcs may become several cubic Bezier segments.

segment_to_lines

</>

pub fn segment_to_lines(
  segment: Segment,
) -> Result(List(Segment), Error)

Approximate a segment with one or more straight lines.

Lines are returned unchanged. Beziers and arcs are subdivided until each resulting chord is within the default geometric tolerance. Degenerate arcs fall back to a straight line between their endpoints.

segment_to_lines_with

</>

pub fn segment_to_lines_with(
  segment: Segment,
  options options: LinearizeOptions,
) -> Result(List(Segment), Error)

Approximate a segment with straight lines using explicit options.

segments

</>

pub fn segments(subpath: Subpath) -> List(Segment)

Return the segments in a subpath.

segments_between

</>

pub fn segments_between(
  segment: Segment,
  between points: List(Float),
) -> Result(List(Segment), Error)

Return segment portions between adjacent parameters.

Parameters are not clamped. Values outside 0.0..1.0 extrapolate along the same segment. Empty and singleton lists return an empty list.

segments_between_inside

</>

pub fn segments_between_inside(
  segment: Segment,
  between points: List(Float),
) -> Result(List(Segment), Error)

Return segment portions between adjacent parameters.

All parameters must be inside 0.0..1.0, inclusive. Empty and singleton lists return an empty list.

segments_between_lengths

</>

pub fn segments_between_lengths(
  segment: Segment,
  between distances: List(Float),
) -> Result(List(Segment), Error)

Return segment portions between adjacent traveled distances.

Distances are measured in path coordinate units from the segment start and must be inside 0.0..length, inclusive. Empty and singleton lists return an empty list.

segments_between_lengths_with

</>

pub fn segments_between_lengths_with(
  segment: Segment,
  between distances: List(Float),
  options options: LengthOptions,
) -> Result(List(Segment), Error)

Return segment portions between adjacent traveled distances using explicit length options.

set_closed

</>

pub fn set_closed(
  subpath: Subpath,
  closed closed: Bool,
) -> Result(Subpath, Error)

Set a subpath’s semantic closed state.

Setting closed to False always succeeds. Setting it to True requires a non-empty subpath’s end point to exactly match its start point. Empty subpaths may be closed.

set_closed_with

</>

pub fn set_closed_with(
  subpath: Subpath,
  closed closed: Bool,
  policy endpoint_policy: EndpointPolicy,
) -> Result(Subpath, Error)

Set a subpath’s semantic closed state with an endpoint policy.

Setting closed to False always succeeds. Setting it to True uses the given endpoint policy to reconcile a non-empty subpath’s end point with its start point. Empty subpaths may be closed.

splice

</>

pub fn splice(
  subpath: Subpath,
  start start: Int,
  delete delete: Int,
  insert insert: List(Segment),
) -> Result(Subpath, Error)

Replace a range of segments in a subpath.

start is a zero-based segment index and delete is the number of segments to remove. If start + delete extends past the end of the subpath, everything from start onward is deleted. Negative start, negative delete, and start greater than the subpath length return InvalidSplice.

The edited subpath must remain continuous. Closed subpaths preserve their closed state. If the splice result is nonempty, the subpath start is updated to the first resulting segment’s start point. If the splice result is empty, the previous start point is preserved.

splice_with

</>

pub fn splice_with(
  subpath: Subpath,
  start start: Int,
  delete delete: Int,
  insert insert: List(Segment),
  policy endpoint_policy: EndpointPolicy,
) -> Result(Subpath, Error)

Replace a range of segments in a subpath using the given endpoint policy.

split_segment

</>

pub fn split_segment(
  segment: Segment,
  at t: Float,
) -> Result(#(Segment, Segment), Error)

Split a segment at parameter t.

t is not clamped. Values outside 0.0..1.0 extrapolate along the same segment.

split_segment_inside

</>

pub fn split_segment_inside(
  segment: Segment,
  at t: Float,
) -> Result(#(Segment, Segment), Error)

Split a segment at parameter t, returning an error outside 0.0..1.0.

Values exactly at 0.0 or 1.0 are accepted and produce one zero-length segment.

split_subpath

</>

pub fn split_subpath(
  subpath: Subpath,
  at at: SubpathParameter,
) -> Result(#(Subpath, Subpath), Error)

Split an open subpath at a subpath parameter.

The split point must be inside the subpath: it cannot be the first point, the last point, outside the segment list, or outside the addressed segment’s 0.0..1.0 parameter range. Closed and empty subpaths are rejected.

start

</>

pub fn start(subpath: Subpath) -> Result(vec2.Vec2(Float), Error)

Return the start point of a subpath.

subpath

</>

pub fn subpath(segments: List(Segment)) -> Result(Subpath, Error)

Create an open subpath from a non-empty continuous list of segments.

Returns EmptySubpath if the segment list is empty. Use empty_subpath when you need to represent a move-only subpath.

Returns Discontinuous if any segment starts somewhere other than the previous segment’s end point. The error includes the two segment indices that failed to meet.

subpath_arcs_to_cubic_beziers

</>

pub fn subpath_arcs_to_cubic_beziers(subpath: Subpath) -> Subpath

Convert every arc in a subpath to cubic Bezier curves.

Lines, quadratic Beziers, and cubic Beziers are preserved. Elliptical arcs are approximated with one or more cubic Beziers, split into chunks of at most a quarter turn. Degenerate arcs fall back to a straight-line cubic Bezier between their endpoints.

subpath_between

</>

pub fn subpath_between(
  subpath: Subpath,
  from from: SubpathParameter,
  to to: SubpathParameter,
) -> Result(Subpath, Error)

Return the open subpath between two subpath parameters.

Parameters must be valid for the subpath and must describe a positive-length interval. Open subpaths reject reversed intervals. Closed subpaths allow wrapped intervals, but equal parameters are still rejected.

subpath_between_lengths

</>

pub fn subpath_between_lengths(
  subpath: Subpath,
  from from: Float,
  to to: Float,
) -> Result(Subpath, Error)

Return the open subpath between two traveled distances.

Distances are measured in path coordinate units from the subpath start and must be inside 0.0..length, inclusive. The resulting parameters follow the same interval rules as subpath_between.

subpath_between_lengths_with

</>

pub fn subpath_between_lengths_with(
  subpath: Subpath,
  from from: Float,
  to to: Float,
  options options: LengthOptions,
) -> Result(Subpath, Error)

Return the open subpath between two traveled distances using explicit length options.

subpath_bounding_box

</>

pub fn subpath_bounding_box(
  subpath: Subpath,
) -> Result(BoundingBox, Error)

Return a non-empty subpath’s exact axis-aligned bounding box.

subpath_containment

</>

pub fn subpath_containment(
  point: vec2.Vec2(Float),
  within subpath: Subpath,
  using fill_rule: FillRule,
) -> Result(PointContainment, Error)

Classify a point relative to a subpath’s fill area.

Open and closed subpaths use the same fill geometry: an open subpath is implicitly closed by a straight line from its end to its start. Move-only subpaths have no fill area or boundary.

subpath_containment_with

</>

pub fn subpath_containment_with(
  point: vec2.Vec2(Float),
  within subpath: Subpath,
  using fill_rule: FillRule,
  options options: ContainmentOptions,
) -> Result(PointContainment, Error)

Classify a point relative to a subpath’s fill area using explicit options.

tolerance is measured in path coordinate units and determines the width classified as Boundary. samples and max_iterations control numerical projection and adaptive line approximation for curves.

subpath_derivative

</>

pub fn subpath_derivative(
  subpath: Subpath,
  at parameter: SubpathParameter,
) -> Result(vec2.Vec2(Float), Error)

Return a subpath’s segment derivative at a subpath parameter.

The parameter must address a segment in the subpath, with t inside 0.0..1.0. Internal segment-end parameters are evaluated through their canonical next-segment start address.

subpath_derivative_at_length

</>

pub fn subpath_derivative_at_length(
  subpath: Subpath,
  distance distance: Float,
) -> Result(vec2.Vec2(Float), Error)

Return the subpath derivative at a traveled distance from the subpath start.

subpath_derivative_at_length_with

</>

pub fn subpath_derivative_at_length_with(
  subpath: Subpath,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(vec2.Vec2(Float), Error)

Return the subpath derivative at a traveled distance using explicit options.

subpath_intersections

</>

pub fn subpath_intersections(
  left: Subpath,
  right: Subpath,
) -> Result(List(SubpathIntersection), Error)

Return the point intersections between two subpaths.

Each result contains an intersection point and every corresponding parameter on both subpaths. Results are ordered by the first left parameter. Parameters at both sides of a subpath segment boundary are retained.

subpath_intersections_with

</>

pub fn subpath_intersections_with(
  left: Subpath,
  right: Subpath,
  options options: IntersectionOptions,
) -> Result(List(SubpathIntersection), Error)

Return the point intersections between two subpaths using explicit options.

subpath_length

</>

pub fn subpath_length(subpath: Subpath) -> Result(Float, Error)

Return the approximate length of a subpath.

Empty subpaths have length 0.0.

subpath_length_with

</>

pub fn subpath_length_with(
  subpath: Subpath,
  options options: LengthOptions,
) -> Result(Float, Error)

Return the approximate length of a subpath using explicit options.

subpath_parameter_at_length

</>

pub fn subpath_parameter_at_length(
  subpath: Subpath,
  distance distance: Float,
) -> Result(SubpathParameter, Error)

Return the subpath parameter at a traveled distance from the subpath start.

The distance is measured in path coordinate units, not normalized. The returned value is an ordinary public SubpathParameter.

subpath_parameter_at_length_with

</>

pub fn subpath_parameter_at_length_with(
  subpath: Subpath,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(SubpathParameter, Error)

Return the subpath parameter at a traveled distance using explicit options.

subpath_point

</>

pub fn subpath_point(
  subpath: Subpath,
  at parameter: SubpathParameter,
) -> Result(vec2.Vec2(Float), Error)

Evaluate a subpath at a subpath parameter.

The parameter must address a segment in the subpath, with t inside 0.0..1.0. Internal segment-end parameters are evaluated through their canonical next-segment start address.

subpath_point_at_length

</>

pub fn subpath_point_at_length(
  subpath: Subpath,
  distance distance: Float,
) -> Result(vec2.Vec2(Float), Error)

Return the subpath point at a traveled distance from the subpath start.

subpath_point_at_length_with

</>

pub fn subpath_point_at_length_with(
  subpath: Subpath,
  distance distance: Float,
  options options: LengthOptions,
) -> Result(vec2.Vec2(Float), Error)

Return the subpath point at a traveled distance using explicit options.

subpath_projection

</>

pub fn subpath_projection(
  point: vec2.Vec2(Float),
  to subpath: Subpath,
) -> Result(SubpathProjection, Error)

Return the nearest point on a subpath to an input point.

subpath_projection_with

</>

pub fn subpath_projection_with(
  point: vec2.Vec2(Float),
  to subpath: Subpath,
  options options: DistanceOptions,
) -> Result(SubpathProjection, Error)

Return the nearest point on a subpath to an input point using explicit options.

subpath_self_intersections

</>

pub fn subpath_self_intersections(
  subpath: Subpath,
) -> Result(List(SubpathSelfIntersection), Error)

Return point intersections where a subpath intersects itself.

Results are ordered by the first parameter. Adjacent segment endpoints are filtered by arc-length separation, so ordinary segment joins are not reported as self-intersections.

subpath_self_intersections_with

</>

pub fn subpath_self_intersections_with(
  subpath: Subpath,
  options options: SelfIntersectionOptions,
) -> Result(List(SubpathSelfIntersection), Error)

Return point intersections where a subpath intersects itself using explicit options.

subpath_to_cubic_beziers

</>

pub fn subpath_to_cubic_beziers(subpath: Subpath) -> Subpath

Convert every segment in a subpath to cubic Bezier curves.

Lines and quadratic Beziers are converted exactly. Cubic Beziers are preserved. Elliptical arcs are approximated with one or more cubic Beziers, split into chunks of at most a quarter turn.

subpath_to_lines

</>

pub fn subpath_to_lines(
  subpath: Subpath,
) -> Result(Subpath, Error)

Approximate every segment in a subpath with straight lines.

The subpath’s start point and closed state are preserved. Move-only subpaths remain move-only.

subpath_to_lines_with

</>

pub fn subpath_to_lines_with(
  subpath: Subpath,
  options options: LinearizeOptions,
) -> Result(Subpath, Error)

Approximate every segment in a subpath with straight lines using explicit options.

subpath_with

</>

pub fn subpath_with(
  segments: List(Segment),
  policy endpoint_policy: EndpointPolicy,
) -> Result(Subpath, Error)

Create an open subpath using the given endpoint reconciliation policy.

Empty segment lists still return EmptySubpath.

subpaths

</>

pub fn subpaths(path: Path) -> List(Subpath)

Return the subpaths in a path.

subpaths_between

</>

pub fn subpaths_between(
  subpath: Subpath,
  between points: List(SubpathParameter),
) -> Result(List(Subpath), Error)

Split a subpath at multiple subpath parameters.

Open subpaths return the outer pieces as well as the pieces between split points, so an empty split list returns the original subpath. Open split points must be strictly increasing and cannot include the very start or very end. Closed split points must be cyclically increasing and distinct. For closed subpaths, an empty split list returns an empty list, and a single split point returns one open subpath traversing the whole loop from that point back to itself.

subpaths_between_lengths

</>

pub fn subpaths_between_lengths(
  subpath: Subpath,
  between distances: List(Float),
) -> Result(List(Subpath), Error)

Split a subpath at multiple traveled distances.

Distances are measured in path coordinate units from the subpath start and must be inside 0.0..length, inclusive. The resulting parameters follow the same split-point rules as subpaths_between.

subpaths_between_lengths_with

</>

pub fn subpaths_between_lengths_with(
  subpath: Subpath,
  between distances: List(Float),
  options options: LengthOptions,
) -> Result(List(Subpath), Error)

Split a subpath at multiple traveled distances using explicit length options.