@matboks/utilities 0.0.1

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const EPS = 1e-9;

package/dist/constants.js

@@ -0,0 +1 @@
+export const EPS = 1e-9;

package/dist/geometry/aabb.d.ts

@@ -0,0 +1,40 @@
+import { Line } from "./line.js";
+import { Polygon } from "./polygon.js";
+import { Vec2 } from "./vec2.js";
+export declare class AABB {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+    constructor(xMin: number, xMax: number, yMin: number, yMax: number);
+    get width(): number;
+    get height(): number;
+    get center(): Vec2;
+    get diagonal(): number;
+    get size(): Vec2;
+    get halfSize(): Vec2;
+    get aspectRatio(): number;
+    get area(): number;
+    translate(translation: Vec2): this;
+    static fromVertices(vertices: Vec2[]): AABB;
+    static fromPoint({ x, y }: Vec2): AABB;
+    static fromCenterSize(center: Vec2, size: Vec2): AABB;
+    static placeholder(): AABB;
+    clone(): AABB;
+    signedDistanceTo(position: Vec2): number;
+    contains(other: AABB): boolean;
+    isOverlapping(other: AABB): boolean;
+    isInside(other: AABB): boolean;
+    intersectsLine(line: Line): boolean;
+    grow(amount: number): AABB;
+    grow(amount: Vec2): AABB;
+    grow(xMin: number, xMax: number, yMin: number, yMax: number): AABB;
+    combine(other: AABB): this;
+    update(position: Vec2): this;
+    isPointInside({ x, y }: Vec2): boolean;
+    setBounds(xMin: number, xMax: number, yMin: number, yMax: number): this;
+    mapToUV(p: Vec2): Vec2;
+    mapFromUV(p: Vec2): Vec2;
+    toPolygon(): Polygon;
+    toString(): string;
+}

package/dist/geometry/aabb.js

