paperjs-offset 1.0.8 → 2.1.0

package/dist/index.umd.js

@@ -1,413 +1,827 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('paper')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'paper'], factory) :
-  (global = global || self, factory(global.paperjsOffset = {}, global.paper));
-}(this, (function (exports, paper) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('paper')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'paper'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.paperjsOffset = {}, global.paper));
+})(this, (function (exports, paper) { 'use strict';
 
-  paper = paper && Object.prototype.hasOwnProperty.call(paper, 'default') ? paper['default'] : paper;
+    var MAX_RECURSION_TIME = 20;
+    var STRATEGIES = [
+        {
+            algorithm: 'adaptive',
+            splitSelfIntersectingCurves: true,
+            guardInsideJoins: true,
+            simplifySelfIntersectingStroke: true,
+            adaptiveFallback: true,
+        },
+        {
+            algorithm: 'robust',
+            splitSelfIntersectingCurves: true,
+            guardInsideJoins: true,
+            simplifySelfIntersectingStroke: true,
+            adaptiveFallback: false,
+        },
+        {
+            algorithm: 'split',
+            splitSelfIntersectingCurves: true,
+            guardInsideJoins: false,
+            simplifySelfIntersectingStroke: false,
+            adaptiveFallback: false,
+        },
+        {
+            algorithm: 'legacy',
+            splitSelfIntersectingCurves: false,
+            guardInsideJoins: false,
+            simplifySelfIntersectingStroke: false,
+            adaptiveFallback: false,
+        },
+    ];
+    function getStrategy(algorithm) {
+        if (algorithm === 'auto') {
+            return STRATEGIES[0];
+        }
+        return STRATEGIES.filter(function (strategy) { return strategy.algorithm === algorithm; })[0] || STRATEGIES[0];
+    }
+    /**
+     * Offset the start/terminal segment of a bezier curve
+     * @param segment segment to offset
+     * @param curve curve to offset
+     * @param handleNormal the normal of the the line formed of two handles
+     * @param offset offset value
+     */
+    function offsetSegment(segment, curve, handleNormal, offset) {
+        var isFirst = segment.curve === curve;
+        // get offset vector
+        var offsetVector = (curve.getNormalAtTime(isFirst ? 0 : 1)).multiply(offset);
+        // get offset point
+        var point = segment.point.add(offsetVector);
+        var newSegment = new paper.Segment(point);
+        // handleOut for start segment & handleIn for terminal segment
+        var handle = (isFirst ? 'handleOut' : 'handleIn');
+        newSegment[handle] = segment[handle].add(handleNormal.subtract(offsetVector).divide(2));
+        return newSegment;
+    }
+    /**
+     * Adaptive offset a curve by repeatly apply the approximation proposed by Tiller and Hanson.
+     * @param curve curve to offset
+     * @param offset offset value
+     */
+    function adaptiveOffsetCurve(curve, offset, strategy, recursionTime) {
+        if (recursionTime === void 0) { recursionTime = 0; }
+        var hNormal = (new paper.Curve(curve.segment1.handleOut.add(curve.segment1.point), new paper.Point(0, 0), new paper.Point(0, 0), curve.segment2.handleIn.add(curve.segment2.point))).getNormalAtTime(0.5).multiply(offset);
+        var segment1 = offsetSegment(curve.segment1, curve, hNormal, offset);
+        var segment2 = offsetSegment(curve.segment2, curve, hNormal, offset);
+        if (recursionTime > MAX_RECURSION_TIME) {
+            return [segment1, segment2];
+        }
+        // divide && re-offset
+        var offsetCurve = new paper.Curve(segment1, segment2);
+        var offsetCurveIntersections = offsetCurve.getIntersections(offsetCurve);
+        var threshold = Math.min(Math.abs(offset) / 10, 1);
+        var midOffset = offsetCurve.getPointAtTime(0.5).getDistance(curve.getPointAtTime(0.5));
+        var needsSplit = strategy.splitSelfIntersectingCurves
+            ? offsetCurveIntersections.length > 0 || Math.abs(midOffset - Math.abs(offset)) > threshold
+            : offsetCurveIntersections.length === 0 && Math.abs(midOffset - Math.abs(offset)) > threshold;
+        if (needsSplit) {
+            var subCurve = curve.divideAtTime(0.5);
+            if (subCurve != null) {
+                return adaptiveOffsetCurve(curve, offset, strategy, recursionTime + 1)
+                    .concat(adaptiveOffsetCurve(subCurve, offset, strategy, recursionTime + 1));
+            }
+        }
+        return [segment1, segment2];
+    }
+    /**
+     * Create a round join segment between two adjacent segments.
+     */
+    function makeRoundJoin(segment1, segment2, originPoint, radius) {
+        var through = segment1.point.subtract(originPoint).add(segment2.point.subtract(originPoint))
+            .normalize(Math.abs(radius)).add(originPoint);
+        var arc = new paper.Path.Arc({ from: segment1.point, to: segment2.point, through: through, insert: false });
+        segment1.handleOut = arc.firstSegment.handleOut;
+        segment2.handleIn = arc.lastSegment.handleIn;
+        return arc.segments.length === 3 ? arc.segments[1] : null;
+    }
+    function det(p1, p2) {
+        return p1.x * p2.y - p1.y * p2.x;
+    }
+    /**
+     * Get the intersection point of point based lines
+     */
+    function getPointLineIntersections(p1, p2, p3, p4) {
+        var l1 = p1.subtract(p2);
+        var l2 = p3.subtract(p4);
+        var dl1 = det(p1, p2);
+        var dl2 = det(p3, p4);
+        return new paper.Point(dl1 * l2.x - l1.x * dl2, dl1 * l2.y - l1.y * dl2).divide(det(l1, l2));
+    }
+    /**
+     * Connect two adjacent bezier curve, each curve is represented by two segments,
+     * create different types of joins or simply removal redundant segment.
+     */
+    function isOutsideJoin(origin, offset) {
+        var _a;
+        var previousCurve = (_a = origin.previous) === null || _a === void 0 ? void 0 : _a.curve;
+        var nextCurve = origin.curve;
+        if (!previousCurve || !nextCurve) {
+            return true;
+        }
+        var tangentIn = previousCurve.getTangentAtTime(1);
+        var tangentOut = nextCurve.getTangentAtTime(0);
+        var turn = det(tangentIn, tangentOut);
+        return Math.abs(turn) < 1e-9 || turn * offset > 0;
+    }
+    function connectAdjacentBezier(segments1, segments2, origin, joinType, offset, limit, closed, strategy) {
+        var curve1 = new paper.Curve(segments1[0], segments1[1]);
+        var curve2 = new paper.Curve(segments2[0], segments2[1]);
+        var intersection = curve1.getIntersections(curve2);
+        var distance = segments1[1].point.getDistance(segments2[0].point);
+        var shouldJoin = !closed || !strategy.guardInsideJoins || isOutsideJoin(origin, offset);
+        if (origin.isSmooth()) {
+            segments2[0].handleOut = segments2[0].handleOut.project(origin.handleOut);
+            segments2[0].handleIn = segments1[1].handleIn.project(origin.handleIn);
+            segments2[0].point = segments1[1].point.add(segments2[0].point).divide(2);
+            segments1.pop();
+        }
+        else {
+            if (intersection.length === 0) {
+                if (distance > Math.abs(offset) * 0.1) {
+                    // connect
+                    switch (joinType) {
+                        case 'miter':
+                            if (shouldJoin) {
+                                var join = getPointLineIntersections(curve1.point2, curve1.point2.add(curve1.getTangentAtTime(1)), curve2.point1, curve2.point1.add(curve2.getTangentAtTime(0)));
+                                // prevent sharp angle
+                                var joinOffset = Math.max(join.getDistance(curve1.point2), join.getDistance(curve2.point1));
+                                if (joinOffset < Math.abs(offset) * limit) {
+                                    segments1.push(new paper.Segment(join));
+                                }
+                            }
+                            break;
+                        case 'round':
+                            if (shouldJoin) {
+                                var mid = makeRoundJoin(segments1[1], segments2[0], origin.point, offset);
+                                if (mid) {
+                                    segments1.push(mid);
+                                }
+                            }
+                            break;
+                    }
+                }
+                else {
+                    segments2[0].handleIn = segments1[1].handleIn;
+                    segments1.pop();
+                }
+            }
+            else {
+                var second1 = curve1.divideAt(intersection[0]);
+                if (second1) {
+                    var join = second1.segment1;
+                    var second2 = curve2.divideAt(curve2.getIntersections(curve1)[0]);
+                    join.handleOut = second2 ? second2.segment1.handleOut : segments2[0].handleOut;
+                    segments1.pop();
+                    segments2[0] = join;
+                }
+                else {
+                    segments2[0].handleIn = segments1[1].handleIn;
+                    segments1.pop();
+                }
+            }
+        }
+    }
+    /**
+     * Connect all the segments together.
+     */
+    function connectBeziers(rawSegments, join, source, offset, limit, strategy) {
+        var originSegments = source.segments;
+        var first = rawSegments[0].slice();
+        for (var i = 0; i < rawSegments.length - 1; ++i) {
+            connectAdjacentBezier(rawSegments[i], rawSegments[i + 1], originSegments[i + 1], join, offset, limit, source.closed, strategy);
+        }
+        if (source.closed) {
+            connectAdjacentBezier(rawSegments[rawSegments.length - 1], first, originSegments[0], join, offset, limit, source.closed, strategy);
+            rawSegments[0][0] = first[0];
+        }
+        return rawSegments;
+    }
+    function reduceSingleChildCompoundPath(path) {
+        if (path.children.length === 1) {
+            path = path.children[0];
+            path.remove(); // remove from parent, this is critical, or the style attributes will be ignored
+        }
+        return path;
+    }
+    /** Normalize a path, always clockwise, non-self-intersection, ignore really small components, and no one-component compound path. */
+    function normalize(path, areaThreshold) {
+        if (areaThreshold === void 0) { areaThreshold = 0.01; }
+        if (path.closed) {
+            var ignoreArea_1 = Math.abs(path.area * areaThreshold);
+            if (!path.clockwise) {
+                path.reverse();
+            }
+            path = path.unite(path, { insert: false });
+            path = path.resolveCrossings();
+            if (path instanceof paper.CompoundPath) {
+                path.children.filter(function (c) { return Math.abs(c.area) < ignoreArea_1; }).forEach(function (c) { return c.remove(); });
+                if (path.children.length === 1) {
+                    return reduceSingleChildCompoundPath(path);
+                }
+            }
+        }
+        return path;
+    }
+    function cleanupStrokeOutline(path, offset, strategy) {
+        var result = normalize(path);
+        if (strategy.simplifySelfIntersectingStroke && countSelfIntersections(result) > 0) {
+            var simplified = result.clone({ insert: false });
+            simplified.simplify(Math.max(Math.min(Math.abs(offset) * 0.02, 0.5), 0.1));
+            result = normalize(simplified);
+        }
+        return result;
+    }
+    function isSameDirection(partialPath, fullPath) {
+        var offset1 = partialPath.segments[0].location.offset;
+        var offset2 = partialPath.segments[Math.max(1, Math.floor(partialPath.segments.length / 2))].location.offset;
+        var sampleOffset = (offset1 + offset2) / 3;
+        var originOffset1 = fullPath.getNearestLocation(partialPath.getPointAt(sampleOffset)).offset;
+        var originOffset2 = fullPath.getNearestLocation(partialPath.getPointAt(2 * sampleOffset)).offset;
+        return originOffset1 < originOffset2;
+    }
+    /** Remove self intersection when offset is negative by point direction dectection. */
+    function removeIntersection(path) {
+        if (path.closed) {
+            var newPath = path.unite(path, { insert: false });
+            if (newPath instanceof paper.CompoundPath) {
+                newPath.children.filter(function (c) {
+                    if (c.segments.length > 1) {
+                        return !isSameDirection(c, path);
+                    }
+                    else {
+                        return true;
+                    }
+                }).forEach(function (c) { return c.remove(); });
+                return reduceSingleChildCompoundPath(newPath);
+            }
+        }
+        return path;
+    }
+    function getSegments(path) {
+        if (path instanceof paper.CompoundPath) {
+            return path.children.map(function (c) { return c.segments; }).flat();
+        }
+        else {
+            return path.segments;
+        }
+    }
+    /**
+     * Remove impossible segments in negative offset condition.
+     */
+    function removeOutsiders(newPath, path) {
+        var segments = getSegments(newPath).slice();
+        segments.forEach(function (segment) {
+            if (!path.contains(segment.point)) {
+                segment.remove();
+            }
+        });
+    }
+    function preparePath(path, offset) {
+        var source = path.clone({ insert: false });
+        source.reduce({});
+        if (path.closed && !path.clockwise) {
+            source.reverse();
+            offset = -offset;
+        }
+        return [source, offset];
+    }
+    function offsetSimpleShape(path, offset, join, limit, strategy) {
+        var _a;
+        var source;
+        _a = preparePath(path, offset), source = _a[0], offset = _a[1];
+        var curves = source.curves.slice();
+        var offsetCurves = curves.map(function (curve) { return adaptiveOffsetCurve(curve, offset, strategy); }).flat();
+        var raws = [];
+        for (var i = 0; i < offsetCurves.length; i += 2) {
+            raws.push(offsetCurves.slice(i, i + 2));
+        }
+        var segments = connectBeziers(raws, join, source, offset, limit, strategy).flat();
+        var newPath = removeIntersection(new paper.Path({ segments: segments, insert: false, closed: path.closed }));
+        newPath.reduce({});
+        if (source.closed && ((source.clockwise && offset < 0) || (!source.clockwise && offset > 0))) {
+            removeOutsiders(newPath, path);
+        }
+        // recovery path
+        if (source.clockwise !== path.clockwise) {
+            newPath.reverse();
+        }
+        return normalize(newPath);
+    }
+    function makeRoundCap(from, to, offset) {
+        var origin = from.point.add(to.point).divide(2);
+        var normal = to.point.subtract(from.point).rotate(-90, new paper.Point(0, 0)).normalize(offset);
+        var through = origin.add(normal);
+        var arc = new paper.Path.Arc({ from: from.point, to: to.point, through: through, insert: false });
+        return arc.segments;
+    }
+    function connectSide(outer, inner, offset, cap) {
+        if (outer instanceof paper.CompoundPath) {
+            var cs = outer.children.map(function (c) { return ({ c: c, a: Math.abs(c.area) }); });
+            cs = cs.sort(function (c1, c2) { return c2.a - c1.a; });
+            outer = cs[0].c;
+        }
+        var oSegments = outer.segments.slice();
+        var iSegments = inner.segments.slice();
+        switch (cap) {
+            case 'round':
+                var heads = makeRoundCap(iSegments[iSegments.length - 1], oSegments[0], offset);
+                var tails = makeRoundCap(oSegments[oSegments.length - 1], iSegments[0], offset);
+                var result = new paper.Path({ segments: heads.concat(oSegments, tails, iSegments), closed: true, insert: false });
+                result.reduce({});
+                return result;
+            default: return new paper.Path({ segments: oSegments.concat(iSegments), closed: true, insert: false });
+        }
+    }
+    function offsetSimpleStroke(path, offset, join, cap, limit, strategy) {
+        offset = path.closed && !path.clockwise ? -offset : offset;
+        var positiveOffset = offsetSimpleShape(path, offset, join, limit, strategy);
+        var negativeOffset = offsetSimpleShape(path, -offset, join, limit, strategy);
+        if (path.closed) {
+            return cleanupStrokeOutline(positiveOffset.subtract(negativeOffset, { insert: false }), offset, strategy);
+        }
+        else {
+            var inner = negativeOffset;
+            var holes = new Array();
+            if (negativeOffset instanceof paper.CompoundPath) {
+                holes = negativeOffset.children.filter(function (c) { return c.closed; });
+                holes.forEach(function (h) { return h.remove(); });
+                inner = negativeOffset.children[0];
+            }
+            inner.reverse();
+            var final = connectSide(positiveOffset, inner, offset, cap);
+            if (holes.length > 0) {
+                for (var _i = 0, holes_1 = holes; _i < holes_1.length; _i++) {
+                    var hole = holes_1[_i];
+                    final = final.subtract(hole, { insert: false });
+                }
+            }
+            return cleanupStrokeOutline(final, offset, strategy);
+        }
+    }
+    function getChildPaths(path) {
+        if (path instanceof paper.CompoundPath) {
+            return path.children;
+        }
+        return [path];
+    }
+    function finiteNumber(value) {
+        return Number.isFinite(value);
+    }
+    function countSelfIntersections(path) {
+        if (!path.closed) {
+            return 0;
+        }
+        try {
+            var children_1 = getChildPaths(path);
+            var count_1 = 0;
+            children_1.forEach(function (child, index) {
+                count_1 += child.getIntersections(child).length;
+                for (var i = index + 1; i < children_1.length; i += 1) {
+                    count_1 += child.getIntersections(children_1[i]).length;
+                }
+            });
+            return count_1;
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    function samplePoints(path, maxPerChild) {
+        if (maxPerChild === void 0) { maxPerChild = 16; }
+        var points = [];
+        getChildPaths(path).forEach(function (child) {
+            if (!child.length || child.segments.length === 0) {
+                return;
+            }
+            var count = Math.min(maxPerChild, Math.max(4, Math.ceil(child.length / 30)));
+            for (var i = 0; i < count; i += 1) {
+                var ratio = child.closed ? i / count : i / Math.max(count - 1, 1);
+                var point = child.getPointAt(child.length * ratio);
+                if (point) {
+                    points.push(point);
+                }
+            }
+        });
+        return points;
+    }
+    function containsPoint(path, point) {
+        try {
+            return path.contains(point);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    function distanceToPath(path, point) {
+        try {
+            var nearest = path.getNearestPoint(point);
+            return nearest ? nearest.getDistance(point) : Number.POSITIVE_INFINITY;
+        }
+        catch (error) {
+            return Number.POSITIVE_INFINITY;
+        }
+    }
+    function addWarning(warnings, warning) {
+        if (warnings.indexOf(warning) === -1) {
+            warnings.push(warning);
+        }
+    }
+    function analyzeOffsetQuality(source, result, offset, options) {
+        if (options === void 0) { options = {}; }
+        var warnings = new Array();
+        var expectedClosed = options.stroke ? true : source.closed;
+        var segmentCount = getSegments(result).length;
+        var area = Math.abs(result.area || 0);
+        var absOffset = Math.abs(offset);
+        var score = segmentCount * 0.01;
+        var containmentErrors = 0;
+        var distanceErrors = 0;
+        var bounds = result.bounds;
+        if (segmentCount === 0) {
+            score += 100000;
+            addWarning(warnings, 'empty-result');
+        }
+        if (!bounds || !finiteNumber(bounds.x) || !finiteNumber(bounds.y) || !finiteNumber(bounds.width) || !finiteNumber(bounds.height)) {
+            score += 100000;
+            addWarning(warnings, 'non-finite-bounds');
+        }
+        if (result.closed !== expectedClosed) {
+            score += 50000;
+            addWarning(warnings, 'unexpected-closed-state');
+        }
+        var selfIntersections = countSelfIntersections(result);
+        if (selfIntersections > 0) {
+            score += selfIntersections * 1000;
+            addWarning(warnings, 'self-intersection');
+        }
+        if (source.closed && result.closed && !options.stroke) {
+            var sourceArea = Math.abs(source.area || 0);
+            if (sourceArea > 0 && offset > 0 && area < sourceArea * 0.95) {
+                score += ((sourceArea - area) / sourceArea) * 2000;
+                addWarning(warnings, 'positive-offset-area-shrank');
+            }
+            if (sourceArea > 0 && offset < 0 && area > sourceArea * 1.05) {
+                score += ((area - sourceArea) / sourceArea) * 2000;
+                addWarning(warnings, 'negative-offset-area-grew');
+            }
+            if (sourceArea > 0 && offset < 0) {
+                var areaRatio = area / sourceArea;
+                if (areaRatio < 0.25) {
+                    score += (0.25 - areaRatio) * 4000;
+                    addWarning(warnings, 'negative-offset-collapse');
+                }
+            }
+            if (sourceArea > 0 && offset > 0) {
+                var sourceBounds = source.bounds;
+                var centerShift = result.bounds.center.getDistance(sourceBounds.center);
+                var centerTolerance = Math.max(absOffset * 1.15, Math.min(sourceBounds.width, sourceBounds.height) * 0.08);
+                if (centerShift > centerTolerance) {
+                    score += (centerShift - centerTolerance) * 80;
+                    addWarning(warnings, 'offset-center-shift');
+                }
+            }
+            var containmentTolerance_1 = Math.max(absOffset * 0.08, 0.5);
+            var containmentSamples = offset >= 0 ? samplePoints(source) : samplePoints(result);
+            containmentSamples.forEach(function (point) {
+                var container = offset >= 0 ? result : source;
+                if (!containsPoint(container, point) && distanceToPath(container, point) > containmentTolerance_1) {
+                    containmentErrors += 1;
+                }
+            });
+            if (containmentErrors > 0) {
+                score += containmentErrors * 150;
+                addWarning(warnings, offset >= 0 ? 'source-outside-positive-offset' : 'negative-offset-outside-source');
+            }
+        }
+        if (absOffset > 0.001) {
+            var distanceTolerance_1 = Math.max(absOffset * 0.18, 0.75);
+            samplePoints(result).forEach(function (point) {
+                var distance = distanceToPath(source, point);
+                if (finiteNumber(distance) && distance < distanceTolerance_1) {
+                    distanceErrors += 1;
+                }
+            });
+            if (distanceErrors > 0) {
+                score += distanceErrors * 35;
+                addWarning(warnings, 'offset-distance-collapse');
+            }
+        }
+        return {
+            score: score,
+            warnings: warnings,
+            selfIntersections: selfIntersections,
+            containmentErrors: containmentErrors,
+            distanceErrors: distanceErrors,
+            segmentCount: segmentCount,
+            area: area,
+        };
+    }
+    function pickBestResult(source, offset, stroke, makeResult) {
+        var bestResult = null;
+        var bestQuality = null;
+        var firstError = null;
+        STRATEGIES.forEach(function (strategy) {
+            try {
+                var result = makeResult(strategy);
+                var quality = analyzeOffsetQuality(source, result, offset, { stroke: stroke });
+                quality.algorithm = strategy.algorithm;
+                if (!bestQuality || quality.score < bestQuality.score) {
+                    bestResult = result;
+                    bestQuality = quality;
+                }
+            }
+            catch (error) {
+                if (!firstError && error instanceof Error) {
+                    firstError = error;
+                }
+            }
+        });
+        if (!bestResult) {
+            throw firstError || new Error('Unable to offset path with any algorithm');
+        }
+        return bestResult;
+    }
+    function getNonSelfIntersectionPath(path) {
+        if (path.closed) {
+            return path.unite(path, { insert: false });
+        }
+        return path;
+    }
+    function offsetCompoundChild(child, parent, offset, join, limit, strategy) {
+        if (child.segments.length <= 1) {
+            return null;
+        }
+        if (!isSameDirection(child, parent)) {
+            child.reverse();
+        }
+        var childOffset = offsetSimpleShape(child, offset, join, limit, strategy);
+        childOffset = normalize(childOffset);
+        if (childOffset.clockwise !== child.clockwise) {
+            childOffset.reverse();
+        }
+        if (childOffset instanceof paper.CompoundPath) {
+            childOffset.applyMatrix = true;
+            return childOffset.children;
+        }
+        return childOffset;
+    }
+    function offsetCompoundShape(path, offset, join, limit, strategy) {
+        var children = path.children.filter(function (child) { return child.segments.length > 1; });
+        var outers = children.filter(function (child) { return child.clockwise; });
+        var holes = children.filter(function (child) { return !child.clockwise; });
+        if (outers.length === 0 || holes.length === 0) {
+            var offsetParts = children.map(function (child) { return offsetCompoundChild(child, path, offset, join, limit, strategy); });
+            return new paper.CompoundPath({ children: offsetParts.flat().filter(function (child) { return !!child; }), insert: false });
+        }
+        var pieces = outers.map(function (outer) {
+            var outerOffset = offsetCompoundChild(outer, path, offset, join, limit, strategy);
+            var result = outerOffset instanceof Array
+                ? new paper.CompoundPath({ children: outerOffset, insert: false })
+                : outerOffset;
+            holes.forEach(function (hole) {
+                if (!outer.contains(hole.bounds.center)) {
+                    return;
+                }
+                var holeOffset = offsetCompoundChild(hole, path, offset, join, limit, strategy);
+                if (!holeOffset) {
+                    return;
+                }
+                var holePath = holeOffset instanceof Array
+                    ? new paper.CompoundPath({ children: holeOffset, insert: false })
+                    : holeOffset;
+                var next = result.subtract(holePath, { insert: false });
+                result.remove();
+                holePath.remove();
+                result = next;
+            });
+            return result;
+        });
+        if (pieces.length === 1) {
+            return pieces[0];
+        }
+        return pieces.slice(1).reduce(function (result, piece) {
+            var next = result.unite(piece, { insert: false });
+            result.remove();
+            piece.remove();
+            return next;
+        }, pieces[0]);
+    }
+    function hasCompoundHoles(path) {
+        if (!(path instanceof paper.CompoundPath)) {
+            return false;
+        }
+        var children = path.children;
+        return children.some(function (child) { return child.clockwise; }) && children.some(function (child) { return !child.clockwise; });
+    }
+    function withoutAdaptiveFallback(strategy) {
+        return {
+            algorithm: 'robust',
+            splitSelfIntersectingCurves: strategy.splitSelfIntersectingCurves,
+            guardInsideJoins: strategy.guardInsideJoins,
+            simplifySelfIntersectingStroke: strategy.simplifySelfIntersectingStroke,
+            adaptiveFallback: false,
+        };
+    }
+    function addAdaptiveCandidate(candidates, makeResult) {
+        try {
+            candidates.push(makeResult());
+        }
+        catch (error) {
+            // Keep adaptive mode opportunistic: a failed fallback should not hide valid strict results.
+        }
+    }
+    function pickBestCandidate(source, offset, stroke, candidates) {
+        var bestResult = candidates[0];
+        var bestQuality = analyzeOffsetQuality(source, bestResult, offset, { stroke: stroke });
+        for (var i = 1; i < candidates.length; i += 1) {
+            var quality = analyzeOffsetQuality(source, candidates[i], offset, { stroke: stroke });
+            if (quality.score < bestQuality.score) {
+                bestResult = candidates[i];
+                bestQuality = quality;
+            }
+        }
+        return bestResult;
+    }
+    function offsetPathAdaptive(path, offset, join, limit, strategy) {
+        var baseStrategy = withoutAdaptiveFallback(strategy);
+        var candidates = new Array();
+        addAdaptiveCandidate(candidates, function () { return offsetPathWithStrategy(path, offset, join, limit, baseStrategy); });
+        if (join !== 'round') {
+            addAdaptiveCandidate(candidates, function () { return offsetPathWithStrategy(path, offset, 'round', limit, baseStrategy); });
+        }
+        if (path.closed && offset < 0) {
+            [0.8, 0.65, 0.5, 0.35, 0.25].forEach(function (factor) {
+                var fallbackOffset = offset * factor;
+                addAdaptiveCandidate(candidates, function () { return offsetPathWithStrategy(path, fallbackOffset, join, limit, baseStrategy); });
+                if (join !== 'round') {
+                    addAdaptiveCandidate(candidates, function () { return offsetPathWithStrategy(path, fallbackOffset, 'round', limit, baseStrategy); });
+                }
+            });
+        }
+        if (candidates.length === 0) {
+            return offsetPathWithStrategy(path, offset, join, limit, baseStrategy);
+        }
+        return pickBestCandidate(path, offset, false, candidates);
+    }
+    function offsetPathWithStrategy(path, offset, join, limit, strategy) {
+        if (strategy.adaptiveFallback) {
+            return offsetPathAdaptive(path, offset, join, limit, strategy);
+        }
+        var nonSIPath = getNonSelfIntersectionPath(path);
+        var shouldNormalizeResult = !hasCompoundHoles(nonSIPath);
+        var result = nonSIPath;
+        if (nonSIPath instanceof paper.Path) {
+            result = offsetSimpleShape(nonSIPath, offset, join, limit, strategy);
+        }
+        else {
+            result = offsetCompoundShape(nonSIPath, offset, join, limit, strategy);
+        }
+        if (shouldNormalizeResult) {
+            result = normalize(result);
+        }
+        result.copyAttributes(nonSIPath, false);
+        result.remove();
+        return result;
+    }
+    function offsetPath(path, offset, join, limit, algorithm) {
+        if (algorithm === void 0) { algorithm = 'auto'; }
+        if (algorithm === 'auto') {
+            return pickBestResult(path, offset, false, function (strategy) { return offsetPathWithStrategy(path, offset, join, limit, strategy); });
+        }
+        return offsetPathWithStrategy(path, offset, join, limit, getStrategy(algorithm));
+    }
+    function offsetStrokeWithStrategy(path, offset, join, cap, limit, strategy) {
+        if (strategy.adaptiveFallback) {
+            return offsetStrokeAdaptive(path, offset, join, cap, limit, strategy);
+        }
+        var nonSIPath = getNonSelfIntersectionPath(path);
+        var result = nonSIPath;
+        if (nonSIPath instanceof paper.Path) {
+            result = offsetSimpleStroke(nonSIPath, offset, join, cap, limit, strategy);
+        }
+        else {
+            var children = nonSIPath.children.flatMap(function (c) {
+                return offsetSimpleStroke(c, offset, join, cap, limit, strategy);
+            });
+            result = children.reduce(function (c1, c2) { return c1.unite(c2, { insert: false }); });
+        }
+        result.strokeWidth = 0;
+        result.fillColor = nonSIPath.strokeColor;
+        result.shadowBlur = nonSIPath.shadowBlur;
+        result.shadowColor = nonSIPath.shadowColor;
+        result.shadowOffset = nonSIPath.shadowOffset;
+        return result;
+    }
+    function offsetStrokeAdaptive(path, offset, join, cap, limit, strategy) {
+        var baseStrategy = withoutAdaptiveFallback(strategy);
+        var candidates = new Array();
+        addAdaptiveCandidate(candidates, function () { return offsetStrokeWithStrategy(path, offset, join, cap, limit, baseStrategy); });
+        if (join !== 'round') {
+            addAdaptiveCandidate(candidates, function () { return offsetStrokeWithStrategy(path, offset, 'round', cap, limit, baseStrategy); });
+        }
+        if (cap !== 'round') {
+            addAdaptiveCandidate(candidates, function () { return offsetStrokeWithStrategy(path, offset, join, 'round', limit, baseStrategy); });
+        }
+        if (join !== 'round' && cap !== 'round') {
+            addAdaptiveCandidate(candidates, function () { return offsetStrokeWithStrategy(path, offset, 'round', 'round', limit, baseStrategy); });
+        }
+        if (candidates.length === 0) {
+            return offsetStrokeWithStrategy(path, offset, join, cap, limit, baseStrategy);
+        }
+        return pickBestCandidate(path, offset, true, candidates);
+    }
+    function offsetStroke$1(path, offset, join, cap, limit, algorithm) {
+        if (algorithm === void 0) { algorithm = 'auto'; }
+        if (algorithm === 'auto') {
+            return pickBestResult(path, offset, true, function (strategy) { return offsetStrokeWithStrategy(path, offset, join, cap, limit, strategy); });
+        }
+        return offsetStrokeWithStrategy(path, offset, join, cap, limit, getStrategy(algorithm));
+    }
 
-  /**
-   * Offset the start/terminal segment of a bezier curve
-   * @param segment segment to offset
-   * @param curve curve to offset
-   * @param handleNormal the normal of the the line formed of two handles
-   * @param offset offset value
-   */
-  function offsetSegment(segment, curve, handleNormal, offset) {
-      var isFirst = segment.curve === curve;
-      // get offset vector
-      var offsetVector = (curve.getNormalAtTime(isFirst ? 0 : 1)).multiply(offset);
-      // get offset point
-      var point = segment.point.add(offsetVector);
-      var newSegment = new paper.Segment(point);
-      // handleOut for start segment & handleIn for terminal segment
-      var handle = (isFirst ? 'handleOut' : 'handleIn');
-      newSegment[handle] = segment[handle].add(handleNormal.subtract(offsetVector).divide(2));
-      return newSegment;
-  }
-  /**
-   * Adaptive offset a curve by repeatly apply the approximation proposed by Tiller and Hanson.
-   * @param curve curve to offset
-   * @param offset offset value
-   */
-  function adaptiveOffsetCurve(curve, offset) {
-      var hNormal = (new paper.Curve(curve.segment1.handleOut.add(curve.segment1.point), new paper.Point(0, 0), new paper.Point(0, 0), curve.segment2.handleIn.add(curve.segment2.point))).getNormalAtTime(0.5).multiply(offset);
-      var segment1 = offsetSegment(curve.segment1, curve, hNormal, offset);
-      var segment2 = offsetSegment(curve.segment2, curve, hNormal, offset);
-      // divide && re-offset
-      var offsetCurve = new paper.Curve(segment1, segment2);
-      // if the offset curve is not self intersected, divide it
-      if (offsetCurve.getIntersections(offsetCurve).length === 0) {
-          var threshold = Math.min(Math.abs(offset) / 10, 1);
-          var midOffset = offsetCurve.getPointAtTime(0.5).getDistance(curve.getPointAtTime(0.5));
-          if (Math.abs(midOffset - Math.abs(offset)) > threshold) {
-              var subCurve = curve.divideAtTime(0.5);
-              if (subCurve != null) {
-                  return adaptiveOffsetCurve(curve, offset).concat(adaptiveOffsetCurve(subCurve, offset));
-              }
-          }
-      }
-      return [segment1, segment2];
-  }
-  /**
-   * Create a round join segment between two adjacent segments.
-   */
-  function makeRoundJoin(segment1, segment2, originPoint, radius) {
-      var through = segment1.point.subtract(originPoint).add(segment2.point.subtract(originPoint))
-          .normalize(Math.abs(radius)).add(originPoint);
-      var arc = new paper.Path.Arc({ from: segment1.point, to: segment2.point, through: through, insert: false });
-      segment1.handleOut = arc.firstSegment.handleOut;
-      segment2.handleIn = arc.lastSegment.handleIn;
-      return arc.segments.length === 3 ? arc.segments[1] : null;
-  }
-  function det(p1, p2) {
-      return p1.x * p2.y - p1.y * p2.x;
-  }
-  /**
-   * Get the intersection point of point based lines
-   */
-  function getPointLineIntersections(p1, p2, p3, p4) {
-      var l1 = p1.subtract(p2);
-      var l2 = p3.subtract(p4);
-      var dl1 = det(p1, p2);
-      var dl2 = det(p3, p4);
-      return new paper.Point(dl1 * l2.x - l1.x * dl2, dl1 * l2.y - l1.y * dl2).divide(det(l1, l2));
-  }
-  /**
-   * Connect two adjacent bezier curve, each curve is represented by two segments,
-   * create different types of joins or simply removal redundant segment.
-   */
-  function connectAdjacentBezier(segments1, segments2, origin, joinType, offset, limit) {
-      var curve1 = new paper.Curve(segments1[0], segments1[1]);
-      var curve2 = new paper.Curve(segments2[0], segments2[1]);
-      var intersection = curve1.getIntersections(curve2);
-      var distance = segments1[1].point.getDistance(segments2[0].point);
-      if (origin.isSmooth()) {
-          segments2[0].handleOut = segments2[0].handleOut.project(origin.handleOut);
-          segments2[0].handleIn = segments1[1].handleIn.project(origin.handleIn);
-          segments2[0].point = segments1[1].point.add(segments2[0].point).divide(2);
-          segments1.pop();
-      }
-      else {
-          if (intersection.length === 0) {
-              if (distance > Math.abs(offset) * 0.1) {
-                  // connect
-                  switch (joinType) {
-                      case 'miter':
-                          var join = getPointLineIntersections(curve1.point2, curve1.point2.add(curve1.getTangentAtTime(1)), curve2.point1, curve2.point1.add(curve2.getTangentAtTime(0)));
-                          // prevent sharp angle
-                          var joinOffset = Math.max(join.getDistance(curve1.point2), join.getDistance(curve2.point1));
-                          if (joinOffset < Math.abs(offset) * limit) {
-                              segments1.push(new paper.Segment(join));
-                          }
-                          break;
-                      case 'round':
-                          var mid = makeRoundJoin(segments1[1], segments2[0], origin.point, offset);
-                          if (mid) {
-                              segments1.push(mid);
-                          }
-                          break;
-                  }
-              }
-              else {
-                  segments2[0].handleIn = segments1[1].handleIn;
-                  segments1.pop();
-              }
-          }
-          else {
-              var second1 = curve1.divideAt(intersection[0]);
-              if (second1) {
-                  var join = second1.segment1;
-                  var second2 = curve2.divideAt(curve2.getIntersections(curve1)[0]);
-                  join.handleOut = second2 ? second2.segment1.handleOut : segments2[0].handleOut;
-                  segments1.pop();
-                  segments2[0] = join;
-              }
-              else {
-                  segments2[0].handleIn = segments1[1].handleIn;
-                  segments1.pop();
-              }
-          }
-      }
-  }
-  /**
-   * Connect all the segments together.
-   */
-  function connectBeziers(rawSegments, join, source, offset, limit) {
-      var originSegments = source.segments;
-      var first = rawSegments[0].slice();
-      for (var i = 0; i < rawSegments.length - 1; ++i) {
-          connectAdjacentBezier(rawSegments[i], rawSegments[i + 1], originSegments[i + 1], join, offset, limit);
-      }
-      if (source.closed) {
-          connectAdjacentBezier(rawSegments[rawSegments.length - 1], first, originSegments[0], join, offset, limit);
-          rawSegments[0][0] = first[0];
-      }
-      return rawSegments;
-  }
-  function reduceSingleChildCompoundPath(path) {
-      if (path.children.length === 1) {
-          path = path.children[0];
-          path.remove(); // remove from parent, this is critical, or the style attributes will be ignored
-      }
-      return path;
-  }
-  /** Normalize a path, always clockwise, non-self-intersection, ignore really small components, and no one-component compound path. */
-  function normalize(path, areaThreshold) {
-      if (areaThreshold === void 0) { areaThreshold = 0.01; }
-      if (path.closed) {
-          var ignoreArea_1 = Math.abs(path.area * areaThreshold);
-          if (!path.clockwise) {
-              path.reverse();
-          }
-          path = path.unite(path, { insert: false });
-          if (path instanceof paper.CompoundPath) {
-              path.children.filter(function (c) { return Math.abs(c.area) < ignoreArea_1; }).forEach(function (c) { return c.remove(); });
-              if (path.children.length === 1) {
-                  return reduceSingleChildCompoundPath(path);
-              }
-          }
-      }
-      return path;
-  }
-  function isSameDirection(partialPath, fullPath) {
-      var offset1 = partialPath.segments[0].location.offset;
-      var offset2 = partialPath.segments[Math.max(1, Math.floor(partialPath.segments.length / 2))].location.offset;
-      var sampleOffset = (offset1 + offset2) / 3;
-      var originOffset1 = fullPath.getNearestLocation(partialPath.getPointAt(sampleOffset)).offset;
-      var originOffset2 = fullPath.getNearestLocation(partialPath.getPointAt(2 * sampleOffset)).offset;
-      return originOffset1 < originOffset2;
-  }
-  /** Remove self intersection when offset is negative by point direction dectection. */
-  function removeIntersection(path) {
-      if (path.closed) {
-          var newPath = path.unite(path, { insert: false });
-          if (newPath instanceof paper.CompoundPath) {
-              newPath.children.filter(function (c) {
-                  if (c.segments.length > 1) {
-                      return !isSameDirection(c, path);
-                  }
-                  else {
-                      return true;
-                  }
-              }).forEach(function (c) { return c.remove(); });
-              return reduceSingleChildCompoundPath(newPath);
-          }
-      }
-      return path;
-  }
-  function getSegments(path) {
-      if (path instanceof paper.CompoundPath) {
-          return path.children.map(function (c) { return c.segments; }).flat();
-      }
-      else {
-          return path.segments;
-      }
-  }
-  /**
-   * Remove impossible segments in negative offset condition.
-   */
-  function removeOutsiders(newPath, path) {
-      var segments = getSegments(newPath).slice();
-      segments.forEach(function (segment) {
-          if (!path.contains(segment.point)) {
-              segment.remove();
-          }
-      });
-  }
-  function preparePath(path, offset) {
-      var source = path.clone({ insert: false });
-      source.reduce({});
-      if (!path.clockwise) {
-          source.reverse();
-          offset = -offset;
-      }
-      return [source, offset];
-  }
-  function offsetSimpleShape(path, offset, join, limit) {
-      var _a;
-      var source;
-      _a = preparePath(path, offset), source = _a[0], offset = _a[1];
-      var curves = source.curves.slice();
-      var offsetCurves = curves.map(function (curve) { return adaptiveOffsetCurve(curve, offset); }).flat();
-      var raws = [];
-      for (var i = 0; i < offsetCurves.length; i += 2) {
-          raws.push(offsetCurves.slice(i, i + 2));
-      }
-      var segments = connectBeziers(raws, join, source, offset, limit).flat();
-      var newPath = removeIntersection(new paper.Path({ segments: segments, insert: false, closed: path.closed }));
-      newPath.reduce({});
-      if (source.closed && ((source.clockwise && offset < 0) || (!source.clockwise && offset > 0))) {
-          removeOutsiders(newPath, path);
-      }
-      // recovery path
-      if (source.clockwise !== path.clockwise) {
-          newPath.reverse();
-      }
-      return normalize(newPath);
-  }
-  function makeRoundCap(from, to, offset) {
-      var origin = from.point.add(to.point).divide(2);
-      var normal = to.point.subtract(from.point).rotate(-90, new paper.Point(0, 0)).normalize(offset);
-      var through = origin.add(normal);
-      var arc = new paper.Path.Arc({ from: from.point, to: to.point, through: through, insert: false });
-      return arc.segments;
-  }
-  function connectSide(outer, inner, offset, cap) {
-      if (outer instanceof paper.CompoundPath) {
-          var cs = outer.children.map(function (c) { return ({ c: c, a: Math.abs(c.area) }); });
-          cs = cs.sort(function (c1, c2) { return c2.a - c1.a; });
-          outer = cs[0].c;
-      }
-      var oSegments = outer.segments.slice();
-      var iSegments = inner.segments.slice();
-      switch (cap) {
-          case 'round':
-              var heads = makeRoundCap(iSegments[iSegments.length - 1], oSegments[0], offset);
-              var tails = makeRoundCap(oSegments[oSegments.length - 1], iSegments[0], offset);
-              var result = new paper.Path({ segments: heads.concat(oSegments, tails, iSegments), closed: true, insert: false });
-              result.reduce({});
-              return result;
-          default: return new paper.Path({ segments: oSegments.concat(iSegments), closed: true, insert: false });
-      }
-  }
-  function offsetSimpleStroke(path, offset, join, cap, limit) {
-      offset = path.clockwise ? offset : -offset;
-      var positiveOffset = offsetSimpleShape(path, offset, join, limit);
-      var negativeOffset = offsetSimpleShape(path, -offset, join, limit);
-      if (path.closed) {
-          return positiveOffset.subtract(negativeOffset, { insert: false });
-      }
-      else {
-          var inner = negativeOffset;
-          var holes = new Array();
-          if (negativeOffset instanceof paper.CompoundPath) {
-              holes = negativeOffset.children.filter(function (c) { return c.closed; });
-              holes.forEach(function (h) { return h.remove(); });
-              inner = negativeOffset.children[0];
-          }
-          inner.reverse();
-          var final = connectSide(positiveOffset, inner, offset, cap);
-          if (holes.length > 0) {
-              for (var _i = 0, holes_1 = holes; _i < holes_1.length; _i++) {
-                  var hole = holes_1[_i];
-                  final = final.subtract(hole, { insert: false });
-              }
-          }
-          return final;
-      }
-  }
-  function getNonSelfItersectionPath(path) {
-      if (path.closed) {
-          return path.unite(path, { insert: false });
-      }
-      return path;
-  }
-  function offsetPath(path, offset, join, limit) {
-      var nonSIPath = getNonSelfItersectionPath(path);
-      var result = nonSIPath;
-      if (nonSIPath instanceof paper.Path) {
-          result = offsetSimpleShape(nonSIPath, offset, join, limit);
-      }
-      else {
-          var offsetParts = nonSIPath.children.map(function (c) {
-              if (c.segments.length > 1) {
-                  if (!isSameDirection(c, path)) {
-                      c.reverse();
-                  }
-                  var offseted = offsetSimpleShape(c, offset, join, limit);
-                  offseted = normalize(offseted);
-                  if (offseted.clockwise !== c.clockwise) {
-                      offseted.reverse();
-                  }
-                  if (offseted instanceof paper.CompoundPath) {
-                      offseted.applyMatrix = true;
-                      return offseted.children;
-                  }
-                  else {
-                      return offseted;
-                  }
-              }
-              else {
-                  return null;
-              }
-          });
-          var children = offsetParts.flat().filter(function (c) { return !!c; });
-          result = new paper.CompoundPath({ children: children, insert: false });
-      }
-      result.copyAttributes(nonSIPath, false);
-      result.remove();
-      return result;
-  }
-  function offsetStroke(path, offset, join, cap, limit) {
-      var nonSIPath = getNonSelfItersectionPath(path);
-      var result = nonSIPath;
-      if (nonSIPath instanceof paper.Path) {
-          result = offsetSimpleStroke(nonSIPath, offset, join, cap, limit);
-      }
-      else {
-          var children = nonSIPath.children.flatMap(function (c) {
-              return offsetSimpleStroke(c, offset, join, cap, limit);
-          });
-          result = children.reduce(function (c1, c2) { return c1.unite(c2, { insert: false }); });
-      }
-      result.strokeWidth = 0;
-      result.fillColor = nonSIPath.strokeColor;
-      result.shadowBlur = nonSIPath.shadowBlur;
-      result.shadowColor = nonSIPath.shadowColor;
-      result.shadowOffset = nonSIPath.shadowOffset;
-      return result;
-  }
+    function resolveOptions(options) {
+        var _a, _b, _c, _d;
+        return {
+            join: (_a = options === null || options === void 0 ? void 0 : options.join) !== null && _a !== void 0 ? _a : 'miter',
+            cap: (_b = options === null || options === void 0 ? void 0 : options.cap) !== null && _b !== void 0 ? _b : 'butt',
+            limit: (_c = options === null || options === void 0 ? void 0 : options.limit) !== null && _c !== void 0 ? _c : 10,
+            algorithm: (_d = options === null || options === void 0 ? void 0 : options.algorithm) !== null && _d !== void 0 ? _d : 'auto',
+        };
+    }
+    function insertResult(source, result, options) {
+        if (!options || options.insert !== false) {
+            (source.parent || paper.project.activeLayer).addChild(result);
+        }
+    }
+    function offset(path, distance, options) {
+        var resolvedOptions = resolveOptions(options);
+        var newPath = offsetPath(path, distance, resolvedOptions.join, resolvedOptions.limit, resolvedOptions.algorithm);
+        insertResult(path, newPath, options);
+        return newPath;
+    }
+    function offsetStroke(path, distance, options) {
+        var resolvedOptions = resolveOptions(options);
+        var newPath = offsetStroke$1(path, distance, resolvedOptions.join, resolvedOptions.cap, resolvedOptions.limit, resolvedOptions.algorithm);
+        insertResult(path, newPath, options);
+        return newPath;
+    }
+    function analyze(source, result, distance, options) {
+        return analyzeOffsetQuality(source, result, distance, options || {});
+    }
+    var PaperOffset = /** @class */ (function () {
+        function PaperOffset() {
+        }
+        PaperOffset.offset = function (path, distance, options) {
+            return offset(path, distance, options);
+        };
+        PaperOffset.offsetStroke = function (path, distance, options) {
+            return offsetStroke(path, distance, options);
+        };
+        PaperOffset.analyze = function (source, result, distance, options) {
+            return analyze(source, result, distance, options);
+        };
+        return PaperOffset;
+    }());
+    /**
+     * @deprecated EXTEND existing paper module is not recommend anymore
+     */
+    function ExtendPaperJs(paperNs) {
+        paperNs.Path.prototype.offset = function (distance, options) {
+            return offset(this, distance, options);
+        };
+        paperNs.Path.prototype.offsetStroke = function (distance, options) {
+            return offsetStroke(this, distance, options);
+        };
+        paperNs.CompoundPath.prototype.offset = function (distance, options) {
+            return offset(this, distance, options);
+        };
+        paperNs.CompoundPath.prototype.offsetStroke = function (distance, options) {
+            return offsetStroke(this, distance, options);
+        };
+    }
 
-  var PaperOffset = /** @class */ (function () {
-      function PaperOffset() {
-      }
-      PaperOffset.offset = function (path, offset, options) {
-          options = options || {};
-          var newPath = offsetPath(path, offset, options.join || 'miter', options.limit || 10);
-          if (options.insert === undefined) {
-              options.insert = true;
-          }
-          if (options.insert) {
-              (path.parent || paper.project.activeLayer).addChild(newPath);
-          }
-          return newPath;
-      };
-      PaperOffset.offsetStroke = function (path, offset, options) {
-          options = options || {};
-          var newPath = offsetStroke(path, offset, options.join || 'miter', options.cap || 'butt', options.limit || 10);
-          if (options.insert === undefined) {
-              options.insert = true;
-          }
-          if (options.insert) {
-              (path.parent || paper.project.activeLayer).addChild(newPath);
-          }
-          return newPath;
-      };
-      return PaperOffset;
-  }());
-  /**
-   * @deprecated EXTEND existing paper module is not recommend anymore
-   */
-  function ExtendPaperJs(paperNs) {
-      paperNs.Path.prototype.offset = function (offset, options) {
-          return PaperOffset.offset(this, offset, options);
-      };
-      paperNs.Path.prototype.offsetStroke = function (offset, options) {
-          return PaperOffset.offsetStroke(this, offset, options);
-      };
-      paperNs.CompoundPath.prototype.offset = function (offset, options) {
-          return PaperOffset.offset(this, offset, options);
-      };
-      paperNs.CompoundPath.prototype.offsetStroke = function (offset, options) {
-          return PaperOffset.offsetStroke(this, offset, options);
-      };
-  }
+    exports.PaperOffset = PaperOffset;
+    exports.analyze = analyze;
+    exports.default = ExtendPaperJs;
+    exports.extendPaperJs = ExtendPaperJs;
+    exports.offset = offset;
+    exports.offsetStroke = offsetStroke;
 
-  exports.PaperOffset = PaperOffset;
-  exports.default = ExtendPaperJs;
+    Object.defineProperty(exports, '__esModule', { value: true });
 
-  Object.defineProperty(exports, '__esModule', { value: true });
+}));
 
-})));
+;(function(global) {
+  if (!global || !global.paperjsOffset) return;
+  global.PaperOffset = global.paperjsOffset;
+  if (global.paper && typeof global.paperjsOffset.default === 'function') {
+    global.paperjsOffset.default(global.paper);
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : this);
 //# sourceMappingURL=index.umd.js.map