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 = (0, PathToNativePath_1.pathToNativePath)(this._nativeLib, path);
        try {
            return this._clipper.addPath(nativePath, (0, 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 = (0, PathsToNativePaths_1.pathsToNativePaths)(this._nativeLib, paths);
        try {
            return this._clipper.addPaths(nativePaths, (0, 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((0, nativeEnumConversion_1.clipTypeToNative)(this._nativeLib, clipType), outNativePaths, (0, nativeEnumConversion_1.polyFillTypeToNative)(this._nativeLib, subjFillType), (0, nativeEnumConversion_1.polyFillTypeToNative)(this._nativeLib, clipFillType));
            if (!success) {
                return undefined;
            }
            else {
                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();
            }
        }
    };
    /**
     * 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((0, nativeEnumConversion_1.clipTypeToNative)(this._nativeLib, clipType), outNativePolyTree, (0, nativeEnumConversion_1.polyFillTypeToNative)(this._nativeLib, subjFillType), (0, 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":["/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport { ClipType, PolyFillType, PolyType } from \"./enums\";\nimport { IntRect } from \"./IntRect\";\nimport { NativeClipper } from \"./native/NativeClipper\";\nimport { NativeClipperLibInstance } from \"./native/NativeClipperLibInstance\";\nimport {\n  clipTypeToNative,\n  polyFillTypeToNative,\n  polyTypeToNative,\n} 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\nexport interface ClipperInitOptions {\n  /**\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\n   * orientations.\n   */\n  reverseSolution?: boolean;\n\n  /**\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\n   * orientations.\n   */\n  strictlySimple?: boolean;\n\n  /**\n   * By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before\n   * clipping. When enabled the preserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.\n   */\n  preserveCollinear?: boolean;\n}\n\nexport class Clipper {\n  private _clipper?: NativeClipper;\n\n  /**\n   * By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before\n   * clipping. When enabled the preserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.\n   *\n   * @return {boolean} - true if set, false otherwise\n   */\n  get preserveCollinear(): boolean {\n    return this._clipper!.preserveCollinear;\n  }\n\n  /**\n   * By default, when three or more vertices are collinear in input polygons (subject or clip), the Clipper object removes the 'inner' vertices before\n   * clipping. When enabled the preserveCollinear property prevents this default behavior to allow these inner vertices to appear in the solution.\n   *\n   * @param value - value to set\n   */\n  set preserveCollinear(value: boolean) {\n    this._clipper!.preserveCollinear = value;\n  }\n\n  /**\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\n   * orientations.\n   *\n   * @return {boolean} - true if set, false otherwise\n   */\n  get reverseSolution(): boolean {\n    return this._clipper!.reverseSolution;\n  }\n\n  /**\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\n   * orientations.\n   *\n   * @param value - value to set\n   */\n  set reverseSolution(value: boolean) {\n    this._clipper!.reverseSolution = value;\n  }\n\n  /**\n   * Terminology:\n   * - A simple polygon is one that does not self-intersect.\n   * - A weakly simple polygon is a simple polygon that contains 'touching' vertices, or 'touching' edges.\n   * - A strictly simple polygon is a simple polygon that does not contain 'touching' vertices, or 'touching' edges.\n   *\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\n   * excluding its adjacent edges, or if they are co-linear and overlapping (including adjacent edges).\n   *\n   * Polygons returned by clipping operations (see Clipper.execute()) should always be simple polygons. When the StrictlySimply property is enabled,\n   * polygons returned will be strictly simple, otherwise they may be weakly simple. It's computationally expensive ensuring polygons are strictly simple\n   * and so this property is disabled by default.\n   *\n   * Note: There's currently no guarantee that polygons will be strictly simple since 'simplifying' is still a work in progress.\n   *\n   * @return {boolean} - true if set, false otherwise\n   */\n  get strictlySimple(): boolean {\n    return this._clipper!.strictlySimple;\n  }\n\n  /**\n   * Terminology:\n   * - A simple polygon is one that does not self-intersect.\n   * - A weakly simple polygon is a simple polygon that contains 'touching' vertices, or 'touching' edges.\n   * - A strictly simple polygon is a simple polygon that does not contain 'touching' vertices, or 'touching' edges.\n   *\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\n   * excluding its adjacent edges, or if they are co-linear and overlapping (including adjacent edges).\n   *\n   * Polygons returned by clipping operations (see Clipper.execute()) should always be simple polygons. When the StrictlySimply property is enabled,\n   * polygons returned will be strictly simple, otherwise they may be weakly simple. It's computationally expensive ensuring polygons are strictly simple\n   * and so this property is disabled by default.\n   *\n   * Note: There's currently no guarantee that polygons will be strictly simple since 'simplifying' is still a work in progress.\n   *\n   * @param value - value to set\n   */\n  set strictlySimple(value: boolean) {\n    this._clipper!.strictlySimple = value;\n  }\n\n  /**\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.\n   * (These properties can still be set or reset after construction.)\n   *\n   * @param _nativeLib\n   * @param initOptions\n   */\n  constructor(\n    private readonly _nativeLib: NativeClipperLibInstance,\n    initOptions: ClipperInitOptions = {}\n  ) {\n    const realInitOptions = {\n      reverseSolutions: false,\n      strictlySimple: false,\n      preserveCollinear: false,\n      ...initOptions,\n    };\n\n    let nativeInitOptions = 0;\n    if (realInitOptions.reverseSolutions) {\n      nativeInitOptions += _nativeLib.InitOptions.ReverseSolution.value;\n    }\n    if (realInitOptions.strictlySimple) {\n      nativeInitOptions += _nativeLib.InitOptions.StrictlySimple.value;\n    }\n    if (realInitOptions.preserveCollinear) {\n      nativeInitOptions += _nativeLib.InitOptions.PreserveCollinear.value;\n    }\n\n    this._clipper = new _nativeLib.Clipper(nativeInitOptions);\n    nativeFinalizationRegistry?.register(this, this._clipper, this);\n  }\n\n  /**\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()\n   * method, or even using both methods.\n   *\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\n   * polygons to clip both lines and other polygons, but doesn't allow lines to clip either lines or polygons.\n   *\n   * With closed paths, orientation should conform with the filling rule that will be passed via Clipper's execute method.\n   *\n   * Path Coordinate range:\n   * Path coordinates must be between ± 9007199254740991, otherwise a range error will be thrown when attempting to add the path to the Clipper object.\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\n   * avoiding large integer math.\n   *\n   * Return Value:\n   * The function will return false if the path is invalid for clipping. A path is invalid for clipping when:\n   * - it has less than 2 vertices\n   * - it has 2 vertices but is not an open path\n   * - the vertices are all co-linear and it is not an open path\n   *\n   * @param path - Path to add\n   * @param polyType - Polygon type\n   * @param closed - If the path is closed\n   */\n  addPath(path: ReadonlyPath, polyType: PolyType, closed: boolean): boolean {\n    const nativePath = pathToNativePath(this._nativeLib, path);\n    try {\n      return this._clipper!.addPath(\n        nativePath,\n        polyTypeToNative(this._nativeLib, polyType),\n        closed\n      );\n    } finally {\n      nativePath.delete();\n    }\n  }\n\n  /**\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()\n   * method, or even using both methods.\n   *\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\n   * polygons to clip both lines and other polygons, but doesn't allow lines to clip either lines or polygons.\n   *\n   * With closed paths, orientation should conform with the filling rule that will be passed via Clipper's execute method.\n   *\n   * Path Coordinate range:\n   * Path coordinates must be between ± 9007199254740991, otherwise a range error will be thrown when attempting to add the path to the Clipper object.\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\n   * by avoiding large integer math.\n   *\n   * Return Value:\n   * The function will return false if the path is invalid for clipping. A path is invalid for clipping when:\n   * - it has less than 2 vertices\n   * - it has 2 vertices but is not an open path\n   * - the vertices are all co-linear and it is not an open path\n   *\n   * @param paths - Paths to add\n   * @param polyType - Paths polygon type\n   * @param closed - If all the inner paths are closed\n   */\n  addPaths(paths: ReadonlyPaths, polyType: PolyType, closed: boolean): boolean {\n    const nativePaths = pathsToNativePaths(this._nativeLib, paths);\n    try {\n      return this._clipper!.addPaths(\n        nativePaths,\n        polyTypeToNative(this._nativeLib, polyType),\n        closed\n      );\n    } finally {\n      nativePaths.delete();\n    }\n  }\n\n  /**\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.\n   */\n  clear(): void {\n    this._clipper!.clear();\n  }\n\n  /**\n   * This method returns the axis-aligned bounding rectangle of all polygons that have been added to the Clipper object.\n   *\n   * @return {{left: number, right: number, top: number, bottom: number}} - Bounds\n   */\n  getBounds(): IntRect {\n    const nativeBounds = this._clipper!.getBounds();\n    const rect = {\n      left: nativeBounds.left,\n      right: nativeBounds.right,\n      top: nativeBounds.top,\n      bottom: nativeBounds.bottom,\n    };\n    nativeBounds.delete();\n    return rect;\n  }\n\n  /**\n   * Once subject and clip paths have been assigned (via addPath and/or addPaths), execute can then perform the clipping operation (intersection, union,\n   * difference or XOR) specified by the clipType parameter.\n   *\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\n   * quicker to populate and hence clipping performance is a little better (it's roughly 10% faster). However, the PolyTree data structure provides more\n   * information about the returned paths which may be important to users. Firstly, the PolyTree structure preserves nested parent-child polygon relationships\n   * (ie outer polygons owning/containing holes and holes owning/containing other outer polygons etc). Also, only the PolyTree structure can differentiate\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.)\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\n   * will be raised.\n   *\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\n   * closed paths from the solution - OpenPathsFromPolyTree and ClosedPathsFromPolyTree. PolyTreeToPaths is also available to convert path data to a Paths\n   * structure (irrespective of whether they're open or closed).\n   *\n   * There are several things to note about the solution paths returned:\n   * - they aren't in any specific order\n   * - they should never overlap or be self-intersecting (but see notes on rounding)\n   * - holes will be oriented opposite outer polygons\n   * - the solution fill type can be considered either EvenOdd or NonZero since it will comply with either filling rule\n   * - polygons may rarely share a common edge (though this is now very rare as of version 6)\n   *\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\n   * paths respectively. (It's usual though obviously not essential that both sets of polygons use the same fill rule.)\n   *\n   * execute can be called multiple times without reassigning subject and clip polygons (ie when different clipping operations are required on the\n   * same polygon sets).\n   *\n   * @param clipType - Clip operation type\n   * @param subjFillType - Fill type of the subject polygons\n   * @param clipFillType - Fill type of the clip polygons\n   * @param cleanDistance - Clean distance over the output, or undefined for no cleaning.\n   * @return {Paths | undefined} - The solution or undefined if there was an error\n   */\n  executeToPaths(\n    clipType: ClipType,\n    subjFillType: PolyFillType,\n    clipFillType: PolyFillType,\n    cleanDistance: number | undefined\n  ): Paths | undefined {\n    const outNativePaths = new this._nativeLib.Paths();\n    try {\n      const success = this._clipper!.executePathsWithFillTypes(\n        clipTypeToNative(this._nativeLib, clipType),\n        outNativePaths,\n        polyFillTypeToNative(this._nativeLib, subjFillType),\n        polyFillTypeToNative(this._nativeLib, clipFillType)\n      );\n      if (!success) {\n        return undefined;\n      } else {\n        if (cleanDistance !== undefined) {\n          this._nativeLib.cleanPolygons(outNativePaths, cleanDistance);\n        }\n        return nativePathsToPaths(this._nativeLib, outNativePaths, true); // frees outNativePaths\n      }\n    } finally {\n      if (!outNativePaths.isDeleted()) {\n        outNativePaths.delete();\n      }\n    }\n  }\n\n  /**\n   * Once subject and clip paths have been assigned (via addPath and/or addPaths), execute can then perform the clipping operation (intersection, union,\n   * difference or XOR) specified by the clipType parameter.\n   *\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\n   * quicker to populate and hence clipping performance is a little better (it's roughly 10% faster). However, the PolyTree data structure provides more\n   * information about the returned paths which may be important to users. Firstly, the PolyTree structure preserves nested parent-child polygon relationships\n   * (ie outer polygons owning/containing holes and holes owning/containing other outer polygons etc). Also, only the PolyTree structure can differentiate\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.)\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\n   * will be raised.\n   *\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\n   * closed paths from the solution - OpenPathsFromPolyTree and ClosedPathsFromPolyTree. PolyTreeToPaths is also available to convert path data to a Paths\n   * structure (irrespective of whether they're open or closed).\n   *\n   * There are several things to note about the solution paths returned:\n   * - they aren't in any specific order\n   * - they should never overlap or be self-intersecting (but see notes on rounding)\n   * - holes will be oriented opposite outer polygons\n   * - the solution fill type can be considered either EvenOdd or NonZero since it will comply with either filling rule\n   * - polygons may rarely share a common edge (though this is now very rare as of version 6)\n   *\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\n   * paths respectively. (It's usual though obviously not essential that both sets of polygons use the same fill rule.)\n   *\n   * execute can be called multiple times without reassigning subject and clip polygons (ie when different clipping operations are required on the\n   * same polygon sets).\n   *\n   * @param clipType - Clip operation type\n   * @param subjFillType - Fill type of the subject polygons\n   * @param clipFillType - Fill type of the clip polygons\n   * @return {PolyTree | undefined} - The solution or undefined if there was an error\n   */\n  executeToPolyTee(\n    clipType: ClipType,\n    subjFillType: PolyFillType,\n    clipFillType: PolyFillType\n  ): PolyTree | undefined {\n    const outNativePolyTree = new this._nativeLib.PolyTree();\n    try {\n      const success = this._clipper!.executePolyTreeWithFillTypes(\n        clipTypeToNative(this._nativeLib, clipType),\n        outNativePolyTree,\n        po