@@ -0,0 +1,143 @@
+import { EPS } from "../constants.js";
+import { Polygon } from "./polygon.js";
+import { vec2, Vec2 } from "./vec2.js";
+const { min, max } = Math;
+export class AABB {
+    constructor(xMin, xMax, yMin, yMax) {
+        this.xMin = xMin;
+        this.xMax = xMax;
+        this.yMin = yMin;
+        this.yMax = yMax;
+    }
+    get width() { return this.xMax - this.xMin; }
+    get height() { return this.yMax - this.yMin; }
+    get center() { return vec2((this.xMin + this.xMax) / 2, (this.yMin + this.yMax) / 2); }
+    get diagonal() { return this.size.length(); }
+    get size() { return vec2((this.xMax - this.xMin), (this.yMax - this.yMin)); }
+    get halfSize() { return Vec2.multiply(this.size, 0.5); }
+    get aspectRatio() { return (this.xMax - this.xMin) / (this.yMax - this.yMin); }
+    get area() { return (this.xMax - this.xMin) * (this.yMax - this.yMin); }
+    translate(translation) {
+        const { x, y } = translation;
+        const { xMin, xMax, yMin, yMax } = this;
+        return this.setBounds(xMin + x, xMax + x, yMin + y, yMax + y);
+    }
+    static fromVertices(vertices) {
+        let { xMin, xMax, yMin, yMax } = AABB.placeholder();
+        for (let i = 0; i < vertices.length; i++) {
+            const { x, y } = vertices[i];
+            if (x < xMin)
+                xMin = x;
+            if (x > xMax)
+                xMax = x;
+            if (y < yMin)
+                yMin = y;
+            if (y > yMax)
+                yMax = y;
+        }
+        return new AABB(xMin, xMax, yMin, yMax);
+    }
+    static fromPoint({ x, y }) {
+        return new AABB(x, x, y, y);
+    }
+    static fromCenterSize(center, size) {
+        return new AABB(center.x - size.x / 2, center.x + size.x / 2, center.y - size.y / 2, center.y + size.y / 2);
+    }
+    static placeholder() {
+        return new AABB(Infinity, -Infinity, Infinity, -Infinity);
+    }
+    clone() {
+        return new AABB(this.xMin, this.xMax, this.yMin, this.yMax);
+    }
+    signedDistanceTo(position) {
+        // Fix AABB
+        const difference = Vec2.subtract(position, this.center).absolute().minus(this.halfSize);
+        if (difference.x < 0 && difference.y < 0) {
+            return max(difference.x, difference.y);
+        }
+        else if (difference.x > 0 && difference.y > 0) {
+            return difference.length();
+        }
+        else {
+            return max(difference.x, difference.y);
+        }
+    }
+    contains(other) {
+        return this.xMin < other.xMin + EPS && this.xMax > other.xMax - EPS && this.yMin < other.yMin + EPS && this.yMax > other.yMax - EPS;
+    }
+    isOverlapping(other) {
+        return !(this.xMax < other.xMin || this.xMin > other.xMax || this.yMax < other.yMin || this.yMin > other.yMax);
+    }
+    isInside(other) {
+        return this.xMin >= other.xMin && this.xMax <= other.xMax && this.yMin >= other.yMin && this.yMax <= other.yMax;
+    }
+    // Checks if all 4 corners of AABB are on the same side of line
+    intersectsLine(line) {
+        const { point, direction } = line;
+        const polygon = this.toPolygon();
+        let sum = 0;
+        for (const vertex of polygon.vertices) {
+            sum += Math.sign(Vec2.subtract(vertex, point).cross(direction));
+        }
+        return Math.abs(sum) !== 4;
+    }
+    grow(...args) {
+        const { xMin, xMax, yMin, yMax, width, height } = this;
+        if (args.length === 1) {
+            let amount = args[0];
+            amount = typeof amount === "number" ? vec2(amount) : amount;
+            amount = vec2(max(amount.x, -width / 2), max(amount.y, -height / 2));
+            return this.setBounds(xMin - amount.x, xMax + amount.x, yMin - amount.y, yMax + amount.y);
+        }
+        else {
+            const [dxMin, dxMax, dyMin, dyMax] = args;
+            let newXMin = xMin + dxMin;
+            let newXMax = xMax + dxMax;
+            let newYMin = yMin + dyMin;
+            let newYMax = yMax + dyMax;
+            if (newXMin > newXMax)
+                newXMin = newXMax = 0.5 * (newXMin + newXMax);
+            if (newYMin > newYMax)
+                newYMin = newYMax = 0.5 * (newYMin + newYMax);
+            return this.setBounds(newXMin, newXMax, newYMin, newYMax);
+        }
+    }
+    combine(other) {
+        return this.setBounds(min(this.xMin, other.xMin), max(this.xMax, other.xMax), min(this.yMin, other.yMin), max(this.yMax, other.yMax));
+    }
+    update(position) {
+        return this.setBounds(min(this.xMin, position.x), max(this.xMax, position.x), min(this.yMin, position.y), max(this.yMax, position.y));
+    }
+    isPointInside({ x, y }) {
+        const { xMin, xMax, yMin, yMax } = this;
+        return x >= xMin - EPS && x <= xMax + EPS && y >= yMin - EPS && y <= yMax + EPS;
+    }
+    setBounds(xMin, xMax, yMin, yMax) {
+        this.xMin = xMin;
+        this.xMax = xMax;
+        this.yMin = yMin;
+        this.yMax = yMax;
+        return this;
+    }
+    mapToUV(p) {
+        const { xMin, yMin, width, height } = this;
+        return p.clone().minus(vec2(xMin, yMin)).times(vec2(1 / width, 1 / height));
+    }
+    mapFromUV(p) {
+        const { xMin, yMin, width, height } = this;
+        return p.clone().times(vec2(width, height)).plus(vec2(xMin, yMin));
+    }
+    toPolygon() {
+        const { xMin, xMax, yMin, yMax } = this;
+        return new Polygon([
+            vec2(xMin, yMin),
+            vec2(xMax, yMin),
+            vec2(xMax, yMax),
+            vec2(xMin, yMax)
+        ]);
+    }
+    toString() {
+        const { xMin, xMax, yMin, yMax } = this;
+        return `AABB(xMin=${xMin}, xMax=${xMax}, yMin=${yMin}, yMax=${yMax})`;
+    }
+}

package/dist/geometry/cut-polygon.d.ts

@@ -0,0 +1,7 @@
+import { Line } from "./line.js";
+import { Polygon } from "./polygon.js";
+import { Ray } from "./ray.js";
+import { Segment } from "./segment.js";
+type CutObject = Line | Segment | Ray;
+export declare function cutPolygon(polygons: Polygon | Array<Polygon>, cutObject: CutObject | ((polygon: Polygon) => CutObject)): Polygon[];
+export {};

package/dist/geometry/cut-polygon.js

