js-angusj-clipper
Version:
Polygon and line clipping and offsetting library for Javascript / Typescript - a port of Angus Johnson's clipper to WebAssembly / Asm.JS
244 lines • 36.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ClipperOffset = void 0;
var nativeEnumConversion_1 = require("./native/nativeEnumConversion");
var PathsToNativePaths_1 = require("./native/PathsToNativePaths");
var PathToNativePath_1 = require("./native/PathToNativePath");
var PolyTree_1 = require("./PolyTree");
var nativeFinalizationRegistry_1 = require("./nativeFinalizationRegistry");
/**
* The ClipperOffset class encapsulates the process of offsetting (inflating/deflating) both open and closed paths using a number of different join types
* and end types.
*
* Preconditions for offsetting:
* 1. The orientations of closed paths must be consistent such that outer polygons share the same orientation, and any holes have the opposite orientation
* (ie non-zero filling). Open paths must be oriented with closed outer polygons.
* 2. Polygons must not self-intersect.
*
* Limitations:
* When offsetting, small artefacts may appear where polygons overlap. To avoid these artefacts, offset overlapping polygons separately.
*/
var ClipperOffset = /** @class */ (function () {
/**
* The ClipperOffset constructor takes 2 optional parameters: MiterLimit and ArcTolerance. The two parameters corresponds to properties of the same name.
* MiterLimit is only relevant when JoinType is Miter, and ArcTolerance is only relevant when JoinType is Round or when EndType is OpenRound.
*
* @param _nativeLib - Native clipper lib instance to use
* @param miterLimit - Miter limit
* @param arcTolerance - ArcTolerance (round precision)
*/
function ClipperOffset(_nativeLib, miterLimit, arcTolerance) {
if (miterLimit === void 0) { miterLimit = 2; }
if (arcTolerance === void 0) { arcTolerance = 0.25; }
this._nativeLib = _nativeLib;
this._clipperOffset = new _nativeLib.ClipperOffset(miterLimit, arcTolerance);
nativeFinalizationRegistry_1.nativeFinalizationRegistry === null || nativeFinalizationRegistry_1.nativeFinalizationRegistry === void 0 ? void 0 : nativeFinalizationRegistry_1.nativeFinalizationRegistry.register(this, this._clipperOffset, this);
}
Object.defineProperty(ClipperOffset.prototype, "arcTolerance", {
/**
* Firstly, this field/property is only relevant when JoinType = Round and/or EndType = Round.
*
* Since flattened paths can never perfectly represent arcs, this field/property specifies a maximum acceptable imprecision ('tolerance') when arcs are
* approximated in an offsetting operation. Smaller values will increase 'smoothness' up to a point though at a cost of performance and in creating more
* vertices to construct the arc.
*
* The default ArcTolerance is 0.25 units. This means that the maximum distance the flattened path will deviate from the 'true' arc will be no more
* than 0.25 units (before rounding).
*
* Reducing tolerances below 0.25 will not improve smoothness since vertex coordinates will still be rounded to integer values. The only way to achieve
* sub-integer precision is through coordinate scaling before and after offsetting (see example below).
*
* It's important to make ArcTolerance a sensible fraction of the offset delta (arc radius). Large tolerances relative to the offset delta will produce
* poor arc approximations but, just as importantly, very small tolerances will substantially slow offsetting performance while providing unnecessary
* degrees of precision. This is most likely to be an issue when offsetting polygons whose coordinates have been scaled to preserve floating point precision.
*
* Example: Imagine a set of polygons (defined in floating point coordinates) that is to be offset by 10 units using round joins, and the solution is to
* retain floating point precision up to at least 6 decimal places.
* To preserve this degree of floating point precision, and given that Clipper and ClipperOffset both operate on integer coordinates, the polygon
* coordinates will be scaled up by 108 (and rounded to integers) prior to offsetting. Both offset delta and ArcTolerance will also need to be scaled
* by this same factor. If ArcTolerance was left unscaled at the default 0.25 units, every arc in the solution would contain a fraction of 44 THOUSAND
* vertices while the final arc imprecision would be 0.25 × 10-8 units (ie once scaling was reversed). However, if 0.1 units was an acceptable imprecision
* in the final unscaled solution, then ArcTolerance should be set to 0.1 × scaling_factor (0.1 × 108 ). Now if scaling is applied equally to both
* ArcTolerance and to Delta Offset, then in this example the number of vertices (steps) defining each arc would be a fraction of 23.
*
* The formula for the number of steps in a full circular arc is ... Pi / acos(1 - arc_tolerance / abs(delta))
*
* @return {number} - Current arc tolerance
*/
get: function () {
return this._clipperOffset.arcTolerance;
},
/**
* Firstly, this field/property is only relevant when JoinType = Round and/or EndType = Round.
*
* Since flattened paths can never perfectly represent arcs, this field/property specifies a maximum acceptable imprecision ('tolerance') when arcs are
* approximated in an offsetting operation. Smaller values will increase 'smoothness' up to a point though at a cost of performance and in creating more
* vertices to construct the arc.
*
* The default ArcTolerance is 0.25 units. This means that the maximum distance the flattened path will deviate from the 'true' arc will be no more
* than 0.25 units (before rounding).
*
* Reducing tolerances below 0.25 will not improve smoothness since vertex coordinates will still be rounded to integer values. The only way to achieve
* sub-integer precision is through coordinate scaling before and after offsetting (see example below).
*
* It's important to make ArcTolerance a sensible fraction of the offset delta (arc radius). Large tolerances relative to the offset delta will produce
* poor arc approximations but, just as importantly, very small tolerances will substantially slow offsetting performance while providing unnecessary
* degrees of precision. This is most likely to be an issue when offsetting polygons whose coordinates have been scaled to preserve floating point precision.
*
* Example: Imagine a set of polygons (defined in floating point coordinates) that is to be offset by 10 units using round joins, and the solution is to
* retain floating point precision up to at least 6 decimal places.
* To preserve this degree of floating point precision, and given that Clipper and ClipperOffset both operate on integer coordinates, the polygon
* coordinates will be scaled up by 108 (and rounded to integers) prior to offsetting. Both offset delta and ArcTolerance will also need to be scaled
* by this same factor. If ArcTolerance was left unscaled at the default 0.25 units, every arc in the solution would contain a fraction of 44 THOUSAND
* vertices while the final arc imprecision would be 0.25 × 10-8 units (ie once scaling was reversed). However, if 0.1 units was an acceptable imprecision
* in the final unscaled solution, then ArcTolerance should be set to 0.1 × scaling_factor (0.1 × 108 ). Now if scaling is applied equally to both
* ArcTolerance and to Delta Offset, then in this example the number of vertices (steps) defining each arc would be a fraction of 23.
*
* The formula for the number of steps in a full circular arc is ... Pi / acos(1 - arc_tolerance / abs(delta))
*
* @param value - Arc tolerance to set.
*/
set: function (value) {
this._clipperOffset.arcTolerance = value;
},
enumerable: false,
configurable: true
});
Object.defineProperty(ClipperOffset.prototype, "miterLimit", {
/**
* This property sets the maximum distance in multiples of delta that vertices can be offset from their original positions before squaring is applied.
* (Squaring truncates a miter by 'cutting it off' at 1 × delta distance from the original vertex.)
*
* The default value for MiterLimit is 2 (ie twice delta). This is also the smallest MiterLimit that's allowed. If mitering was unrestricted (ie without
* any squaring), then offsets at very acute angles would generate unacceptably long 'spikes'.
*
* @return {number} - Current miter limit
*/
get: function () {
return this._clipperOffset.miterLimit;
},
/**
* Sets the current miter limit (see getter docs for more info).
*
* @param value - Mit limit to set.
*/
set: function (value) {
this._clipperOffset.miterLimit = value;
},
enumerable: false,
configurable: true
});
/**
* Adds a Path to a ClipperOffset object in preparation for offsetting.
*
* Any number of paths can be added, and each has its own JoinType and EndType. All 'outer' Paths must have the same orientation, and any 'hole' paths must
* have reverse orientation. Closed paths must have at least 3 vertices. Open paths may have as few as one vertex. Open paths can only be offset
* with positive deltas.
*
* @param path - Path to add
* @param joinType - Join type
* @param endType - End type
*/
ClipperOffset.prototype.addPath = function (path, joinType, endType) {
var nativePath = (0, PathToNativePath_1.pathToNativePath)(this._nativeLib, path);
try {
this._clipperOffset.addPath(nativePath, (0, nativeEnumConversion_1.joinTypeToNative)(this._nativeLib, joinType), (0, nativeEnumConversion_1.endTypeToNative)(this._nativeLib, endType));
}
finally {
nativePath.delete();
}
};
/**
* Adds Paths to a ClipperOffset object in preparation for offsetting.
*
* Any number of paths can be added, and each path has its own JoinType and EndType. All 'outer' Paths must have the same orientation, and any 'hole'
* paths must have reverse orientation. Closed paths must have at least 3 vertices. Open paths may have as few as one vertex. Open paths can only be
* offset with positive deltas.
*
* @param paths - Paths to add
* @param joinType - Join type
* @param endType - End type
*/
ClipperOffset.prototype.addPaths = function (paths, joinType, endType) {
var nativePaths = (0, PathsToNativePaths_1.pathsToNativePaths)(this._nativeLib, paths);
try {
this._clipperOffset.addPaths(nativePaths, (0, nativeEnumConversion_1.joinTypeToNative)(this._nativeLib, joinType), (0, nativeEnumConversion_1.endTypeToNative)(this._nativeLib, endType));
}
finally {
nativePaths.delete();
}
};
/**
* Negative delta values shrink polygons and positive delta expand them.
*
* This method can be called multiple times, offsetting the same paths by different amounts (ie using different deltas).
*
* @param delta - Delta
* @param cleanDistance - Clean distance over the output, or undefined for no cleaning.
* @return {Paths} - Solution paths
*/
ClipperOffset.prototype.executeToPaths = function (delta, cleanDistance) {
var outNativePaths = new this._nativeLib.Paths();
try {
this._clipperOffset.executePaths(outNativePaths, delta);
if (cleanDistance !== undefined) {
this._nativeLib.cleanPolygons(outNativePaths, cleanDistance);
}
return (0, PathsToNativePaths_1.nativePathsToPaths)(this._nativeLib, outNativePaths, true); // frees outNativePaths
}
finally {
if (!outNativePaths.isDeleted()) {
outNativePaths.delete();
}
}
};
/**
* This method takes two parameters. The first is the structure that receives the result of the offset operation (a PolyTree structure). The second parameter
* is the amount to which the supplied paths will be offset. Negative delta values shrink polygons and positive delta expand them.
*
* This method can be called multiple times, offsetting the same paths by different amounts (ie using different deltas).
*
* @param delta - Delta
* @return {Paths} - Solution paths
*/
ClipperOffset.prototype.executeToPolyTree = function (delta) {
var outNativePolyTree = new this._nativeLib.PolyTree();
try {
this._clipperOffset.executePolyTree(outNativePolyTree, delta);
return PolyTree_1.PolyTree.fromNativePolyTree(this._nativeLib, outNativePolyTree, true); // frees outNativePolyTree
}
finally {
if (!outNativePolyTree.isDeleted()) {
outNativePolyTree.delete();
}
}
};
/**
* This method clears all paths from the ClipperOffset object, allowing new paths to be assigned.
*/
ClipperOffset.prototype.clear = function () {
this._clipperOffset.clear();
};
/**
* Checks if the object has been disposed.
*
* @return {boolean} - true if disposed, false if not
*/
ClipperOffset.prototype.isDisposed = function () {
return this._clipperOffset === undefined || this._clipperOffset.isDeleted();
};
/**
* Since this library uses WASM/ASM.JS internally for speed this means that you must dispose objects after you are done using them or mem leaks will occur.
* (If the runtime supports FinalizationRegistry then this becomes non-mandatory, but still recommended).
*/
ClipperOffset.prototype.dispose = function () {
if (this._clipperOffset) {
this._clipperOffset.delete();
nativeFinalizationRegistry_1.nativeFinalizationRegistry === null || nativeFinalizationRegistry_1.nativeFinalizationRegistry === void 0 ? void 0 : nativeFinalizationRegistry_1.nativeFinalizationRegistry.unregister(this);
this._clipperOffset = undefined;
}
};
return ClipperOffset;
}());
exports.ClipperOffset = ClipperOffset;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ClipperOffset.js","sourceRoot":"","sources":["../src/ClipperOffset.ts"],"names":[],"mappings":";;;AAIA,sEAAkF;AAClF,kEAAqF;AACrF,8DAA6D;AAG7D,uCAAsC;AACtC,2EAA0E;AAE1E;;;;;;;;;;;GAWG;AACH;IA6FE;;;;;;;OAOG;IACH,uBACmB,UAAoC,EACrD,UAAc,EACd,YAAmB;QADnB,2BAAA,EAAA,cAAc;QACd,6BAAA,EAAA,mBAAmB;QAFF,eAAU,GAAV,UAAU,CAA0B;QAIrD,IAAI,CAAC,cAAc,GAAG,IAAI,UAAU,CAAC,aAAa,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAC7E,uDAA0B,aAA1B,uDAA0B,uBAA1B,uDAA0B,CAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;IACxE,CAAC;IA3ED,sBAAI,uCAAY;QA9BhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA6BG;aACH;YACE,OAAO,IAAI,CAAC,cAAe,CAAC,YAAY,CAAC;QAC3C,CAAC;QAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA6BG;aACH,UAAiB,KAAa;YAC5B,IAAI,CAAC,cAAe,CAAC,YAAY,GAAG,KAAK,CAAC;QAC5C,CAAC;;;OAlCA;IA6CD,sBAAI,qCAAU;QATd;;;;;;;;WAQG;aACH;YACE,OAAO,IAAI,CAAC,cAAe,CAAC,UAAU,CAAC;QACzC,CAAC;QAED;;;;WAIG;aACH,UAAe,KAAa;YAC1B,IAAI,CAAC,cAAe,CAAC,UAAU,GAAG,KAAK,CAAC;QAC1C,CAAC;;;OATA;IA4BD;;;;;;;;;;OAUG;IACH,+BAAO,GAAP,UAAQ,IAAkB,EAAE,QAAkB,EAAE,OAAgB;QAC9D,IAAM,UAAU,GAAG,IAAA,mCAAgB,EAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QAC3D,IAAI;YACF,IAAI,CAAC,cAAe,CAAC,OAAO,CAC1B,UAAU,EACV,IAAA,uCAAgB,EAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,EAC3C,IAAA,sCAAe,EAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,CAC1C,CAAC;SACH;gBAAS;YACR,UAAU,CAAC,MAAM,EAAE,CAAC;SACrB;IACH,CAAC;IAED;;;;;;;;;;OAUG;IACH,gCAAQ,GAAR,UAAS,KAAoB,EAAE,QAAkB,EAAE,OAAgB;QACjE,IAAM,WAAW,GAAG,IAAA,uCAAkB,EAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAC/D,IAAI;YACF,IAAI,CAAC,cAAe,CAAC,QAAQ,CAC3B,WAAW,EACX,IAAA,uCAAgB,EAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,EAC3C,IAAA,sCAAe,EAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,CAC1C,CAAC;SACH;gBAAS;YACR,WAAW,CAAC,MAAM,EAAE,CAAC;SACtB;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,sCAAc,GAAd,UAAe,KAAa,EAAE,aAAiC;QAC7D,IAAM,cAAc,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACnD,IAAI;YACF,IAAI,CAAC,cAAe,CAAC,YAAY,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC;YACzD,IAAI,aAAa,KAAK,SAAS,EAAE;gBAC/B,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;aAC9D;YACD,OAAO,IAAA,uCAAkB,EAAC,IAAI,CAAC,UAAU,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC,CAAC,uBAAuB;SAC1F;gBAAS;YACR,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,EAAE;gBAC/B,cAAc,CAAC,MAAM,EAAE,CAAC;aACzB;SACF;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,yCAAiB,GAAjB,UAAkB,KAAa;QAC7B,IAAM,iBAAiB,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;QACzD,IAAI;YACF,IAAI,CAAC,cAAe,CAAC,eAAe,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;YAC/D,OAAO,mBAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,EAAE,iBAAiB,EAAE,IAAI,CAAC,CAAC,CAAC,0BAA0B;SACzG;gBAAS;YACR,IAAI,CAAC,iBAAiB,CAAC,SAAS,EAAE,EAAE;gBAClC,iBAAiB,CAAC,MAAM,EAAE,CAAC;aAC5B;SACF;IACH,CAAC;IAED;;OAEG;IACH,6BAAK,GAAL;QACE,IAAI,CAAC,cAAe,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;IAED;;;;OAIG;IACH,kCAAU,GAAV;QACE,OAAO,IAAI,CAAC,cAAc,KAAK,SAAS,IAAI,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC;IAC9E,CAAC;IAED;;;OAGG;IACH,+BAAO,GAAP;QACE,IAAI,IAAI,CAAC,cAAc,EAAE;YACvB,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;YAC7B,uDAA0B,aAA1B,uDAA0B,uBAA1B,uDAA0B,CAAE,UAAU,CAAC,IAAI,CAAC,CAAC;YAC7C,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;SACjC;IACH,CAAC;IACH,oBAAC;AAAD,CAAC,AAtOD,IAsOC;AAtOY,sCAAa","sourcesContent":["/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport { EndType, JoinType } from \"./enums\";\nimport { NativeClipperLibInstance } from \"./native/NativeClipperLibInstance\";\nimport { NativeClipperOffset } from \"./native/NativeClipperOffset\";\nimport { endTypeToNative, joinTypeToNative } from \"./native/nativeEnumConversion\";\nimport { nativePathsToPaths, pathsToNativePaths } from \"./native/PathsToNativePaths\";\nimport { pathToNativePath } from \"./native/PathToNativePath\";\nimport { ReadonlyPath } from \"./Path\";\nimport { Paths, ReadonlyPaths } from \"./Paths\";\nimport { PolyTree } from \"./PolyTree\";\nimport { nativeFinalizationRegistry } from \"./nativeFinalizationRegistry\";\n\n/**\n * The ClipperOffset class encapsulates the process of offsetting (inflating/deflating) both open and closed paths using a number of different join types\n * and end types.\n *\n * Preconditions for offsetting:\n * 1. The orientations of closed paths must be consistent such that outer polygons share the same orientation, and any holes have the opposite orientation\n * (ie non-zero filling). Open paths must be oriented with closed outer polygons.\n * 2. Polygons must not self-intersect.\n *\n * Limitations:\n * When offsetting, small artefacts may appear where polygons overlap. To avoid these artefacts, offset overlapping polygons separately.\n */\nexport class ClipperOffset {\n  private _clipperOffset?: NativeClipperOffset;\n\n  /**\n   * Firstly, this field/property is only relevant when JoinType = Round and/or EndType = Round.\n   *\n   * Since flattened paths can never perfectly represent arcs, this field/property specifies a maximum acceptable imprecision ('tolerance') when arcs are\n   * approximated in an offsetting operation. Smaller values will increase 'smoothness' up to a point though at a cost of performance and in creating more\n   * vertices to construct the arc.\n   *\n   * The default ArcTolerance is 0.25 units. This means that the maximum distance the flattened path will deviate from the 'true' arc will be no more\n   * than 0.25 units (before rounding).\n   *\n   * Reducing tolerances below 0.25 will not improve smoothness since vertex coordinates will still be rounded to integer values. The only way to achieve\n   * sub-integer precision is through coordinate scaling before and after offsetting (see example below).\n   *\n   * It's important to make ArcTolerance a sensible fraction of the offset delta (arc radius). Large tolerances relative to the offset delta will produce\n   * poor arc approximations but, just as importantly, very small tolerances will substantially slow offsetting performance while providing unnecessary\n   * degrees of precision. This is most likely to be an issue when offsetting polygons whose coordinates have been scaled to preserve floating point precision.\n   *\n   * Example: Imagine a set of polygons (defined in floating point coordinates) that is to be offset by 10 units using round joins, and the solution is to\n   * retain floating point precision up to at least 6 decimal places.\n   * To preserve this degree of floating point precision, and given that Clipper and ClipperOffset both operate on integer coordinates, the polygon\n   * coordinates will be scaled up by 108 (and rounded to integers) prior to offsetting. Both offset delta and ArcTolerance will also need to be scaled\n   * by this same factor. If ArcTolerance was left unscaled at the default 0.25 units, every arc in the solution would contain a fraction of 44 THOUSAND\n   * vertices while the final arc imprecision would be 0.25 × 10-8 units (ie once scaling was reversed). However, if 0.1 units was an acceptable imprecision\n   * in the final unscaled solution, then ArcTolerance should be set to 0.1 × scaling_factor (0.1 × 108 ). Now if scaling is applied equally to both\n   * ArcTolerance and to Delta Offset, then in this example the number of vertices (steps) defining each arc would be a fraction of 23.\n   *\n   * The formula for the number of steps in a full circular arc is ... Pi / acos(1 - arc_tolerance / abs(delta))\n   *\n   * @return {number} - Current arc tolerance\n   */\n  get arcTolerance(): number {\n    return this._clipperOffset!.arcTolerance;\n  }\n\n  /**\n   * Firstly, this field/property is only relevant when JoinType = Round and/or EndType = Round.\n   *\n   * Since flattened paths can never perfectly represent arcs, this field/property specifies a maximum acceptable imprecision ('tolerance') when arcs are\n   * approximated in an offsetting operation. Smaller values will increase 'smoothness' up to a point though at a cost of performance and in creating more\n   * vertices to construct the arc.\n   *\n   * The default ArcTolerance is 0.25 units. This means that the maximum distance the flattened path will deviate from the 'true' arc will be no more\n   * than 0.25 units (before rounding).\n   *\n   * Reducing tolerances below 0.25 will not improve smoothness since vertex coordinates will still be rounded to integer values. The only way to achieve\n   * sub-integer precision is through coordinate scaling before and after offsetting (see example below).\n   *\n   * It's important to make ArcTolerance a sensible fraction of the offset delta (arc radius). Large tolerances relative to the offset delta will produce\n   * poor arc approximations but, just as importantly, very small tolerances will substantially slow offsetting performance while providing unnecessary\n   * degrees of precision. This is most likely to be an issue when offsetting polygons whose coordinates have been scaled to preserve floating point precision.\n   *\n   * Example: Imagine a set of polygons (defined in floating point coordinates) that is to be offset by 10 units using round joins, and the solution is to\n   * retain floating point precision up to at least 6 decimal places.\n   * To preserve this degree of floating point precision, and given that Clipper and ClipperOffset both operate on integer coordinates, the polygon\n   * coordinates will be scaled up by 108 (and rounded to integers) prior to offsetting. Both offset delta and ArcTolerance will also need to be scaled\n   * by this same factor. If ArcTolerance was left unscaled at the default 0.25 units, every arc in the solution would contain a fraction of 44 THOUSAND\n   * vertices while the final arc imprecision would be 0.25 × 10-8 units (ie once scaling was reversed). However, if 0.1 units was an acceptable imprecision\n   * in the final unscaled solution, then ArcTolerance should be set to 0.1 × scaling_factor (0.1 × 108 ). Now if scaling is applied equally to both\n   * ArcTolerance and to Delta Offset, then in this example the number of vertices (steps) defining each arc would be a fraction of 23.\n   *\n   * The formula for the number of steps in a full circular arc is ... Pi / acos(1 - arc_tolerance / abs(delta))\n   *\n   * @param value - Arc tolerance to set.\n   */\n  set arcTolerance(value: number) {\n    this._clipperOffset!.arcTolerance = value;\n  }\n\n  /**\n   * This property sets the maximum distance in multiples of delta that vertices can be offset from their original positions before squaring is applied.\n   * (Squaring truncates a miter by 'cutting it off' at 1 × delta distance from the original vertex.)\n   *\n   * The default value for MiterLimit is 2 (ie twice delta). This is also the smallest MiterLimit that's allowed. If mitering was unrestricted (ie without\n   * any squaring), then offsets at very acute angles would generate unacceptably long 'spikes'.\n   *\n   * @return {number} - Current miter limit\n   */\n  get miterLimit(): number {\n    return this._clipperOffset!.miterLimit;\n  }\n\n  /**\n   * Sets the current miter limit (see getter docs for more info).\n   *\n   * @param value - Mit limit to set.\n   */\n  set miterLimit(value: number) {\n    this._clipperOffset!.miterLimit = value;\n  }\n\n  /**\n   * The ClipperOffset constructor takes 2 optional parameters: MiterLimit and ArcTolerance. The two parameters corresponds to properties of the same name.\n   * MiterLimit is only relevant when JoinType is Miter, and ArcTolerance is only relevant when JoinType is Round or when EndType is OpenRound.\n   *\n   * @param _nativeLib - Native clipper lib instance to use\n   * @param miterLimit - Miter limit\n   * @param arcTolerance - ArcTolerance (round precision)\n   */\n  constructor(\n    private readonly _nativeLib: NativeClipperLibInstance,\n    miterLimit = 2,\n    arcTolerance = 0.25\n  ) {\n    this._clipperOffset = new _nativeLib.ClipperOffset(miterLimit, arcTolerance);\n    nativeFinalizationRegistry?.register(this, this._clipperOffset, this);\n  }\n\n  /**\n   * Adds a Path to a ClipperOffset object in preparation for offsetting.\n   *\n   * Any number of paths can be added, and each has its own JoinType and EndType. All 'outer' Paths must have the same orientation, and any 'hole' paths must\n   * have reverse orientation. Closed paths must have at least 3 vertices. Open paths may have as few as one vertex. Open paths can only be offset\n   * with positive deltas.\n   *\n   * @param path - Path to add\n   * @param joinType - Join type\n   * @param endType - End type\n   */\n  addPath(path: ReadonlyPath, joinType: JoinType, endType: EndType): void {\n    const nativePath = pathToNativePath(this._nativeLib, path);\n    try {\n      this._clipperOffset!.addPath(\n        nativePath,\n        joinTypeToNative(this._nativeLib, joinType),\n        endTypeToNative(this._nativeLib, endType)\n      );\n    } finally {\n      nativePath.delete();\n    }\n  }\n\n  /**\n   * Adds Paths to a ClipperOffset object in preparation for offsetting.\n   *\n   * Any number of paths can be added, and each path has its own JoinType and EndType. All 'outer' Paths must have the same orientation, and any 'hole'\n   * paths must have reverse orientation. Closed paths must have at least 3 vertices. Open paths may have as few as one vertex. Open paths can only be\n   * offset with positive deltas.\n   *\n   * @param paths - Paths to add\n   * @param joinType - Join type\n   * @param endType - End type\n   */\n  addPaths(paths: ReadonlyPaths, joinType: JoinType, endType: EndType): void {\n    const nativePaths = pathsToNativePaths(this._nativeLib, paths);\n    try {\n      this._clipperOffset!.addPaths(\n        nativePaths,\n        joinTypeToNative(this._nativeLib, joinType),\n        endTypeToNative(this._nativeLib, endType)\n      );\n    } finally {\n      nativePaths.delete();\n    }\n  }\n\n  /**\n   * Negative delta values shrink polygons and positive delta expand them.\n   *\n   * This method can be called multiple times, offsetting the same paths by different amounts (ie using different deltas).\n   *\n   * @param delta - Delta\n   * @param cleanDistance - Clean distance over the output, or undefined for no cleaning.\n   * @return {Paths} - Solution paths\n   */\n  executeToPaths(delta: number, cleanDistance: number | undefined): Paths {\n    const outNativePaths = new this._nativeLib.Paths();\n    try {\n      this._clipperOffset!.executePaths(outNativePaths, delta);\n      if (cleanDistance !== undefined) {\n        this._nativeLib.cleanPolygons(outNativePaths, cleanDistance);\n      }\n      return nativePathsToPaths(this._nativeLib, outNativePaths, true); // frees outNativePaths\n    } finally {\n      if (!outNativePaths.isDeleted()) {\n        outNativePaths.delete();\n      }\n    }\n  }\n\n  /**\n   * This method takes two parameters. The first is the structure that receives the result of the offset operation (a PolyTree structure). The second parameter\n   * is the amount to which the supplied paths will be offset. Negative delta values shrink polygons and positive delta expand them.\n   *\n   * This method can be called multiple times, offsetting the same paths by different amounts (ie using different deltas).\n   *\n   * @param delta - Delta\n   * @return {Paths} - Solution paths\n   */\n  executeToPolyTree(delta: number): PolyTree {\n    const outNativePolyTree = new this._nativeLib.PolyTree();\n    try {\n      this._clipperOffset!.executePolyTree(outNativePolyTree, delta);\n      return PolyTree.fromNativePolyTree(this._nativeLib, outNativePolyTree, true); // frees outNativePolyTree\n    } finally {\n      if (!outNativePolyTree.isDeleted()) {\n        outNativePolyTree.delete();\n      }\n    }\n  }\n\n  /**\n   * This method clears all paths from the ClipperOffset object, allowing new paths to be assigned.\n   */\n  clear(): void {\n    this._clipperOffset!.clear();\n  }\n\n  /**\n   * Checks if the object has been disposed.\n   *\n   * @return {boolean} - true if disposed, false if not\n   */\n  isDisposed(): boolean {\n    return this._clipperOffset === undefined || this._clipperOffset.isDeleted();\n  }\n\n  /**\n   * Since this library uses WASM/ASM.JS internally for speed this means that you must dispose objects after you are done using them or mem leaks will occur.\n   * (If the runtime supports FinalizationRegistry then this becomes non-mandatory, but still recommended).\n   */\n  dispose(): void {\n    if (this._clipperOffset) {\n      this._clipperOffset.delete();\n      nativeFinalizationRegistry?.unregister(this);\n      this._clipperOffset = undefined;\n    }\n  }\n}\n"]}