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

package/lib/recognition/pdfHatchRecognition.js

@@ -0,0 +1,3781 @@
+/**
+ * Recovers pattern hatches from the loose stroke segments a PDF holds.
+ *
+ * CAD programs (AutoCAD included) write a pattern hatch to PDF as plain
+ * strokes that are already clipped to the hatch boundary, so an import sees
+ * thousands of short lines. This module finds groups of segments that form
+ * a regular pattern, matches them against the `acadiso.pat` library (or a
+ * user-defined single / double pattern), recovers a boundary and accepts
+ * the hatch only when re-drawing it reproduces the source segments.
+ *
+ * Pure data in, pure data out: entity construction happens in
+ * `AcApPdfImportConvertor`.
+ */
+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);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+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 { AcDbPredefinedAcadIsoPat } from '@mlightcad/data-model';
+import { tessellateHatchPattern } from '@mlightcad/pdf-renderer';
+import { acapPdfFaceArrangement, acapPdfFaceBoundaryIn, acapPdfFaceBoundaryParts, acapPdfShapePolyline } from './pdfHatchFaces';
+/**
+ * Recognizes pattern hatches among placed shape items.
+ *
+ * Only unfilled, undashed straight lines take part. Segments a hatch does
+ * not reproduce stay as they are, so a failed recognition changes nothing.
+ *
+ * @param items - Placed shapes in paint order (from `buildPdfImportShapes`).
+ * @param options - Tolerances and thresholds.
+ * @param clipPaths - Clip loops by {@link PdfImportShapeItem.clipPath} id,
+ * placed like the items. A clip around a hatch is a boundary candidate.
+ */
+export function acapPdfRecognizeHatches(items, options, clipPaths) {
+    var e_1, _a;
+    var opts = resolveOptions(options);
+    var hatches = [];
+    var consumed = new Set();
+    var library = patternSignatures(opts.patterns);
+    var closedShapes = collectClosedShapes(items);
+    var context = {
+        library: library,
+        closedShapes: closedShapes,
+        clipPaths: clipPaths,
+        items: items,
+        itemIndex: new ItemIndex(items),
+        opts: opts,
+        faces: new FaceCache()
+    };
+    var _loop_1 = function (group) {
+        var accept = function (region) {
+            var e_2, _a, e_3, _b;
+            var any = false;
+            try {
+                for (var _c = (e_2 = void 0, __values(recognizeRegion(region, group.all, context))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var found = _d.value;
+                    var minSegments = found.minSegments, hatch = __rest(found, ["minSegments"]);
+                    var kept = hatch.items.filter(function (index) { return !consumed.has(index); });
+                    if (kept.length < (minSegments !== null && minSegments !== void 0 ? minSegments : opts.minSegments))
+                        continue;
+                    try {
+                        for (var kept_1 = (e_3 = void 0, __values(kept)), kept_1_1 = kept_1.next(); !kept_1_1.done; kept_1_1 = kept_1.next()) {
+                            var index = kept_1_1.value;
+                            consumed.add(index);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (kept_1_1 && !kept_1_1.done && (_b = kept_1.return)) _b.call(kept_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    var first = items[kept[0]];
+                    hatches.push(__assign(__assign({}, hatch), { items: kept, layerName: first.layerName, color: first.color, lineWidth: first.lineWidth }));
+                    any = true;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return any;
+        };
+        var regions = findRegions(group.long, opts);
+        opts.trace('regions', {
+            candidates: group.all.length,
+            long: group.long.length,
+            sizes: regions.map(function (region) { return region.length; })
+        });
+        var queue = __spreadArray([], __read(regions), false);
+        var patchesFrom = regions.length;
+        for (var k = 0; k < queue.length; k++) {
+            var region = queue[k];
+            if (region.some(function (seg) { return consumed.has(seg.index); }))
+                continue;
+            if (accept(region))
+                continue;
+            // Hatches of one pattern spread over the drawing (AR-CONC in several
+            // rooms) form one region too large to bound; try each patch, once.
+            if (k < patchesFrom && region.length >= MIN_PATCH_REGION) {
+                var patches = spatialPatches(region, opts);
+                if (patches.length > 1) {
+                    queue.push.apply(queue, __spreadArray([], __read(patches), false));
+                    continue;
+                }
+            }
+            // Hatches of one colour that touch can end up in one region; peel
+            // off one regular run of parallel lines at a time.
+            var rest = region;
+            var _loop_2 = function (round) {
+                var run = dominantProgression(rest, opts);
+                // The whole region already failed as one piece.
+                if (!run || (round === 0 && run.length === region.length))
+                    return "break";
+                accept(run);
+                var taken = new Set(run);
+                rest = rest.filter(function (seg) { return !taken.has(seg) && !consumed.has(seg.index); });
+                if (rest.length < opts.minSegments)
+                    return "break";
+            };
+            for (var round = 0; round < MAX_SPLITS; round++) {
+                var state_1 = _loop_2(round);
+                if (state_1 === "break")
+                    break;
+            }
+        }
+    };
+    try {
+        for (var _b = __values(groupCandidates(items, opts.tolerance)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var group = _c.value;
+            _loop_1(group);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return { hatches: hatches, consumed: consumed };
+}
+var NO_TRACE = function () { };
+function resolveOptions(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var tolerance = options === null || options === void 0 ? void 0 : options.tolerance;
+    return {
+        tolerance: tolerance !== undefined && tolerance > 0 ? tolerance : 0.05,
+        minSegments: Math.max(2, (_a = options === null || options === void 0 ? void 0 : options.minSegments) !== null && _a !== void 0 ? _a : 8),
+        minLines: Math.max(2, (_b = options === null || options === void 0 ? void 0 : options.minLines) !== null && _b !== void 0 ? _b : 3),
+        minRecall: (_c = options === null || options === void 0 ? void 0 : options.minRecall) !== null && _c !== void 0 ? _c : 0.9,
+        minPrecision: (_d = options === null || options === void 0 ? void 0 : options.minPrecision) !== null && _d !== void 0 ? _d : 0.95,
+        patterns: (_e = options === null || options === void 0 ? void 0 : options.patterns) !== null && _e !== void 0 ? _e : AcDbPredefinedAcadIsoPat.patterns,
+        customPatterns: (_f = options === null || options === void 0 ? void 0 : options.customPatterns) !== null && _f !== void 0 ? _f : false,
+        faceBoundaries: (_g = options === null || options === void 0 ? void 0 : options.faceBoundaries) !== null && _g !== void 0 ? _g : true,
+        boundaries: (_h = options === null || options === void 0 ? void 0 : options.boundaries) !== null && _h !== void 0 ? _h : [],
+        trace: (_j = options === null || options === void 0 ? void 0 : options.trace) !== null && _j !== void 0 ? _j : NO_TRACE
+    };
+}
+/** Segments too short for a reliable direction (corner stubs). */
+var SHORT_FACTOR = 4;
+/** Angle gap that splits two direction clusters (radians). */
+var ANGLE_GAP = (0.5 * Math.PI) / 180;
+/** Most translation hypotheses scored per pattern. */
+var MAX_TRANSLATIONS = 400;
+/** Segments sampled to score a translation. */
+var SCORE_SAMPLE = 64;
+/** Lowest sample score worth a full verification. */
+var MIN_SCORE = 0.8;
+function groupCandidates(items, tolerance) {
+    var groups = new Map();
+    items.forEach(function (item, index) {
+        var _a, _b, _c;
+        var shape = item.shape;
+        if (shape.kind !== 'line' || item.filled || item.dashPattern)
+            return;
+        var dx = shape.end.x - shape.start.x;
+        var dy = shape.end.y - shape.start.y;
+        var len = Math.hypot(dx, dy);
+        if (!(len > tolerance * 0.1))
+            return;
+        var theta = Math.atan2(dy, dx);
+        if (theta < 0)
+            theta += Math.PI;
+        if (theta >= Math.PI)
+            theta -= Math.PI;
+        var seg = { index: index, a: shape.start, b: shape.end, len: len, theta: theta };
+        // A hatch has one layer, colour and pen width.
+        var key = "".concat((_a = item.layerName) !== null && _a !== void 0 ? _a : '', "|").concat((_b = item.color) !== null && _b !== void 0 ? _b : '', "|").concat(((_c = item.lineWidth) !== null && _c !== void 0 ? _c : 0).toFixed(3));
+        var group = groups.get(key);
+        if (!group) {
+            group = { long: [], all: [] };
+            groups.set(key, group);
+        }
+        group.all.push(seg);
+        if (len >= tolerance * SHORT_FACTOR)
+            group.long.push(seg);
+    });
+    return __spreadArray([], __read(groups.values()), false);
+}
+function clusterByAngle(segs) {
+    var e_4, _a;
+    var sorted = __spreadArray([], __read(segs), false).sort(function (p, q) { return p.theta - q.theta; });
+    var clusters = [];
+    try {
+        for (var sorted_1 = __values(sorted), sorted_1_1 = sorted_1.next(); !sorted_1_1.done; sorted_1_1 = sorted_1.next()) {
+            var seg = sorted_1_1.value;
+            var last = clusters[clusters.length - 1];
+            if (last && seg.theta - last[last.length - 1].theta <= ANGLE_GAP) {
+                last.push(seg);
+            }
+            else {
+                clusters.push([seg]);
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (sorted_1_1 && !sorted_1_1.done && (_a = sorted_1.return)) _a.call(sorted_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    // 0 and π are the same direction.
+    if (clusters.length > 1) {
+        var first = clusters[0];
+        var last = clusters[clusters.length - 1];
+        if (first[0].theta + Math.PI - last[last.length - 1].theta <= ANGLE_GAP) {
+            clusters[0] = __spreadArray(__spreadArray([], __read(last), false), __read(first), false);
+            clusters.pop();
+        }
+    }
+    return clusters.map(function (list) { return ({ theta: meanAngle(list), segs: list }); });
+}
+/** Length-weighted mean direction in `[0, π)` (doubled-angle average). */
+function meanAngle(segs) {
+    var e_5, _a;
+    var sx = 0;
+    var sy = 0;
+    try {
+        for (var segs_1 = __values(segs), segs_1_1 = segs_1.next(); !segs_1_1.done; segs_1_1 = segs_1.next()) {
+            var seg = segs_1_1.value;
+            sx += seg.len * Math.cos(2 * seg.theta);
+            sy += seg.len * Math.sin(2 * seg.theta);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (segs_1_1 && !segs_1_1.done && (_a = segs_1.return)) _a.call(segs_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    var theta = Math.atan2(sy, sx) / 2;
+    if (theta < 0)
+        theta += Math.PI;
+    return theta;
+}
+/** Groups parallel segments into lines by their perpendicular offset. */
+function linesOf(segs, theta, tol) {
+    var e_6, _a, e_7, _b;
+    var ux = Math.cos(theta);
+    var uy = Math.sin(theta);
+    var entries = segs.map(function (seg) {
+        var c = -uy * (seg.a.x + seg.b.x) * 0.5 + ux * (seg.a.y + seg.b.y) * 0.5;
+        var p = ux * seg.a.x + uy * seg.a.y;
+        var q = ux * seg.b.x + uy * seg.b.y;
+        return { seg: seg, c: c, s0: Math.min(p, q), s1: Math.max(p, q) };
+    });
+    entries.sort(function (p, q) { return p.c - q.c; });
+    var lines = [];
+    var sum = 0;
+    var lastC = -Infinity;
+    try {
+        for (var entries_1 = __values(entries), entries_1_1 = entries_1.next(); !entries_1_1.done; entries_1_1 = entries_1.next()) {
+            var entry = entries_1_1.value;
+            var last = lines[lines.length - 1];
+            var item = { seg: entry.seg, s0: entry.s0, s1: entry.s1 };
+            // Chain neighbours: PDF rounding spreads one line over a few offsets.
+            if (last && entry.c - lastC <= tol) {
+                last.segs.push(item);
+                sum += entry.c;
+                last.c = sum / last.segs.length;
+            }
+            else {
+                lines.push({ c: entry.c, segs: [item] });
+                sum = entry.c;
+            }
+            lastC = entry.c;
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) _a.call(entries_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    try {
+        for (var lines_1 = __values(lines), lines_1_1 = lines_1.next(); !lines_1_1.done; lines_1_1 = lines_1.next()) {
+            var line = lines_1_1.value;
+            line.segs.sort(function (p, q) { return p.s0 - q.s0; });
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (lines_1_1 && !lines_1_1.done && (_b = lines_1.return)) _b.call(lines_1);
+        }
+        finally { if (e_7) throw e_7.error; }
+    }
+    return lines;
+}
+var UnionFind = /** @class */ (function () {
+    function UnionFind(size) {
+        this.parent = Array.from({ length: size }, function (_, i) { return i; });
+    }
+    UnionFind.prototype.find = function (i) {
+        while (this.parent[i] !== i) {
+            this.parent[i] = this.parent[this.parent[i]];
+            i = this.parent[i];
+        }
+        return i;
+    };
+    UnionFind.prototype.union = function (a, b) {
+        var ra = this.find(a);
+        var rb = this.find(b);
+        if (ra !== rb)
+            this.parent[ra] = rb;
+    };
+    return UnionFind;
+}());
+/** Lines scanned past a segment for its nearest overlapping neighbour. */
+var NEIGHBOUR_SCAN = 256;
+/** Largest jump between neighbouring gaps that still links (gap ratio). */
+var GAP_RATIO = 2.5;
+/** Share of the shorter segment two neighbours must overlap to link. */
+var MIN_OVERLAP = 0.3;
+/** Segments shorter than this share of the median length do not link. */
+var SHORT_LINK = 0.25;
+/**
+ * Spatially connected runs of parallel segments within one cluster.
+ *
+ * Several hatches of one colour interleave in offset order, so each segment
+ * links to its nearest parallel neighbour whose extent overlaps, not to the
+ * next line overall. A link is kept only when its gap fits the gaps around
+ * it, so a lone parallel line far from a hatch does not join it.
+ */
+function clusterComponents(cluster, tol) {
+    var e_8, _a, e_9, _b, e_10, _c, e_11, _d, e_12, _e, e_13, _f, e_14, _g, e_15, _h;
+    var lines = linesOf(cluster.segs, cluster.theta, tol);
+    var rows = [];
+    var id = 0;
+    try {
+        for (var lines_2 = __values(lines), lines_2_1 = lines_2.next(); !lines_2_1.done; lines_2_1 = lines_2.next()) {
+            var line = lines_2_1.value;
+            rows.push(line.segs.map(function (e) { return (__assign(__assign({}, e), { id: id++ })); }));
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (lines_2_1 && !lines_2_1.done && (_a = lines_2.return)) _a.call(lines_2);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    // Gaps to the nearest neighbour that overlaps (same hatch) and to the
+    // nearest one that merely touches (staggered dashes such as bricks).
+    var fwd = new Array(id).fill(Infinity);
+    var bwd = new Array(id).fill(Infinity);
+    var touchFwd = new Array(id).fill(Infinity);
+    var touchBwd = new Array(id).fill(Infinity);
+    var links = [];
+    // Corner stubs overlap a neighbouring hatch as much as their own, so
+    // they do not link; verification picks them up afterwards.
+    var lengths = cluster.segs.map(function (seg) { return seg.len; }).sort(function (p, q) { return p - q; });
+    var minLinkLength = lengths[Math.floor(lengths.length / 2)] * SHORT_LINK;
+    var linkable = function (e) { return e.s1 - e.s0 >= minLinkLength; };
+    for (var i = 0; i < rows.length; i++) {
+        var _loop_3 = function (entry) {
+            var e_16, _r, e_17, _s;
+            if (!linkable(entry))
+                return "continue";
+            var touched = false;
+            for (var j = i + 1; j < rows.length && j - i <= NEIGHBOUR_SCAN; j++) {
+                var gap = lines[j].c - lines[i].c;
+                if (!touched) {
+                    var slack = gap * 2 + tol;
+                    var near = overlapping(rows[j], entry.s0 - slack, entry.s1 + slack);
+                    if (near.length > 0) {
+                        touched = true;
+                        touchFwd[entry.id] = gap;
+                        try {
+                            for (var near_1 = (e_16 = void 0, __values(near)), near_1_1 = near_1.next(); !near_1_1.done; near_1_1 = near_1.next()) {
+                                var hit = near_1_1.value;
+                                touchBwd[hit.id] = Math.min(touchBwd[hit.id], gap);
+                            }
+                        }
+                        catch (e_16_1) { e_16 = { error: e_16_1 }; }
+                        finally {
+                            try {
+                                if (near_1_1 && !near_1_1.done && (_r = near_1.return)) _r.call(near_1);
+                            }
+                            finally { if (e_16) throw e_16.error; }
+                        }
+                    }
+                }
+                // Lines of one hatch overlap along their length; lines of two
+                // hatches that only meet at a shared edge do not.
+                var hits = overlapping(rows[j], entry.s0, entry.s1).filter(function (hit) {
+                    return linkable(hit) &&
+                        Math.min(hit.s1, entry.s1) - Math.max(hit.s0, entry.s0) >=
+                            MIN_OVERLAP * Math.min(hit.s1 - hit.s0, entry.s1 - entry.s0);
+                });
+                if (hits.length === 0)
+                    continue;
+                fwd[entry.id] = gap;
+                try {
+                    for (var hits_1 = (e_17 = void 0, __values(hits)), hits_1_1 = hits_1.next(); !hits_1_1.done; hits_1_1 = hits_1.next()) {
+                        var hit = hits_1_1.value;
+                        bwd[hit.id] = Math.min(bwd[hit.id], gap);
+                        links.push({ a: entry.id, b: hit.id, gap: gap });
+                    }
+                }
+                catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                finally {
+                    try {
+                        if (hits_1_1 && !hits_1_1.done && (_s = hits_1.return)) _s.call(hits_1);
+                    }
+                    finally { if (e_17) throw e_17.error; }
+                }
+                break;
+            }
+        };
+        try {
+            for (var _j = (e_9 = void 0, __values(rows[i])), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var entry = _k.value;
+                _loop_3(entry);
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+    }
+    var uf = new UnionFind(id);
+    try {
+        for (var links_1 = __values(links), links_1_1 = links_1.next(); !links_1_1.done; links_1_1 = links_1.next()) {
+            var _l = links_1_1.value, a = _l.a, b = _l.b, gap = _l.gap;
+            var around = Math.min(bwd[a], fwd[b]);
+            if (!Number.isFinite(around) || gap <= around * GAP_RATIO)
+                uf.union(a, b);
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (links_1_1 && !links_1_1.done && (_c = links_1.return)) _c.call(links_1);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+    // Each stub joins the component of its nearest overlapping long segment:
+    // one attachment cannot bridge two hatches.
+    for (var i = 0; i < rows.length; i++) {
+        try {
+            for (var _m = (e_11 = void 0, __values(rows[i])), _o = _m.next(); !_o.done; _o = _m.next()) {
+                var entry = _o.value;
+                if (linkable(entry))
+                    continue;
+                var best = void 0;
+                try {
+                    for (var _p = (e_12 = void 0, __values([-1, 1])), _q = _p.next(); !_q.done; _q = _p.next()) {
+                        var dir = _q.value;
+                        for (var j = i + dir; j >= 0 && j < rows.length && Math.abs(j - i) <= NEIGHBOUR_SCAN; j += dir) {
+                            var gap = Math.abs(lines[j].c - lines[i].c);
+                            if (best && gap >= best.gap)
+                                break;
+                            var hit = overlapping(rows[j], entry.s0 - tol, entry.s1 + tol).find(linkable);
+                            if (hit) {
+                                best = { id: hit.id, gap: gap };
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                finally {
+                    try {
+                        if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
+                    }
+                    finally { if (e_12) throw e_12.error; }
+                }
+                if (best)
+                    uf.union(entry.id, best.id);
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+    }
+    var localGap = function (e) {
+        var own = Math.min(fwd[e.id], bwd[e.id]);
+        return Number.isFinite(own) ? own : Math.min(touchFwd[e.id], touchBwd[e.id]);
+    };
+    try {
+        // Dashes of one line belong together when their gaps match the spacing.
+        for (var rows_1 = __values(rows), rows_1_1 = rows_1.next(); !rows_1_1.done; rows_1_1 = rows_1.next()) {
+            var row = rows_1_1.value;
+            for (var k = 0; k + 1 < row.length; k++) {
+                var p = row[k];
+                var q = row[k + 1];
+                var local = Math.max(localGap(p), localGap(q));
+                if (Number.isFinite(local) && q.s0 - p.s1 <= local * GAP_RATIO + tol) {
+                    uf.union(p.id, q.id);
+                }
+            }
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (rows_1_1 && !rows_1_1.done && (_f = rows_1.return)) _f.call(rows_1);
+        }
+        finally { if (e_13) throw e_13.error; }
+    }
+    var byRoot = new Map();
+    try {
+        for (var rows_2 = __values(rows), rows_2_1 = rows_2.next(); !rows_2_1.done; rows_2_1 = rows_2.next()) {
+            var row = rows_2_1.value;
+            try {
+                for (var row_1 = (e_15 = void 0, __values(row)), row_1_1 = row_1.next(); !row_1_1.done; row_1_1 = row_1.next()) {
+                    var entry = row_1_1.value;
+                    var root = uf.find(entry.id);
+                    var list = byRoot.get(root);
+                    if (list)
+                        list.push(entry.seg);
+                    else
+                        byRoot.set(root, [entry.seg]);
+                }
+            }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+            finally {
+                try {
+                    if (row_1_1 && !row_1_1.done && (_h = row_1.return)) _h.call(row_1);
+                }
+                finally { if (e_15) throw e_15.error; }
+            }
+        }
+    }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
+    finally {
+        try {
+            if (rows_2_1 && !rows_2_1.done && (_g = rows_2.return)) _g.call(rows_2);
+        }
+        finally { if (e_14) throw e_14.error; }
+    }
+    return __spreadArray([], __read(byRoot.values()), false);
+}
+/** Entries of a row (sorted by `s0`) whose extent meets `[lo, hi]`. */
+function overlapping(row, lo, hi) {
+    var e_18, _a;
+    var out = [];
+    try {
+        for (var row_2 = __values(row), row_2_1 = row_2.next(); !row_2_1.done; row_2_1 = row_2.next()) {
+            var entry = row_2_1.value;
+            if (entry.s0 > hi)
+                break;
+            if (entry.s1 >= lo)
+                out.push(entry);
+        }
+    }
+    catch (e_18_1) { e_18 = { error: e_18_1 }; }
+    finally {
+        try {
+            if (row_2_1 && !row_2_1.done && (_a = row_2.return)) _a.call(row_2);
+        }
+        finally { if (e_18) throw e_18.error; }
+    }
+    return out;
+}
+function segsBox(segs) {
+    var e_19, _a, e_20, _b;
+    var box = {
+        minX: Infinity,
+        minY: Infinity,
+        maxX: -Infinity,
+        maxY: -Infinity
+    };
+    try {
+        for (var segs_2 = __values(segs), segs_2_1 = segs_2.next(); !segs_2_1.done; segs_2_1 = segs_2.next()) {
+            var seg = segs_2_1.value;
+            try {
+                for (var _c = (e_20 = void 0, __values([seg.a, seg.b])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var p = _d.value;
+                    if (p.x < box.minX)
+                        box.minX = p.x;
+                    if (p.y < box.minY)
+                        box.minY = p.y;
+                    if (p.x > box.maxX)
+                        box.maxX = p.x;
+                    if (p.y > box.maxY)
+                        box.maxY = p.y;
+                }
+            }
+            catch (e_20_1) { e_20 = { error: e_20_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_20) throw e_20.error; }
+            }
+        }
+    }
+    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+    finally {
+        try {
+            if (segs_2_1 && !segs_2_1.done && (_a = segs_2.return)) _a.call(segs_2);
+        }
+        finally { if (e_19) throw e_19.error; }
+    }
+    return box;
+}
+function boxArea(box, pad) {
+    return Math.max(box.maxX - box.minX, pad) * Math.max(box.maxY - box.minY, pad);
+}
+function overlapArea(p, q) {
+    var w = Math.min(p.maxX, q.maxX) - Math.max(p.minX, q.minX);
+    var h = Math.min(p.maxY, q.maxY) - Math.max(p.minY, q.minY);
+    return w > 0 && h > 0 ? w * h : 0;
+}
+/**
+ * Candidate hatch regions: components of every direction cluster, merged
+ * across directions when their boxes overlap (cross-hatch, bricks, ...).
+ */
+function findRegions(segs, opts) {
+    var e_21, _a, e_22, _b, e_23, _c;
+    if (segs.length < opts.minSegments)
+        return [];
+    var components = [];
+    try {
+        for (var _d = __values(clusterByAngle(segs)), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var cluster = _e.value;
+            if (cluster.segs.length < 2)
+                continue;
+            try {
+                for (var _f = (e_22 = void 0, __values(clusterComponents(cluster, opts.tolerance))), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var comp = _g.value;
+                    if (comp.length < 2)
+                        continue;
+                    components.push({ segs: comp, box: segsBox(comp) });
+                }
+            }
+            catch (e_22_1) { e_22 = { error: e_22_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_22) throw e_22.error; }
+            }
+        }
+    }
+    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_21) throw e_21.error; }
+    }
+    components.sort(function (p, q) { return q.segs.length - p.segs.length; });
+    var regions = [];
+    var _loop_4 = function (comp) {
+        var _h;
+        var pad = opts.tolerance;
+        var target = regions.find(function (region) {
+            var shared = overlapArea(region.box, comp.box);
+            return (shared >=
+                0.5 * Math.min(boxArea(region.box, pad), boxArea(comp.box, pad)));
+        });
+        if (target) {
+            (_h = target.segs).push.apply(_h, __spreadArray([], __read(comp.segs), false));
+            target.box = segsBox(target.segs);
+        }
+        else {
+            regions.push({ segs: __spreadArray([], __read(comp.segs), false), box: comp.box });
+        }
+    };
+    try {
+        for (var components_1 = __values(components), components_1_1 = components_1.next(); !components_1_1.done; components_1_1 = components_1.next()) {
+            var comp = components_1_1.value;
+            _loop_4(comp);
+        }
+    }
+    catch (e_23_1) { e_23 = { error: e_23_1 }; }
+    finally {
+        try {
+            if (components_1_1 && !components_1_1.done && (_c = components_1.return)) _c.call(components_1);
+        }
+        finally { if (e_23) throw e_23.error; }
+    }
+    return regions
+        .map(function (region) { return region.segs; })
+        .filter(function (region) { return region.length >= opts.minSegments; });
+}
+/** Smallest failed region worth splitting into patches. */
+var MIN_PATCH_REGION = 200;
+/** Most grid cells a region is split with. */
+var MAX_PATCH_CELLS = 4000000;
+/**
+ * Spatially separate patches of a region: strokes in the same or touching
+ * grid cells, one family spacing wide, belong together.
+ */
+function spatialPatches(region, opts) {
+    var e_24, _a, e_25, _b;
+    var families = measureFamilies(region, opts.tolerance);
+    var main = families[0];
+    if (!main)
+        return [];
+    // The spacing of the pattern's own families; sparse ones are line work.
+    var link = Math.max.apply(Math, __spreadArray([], __read(families
+        .filter(function (f) { return f.segs.length >= main.segs.length * 0.3; })
+        .map(function (f) { return f.period; })), false));
+    if (!(link > 0))
+        return [];
+    var box = segsBox(region);
+    var nx = Math.floor((box.maxX - box.minX) / link) + 1;
+    var ny = Math.floor((box.maxY - box.minY) / link) + 1;
+    if (nx * ny > MAX_PATCH_CELLS)
+        return [];
+    var cellOf = function (p) {
+        return Math.floor((p.x - box.minX) / link) * ny +
+            Math.floor((p.y - box.minY) / link);
+    };
+    // Every stroke joins the cells of its ends and midpoint; cells that hold
+    // strokes and touch join each other.
+    var first = new Map();
+    var uf = new UnionFind(region.length);
+    region.forEach(function (seg, i) {
+        var e_26, _a;
+        try {
+            for (var _b = __values([seg.a, seg.b, midpoint(seg)]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var p = _c.value;
+                var c = cellOf(p);
+                var j = first.get(c);
+                if (j === undefined)
+                    first.set(c, i);
+                else
+                    uf.union(i, j);
+            }
+        }
+        catch (e_26_1) { e_26 = { error: e_26_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_26) throw e_26.error; }
+        }
+    });
+    try {
+        for (var first_1 = __values(first), first_1_1 = first_1.next(); !first_1_1.done; first_1_1 = first_1.next()) {
+            var _c = __read(first_1_1.value, 2), c = _c[0], i = _c[1];
+            var cx = Math.floor(c / ny);
+            var cy = c % ny;
+            try {
+                for (var _d = (e_25 = void 0, __values([
+                    [1, -1],
+                    [1, 0],
+                    [1, 1],
+                    [0, 1]
+                ])), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var _f = __read(_e.value, 2), dx = _f[0], dy = _f[1];
+                    var x = cx + dx;
+                    var y = cy + dy;
+                    if (x >= nx || y < 0 || y >= ny)
+                        continue;
+                    var j = first.get(x * ny + y);
+                    if (j !== undefined)
+                        uf.union(i, j);
+                }
+            }
+            catch (e_25_1) { e_25 = { error: e_25_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+                }
+                finally { if (e_25) throw e_25.error; }
+            }
+        }
+    }
+    catch (e_24_1) { e_24 = { error: e_24_1 }; }
+    finally {
+        try {
+            if (first_1_1 && !first_1_1.done && (_a = first_1.return)) _a.call(first_1);
+        }
+        finally { if (e_24) throw e_24.error; }
+    }
+    var byRoot = new Map();
+    region.forEach(function (seg, i) {
+        var root = uf.find(i);
+        var list = byRoot.get(root);
+        if (list)
+            list.push(seg);
+        else
+            byRoot.set(root, [seg]);
+    });
+    return __spreadArray([], __read(byRoot.values()), false).filter(function (patch) { return patch.length >= opts.minSegments; });
+}
+/** Most runs peeled off one mixed region. */
+var MAX_SPLITS = 4;
+/**
+ * Segments of the largest direction cluster that lie on its most common
+ * arithmetic progression of offsets (one hatch out of several mixed ones).
+ */
+function dominantProgression(region, opts) {
+    var tol = opts.tolerance;
+    var cluster = clusterByAngle(region).sort(function (p, q) { return q.segs.length - p.segs.length; })[0];
+    if (!cluster || cluster.segs.length < opts.minSegments)
+        return undefined;
+    var lines = linesOf(cluster.segs, cluster.theta, tol);
+    var period = votedSpacing(lines, tol);
+    if (!period)
+        return undefined;
+    // Grow chains of lines one spacing apart (re-anchored at every line, so
+    // rounding does not drift) and keep the longest.
+    var reach = Math.max(tol * 2, period * 0.02);
+    var find = function (target) {
+        var lo = 0;
+        var hi = lines.length - 1;
+        while (lo <= hi) {
+            var mid = (lo + hi) >> 1;
+            if (lines[mid].c < target - reach)
+                lo = mid + 1;
+            else if (lines[mid].c > target + reach)
+                hi = mid - 1;
+            else
+                return mid;
+        }
+        return -1;
+    };
+    var walk = function (start, dir) {
+        var out = [];
+        var current = lines[start].c;
+        for (;;) {
+            var next = -1;
+            for (var m = 1; m <= 3 && next < 0; m++)
+                next = find(current + dir * m * period);
+            if (next < 0)
+                return out;
+            out.push(next);
+            current = lines[next].c;
+        }
+    };
+    var chain = [];
+    var step = Math.max(1, Math.floor(lines.length / 12));
+    for (var seed = 0; seed < lines.length; seed += step) {
+        var candidate = __spreadArray(__spreadArray(__spreadArray([], __read(walk(seed, -1).reverse()), false), [seed], false), __read(walk(seed, 1)), false);
+        if (candidate.length > chain.length)
+            chain = candidate;
+    }
+    if (chain.length < opts.minLines)
+        return undefined;
+    // Keep the pieces of each chain line that overlap the neighbouring chain
+    // lines: another hatch may share an offset somewhere else.
+    var rows = chain.map(function (i) { return lines[i].segs; });
+    var run = [];
+    rows.forEach(function (row, r) {
+        var e_27, _a;
+        var _b, _c;
+        var neighbours = __spreadArray(__spreadArray([], __read(((_b = rows[r - 1]) !== null && _b !== void 0 ? _b : [])), false), __read(((_c = rows[r + 1]) !== null && _c !== void 0 ? _c : [])), false);
+        var _loop_5 = function (entry) {
+            var len = entry.s1 - entry.s0;
+            var linked = neighbours.some(function (other) {
+                return Math.min(other.s1, entry.s1) - Math.max(other.s0, entry.s0) >=
+                    MIN_OVERLAP * Math.min(len, other.s1 - other.s0);
+            });
+            if (linked)
+                run.push(entry.seg);
+        };
+        try {
+            for (var row_3 = __values(row), row_3_1 = row_3.next(); !row_3_1.done; row_3_1 = row_3.next()) {
+                var entry = row_3_1.value;
+                _loop_5(entry);
+            }
+        }
+        catch (e_27_1) { e_27 = { error: e_27_1 }; }
+        finally {
+            try {
+                if (row_3_1 && !row_3_1.done && (_a = row_3.return)) _a.call(row_3);
+            }
+            finally { if (e_27) throw e_27.error; }
+        }
+    });
+    return run.length >= opts.minSegments ? run : undefined;
+}
+/** Most common spacing among nearby parallel lines (mean of its votes). */
+function votedSpacing(lines, tol) {
+    var e_28, _a;
+    var _b, _c, _d;
+    var bin = tol * 2;
+    var votes = new Map();
+    for (var i = 0; i < lines.length; i++) {
+        for (var j = i + 1; j < lines.length && j <= i + 6; j++) {
+            var d = lines[j].c - lines[i].c;
+            if (d <= bin)
+                continue;
+            var key = Math.round(d / bin);
+            var list = votes.get(key);
+            if (list)
+                list.push(d);
+            else
+                votes.set(key, [d]);
+        }
+    }
+    var best;
+    try {
+        for (var _e = __values(votes.keys()), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var key = _f.value;
+            // Neighbouring bins share one spacing split by rounding.
+            var merged = __spreadArray(__spreadArray(__spreadArray([], __read(((_b = votes.get(key - 1)) !== null && _b !== void 0 ? _b : [])), false), __read(((_c = votes.get(key)) !== null && _c !== void 0 ? _c : [])), false), __read(((_d = votes.get(key + 1)) !== null && _d !== void 0 ? _d : [])), false);
+            if (!best || merged.length > best.length)
+                best = merged;
+        }
+    }
+    catch (e_28_1) { e_28 = { error: e_28_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_28) throw e_28.error; }
+    }
+    if (!best || best.length === 0)
+        return undefined;
+    return best.reduce(function (sum, d) { return sum + d; }, 0) / best.length;
+}
+function measureFamilies(region, tol) {
+    var e_29, _a;
+    var box = segsBox(region);
+    var cx = (box.minX + box.maxX) / 2;
+    var cy = (box.minY + box.maxY) / 2;
+    // Segments near the centre are least likely clipped by the boundary.
+    var centerDistance = function (seg) {
+        return Math.hypot((seg.a.x + seg.b.x) / 2 - cx, (seg.a.y + seg.b.y) / 2 - cy);
+    };
+    var families = [];
+    try {
+        for (var _b = __values(clusterByAngle(region)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var cluster = _c.value;
+            var offsets = linesOf(cluster.segs, cluster.theta, tol).map(function (l) { return l.c; });
+            if (offsets.length < 2)
+                continue;
+            var period = fundamentalPeriod(offsets, tol);
+            if (!period)
+                continue;
+            families.push({
+                theta: cluster.theta,
+                segs: cluster.segs,
+                offsets: offsets,
+                period: period,
+                residues: countResidues(offsets, period, tol),
+                byCenter: cluster.segs
+                    .map(function (seg) { return ({ seg: seg, d: centerDistance(seg) }); })
+                    .sort(function (p, q) { return p.d - q.d; })
+                    .map(function (entry) { return entry.seg; })
+            });
+        }
+    }
+    catch (e_29_1) { e_29 = { error: e_29_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_29) throw e_29.error; }
+    }
+    return families.sort(function (p, q) { return q.segs.length - p.segs.length; });
+}
+/** Smallest period that maps most offsets onto other offsets. */
+function fundamentalPeriod(offsets, tol) {
+    var e_30, _a, e_31, _b;
+    var n = offsets.length;
+    var has = function (value) {
+        var lo = 0;
+        var hi = n - 1;
+        while (lo <= hi) {
+            var mid = (lo + hi) >> 1;
+            if (offsets[mid] < value - tol)
+                lo = mid + 1;
+            else if (offsets[mid] > value + tol)
+                hi = mid - 1;
+            else
+                return true;
+        }
+        return false;
+    };
+    var ref = Math.floor(n / 2);
+    var candidates = [];
+    for (var m = 1; m <= 8; m++) {
+        if (ref + m < n)
+            candidates.push(offsets[ref + m] - offsets[ref]);
+        if (ref - m >= 0)
+            candidates.push(offsets[ref] - offsets[ref - m]);
+    }
+    candidates.sort(function (p, q) { return p - q; });
+    var last = offsets[n - 1];
+    try {
+        for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+            var period = candidates_1_1.value;
+            if (!(period > tol * 2))
+                continue;
+            var tested = 0;
+            var hit = 0;
+            try {
+                for (var offsets_1 = (e_31 = void 0, __values(offsets)), offsets_1_1 = offsets_1.next(); !offsets_1_1.done; offsets_1_1 = offsets_1.next()) {
+                    var c = offsets_1_1.value;
+                    if (c + period > last + tol)
+                        break;
+                    tested++;
+                    if (has(c + period))
+                        hit++;
+                }
+            }
+            catch (e_31_1) { e_31 = { error: e_31_1 }; }
+            finally {
+                try {
+                    if (offsets_1_1 && !offsets_1_1.done && (_b = offsets_1.return)) _b.call(offsets_1);
+                }
+                finally { if (e_31) throw e_31.error; }
+            }
+            if (tested > 0 && hit / tested >= 0.8) {
+                return refinePeriod(offsets, period, tol);
+            }
+        }
+    }
+    catch (e_30_1) { e_30 = { error: e_30_1 }; }
+    finally {
+        try {
+            if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+        }
+        finally { if (e_30) throw e_30.error; }
+    }
+    return undefined;
+}
+/**
+ * Least-squares period over every line on the main residue: one gap is
+ * off by the PDF rounding, which would add up across a large hatch.
+ */
+function refinePeriod(offsets, period, tol) {
+    var e_32, _a;
+    var ref = offsets[Math.floor(offsets.length / 2)];
+    var n = 0;
+    var sk = 0;
+    var sc = 0;
+    var skk = 0;
+    var skc = 0;
+    try {
+        for (var offsets_2 = __values(offsets), offsets_2_1 = offsets_2.next(); !offsets_2_1.done; offsets_2_1 = offsets_2.next()) {
+            var c = offsets_2_1.value;
+            var k = Math.round((c - ref) / period);
+            if (Math.abs(c - ref - k * period) > tol * 2)
+                continue;
+            n++;
+            sk += k;
+            sc += c;
+            skk += k * k;
+            skc += k * c;
+        }
+    }
+    catch (e_32_1) { e_32 = { error: e_32_1 }; }
+    finally {
+        try {
+            if (offsets_2_1 && !offsets_2_1.done && (_a = offsets_2.return)) _a.call(offsets_2);
+        }
+        finally { if (e_32) throw e_32.error; }
+    }
+    var den = n * skk - sk * sk;
+    if (n < 3 || !(Math.abs(den) > 0))
+        return period;
+    var slope = (n * skc - sk * sc) / den;
+    return slope > 0 && Math.abs(slope - period) <= period * 0.05 ? slope : period;
+}
+function countResidues(offsets, period, tol) {
+    var e_33, _a;
+    var residues = offsets
+        .map(function (c) { return ((c % period) + period) % period; })
+        .sort(function (p, q) { return p - q; });
+    var count = 0;
+    var last = -Infinity;
+    try {
+        for (var residues_1 = __values(residues), residues_1_1 = residues_1.next(); !residues_1_1.done; residues_1_1 = residues_1.next()) {
+            var r = residues_1_1.value;
+            if (r - last > tol * 2) {
+                count++;
+                last = r;
+            }
+        }
+    }
+    catch (e_33_1) { e_33 = { error: e_33_1 }; }
+    finally {
+        try {
+            if (residues_1_1 && !residues_1_1.done && (_a = residues_1.return)) _a.call(residues_1);
+        }
+        finally { if (e_33) throw e_33.error; }
+    }
+    // The first and last residue may be one value split by the wrap.
+    if (count > 1 &&
+        residues[0] + period - residues[residues.length - 1] <= tol * 2) {
+        count--;
+    }
+    return Math.max(1, count);
+}
+var DEG = Math.PI / 180;
+function patternSignatures(patterns) {
+    var out = [];
+    patterns.forEach(function (pattern, order) {
+        var e_34, _a, e_35, _b;
+        // Dots (zero dashes) are allowed: PDF writers often drop them, and a
+        // hatch re-draws them as points that verification does not count.
+        if (pattern.lines.length === 0)
+            return;
+        var groups = [];
+        var _loop_6 = function (line) {
+            var angle = normalizeDirection(line.angle * DEG);
+            var group = groups.find(function (g) { return directionDelta(g.angle, angle) < 1e-4; });
+            if (group)
+                group.lines.push(line);
+            else
+                groups.push({ angle: angle, lines: [line] });
+        };
+        try {
+            for (var _c = __values(pattern.lines), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var line = _d.value;
+                _loop_6(line);
+            }
+        }
+        catch (e_34_1) { e_34 = { error: e_34_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_34) throw e_34.error; }
+        }
+        var signature = [];
+        var _loop_7 = function (group) {
+            var period = Math.max.apply(Math, __spreadArray([], __read(group.lines.map(function (l) { return Math.abs(l.deltaY); })), false));
+            if (!(period > 0))
+                return { value: void 0 };
+            // Perpendicular offset of each line's origin, in the group direction.
+            var nx = -Math.sin(group.angle);
+            var ny = Math.cos(group.angle);
+            var offsets = group.lines.map(function (l) {
+                var c = nx * l.originX + ny * l.originY;
+                return ((c % period) + period) % period;
+            });
+            var lattice = latticePeriod(offsets, period);
+            signature.push({
+                angle: group.angle,
+                period: lattice,
+                residues: countResidues(offsets.map(function (c) { return c % lattice; }), lattice, lattice * 1e-3),
+                dotsOnly: group.lines.every(function (l) { return isDotsOnly(l.dashes); })
+            });
+        };
+        try {
+            for (var groups_1 = __values(groups), groups_1_1 = groups_1.next(); !groups_1_1.done; groups_1_1 = groups_1.next()) {
+                var group = groups_1_1.value;
+                var state_2 = _loop_7(group);
+                if (typeof state_2 === "object")
+                    return state_2.value;
+            }
+        }
+        catch (e_35_1) { e_35 = { error: e_35_1 }; }
+        finally {
+            try {
+                if (groups_1_1 && !groups_1_1.done && (_b = groups_1.return)) _b.call(groups_1);
+            }
+            finally { if (e_35) throw e_35.error; }
+        }
+        // A pattern of dots only leaves nothing to match.
+        if (signature.every(function (g) { return g.dotsOnly; }))
+            return;
+        out.push({
+            pattern: pattern,
+            order: order,
+            groups: signature,
+            dashed: pattern.lines.some(function (line) { return line.dashes.length > 0; })
+        });
+    });
+    return out;
+}
+/**
+ * Smallest period of the line positions of one pattern group.
+ *
+ * Strokes are measured by where their lines lie, not by what the lines
+ * draw, so a group whose lines sit evenly within the pattern repeat (ANSI35:
+ * a solid and a dashed line half a repeat apart) is measured with a shorter
+ * period than the repeat. The signature must use the same period.
+ *
+ * @param offsets - Line offsets in `[0, period)`.
+ * @param period - Repeat of the group.
+ */
+function latticePeriod(offsets, period) {
+    var eps = period * 1e-3;
+    var has = function (value) {
+        return offsets.some(function (c) {
+            var d = Math.abs(c - value);
+            return Math.min(d, period - d) <= eps;
+        });
+    };
+    var _loop_8 = function (k) {
+        var step = period / k;
+        if (offsets.every(function (c) { return has((c + step) % period); }))
+            return { value: step };
+    };
+    for (var k = offsets.length; k > 1; k--) {
+        var state_3 = _loop_8(k);
+        if (typeof state_3 === "object")
+            return state_3.value;
+    }
+    return period;
+}
+/** A dash list that draws dots only (zeros and gaps, no dash). */
+function isDotsOnly(dashes) {
+    return dashes.length > 0 && dashes.every(function (d) { return d <= 0; });
+}
+function normalizeDirection(angle) {
+    var a = angle % Math.PI;
+    if (a < 0)
+        a += Math.PI;
+    return a;
+}
+/** Smallest difference between two directions (mod π). */
+function directionDelta(p, q) {
+    var d = Math.abs(normalizeDirection(p) - normalizeDirection(q));
+    return Math.min(d, Math.PI - d);
+}
+function relClose(p, q, rel, abs) {
+    return Math.abs(p - q) <= Math.max(rel * Math.max(p, q), abs);
+}
+function matchPattern(sig, families, tol, extent) {
+    var e_36, _a;
+    // Extra families are line work around the hatch (its boundary, other
+    // drawing lines); every pattern group that draws dashes still needs a
+    // family of its own. Dot-only groups leave no strokes to measure.
+    var required = sig.groups.filter(function (g) { return !g.dotsOnly; });
+    if (required.length > families.length)
+        return [];
+    var anchor = families[0];
+    var out = [];
+    var _loop_9 = function (group) {
+        var e_37, _b;
+        if (group.residues !== anchor.residues)
+            return "continue";
+        var scale = anchor.period / group.period;
+        var base = anchor.theta - group.angle;
+        // A dashed pattern turned half a turn is a different drawing.
+        var rotations = sig.dashed ? [base, base + Math.PI] : [base];
+        var _loop_10 = function (rotation) {
+            var e_38, _c;
+            var mapping = new Map();
+            var ok = true;
+            var _loop_11 = function (g) {
+                var family = families.find(function (f) {
+                    return directionDelta(f.theta, g.angle + rotation) < ANGLE_GAP &&
+                        f.residues === g.residues &&
+                        relClose(f.period, g.period * scale, 0.03, tol * 2);
+                });
+                if (!family || __spreadArray([], __read(mapping.values()), false).includes(family)) {
+                    ok = false;
+                    return "break";
+                }
+                mapping.set(g, family);
+            };
+            try {
+                for (var required_2 = (e_38 = void 0, __values(required)), required_2_1 = required_2.next(); !required_2_1.done; required_2_1 = required_2.next()) {
+                    var g = required_2_1.value;
+                    var state_4 = _loop_11(g);
+                    if (state_4 === "break")
+                        break;
+                }
+            }
+            catch (e_38_1) { e_38 = { error: e_38_1 }; }
+            finally {
+                try {
+                    if (required_2_1 && !required_2_1.done && (_c = required_2.return)) _c.call(required_2);
+                }
+                finally { if (e_38) throw e_38.error; }
+            }
+            if (!ok)
+                return "continue";
+            out.push({
+                name: sig.pattern.name,
+                order: sig.order,
+                rotation: snapAngle(rotation, tol, extent),
+                scale: snapScale(scale, tol, extent),
+                lines: sig.pattern.lines,
+                families: sig.pattern.lines.map(function (line) {
+                    var angle = normalizeDirection(line.angle * DEG);
+                    var g = sig.groups.find(function (gr) { return directionDelta(gr.angle, angle) < 1e-4; });
+                    // Dot-only lines have no family (see PatternGroup.dotsOnly).
+                    return mapping.get(g);
+                })
+            });
+        };
+        try {
+            for (var rotations_1 = (e_37 = void 0, __values(rotations)), rotations_1_1 = rotations_1.next(); !rotations_1_1.done; rotations_1_1 = rotations_1.next()) {
+                var rotation = rotations_1_1.value;
+                _loop_10(rotation);
+            }
+        }
+        catch (e_37_1) { e_37 = { error: e_37_1 }; }
+        finally {
+            try {
+                if (rotations_1_1 && !rotations_1_1.done && (_b = rotations_1.return)) _b.call(rotations_1);
+            }
+            finally { if (e_37) throw e_37.error; }
+        }
+    };
+    try {
+        for (var required_1 = __values(required), required_1_1 = required_1.next(); !required_1_1.done; required_1_1 = required_1.next()) {
+            var group = required_1_1.value;
+            _loop_9(group);
+        }
+    }
+    catch (e_36_1) { e_36 = { error: e_36_1 }; }
+    finally {
+        try {
+            if (required_1_1 && !required_1_1.done && (_a = required_1.return)) _a.call(required_1);
+        }
+        finally { if (e_36) throw e_36.error; }
+    }
+    return out;
+}
+/** Single or crossed parallel lines that no library pattern explains. */
+function userDefinedHypotheses(families, tol, extent) {
+    var first = families[0];
+    if (!first || first.residues !== 1)
+        return [];
+    var out = [];
+    // A perpendicular family of the same spacing makes it a cross-hatch.
+    var second = families.find(function (f) {
+        return f !== first &&
+            f.residues === 1 &&
+            Math.abs(directionDelta(first.theta, f.theta) - Math.PI / 2) <
+                ANGLE_GAP &&
+            relClose(first.period, f.period, 0.03, tol * 2);
+    });
+    if (second)
+        out.push(userDefinedPair(first, second, tol, extent));
+    out.push(userDefinedSingle(first, tol, extent));
+    return out;
+}
+function userDefinedLine(angle) {
+    return {
+        angle: angle,
+        originX: 0,
+        originY: 0,
+        deltaX: 0,
+        deltaY: 1,
+        dashes: [],
+        sourceLine: 0
+    };
+}
+function userDefinedSingle(first, tol, extent) {
+    return {
+        order: Infinity,
+        rotation: snapAngle(first.theta, tol, extent),
+        scale: first.period,
+        lines: [userDefinedLine(0)],
+        families: [first],
+        userDefined: { double: false, spacing: first.period }
+    };
+}
+function userDefinedPair(first, second, tol, extent) {
+    var lower = first.theta <= second.theta ? first : second;
+    var upper = lower === first ? second : first;
+    return {
+        order: Infinity,
+        rotation: snapAngle(lower.theta, tol, extent),
+        scale: lower.period,
+        lines: [userDefinedLine(0), userDefinedLine(90)],
+        families: [lower, upper],
+        userDefined: { double: true, spacing: lower.period }
+    };
+}
+/**
+ * Rounds to a whole or half degree when the turn moves no point of the
+ * region (size `extent`) by more than half the tolerance.
+ */
+function snapAngle(angle, tol, extent) {
+    var a = angle % (Math.PI * 2);
+    if (a < 0)
+        a += Math.PI * 2;
+    var half = Math.round((a / DEG) * 2) / 2;
+    if (Math.abs(half * DEG - a) * extent <= tol * 0.5)
+        a = (half % 360) * DEG;
+    return a;
+}
+/**
+ * Rounds to 2 or 3 significant digits when the change shifts no line of
+ * the region (size `extent`) by more than half the tolerance.
+ */
+function snapScale(scale, tol, extent) {
+    var e_39, _a;
+    try {
+        for (var _b = __values([2, 3]), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var digits = _c.value;
+            var rounded = Number(scale.toPrecision(digits));
+            if ((Math.abs(rounded - scale) / scale) * extent <= tol * 0.5) {
+                return rounded;
+            }
+        }
+    }
+    catch (e_39_1) { e_39 = { error: e_39_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_39) throw e_39.error; }
+    }
+    return scale;
+}
+/** World definition lines of a hypothesis, translated by `t`. */
+function definitionLines(hyp, t) {
+    var cr = Math.cos(hyp.rotation);
+    var sr = Math.sin(hyp.rotation);
+    return hyp.lines.map(function (line) {
+        var turn = Math.PI * 2;
+        var angle = (((line.angle * DEG + hyp.rotation) % turn) + turn) % turn;
+        var ox = line.originX * hyp.scale;
+        var oy = line.originY * hyp.scale;
+        var dx = line.deltaX * hyp.scale;
+        var dy = line.deltaY * hyp.scale;
+        var c = Math.cos(angle);
+        var s = Math.sin(angle);
+        return {
+            angle: angle,
+            base: { x: cr * ox - sr * oy + t.x, y: sr * ox + cr * oy + t.y },
+            offset: { x: c * dx - s * dy, y: s * dx + c * dy },
+            dashLengths: line.dashes.map(function (d) { return d * hyp.scale; })
+        };
+    });
+}
+function lineFrame(line) {
+    var e_40, _a;
+    var ux = Math.cos(line.angle);
+    var uy = Math.sin(line.angle);
+    // Offset in line space (matches tessellateHatchPattern).
+    var lx = ux * line.offset.x + uy * line.offset.y;
+    var ly = -uy * line.offset.x + ux * line.offset.y;
+    var spacing = Math.abs(ly) > 1e-9 ? ly : Math.hypot(lx, ly);
+    var dashes = [];
+    var cursor = 0;
+    try {
+        for (var _b = __values(line.dashLengths), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var value = _c.value;
+            if (value > 0)
+                dashes.push({ start: cursor, length: value });
+            cursor += Math.abs(value);
+        }
+    }
+    catch (e_40_1) { e_40 = { error: e_40_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_40) throw e_40.error; }
+    }
+    return {
+        ux: ux,
+        uy: uy,
+        spacing: spacing,
+        shiftPerLine: Math.abs(ly) > 1e-9 ? lx : 0,
+        period: cursor,
+        dashes: dashes,
+        dotsOnly: isDotsOnly(line.dashLengths)
+    };
+}
+/** True when `p` lies on a drawn part of `line` (within `tol`). */
+function onLine(p, line, frame, tol) {
+    var e_41, _a, e_42, _b;
+    var dx = p.x - line.base.x;
+    var dy = p.y - line.base.y;
+    var x = frame.ux * dx + frame.uy * dy;
+    var y = -frame.uy * dx + frame.ux * dy;
+    var k = Math.round(y / frame.spacing);
+    if (Math.abs(y - k * frame.spacing) > tol)
+        return false;
+    // Dots are not strokes; a dot-only line never explains one.
+    if (frame.dotsOnly)
+        return false;
+    if (frame.dashes.length === 0 || !(frame.period > 0))
+        return true;
+    var pos = x - k * frame.shiftPerLine;
+    var phase = ((pos % frame.period) + frame.period) % frame.period;
+    try {
+        for (var _c = __values(frame.dashes), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var dash = _d.value;
+            try {
+                for (var _e = (e_42 = void 0, __values([phase, phase - frame.period, phase + frame.period])), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var shifted = _f.value;
+                    if (shifted >= dash.start - tol &&
+                        shifted <= dash.start + dash.length + tol) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_42_1) { e_42 = { error: e_42_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_42) throw e_42.error; }
+            }
+        }
+    }
+    catch (e_41_1) { e_41 = { error: e_41_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_41) throw e_41.error; }
+    }
+    return false;
+}
+function segOnPattern(seg, lines, frames, tol) {
+    var mid = { x: (seg.a.x + seg.b.x) / 2, y: (seg.a.y + seg.b.y) / 2 };
+    for (var i = 0; i < lines.length; i++) {
+        if (directionDelta(lines[i].angle, seg.theta) > ANGLE_GAP)
+            continue;
+        if (onLine(mid, lines[i], frames[i], tol) &&
+            onLine(seg.a, lines[i], frames[i], tol) &&
+            onLine(seg.b, lines[i], frames[i], tol)) {
+            return true;
+        }
+    }
+    return false;
+}
+function sampleSegs(segs, count) {
+    if (segs.length <= count)
+        return __spreadArray([], __read(segs), false);
+    var step = segs.length / count;
+    var out = [];
+    for (var i = 0; i < count; i++)
+        out.push(segs[Math.floor(i * step)]);
+    return out;
+}
+/** Best translation for a hypothesis, with its sample score. */
+function estimateTranslation(hyp, region, tol) {
+    var e_43, _a, e_44, _b, e_45, _c;
+    var lines0 = definitionLines(hyp, { x: 0, y: 0 });
+    var halves = [];
+    var fulls = [];
+    lines0.forEach(function (line, i) {
+        var e_46, _a, e_47, _b;
+        var family = hyp.families[i];
+        // Dot-only lines left no strokes to place.
+        if (!family)
+            return;
+        var frame = lineFrame(line);
+        var nx = -frame.uy;
+        var ny = frame.ux;
+        var ordered = family.byCenter;
+        var startOf = function (seg) {
+            return frame.ux * seg.a.x + frame.uy * seg.a.y <=
+                frame.ux * seg.b.x + frame.uy * seg.b.y
+                ? seg.a
+                : seg.b;
+        };
+        // Put the segment on line k = 0: its perpendicular offset fixes n·t.
+        var perp = function (seg) {
+            return nx * ((seg.a.x + seg.b.x) / 2 - line.base.x) +
+                ny * ((seg.a.y + seg.b.y) / 2 - line.base.y);
+        };
+        if (frame.dashes.length === 0) {
+            try {
+                for (var _c = __values(ordered.slice(0, 3)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var seg = _d.value;
+                    halves.push({ nx: nx, ny: ny, value: perp(seg) });
+                }
+            }
+            catch (e_46_1) { e_46 = { error: e_46_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_46) throw e_46.error; }
+            }
+            return;
+        }
+        var _loop_12 = function (dash) {
+            var e_48, _g;
+            var matches = ordered
+                .filter(function (seg) { return Math.abs(seg.len - dash.length) <= tol * 2; })
+                .slice(0, 2);
+            try {
+                for (var matches_1 = (e_48 = void 0, __values(matches)), matches_1_1 = matches_1.next(); !matches_1_1.done; matches_1_1 = matches_1.next()) {
+                    var seg = matches_1_1.value;
+                    var start = startOf(seg);
+                    var along = frame.ux * (start.x - line.base.x) +
+                        frame.uy * (start.y - line.base.y) -
+                        dash.start;
+                    var across = perp(seg);
+                    fulls.push({
+                        x: frame.ux * along + nx * across,
+                        y: frame.uy * along + ny * across
+                    });
+                }
+            }
+            catch (e_48_1) { e_48 = { error: e_48_1 }; }
+            finally {
+                try {
+                    if (matches_1_1 && !matches_1_1.done && (_g = matches_1.return)) _g.call(matches_1);
+                }
+                finally { if (e_48) throw e_48.error; }
+            }
+        };
+        try {
+            // A whole dash also fixes where along the line the pattern starts.
+            for (var _e = __values(frame.dashes), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var dash = _f.value;
+                _loop_12(dash);
+            }
+        }
+        catch (e_47_1) { e_47 = { error: e_47_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_47) throw e_47.error; }
+        }
+    });
+    var candidates = __spreadArray([], __read(fulls), false);
+    for (var i = 0; i < halves.length && candidates.length < MAX_TRANSLATIONS; i++) {
+        for (var j = i + 1; j < halves.length; j++) {
+            var p = halves[i];
+            var q = halves[j];
+            var det = p.nx * q.ny - p.ny * q.nx;
+            if (Math.abs(det) < 1e-6)
+                continue;
+            candidates.push({
+                x: (p.value * q.ny - q.value * p.ny) / det,
+                y: (p.nx * q.value - q.nx * p.value) / det
+            });
+            if (candidates.length >= MAX_TRANSLATIONS)
+                break;
+        }
+    }
+    // Parallel continuous lines only: the along-line shift does not matter.
+    if (candidates.length === 0) {
+        try {
+            for (var halves_1 = __values(halves), halves_1_1 = halves_1.next(); !halves_1_1.done; halves_1_1 = halves_1.next()) {
+                var half = halves_1_1.value;
+                candidates.push({ x: half.nx * half.value, y: half.ny * half.value });
+            }
+        }
+        catch (e_43_1) { e_43 = { error: e_43_1 }; }
+        finally {
+            try {
+                if (halves_1_1 && !halves_1_1.done && (_a = halves_1.return)) _a.call(halves_1);
+            }
+            finally { if (e_43) throw e_43.error; }
+        }
+    }
+    var sample = sampleSegs(region, SCORE_SAMPLE);
+    var best;
+    try {
+        for (var _d = __values(candidates.slice(0, MAX_TRANSLATIONS)), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var t = _e.value;
+            var lines = definitionLines(hyp, t);
+            var frames_1 = lines.map(lineFrame);
+            var hit = 0;
+            try {
+                for (var sample_1 = (e_45 = void 0, __values(sample)), sample_1_1 = sample_1.next(); !sample_1_1.done; sample_1_1 = sample_1.next()) {
+                    var seg = sample_1_1.value;
+                    if (segOnPattern(seg, lines, frames_1, tol))
+                        hit++;
+                }
+            }
+            catch (e_45_1) { e_45 = { error: e_45_1 }; }
+            finally {
+                try {
+                    if (sample_1_1 && !sample_1_1.done && (_c = sample_1.return)) _c.call(sample_1);
+                }
+                finally { if (e_45) throw e_45.error; }
+            }
+            var score = hit / sample.length;
+            if (!best || score > best.score)
+                best = { t: t, score: score };
+            if (score === 1)
+                break;
+        }
+    }
+    catch (e_44_1) { e_44 = { error: e_44_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+        }
+        finally { if (e_44) throw e_44.error; }
+    }
+    return best;
+}
+/**
+ * Places every pattern line on its own family's strokes.
+ *
+ * One translation places all lines only when they share a lattice (ANSI
+ * and most patterns). Lines such as AR-CONC's each have their own spacing
+ * and stagger, so the strokes near the region fix each line separately.
+ * The hatch keeps explicit lines, so it draws the same either way. Dot-only
+ * lines left no strokes and follow the first placed line.
+ */
+function placeLinesSeparately(hyp, region, tol) {
+    if (hyp.custom || hyp.userDefined || hyp.lines.length < 2)
+        return undefined;
+    var lines0 = definitionLines(hyp, { x: 0, y: 0 });
+    var shifts = lines0.map(function (_, i) {
+        var _a;
+        var family = hyp.families[i];
+        if (!family)
+            return undefined;
+        var single = __assign(__assign({}, hyp), { lines: [hyp.lines[i]], families: [family] });
+        return (_a = estimateTranslation(single, family.segs, tol)) === null || _a === void 0 ? void 0 : _a.t;
+    });
+    var fallback = shifts.find(function (t) { return t !== undefined; });
+    if (!fallback)
+        return undefined;
+    var lines = lines0.map(function (line, i) {
+        var _a;
+        var t = (_a = shifts[i]) !== null && _a !== void 0 ? _a : fallback;
+        return __assign(__assign({}, line), { base: { x: line.base.x + t.x, y: line.base.y + t.y } });
+    });
+    var frames = lines.map(lineFrame);
+    var sample = sampleSegs(region, SCORE_SAMPLE);
+    if (sample.length === 0)
+        return undefined;
+    var hit = sample.filter(function (seg) { return segOnPattern(seg, lines, frames, tol); });
+    return { lines: lines, score: hit.length / sample.length };
+}
+/** Closed outlines that can bound a hatch. */
+function collectClosedShapes(items) {
+    var out = [];
+    items.forEach(function (item, index) {
+        var outline = shapeOutline(item.shape);
+        if (!outline || outline.length < 3)
+            return;
+        out.push({ index: index, shape: item.shape, outline: outline, box: pointsBox(outline) });
+    });
+    return out;
+}
+var CURVE_STEPS = 72;
+/** Polygon of a closed shape, or `undefined` for open shapes. */
+function shapeOutline(shape) {
+    switch (shape.kind) {
+        case 'circle': {
+            var out = [];
+            for (var i = 0; i < CURVE_STEPS; i++) {
+                var a = (i / CURVE_STEPS) * Math.PI * 2;
+                out.push({
+                    x: shape.center.x + shape.radius * Math.cos(a),
+                    y: shape.center.y + shape.radius * Math.sin(a)
+                });
+            }
+            return out;
+        }
+        case 'ellipse': {
+            if (Math.abs(shape.endAngle - shape.startAngle - Math.PI * 2) > 1e-9) {
+                return undefined;
+            }
+            var mx = shape.majorAxis.x;
+            var my = shape.majorAxis.y;
+            var out = [];
+            for (var i = 0; i < CURVE_STEPS; i++) {
+                var a = (i / CURVE_STEPS) * Math.PI * 2;
+                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': {
+            if (!shape.closed || shape.vertices.length < 2)
+                return undefined;
+            var v = shape.vertices;
+            var out = [];
+            for (var i = 0; i < v.length; i++) {
+                var a = v[i];
+                var b = v[(i + 1) % v.length];
+                out.push({ x: a.x, y: a.y });
+                if (Math.abs(a.bulge) > 1e-12) {
+                    // Sample the bulge arc between a and b.
+                    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 mx = (a.x + b.x) / 2;
+                    var my = (a.y + b.y) / 2;
+                    var h = radius * Math.cos(Math.abs(sweep) / 2) * Math.sign(a.bulge);
+                    var cx = mx - (h * (b.y - a.y)) / chord;
+                    var cy = my + (h * (b.x - a.x)) / chord;
+                    var start = Math.atan2(a.y - cy, a.x - cx);
+                    var steps = Math.max(2, Math.ceil((Math.abs(sweep) / Math.PI) * 18));
+                    for (var k = 1; k < steps; k++) {
+                        var t = start + (sweep * k) / steps;
+                        out.push({
+                            x: cx + radius * Math.cos(t),
+                            y: cy + radius * Math.sin(t)
+                        });
+                    }
+                }
+            }
+            return out.length >= 3 ? out : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function pointsBox(points) {
+    var e_49, _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;
+            if (p.x < box.minX)
+                box.minX = p.x;
+            if (p.y < box.minY)
+                box.minY = p.y;
+            if (p.x > box.maxX)
+                box.maxX = p.x;
+            if (p.y > box.maxY)
+                box.maxY = p.y;
+        }
+    }
+    catch (e_49_1) { e_49 = { error: e_49_1 }; }
+    finally {
+        try {
+            if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+        }
+        finally { if (e_49) throw e_49.error; }
+    }
+    return box;
+}
+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 onOutline(p, outline, tol) {
+    for (var i = 0; i < outline.length; i++) {
+        if (distanceToSegment(p, outline[i], outline[(i + 1) % outline.length]) <= tol) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Closed shapes on which the region's segments end. */
+function boundaryFromShapes(region, shapes, tol) {
+    var e_50, _a, e_51, _b, e_52, _c;
+    var _d;
+    var box = segsBox(region);
+    var near = shapes.filter(function (s) {
+        return s.box.maxX >= box.minX - tol &&
+            s.box.minX <= box.maxX + tol &&
+            s.box.maxY >= box.minY - tol &&
+            s.box.minY <= box.maxY + tol;
+    });
+    if (near.length === 0)
+        return undefined;
+    var hits = new Map();
+    try {
+        for (var _e = __values(sampleSegs(region, 400)), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var seg = _f.value;
+            try {
+                for (var _g = (e_51 = void 0, __values([seg.a, seg.b])), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var p = _h.value;
+                    try {
+                        for (var near_2 = (e_52 = void 0, __values(near)), near_2_1 = near_2.next(); !near_2_1.done; near_2_1 = near_2.next()) {
+                            var s = near_2_1.value;
+                            if (p.x < s.box.minX - tol ||
+                                p.x > s.box.maxX + tol ||
+                                p.y < s.box.minY - tol ||
+                                p.y > s.box.maxY + tol) {
+                                continue;
+                            }
+                            if (onOutline(p, s.outline, tol)) {
+                                hits.set(s, ((_d = hits.get(s)) !== null && _d !== void 0 ? _d : 0) + 1);
+                            }
+                        }
+                    }
+                    catch (e_52_1) { e_52 = { error: e_52_1 }; }
+                    finally {
+                        try {
+                            if (near_2_1 && !near_2_1.done && (_c = near_2.return)) _c.call(near_2);
+                        }
+                        finally { if (e_52) throw e_52.error; }
+                    }
+                }
+            }
+            catch (e_51_1) { e_51 = { error: e_51_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                }
+                finally { if (e_51) throw e_51.error; }
+            }
+        }
+    }
+    catch (e_50_1) { e_50 = { error: e_50_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_50) throw e_50.error; }
+    }
+    var chosen = __spreadArray([], __read(hits.entries()), false).filter(function (_a) {
+        var _b = __read(_a, 2), count = _b[1];
+        return count >= 3;
+    })
+        .map(function (_a) {
+        var _b = __read(_a, 1), shape = _b[0];
+        return shape;
+    });
+    if (chosen.length === 0)
+        return undefined;
+    var outer = pointsBox(chosen.flatMap(function (s) { return s.outline; }));
+    if (outer.minX > box.minX + tol ||
+        outer.minY > box.minY + tol ||
+        outer.maxX < box.maxX - tol ||
+        outer.maxY < box.maxY - tol) {
+        return undefined;
+    }
+    return {
+        shapes: chosen.map(function (s) { return s.shape; }),
+        polygons: chosen.map(function (s) { return s.outline; })
+    };
+}
+function polygonsToBoundary(polygons) {
+    return {
+        shapes: polygons.map(function (polygon) { return ({
+            kind: 'polyline',
+            vertices: polygon.map(function (p) { return ({ x: p.x, y: p.y, bulge: 0 }); }),
+            closed: true
+        }); }),
+        polygons: polygons
+    };
+}
+/** Clip path every segment of the region was painted under. */
+function boundaryFromClip(region, items, clipPaths) {
+    var _a, _b;
+    if (!clipPaths)
+        return undefined;
+    var id = (_a = items[region[0].index]) === null || _a === void 0 ? void 0 : _a.clipPath;
+    if (id === undefined)
+        return undefined;
+    if (region.some(function (seg) { var _a; return ((_a = items[seg.index]) === null || _a === void 0 ? void 0 : _a.clipPath) !== id; }))
+        return undefined;
+    var loops = (_b = clipPaths[id]) === null || _b === void 0 ? void 0 : _b.filter(function (loop) { return loop.length >= 3; });
+    if (!loops || loops.length === 0)
+        return undefined;
+    return polygonsToBoundary(loops.map(function (loop) { return __spreadArray([], __read(loop), false); }));
+}
+/**
+ * Boundary traced through the segment ends of one continuous family. Only
+ * for regions every line crosses once (no holes, convex in that direction).
+ */
+function boundaryFromEnds(hyp, lines, tol) {
+    var e_53, _a, e_54, _b;
+    var index = lines.findIndex(function (line) { return line.dashLengths.length === 0; });
+    if (index < 0)
+        return undefined;
+    var family = hyp.families[index];
+    if (!family)
+        return undefined;
+    var theta = normalizeDirection(lines[index].angle);
+    var rows = linesOf(family.segs, theta, tol);
+    if (rows.length < 2)
+        return undefined;
+    var ux = Math.cos(theta);
+    var uy = Math.sin(theta);
+    var starts = [];
+    var ends = [];
+    try {
+        for (var rows_3 = __values(rows), rows_3_1 = rows_3.next(); !rows_3_1.done; rows_3_1 = rows_3.next()) {
+            var row = rows_3_1.value;
+            // Touching collinear pieces form one crossing (segments are sorted).
+            var s0 = row.segs[0].s0;
+            var s1 = row.segs[0].s1;
+            try {
+                for (var _c = (e_54 = void 0, __values(row.segs.slice(1))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var entry = _d.value;
+                    if (entry.s0 > s1 + tol)
+                        return undefined;
+                    s1 = Math.max(s1, entry.s1);
+                }
+            }
+            catch (e_54_1) { e_54 = { error: e_54_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                }
+                finally { if (e_54) throw e_54.error; }
+            }
+            // Half a tolerance past the ends: lines of another family that run
+            // exactly along the edge then stay inside instead of on it.
+            var a = s0 - tol / 2;
+            var b = s1 + tol / 2;
+            starts.push({ x: ux * a - uy * row.c, y: uy * a + ux * row.c });
+            ends.push({ x: ux * b - uy * row.c, y: uy * b + ux * row.c });
+        }
+    }
+    catch (e_53_1) { e_53 = { error: e_53_1 }; }
+    finally {
+        try {
+            if (rows_3_1 && !rows_3_1.done && (_a = rows_3.return)) _a.call(rows_3);
+        }
+        finally { if (e_53) throw e_53.error; }
+    }
+    // Cap half a spacing past the outer lines so they are not on the edge
+    // (no line of this family lies in that strip).
+    var half = family.period / 2;
+    var nx = -uy;
+    var ny = ux;
+    var shift = function (p, k) { return ({
+        x: p.x + nx * half * k,
+        y: p.y + ny * half * k
+    }); };
+    var last = rows.length - 1;
+    var polygon = simplifyPolygon(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
+        shift(starts[0], -1)
+    ], __read(starts), false), [
+        shift(starts[last], 1),
+        shift(ends[last], 1)
+    ], false), __read(__spreadArray([], __read(ends), false).reverse()), false), [
+        shift(ends[0], -1)
+    ], false), tol * 0.1);
+    if (polygon.length < 3)
+        return undefined;
+    return polygonsToBoundary([polygon]);
+}
+/**
+ * The caller's boundaries around the region: those holding its strokes,
+ * plus the ones nested inside them (holes).
+ */
+function boundaryFromGiven(region, given) {
+    if (given.length === 0)
+        return undefined;
+    var mids = region.map(midpoint);
+    var polygons = given.filter(function (p) { return p.length >= 3; }).map(function (p) { return __spreadArray([], __read(p), false); });
+    var boxes = polygons.map(pointsBox);
+    var chosen = new Set();
+    polygons.forEach(function (polygon, i) {
+        if (mids.some(function (m) { return inBox(m, boxes[i]) && pointInPolygon(m, polygon); })) {
+            chosen.add(i);
+        }
+    });
+    if (chosen.size === 0)
+        return undefined;
+    polygons.forEach(function (polygon, i) {
+        if (chosen.has(i))
+            return;
+        var inside = __spreadArray([], __read(chosen), false).some(function (j) {
+            return boxInside(boxes[i], boxes[j]) && pointInPolygon(polygon[0], polygons[j]);
+        });
+        if (inside)
+            chosen.add(i);
+    });
+    var picked = __spreadArray([], __read(chosen), false).map(function (i) { return polygons[i]; });
+    var covered = mids.filter(function (m) { return picked.filter(function (polygon) { return pointInPolygon(m, polygon); }).length % 2 === 1; }).length;
+    if (covered < mids.length * 0.9)
+        return undefined;
+    return polygonsToBoundary(picked);
+}
+/** Most edge segments a face arrangement is built from. */
+var MAX_FACE_SEGMENTS = 20000;
+/**
+ * Face arrangements and sampled polylines, shared by the hypotheses and
+ * regions of one recognition run.
+ */
+var FaceCache = /** @class */ (function () {
+    function FaceCache() {
+        /** Recent arrangements by their sorted edge item indices. */
+        this.recent = [];
+        this.polylines = new Map();
+        this.groups = new WeakMap();
+    }
+    /** Candidate segments of a group by item index. */
+    FaceCache.prototype.segsOf = function (all) {
+        var map = this.groups.get(all);
+        if (!map) {
+            map = new Map(all.map(function (seg) { return [seg.index, seg]; }));
+            this.groups.set(all, map);
+        }
+        return map;
+    };
+    FaceCache.prototype.polyline = function (context, index) {
+        var polyline = this.polylines.get(index);
+        if (!polyline) {
+            polyline = acapPdfShapePolyline(context.items[index].shape, context.opts.tolerance * 0.25);
+            this.polylines.set(index, polyline);
+        }
+        return polyline;
+    };
+    /**
+     * The arrangement of the given items. Hypotheses of one region mostly
+     * leave the same strokes out, so the line work repeats.
+     */
+    FaceCache.prototype.arrangement = function (context, edges) {
+        var e_55, _a;
+        var hit = this.recent.find(function (entry) { return sameIndices(entry.edges, edges); });
+        if (hit)
+            return hit.arrangement;
+        var polylines = [];
+        try {
+            for (var edges_1 = __values(edges), edges_1_1 = edges_1.next(); !edges_1_1.done; edges_1_1 = edges_1.next()) {
+                var index = edges_1_1.value;
+                var polyline = this.polyline(context, index);
+                if (polyline.length >= 2)
+                    polylines.push(polyline);
+            }
+        }
+        catch (e_55_1) { e_55 = { error: e_55_1 }; }
+        finally {
+            try {
+                if (edges_1_1 && !edges_1_1.done && (_a = edges_1.return)) _a.call(edges_1);
+            }
+            finally { if (e_55) throw e_55.error; }
+        }
+        var arrangement = acapPdfFaceArrangement(polylines, {
+            tolerance: context.opts.tolerance,
+            maxSegments: MAX_FACE_SEGMENTS
+        });
+        this.recent.unshift({ edges: edges, arrangement: arrangement });
+        if (this.recent.length > 4)
+            this.recent.pop();
+        return arrangement;
+    };
+    return FaceCache;
+}());
+function sameIndices(p, q) {
+    if (p.length !== q.length)
+        return false;
+    for (var i = 0; i < p.length; i++)
+        if (p[i] !== q[i])
+            return false;
+    return true;
+}
+/**
+ * Faces of the line work around the region that hold its strokes. The
+ * strokes the pattern re-draws are left out of the line work.
+ */
+function boundaryFromFaces(region, all, lines, context) {
+    var e_56, _a, e_57, _b, e_58, _c;
+    var _d;
+    var tol = context.opts.tolerance;
+    var box = segsBox(region);
+    var frames = lines.map(lineFrame);
+    // The strokes of a sparse pattern (AR-CONC) can stop a whole repeat
+    // short of the boundary: reach one repeat past them.
+    var pad = tol * 4;
+    try {
+        for (var frames_2 = __values(frames), frames_2_1 = frames_2.next(); !frames_2_1.done; frames_2_1 = frames_2.next()) {
+            var frame = frames_2_1.value;
+            if (frame.dotsOnly)
+                continue;
+            pad = Math.max(pad, Math.abs(frame.spacing), frame.period);
+        }
+    }
+    catch (e_56_1) { e_56 = { error: e_56_1 }; }
+    finally {
+        try {
+            if (frames_2_1 && !frames_2_1.done && (_a = frames_2.return)) _a.call(frames_2);
+        }
+        finally { if (e_56) throw e_56.error; }
+    }
+    var query = {
+        minX: box.minX - pad,
+        minY: box.minY - pad,
+        maxX: box.maxX + pad,
+        maxY: box.maxY + pad
+    };
+    var near = context.itemIndex.query(query);
+    // Each item gives one segment or more: too much line work is refused
+    // before anything is sampled.
+    if (near.length - region.length > MAX_FACE_SEGMENTS)
+        return undefined;
+    var strokes = new Set();
+    try {
+        for (var region_1 = __values(region), region_1_1 = region_1.next(); !region_1_1.done; region_1_1 = region_1.next()) {
+            var seg = region_1_1.value;
+            strokes.add(seg.index);
+        }
+    }
+    catch (e_57_1) { e_57 = { error: e_57_1 }; }
+    finally {
+        try {
+            if (region_1_1 && !region_1_1.done && (_b = region_1.return)) _b.call(region_1);
+        }
+        finally { if (e_57) throw e_57.error; }
+    }
+    var candidates = context.faces.segsOf(all);
+    var edges = [];
+    try {
+        for (var near_3 = __values(near), near_3_1 = near_3.next(); !near_3_1.done; near_3_1 = near_3.next()) {
+            var index = near_3_1.value;
+            if (strokes.has(index))
+                continue;
+            var seg = candidates.get(index);
+            if (seg && segOnPattern(seg, lines, frames, tol))
+                continue;
+            edges.push(index);
+        }
+    }
+    catch (e_58_1) { e_58 = { error: e_58_1 }; }
+    finally {
+        try {
+            if (near_3_1 && !near_3_1.done && (_c = near_3.return)) _c.call(near_3);
+        }
+        finally { if (e_58) throw e_58.error; }
+    }
+    edges.sort(function (p, q) { return p - q; });
+    var arrangement = context.faces.arrangement(context, edges);
+    // Hatches of one pattern that touch are told apart by their strokes,
+    // which stop on the shared edge instead of crossing it.
+    var parts = arrangement
+        ? acapPdfFaceBoundaryParts(arrangement, region.map(midpoint), {
+            strokes: region.map(function (seg) { return [seg.a, seg.b]; })
+        })
+        : undefined;
+    context.opts.trace('faces', {
+        near: near.length,
+        strokes: strokes.size,
+        edges: edges.length,
+        arranged: !!arrangement,
+        parts: (_d = parts === null || parts === void 0 ? void 0 : parts.length) !== null && _d !== void 0 ? _d : 0
+    });
+    return parts === null || parts === void 0 ? void 0 : parts.map(polygonsToBoundary);
+}
+function midpoint(seg) {
+    return { x: (seg.a.x + seg.b.x) / 2, y: (seg.a.y + seg.b.y) / 2 };
+}
+function inBox(p, box) {
+    return (p.x >= box.minX && p.x <= box.maxX && p.y >= box.minY && p.y <= box.maxY);
+}
+function boxInside(inner, outer) {
+    return (inner.minX >= outer.minX &&
+        inner.minY >= outer.minY &&
+        inner.maxX <= outer.maxX &&
+        inner.maxY <= outer.maxY);
+}
+function boxTouches(p, q) {
+    return !(p.maxX < q.minX ||
+        q.maxX < p.minX ||
+        p.maxY < q.minY ||
+        q.maxY < p.minY);
+}
+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;
+}
+/** Uniform grid over the item boxes, built on first use. */
+var ItemIndex = /** @class */ (function () {
+    function ItemIndex(items) {
+        this.items = items;
+        this.stride = 1;
+        this.boxes = [];
+        this.originX = 0;
+        this.originY = 0;
+        this.size = 1;
+    }
+    /** Items whose box meets `box`. */
+    ItemIndex.prototype.query = function (box) {
+        var e_59, _a;
+        var _this = this;
+        var _b;
+        var cells = this.build();
+        // Cells lie in [0, stride - 1]; clamping keeps numeric keys unique.
+        var last = this.stride - 1;
+        var cellOf = function (v, origin) {
+            return Math.min(last, Math.max(0, Math.floor((v - origin) / _this.size)));
+        };
+        var x0 = cellOf(box.minX, this.originX);
+        var x1 = cellOf(box.maxX, this.originX);
+        var y0 = cellOf(box.minY, this.originY);
+        var y1 = cellOf(box.maxY, this.originY);
+        var out = new Set();
+        if ((x1 - x0 + 1) * (y1 - y0 + 1) > cells.size) {
+            // A query wider than the grid: scan the boxes instead.
+            this.boxes.forEach(function (b, i) {
+                if (boxTouches(b, box))
+                    out.add(i);
+            });
+            return __spreadArray([], __read(out), false);
+        }
+        for (var x = x0; x <= x1; x++) {
+            for (var y = y0; y <= y1; y++) {
+                try {
+                    for (var _c = (e_59 = void 0, __values((_b = cells.get(x * this.stride + y)) !== null && _b !== void 0 ? _b : [])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var i = _d.value;
+                        if (!out.has(i) && boxTouches(this.boxes[i], box))
+                            out.add(i);
+                    }
+                }
+                catch (e_59_1) { e_59 = { error: e_59_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_59) throw e_59.error; }
+                }
+            }
+        }
+        return __spreadArray([], __read(out), false);
+    };
+    ItemIndex.prototype.build = function () {
+        var e_60, _a;
+        var _this = this;
+        if (this.cells)
+            return this.cells;
+        this.boxes = this.items.map(function (item) { return shapeBox(item.shape); });
+        var minX = Infinity;
+        var minY = Infinity;
+        var maxX = -Infinity;
+        var maxY = -Infinity;
+        try {
+            for (var _b = __values(this.boxes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var b = _c.value;
+                if (!Number.isFinite(b.minX))
+                    continue;
+                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_60_1) { e_60 = { error: e_60_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_60) throw e_60.error; }
+        }
+        var cells = new Map();
+        this.cells = cells;
+        if (!Number.isFinite(minX))
+            return cells;
+        var n = Math.max(1, Math.ceil(Math.sqrt(this.boxes.length / 4)));
+        this.originX = minX;
+        this.originY = minY;
+        this.size = Math.max((maxX - minX) / n, (maxY - minY) / n, 1e-9);
+        this.stride = n + 2;
+        this.boxes.forEach(function (b, i) {
+            if (!Number.isFinite(b.minX))
+                return;
+            var x0 = Math.floor((b.minX - minX) / _this.size);
+            var x1 = Math.floor((b.maxX - minX) / _this.size);
+            var y0 = Math.floor((b.minY - minY) / _this.size);
+            var y1 = Math.floor((b.maxY - minY) / _this.size);
+            for (var x = x0; x <= x1; x++) {
+                for (var y = y0; y <= y1; y++) {
+                    var key = x * _this.stride + y;
+                    var list = cells.get(key);
+                    if (list)
+                        list.push(i);
+                    else
+                        cells.set(key, [i]);
+                }
+            }
+        });
+        return cells;
+    };
+    return ItemIndex;
+}());
+function shapeBox(shape) {
+    switch (shape.kind) {
+        case 'line':
+            return pointsBox([shape.start, shape.end]);
+        case 'circle':
+        case 'arc':
+            return {
+                minX: shape.center.x - shape.radius,
+                minY: shape.center.y - shape.radius,
+                maxX: shape.center.x + shape.radius,
+                maxY: shape.center.y + shape.radius
+            };
+        case 'ellipse': {
+            var r = Math.hypot(shape.majorAxis.x, shape.majorAxis.y);
+            return {
+                minX: shape.center.x - r,
+                minY: shape.center.y - r,
+                maxX: shape.center.x + r,
+                maxY: shape.center.y + r
+            };
+        }
+        case 'polyline': {
+            var box = pointsBox(shape.vertices);
+            // Bulges can bow past the vertices; half the box is a safe margin.
+            if (!shape.vertices.some(function (v) { return Math.abs(v.bulge) > 1e-12; }))
+                return box;
+            var pad = Math.max(box.maxX - box.minX, box.maxY - box.minY) / 2;
+            return {
+                minX: box.minX - pad,
+                minY: box.minY - pad,
+                maxX: box.maxX + pad,
+                maxY: box.maxY + pad
+            };
+        }
+        case 'spline':
+            return pointsBox(shape.controlPoints);
+    }
+}
+/**
+ * Drops vertices that lie on the line between their kept neighbours
+ * (one pass with a stack, then the seam where the ring closes).
+ */
+function simplifyPolygon(points, tol) {
+    var e_61, _a;
+    var out = [];
+    try {
+        for (var points_2 = __values(points), points_2_1 = points_2.next(); !points_2_1.done; points_2_1 = points_2.next()) {
+            var p = points_2_1.value;
+            while (out.length >= 2 &&
+                distanceToSegment(out[out.length - 1], out[out.length - 2], p) <= tol) {
+                out.pop();
+            }
+            out.push(p);
+        }
+    }
+    catch (e_61_1) { e_61 = { error: e_61_1 }; }
+    finally {
+        try {
+            if (points_2_1 && !points_2_1.done && (_a = points_2.return)) _a.call(points_2);
+        }
+        finally { if (e_61) throw e_61.error; }
+    }
+    var changed = true;
+    while (changed && out.length > 3) {
+        changed = false;
+        var n = out.length;
+        if (distanceToSegment(out[n - 1], out[n - 2], out[0]) <= tol) {
+            out.pop();
+            changed = true;
+        }
+        else if (distanceToSegment(out[0], out[n - 1], out[1]) <= tol) {
+            out.shift();
+            changed = true;
+        }
+    }
+    return out;
+}
+/**
+ * Every pattern line the segment lies on (both ends within `tol`), keyed by
+ * definition line and line index, with its extent along that line.
+ */
+function patternSpans(a, b, lines, frames, tol) {
+    var out = [];
+    for (var i = 0; i < lines.length; i++) {
+        var base = lines[i].base;
+        var _a = frames[i], ux = _a.ux, uy = _a.uy, spacing = _a.spacing;
+        var ya = -uy * (a.x - base.x) + ux * (a.y - base.y);
+        var yb = -uy * (b.x - base.x) + ux * (b.y - base.y);
+        var k = Math.round((ya + yb) / 2 / spacing);
+        if (Math.abs(ya - k * spacing) > tol || Math.abs(yb - k * spacing) > tol) {
+            continue;
+        }
+        var xa = ux * (a.x - base.x) + uy * (a.y - base.y);
+        var xb = ux * (b.x - base.x) + uy * (b.y - base.y);
+        out.push({ key: "".concat(i, ":").concat(k), s0: Math.min(xa, xb), s1: Math.max(xa, xb) });
+    }
+    return out;
+}
+/** Merged intervals per pattern line, for coverage queries. */
+var SpanIndex = /** @class */ (function () {
+    function SpanIndex(spans, gap) {
+        var e_62, _a, e_63, _b, e_64, _c;
+        this.merged = new Map();
+        var byKey = new Map();
+        try {
+            for (var spans_1 = __values(spans), spans_1_1 = spans_1.next(); !spans_1_1.done; spans_1_1 = spans_1.next()) {
+                var span = spans_1_1.value;
+                var list = byKey.get(span.key);
+                if (list)
+                    list.push([span.s0, span.s1]);
+                else
+                    byKey.set(span.key, [[span.s0, span.s1]]);
+            }
+        }
+        catch (e_62_1) { e_62 = { error: e_62_1 }; }
+        finally {
+            try {
+                if (spans_1_1 && !spans_1_1.done && (_a = spans_1.return)) _a.call(spans_1);
+            }
+            finally { if (e_62) throw e_62.error; }
+        }
+        try {
+            for (var byKey_1 = __values(byKey), byKey_1_1 = byKey_1.next(); !byKey_1_1.done; byKey_1_1 = byKey_1.next()) {
+                var _d = __read(byKey_1_1.value, 2), key = _d[0], list = _d[1];
+                list.sort(function (p, q) { return p[0] - q[0]; });
+                var merged = [];
+                try {
+                    for (var list_1 = (e_64 = void 0, __values(list)), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+                        var _e = __read(list_1_1.value, 2), s0 = _e[0], s1 = _e[1];
+                        var last = merged[merged.length - 1];
+                        if (last && s0 <= last[1] + gap)
+                            last[1] = Math.max(last[1], s1);
+                        else
+                            merged.push([s0, s1]);
+                    }
+                }
+                catch (e_64_1) { e_64 = { error: e_64_1 }; }
+                finally {
+                    try {
+                        if (list_1_1 && !list_1_1.done && (_c = list_1.return)) _c.call(list_1);
+                    }
+                    finally { if (e_64) throw e_64.error; }
+                }
+                this.merged.set(key, merged);
+            }
+        }
+        catch (e_63_1) { e_63 = { error: e_63_1 }; }
+        finally {
+            try {
+                if (byKey_1_1 && !byKey_1_1.done && (_b = byKey_1.return)) _b.call(byKey_1);
+            }
+            finally { if (e_63) throw e_63.error; }
+        }
+    }
+    /** Length of `span` the indexed intervals cover. */
+    SpanIndex.prototype.covered = function (span) {
+        var list = this.merged.get(span.key);
+        if (!list)
+            return 0;
+        // First interval that may end after s0.
+        var lo = 0;
+        var hi = list.length;
+        while (lo < hi) {
+            var mid = (lo + hi) >> 1;
+            if (list[mid][1] < span.s0)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        var total = 0;
+        for (var i = lo; i < list.length && list[i][0] < span.s1; i++) {
+            total += Math.max(0, Math.min(list[i][1], span.s1) - Math.max(list[i][0], span.s0));
+        }
+        return total;
+    };
+    /** Best covered length over the spans of one segment. */
+    SpanIndex.prototype.coveredBest = function (spans) {
+        var e_65, _a;
+        var best = 0;
+        try {
+            for (var spans_2 = __values(spans), spans_2_1 = spans_2.next(); !spans_2_1.done; spans_2_1 = spans_2.next()) {
+                var span = spans_2_1.value;
+                best = Math.max(best, this.covered(span));
+            }
+        }
+        catch (e_65_1) { e_65 = { error: e_65_1 }; }
+        finally {
+            try {
+                if (spans_2_1 && !spans_2_1.done && (_a = spans_2.return)) _a.call(spans_2);
+            }
+            finally { if (e_65) throw e_65.error; }
+        }
+        return best;
+    };
+    return SpanIndex;
+}());
+function verify(lines, boundary, region, all, opts) {
+    var tol = opts.tolerance;
+    var generated = generateStrokes(lines, boundary.polygons, tol);
+    if (generated.length === 0 || generated.length > region.length * 4 + 100) {
+        opts.trace('verify', { generated: generated.length, region: region.length });
+        return undefined;
+    }
+    var match = measureMatch(lines, generated, region, all, tol);
+    if (match.precision < opts.minPrecision) {
+        opts.trace('verify', { precision: match.precision });
+        return undefined;
+    }
+    opts.trace('verify', { precision: match.precision, recall: match.recall });
+    if (match.recall < opts.minRecall)
+        return undefined;
+    return { matched: match.items };
+}
+/** Strokes a hatch draws inside `polygons`, without hairline pieces. */
+function generateStrokes(lines, polygons, tol) {
+    return tessellateHatchPattern(polygons, lines.map(function (line) { return (__assign(__assign({}, line), { base: __assign({}, line.base), offset: __assign({}, line.offset) })); }), 0).filter(function (seg) { return Math.hypot(seg[1].x - seg[0].x, seg[1].y - seg[0].y) > tol; });
+}
+/**
+ * How well `generated` (the strokes a hatch draws) and `region` (the source
+ * strokes) cover each other, and which segments of `all` the hatch re-draws
+ * completely.
+ */
+function measureMatch(lines, generated, region, all, tol) {
+    var e_66, _a;
+    if (generated.length === 0 || region.length === 0) {
+        return { precision: 0, recall: 0, items: [] };
+    }
+    var frames = lines.map(lineFrame);
+    var spansOf = function (a, b) {
+        return patternSpans(a, b, lines, frames, tol);
+    };
+    var genSpans = generated.map(function (_a) {
+        var _b = __read(_a, 2), a = _b[0], b = _b[1];
+        return spansOf(a, b);
+    });
+    var regionSpans = region.map(function (seg) { return spansOf(seg.a, seg.b); });
+    // PDF rounding leaves hairline gaps between pieces of one line.
+    var sourceIndex = new SpanIndex(regionSpans.flat(), tol);
+    var genIndex = new SpanIndex(genSpans.flat(), tol);
+    var genLength = 0;
+    var genCovered = 0;
+    generated.forEach(function (_a, i) {
+        var _b = __read(_a, 2), a = _b[0], b = _b[1];
+        var len = Math.hypot(b.x - a.x, b.y - a.y);
+        genLength += len;
+        genCovered += Math.min(len, sourceIndex.coveredBest(genSpans[i]));
+    });
+    var precision = genLength > 0 ? genCovered / genLength : 0;
+    var srcLength = 0;
+    var srcCovered = 0;
+    region.forEach(function (seg, i) {
+        srcLength += seg.len;
+        srcCovered += Math.min(seg.len, genIndex.coveredBest(regionSpans[i]));
+    });
+    var recall = srcLength > 0 ? srcCovered / srcLength : 0;
+    // Every segment the hatch re-draws goes, short corner stubs included.
+    var box = segsBox(region);
+    var pad = tol * 2;
+    var matched = [];
+    try {
+        for (var all_1 = __values(all), all_1_1 = all_1.next(); !all_1_1.done; all_1_1 = all_1.next()) {
+            var seg = all_1_1.value;
+            if (Math.max(seg.a.x, seg.b.x) < box.minX - pad ||
+                Math.min(seg.a.x, seg.b.x) > box.maxX + pad ||
+                Math.max(seg.a.y, seg.b.y) < box.minY - pad ||
+                Math.min(seg.a.y, seg.b.y) > box.maxY + pad) {
+                continue;
+            }
+            var covered = genIndex.coveredBest(spansOf(seg.a, seg.b));
+            if (covered >= seg.len - tol * 2)
+                matched.push(seg.index);
+        }
+    }
+    catch (e_66_1) { e_66 = { error: e_66_1 }; }
+    finally {
+        try {
+            if (all_1_1 && !all_1_1.done && (_a = all_1.return)) _a.call(all_1);
+        }
+        finally { if (e_66) throw e_66.error; }
+    }
+    return { precision: precision, recall: recall, items: matched.sort(function (p, q) { return p - q; }) };
+}
+/** Fewest strokes of a part split off a recognized region. */
+var MIN_PART_SEGMENTS = 3;
+/** Library hypotheses tried with a boundary, best score first. */
+var MAX_VERIFIED = 8;
+function recognizeRegion(region, all, context) {
+    var e_67, _a, e_68, _b, e_69, _c;
+    var _d, _e;
+    var opts = context.opts;
+    var tol = opts.tolerance;
+    var families = measureFamilies(region, tol);
+    opts.trace('families', {
+        segments: region.length,
+        families: families.map(function (f) { return ({
+            angle: f.theta / DEG,
+            lines: f.offsets.length,
+            period: f.period,
+            residues: f.residues,
+            segments: f.segs.length
+        }); })
+    });
+    if (families.length === 0)
+        return [];
+    if (families[0].offsets.length < opts.minLines)
+        return [];
+    var regionBox = segsBox(region);
+    var extent = Math.hypot(regionBox.maxX - regionBox.minX, regionBox.maxY - regionBox.minY);
+    var hypotheses = [];
+    try {
+        for (var _f = __values(context.library), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var sig = _g.value;
+            hypotheses.push.apply(hypotheses, __spreadArray([], __read(matchPattern(sig, families, tol, extent)), false));
+        }
+    }
+    catch (e_67_1) { e_67 = { error: e_67_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+        }
+        finally { if (e_67) throw e_67.error; }
+    }
+    hypotheses.push.apply(hypotheses, __spreadArray([], __read(userDefinedHypotheses(families, tol, extent)), false));
+    var scored = [];
+    try {
+        for (var hypotheses_1 = __values(hypotheses), hypotheses_1_1 = hypotheses_1.next(); !hypotheses_1_1.done; hypotheses_1_1 = hypotheses_1.next()) {
+            var hyp = hypotheses_1_1.value;
+            var segs = hypothesisSegs(hyp);
+            var best = estimateTranslation(hyp, segs, tol);
+            if (best && best.score >= MIN_SCORE) {
+                scored.push(__assign({ hyp: hyp, segs: segs }, best));
+                continue;
+            }
+            var placed = placeLinesSeparately(hyp, segs, tol);
+            if (placed && placed.score >= MIN_SCORE) {
+                scored.push(__assign({ hyp: hyp, segs: segs, t: { x: 0, y: 0 } }, placed));
+            }
+        }
+    }
+    catch (e_68_1) { e_68 = { error: e_68_1 }; }
+    finally {
+        try {
+            if (hypotheses_1_1 && !hypotheses_1_1.done && (_b = hypotheses_1.return)) _b.call(hypotheses_1);
+        }
+        finally { if (e_68) throw e_68.error; }
+    }
+    scored.sort(function (p, q) { return compareScored(p, q, region.length); });
+    var tries = scored.slice(0, MAX_VERIFIED);
+    // A measured pattern is the last resort, tried after every library and
+    // user-defined candidate.
+    var custom = opts.customPatterns
+        ? customHypothesis(families, opts)
+        : undefined;
+    if (custom) {
+        var segs = hypothesisSegs(custom);
+        var lines_3 = definitionLines(custom, { x: 0, y: 0 });
+        var frames_3 = lines_3.map(lineFrame);
+        var sample = sampleSegs(segs, SCORE_SAMPLE);
+        var hit = sample.filter(function (seg) { return segOnPattern(seg, lines_3, frames_3, tol); });
+        tries.push({
+            hyp: custom,
+            segs: segs,
+            t: { x: 0, y: 0 },
+            score: hit.length / sample.length
+        });
+    }
+    opts.trace('hypotheses', {
+        tried: hypotheses.map(function (h) { var _a; return (_a = h.name) !== null && _a !== void 0 ? _a : 'USER'; }),
+        scored: tries.map(function (s) {
+            var _a;
+            return ({
+                name: (_a = s.hyp.name) !== null && _a !== void 0 ? _a : (s.hyp.custom ? 'CUSTOM' : 'USER'),
+                score: s.score,
+                scale: s.hyp.scale,
+                angle: s.hyp.rotation / DEG
+            });
+        })
+    });
+    var _loop_13 = function (entry) {
+        var e_70, _h, e_71, _j;
+        var hyp = entry.hyp, t = entry.t, segs = entry.segs;
+        var lines = (_d = entry.lines) !== null && _d !== void 0 ? _d : definitionLines(hyp, t);
+        var boundaries = [
+            function () { return boundaryFromGiven(segs, opts.boundaries); },
+            function () { return boundaryFromShapes(segs, context.closedShapes, tol); },
+            function () { return boundaryFromClip(segs, context.items, context.clipPaths); },
+            function () { return boundaryFromEnds(hyp, lines, tol); },
+            function () {
+                return opts.faceBoundaries
+                    ? boundaryFromFaces(segs, all, lines, context)
+                    : undefined;
+            }
+        ];
+        try {
+            for (var _k = (e_70 = void 0, __values(boundaries.entries())), _l = _k.next(); !_l.done; _l = _k.next()) {
+                var _m = __read(_l.value, 2), source = _m[0], make = _m[1];
+                var made = make();
+                opts.trace('boundary', {
+                    name: (_e = hyp.name) !== null && _e !== void 0 ? _e : (hyp.custom ? 'CUSTOM' : 'USER'),
+                    source: BOUNDARY_SOURCES[source],
+                    found: !!made
+                });
+                if (!made)
+                    continue;
+                var parts = Array.isArray(made) ? made : [made];
+                var found = [];
+                try {
+                    for (var parts_1 = (e_71 = void 0, __values(parts)), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+                        var boundary = parts_1_1.value;
+                        // A part holds the strokes inside its own outline.
+                        var own = parts.length > 1 ? segsInside(segs, boundary.polygons) : segs;
+                        // A piece split off a recognized region may be small (a corner
+                        // square); the region as a whole already showed the pattern.
+                        var minimum = parts.length > 1 ? MIN_PART_SEGMENTS : opts.minSegments;
+                        if (own.length < minimum)
+                            continue;
+                        var verified = verify(lines, boundary, own, all, opts);
+                        if (!verified)
+                            continue;
+                        found.push({
+                            boundary: boundary.shapes,
+                            pattern: hatchPattern(hyp),
+                            definitionLines: lines,
+                            items: verified.matched,
+                            minSegments: minimum
+                        });
+                    }
+                }
+                catch (e_71_1) { e_71 = { error: e_71_1 }; }
+                finally {
+                    try {
+                        if (parts_1_1 && !parts_1_1.done && (_j = parts_1.return)) _j.call(parts_1);
+                    }
+                    finally { if (e_71) throw e_71.error; }
+                }
+                if (parts.length > 1 && found.length < parts.length) {
+                    // Some part did not verify on its own (a split where the strokes
+                    // only paused): the whole may still be one hatch.
+                    var whole = {
+                        shapes: parts.flatMap(function (part) { return part.shapes; }),
+                        polygons: parts.flatMap(function (part) { return part.polygons; })
+                    };
+                    var verified = verify(lines, whole, segs, all, opts);
+                    var split = found.reduce(function (sum, hatch) { return sum + hatch.items.length; }, 0);
+                    if (verified && verified.matched.length > split) {
+                        return { value: [
+                                {
+                                    boundary: whole.shapes,
+                                    pattern: hatchPattern(hyp),
+                                    definitionLines: lines,
+                                    items: verified.matched
+                                }
+                            ] };
+                    }
+                }
+                if (found.length > 0)
+                    return { value: found };
+            }
+        }
+        catch (e_70_1) { e_70 = { error: e_70_1 }; }
+        finally {
+            try {
+                if (_l && !_l.done && (_h = _k.return)) _h.call(_k);
+            }
+            finally { if (e_70) throw e_70.error; }
+        }
+    };
+    try {
+        for (var tries_1 = __values(tries), tries_1_1 = tries_1.next(); !tries_1_1.done; tries_1_1 = tries_1.next()) {
+            var entry = tries_1_1.value;
+            var state_5 = _loop_13(entry);
+            if (typeof state_5 === "object")
+                return state_5.value;
+        }
+    }
+    catch (e_69_1) { e_69 = { error: e_69_1 }; }
+    finally {
+        try {
+            if (tries_1_1 && !tries_1_1.done && (_c = tries_1.return)) _c.call(tries_1);
+        }
+        finally { if (e_69) throw e_69.error; }
+    }
+    return [];
+}
+/** Segments whose midpoint lies inside `polygons` (even-odd). */
+function segsInside(segs, polygons) {
+    var boxes = polygons.map(pointsBox);
+    return segs.filter(function (seg) {
+        var m = midpoint(seg);
+        var inside = false;
+        polygons.forEach(function (polygon, i) {
+            if (inBox(m, boxes[i]) && pointInPolygon(m, polygon))
+                inside = !inside;
+        });
+        return inside;
+    });
+}
+function hatchPattern(hyp) {
+    var _a;
+    if (hyp.custom)
+        return { type: 'custom', name: CUSTOM_PATTERN_NAME };
+    if (hyp.userDefined) {
+        return {
+            type: 'userDefined',
+            angle: hyp.rotation,
+            spacing: hyp.userDefined.spacing,
+            double: hyp.userDefined.double
+        };
+    }
+    return {
+        type: 'predefined',
+        name: (_a = hyp.name) !== null && _a !== void 0 ? _a : '',
+        scale: hyp.scale,
+        angle: hyp.rotation
+    };
+}
+/** Pattern name recorded on measured custom hatches. */
+export var CUSTOM_PATTERN_NAME = 'PDF_HATCH';
+/** The segments of the families a hypothesis explains. */
+function hypothesisSegs(hyp) {
+    var e_72, _a;
+    var out = [];
+    try {
+        for (var _b = __values(new Set(hyp.families)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var family = _c.value;
+            if (family)
+                out.push.apply(out, __spreadArray([], __read(family.segs), false));
+        }
+    }
+    catch (e_72_1) { e_72 = { error: e_72_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_72) throw e_72.error; }
+    }
+    return out;
+}
+var BOUNDARY_SOURCES = ['given', 'shapes', 'clip', 'ends', 'faces'];
+function rotationRank(angle) {
+    var deg = angle / DEG;
+    return Math.min(deg, 360 - deg);
+}
+/**
+ * Order of placed hypotheses: best score first; then the pattern that
+ * explains most of the region (a cross-hatch over one of its families), the
+ * pattern drawn closest to its own angle, and library patterns (in library
+ * order) over user-defined lines.
+ */
+function compareScored(p, q, regionSize) {
+    return (Math.round((q.score - p.score) * 50) ||
+        Math.round(((q.segs.length - p.segs.length) / regionSize) * 20) ||
+        Math.round(rotationRank(p.hyp.rotation) - rotationRank(q.hyp.rotation)) ||
+        p.hyp.order - q.hyp.order);
+}
+// ---------------------------------------------------------------------------
+// Custom patterns: measured from the strokes when nothing else fits
+/** Most line families a measured custom pattern may have. */
+var MAX_CUSTOM_FAMILIES = 3;
+/**
+ * A custom pattern measured from the region: per family its spacing, the
+ * offset lines within one spacing, the dash sequence along the lines and
+ * the stagger from one line to the next. The pattern lines come out in
+ * drawing coordinates (rotation 0, scale 1).
+ */
+function customHypothesis(families, opts) {
+    var e_73, _a, e_74, _b;
+    var tol = opts.tolerance;
+    var main = families[0];
+    if (!main)
+        return undefined;
+    var picked = families
+        .filter(function (f) {
+        return f === main ||
+            // Other families must be as regular and nearly as dense as the
+            // main one; sparse ones are the line work around the hatch.
+            (f.offsets.length >= opts.minLines &&
+                f.residues <= 4 &&
+                f.segs.length >= Math.max(4, main.segs.length * 0.3));
+    })
+        .slice(0, MAX_CUSTOM_FAMILIES);
+    var lines = [];
+    var owners = [];
+    try {
+        for (var picked_1 = __values(picked), picked_1_1 = picked_1.next(); !picked_1_1.done; picked_1_1 = picked_1.next()) {
+            var family = picked_1_1.value;
+            var measured = measureCustomFamily(family, tol);
+            if (!measured) {
+                if (family === main)
+                    return undefined;
+                continue;
+            }
+            try {
+                for (var measured_1 = (e_74 = void 0, __values(measured)), measured_1_1 = measured_1.next(); !measured_1_1.done; measured_1_1 = measured_1.next()) {
+                    var line = measured_1_1.value;
+                    lines.push(line);
+                    owners.push(family);
+                }
+            }
+            catch (e_74_1) { e_74 = { error: e_74_1 }; }
+            finally {
+                try {
+                    if (measured_1_1 && !measured_1_1.done && (_b = measured_1.return)) _b.call(measured_1);
+                }
+                finally { if (e_74) throw e_74.error; }
+            }
+        }
+    }
+    catch (e_73_1) { e_73 = { error: e_73_1 }; }
+    finally {
+        try {
+            if (picked_1_1 && !picked_1_1.done && (_a = picked_1.return)) _a.call(picked_1);
+        }
+        finally { if (e_73) throw e_73.error; }
+    }
+    if (lines.length === 0)
+        return undefined;
+    return {
+        order: Infinity,
+        rotation: 0,
+        scale: 1,
+        lines: lines,
+        families: owners,
+        custom: true
+    };
+}
+function measureCustomFamily(family, tol) {
+    var e_75, _a, e_76, _b;
+    var theta = family.theta;
+    var ux = Math.cos(theta);
+    var uy = Math.sin(theta);
+    var period = family.period;
+    var rows = linesOf(family.segs, theta, tol);
+    if (rows.length < 2)
+        return undefined;
+    // Rows by offset within one spacing (patterns may hold several lines).
+    var c0 = rows[0].c;
+    var classes = [];
+    var _loop_14 = function (row) {
+        var r = (((row.c - c0) % period) + period) % period;
+        var found = classes.find(function (cls) {
+            var d = Math.abs(cls.residue - r);
+            return Math.min(d, period - d) <= tol * 2;
+        });
+        if (found)
+            found.rows.push(row);
+        else
+            classes.push({ residue: r, rows: [row] });
+    };
+    try {
+        for (var rows_4 = __values(rows), rows_4_1 = rows_4.next(); !rows_4_1.done; rows_4_1 = rows_4.next()) {
+            var row = rows_4_1.value;
+            _loop_14(row);
+        }
+    }
+    catch (e_75_1) { e_75 = { error: e_75_1 }; }
+    finally {
+        try {
+            if (rows_4_1 && !rows_4_1.done && (_a = rows_4.return)) _a.call(rows_4);
+        }
+        finally { if (e_75) throw e_75.error; }
+    }
+    var most = Math.max.apply(Math, __spreadArray([], __read(classes.map(function (cls) { return cls.rows.length; })), false));
+    var out = [];
+    try {
+        for (var classes_1 = __values(classes), classes_1_1 = classes_1.next(); !classes_1_1.done; classes_1_1 = classes_1.next()) {
+            var cls = classes_1_1.value;
+            if (cls.rows.length < Math.max(2, most * 0.3))
+                continue;
+            var line = measureCustomLine(cls.rows, period, tol);
+            if (!line)
+                return undefined;
+            var s = line.s, c = line.c, shift = line.shift, dashes = line.dashes;
+            out.push({
+                angle: theta / DEG,
+                originX: ux * s - uy * c,
+                originY: uy * s + ux * c,
+                deltaX: shift,
+                deltaY: period,
+                dashes: dashes,
+                sourceLine: 0
+            });
+        }
+    }
+    catch (e_76_1) { e_76 = { error: e_76_1 }; }
+    finally {
+        try {
+            if (classes_1_1 && !classes_1_1.done && (_b = classes_1.return)) _b.call(classes_1);
+        }
+        finally { if (e_76) throw e_76.error; }
+    }
+    return out.length > 0 ? out : undefined;
+}
+/**
+ * Dash sequence, phase and stagger of one set of parallel lines one
+ * spacing apart.
+ */
+function measureCustomLine(rows, period, tol) {
+    var e_77, _a, e_78, _b, e_79, _c, e_80, _d;
+    var _e, _f;
+    var intervals = rows.map(function (row) { return mergeIntervals(row, tol); });
+    // Repeat length along the lines, from the rows with several dashes.
+    var repeats = [];
+    try {
+        for (var intervals_1 = __values(intervals), intervals_1_1 = intervals_1.next(); !intervals_1_1.done; intervals_1_1 = intervals_1.next()) {
+            var list_2 = intervals_1_1.value;
+            if (list_2.length < 3)
+                continue;
+            var along_1 = fundamentalPeriod(list_2.map(function (i) { return i.s0; }), tol);
+            if (along_1)
+                repeats.push(along_1);
+        }
+    }
+    catch (e_77_1) { e_77 = { error: e_77_1 }; }
+    finally {
+        try {
+            if (intervals_1_1 && !intervals_1_1.done && (_a = intervals_1.return)) _a.call(intervals_1);
+        }
+        finally { if (e_77) throw e_77.error; }
+    }
+    if (repeats.length === 0) {
+        // Continuous lines; rows that break up must do so at holes, not at a
+        // regular rhythm (no repeat was found).
+        return { s: 0, c: rows[0].c, shift: 0, dashes: [] };
+    }
+    repeats.sort(function (p, q) { return p - q; });
+    var along = repeats[Math.floor(repeats.length / 2)];
+    // One full repeat from an inner dash of the row with the most dashes
+    // (outer dashes may be cut by the boundary).
+    var best = -1;
+    intervals.forEach(function (list, i) {
+        if (best < 0 || list.length > intervals[best].length)
+            best = i;
+    });
+    var list = intervals[best];
+    if (list.length < 3)
+        return undefined;
+    var first = list[1];
+    var s = first.s0;
+    var dashes = [];
+    var cursor = s;
+    try {
+        for (var _g = __values(list.slice(1)), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var interval = _h.value;
+            if (interval.s0 >= s + along - tol)
+                break;
+            if (interval.s0 > cursor + tol)
+                dashes.push(-(interval.s0 - cursor));
+            dashes.push(interval.s1 - interval.s0);
+            cursor = interval.s1;
+        }
+    }
+    catch (e_78_1) { e_78 = { error: e_78_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+        }
+        finally { if (e_78) throw e_78.error; }
+    }
+    if (s + along - cursor > tol)
+        dashes.push(-(s + along - cursor));
+    if (dashes.length < 2 || dashes[0] <= 0)
+        return undefined;
+    var total = dashes.reduce(function (sum, d) { return sum + Math.abs(d); }, 0);
+    if (Math.abs(total - along) > tol * 4)
+        return undefined;
+    // Stagger: where the same dash starts on the next line, voted over every
+    // pair of neighbouring lines.
+    var dashLength = first.s1 - first.s0;
+    var bin = tol * 2;
+    var votes = new Map();
+    for (var i = 0; i + 1 < rows.length; i++) {
+        var k = Math.round((rows[i + 1].c - rows[i].c) / period);
+        if (k !== 1)
+            continue;
+        var here = intervals[i].filter(function (v) { return Math.abs(v.s1 - v.s0 - dashLength) <= tol * 2; });
+        var next = intervals[i + 1].filter(function (v) { return Math.abs(v.s1 - v.s0 - dashLength) <= tol * 2; });
+        if (here.length === 0 || next.length === 0)
+            continue;
+        var ref = here[Math.floor(here.length / 2)].s0;
+        try {
+            for (var next_1 = (e_79 = void 0, __values(next)), next_1_1 = next_1.next(); !next_1_1.done; next_1_1 = next_1.next()) {
+                var v = next_1_1.value;
+                var shift_1 = (((v.s0 - ref) % along) + along) % along;
+                var key = Math.round(shift_1 / bin);
+                var listed = votes.get(key);
+                if (listed)
+                    listed.push(shift_1);
+                else
+                    votes.set(key, [shift_1]);
+            }
+        }
+        catch (e_79_1) { e_79 = { error: e_79_1 }; }
+        finally {
+            try {
+                if (next_1_1 && !next_1_1.done && (_c = next_1.return)) _c.call(next_1);
+            }
+            finally { if (e_79) throw e_79.error; }
+        }
+    }
+    var shift = 0;
+    var count = 0;
+    try {
+        for (var votes_1 = __values(votes), votes_1_1 = votes_1.next(); !votes_1_1.done; votes_1_1 = votes_1.next()) {
+            var _j = __read(votes_1_1.value, 2), key = _j[0], values = _j[1];
+            // Bins at both ends of the repeat are one value split by the wrap.
+            var merged = __spreadArray(__spreadArray(__spreadArray([], __read(values), false), __read(((_e = votes.get(key + 1)) !== null && _e !== void 0 ? _e : [])), false), __read(((_f = votes.get(key - 1)) !== null && _f !== void 0 ? _f : [])), false);
+            if (merged.length > count) {
+                count = merged.length;
+                var mean = values.reduce(function (sum, v) { return sum + v; }, 0) / values.length;
+                shift = mean;
+            }
+        }
+    }
+    catch (e_80_1) { e_80 = { error: e_80_1 }; }
+    finally {
+        try {
+            if (votes_1_1 && !votes_1_1.done && (_d = votes_1.return)) _d.call(votes_1);
+        }
+        finally { if (e_80) throw e_80.error; }
+    }
+    return { s: s, c: rows[best].c, shift: shift, dashes: dashes };
+}
+/** Collinear pieces of one row joined where they touch. */
+function mergeIntervals(row, tol) {
+    var e_81, _a;
+    var out = [];
+    try {
+        for (var _b = __values(row.segs), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var entry = _c.value;
+            var last = out[out.length - 1];
+            if (last && entry.s0 <= last.s1 + tol) {
+                last.s1 = Math.max(last.s1, entry.s1);
+            }
+            else {
+                out.push({ s0: entry.s0, s1: entry.s1 });
+            }
+        }
+    }
+    catch (e_81_1) { e_81 = { error: e_81_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_81) throw e_81.error; }
+    }
+    return out;
+}
+/** Most strokes an edited hatch may draw (a far too small scale). */
+var MAX_EDIT_STROKES = 200000;
+var NO_MATCH = { precision: 0, recall: 0, items: [] };
+/** Direction slack for short stroke pieces (radians). */
+var SHORT_ANGLE_GAP = (15 * Math.PI) / 180;
+/** Fewest line repeats a family spans to count as a pattern, not walls. */
+var MIN_PATTERN_REPEATS = 4;
+function editRegion(items, boundary, tol) {
+    var e_82, _a;
+    var _b, _c;
+    var polygons = boundary
+        .map(shapeOutline)
+        .filter(function (outline) { return !!outline; });
+    if (polygons.length === 0)
+        return undefined;
+    var best;
+    try {
+        for (var _d = __values(groupCandidates(items, tol)), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var group = _e.value;
+            var region = segsInside(group.all, polygons).filter(function (seg) { return !polygons.some(function (outline) { return onOutline(midpoint(seg), outline, tol); }); });
+            var length_1 = region.reduce(function (sum, seg) { return sum + seg.len; }, 0);
+            if (length_1 > 0 && (!best || length_1 > best.length)) {
+                best = { region: region, all: group.all, length: length_1 };
+            }
+        }
+    }
+    catch (e_82_1) { e_82 = { error: e_82_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_82) throw e_82.error; }
+    }
+    var box = pointsBox(polygons.flat());
+    return {
+        shapes: __spreadArray([], __read(boundary), false),
+        polygons: polygons,
+        region: (_b = best === null || best === void 0 ? void 0 : best.region) !== null && _b !== void 0 ? _b : [],
+        all: (_c = best === null || best === void 0 ? void 0 : best.all) !== null && _c !== void 0 ? _c : [],
+        extent: Math.hypot(box.maxX - box.minX, box.maxY - box.minY)
+    };
+}
+/** Rough count of the strokes `lines` draw across a region of `extent`. */
+function strokeEstimate(lines, extent) {
+    var e_83, _a;
+    var count = 0;
+    try {
+        for (var lines_4 = __values(lines), lines_4_1 = lines_4.next(); !lines_4_1.done; lines_4_1 = lines_4.next()) {
+            var line = lines_4_1.value;
+            var frame = lineFrame(line);
+            var spacing = Math.abs(frame.spacing);
+            if (!(spacing > 0))
+                return Infinity;
+            var rows = extent / spacing + 1;
+            var perRow = frame.dashes.length > 0 && frame.period > 0
+                ? (extent / frame.period + 1) * frame.dashes.length
+                : 1;
+            count += rows * perRow;
+        }
+    }
+    catch (e_83_1) { e_83 = { error: e_83_1 }; }
+    finally {
+        try {
+            if (lines_4_1 && !lines_4_1.done && (_a = lines_4.return)) _a.call(lines_4);
+        }
+        finally { if (e_83) throw e_83.error; }
+    }
+    return count;
+}
+function matchIn(edit, lines, tol) {
+    if (lines.length === 0)
+        return NO_MATCH;
+    if (strokeEstimate(lines, edit.extent) > MAX_EDIT_STROKES)
+        return NO_MATCH;
+    var generated = generateStrokes(lines, edit.polygons, tol);
+    return measureMatch(lines, generated, edit.region, edit.all, tol);
+}
+/** Harmonic mean of precision and recall. */
+function matchQuality(match) {
+    var sum = match.precision + match.recall;
+    return sum > 0 ? (2 * match.precision * match.recall) / sum : 0;
+}
+/**
+ * Scores a hatch against the strokes inside its boundary.
+ *
+ * @param items - The shape items the hatch was recognized from.
+ * @param hatch - Boundary and definition lines to score.
+ * @param tolerance - Tolerance the hatch was recognized with.
+ */
+export function acapPdfMatchHatch(items, hatch, tolerance) {
+    var edit = editRegion(items, hatch.boundary, tolerance);
+    return edit ? matchIn(edit, hatch.definitionLines, tolerance) : NO_MATCH;
+}
+/**
+ * Fits a pattern to the strokes inside `boundary`.
+ *
+ * Without `request` every library pattern, user-defined lines and (unless
+ * turned off) a measured custom pattern compete, as in the recognition.
+ * With a pattern its size, angle and origin are measured; with size and
+ * angle given as well only the origin is.
+ *
+ * @param items - Shape items (from `pdfEntitiesToHatchInput`).
+ * @param boundary - Closed shapes; the hatch fills them even-odd.
+ * @returns The best placement, or `undefined` when the boundary has no
+ * closed shape or the pattern name is unknown.
+ */
+export function acapPdfFitHatch(items, boundary, request, options) {
+    var e_84, _a;
+    var _b;
+    var tol = options.tolerance;
+    var edit = editRegion(items, boundary, tol);
+    if (!edit)
+        return undefined;
+    var families = edit.region.length > 0 ? measureFamilies(edit.region, tol) : [];
+    var library = (_b = options.patterns) !== null && _b !== void 0 ? _b : AcDbPredefinedAcadIsoPat.patterns;
+    var hypotheses = fitHypotheses(request, families, library, tol, edit);
+    var placed = hypotheses.map(function (_a) {
+        var hyp = _a.hyp, guessed = _a.guessed;
+        return (__assign({ hyp: hyp, guessed: guessed, segs: hypothesisSegs(hyp) }, placeHypothesis(hyp, tol)));
+    });
+    placed.sort(function (p, q) { return compareScored(p, q, Math.max(edit.region.length, 1)); });
+    var tries = placed.slice(0, MAX_VERIFIED);
+    // A measured pattern is the last resort, as in the recognition.
+    if (!request && options.customPatterns !== false) {
+        var opts = resolveOptions({ tolerance: tol, customPatterns: true });
+        var custom = customHypothesis(families, opts);
+        if (custom) {
+            tries.push(__assign({ hyp: custom, guessed: false, segs: hypothesisSegs(custom) }, placeHypothesis(custom, tol)));
+        }
+    }
+    var best;
+    var bestMatch = NO_MATCH;
+    try {
+        for (var tries_2 = __values(tries), tries_2_1 = tries_2.next(); !tries_2_1.done; tries_2_1 = tries_2.next()) {
+            var entry = tries_2_1.value;
+            var match = matchIn(edit, entry.lines, tol);
+            // Earlier entries win ties: the order prefers simpler explanations.
+            if (!best || matchQuality(match) > matchQuality(bestMatch) + 1e-3) {
+                best = entry;
+                bestMatch = match;
+            }
+        }
+    }
+    catch (e_84_1) { e_84 = { error: e_84_1 }; }
+    finally {
+        try {
+            if (tries_2_1 && !tries_2_1.done && (_a = tries_2.return)) _a.call(tries_2);
+        }
+        finally { if (e_84) throw e_84.error; }
+    }
+    if (!best)
+        return undefined;
+    return {
+        hatch: {
+            boundary: edit.shapes,
+            pattern: hatchPattern(best.hyp),
+            definitionLines: best.lines,
+            items: bestMatch.items
+        },
+        match: bestMatch,
+        fitted: !best.guessed
+    };
+}
+/** Definition lines of a hypothesis placed on its strokes, with a score. */
+function placeHypothesis(hyp, tol) {
+    var _a, _b, _c;
+    // Measured custom lines are already in place.
+    if (hyp.custom) {
+        return { lines: definitionLines(hyp, { x: 0, y: 0 }), score: 1 };
+    }
+    var segs = hypothesisSegs(hyp);
+    if (segs.length === 0) {
+        return { lines: definitionLines(hyp, { x: 0, y: 0 }), score: 0 };
+    }
+    var one = estimateTranslation(hyp, segs, tol);
+    if (one && one.score >= MIN_SCORE) {
+        return { lines: definitionLines(hyp, one.t), score: one.score };
+    }
+    var separate = placeLinesSeparately(hyp, segs, tol);
+    if (separate && separate.score > ((_a = one === null || one === void 0 ? void 0 : one.score) !== null && _a !== void 0 ? _a : 0))
+        return separate;
+    return {
+        lines: definitionLines(hyp, (_b = one === null || one === void 0 ? void 0 : one.t) !== null && _b !== void 0 ? _b : { x: 0, y: 0 }),
+        score: (_c = one === null || one === void 0 ? void 0 : one.score) !== null && _c !== void 0 ? _c : 0
+    };
+}
+/** Families with each of the first few as the anchor of a match. */
+function anchoredFamilies(families) {
+    return families
+        .slice(0, 4)
+        .map(function (anchor) { return __spreadArray([anchor], __read(families.filter(function (f) { return f !== anchor; })), false); });
+}
+function fitHypotheses(request, families, library, tol, edit) {
+    var e_85, _a, e_86, _b, e_87, _c;
+    var _d, _e;
+    var extent = edit.extent;
+    var anchored = anchoredFamilies(families);
+    var found = function (hyps) {
+        return hyps.map(function (hyp) { return ({ hyp: hyp, guessed: false }); });
+    };
+    if (!request) {
+        var hyps_1 = [];
+        try {
+            for (var _f = __values(patternSignatures(library)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var sig_1 = _g.value;
+                try {
+                    for (var anchored_1 = (e_86 = void 0, __values(anchored)), anchored_1_1 = anchored_1.next(); !anchored_1_1.done; anchored_1_1 = anchored_1.next()) {
+                        var list = anchored_1_1.value;
+                        hyps_1.push.apply(hyps_1, __spreadArray([], __read(matchPattern(sig_1, list, tol, extent)), false));
+                    }
+                }
+                catch (e_86_1) { e_86 = { error: e_86_1 }; }
+                finally {
+                    try {
+                        if (anchored_1_1 && !anchored_1_1.done && (_b = anchored_1.return)) _b.call(anchored_1);
+                    }
+                    finally { if (e_86) throw e_86.error; }
+                }
+            }
+        }
+        catch (e_85_1) { e_85 = { error: e_85_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+            }
+            finally { if (e_85) throw e_85.error; }
+        }
+        try {
+            for (var anchored_2 = __values(anchored), anchored_2_1 = anchored_2.next(); !anchored_2_1.done; anchored_2_1 = anchored_2.next()) {
+                var list = anchored_2_1.value;
+                hyps_1.push.apply(hyps_1, __spreadArray([], __read(userDefinedHypotheses(list, tol, extent)), false));
+            }
+        }
+        catch (e_87_1) { e_87 = { error: e_87_1 }; }
+        finally {
+            try {
+                if (anchored_2_1 && !anchored_2_1.done && (_c = anchored_2.return)) _c.call(anchored_2);
+            }
+            finally { if (e_87) throw e_87.error; }
+        }
+        return found(hyps_1);
+    }
+    if (request.type === 'userDefined') {
+        var make_1 = function (angle, spacing) {
+            return fixedHypothesis(request.double
+                ? [userDefinedLine(0), userDefinedLine(90)]
+                : [userDefinedLine(0)], angle, spacing, families, { order: Infinity, userDefined: { double: request.double, spacing: spacing } });
+        };
+        if (request.spacing !== undefined && request.angle !== undefined) {
+            return [{ hyp: make_1(request.angle, request.spacing), guessed: false }];
+        }
+        var hyps_2 = anchored
+            .flatMap(function (list) { return userDefinedHypotheses(list, tol, extent); })
+            .filter(function (hyp) { var _a; return ((_a = hyp.userDefined) === null || _a === void 0 ? void 0 : _a.double) === request.double; });
+        if (hyps_2.length > 0)
+            return found(hyps_2);
+        var main_1 = families[0];
+        var spacing = (_d = main_1 === null || main_1 === void 0 ? void 0 : main_1.period) !== null && _d !== void 0 ? _d : Math.max(extent / 20, tol);
+        return [{ hyp: make_1((_e = main_1 === null || main_1 === void 0 ? void 0 : main_1.theta) !== null && _e !== void 0 ? _e : 0, spacing), guessed: true }];
+    }
+    var order = library.findIndex(function (p) { return p.name === request.name; });
+    if (order < 0)
+        return [];
+    var pattern = library[order];
+    var make = function (angle, scale) {
+        return fixedHypothesis(pattern.lines, angle, scale, families, {
+            name: pattern.name,
+            order: order
+        });
+    };
+    if (request.scale !== undefined && request.angle !== undefined) {
+        return [{ hyp: make(request.angle, request.scale), guessed: false }];
+    }
+    var sig = patternSignatures([pattern])[0];
+    var hyps = sig
+        ? anchored.flatMap(function (list) {
+            return matchPattern(__assign(__assign({}, sig), { order: order }), list, tol, extent);
+        })
+        : [];
+    if (hyps.length > 0)
+        return found(hyps);
+    // No trace of the pattern: size its first group on the main family.
+    var group = sig === null || sig === void 0 ? void 0 : sig.groups.find(function (g) { return !g.dotsOnly; });
+    var main = families[0];
+    var scale = group && main ? main.period / group.period : 1;
+    var angle = group && main ? main.theta - group.angle : 0;
+    return [{ hyp: make(angle, scale), guessed: true }];
+}
+/** A hypothesis at a given rotation and scale, its lines on the families. */
+function fixedHypothesis(lines, rotation, scale, families, extra) {
+    return __assign({ rotation: rotation, scale: scale, lines: lines, families: lines.map(function (line) {
+            if (isDotsOnly(line.dashes))
+                return undefined;
+            var direction = line.angle * DEG + rotation;
+            return families.find(function (f) { return directionDelta(f.theta, direction) < ANGLE_GAP; });
+        }) }, extra);
+}
+/**
+ * Boundary of the area around `point` that the selected line work encloses,
+ * with the strokes of regular patterns left out (they would cut the area
+ * into strips). Islands inside the area belong to it.
+ *
+ * @param items - Shape items (from `pdfEntitiesToHatchInput`).
+ * @param point - A point inside the area, in drawing coordinates.
+ * @param tolerance - Snap tolerance for the line work.
+ * @returns Closed boundary shapes, or `undefined` when no closed area
+ * holds the point.
+ */
+export function acapPdfBoundaryAt(items, point, tolerance) {
+    var e_88, _a, e_89, _b, e_90, _c;
+    var opts = resolveOptions({ tolerance: tolerance });
+    var strokes = new Set();
+    var candidates = new Map();
+    try {
+        for (var _d = __values(groupCandidates(items, tolerance)), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var group = _e.value;
+            try {
+                for (var _f = (e_89 = void 0, __values(group.all)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var seg = _g.value;
+                    candidates.set(seg.index, seg);
+                }
+            }
+            catch (e_89_1) { e_89 = { error: e_89_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_89) throw e_89.error; }
+            }
+            var _loop_15 = function (region) {
+                var e_91, _k, e_92, _l, e_93, _m;
+                // Only the regular, dense families: walls drawn like the strokes join
+                // the region too, and a few evenly spaced walls (a room's sides) also
+                // form a family, but one only a couple of repeats deep.
+                var measured = measureFamilies(region, tolerance);
+                var main = measured[0];
+                var families = measured.filter(function (family) {
+                    return family.offsets.length >= opts.minLines &&
+                        family.offsets[family.offsets.length - 1] - family.offsets[0] >=
+                            family.period * MIN_PATTERN_REPEATS &&
+                        (family === main ||
+                            family.segs.length >= Math.max(4, main.segs.length * 0.3));
+                });
+                try {
+                    for (var families_1 = (e_91 = void 0, __values(families)), families_1_1 = families_1.next(); !families_1_1.done; families_1_1 = families_1.next()) {
+                        var family = families_1_1.value;
+                        try {
+                            for (var _o = (e_92 = void 0, __values(family.segs)), _p = _o.next(); !_p.done; _p = _o.next()) {
+                                var seg = _p.value;
+                                strokes.add(seg.index);
+                            }
+                        }
+                        catch (e_92_1) { e_92 = { error: e_92_1 }; }
+                        finally {
+                            try {
+                                if (_p && !_p.done && (_l = _o.return)) _l.call(_o);
+                            }
+                            finally { if (e_92) throw e_92.error; }
+                        }
+                        // Strokes clipped short at the boundary (or left out of the region)
+                        // still lie on the family's lines; between two walls they would cut
+                        // the area into strips. Short pieces have a rough direction, but the
+                        // tiny steps of an outline seldom run along the pattern.
+                        var box = segsBox(family.segs);
+                        var pad = family.period + tolerance;
+                        var longest = Math.max.apply(Math, __spreadArray([], __read(family.segs.map(function (seg) { return seg.len; })), false));
+                        try {
+                            for (var _q = (e_93 = void 0, __values(group.all)), _r = _q.next(); !_r.done; _r = _q.next()) {
+                                var seg = _r.value;
+                                if (strokes.has(seg.index))
+                                    continue;
+                                if (seg.len > longest + tolerance)
+                                    continue;
+                                var angleTol = seg.len >= tolerance * SHORT_FACTOR ? ANGLE_GAP : SHORT_ANGLE_GAP;
+                                if (directionDelta(seg.theta, family.theta) > angleTol)
+                                    continue;
+                                var m = midpoint(seg);
+                                if (m.x < box.minX - pad ||
+                                    m.x > box.maxX + pad ||
+                                    m.y < box.minY - pad ||
+                                    m.y > box.maxY + pad) {
+                                    continue;
+                                }
+                                if (onFamilyLattice(m, family, tolerance))
+                                    strokes.add(seg.index);
+                            }
+                        }
+                        catch (e_93_1) { e_93 = { error: e_93_1 }; }
+                        finally {
+                            try {
+                                if (_r && !_r.done && (_m = _q.return)) _m.call(_q);
+                            }
+                            finally { if (e_93) throw e_93.error; }
+                        }
+                    }
+                }
+                catch (e_91_1) { e_91 = { error: e_91_1 }; }
+                finally {
+                    try {
+                        if (families_1_1 && !families_1_1.done && (_k = families_1.return)) _k.call(families_1);
+                    }
+                    finally { if (e_91) throw e_91.error; }
+                }
+            };
+            try {
+                for (var _h = (e_90 = void 0, __values(findRegions(group.long, opts))), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var region = _j.value;
+                    _loop_15(region);
+                }
+            }
+            catch (e_90_1) { e_90 = { error: e_90_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                }
+                finally { if (e_90) throw e_90.error; }
+            }
+        }
+    }
+    catch (e_88_1) { e_88 = { error: e_88_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_88) throw e_88.error; }
+    }
+    var polylines = [];
+    items.forEach(function (item, index) {
+        if (strokes.has(index))
+            return;
+        var polyline = acapPdfShapePolyline(item.shape, tolerance * 0.25);
+        if (polyline.length >= 2)
+            polylines.push(polyline);
+    });
+    var arrangement = acapPdfFaceArrangement(polylines, {
+        tolerance: tolerance,
+        maxSegments: MAX_FACE_SEGMENTS
+    });
+    if (!arrangement)
+        return undefined;
+    // Faces split by a line drawn across a hatch (an axis) are one area where
+    // strokes run over the line; areas whose strokes stop on it stay apart.
+    var strokeSegs = __spreadArray([], __read(strokes), false).map(function (index) { return candidates.get(index); })
+        .filter(function (seg) { return !!seg; });
+    var parts = acapPdfFaceBoundaryParts(arrangement, __spreadArray([point], __read(strokeSegs.map(midpoint)), false), { minCoverage: 0, strokes: strokeSegs.map(function (seg) { return [seg.a, seg.b]; }) });
+    var part = parts === null || parts === void 0 ? void 0 : parts.find(function (loops) { return insideLoops(point, loops); });
+    var polygons = part !== null && part !== void 0 ? part : acapPdfFaceBoundaryIn(arrangement, [point], {
+        minCoverage: 1
+    });
+    return polygons && polygons.length > 0
+        ? polygonsToBoundary(polygons).shapes
+        : undefined;
+}
+/** Whether `p` lies inside `loops` (even-odd). */
+function insideLoops(p, loops) {
+    var e_94, _a;
+    var inside = false;
+    try {
+        for (var loops_1 = __values(loops), loops_1_1 = loops_1.next(); !loops_1_1.done; loops_1_1 = loops_1.next()) {
+            var loop = loops_1_1.value;
+            if (pointInPolygon(p, loop))
+                inside = !inside;
+        }
+    }
+    catch (e_94_1) { e_94 = { error: e_94_1 }; }
+    finally {
+        try {
+            if (loops_1_1 && !loops_1_1.done && (_a = loops_1.return)) _a.call(loops_1);
+        }
+        finally { if (e_94) throw e_94.error; }
+    }
+    return inside;
+}
+/** True when `p` lies on one of the lines of `family` or their repeats. */
+function onFamilyLattice(p, family, tol) {
+    var ux = Math.cos(family.theta);
+    var uy = Math.sin(family.theta);
+    var c = -uy * p.x + ux * p.y;
+    var period = family.period;
+    return family.offsets.some(function (offset) {
+        var r = (((c - offset) % period) + period) % period;
+        return Math.min(r, period - r) <= tol;
+    });
+}
+//# sourceMappingURL=pdfHatchRecognition.js.map