@@ -0,0 +1,116 @@
+import { EPS } from "../constants.js";
+import { mod } from "../math/mod.js";
+import { Line } from "./line.js";
+import { Polygon } from "./polygon.js";
+import { Ray } from "./ray.js";
+import { Segment } from "./segment.js";
+import { computeLineIntersection } from "./shared.js";
+// TODO add AABB check
+export function cutPolygon(polygons, cutObject) {
+    polygons = Array.isArray(polygons) ? polygons : [polygons];
+    let cutPolygons = [];
+    for (const polygon of polygons) {
+        const polygonCutObject = typeof cutObject === "function" ? cutObject(polygon) : cutObject;
+        cutSinglePolygonHelper(polygon, polygonCutObject, cutPolygons);
+    }
+    return cutPolygons;
+}
+function cutSinglePolygonHelper(polygon, cutObject, allPolygons) {
+    const cutLine = cutObject instanceof Segment ? new Line(cutObject.start, cutObject.vector) :
+        cutObject instanceof Ray ? new Line(cutObject.point, cutObject.direction) :
+            cutObject;
+    // if (!polygon.aabb().intersectsLine(cutLine)) {
+    //   allPolygons.push(polygon);
+    //   return;
+    // }
+    let intersections = [];
+    for (let i = 0, n = polygon.numVertices(); i < n; i++) {
+        const edge = polygon.getEdge(i);
+        const intersection = computeLineIntersection(cutLine, new Line(edge.start, edge.vector));
+        if (!intersection)
+            continue;
+        const [lineTime, edgeTime] = intersection;
+        if (edgeTime < -EPS || edgeTime > 1 + EPS)
+            continue;
+        const position = edge.interpolate(edgeTime);
+        intersections.push({ index: i, position, lineTime, edgeTime });
+    }
+    if (cutObject instanceof Ray) { // Ray: ensure only intersections
+        intersections = intersections.filter((int) => {
+            return int.lineTime >= 0;
+        });
+    }
+    else if (cutObject instanceof Segment) {
+        intersections = intersections.filter((int) => {
+            const { lineTime } = int;
+            return lineTime >= 0 && lineTime <= 1;
+        });
+    }
+    intersections.sort((a, b) => a.lineTime - b.lineTime);
+    // If cut object is not a line and the start point is inside the polygon,
+    // the first intersection is invalid
+    if (!(cutObject instanceof Line) && polygon.isPointInside(cutLine.point)) {
+        intersections.shift();
+    }
+    intersections = intersections.filter((int, i) => {
+        if (i === intersections.length - 1)
+            return true;
+        const nextIntersection = intersections[i + 1];
+        const timeDifference = nextIntersection.lineTime - int.lineTime;
+        if (timeDifference > EPS)
+            return true;
+        return Math.abs(nextIntersection.index - int.index) <= 1;
+    });
+    const vertices = polygon.vertices;
+    for (let i = 0; i < vertices.length; i++) {
+        vertices[i]._originalIndex = i;
+    }
+    const result = intersectionHelper(vertices, 0, intersections);
+    for (const vertices of result) {
+        allPolygons.push(new Polygon(vertices.map((vertex) => vertex.clone())));
+    }
+}
+// TODO consider rewriting function to be non-recursive
+function intersectionHelper(vertices, intersectionIndex, intersections) {
+    const activeIntersections = [];
+    // We are at the end of the intersection array, simply return shape
+    if (intersectionIndex >= intersections.length - 1)
+        return [vertices];
+    // Find the next two intersections that happen along the vertices
+    while (activeIntersections.length < 2 && intersectionIndex < intersections.length) {
+        const candidate = intersections[intersectionIndex];
+        const index = vertices.findIndex((data) => data._originalIndex === candidate.index);
+        if (index !== -1)
+            activeIntersections.push({ index, intersection: candidate });
+        intersectionIndex++;
+    }
+    const [intersectionData1, intersectionData2] = activeIntersections;
+    if (!(intersectionData1 && intersectionData2))
+        return [vertices];
+    // Split vertices into two sets, based on which sides of the cut line they lie
+    const { vertices1, vertices2 } = splitVertices(vertices, intersectionData1.index, intersectionData2.index);
+    const { position: position1, edgeTime: edgeTime1 } = intersectionData1.intersection;
+    const { position: position2, edgeTime: edgeTime2 } = intersectionData2.intersection;
+    const newVertices1 = (edgeTime1 < (1 - EPS) ? [position1] : []) // If false, position1 coindices with the first vertex in vertices1
+        .concat(vertices1)
+        .concat(edgeTime2 > EPS ? [position2] : []); // If false, position2 coindices with the last vertex in vertices1
+    const newVertices2 = (edgeTime2 < (1 - EPS) ? [position2] : []) // If false, position2 coindices with the first vertex in vertices2
+        .concat(vertices2)
+        .concat(edgeTime1 > EPS ? [position1] : []); // If false, position1 coindices with the last vertex in vertices2
+    const result1 = newVertices1.length > 2 ? intersectionHelper(newVertices1, intersectionIndex, intersections) : [];
+    const result2 = newVertices2.length > 2 ? intersectionHelper(newVertices2, intersectionIndex, intersections) : [];
+    return result1.concat(result2);
+}
+function splitVertices(vertices, startIndex, endIndex) {
+    const numVertices = vertices.length;
+    let vertices1 = [];
+    let vertices2 = [];
+    const diff = startIndex < endIndex ? endIndex - startIndex : (numVertices - (startIndex - endIndex));
+    for (let i = 0; i < diff; i++) {
+        vertices1.push(vertices[mod(startIndex + 1 + i, numVertices)]);
+    }
+    for (let i = 0, n = numVertices - diff; i < n; i++) {
+        vertices2.push(vertices[mod(endIndex + 1 + i, numVertices)]);
+    }
+    return { vertices1, vertices2 };
+}

