js-angusj-clipper/web/Clipper.js

Polygon and line clipping and offsetting library for Javascript / Typescript - a port of Angus Johnson's clipper to WebAssembly / Asm.JS

"use strict";
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);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Clipper = 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");
var Clipper = /** @class */ (function () {
    /**
     * The Clipper constructor creates an instance of the Clipper class. One or more InitOptions may be passed as a parameter to set the corresponding properties.
     * (These properties can still be set or reset after construction.)
     *
     * @param _nativeLib
     * @param initOptions
     */
    function Clipper(_nativeLib, initOptions) {
        if (initOptions === void 0) { initOptions = {}; }
        this._nativeLib = _nativeLib;
        var realInitOptions = __assign({ reverseSolutions: false, strictlySimple: false, preserveCollinear: false }, initOptions);
        var nativeInitOptions = 0;
        if (realInitOptions.reverseSolutions) {
            nativeInitOptions += _nativeLib.InitOptions.ReverseSolution.value;
        }
        if (realInitOptions.strictlySimple) {
            nativeInitOptions += _nativeLib.InitOptions.StrictlySimple.value;
        }
        if (realInitOptions.preserveCollinear) {
            nativeInitOptions += _nativeLib.InitOptions.PreserveCollinear.value;
        }
        this._clipper = new _nativeLib.Clipper(nativeInitOptions);
        nativeFinalizationRegistry_1.nativeFinalizationRegistry === null || nativeFinalizationRegistry_1.nativeFinalizationRegistry === void 0 ? void 0 : nativeFinalizationRegistry_1.nativeFinalizationRegistry.register(this, this._clipper, this);
    }
    Object.defineProperty(Clipper.prototype, "preserveCollinear", {
        /**
         * By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before
         * clipping. When enabled the preserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.
         *
         * @return {boolean} - true if set, false otherwise
         */
        get: function () {
            return this._clipper.preserveCollinear;
        },
        /**
         * By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before
         * clipping. When enabled the preserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.
         *
         * @param value - value to set
         */
        set: function (value) {
            this._clipper.preserveCollinear = value;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Clipper.prototype, "reverseSolution", {
        /**
         * When this property is set to true, polygons returned in the solution parameter of the execute() method will have orientations opposite to their normal
         * orientations.
         *
         * @return {boolean} - true if set, false otherwise
         */
        get: function () {
            return this._clipper.reverseSolution;
        },
        /**
         * When this property is set to true, polygons returned in the solution parameter of the execute() method will have orientations opposite to their normal
         * orientations.
         *
         * @param value - value to set
         */
        set: function (value) {
            this._clipper.reverseSolution = value;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Clipper.prototype, "strictlySimple", {
        /**
         * Terminology:
         * - A simple polygon is one that does not self-intersect.
         * - A weakly simple polygon is a simple polygon that contains 'touching' vertices, or 'touching' edges.
         * - A strictly simple polygon is a simple polygon that does not contain 'touching' vertices, or 'touching' edges.
         *
         * Vertices 'touch' if they share the same coordinates (and are not adjacent). An edge touches another if one of its end vertices touches another edge
         * excluding its adjacent edges, or if they are co-linear and overlapping (including adjacent edges).
         *
         * Polygons returned by clipping operations (see Clipper.execute()) should always be simple polygons. When the StrictlySimply property is enabled,
         * polygons returned will be strictly simple, otherwise they may be weakly simple. It's computationally expensive ensuring polygons are strictly simple
         * and so this property is disabled by default.
         *
         * Note: There's currently no guarantee that polygons will be strictly simple since 'simplifying' is still a work in progress.
         *
         * @return {boolean} - true if set, false otherwise
         */
        get: function () {
            return this._clipper.strictlySimple;
        },
        /**
         * Terminology:
         * - A simple polygon is one that does not self-intersect.
         * - A weakly simple polygon is a simple polygon that contains 'touching' vertices, or 'touching' edges.
         * - A strictly simple polygon is a simple polygon that does not contain 'touching' vertices, or 'touching' edges.
         *
         * Vertices 'touch' if they share the same coordinates (and are not adjacent). An edge touches another if one of its end vertices touches another edge
         * excluding its adjacent edges, or if they are co-linear and overlapping (including adjacent edges).
         *
         * Polygons returned by clipping operations (see Clipper.execute()) should always be simple polygons. When the StrictlySimply property is enabled,
         * polygons returned will be strictly simple, otherwise they may be weakly simple. It's computationally expensive ensuring polygons are strictly simple
         * and so this property is disabled by default.
         *
         * Note: There's currently no guarantee that polygons will be strictly simple since 'simplifying' is still a work in progress.
         *
         * @param value - value to set
         */
        set: function (value) {
            this._clipper.strictlySimple = value;
        },
        enumerable: false,
        configurable: true
    });
    /**
     * Any number of subject and clip paths can be added to a clipping task, either individually via the addPath() method, or as groups via the addPaths()
     * method, or even using both methods.
     *
     * 'Subject' paths may be either open (lines) or closed (polygons) or even a mixture of both, but 'clipping' paths must always be closed. Clipper allows
     * polygons to clip both lines and other polygons, but doesn't allow lines to clip either lines or polygons.
     *
     * With closed paths, orientation should conform with the filling rule that will be passed via Clipper's execute method.
     *
     * Path Coordinate range:
     * Path coordinates must be between ± 9007199254740991, otherwise a range error will be thrown when attempting to add the path to the Clipper object.
     * If coordinates can be kept between ± 0x3FFFFFFF (± 1.0e+9), a modest increase in performance (approx. 15-20%) over the larger range can be achieved by
     * avoiding large integer math.
     *
     * Return Value:
     * The function will return false if the path is invalid for clipping. A path is invalid for clipping when:
     * - it has less than 2 vertices
     * - it has 2 vertices but is not an open path
     * - the vertices are all co-linear and it is not an open path
     *
     * @param path - Path to add
     * @param polyType - Polygon type
     * @param closed - If the path is closed
     */
    Clipper.prototype.addPath = function (path, polyType, closed) {
        var nativePath = PathToNativePath_1.pathToNativePath(this._nativeLib, path);
        try {
            return this._clipper.addPath(nativePath, nativeEnumConversion_1.polyTypeToNative(this._nativeLib, polyType), closed);
        }
        finally {
            nativePath.delete();
        }
    };
    /**
     * Any number of subject and clip paths can be added to a clipping task, either individually via the addPath() method, or as groups via the addPaths()
     * method, or even using both methods.
     *
     * 'Subject' paths may be either open (lines) or closed (polygons) or even a mixture of both, but 'clipping' paths must always be closed. Clipper allows
     * polygons to clip both lines and other polygons, but doesn't allow lines to clip either lines or polygons.
     *
     * With closed paths, orientation should conform with the filling rule that will be passed via Clipper's execute method.
     *
     * Path Coordinate range:
     * Path coordinates must be between ± 9007199254740991, otherwise a range error will be thrown when attempting to add the path to the Clipper object.
     * If coordinates can be kept between ± 0x3FFFFFFF (± 1.0e+9), a modest increase in performance (approx. 15-20%) over the larger range can be achieved
     * by avoiding large integer math.
     *
     * Return Value:
     * The function will return false if the path is invalid for clipping. A path is invalid for clipping when:
     * - it has less than 2 vertices
     * - it has 2 vertices but is not an open path
     * - the vertices are all co-linear and it is not an open path
     *
     * @param paths - Paths to add
     * @param polyType - Paths polygon type
     * @param closed - If all the inner paths are closed
     */
    Clipper.prototype.addPaths = function (paths, polyType, closed) {
        var nativePaths = PathsToNativePaths_1.pathsToNativePaths(this._nativeLib, paths);
        try {
            return this._clipper.addPaths(nativePaths, nativeEnumConversion_1.polyTypeToNative(this._nativeLib, polyType), closed);
        }
        finally {
            nativePaths.delete();
        }
    };
    /**
     * The Clear method removes any existing subject and clip polygons allowing the Clipper object to be reused for clipping operations on different polygon sets.
     */
    Clipper.prototype.clear = function () {
        this._clipper.clear();
    };
    /**
     * This method returns the axis-aligned bounding rectangle of all polygons that have been added to the Clipper object.
     *
     * @return {{left: number, right: number, top: number, bottom: number}} - Bounds
     */
    Clipper.prototype.getBounds = function () {
        var nativeBounds = this._clipper.getBounds();
        var rect = {
            left: nativeBounds.left,
            right: nativeBounds.right,
            top: nativeBounds.top,
            bottom: nativeBounds.bottom
        };
        nativeBounds.delete();
        return rect;
    };
    /**
     * Once subject and clip paths have been assigned (via addPath and/or addPaths), execute can then perform the clipping operation (intersection, union,
     * difference or XOR) specified by the clipType parameter.
     *
     * The solution parameter in this case is a Paths or PolyTree structure. The Paths structure is simpler than the PolyTree structure. Because of this it is
     * quicker to populate and hence clipping performance is a little better (it's roughly 10% faster). However, the PolyTree data structure provides more
     * information about the returned paths which may be important to users. Firstly, the PolyTree structure preserves nested parent-child polygon relationships
     * (ie outer polygons owning/containing holes and holes owning/containing other outer polygons etc). Also, only the PolyTree structure can differentiate
     * between open and closed paths since each PolyNode has an IsOpen property. (The Path structure has no member indicating whether it's open or closed.)
     * For this reason, when open paths are passed to a Clipper object, the user must use a PolyTree object as the solution parameter, otherwise an exception
     * will be raised.
     *
     * When a PolyTree object is used in a clipping operation on open paths, two ancilliary functions have been provided to quickly separate out open and
     * closed paths from the solution - OpenPathsFromPolyTree and ClosedPathsFromPolyTree. PolyTreeToPaths is also available to convert path data to a Paths
     * structure (irrespective of whether they're open or closed).
     *
     * There are several things to note about the solution paths returned:
     * - they aren't in any specific order
     * - they should never overlap or be self-intersecting (but see notes on rounding)
     * - holes will be oriented opposite outer polygons
     * - the solution fill type can be considered either EvenOdd or NonZero since it will comply with either filling rule
     * - polygons may rarely share a common edge (though this is now very rare as of version 6)
     *
     * The subjFillType and clipFillType parameters define the polygon fill rule to be applied to the polygons (ie closed paths) in the subject and clip
     * paths respectively. (It's usual though obviously not essential that both sets of polygons use the same fill rule.)
     *
     * execute can be called multiple times without reassigning subject and clip polygons (ie when different clipping operations are required on the
     * same polygon sets).
     *
     * @param clipType - Clip operation type
     * @param subjFillType - Fill type of the subject polygons
     * @param clipFillType - Fill type of the clip polygons
     * @param cleanDistance - Clean distance over the output, or undefined for no cleaning.
     * @return {Paths | undefined} - The solution or undefined if there was an error
     */
    Clipper.prototype.executeToPaths = function (clipType, subjFillType, clipFillType, cleanDistance) {
        var outNativePaths = new this._nativeLib.Paths();
        try {
            var success = this._clipper.executePathsWithFillTypes(nativeEnumConversion_1.clipTypeToNative(this._nativeLib, clipType), outNativePaths, nativeEnumConversion_1.polyFillTypeToNative(this._nativeLib, subjFillType), nativeEnumConversion_1.polyFillTypeToNative(this._nativeLib, clipFillType));
            if (!success) {
                return undefined;
            }
            else {
                if (cleanDistance !== undefined) {
                    this._nativeLib.cleanPolygons(outNativePaths, cleanDistance);
                }
                return PathsToNativePaths_1.nativePathsToPaths(this._nativeLib, outNativePaths, true); // frees outNativePaths
            }
        }
        finally {
            if (!outNativePaths.isDeleted()) {
                outNativePaths.delete();
            }
        }
    };
    /**
     * Once subject and clip paths have been assigned (via addPath and/or addPaths), execute can then perform the clipping operation (intersection, union,
     * difference or XOR) specified by the clipType parameter.
     *
     * The solution parameter can be either a Paths or PolyTree structure. The Paths structure is simpler than the PolyTree structure. Because of this it is
     * quicker to populate and hence clipping performance is a little better (it's roughly 10% faster). However, the PolyTree data structure provides more
     * information about the returned paths which may be important to users. Firstly, the PolyTree structure preserves nested parent-child polygon relationships
     * (ie outer polygons owning/containing holes and holes owning/containing other outer polygons etc). Also, only the PolyTree structure can differentiate
     * between open and closed paths since each PolyNode has an IsOpen property. (The Path structure has no member indicating whether it's open or closed.)
     * For this reason, when open paths are passed to a Clipper object, the user must use a PolyTree object as the solution parameter, otherwise an exception
     * will be raised.
     *
     * When a PolyTree object is used in a clipping operation on open paths, two ancilliary functions have been provided to quickly separate out open and
     * closed paths from the solution - OpenPathsFromPolyTree and ClosedPathsFromPolyTree. PolyTreeToPaths is also available to convert path data to a Paths
     * structure (irrespective of whether they're open or closed).
     *
     * There are several things to note about the solution paths returned:
     * - they aren't in any specific order
     * - they should never overlap or be self-intersecting (but see notes on rounding)
     * - holes will be oriented opposite outer polygons
     * - the solution fill type can be considered either EvenOdd or NonZero since it will comply with either filling rule
     * - polygons may rarely share a common edge (though this is now very rare as of version 6)
     *
     * The subjFillType and clipFillType parameters define the polygon fill rule to be applied to the polygons (ie closed paths) in the subject and clip
     * paths respectively. (It's usual though obviously not essential that both sets of polygons use the same fill rule.)
     *
     * execute can be called multiple times without reassigning subject and clip polygons (ie when different clipping operations are required on the
     * same polygon sets).
     *
     * @param clipType - Clip operation type
     * @param subjFillType - Fill type of the subject polygons
     * @param clipFillType - Fill type of the clip polygons
     * @return {PolyTree | undefined} - The solution or undefined if there was an error
     */
    Clipper.prototype.executeToPolyTee = function (clipType, subjFillType, clipFillType) {
        var outNativePolyTree = new this._nativeLib.PolyTree();
        try {
            var success = this._clipper.executePolyTreeWithFillTypes(nativeEnumConversion_1.clipTypeToNative(this._nativeLib, clipType), outNativePolyTree, nativeEnumConversion_1.polyFillTypeToNative(this._nativeLib, subjFillType), nativeEnumConversion_1.polyFillTypeToNative(this._nativeLib, clipFillType));
            if (!success) {
                return undefined;
            }
            else {
                return PolyTree_1.PolyTree.fromNativePolyTree(this._nativeLib, outNativePolyTree, true); // frees outNativePolyTree
            }
        }
        finally {
            if (!outNativePolyTree.isDeleted()) {
                outNativePolyTree.delete();
            }
        }
    };
    /**
     * Checks if the object has been disposed.
     *
     * @return {boolean} - true if disposed, false if not
     */
    Clipper.prototype.isDisposed = function () {
        return this._clipper === undefined || this._clipper.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).
     */
    Clipper.prototype.dispose = function () {
        if (this._clipper) {
            this._clipper.delete();
            nativeFinalizationRegistry_1.nativeFinalizationRegistry === null || nativeFinalizationRegistry_1.nativeFinalizationRegistry === void 0 ? void 0 : nativeFinalizationRegistry_1.nativeFinalizationRegistry.unregister(this);
            this._clipper = undefined;
        }
    };
    return Clipper;
}());
exports.Clipper = Clipper;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Clipper.js","sourceRoot":"","sources":["../src/Clipper.ts"],"names":[],"mappings":"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","sourcesContent":["import { ClipType, PolyFillType, PolyType } from \"./enums\";\r\nimport { IntRect } from \"./IntRect\";\r\nimport { NativeClipper } from \"./native/NativeClipper\";\r\nimport { NativeClipperLibInstance } from \"./native/NativeClipperLibInstance\";\r\nimport {\r\n  clipTypeToNative,\r\n  polyFillTypeToNative,\r\n  polyTypeToNative\r\n} from \"./native/nativeEnumConversion\";\r\nimport { nativePathsToPaths, pathsToNativePaths } from \"./native/PathsToNativePaths\";\r\nimport { pathToNativePath } from \"./native/PathToNativePath\";\r\nimport { Path, ReadonlyPath } from \"./Path\";\r\nimport { Paths, ReadonlyPaths } from \"./Paths\";\r\nimport { PolyTree } from \"./PolyTree\";\r\nimport { nativeFinalizationRegistry } from \"./nativeFinalizationRegistry\";\r\n\r\nexport interface ClipperInitOptions {\r\n  /**\r\n   * When this property is set to true, polygons returned in the solution parameter of the execute() method will have orientations opposite to their normal\r\n   * orientations.\r\n   */\r\n  reverseSolution?: boolean;\r\n\r\n  /**\r\n   * When this property is set to true, polygons returned in the solution parameter of the execute() method will have orientations opposite to their normal\r\n   * orientations.\r\n   */\r\n  strictlySimple?: boolean;\r\n\r\n  /**\r\n   * By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before\r\n   * clipping. When enabled the preserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.\r\n   */\r\n  preserveCollinear?: boolean;\r\n}\r\n\r\nexport class Clipper {\r\n  private _clipper?: NativeClipper;\r\n\r\n  /**\r\n   * By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before\r\n   * clipping. When enabled the preserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.\r\n   *\r\n   * @return {boolean} - true if set, false otherwise\r\n   */\r\n  get preserveCollinear(): boolean {\r\n    return this._clipper!.preserveCollinear;\r\n  }\r\n\r\n  /**\r\n   * By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before\r\n   * clipping. When enabled the preserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.\r\n   *\r\n   * @param value - value to set\r\n   */\r\n  set preserveCollinear(value: boolean) {\r\n    this._clipper!.preserveCollinear = value;\r\n  }\r\n\r\n  /**\r\n   * When this property is set to true, polygons returned in the solution parameter of the execute() method will have orientations opposite to their normal\r\n   * orientations.\r\n   *\r\n   * @return {boolean} - true if set, false otherwise\r\n   */\r\n  get reverseSolution(): boolean {\r\n    return this._clipper!.reverseSolution;\r\n  }\r\n\r\n  /**\r\n   * When this property is set to true, polygons returned in the solution parameter of the execute() method will have orientations opposite to their normal\r\n   * orientations.\r\n   *\r\n   * @param value - value to set\r\n   */\r\n  set reverseSolution(value: boolean) {\r\n    this._clipper!.reverseSolution = value;\r\n  }\r\n\r\n  /**\r\n   * Terminology:\r\n   * - A simple polygon is one that does not self-intersect.\r\n   * - A weakly simple polygon is a simple polygon that contains 'touching' vertices, or 'touching' edges.\r\n   * - A strictly simple polygon is a simple polygon that does not contain 'touching' vertices, or 'touching' edges.\r\n   *\r\n   * Vertices 'touch' if they share the same coordinates (and are not adjacent). An edge touches another if one of its end vertices touches another edge\r\n   * excluding its adjacent edges, or if they are co-linear and overlapping (including adjacent edges).\r\n   *\r\n   * Polygons returned by clipping operations (see Clipper.execute()) should always be simple polygons. When the StrictlySimply property is enabled,\r\n   * polygons returned will be strictly simple, otherwise they may be weakly simple. It's computationally expensive ensuring polygons are strictly simple\r\n   * and so this property is disabled by default.\r\n   *\r\n   * Note: There's currently no guarantee that polygons will be strictly simple since 'simplifying' is still a work in progress.\r\n   *\r\n   * @return {boolean} - true if set, false otherwise\r\n   */\r\n  get strictlySimple(): boolean {\r\n    return this._clipper!.strictlySimple;\r\n  }\r\n\r\n  /**\r\n   * Terminology:\r\n   * - A simple polygon is one that does not self-intersect.\r\n   * - A weakly simple polygon is a simple polygon that contains 'touching' vertices, or 'touching' edges.\r\n   * - A strictly simple polygon is a simple polygon that does not contain 'touching' vertices, or 'touching' edges.\r\n   *\r\n   * Vertices 'touch' if they share the same coordinates (and are not adjacent). An edge touches another if one of its end vertices touches another edge\r\n   * excluding its adjacent edges, or if they are co-linear and overlapping (including adjacent edges).\r\n   *\r\n   * Polygons returned by clipping operations (see Clipper.execute()) should always be simple polygons. When the StrictlySimply property is enabled,\r\n   * polygons returned will be strictly simple, otherwise they may be weakly simple. It's computationally expensive ensuring polygons are strictly simple\r\n   * and so this property is disabled by default.\r\n   *\r\n   * Note: There's currently no guarantee that polygons will be strictly simple since 'simplifying' is still a work in progress.\r\n   *\r\n   * @param value - value to set\r\n   */\r\n  set strictlySimple(value: boolean) {\r\n    this._clipper!.strictlySimple = value;\r\n  }\r\n\r\n  /**\r\n   * The Clipper constructor creates an instance of the Clipper class. One or more InitOptions may be passed as a parameter to set the corresponding properties.\r\n   * (These properties can still be set or reset after construction.)\r\n   *\r\n   * @param _nativeLib\r\n   * @param initOptions\r\n   */\r\n  constructor(\r\n    private readonly _nativeLib: NativeClipperLibInstance,\r\n    initOptions: ClipperInitOptions = {}\r\n  ) {\r\n    const realInitOptions = {\r\n      reverseSolutions: false,\r\n      strictlySimple: false,\r\n      preserveCollinear: false,\r\n      ...initOptions\r\n    };\r\n\r\n    let nativeInitOptions = 0;\r\n    if (realInitOptions.reverseSolutions) {\r\n      nativeInitOptions += _nativeLib.InitOptions.ReverseSolution.value;\r\n    }\r\n    if (realInitOptions.strictlySimple) {\r\n      nativeInitOptions += _nativeLib.InitOptions.StrictlySimple.value;\r\n    }\r\n    if (realInitOptions.preserveCollinear) {\r\n      nativeInitOptions += _nativeLib.InitOptions.PreserveCollinear.value;\r\n    }\r\n\r\n    this._clipper = new _nativeLib.Clipper(nativeInitOptions);\r\n    nativeFinalizationRegistry?.register(this, this._clipper, this);\r\n  }\r\n\r\n  /**\r\n   * Any number of subject and clip paths can be added to a clipping task, either individually via the addPath() method, or as groups via the addPaths()\r\n   * method, or even using both methods.\r\n   *\r\n   * 'Subject' paths may be either open (lines) or closed (polygons) or even a mixture of both, but 'clipping' paths must always be closed. Clipper allows\r\n   * polygons to clip both lines and other polygons, but doesn't allow lines to clip either lines or polygons.\r\n   *\r\n   * With closed paths, orientation should conform with the filling rule that will be passed via Clipper's execute method.\r\n   *\r\n   * Path Coordinate range:\r\n   * Path coordinates must be between ± 9007199254740991, otherwise a range error will be thrown when attempting to add the path to the Clipper object.\r\n   * If coordinates can be kept between ± 0x3FFFFFFF (± 1.0e+9), a modest increase in performance (approx. 15-20%) over the larger range can be achieved by\r\n   * avoiding large integer math.\r\n   *\r\n   * Return Value:\r\n   * The function will return false if the path is invalid for clipping. A path is invalid for clipping when:\r\n   * - it has less than 2 vertices\r\n   * - it has 2 vertices but is not an open path\r\n   * - the vertices are all co-linear and it is not an open path\r\n   *\r\n   * @param path - Path to add\r\n   * @param polyType - Polygon type\r\n   * @param closed - If the path is closed\r\n   */\r\n  addPath(path: ReadonlyPath, polyType: PolyType, closed: boolean): boolean {\r\n    const nativePath = pathToNativePath(this._nativeLib, path);\r\n    try {\r\n      return this._clipper!.addPath(\r\n        nativePath,\r\n        polyTypeToNative(this._nativeLib, polyType),\r\n        closed\r\n      );\r\n    } finally {\r\n      nativePath.delete();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Any number of subject and clip paths can be added to a clipping task, either individually via the addPath() method, or as groups via the addPaths()\r\n   * method, or even using both methods.\r\n   *\r\n   * 'Subject' paths may be either open (lines) or closed (polygons) or even a mixture of both, but 'clipping' paths must always be closed. Clipper allows\r\n   * polygons to clip both lines and other polygons, but doesn't allow lines to clip either lines or polygons.\r\n   *\r\n   * With closed paths, orientation should conform with the filling rule that will be passed via Clipper's execute method.\r\n   *\r\n   * Path Coordinate range:\r\n   * Path coordinates must be between ± 9007199254740991, otherwise a range error will be thrown when attempting to add the path to the Clipper object.\r\n   * If coordinates can be kept between ± 0x3FFFFFFF (± 1.0e+9), a modest increase in performance (approx. 15-20%) over the larger range can be achieved\r\n   * by avoiding large integer math.\r\n   *\r\n   * Return Value:\r\n   * The function will return false if the path is invalid for clipping. A path is invalid for clipping when:\r\n   * - it has less than 2 vertices\r\n   * - it has 2 vertices but is not an open path\r\n   * - the vertices are all co-linear and it is not an open path\r\n   *\r\n   * @param paths - Paths to add\r\n   * @param polyType - Paths polygon type\r\n   * @param closed - If all the inner paths are closed\r\n   */\r\n  addPaths(paths: ReadonlyPaths, polyType: PolyType, closed: boolean): boolean {\r\n    const nativePaths = pathsToNativePaths(this._nativeLib, paths);\r\n    try {\r\n      return this._clipper!.addPaths(\r\n        nativePaths,\r\n        polyTypeToNative(this._nativeLib, polyType),\r\n        closed\r\n      );\r\n    } finally {\r\n      nativePaths.delete();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * The Clear method removes any existing subject and clip polygons allowing the Clipper object to be reused for clipping operations on different polygon sets.\r\n   */\r\n  clear(): void {\r\n    this._clipper!.clear();\r\n  }\r\n\r\n  /**\r\n   * This method returns the axis-aligned bounding rectangle of all polygons that have been added to the Clipper object.\r\n   *\r\n   * @return {{left: number, right: number, top: number, bottom: number}} - Bounds\r\n   */\r\n  getBounds(): IntRect {\r\n    const nativeBounds = this._clipper!.getBounds();\r\n    const rect = {\r\n      left: nativeBounds.left,\r\n      right: nativeBounds.right,\r\n      top: nativeBounds.top,\r\n      bottom: nativeBounds.bottom\r\n    };\r\n    nativeBounds.delete();\r\n    return rect;\r\n  }\r\n\r\n  /**\r\n   * Once subject and clip paths have been assigned (via addPath and/or addPaths), execute can then perform the clipping operation (intersection, union,\r\n   * difference or XOR) specified by the clipType parameter.\r\n   *\r\n   * The solution parameter in this case is a Paths or PolyTree structure. The Paths structure is simpler than the PolyTree structure. Because of this it is\r\n   * quicker to populate and hence clipping performance is a little better (it's roughly 10% faster). However, the PolyTree data structure provides more\r\n   * information about the returned paths which may be important to users. Firstly, the PolyTree structure preserves nested parent-child polygon relationships\r\n   * (ie outer polygons owning/containing holes and holes owning/containing other outer polygons etc). Also, only the PolyTree structure can differentiate\r\n   * between open and closed paths since each PolyNode has an IsOpen property. (The Path structure has no member indicating whether it's open or closed.)\r\n   * For this reason, when open paths are passed to a Clipper object, the user must use a PolyTree object as the solution parameter, otherwise an exception\r\n   * will be raised.\r\n   *\r\n   * When a PolyTree object is used in a clipping operation on open paths, two ancilliary functions have been provided to quickly separate out open and\r\n   * closed paths from the solution - OpenPathsFromPolyTree and ClosedPathsFromPolyTree. PolyTreeToPaths is also available to convert path data to a Paths\r\n   * structure (irrespective of whether they're open or closed).\r\n   *\r\n   * There are several things to note about the solution paths returned:\r\n   * - they aren't in any specific order\r\n   * - they should never overlap or be self-intersecting (but see notes on rounding)\r\n   * - holes will be oriented opposite outer polygons\r\n   * - the solution fill type can be considered either EvenOdd or NonZero since it will comply with either filling rule\r\n   * - polygons may rarely share a common edge (though this is now very rare as of version 6)\r\n   *\r\n   * The subjFillType and clipFillType parameters define the polygon fill rule to be applied to the polygons (ie closed paths) in the subject and clip\r\n   * paths respectively. (It's usual though obviously not essential that both sets of polygons use the same fill rule.)\r\n   *\r\n   * execute can be called multiple times without reassigning subject and clip polygons (ie when different clipping operations are required on the\r\n   * same polygon sets).\r\n   *\r\n   * @param clipType - Clip operation type\r\n   * @param subjFillType - Fill type of the subject polygons\r\n   * @param clipFillType - Fill type of the clip polygons\r\n   * @param cleanDistance - Clean distance over the output, or undefined for no cleaning.\r\n   * @return {Paths | undefined} - The solution or undefined if there was an error\r\n   */\r\n  executeToPaths(\r\n    clipType: ClipType,\r\n    subjFillType: PolyFillType,\r\n    clipFillType: PolyFillType,\r\n    cleanDistance: number | undefined\r\n  ): Paths | undefined {\r\n    const outNativePaths = new this._nativeLib.Paths();\r\n    try {\r\n      const success = this._clipper!.executePathsWithFillTypes(\r\n        clipTypeToNative(this._nativeLib, clipType),\r\n        outNativePaths,\r\n        polyFillTypeToNative(this._nativeLib, subjFillType),\r\n        polyFillTypeToNative(this._nativeLib, clipFillType)\r\n      );\r\n      if (!success) {\r\n        return undefined;\r\n      } else {\r\n        if (cleanDistance !== undefined) {\r\n          this._nativeLib.cleanPolygons(outNativePaths, cleanDistance);\r\n        }\r\n        return nativePathsToPaths(this._nativeLib, outNativePaths, true); // frees outNativePaths\r\n      }\r\n    } finally {\r\n      if (!outNativePaths.isDeleted()) {\r\n        outNativePaths.delete();\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Once subject and clip paths have been assigned (via addPath and/or addPaths), execute can then perform the clipping operation (intersection, union,\r\n   * difference or XOR) specified by the clipType parameter.\r\n   *\r\n   * The solution parameter can be either a Paths or PolyTree structure. The Paths structure is simpler than the PolyTree structure. Because of this it is\r\n   * quicker to populate and hence clipping performance is a little better (it's roughly 10% faster). However, the PolyTree data structure provides more\r\n   * information about the returned paths which may be important to users. Firstly, the PolyTree structure preserves nested parent-child polygon relationships\r\n   * (ie outer polygons owning/containing holes and holes owning/containing other outer polygons etc). Also, only the PolyTree structure can differentiate\r\n   * between open and closed paths since each PolyNode has an IsOpen property. (The Path structure has no member indicating whether it's open or closed.)\r\n   * For this reason, when open paths are passed to a Clipper object, the user must use a PolyTree object as the solution parameter, otherwise an exception\r\n   * will be raised.\r\n   *\r\n   * When a PolyTree object is used in a clipping operation on open paths, two ancilliary functions have been provided to quickly separate out open and\r\n   * closed paths from the solution - OpenPathsFromPolyTree and ClosedPathsFromPolyTree. PolyTreeToPaths is also available to convert path data to a Paths\r\n   * structure (irrespective of whether they're open or closed).\r\n   *\r\n   * There are several things to note about the solution paths returned:\r\n   * - they aren't in any specific order\r\n   * - they should never overlap or be self-intersecting (but see notes on rounding)\r\n   * - holes will be oriented opposite outer polygons\r\n   * - the solution fill type can be considered either EvenOdd or NonZero since it will comply with either filling rule\r\n   * - polygons may rarely share a common edge (though this is now very rare as of version 6)\r\n   *\r\n   * The subjFillType and clipFillType parameters define the polygon fill rule to be applied to the polygons (ie closed paths) in the subject and clip\r\n   * paths respectively. (It's usual though obviously not essential that both sets of polygons use the same fill rule.)\r\n   *\r\n   * execute can be called multiple