@mlightcad/cad-pdf-plugin 1.8.0-preview.2 → 1.8.0-preview.4

package/lib/recognition/pdfHatchFaces.js

@@ -0,0 +1,1285 @@
+/**
+ * Hatch boundaries from the faces of the surrounding line work.
+ *
+ * A hatch written to PDF keeps its strokes but loses its boundary object;
+ * the boundary usually survives as ordinary lines, arcs and polylines that
+ * cross each other, meet in T-junctions and run on past the hatch. This
+ * module splits those edges at every intersection (a planar arrangement),
+ * walks the faces of the resulting graph and returns the outline of the
+ * faces that hold hatch strokes, holes included.
+ *
+ * Pure data in, pure data out.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { cubicAt } from './pdfRecGeometry';
+/**
+ * Splits `edges` at every crossing and near touch and walks the faces of
+ * the result. Returns `undefined` when they enclose nothing or hold more
+ * than `maxSegments` segments.
+ *
+ * @param edges - Open or closed polylines of the line work.
+ */
+export function acapPdfFaceArrangement(edges, options) {
+    var _a;
+    var tol = options.tolerance;
+    var maxSegments = (_a = options.maxSegments) !== null && _a !== void 0 ? _a : 20000;
+    var segments = toSegments(edges, tol);
+    if (segments.length < 3 || segments.length > maxSegments)
+        return undefined;
+    var graph = buildGraph(segments, tol);
+    pruneDangling(graph);
+    if (graph.edges.length < 3)
+        return undefined;
+    var faces = traceFaces(graph);
+    var bounded = faces.filter(function (face) { return face.area > 0; });
+    if (bounded.length === 0)
+        return undefined;
+    var grid = new BoxGrid(bounded.map(function (face) { return face.box; }), bounded.length);
+    var arrangement = {
+        kind: 'pdfFaceArrangement',
+        graph: graph,
+        faces: faces,
+        bounded: bounded,
+        grid: grid,
+        tolerance: tol
+    };
+    return arrangement;
+}
+/**
+ * Outline loops (outer and holes, to be filled even-odd) of the faces of
+ * `edges` that contain the `hits`, or `undefined` when the edges do not
+ * enclose them.
+ *
+ * @param edges - Open or closed polylines of the line work around the hatch.
+ * @param hits - Points known to lie inside the hatch (stroke midpoints).
+ */
+export function acapPdfFaceBoundary(edges, hits, options) {
+    if (hits.length === 0)
+        return undefined;
+    var arrangement = acapPdfFaceArrangement(edges, options);
+    return arrangement
+        ? acapPdfFaceBoundaryIn(arrangement, hits, options)
+        : undefined;
+}
+/**
+ * {@link acapPdfFaceBoundary} on an arrangement built once with
+ * {@link acapPdfFaceArrangement}, for callers that try several hit sets
+ * against the same line work.
+ *
+ * @param arrangement - Faces of the line work around the hatch.
+ * @param hits - Points known to lie inside the hatch (stroke midpoints).
+ */
+export function acapPdfFaceBoundaryIn(arrangement, hits, options) {
+    var _a;
+    return (_a = acapPdfFaceBoundaryParts(arrangement, hits, options)) === null || _a === void 0 ? void 0 : _a[0];
+}
+/**
+ * Like {@link acapPdfFaceBoundaryIn}, but split into separate hatches.
+ *
+ * Without `strokes` every face holding hits joins one outline. With them,
+ * two such faces join only when strokes run across the edge between them
+ * (a line drawn over one hatch, such as an axis). When strokes stop on the
+ * edge from both sides instead, each side was clipped to its own boundary:
+ * two hatches of one pattern that touch, kept apart.
+ *
+ * @param strokes - The hatch strokes the hits came from.
+ * @returns Outline loops per hatch, the one with the most hits first.
+ */
+export function acapPdfFaceBoundaryParts(arrangement, hits, options) {
+    var e_1, _a, e_2, _b, e_3, _c;
+    var _d, _e, _f, _g;
+    var minCoverage = (_d = options === null || options === void 0 ? void 0 : options.minCoverage) !== null && _d !== void 0 ? _d : 0.9;
+    if (hits.length === 0)
+        return undefined;
+    var state = arrangement;
+    var graph = state.graph, faces = state.faces, bounded = state.bounded, grid = state.grid;
+    // Each hit belongs to the smallest bounded face around it; a face of an
+    // island inside a bigger face is smaller, so islands come out right.
+    var hitCount = new Map();
+    var assigned = 0;
+    var _loop_1 = function (p) {
+        var best;
+        grid.forEachAt(p, function (i) {
+            var face = bounded[i];
+            if (best && face.area >= best.area)
+                return;
+            if (!inBox(p, face.box) || !pointInPolygon(p, face.points))
+                return;
+            best = face;
+        });
+        if (best) {
+            hitCount.set(best, ((_e = hitCount.get(best)) !== null && _e !== void 0 ? _e : 0) + 1);
+            assigned++;
+        }
+    };
+    try {
+        for (var hits_1 = __values(hits), hits_1_1 = hits_1.next(); !hits_1_1.done; hits_1_1 = hits_1.next()) {
+            var p = hits_1_1.value;
+            _loop_1(p);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (hits_1_1 && !hits_1_1.done && (_a = hits_1.return)) _a.call(hits_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (assigned < hits.length * minCoverage)
+        return undefined;
+    // Stray strokes (a dimension tick, a stub of another hatch) must not pull
+    // in a large empty face: keep faces whose hit density fits the rest.
+    var densities = __spreadArray([], __read(hitCount.entries()), false).map(function (_a) {
+        var _b = __read(_a, 2), face = _b[0], count = _b[1];
+        return count / face.area;
+    })
+        .sort(function (p, q) { return p - q; });
+    var median = densities[Math.floor(densities.length / 2)];
+    var selected = new Set();
+    var kept = 0;
+    try {
+        for (var hitCount_1 = __values(hitCount), hitCount_1_1 = hitCount_1.next(); !hitCount_1_1.done; hitCount_1_1 = hitCount_1.next()) {
+            var _h = __read(hitCount_1_1.value, 2), face = _h[0], count = _h[1];
+            // A face the hatch covers holds about as many hits as its area says;
+            // a big face with a few stray strokes does not. Small faces (expected
+            // to hold a handful) are judged leniently.
+            var expected = median * face.area;
+            var sparse = expected >= 6 ? count < expected * MIN_DENSITY_SHARE : count < 3;
+            if (sparse && count / face.area < median * 0.1)
+                continue;
+            if (sparse && expected >= 6)
+                continue;
+            selected.add(face);
+            kept += count;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (hitCount_1_1 && !hitCount_1_1.done && (_b = hitCount_1.return)) _b.call(hitCount_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (kept < hits.length * minCoverage)
+        return undefined;
+    // Outer cycles of islands bound the face around them.
+    (_f = state.owner) !== null && _f !== void 0 ? _f : (state.owner = resolveHoleOwners(faces, bounded, grid));
+    var owner = state.owner;
+    var resolve = function (face) { var _a; return (_a = owner.get(face)) !== null && _a !== void 0 ? _a : face; };
+    var parts = splitFaces(graph, faces, resolve, selected, options === null || options === void 0 ? void 0 : options.strokes, state.tolerance);
+    var out = [];
+    var _loop_2 = function (part) {
+        var e_4, _j;
+        var loops = unionOutline(graph, faces, function (face) { return part.has(resolve(face)); }, state.tolerance);
+        if (!loops)
+            return "continue";
+        var count = 0;
+        try {
+            for (var part_1 = (e_4 = void 0, __values(part)), part_1_1 = part_1.next(); !part_1_1.done; part_1_1 = part_1.next()) {
+                var face = part_1_1.value;
+                count += (_g = hitCount.get(face)) !== null && _g !== void 0 ? _g : 0;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (part_1_1 && !part_1_1.done && (_j = part_1.return)) _j.call(part_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        out.push({ loops: loops, hits: count });
+    };
+    try {
+        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+            var part = parts_1_1.value;
+            _loop_2(part);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (parts_1_1 && !parts_1_1.done && (_c = parts_1.return)) _c.call(parts_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    if (out.length === 0)
+        return undefined;
+    return out.sort(function (p, q) { return q.hits - p.hits; }).map(function (part) { return part.loops; });
+}
+/**
+ * Polyline through a recognized shape, with curves sampled so no chord is
+ * further than `chordTolerance` from the curve.
+ */
+export function acapPdfShapePolyline(shape, chordTolerance) {
+    var arcPoints = function (center, radius, start, sweep) {
+        var steps = arcSteps(radius, Math.abs(sweep), chordTolerance);
+        var out = [];
+        for (var i = 0; i <= steps; i++) {
+            var a = start + (sweep * i) / steps;
+            out.push({
+                x: center.x + radius * Math.cos(a),
+                y: center.y + radius * Math.sin(a)
+            });
+        }
+        return out;
+    };
+    switch (shape.kind) {
+        case 'line':
+            return [shape.start, shape.end];
+        case 'circle':
+            return arcPoints(shape.center, shape.radius, 0, Math.PI * 2);
+        case 'arc': {
+            var sweep = shape.endAngle - shape.startAngle;
+            if (sweep <= 0)
+                sweep += Math.PI * 2;
+            return arcPoints(shape.center, shape.radius, shape.startAngle, sweep);
+        }
+        case 'ellipse': {
+            var sweep = shape.endAngle - shape.startAngle;
+            if (sweep <= 0)
+                sweep += Math.PI * 2;
+            var major = Math.hypot(shape.majorAxis.x, shape.majorAxis.y);
+            var steps = arcSteps(major, sweep, chordTolerance);
+            var mx = shape.majorAxis.x;
+            var my = shape.majorAxis.y;
+            var out = [];
+            for (var i = 0; i <= steps; i++) {
+                var a = shape.startAngle + (sweep * i) / steps;
+                var cos = Math.cos(a);
+                var sin = Math.sin(a) * shape.radiusRatio;
+                out.push({
+                    x: shape.center.x + mx * cos - my * sin,
+                    y: shape.center.y + my * cos + mx * sin
+                });
+            }
+            return out;
+        }
+        case 'polyline': {
+            var v = shape.vertices;
+            var out = [];
+            var count = shape.closed ? v.length : v.length - 1;
+            for (var i = 0; i < count; i++) {
+                var a = v[i];
+                var b = v[(i + 1) % v.length];
+                if (Math.abs(a.bulge) <= 1e-12) {
+                    out.push({ x: a.x, y: a.y });
+                    continue;
+                }
+                var sweep = 4 * Math.atan(a.bulge);
+                var chord = Math.hypot(b.x - a.x, b.y - a.y);
+                var radius = chord / (2 * Math.sin(Math.abs(sweep) / 2));
+                var h = radius * Math.cos(Math.abs(sweep) / 2) * Math.sign(a.bulge);
+                var center = {
+                    x: (a.x + b.x) / 2 - (h * (b.y - a.y)) / chord,
+                    y: (a.y + b.y) / 2 + (h * (b.x - a.x)) / chord
+                };
+                var start = Math.atan2(a.y - center.y, a.x - center.x);
+                var arc = arcPoints(center, radius, start, sweep);
+                out.push.apply(out, __spreadArray([], __read(arc.slice(0, -1)), false));
+            }
+            var end = shape.closed ? v[0] : v[v.length - 1];
+            if (end)
+                out.push({ x: end.x, y: end.y });
+            return out;
+        }
+        case 'spline': {
+            var c = shape.controlPoints;
+            if (c.length < 4)
+                return c.map(function (p) { return ({ x: p.x, y: p.y }); });
+            var out = [c[0]];
+            for (var i = 0; i + 3 < c.length; i += 3) {
+                for (var k = 1; k <= 16; k++) {
+                    out.push(cubicAt(c[i], c[i + 1], c[i + 2], c[i + 3], k / 16));
+                }
+            }
+            return out;
+        }
+    }
+}
+function arcSteps(radius, sweep, chordTolerance) {
+    // Sagitta r(1 - cos(θ/2)) <= tolerance.
+    var ratio = Math.min(1, Math.max(0, 1 - chordTolerance / radius));
+    var step = ratio > 0 ? 2 * Math.acos(ratio) : Math.PI / 4;
+    return Math.min(256, Math.max(2, Math.ceil(sweep / Math.max(step, 1e-3))));
+}
+function toSegments(edges, tol) {
+    var e_5, _a;
+    var out = [];
+    var min = tol * 0.01;
+    try {
+        for (var edges_1 = __values(edges), edges_1_1 = edges_1.next(); !edges_1_1.done; edges_1_1 = edges_1.next()) {
+            var polyline = edges_1_1.value;
+            for (var i = 0; i + 1 < polyline.length; i++) {
+                var a = polyline[i];
+                var b = polyline[i + 1];
+                if (Math.hypot(b.x - a.x, b.y - a.y) > min)
+                    out.push([a, b]);
+            }
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (edges_1_1 && !edges_1_1.done && (_a = edges_1.return)) _a.call(edges_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return out;
+}
+/** Splits segments at every crossing and near touch, snapping vertices. */
+function buildGraph(segments, tol) {
+    var e_6, _a, e_7, _b;
+    var params = segments.map(function () { return [0, 1]; });
+    var boxes = segments.map(function (_a) {
+        var _b = __read(_a, 2), a = _b[0], b = _b[1];
+        return ({
+            minX: Math.min(a.x, b.x) - tol,
+            minY: Math.min(a.y, b.y) - tol,
+            maxX: Math.max(a.x, b.x) + tol,
+            maxY: Math.max(a.y, b.y) + tol
+        });
+    });
+    forEachNearPair(boxes, function (i, j) {
+        var _a = __read(segments[i], 2), a = _a[0], b = _a[1];
+        var _b = __read(segments[j], 2), c = _b[0], d = _b[1];
+        var cross = crossing(a, b, c, d);
+        if (cross) {
+            params[i].push(cross[0]);
+            params[j].push(cross[1]);
+        }
+        // T-junctions and ends that stop just short of (or past) another edge.
+        var t = projectWithin(a, c, d, tol);
+        if (t !== undefined)
+            params[j].push(t);
+        t = projectWithin(b, c, d, tol);
+        if (t !== undefined)
+            params[j].push(t);
+        t = projectWithin(c, a, b, tol);
+        if (t !== undefined)
+            params[i].push(t);
+        t = projectWithin(d, a, b, tol);
+        if (t !== undefined)
+            params[i].push(t);
+    });
+    // Snap grid with numeric cell keys (string keys dominate on big inputs).
+    var originX = Infinity;
+    var originY = Infinity;
+    var maxY = -Infinity;
+    try {
+        for (var boxes_1 = __values(boxes), boxes_1_1 = boxes_1.next(); !boxes_1_1.done; boxes_1_1 = boxes_1.next()) {
+            var box = boxes_1_1.value;
+            originX = Math.min(originX, box.minX);
+            originY = Math.min(originY, box.minY);
+            maxY = Math.max(maxY, box.maxY);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (boxes_1_1 && !boxes_1_1.done && (_a = boxes_1.return)) _a.call(boxes_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    var cell = tol * 2;
+    // A spare cell on each side keeps neighbour keys from wrapping.
+    originX -= cell;
+    originY -= cell;
+    var stride = Math.floor((maxY - originY) / cell) + 3;
+    var points = [];
+    var grid = new Map();
+    var vertexAt = function (x, y) {
+        var e_8, _a;
+        var gx = Math.floor((x - originX) / cell);
+        var gy = Math.floor((y - originY) / cell);
+        for (var dx = -1; dx <= 1; dx++) {
+            for (var dy = -1; dy <= 1; dy++) {
+                var list_2 = grid.get((gx + dx) * stride + gy + dy);
+                if (!list_2)
+                    continue;
+                try {
+                    for (var list_1 = (e_8 = void 0, __values(list_2)), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+                        var id_1 = list_1_1.value;
+                        var q = points[id_1];
+                        if (Math.hypot(q.x - x, q.y - y) <= tol)
+                            return id_1;
+                    }
+                }
+                catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                finally {
+                    try {
+                        if (list_1_1 && !list_1_1.done && (_a = list_1.return)) _a.call(list_1);
+                    }
+                    finally { if (e_8) throw e_8.error; }
+                }
+            }
+        }
+        var id = points.length;
+        points.push({ x: x, y: y });
+        var key = gx * stride + gy;
+        var list = grid.get(key);
+        if (list)
+            list.push(id);
+        else
+            grid.set(key, [id]);
+        return id;
+    };
+    var maxPoints = 0;
+    try {
+        for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+            var list = params_1_1.value;
+            maxPoints += list.length;
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (params_1_1 && !params_1_1.done && (_b = params_1.return)) _b.call(params_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    var seen = new Set();
+    var edges = [];
+    segments.forEach(function (_a, i) {
+        var e_9, _b;
+        var _c = __read(_a, 2), a = _c[0], b = _c[1];
+        var ts = params[i].sort(function (p, q) { return p - q; });
+        var prev = -1;
+        var last = NaN;
+        try {
+            for (var ts_1 = __values(ts), ts_1_1 = ts_1.next(); !ts_1_1.done; ts_1_1 = ts_1.next()) {
+                var t = ts_1_1.value;
+                if (t === last)
+                    continue;
+                last = t;
+                var id = vertexAt(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+                if (prev >= 0 && id !== prev) {
+                    var key = prev < id ? prev * maxPoints + id : id * maxPoints + prev;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        edges.push([prev, id]);
+                    }
+                }
+                prev = id;
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (ts_1_1 && !ts_1_1.done && (_b = ts_1.return)) _b.call(ts_1);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+    });
+    var out = points.map(function () { return []; });
+    edges.forEach(function (_a, e) {
+        var _b = __read(_a, 2), u = _b[0], v = _b[1];
+        out[u].push(2 * e);
+        out[v].push(2 * e + 1);
+    });
+    return { points: points, edges: edges, out: out };
+}
+/** Calls `fn` once for every pair of boxes that overlap. */
+function forEachNearPair(boxes, fn) {
+    if (boxes.length < 2)
+        return;
+    var grid = new BoxGrid(boxes, boxes.length);
+    grid.forEachCell(function (ids, cx, cy) {
+        for (var p = 0; p < ids.length; p++) {
+            var a = boxes[ids[p]];
+            for (var q = p + 1; q < ids.length; q++) {
+                var b = boxes[ids[q]];
+                if (a.maxX < b.minX ||
+                    b.maxX < a.minX ||
+                    a.maxY < b.minY ||
+                    b.maxY < a.minY) {
+                    continue;
+                }
+                // Two boxes share several cells; only the one holding the low
+                // corner of their overlap reports the pair.
+                if (grid.cellX(Math.max(a.minX, b.minX)) !== cx ||
+                    grid.cellY(Math.max(a.minY, b.minY)) !== cy) {
+                    continue;
+                }
+                var i = ids[p];
+                var j = ids[q];
+                if (i < j)
+                    fn(i, j);
+                else
+                    fn(j, i);
+            }
+        }
+    });
+}
+/**
+ * Uniform grid over boxes in compressed rows with numeric cells. Cells
+ * follow the median box, enlarged so the grid stays near `cellBudget`
+ * cells.
+ */
+var BoxGrid = /** @class */ (function () {
+    function BoxGrid(boxes, cellBudget) {
+        var e_10, _a, e_11, _b;
+        var _this = this;
+        this.minX = 0;
+        this.minY = 0;
+        this.size = 1;
+        this.nx = 1;
+        this.ny = 1;
+        this.start = new Int32Array(2);
+        this.ids = new Int32Array(0);
+        var minX = Infinity;
+        var minY = Infinity;
+        var maxX = -Infinity;
+        var maxY = -Infinity;
+        try {
+            for (var boxes_2 = __values(boxes), boxes_2_1 = boxes_2.next(); !boxes_2_1.done; boxes_2_1 = boxes_2.next()) {
+                var b = boxes_2_1.value;
+                minX = Math.min(minX, b.minX);
+                minY = Math.min(minY, b.minY);
+                maxX = Math.max(maxX, b.maxX);
+                maxY = Math.max(maxY, b.maxY);
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (boxes_2_1 && !boxes_2_1.done && (_a = boxes_2.return)) _a.call(boxes_2);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        if (!Number.isFinite(minX + minY + maxX + maxY))
+            return;
+        var width = maxX - minX;
+        var height = maxY - minY;
+        // The median keeps short edges in few cells; the budget keeps a few
+        // long edges from multiplying the cell count.
+        var sizes = boxes.map(function (b) { return Math.max(b.maxX - b.minX, b.maxY - b.minY); });
+        sizes.sort(function (p, q) { return p - q; });
+        var typical = sizes[Math.floor(sizes.length / 2)];
+        var budget = Math.sqrt((width * height) / Math.max(1, cellBudget));
+        this.size = Math.max(typical, budget, width / 2048, height / 2048, 1e-9);
+        this.minX = minX;
+        this.minY = minY;
+        this.nx = Math.floor(width / this.size) + 1;
+        this.ny = Math.floor(height / this.size) + 1;
+        var counts = new Int32Array(this.nx * this.ny + 1);
+        try {
+            for (var boxes_3 = __values(boxes), boxes_3_1 = boxes_3.next(); !boxes_3_1.done; boxes_3_1 = boxes_3.next()) {
+                var b = boxes_3_1.value;
+                var x0 = this.cellX(b.minX);
+                var x1 = this.cellX(b.maxX);
+                var y0 = this.cellY(b.minY);
+                var y1 = this.cellY(b.maxY);
+                for (var x = x0; x <= x1; x++) {
+                    for (var y = y0; y <= y1; y++)
+                        counts[x * this.ny + y + 1]++;
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (boxes_3_1 && !boxes_3_1.done && (_b = boxes_3.return)) _b.call(boxes_3);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        for (var c = 1; c < counts.length; c++)
+            counts[c] += counts[c - 1];
+        this.start = counts.slice();
+        this.ids = new Int32Array(counts[counts.length - 1]);
+        boxes.forEach(function (b, i) {
+            var x0 = _this.cellX(b.minX);
+            var x1 = _this.cellX(b.maxX);
+            var y0 = _this.cellY(b.minY);
+            var y1 = _this.cellY(b.maxY);
+            for (var x = x0; x <= x1; x++) {
+                for (var y = y0; y <= y1; y++)
+                    _this.ids[counts[x * _this.ny + y]++] = i;
+            }
+        });
+    }
+    BoxGrid.prototype.cellX = function (x) {
+        var c = Math.floor((x - this.minX) / this.size);
+        return c < 0 ? 0 : c >= this.nx ? this.nx - 1 : c;
+    };
+    BoxGrid.prototype.cellY = function (y) {
+        var c = Math.floor((y - this.minY) / this.size);
+        return c < 0 ? 0 : c >= this.ny ? this.ny - 1 : c;
+    };
+    /** Calls `fn` with every box id registered in the cell of `p`. */
+    BoxGrid.prototype.forEachAt = function (p, fn) {
+        var c = this.cellX(p.x) * this.ny + this.cellY(p.y);
+        for (var k = this.start[c]; k < this.start[c + 1]; k++)
+            fn(this.ids[k]);
+    };
+    /** Calls `fn` with the box ids of every cell that holds two or more. */
+    BoxGrid.prototype.forEachCell = function (fn) {
+        for (var x = 0; x < this.nx; x++) {
+            for (var y = 0; y < this.ny; y++) {
+                var c = x * this.ny + y;
+                var from = this.start[c];
+                var to = this.start[c + 1];
+                if (to - from >= 2)
+                    fn(this.ids.subarray(from, to), x, y);
+            }
+        }
+    };
+    return BoxGrid;
+}());
+/** Parameters where segments ab and cd cross, if they do. */
+function crossing(a, b, c, d) {
+    var rx = b.x - a.x;
+    var ry = b.y - a.y;
+    var sx = d.x - c.x;
+    var sy = d.y - c.y;
+    var den = rx * sy - ry * sx;
+    if (Math.abs(den) <= 1e-12 * Math.hypot(rx, ry) * Math.hypot(sx, sy)) {
+        return undefined;
+    }
+    var qx = c.x - a.x;
+    var qy = c.y - a.y;
+    var t = (qx * sy - qy * sx) / den;
+    var u = (qx * ry - qy * rx) / den;
+    if (t < 0 || t > 1 || u < 0 || u > 1)
+        return undefined;
+    return [t, u];
+}
+/** Parameter of `p` projected on segment ab when it lies within `tol`. */
+function projectWithin(p, a, b, tol) {
+    var dx = b.x - a.x;
+    var dy = b.y - a.y;
+    var len2 = dx * dx + dy * dy;
+    if (!(len2 > 0))
+        return undefined;
+    var t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+    if (t < 0 || t > 1)
+        return undefined;
+    var d = Math.hypot(p.x - (a.x + dx * t), p.y - (a.y + dy * t));
+    return d <= tol ? t : undefined;
+}
+/** Removes edges that end in a vertex of degree one, repeatedly. */
+function pruneDangling(graph) {
+    var e_12, _a;
+    var degree = graph.out.map(function (list) { return list.length; });
+    var stack = [];
+    degree.forEach(function (d, v) {
+        if (d === 1)
+            stack.push(v);
+    });
+    while (stack.length > 0) {
+        var v = stack.pop();
+        if (degree[v] !== 1)
+            continue;
+        try {
+            for (var _b = (e_12 = void 0, __values(graph.out[v])), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var h = _c.value;
+                var e = h >> 1;
+                var edge = graph.edges[e];
+                if (!edge)
+                    continue;
+                graph.edges[e] = undefined;
+                var other = edge[0] === v ? edge[1] : edge[0];
+                degree[v]--;
+                degree[other]--;
+                if (degree[other] === 1)
+                    stack.push(other);
+                break;
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+    }
+    graph.edges = graph.edges.filter(function (edge) { return edge; });
+    rebuildIds(graph);
+}
+function rebuildIds(graph) {
+    var e_13, _a;
+    var edges = graph.edges;
+    var out = graph.points.map(function () { return []; });
+    edges.forEach(function (_a, e) {
+        var _b = __read(_a, 2), u = _b[0], v = _b[1];
+        out[u].push(2 * e);
+        out[v].push(2 * e + 1);
+    });
+    var angle = function (h) {
+        var _a = __read(halfEdge(graph, h), 2), from = _a[0], to = _a[1];
+        var p = graph.points[from];
+        var q = graph.points[to];
+        return Math.atan2(q.y - p.y, q.x - p.x);
+    };
+    try {
+        for (var out_1 = __values(out), out_1_1 = out_1.next(); !out_1_1.done; out_1_1 = out_1.next()) {
+            var list = out_1_1.value;
+            list.sort(function (p, q) { return angle(p) - angle(q); });
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (out_1_1 && !out_1_1.done && (_a = out_1.return)) _a.call(out_1);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    graph.out = out;
+}
+function halfEdge(graph, h) {
+    var edge = graph.edges[h >> 1];
+    return h & 1 ? [edge[1], edge[0]] : [edge[0], edge[1]];
+}
+/** Next half-edge around the face on the left of `h`. */
+function nextHalfEdge(graph, h) {
+    var _a = __read(halfEdge(graph, h), 2), to = _a[1];
+    var list = graph.out[to];
+    var twin = h ^ 1;
+    var at = list.indexOf(twin);
+    // The neighbour clockwise from the twin keeps the face on the left.
+    return list[(at - 1 + list.length) % list.length];
+}
+function traceFaces(graph) {
+    var component = components(graph);
+    var faceOf = new Int32Array(graph.edges.length * 2).fill(-1);
+    var faces = [];
+    for (var start = 0; start < graph.edges.length * 2; start++) {
+        if (faceOf[start] >= 0)
+            continue;
+        var halfEdges = [];
+        var h = start;
+        while (faceOf[h] < 0 && halfEdges.length <= graph.edges.length * 2) {
+            faceOf[h] = faces.length;
+            halfEdges.push(h);
+            h = nextHalfEdge(graph, h);
+        }
+        var points = halfEdges.map(function (e) { return graph.points[halfEdge(graph, e)[0]]; });
+        faces.push({
+            halfEdges: halfEdges,
+            points: points,
+            area: signedArea(points),
+            box: boxOf(points),
+            component: component[halfEdge(graph, start)[0]]
+        });
+    }
+    return faces;
+}
+function components(graph) {
+    var e_14, _a;
+    var id = new Array(graph.points.length).fill(-1);
+    var next = 0;
+    for (var v = 0; v < graph.points.length; v++) {
+        if (id[v] >= 0 || graph.out[v].length === 0)
+            continue;
+        var stack = [v];
+        id[v] = next;
+        while (stack.length > 0) {
+            var u = stack.pop();
+            try {
+                for (var _b = (e_14 = void 0, __values(graph.out[u])), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var h = _c.value;
+                    var _d = __read(halfEdge(graph, h), 2), w = _d[1];
+                    if (id[w] < 0) {
+                        id[w] = next;
+                        stack.push(w);
+                    }
+                }
+            }
+            catch (e_14_1) { e_14 = { error: e_14_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_14) throw e_14.error; }
+            }
+        }
+        next++;
+    }
+    return id;
+}
+/**
+ * The bounded face of another component that encloses each outer cycle
+ * (negative area) of a component: an island's outer cycle is a hole of
+ * that face.
+ */
+function resolveHoleOwners(faces, bounded, grid) {
+    var e_15, _a;
+    var owner = new Map();
+    var _loop_3 = function (face) {
+        if (face.area > 0)
+            return "continue";
+        var p = face.points[0];
+        var best;
+        grid.forEachAt(p, function (i) {
+            var candidate = bounded[i];
+            if (candidate.component === face.component)
+                return;
+            if (candidate.area <= -face.area)
+                return;
+            if (best && candidate.area >= best.area)
+                return;
+            if (!inBox(p, candidate.box) || !pointInPolygon(p, candidate.points)) {
+                return;
+            }
+            best = candidate;
+        });
+        if (best)
+            owner.set(face, best);
+    };
+    try {
+        for (var faces_1 = __values(faces), faces_1_1 = faces_1.next(); !faces_1_1.done; faces_1_1 = faces_1.next()) {
+            var face = faces_1_1.value;
+            _loop_3(face);
+        }
+    }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    finally {
+        try {
+            if (faces_1_1 && !faces_1_1.done && (_a = faces_1.return)) _a.call(faces_1);
+        }
+        finally { if (e_15) throw e_15.error; }
+    }
+    return owner;
+}
+/** Share of the median hit density a big face needs to be hatched. */
+var MIN_DENSITY_SHARE = 0.25;
+/** Strokes ending on an edge that mark it as two hatches' shared edge. */
+var MIN_CLIPPED_ENDS = 3;
+/** Most edge-stroke pairs tested before splitting is skipped. */
+var MAX_SPLIT_TESTS = 4000000;
+/**
+ * Groups the selected faces into hatches: neighbours join unless the
+ * strokes stop on the edge between them without crossing it.
+ */
+function splitFaces(graph, faces, resolve, selected, strokes, tol) {
+    var e_16, _a, e_17, _b, e_18, _c, e_19, _d, e_20, _e;
+    var list = __spreadArray([], __read(selected), false);
+    if (!strokes || strokes.length === 0 || list.length < 2)
+        return [selected];
+    var index = new Map(list.map(function (face, i) { return [face, i]; }));
+    var faceOf = new Int32Array(graph.edges.length * 2);
+    faces.forEach(function (face, i) {
+        var e_21, _a;
+        try {
+            for (var _b = __values(face.halfEdges), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var h = _c.value;
+                faceOf[h] = i;
+            }
+        }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_21) throw e_21.error; }
+        }
+    });
+    var internal = [];
+    for (var e = 0; e < graph.edges.length; e++) {
+        var a = index.get(resolve(faces[faceOf[2 * e]]));
+        var b = index.get(resolve(faces[faceOf[2 * e + 1]]));
+        if (a === undefined || b === undefined || a === b)
+            continue;
+        internal.push({ e: e, a: a, b: b });
+    }
+    if (internal.length * strokes.length > MAX_SPLIT_TESTS)
+        return [selected];
+    var parent = list.map(function (_, i) { return i; });
+    var find = function (i) {
+        while (parent[i] !== i) {
+            parent[i] = parent[parent[i]];
+            i = parent[i];
+        }
+        return i;
+    };
+    // Judge each pair of neighbouring faces on all the edges they share: a
+    // short piece of a shared outline may hold too few stroke ends alone.
+    var shared = new Map();
+    try {
+        for (var internal_1 = __values(internal), internal_1_1 = internal_1.next(); !internal_1_1.done; internal_1_1 = internal_1.next()) {
+            var _f = internal_1_1.value, e = _f.e, a = _f.a, b = _f.b;
+            var key = a < b ? "".concat(a, ",").concat(b) : "".concat(b, ",").concat(a);
+            var entry = shared.get(key);
+            if (entry)
+                entry.edges.push(e);
+            else
+                shared.set(key, { a: a, b: b, edges: [e] });
+        }
+    }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    finally {
+        try {
+            if (internal_1_1 && !internal_1_1.done && (_a = internal_1.return)) _a.call(internal_1);
+        }
+        finally { if (e_16) throw e_16.error; }
+    }
+    var cuts = [];
+    try {
+        for (var _g = __values(shared.values()), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var _j = _h.value, a = _j.a, b = _j.b, edges = _j.edges;
+            var segments = edges.map(function (e) {
+                var _a = __read(graph.edges[e], 2), u = _a[0], v = _a[1];
+                return [graph.points[u], graph.points[v]];
+            });
+            if (separates(segments, strokes, tol)) {
+                try {
+                    for (var edges_2 = (e_18 = void 0, __values(edges)), edges_2_1 = edges_2.next(); !edges_2_1.done; edges_2_1 = edges_2.next()) {
+                        var e = edges_2_1.value;
+                        cuts.push({ e: e, a: a, b: b });
+                    }
+                }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                finally {
+                    try {
+                        if (edges_2_1 && !edges_2_1.done && (_c = edges_2.return)) _c.call(edges_2);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                }
+            }
+            else {
+                parent[find(a)] = find(b);
+            }
+        }
+    }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+        }
+        finally { if (e_17) throw e_17.error; }
+    }
+    // Loops of one hatch picked on both sides of an axis are clipped there
+    // too, but they meet along that one straight line. Two hatches that
+    // touch share a bent piece of outline instead.
+    // Repeat with the merged parts: four loops around a cross of axes join
+    // in pairs first, then the pairs along the other axis.
+    for (var merged = true; merged;) {
+        merged = false;
+        var byPair = new Map();
+        try {
+            for (var cuts_1 = (e_19 = void 0, __values(cuts)), cuts_1_1 = cuts_1.next(); !cuts_1_1.done; cuts_1_1 = cuts_1.next()) {
+                var _k = cuts_1_1.value, e = _k.e, a = _k.a, b = _k.b;
+                var ra = find(a);
+                var rb = find(b);
+                if (ra === rb)
+                    continue;
+                var key = ra < rb ? "".concat(ra, ",").concat(rb) : "".concat(rb, ",").concat(ra);
+                var pair = byPair.get(key);
+                if (pair)
+                    pair.push(e);
+                else
+                    byPair.set(key, [e]);
+            }
+        }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (cuts_1_1 && !cuts_1_1.done && (_d = cuts_1.return)) _d.call(cuts_1);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
+        try {
+            for (var byPair_1 = (e_20 = void 0, __values(byPair)), byPair_1_1 = byPair_1.next(); !byPair_1_1.done; byPair_1_1 = byPair_1.next()) {
+                var _l = __read(byPair_1_1.value, 2), key = _l[0], edges = _l[1];
+                var _m = __read(key.split(',').map(Number), 2), ra = _m[0], rb = _m[1];
+                if (isStraightCut(graph, edges, tol)) {
+                    parent[ra] = rb;
+                    merged = true;
+                    break;
+                }
+            }
+        }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        finally {
+            try {
+                if (byPair_1_1 && !byPair_1_1.done && (_e = byPair_1.return)) _e.call(byPair_1);
+            }
+            finally { if (e_20) throw e_20.error; }
+        }
+    }
+    var groups = new Map();
+    list.forEach(function (face, i) {
+        var root = find(i);
+        var group = groups.get(root);
+        if (!group)
+            groups.set(root, (group = new Set()));
+        group.add(face);
+    });
+    return __spreadArray([], __read(groups.values()), false);
+}
+/**
+ * True when `edges` lie on one straight line: an axis or grid line drawn
+ * across the loops of one hatch. Two hatches that touch share a bent piece
+ * of outline (a notch, a recess) instead.
+ */
+function isStraightCut(graph, edges, tol) {
+    var e_22, _a, e_23, _b, e_24, _c;
+    var p;
+    var q;
+    var best = 0;
+    try {
+        // The longest edge fixes the direction most reliably.
+        for (var edges_3 = __values(edges), edges_3_1 = edges_3.next(); !edges_3_1.done; edges_3_1 = edges_3.next()) {
+            var e = edges_3_1.value;
+            var _d = __read(graph.edges[e], 2), u = _d[0], v = _d[1];
+            var a = graph.points[u];
+            var b = graph.points[v];
+            var len = Math.hypot(b.x - a.x, b.y - a.y);
+            if (len > best) {
+                best = len;
+                p = a;
+                q = b;
+            }
+        }
+    }
+    catch (e_22_1) { e_22 = { error: e_22_1 }; }
+    finally {
+        try {
+            if (edges_3_1 && !edges_3_1.done && (_a = edges_3.return)) _a.call(edges_3);
+        }
+        finally { if (e_22) throw e_22.error; }
+    }
+    if (!p || !q || !(best > 0))
+        return false;
+    var ux = (q.x - p.x) / best;
+    var uy = (q.y - p.y) / best;
+    try {
+        for (var edges_4 = __values(edges), edges_4_1 = edges_4.next(); !edges_4_1.done; edges_4_1 = edges_4.next()) {
+            var e = edges_4_1.value;
+            try {
+                for (var _e = (e_24 = void 0, __values(graph.edges[e])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var v = _f.value;
+                    var r = graph.points[v];
+                    if (Math.abs(-uy * (r.x - p.x) + ux * (r.y - p.y)) > tol)
+                        return false;
+                }
+            }
+            catch (e_24_1) { e_24 = { error: e_24_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_c = _e.return)) _c.call(_e);
+                }
+                finally { if (e_24) throw e_24.error; }
+            }
+        }
+    }
+    catch (e_23_1) { e_23 = { error: e_23_1 }; }
+    finally {
+        try {
+            if (edges_4_1 && !edges_4_1.done && (_b = edges_4.return)) _b.call(edges_4);
+        }
+        finally { if (e_23) throw e_23.error; }
+    }
+    return true;
+}
+/**
+ * True when strokes end on the shared edges from their sides and none
+ * crosses them: the edges are where two hatches were each clipped.
+ */
+function separates(edges, strokes, tol) {
+    var e_25, _a, e_26, _b;
+    var ends = 0;
+    try {
+        for (var edges_5 = __values(edges), edges_5_1 = edges_5.next(); !edges_5_1.done; edges_5_1 = edges_5.next()) {
+            var _c = __read(edges_5_1.value, 2), p = _c[0], q = _c[1];
+            var minX = Math.min(p.x, q.x) - tol;
+            var maxX = Math.max(p.x, q.x) + tol;
+            var minY = Math.min(p.y, q.y) - tol;
+            var maxY = Math.max(p.y, q.y) + tol;
+            try {
+                for (var strokes_1 = (e_26 = void 0, __values(strokes)), strokes_1_1 = strokes_1.next(); !strokes_1_1.done; strokes_1_1 = strokes_1.next()) {
+                    var _d = __read(strokes_1_1.value, 2), a = _d[0], b = _d[1];
+                    if (Math.max(a.x, b.x) < minX ||
+                        Math.min(a.x, b.x) > maxX ||
+                        Math.max(a.y, b.y) < minY ||
+                        Math.min(a.y, b.y) > maxY) {
+                        continue;
+                    }
+                    var cross = crossing(a, b, p, q);
+                    if (cross) {
+                        var len = Math.hypot(b.x - a.x, b.y - a.y);
+                        var margin = len > 0 ? tol / len : 1;
+                        // Crossing away from the stroke's ends: it runs across the edge.
+                        if (cross[0] > margin && cross[0] < 1 - margin)
+                            return false;
+                    }
+                    if (distanceToSegment(a, p, q) <= tol ||
+                        distanceToSegment(b, p, q) <= tol) {
+                        ends++;
+                    }
+                }
+            }
+            catch (e_26_1) { e_26 = { error: e_26_1 }; }
+            finally {
+                try {
+                    if (strokes_1_1 && !strokes_1_1.done && (_b = strokes_1.return)) _b.call(strokes_1);
+                }
+                finally { if (e_26) throw e_26.error; }
+            }
+        }
+    }
+    catch (e_25_1) { e_25 = { error: e_25_1 }; }
+    finally {
+        try {
+            if (edges_5_1 && !edges_5_1.done && (_a = edges_5.return)) _a.call(edges_5);
+        }
+        finally { if (e_25) throw e_25.error; }
+    }
+    return ends >= MIN_CLIPPED_ENDS;
+}
+/** Loops along the edges between selected and unselected faces. */
+function unionOutline(graph, faces, isSelected, tol) {
+    var faceOf = new Int32Array(graph.edges.length * 2);
+    faces.forEach(function (face, i) {
+        var e_27, _a;
+        try {
+            for (var _b = __values(face.halfEdges), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var h = _c.value;
+                faceOf[h] = i;
+            }
+        }
+        catch (e_27_1) { e_27 = { error: e_27_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_27) throw e_27.error; }
+        }
+    });
+    var onOutline = function (h) {
+        return isSelected(faces[faceOf[h]]) && !isSelected(faces[faceOf[h ^ 1]]);
+    };
+    var used = new Uint8Array(graph.edges.length * 2);
+    var loops = [];
+    for (var start = 0; start < graph.edges.length * 2; start++) {
+        if (used[start] || !onOutline(start))
+            continue;
+        var loop = [];
+        var h = start;
+        var guard = graph.edges.length * 2 + 1;
+        while (!used[h] && guard-- > 0) {
+            used[h] = 1;
+            loop.push(graph.points[halfEdge(graph, h)[0]]);
+            // Turn past edges that lie between two selected faces.
+            var g = nextHalfEdge(graph, h);
+            var spin = graph.edges.length * 2 + 1;
+            while (!onOutline(g) && spin-- > 0)
+                g = nextHalfEdge(graph, g ^ 1);
+            h = g;
+        }
+        var simple = simplify(loop, tol * 0.1);
+        if (simple.length >= 3 && Math.abs(signedArea(simple)) > tol * tol) {
+            loops.push(simple);
+        }
+    }
+    return loops.length > 0 ? loops : undefined;
+}
+/** Drops vertices on the straight line between their neighbours. */
+function simplify(points, tol) {
+    var out = points;
+    for (var pass = 0; pass < 4; pass++) {
+        var next = out.filter(function (p, i) {
+            var a = out[(i - 1 + out.length) % out.length];
+            var b = out[(i + 1) % out.length];
+            return distanceToSegment(p, a, b) > tol;
+        });
+        if (next.length === out.length || next.length < 3)
+            break;
+        out = next;
+    }
+    return out;
+}
+function distanceToSegment(p, a, b) {
+    var dx = b.x - a.x;
+    var dy = b.y - a.y;
+    var len2 = dx * dx + dy * dy;
+    var t = len2 > 0 ? ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2 : 0;
+    t = Math.max(0, Math.min(1, t));
+    return Math.hypot(p.x - (a.x + dx * t), p.y - (a.y + dy * t));
+}
+function signedArea(points) {
+    var sum = 0;
+    for (var i = 0; i < points.length; i++) {
+        var a = points[i];
+        var b = points[(i + 1) % points.length];
+        sum += a.x * b.y - b.x * a.y;
+    }
+    return sum / 2;
+}
+function boxOf(points) {
+    var e_28, _a;
+    var box = {
+        minX: Infinity,
+        minY: Infinity,
+        maxX: -Infinity,
+        maxY: -Infinity
+    };
+    try {
+        for (var points_1 = __values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
+            var p = points_1_1.value;
+            box.minX = Math.min(box.minX, p.x);
+            box.minY = Math.min(box.minY, p.y);
+            box.maxX = Math.max(box.maxX, p.x);
+            box.maxY = Math.max(box.maxY, p.y);
+        }
+    }
+    catch (e_28_1) { e_28 = { error: e_28_1 }; }
+    finally {
+        try {
+            if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+        }
+        finally { if (e_28) throw e_28.error; }
+    }
+    return box;
+}
+function inBox(p, box) {
+    return (p.x >= box.minX && p.x <= box.maxX && p.y >= box.minY && p.y <= box.maxY);
+}
+function pointInPolygon(p, polygon) {
+    var inside = false;
+    for (var i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        var a = polygon[i];
+        var b = polygon[j];
+        if (a.y > p.y !== b.y > p.y &&
+            p.x < ((b.x - a.x) * (p.y - a.y)) / (b.y - a.y) + a.x) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+//# sourceMappingURL=pdfHatchFaces.js.map