package/dist/geometry/hollowgon.d.ts

@@ -0,0 +1,24 @@
+import { IntersectionObject, Polygon } from "./polygon.js";
+import { Vec2 } from "./vec2.js";
+export declare class Hollowgon {
+    #private;
+    boundary: Polygon;
+    holes: Polygon[];
+    constructor(boundary: Polygon, holes?: Polygon[], ensureCorrectOrientation?: boolean);
+    centroid(): Vec2;
+    rotate(rotation: number, center?: Vec2): this;
+    toSimplePolygons(): Polygon;
+    area(): number;
+    aabb(): import("./aabb.js").AABB;
+    clone(): Hollowgon;
+    translate(translation: Vec2): this;
+    isPointInside(position: Vec2): boolean;
+    signedDistanceToBoundary(position: Vec2): number;
+    signedDistanceToHole(position: Vec2): number;
+    signedDistanceTo(position: Vec2): number;
+    addHole(hole: Polygon, ensureCorrectOrientation?: boolean): void;
+    tessellate(): Polygon[];
+    render(ctx: CanvasRenderingContext2D, beginPath?: boolean): void;
+    computeIntersections(intersectionObject: IntersectionObject): import("./polygon.js").PolygonIntersection[];
+    toArray(): [number, number][][];
+}

package/dist/geometry/hollowgon.js

