@mlightcad/geometry-engine 3.2.38 → 3.2.40

package/lib/geometry/AcGePolyline2dOffset.js

@@ -0,0 +1,886 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { AcGePoint2d } from '../math/AcGePoint2d';
+import { AcGeMathUtil, AcGeTol, TAU } from '../util';
+import { AcGeCircArc2d } from './AcGeCircArc2d';
+import { AcGePolyline2d } from './AcGePolyline2d';
+/** Epsilon for circle–circle intersection and tangency tests during arc joins. */
+var ROUND_JOIN_POINT_EPSILON = 1e-6;
+/**
+ * Creates offset curves for a 2D polyline in the XY plane.
+ *
+ * Routing depends on polyline content:
+ * - Polylines with bulge (arc) segments use analytic line/arc offset and custom joins.
+ * - Vertex-only polylines (open or closed) use parallel edge offset with miter intersections.
+ *
+ * Sign convention: positive `offsetDist` offsets to the left of the travel direction
+ * along each segment (consistent with AutoCAD-style polyline offset).
+ *
+ * @param polyline - Source polyline; may be open or closed, with or without bulge arcs
+ * @param offsetDist - Signed offset distance in drawing units (left = positive)
+ * @returns One or more offset polylines; empty array when offsetting fails or input is degenerate
+ */
+export function offsetAcGePolyline2d(polyline, offsetDist) {
+    if (hasArcSegments(polyline)) {
+        var result_1 = offsetPolylineWithArcSegments(polyline, offsetDist);
+        return result_1 ? [result_1] : [];
+    }
+    var source = normalizeVertexPolyline(polyline);
+    var n = source.numberOfVertices;
+    if (n < 2)
+        return [];
+    var result = createVertexOnlyPolylineOffset(source, offsetDist);
+    return result ? [result] : [];
+}
+/**
+ * Normalizes a vertex-only polyline before offset or other geometric processing.
+ *
+ * Removes consecutive duplicate vertices and, for closed paths, drops a closing
+ * vertex that coincides with the first vertex so downstream algorithms see a
+ * minimal vertex ring.
+ *
+ * @param polyline - Input polyline (typically straight segments only)
+ * @returns The same instance if already normalized, otherwise a new polyline with cleaned vertices
+ */
+export function preparePolylineForOffset(polyline) {
+    return normalizeVertexPolyline(polyline);
+}
+/**
+ * Offsets a polyline that contains one or more bulge-defined arc segments.
+ *
+ * Each segment is offset individually (parallel line or concentric arc), then
+ * segment ends are joined at original vertices with miter, tangent, or round
+ * fallbacks as appropriate.
+ *
+ * @param polyline - Source polyline with at least one non-zero bulge
+ * @param offsetDist - Signed offset distance in drawing units
+ * @returns A single closed or open offset polyline, or `null` if any segment offset or join fails
+ */
+function offsetPolylineWithArcSegments(polyline, offsetDist) {
+    var e_1, _a;
+    var segments = collectPlanarSegments(polyline);
+    if (segments.length === 0)
+        return null;
+    var offsetSegments = [];
+    try {
+        for (var segments_1 = __values(segments), segments_1_1 = segments_1.next(); !segments_1_1.done; segments_1_1 = segments_1.next()) {
+            var segment = segments_1_1.value;
+            var offsetSegment = offsetPlanarSegment(segment, offsetDist);
+            if (!offsetSegment)
+                return null;
+            offsetSegments.push(offsetSegment);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (segments_1_1 && !segments_1_1.done && (_a = segments_1.return)) _a.call(segments_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var joinVertices = collectJoinVertices(polyline);
+    var points = buildJoinedOffsetPath(offsetSegments, joinVertices, polyline.closed, offsetDist);
+    if (points.length < 2)
+        return null;
+    var result = new AcGePolyline2d();
+    points.forEach(function (point, index) {
+        result.addVertexAt(index, { x: point.x, y: point.y });
+    });
+    result.closed = polyline.closed;
+    return result;
+}
+/**
+ * Decomposes a polyline into ordered planar segments in traversal order.
+ *
+ * Each edge from vertex `i` to `(i + 1) % n` becomes either a line chord (zero bulge)
+ * or a circular arc constructed from start vertex, end vertex, and bulge.
+ *
+ * @param polyline - Source polyline
+ * @returns Array of line and arc segments; empty when the polyline has fewer than two vertices (open) or one vertex (closed)
+ */
+function collectPlanarSegments(polyline) {
+    var _a;
+    var segments = [];
+    var count = polyline.numberOfVertices;
+    var segmentCount = polyline.closed ? count : count - 1;
+    for (var i = 0; i < segmentCount; i++) {
+        var start = polyline.vertices[i];
+        var end = polyline.vertices[(i + 1) % count];
+        if (AcGeTol.isPositive(Math.abs((_a = start.bulge) !== null && _a !== void 0 ? _a : 0))) {
+            segments.push({
+                kind: 'arc',
+                arc: new AcGeCircArc2d(start, end, start.bulge)
+            });
+        }
+        else {
+            segments.push({
+                kind: 'line',
+                start: new AcGePoint2d(start.x, start.y),
+                end: new AcGePoint2d(end.x, end.y)
+            });
+        }
+    }
+    return segments;
+}
+/**
+ * Collects the 2D positions of all polyline vertices in index order.
+ *
+ * Used as join anchors when connecting offset segments at original corners.
+ *
+ * @param polyline - Source polyline
+ * @returns Clone-free point list matching `polyline.numberOfVertices` entries
+ */
+function collectJoinVertices(polyline) {
+    var vertices = [];
+    for (var i = 0; i < polyline.numberOfVertices; i++) {
+        vertices.push(polyline.getPointAt(i));
+    }
+    return vertices;
+}
+/**
+ * Offsets a single planar segment by the signed distance.
+ *
+ * @param segment - Line chord or bulge arc segment
+ * @param offsetDist - Signed offset distance (left of travel = positive)
+ * @returns Offset line (with direction vector) or offset arc, or `null` if degenerate
+ */
+function offsetPlanarSegment(segment, offsetDist) {
+    if (segment.kind === 'line') {
+        var offsetLine = offsetLineSegment(segment.start, segment.end, offsetDist);
+        if (!offsetLine)
+            return null;
+        return __assign({ kind: 'line' }, offsetLine);
+    }
+    var offsetArc = offsetCircArc2d(segment.arc, segment.arc.startPoint, segment.arc.endPoint, offsetDist);
+    if (!offsetArc)
+        return null;
+    return { kind: 'arc', arc: offsetArc };
+}
+/**
+ * Builds a concentric circular arc at the requested offset from a source arc.
+ *
+ * Radius change follows the same left-hand rule as line offset via {@link getArcRadiusDelta}.
+ *
+ * @param arc - Source circular arc
+ * @param start - Start point of the arc segment (chord start)
+ * @param end - End point of the arc segment (chord end)
+ * @param offsetDist - Signed offset distance
+ * @returns New arc sharing center and angles, or `null` if the offset radius is non-positive
+ */
+function offsetCircArc2d(arc, start, end, offsetDist) {
+    var radiusDelta = getArcRadiusDelta(arc, start, end, offsetDist);
+    var radius = arc.radius + radiusDelta;
+    if (AcGeTol.isNonPositive(radius))
+        return null;
+    return new AcGeCircArc2d(arc.center, radius, arc.startAngle, arc.endAngle, arc.clockwise);
+}
+/**
+ * Computes the signed radius change for a concentric arc offset.
+ *
+ * Applies the same left-hand offset rule used for line segments: positive
+ * `offsetDist` shifts the arc to the left of its travel direction.
+ *
+ * Concentric offset direction depends on which side of the chord the center
+ * lies: when the center is on the left, shrink the radius; when on the right,
+ * expand it. Degenerate zero-length chords fall back to clockwise flag only.
+ *
+ * @param arc - Source circular arc
+ * @param start - Chord start point
+ * @param end - Chord end point
+ * @param offsetDist - Signed offset distance
+ * @returns Signed delta to add to `arc.radius` (not the new radius itself)
+ */
+function getArcRadiusDelta(arc, start, end, offsetDist) {
+    var dx = end.x - start.x;
+    var dy = end.y - start.y;
+    var len = Math.hypot(dx, dy);
+    if (AcGeTol.isNonPositive(len)) {
+        return arc.clockwise ? -offsetDist : offsetDist;
+    }
+    var leftNx = -dy / len;
+    var leftNy = dx / len;
+    var toCenterX = arc.center.x - (start.x + end.x) / 2;
+    var toCenterY = arc.center.y - (start.y + end.y) / 2;
+    var centerOnLeft = toCenterX * leftNx + toCenterY * leftNy > 0;
+    return centerOnLeft ? -offsetDist : offsetDist;
+}
+/**
+ * Offsets a finite line segment parallel to itself.
+ *
+ * The offset direction is the left normal scaled by `offsetDist`. The returned
+ * `dx`/`dy` match the original edge direction for use in later miter joins.
+ *
+ * @param start - Segment start
+ * @param end - Segment end
+ * @param offsetDist - Signed offset distance
+ * @returns Offset endpoints plus original direction components, or `null` if the segment length is zero
+ */
+function offsetLineSegment(start, end, offsetDist) {
+    var dx = end.x - start.x;
+    var dy = end.y - start.y;
+    var len = Math.hypot(dx, dy);
+    if (AcGeTol.isNonPositive(len))
+        return null;
+    var nx = (-dy / len) * offsetDist;
+    var ny = (dx / len) * offsetDist;
+    return {
+        start: new AcGePoint2d(start.x + nx, start.y + ny),
+        end: new AcGePoint2d(end.x + nx, end.y + ny),
+        dx: dx,
+        dy: dy
+    };
+}
+/**
+ * Assembles a continuous polyline path from offset segments and per-vertex join data.
+ *
+ * Walks segments in order, emitting join points, optional round fillet samples,
+ * and interior samples along offset arcs between join limits.
+ *
+ * @param offsetSegments - Per-edge offset geometry in path order
+ * @param joinVertices - Original polyline vertices used as join anchors
+ * @param closed - Whether the path wraps from last segment back to first
+ * @param offsetDist - Signed offset distance (used for round-join radius)
+ * @returns Ordered vertex chain with consecutive duplicates removed
+ */
+function buildJoinedOffsetPath(offsetSegments, joinVertices, closed, offsetDist) {
+    var _a, _b, _c;
+    var count = offsetSegments.length;
+    if (count === 0)
+        return [];
+    var joins = computeSegmentJoins(offsetSegments, joinVertices, closed, offsetDist);
+    var points = [
+        (_b = (_a = joins[0].nextSegmentStart) === null || _a === void 0 ? void 0 : _a.clone()) !== null && _b !== void 0 ? _b : joins[0].point.clone()
+    ];
+    for (var i = 0; i < count; i++) {
+        var segment = offsetSegments[i];
+        var joinAtEnd = i === count - 1 && !closed
+            ? {
+                point: getOffsetSegmentEnd(segment)
+            }
+            : joins[(i + 1) % count];
+        if (i > 0 && joins[i].filletPoints) {
+            joins[i].filletPoints.forEach(function (point) { return points.push(point.clone()); });
+        }
+        if (segment.kind === 'arc') {
+            var arcStart = (_c = joins[i].nextSegmentStart) !== null && _c !== void 0 ? _c : joins[i].point;
+            var arcEnd = joinAtEnd.point;
+            var arcSamples = sampleArcBetweenPoints(segment.arc, arcStart, arcEnd, Math.max(16, 32));
+            for (var j = 1; j < arcSamples.length; j++) {
+                points.push(arcSamples[j]);
+            }
+        }
+        else {
+            points.push(joinAtEnd.point.clone());
+        }
+    }
+    return dedupeConsecutivePoints(points);
+}
+/**
+ * Computes join information at every vertex between consecutive offset segments.
+ *
+ * For closed polylines, index `0` joins the last and first offset segments at
+ * `joinVertices[0]`. For open polylines, the start uses the first segment's
+ * offset start without a prior join.
+ *
+ * @param offsetSegments - Offset segments in path order
+ * @param joinVertices - Original corner vertices
+ * @param closed - Whether the polyline is closed
+ * @param offsetDist - Signed offset distance for round joins
+ * @returns One {@link SegmentJoinInfo} per segment, aligned with segment indices
+ */
+function computeSegmentJoins(offsetSegments, joinVertices, closed, offsetDist) {
+    var count = offsetSegments.length;
+    var joins = [];
+    for (var i = 0; i < count; i++) {
+        if (i === 0) {
+            joins.push(closed
+                ? joinOffsetSegments(offsetSegments[count - 1], offsetSegments[0], joinVertices[0], offsetDist)
+                : { point: getOffsetSegmentStart(offsetSegments[0]) });
+        }
+        else {
+            joins.push(joinOffsetSegments(offsetSegments[i - 1], offsetSegments[i], joinVertices[i], offsetDist));
+        }
+    }
+    return joins;
+}
+/**
+ * Samples points along a circular arc between two arbitrary points on the arc.
+ *
+ * Projects `start` and `end` onto the arc, measures sweep in internal angle
+ * space, and interpolates at uniform parameter steps. Endpoints are included.
+ *
+ * @param arc - Circular arc to sample
+ * @param start - Approximate start of the sampled span (need not lie exactly on the arc)
+ * @param end - Approximate end of the sampled span
+ * @param numPoints - Number of interior divisions (total samples = `numPoints + 1`)
+ * @returns Polyline of sampled points from start to end along the arc
+ */
+function sampleArcBetweenPoints(arc, start, end, numPoints) {
+    var startOnArc = arc.nearestPoint(start);
+    var endOnArc = arc.nearestPoint(end);
+    var startInternal = internalAngleAtPoint(arc, startOnArc);
+    var endInternal = internalAngleAtPoint(arc, endOnArc);
+    var sweep = sweepAlongArc(arc, startInternal, endInternal);
+    var points = [];
+    for (var i = 0; i <= numPoints; i++) {
+        var t = i / numPoints;
+        var internalAngle = arc.clockwise
+            ? startInternal - sweep * t
+            : startInternal + sweep * t;
+        points.push(arc.getPointAtAngle(publicAngleFromInternal(arc, internalAngle)));
+    }
+    return points;
+}
+/**
+ * Returns the mathematical polar angle from the arc center to a point.
+ *
+ * @param arc - Circular arc providing the center
+ * @param point - Point in the arc plane
+ * @returns Angle in radians in `[-π, π]`, consistent with `Math.atan2`
+ */
+function internalAngleAtPoint(arc, point) {
+    return Math.atan2(point.y - arc.center.y, point.x - arc.center.x);
+}
+/**
+ * Converts an internal (mathematical) angle to the public angle used by {@link AcGeCircArc2d}.
+ *
+ * Counterclockwise arcs use normalized mathematical angles; clockwise arcs apply
+ * the arc's mirrored angle convention.
+ *
+ * @param arc - Circular arc defining clockwise vs counterclockwise storage
+ * @param internalAngle - Angle in internal/mathematical space
+ * @returns Angle suitable for `arc.getPointAtAngle`
+ */
+function publicAngleFromInternal(arc, internalAngle) {
+    var normalized = AcGeMathUtil.normalizeAngle(internalAngle);
+    return arc.clockwise ? mirrorAngle(normalized) : normalized;
+}
+/**
+ * Mirrors a mathematical angle into the clockwise arc angle convention.
+ *
+ * @param angle - Angle in radians (mathematical convention)
+ * @returns Mirrored angle in radians for clockwise arc parameterization
+ */
+function mirrorAngle(angle) {
+    var degrees = (angle * 180) / Math.PI;
+    return ((360 - degrees) % 360) * (Math.PI / 180);
+}
+/**
+ * Computes the positive sweep from one internal angle to another along the arc.
+ *
+ * @param arc - Circular arc (direction from `clockwise`)
+ * @param fromInternal - Start internal angle
+ * @param toInternal - End internal angle
+ * @returns Positive sweep magnitude in radians along the arc direction
+ */
+function sweepAlongArc(arc, fromInternal, toInternal) {
+    if (arc.clockwise) {
+        var sweep_1 = fromInternal - toInternal;
+        if (AcGeTol.isNonPositive(sweep_1)) {
+            sweep_1 += TAU;
+        }
+        return sweep_1;
+    }
+    var sweep = toInternal - fromInternal;
+    if (AcGeTol.isNonPositive(sweep)) {
+        sweep += TAU;
+    }
+    return sweep;
+}
+/**
+ * Returns the start point of an offset segment in path order.
+ *
+ * @param segment - Line or arc offset segment
+ * @returns Cloned start point of the offset geometry
+ */
+function getOffsetSegmentStart(segment) {
+    return segment.kind === 'line'
+        ? segment.start.clone()
+        : segment.arc.startPoint.clone();
+}
+/**
+ * Returns the end point of an offset segment in path order.
+ *
+ * @param segment - Line or arc offset segment
+ * @returns Cloned end point of the offset geometry
+ */
+function getOffsetSegmentEnd(segment) {
+    return segment.kind === 'line'
+        ? segment.end.clone()
+        : segment.arc.endPoint.clone();
+}
+/**
+ * Resolves the connection between two consecutive offset segments at a corner vertex.
+ *
+ * Dispatches to line–line miter, line–arc, arc–line, or arc–arc join logic.
+ * Falls back to the original vertex when segment kinds are unexpected.
+ *
+ * @param previous - Offset segment entering the vertex
+ * @param next - Offset segment leaving the vertex
+ * @param vertex - Original polyline corner
+ * @param offsetDist - Signed offset distance (magnitude used for round joins)
+ * @returns Join point and optional fillet bridging to the next segment
+ */
+function joinOffsetSegments(previous, next, vertex, offsetDist) {
+    if (previous.kind === 'line' && next.kind === 'line') {
+        return {
+            point: intersectPolylineOffsetSegments({
+                start: previous.start,
+                end: previous.end,
+                dx: previous.dx,
+                dy: previous.dy
+            }, {
+                start: next.start,
+                end: next.end,
+                dx: next.dx,
+                dy: next.dy
+            })
+        };
+    }
+    if (previous.kind === 'line' && next.kind === 'arc') {
+        return joinLineWithArcOffset(previous, next.arc, vertex, offsetDist, true);
+    }
+    if (previous.kind === 'arc' && next.kind === 'line') {
+        return joinLineWithArcOffset(next, previous.arc, vertex, offsetDist, false);
+    }
+    if (previous.kind === 'arc' && next.kind === 'arc') {
+        return joinArcWithArcOffset(previous.arc, next.arc, vertex, offsetDist);
+    }
+    return { point: vertex.clone() };
+}
+/**
+ * Joins two offset circular arcs meeting at a common vertex.
+ *
+ * Prefers a point on both offset arcs near the gap midpoint (circle–circle
+ * intersection). If none exists, inserts a round join sampled around the vertex.
+ *
+ * @param previous - Offset arc ending at the vertex
+ * @param next - Offset arc starting at the vertex
+ * @param vertex - Original corner vertex
+ * @param offsetDist - Signed offset distance (absolute value = fillet radius)
+ * @returns Miter point on both arcs, or round join with separate segment endpoints
+ */
+function joinArcWithArcOffset(previous, next, vertex, offsetDist) {
+    var near = midpoint(previous.endPoint, next.startPoint);
+    var candidates = intersectOffsetCircles(previous, next);
+    var onBoth = candidates.filter(function (candidate) {
+        return isPointOnArc(previous, candidate) && isPointOnArc(next, candidate);
+    });
+    if (onBoth.length > 0) {
+        return { point: pickClosestPoint(onBoth, near) };
+    }
+    var from = previous.endPoint.clone();
+    var to = next.startPoint.clone();
+    var filletPoints = sampleVertexRoundJoin(vertex, Math.abs(offsetDist), from, to);
+    return {
+        point: from,
+        filletPoints: filletPoints,
+        nextSegmentStart: to
+    };
+}
+/**
+ * Joins an offset line segment with an offset arc at a shared vertex.
+ *
+ * @param line - Offset line segment (includes direction `dx`/`dy`)
+ * @param arc - Offset circular arc on the other side of the vertex
+ * @param vertex - Original corner vertex
+ * @param offsetDist - Signed offset distance
+ * @param lineBeforeArc - `true` if `line` is the incoming segment and `arc` is outgoing
+ * @returns Intersection on both primitives, or round join with optional `nextSegmentStart`
+ */
+function joinLineWithArcOffset(line, arc, vertex, offsetDist, lineBeforeArc) {
+    var near = midpoint(lineBeforeArc ? line.end : line.start, lineBeforeArc ? arc.startPoint : arc.endPoint);
+    var intersection = intersectLineWithCircle(line, arc, near);
+    if (isPointOnOffsetLine(line, intersection) &&
+        isPointOnArc(arc, intersection)) {
+        return { point: intersection };
+    }
+    var lineSide = getLineOffsetPointAtVertex(line, vertex, offsetDist);
+    var arcSide = lineBeforeArc ? arc.startPoint.clone() : arc.endPoint.clone();
+    var filletPoints = sampleVertexRoundJoin(vertex, Math.abs(offsetDist), lineBeforeArc ? lineSide : arcSide, lineBeforeArc ? arcSide : lineSide);
+    if (lineBeforeArc) {
+        return {
+            point: lineSide,
+            filletPoints: filletPoints,
+            nextSegmentStart: arcSide
+        };
+    }
+    return {
+        point: arcSide,
+        filletPoints: filletPoints,
+        nextSegmentStart: lineSide
+    };
+}
+/**
+ * Computes the offset line point closest to a vertex along the left normal.
+ *
+ * @param line - Offset line with original edge direction `dx`/`dy`
+ * @param vertex - Corner on the source polyline
+ * @param offsetDist - Signed offset distance
+ * @returns Point on the infinite offset line through the vertex
+ */
+function getLineOffsetPointAtVertex(line, vertex, offsetDist) {
+    var len = Math.hypot(line.dx, line.dy);
+    var nx = (-line.dy / len) * offsetDist;
+    var ny = (line.dx / len) * offsetDist;
+    return new AcGePoint2d(vertex.x + nx, vertex.y + ny);
+}
+/**
+ * Tests whether a point lies on the infinite line supporting an offset segment.
+ *
+ * @param line - Offset line with start and direction
+ * @param point - Candidate point
+ * @returns `true` if perpendicular distance to the line is within tolerance
+ */
+function isPointOnOffsetLine(line, point) {
+    var len = Math.hypot(line.dx, line.dy);
+    if (AcGeTol.isNonPositive(len))
+        return false;
+    var ux = line.dx / len;
+    var uy = line.dy / len;
+    var px = point.x - line.start.x;
+    var py = point.y - line.start.y;
+    var perp = Math.abs(px * uy - py * ux);
+    return AcGeTol.equalToZero(perp);
+}
+/**
+ * Samples interior points of a circular round join at a vertex.
+ *
+ * Arc spans the shorter rotation from `from` to `to` about `vertex` at `radius`.
+ * Endpoints are excluded from the returned list.
+ *
+ * @param vertex - Center of the round join
+ * @param radius - Fillet radius (positive)
+ * @param from - Start direction point on the fillet circle
+ * @param to - End direction point on the fillet circle
+ * @returns Interior fillet samples; empty when start and end directions coincide
+ */
+function sampleVertexRoundJoin(vertex, radius, from, to) {
+    var a1 = Math.atan2(from.y - vertex.y, from.x - vertex.x);
+    var a2 = Math.atan2(to.y - vertex.y, to.x - vertex.x);
+    var sweep = shortestAngleSweep(a1, a2);
+    if (AcGeTol.equalToZero(Math.abs(sweep))) {
+        return [];
+    }
+    var points = [];
+    var steps = Math.max(2, Math.ceil((Math.abs(sweep) / Math.PI) * 16));
+    for (var i = 1; i < steps; i++) {
+        var t = i / steps;
+        var angle = a1 + sweep * t;
+        points.push(new AcGePoint2d(vertex.x + radius * Math.cos(angle), vertex.y + radius * Math.sin(angle)));
+    }
+    return points;
+}
+/**
+ * Returns the shortest signed angular sweep from one direction to another.
+ *
+ * @param from - Start angle in radians
+ * @param to - End angle in radians
+ * @returns Signed sweep in `(-π, π]`
+ */
+function shortestAngleSweep(from, to) {
+    var sweep = to - from;
+    while (sweep > Math.PI) {
+        sweep -= TAU;
+    }
+    while (sweep <= -Math.PI) {
+        sweep += TAU;
+    }
+    return sweep;
+}
+/**
+ * Intersects an infinite offset line with a circle (offset arc boundary).
+ *
+ * @param line - Offset line segment defining origin and direction
+ * @param arc - Circular arc whose radius and center define the circle
+ * @param near - Preference point when choosing among multiple intersections
+ * @returns Closest valid intersection to `near`, or `near` when no real roots exist
+ */
+function intersectLineWithCircle(line, arc, near) {
+    var dirLen = Math.hypot(line.dx, line.dy);
+    if (AcGeTol.isNonPositive(dirLen)) {
+        return near.clone();
+    }
+    var ux = line.dx / dirLen;
+    var uy = line.dy / dirLen;
+    var fx = line.start.x - arc.center.x;
+    var fy = line.start.y - arc.center.y;
+    var b = 2 * (fx * ux + fy * uy);
+    var c = fx * fx + fy * fy - arc.radius * arc.radius;
+    var discriminant = b * b - 4 * c;
+    if (discriminant < 0) {
+        return near.clone();
+    }
+    var sqrtDisc = Math.sqrt(discriminant);
+    var candidates = [(-b - sqrtDisc) / 2, (-b + sqrtDisc) / 2].map(function (t) { return new AcGePoint2d(line.start.x + ux * t, line.start.y + uy * t); });
+    var onArc = candidates.filter(function (candidate) { return isPointOnArc(arc, candidate); });
+    return pickClosestPoint(onArc.length > 0 ? onArc : candidates, near);
+}
+/**
+ * Tests whether a point lies on a circular arc segment (not merely on the full circle).
+ *
+ * @param arc - Circular arc with defined start/end and clockwise flag
+ * @param point - Candidate point
+ * @returns `true` if distance to center matches radius and angle is within the arc span
+ */
+function isPointOnArc(arc, point) {
+    var radiusDelta = Math.abs(Math.hypot(point.x - arc.center.x, point.y - arc.center.y) - arc.radius);
+    if (AcGeTol.isPositive(radiusDelta)) {
+        return false;
+    }
+    var internalAngle = internalAngleAtPoint(arc, point);
+    var internalStart = arc.clockwise
+        ? mirrorAngle(AcGeMathUtil.normalizeAngle(arc.startAngle))
+        : AcGeMathUtil.normalizeAngle(arc.startAngle);
+    var internalEnd = arc.clockwise
+        ? mirrorAngle(AcGeMathUtil.normalizeAngle(arc.endAngle))
+        : AcGeMathUtil.normalizeAngle(arc.endAngle);
+    return AcGeMathUtil.isBetweenAngle(internalAngle, internalStart, internalEnd, arc.clockwise);
+}
+/**
+ * Intersects two circles defined by offset arc centers and radii.
+ *
+ * @param a - First offset arc (circle at `a.center` with radius `a.radius`)
+ * @param b - Second offset arc
+ * @returns Zero, one (tangent), or two intersection points; empty when circles are separated or nested beyond tolerance
+ */
+function intersectOffsetCircles(a, b) {
+    var dx = b.center.x - a.center.x;
+    var dy = b.center.y - a.center.y;
+    var dist = Math.hypot(dx, dy);
+    if (AcGeTol.isNonPositive(dist)) {
+        return [];
+    }
+    var radiusSum = a.radius + b.radius;
+    var radiusDiff = Math.abs(a.radius - b.radius);
+    if (dist > radiusSum + ROUND_JOIN_POINT_EPSILON) {
+        return [];
+    }
+    if (dist < radiusDiff - ROUND_JOIN_POINT_EPSILON) {
+        return [];
+    }
+    var aTerm = (a.radius * a.radius - b.radius * b.radius + dist * dist) / (2 * dist);
+    var hSquared = a.radius * a.radius - aTerm * aTerm;
+    if (hSquared < -ROUND_JOIN_POINT_EPSILON) {
+        return [];
+    }
+    var mx = a.center.x + (aTerm * dx) / dist;
+    var my = a.center.y + (aTerm * dy) / dist;
+    if (hSquared <= ROUND_JOIN_POINT_EPSILON) {
+        return [new AcGePoint2d(mx, my)];
+    }
+    var h = Math.sqrt(hSquared);
+    var rx = (-dy * h) / dist;
+    var ry = (dx * h) / dist;
+    return [new AcGePoint2d(mx + rx, my + ry), new AcGePoint2d(mx - rx, my - ry)];
+}
+/**
+ * Selects the candidate point closest to a reference location.
+ *
+ * @param points - Non-empty list of candidates
+ * @param near - Reference point for distance comparison
+ * @returns Clone of the closest candidate
+ */
+function pickClosestPoint(points, near) {
+    var best = points[0];
+    var bestDist = best.distanceToSquared(near);
+    for (var i = 1; i < points.length; i++) {
+        var dist = points[i].distanceToSquared(near);
+        if (dist < bestDist) {
+            best = points[i];
+            bestDist = dist;
+        }
+    }
+    return best.clone();
+}
+/**
+ * Computes the component-wise midpoint between two points.
+ *
+ * @param a - First point
+ * @param b - Second point
+ * @returns New point at `(a + b) / 2`
+ */
+function midpoint(a, b) {
+    return new AcGePoint2d((a.x + b.x) / 2, (a.y + b.y) / 2);
+}
+/**
+ * Determines whether a polyline contains any bulge-defined arc segments.
+ *
+ * @param polyline - Polyline to inspect
+ * @returns `true` if any edge has a non-zero bulge within tolerance
+ */
+function hasArcSegments(polyline) {
+    var _a;
+    var count = polyline.numberOfVertices;
+    var segmentCount = polyline.closed ? count : count - 1;
+    for (var i = 0; i < segmentCount; i++) {
+        var vertex = polyline.vertices[i];
+        if (AcGeTol.isPositive(Math.abs((_a = vertex.bulge) !== null && _a !== void 0 ? _a : 0))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Returns a vertex-only polyline with normalized path points.
+ *
+ * @param polyline - Input polyline
+ * @returns `polyline` unchanged when already normalized, else a new instance
+ */
+function normalizeVertexPolyline(polyline) {
+    var points = normalizePathPoints(polyline.vertices.map(function (vertex) { return new AcGePoint2d(vertex.x, vertex.y); }), polyline.closed);
+    if (points.length === polyline.numberOfVertices) {
+        return polyline;
+    }
+    return new AcGePolyline2d(points.map(function (point) { return ({ x: point.x, y: point.y }); }), polyline.closed);
+}
+/**
+ * Deduplicates consecutive vertices and removes redundant closure for closed paths.
+ *
+ * @param points - Vertex chain in order
+ * @param closed - Whether the path is closed
+ * @returns Cleaned vertex list
+ */
+function normalizePathPoints(points, closed) {
+    var deduped = dedupeConsecutivePoints(points);
+    if (!closed || deduped.length < 2)
+        return deduped;
+    var first = deduped[0];
+    var last = deduped[deduped.length - 1];
+    if (AcGeTol.isNonPositive(Math.hypot(first.x - last.x, first.y - last.y))) {
+        deduped.pop();
+    }
+    return deduped;
+}
+/**
+ * Removes consecutive vertices that coincide within geometric tolerance.
+ *
+ * @param points - Input vertex chain (may contain duplicates)
+ * @returns New array with only distinct consecutive points
+ */
+function dedupeConsecutivePoints(points) {
+    var result = [];
+    points.forEach(function (point) {
+        var last = result[result.length - 1];
+        if (!last ||
+            AcGeTol.isPositive(Math.hypot(last.x - point.x, last.y - point.y))) {
+            result.push(new AcGePoint2d(point.x, point.y));
+        }
+    });
+    return result;
+}
+/**
+ * Offsets a vertex-only polyline (open or closed) composed of straight segments.
+ *
+ * Each edge is offset parallel to itself; consecutive offset lines are joined with
+ * miter intersections. Open paths keep raw offset starts/ends; closed paths join
+ * cyclically at every corner.
+ *
+ * @param polyline - Vertex-only polyline with at least two vertices
+ * @param offsetDist - Signed offset distance
+ * @returns Offset polyline, or `null` if no valid edges remain after skipping zero-length segments
+ */
+function createVertexOnlyPolylineOffset(polyline, offsetDist) {
+    var sourcePoints = [];
+    for (var i = 0; i < polyline.numberOfVertices; i++) {
+        sourcePoints.push(polyline.getPointAt(i));
+    }
+    var offsetSegments = buildPolylineOffsetSegments(sourcePoints, polyline.closed, offsetDist);
+    if (offsetSegments.length === 0)
+        return null;
+    var resultPoints = [];
+    if (polyline.closed) {
+        if (offsetSegments.length < 2)
+            return null;
+        var count = offsetSegments.length;
+        for (var i = 0; i < count; i++) {
+            var prev = offsetSegments[(i - 1 + count) % count];
+            var curr = offsetSegments[i];
+            resultPoints.push(intersectPolylineOffsetSegments(prev, curr));
+        }
+    }
+    else {
+        resultPoints.push(offsetSegments[0].start);
+        for (var i = 1; i < offsetSegments.length; i++) {
+            resultPoints.push(intersectPolylineOffsetSegments(offsetSegments[i - 1], offsetSegments[i]));
+        }
+        resultPoints.push(offsetSegments[offsetSegments.length - 1].end);
+    }
+    var result = new AcGePolyline2d();
+    resultPoints.forEach(function (point, index) {
+        result.addVertexAt(index, { x: point.x, y: point.y });
+    });
+    result.closed = polyline.closed;
+    return result;
+}
+/**
+ * Builds parallel offset segments for each non-degenerate edge of a vertex path.
+ *
+ * @param sourcePoints - Vertices in path order
+ * @param closed - Whether edges wrap from the last vertex back to the first
+ * @param offsetDist - Signed offset distance (left of travel = positive)
+ * @returns One offset segment per valid edge, in path order
+ */
+function buildPolylineOffsetSegments(sourcePoints, closed, offsetDist) {
+    var offsetSegments = [];
+    var edgeCount = closed ? sourcePoints.length : sourcePoints.length - 1;
+    for (var i = 0; i < edgeCount; i++) {
+        var start = sourcePoints[i];
+        var end = sourcePoints[closed ? (i + 1) % sourcePoints.length : i + 1];
+        var dx = end.x - start.x;
+        var dy = end.y - start.y;
+        var len = Math.hypot(dx, dy);
+        if (AcGeTol.isNonPositive(len))
+            continue;
+        var nx = (-dy / len) * offsetDist;
+        var ny = (dx / len) * offsetDist;
+        offsetSegments.push({
+            start: new AcGePoint2d(start.x + nx, start.y + ny),
+            end: new AcGePoint2d(end.x + nx, end.y + ny),
+            dx: dx,
+            dy: dy
+        });
+    }
+    return offsetSegments;
+}
+/**
+ * Computes the intersection of two infinite offset lines from consecutive polyline edges.
+ *
+ * Each segment supplies a point on the line (`start`) and direction (`dx`, `dy`).
+ * Parallel edges return the midpoint of the gap between segment ends as a fallback.
+ *
+ * @param a - First offset edge
+ * @param b - Second offset edge
+ * @returns Intersection point (miter) of the two supporting lines
+ */
+function intersectPolylineOffsetSegments(a, b) {
+    var det = a.dx * b.dy - a.dy * b.dx;
+    if (AcGeTol.equalToZero(det)) {
+        return new AcGePoint2d((a.end.x + b.start.x) / 2, (a.end.y + b.start.y) / 2);
+    }
+    var qpx = b.start.x - a.start.x;
+    var qpy = b.start.y - a.start.y;
+    var t = (qpx * b.dy - qpy * b.dx) / det;
+    return new AcGePoint2d(a.start.x + t * a.dx, a.start.y + t * a.dy);
+}
+//# sourceMappingURL=AcGePolyline2dOffset.js.map