@@ -0,0 +1,156 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Hollowgon_instances, _Hollowgon_area, _Hollowgon_computeArea;
+import earcut from "earcut";
+import { Polygon } from "./polygon.js";
+import { Vec2 } from "./vec2.js";
+const { abs } = Math;
+export class Hollowgon {
+    constructor(boundary, holes, ensureCorrectOrientation = true) {
+        _Hollowgon_instances.add(this);
+        this.holes = [];
+        _Hollowgon_area.set(this, void 0);
+        if (ensureCorrectOrientation)
+            boundary.makeCounterClockwise();
+        this.boundary = boundary;
+        if (holes)
+            for (const hole of holes)
+                this.addHole(hole);
+    }
+    centroid() {
+        const { boundary, holes } = this;
+        const centroid = boundary.centroid().clone().times(boundary.area());
+        let areaSum = boundary.area();
+        for (const hole of holes) {
+            centroid.minus(hole.centroid().times(hole.area()));
+            areaSum -= hole.area();
+        }
+        return centroid.times(1 / areaSum);
+    }
+    rotate(rotation, center) {
+        center ?? (center = this.centroid());
+        this.boundary.rotate(rotation, center);
+        for (const hole of this.holes) {
+            hole.rotate(rotation, center);
+        }
+        return this;
+    }
+    toSimplePolygons() {
+        const result = this.boundary.clone();
+        for (const hole of this.holes)
+            result.addHole(hole);
+        return result;
+    }
+    area() { return __classPrivateFieldSet(this, _Hollowgon_area, __classPrivateFieldGet(this, _Hollowgon_area, "f") ?? __classPrivateFieldGet(this, _Hollowgon_instances, "m", _Hollowgon_computeArea).call(this), "f"); }
+    aabb() { return this.boundary.aabb(); }
+    clone() {
+        const { boundary, holes } = this;
+        const clone = new Hollowgon(boundary.clone());
+        for (const hole of holes)
+            clone.addHole(hole.clone());
+        return clone;
+    }
+    translate(translation) {
+        this.boundary.translate(translation);
+        for (const hole of this.holes)
+            hole.translate(translation);
+        return this;
+    }
+    isPointInside(position) {
+        const { boundary, holes } = this;
+        if (!boundary.isPointInside(position))
+            return false;
+        for (const hole of holes) {
+            if (hole.isPointInside(position))
+                return false;
+        }
+        return true;
+    }
+    signedDistanceToBoundary(position) {
+        return this.boundary.signedDistanceToBoundary(position);
+    }
+    signedDistanceToHole(position) {
+        let distance = Infinity;
+        for (const hole of this.holes) {
+            const holeDistance = -hole.signedDistanceToBoundary(position);
+            if (abs(holeDistance) < abs(distance))
+                distance = holeDistance;
+        }
+        return distance;
+    }
+    signedDistanceTo(position) {
+        const boundaryDistance = this.signedDistanceToBoundary(position);
+        const holeDistance = this.signedDistanceToHole(position);
+        return abs(boundaryDistance) < abs(holeDistance) ? boundaryDistance : holeDistance;
+    }
+    addHole(hole, ensureCorrectOrientation = true) {
+        if (ensureCorrectOrientation)
+            hole.makeClockwise();
+        this.holes.push(hole);
+    }
+    tessellate() {
+        const vertices = [];
+        const holeIndices = [];
+        vertices.push(...this.boundary.vertices);
+        for (const hole of this.holes) {
+            holeIndices.push(vertices.length);
+            vertices.push(...hole.vertices);
+        }
+        const indices = earcut(Vec2.toBuffer(vertices), holeIndices);
+        let triangles = [];
+        for (let i = 0; i < indices.length;) {
+            const triangle = new Polygon([
+                vertices[indices[i++]].clone(),
+                vertices[indices[i++]].clone(),
+                vertices[indices[i++]].clone()
+            ]);
+            triangles.push(triangle);
+        }
+        return triangles;
+    }
+    render(ctx, beginPath = true) {
+        const { boundary, holes } = this;
+        if (beginPath)
+            ctx.beginPath();
+        renderHelper(ctx, boundary);
+        for (const hole of holes)
+            renderHelper(ctx, hole);
+        ctx.closePath();
+    }
+    computeIntersections(intersectionObject) {
+        let intersections = this.boundary.computeIntersections(intersectionObject);
+        for (const hole of this.holes) {
+            intersections = intersections.concat(hole.computeIntersections(intersectionObject));
+        }
+        intersections.sort((a, b) => a.lineTime - b.lineTime);
+        return intersections;
+    }
+    toArray() {
+        const vertexArray = [this.boundary.toArray()];
+        for (const hole of this.holes)
+            vertexArray.push(hole.toArray());
+        return vertexArray;
+    }
+}
+_Hollowgon_area = new WeakMap(), _Hollowgon_instances = new WeakSet(), _Hollowgon_computeArea = function _Hollowgon_computeArea() {
+    let area = this.boundary.area();
+    for (const hole of this.holes)
+        area -= hole.area();
+    return area;
+};
+function renderHelper(ctx, polygon) {
+    for (let i = 0, n = polygon.numVertices(); i <= n; i++) {
+        const { x, y } = polygon.getVertex(i);
+        i === 0 ? ctx.moveTo(x, y) : ctx.lineTo(x, y);
+    }
+    ctx.closePath();
+}

package/dist/geometry/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./aabb.js";
+export * from "./line.js";
+export * from "./polygon.js";
+export * from "./ray.js";
+export * from "./segment.js";
+export * from "./vec2.js";
+export * from "./vec3.js";
+export * from "./vec4.js";
+export * from "./transformations.js";
+export * from "./hollowgon.js";
+export * from "./polyline.js";
+export * from "./polygon-operations.js";
+export * from "./ray3.js";

package/dist/geometry/index.js

@@ -0,0 +1,14 @@
+export * from "./aabb.js";
+// export * from "./cut-polygon.js";
+export * from "./line.js";
+export * from "./polygon.js";
+export * from "./ray.js";
+export * from "./segment.js";
+export * from "./vec2.js";
+export * from "./vec3.js";
+export * from "./vec4.js";
+export * from "./transformations.js";
+export * from "./hollowgon.js";
+export * from "./polyline.js";
+export * from "./polygon-operations.js";
+export * from "./ray3.js";

package/dist/geometry/line.d.ts

@@ -0,0 +1,10 @@
+import { Vec2 } from "./vec2.js";
+export declare class Line {
+    point: Vec2;
+    direction: Vec2;
+    constructor(point: Vec2, direction: Vec2);
+    static fromPoints(start: Vec2, end: Vec2): Line;
+    interpolate(time: number): Vec2;
+    computeIntersection(other: Line): Vec2 | null;
+    projectVectorOnto(vector: Vec2): Vec2;
+}

package/dist/geometry/line.js

@@ -0,0 +1,26 @@
+import { EPS } from "../constants.js";
+import { Vec2 } from "./vec2.js";
+const { abs } = Math;
+export class Line {
+    constructor(point, direction) {
+        this.point = point;
+        this.direction = direction;
+    }
+    static fromPoints(start, end) {
+        return new Line(start, Vec2.subtract(end, start));
+    }
+    interpolate(time) {
+        return Vec2.add(this.point, Vec2.multiply(this.direction, time));
+    }
+    computeIntersection(other) {
+        const denominator = this.direction.cross(other.direction);
+        if (abs(denominator) < EPS)
+            return null;
+        let time1 = Vec2.subtract(other.point, this.point).cross(other.direction) / denominator;
+        return this.interpolate(time1);
+    }
+    projectVectorOnto(vector) {
+        const originLineProjection = Vec2.subtract(vector, this.point).projectOnto(this.direction);
+        return Vec2.add(this.point, originLineProjection);
+    }
+}

package/dist/geometry/polygon-operations.d.ts

@@ -0,0 +1,31 @@
+import { Hollowgon } from "./hollowgon.js";
+import { Line } from "./line.js";
+import { Polygon } from "./polygon.js";
+import { Polyline } from "./polyline.js";
+import { Ray } from "./ray.js";
+import { Segment } from "./segment.js";
+export type OperationShape = Polygon | Hollowgon;
+export type SubdivisionObject = Line | Ray | Segment | Polyline;
+type SubdivisionObjectInput<T extends OperationShape> = SubdivisionObject | ((shape: T) => SubdivisionObject);
+export declare function subdivide(shape: Polygon | Array<Polygon>, subdivisionObject: SubdivisionObjectInput<Polygon>): Array<Polygon>;
+export declare function subdivide(shape: Hollowgon | Array<Hollowgon>, subdivisionObject: SubdivisionObjectInput<Hollowgon>): Array<OperationShape>;
+export declare function subdivide(shape: OperationShape | Array<OperationShape>, subdivisionObject: SubdivisionObjectInput<OperationShape>): Array<OperationShape>;
+export declare function intersect(shapes: Array<Polygon>): Array<Polygon>;
+export declare function intersect(shapes: Array<OperationShape>): Array<OperationShape>;
+export declare function union(shapes: Array<Polygon>): Array<Polygon>;
+export declare function union(shapes: Array<OperationShape>): Array<OperationShape>;
+export declare function difference(shapes: Array<OperationShape>): OperationShape[];
+export declare function xor(shapes: Array<OperationShape>): OperationShape[];
+export declare function clip(shape: Polygon | Array<Polygon>, clipShapes: OperationShape | Array<OperationShape>): Array<Polygon>;
+export declare function clip(shape: Hollowgon | Array<Hollowgon>, clipShapes: OperationShape | Array<OperationShape>): Array<OperationShape>;
+export declare function clip(shape: OperationShape | Array<OperationShape>, clipShapes: OperationShape | Array<OperationShape>): Array<OperationShape>;
+export declare const polygonOperations: {
+    subdivide: typeof subdivide;
+    intersect: typeof intersect;
+    union: typeof union;
+    difference: typeof difference;
+    xor: typeof xor;
+    clip: typeof clip;
+};
+export declare function createSubdivisionPolygon(shape: OperationShape, subdivisionObject: SubdivisionObject): Polygon | null;
+export {};