@mlightcad/cad-simple-viewer 1.8.0-preview.2 → 1.8.0-preview.4

package/lib/smartBlock/AcApSmartBlockDetect.js

@@ -0,0 +1,1464 @@
+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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 { excludeLockedLayerIds } from '../service/AcApLockedLayer';
+import { acapConvertSmartBlock, acapInvertAffine2d } from './AcApSmartBlockConvert';
+import { acapBuildSmartBlockTemplate, acapComposeAffine2d, acapFindSmartBlockMatches, AcApSmartBlockCandidatePool, AcApSmartBlockFeatureCache, acapSmartBlockTemplateCenter, acapSmartBlockVariableTexts } from './AcApSmartBlockSearch';
+import { acedApplyAffine2d, acedFindShapeMatches, acedShapeLandsOn } from './AcEdShapeMatcher';
+/**
+ * Converts a detected group into a new block: the representative and every
+ * instance become references of it. Call it inside one undo mark, like
+ * {@link acapConvertSmartBlock}. Instances must still be unchanged since
+ * detection.
+ *
+ * @param db - Drawing database the group was detected in.
+ * @param cluster - Group from {@link acapDetectSmartBlocks}.
+ * @param options - Block name, insertion point and attributes.
+ */
+export function acapConvertSmartBlockCluster(db, cluster, options) {
+    var _a, _b, _c;
+    var template = acapBuildSmartBlockTemplate(db, cluster.ids, {
+        matchLayer: (_a = options.matchLayer) !== null && _a !== void 0 ? _a : true
+    });
+    if (template.ids.length !== cluster.ids.length) {
+        throw new Error('Detected group changed since detection');
+    }
+    var attributes = (_b = options.attributes) !== null && _b !== void 0 ? _b : acapSmartBlockVariableTexts(template, cluster.matches).map(function (index, i) { return ({
+        index: index,
+        tag: "TEXT".concat(i + 1)
+    }); });
+    return acapConvertSmartBlock(db, template, cluster.matches, {
+        target: {
+            kind: 'new',
+            name: options.name,
+            basePoint: (_c = options.basePoint) !== null && _c !== void 0 ? _c : acapSmartBlockTemplateCenter(template),
+            attributes: attributes
+        }
+    });
+}
+/**
+ * Finds groups of identical shapes anywhere in model space, without a
+ * selection: the heuristic counterpart of AutoCAD's Detect and Convert
+ * (`BDETECT`), which uses a cloud recognition model.
+ *
+ * Steps:
+ *
+ * 1. Every describable shape gets its neighbors, nearest first: shapes that
+ *    touch it (a characteristic point in its padded bounds) and shapes
+ *    whose bounds are closer than the smaller one's size.
+ * 2. Each neighbor pair gets a key that does not change under translation,
+ *    rotation and (optionally) mirroring: kinds, sizes, distance and the
+ *    second moments of both shapes in the pair's own frame. Keys that occur
+ *    at least `minInstances` times seed a group, most frequent first.
+ * 3. The seed occurrences grow together, round by round: a shape touching
+ *    the first occurrence joins when, in enough other occurrences, a shape
+ *    lands on it under that occurrence's transform. Walls and other shapes
+ *    that differ around each copy are left out.
+ * 4. Every round is rated by the exact matcher on just the shapes growth
+ *    collected; the best round is then verified on the whole drawing by
+ *    the Smart Blocks search ({@link acapFindSmartBlockMatches}).
+ * 5. A seed pair may play different roles in one symbol (an arc at a
+ *    corner and at an end), which stops growth early. The verified copies
+ *    are consistent, so the group grows again from them, absorbing earlier
+ *    groups that turn out to be parts of it when the whole saves more.
+ * 6. Texts inside the group join it when most copies have one there; with
+ *    text variations they become attributes on conversion.
+ * 7. The copies' entities are claimed so groups never share entities.
+ *    Groups saving fewer than `minSavings` entities are dropped.
+ *
+ * Every group can be reviewed and converted with `AcApSmartBlockSearch`
+ * from its {@link AcApSmartBlockCluster.ids}. That search may find more
+ * copies than reported here: copies used by another group are not counted.
+ *
+ * Groups are returned largest saving first.
+ *
+ * @param db - Drawing database.
+ * @param options - Thresholds and allowed transforms.
+ * @param cache - Feature cache shared with later searches.
+ */
+export function acapDetectSmartBlocks(db, options, cache) {
+    if (options === void 0) { options = {}; }
+    if (cache === void 0) { cache = new AcApSmartBlockFeatureCache(); }
+    var run = detect(db, options, cache);
+    for (;;) {
+        var step = run.next();
+        if (step.done)
+            return step.value;
+    }
+}
+/**
+ * {@link acapDetectSmartBlocks} in slices, yielding to the event loop
+ * between them so a UI stays responsive, with progress and cancellation.
+ * Single steps (one exact search) can still take a moment in large
+ * drawings.
+ *
+ * @param db - Drawing database; do not edit it until the promise settles.
+ * @param options - Thresholds and allowed transforms.
+ * @param control - Progress callback, abort signal and slice length.
+ * @param cache - Feature cache shared with later searches.
+ */
+export function acapDetectSmartBlocksAsync(db_1) {
+    return __awaiter(this, arguments, void 0, function (db, options, control, cache) {
+        var slice, run, last, step;
+        var _a, _b, _c, _d;
+        if (options === void 0) { options = {}; }
+        if (control === void 0) { control = {}; }
+        if (cache === void 0) { cache = new AcApSmartBlockFeatureCache(); }
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    slice = (_a = control.sliceMs) !== null && _a !== void 0 ? _a : 30;
+                    run = detect(db, options, cache);
+                    last = performance.now();
+                    _e.label = 1;
+                case 1:
+                    (_b = control.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
+                    step = run.next();
+                    if (step.done) {
+                        (_c = control.onProgress) === null || _c === void 0 ? void 0 : _c.call(control, { fraction: 1, groups: step.value.length });
+                        return [2 /*return*/, step.value];
+                    }
+                    if (!(performance.now() - last >= slice)) return [3 /*break*/, 3];
+                    (_d = control.onProgress) === null || _d === void 0 ? void 0 : _d.call(control, step.value);
+                    return [4 /*yield*/, yieldToEventLoop()];
+                case 2:
+                    _e.sent();
+                    last = performance.now();
+                    _e.label = 3;
+                case 3: return [3 /*break*/, 1];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * Lets pending events run. A message is used rather than `setTimeout(0)`,
+ * which browsers clamp to about a second in background tabs: detection
+ * would crawl as soon as the user switched tabs.
+ */
+function yieldToEventLoop() {
+    if (typeof MessageChannel === 'undefined') {
+        return new Promise(function (resolve) { return setTimeout(resolve, 0); });
+    }
+    return new Promise(function (resolve) {
+        var channel = new MessageChannel();
+        channel.port1.onmessage = function () {
+            channel.port1.close();
+            channel.port2.close();
+            resolve();
+        };
+        channel.port2.postMessage(undefined);
+    });
+}
+/** The detection, yielding progress at points where it may pause. */
+function detect(db, options, cache) {
+    var minInstances, minEntities, minSavings, maxEntities, agreement, neighborLimit, maxSeeds, allowMirror, allowScale, searchOptions, _a, nodes, texts, _b, _c, done, e_1_1, seeds, i, _d, _e, j, ab, ba, _f, key, a, b, list, keys, claimed, index, textGrid, clusterOf, context, pool, clusters, k, pairs, occurrences, aligned, need, idsOf, rounds, members, localSaving, estimate, rounds_1, rounds_1_1, round, labels, size, local, saving, best, pass, grown, absorbed, grown_1, grown_1_1, i, owner, released, verified, before, after, absorbed_1, absorbed_1_1, cluster_1, _g, _h, id, shapeIds, inside, withTexts, instanceCount, cluster, _j, _k, id;
+    var e_1, _l, e_2, _m, e_3, _o, e_4, _p, e_5, _q, e_6, _r, e_7, _s;
+    var _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3;
+    return __generator(this, function (_4) {
+        switch (_4.label) {
+            case 0:
+                minInstances = Math.max(2, (_t = options.minInstances) !== null && _t !== void 0 ? _t : 3);
+                minEntities = Math.max(1, (_u = options.minEntities) !== null && _u !== void 0 ? _u : 2);
+                minSavings = (_v = options.minSavings) !== null && _v !== void 0 ? _v : 10;
+                maxEntities = (_w = options.maxEntities) !== null && _w !== void 0 ? _w : 64;
+                agreement = (_x = options.agreement) !== null && _x !== void 0 ? _x : 0.8;
+                neighborLimit = (_y = options.neighborLimit) !== null && _y !== void 0 ? _y : 24;
+                maxSeeds = (_z = options.maxSeeds) !== null && _z !== void 0 ? _z : Infinity;
+                allowMirror = (_0 = options.allowMirror) !== null && _0 !== void 0 ? _0 : true;
+                allowScale = (_1 = options.allowScale) !== null && _1 !== void 0 ? _1 : false;
+                searchOptions = {
+                    allowRotation: options.allowRotation,
+                    allowMirror: allowMirror,
+                    allowScale: allowScale,
+                    matchLayer: (_2 = options.matchLayer) !== null && _2 !== void 0 ? _2 : true,
+                    textVariations: (_3 = options.textVariations) !== null && _3 !== void 0 ? _3 : true
+                };
+                _a = collect(db, searchOptions.matchLayer, cache), nodes = _a.nodes, texts = _a.texts;
+                if (nodes.length < minInstances * minEntities)
+                    return [2 /*return*/, []];
+                return [4 /*yield*/, { fraction: 0.02, groups: 0 }];
+            case 1:
+                _4.sent();
+                _4.label = 2;
+            case 2:
+                _4.trys.push([2, 7, 8, 9]);
+                _b = __values(linkNeighbors(nodes, neighborLimit)), _c = _b.next();
+                _4.label = 3;
+            case 3:
+                if (!!_c.done) return [3 /*break*/, 6];
+                done = _c.value;
+                return [4 /*yield*/, { fraction: 0.02 + 0.13 * done, groups: 0 }];
+            case 4:
+                _4.sent();
+                _4.label = 5;
+            case 5:
+                _c = _b.next();
+                return [3 /*break*/, 3];
+            case 6: return [3 /*break*/, 9];
+            case 7:
+                e_1_1 = _4.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 9];
+            case 8:
+                try {
+                    if (_c && !_c.done && (_l = _b.return)) _l.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+                return [7 /*endfinally*/];
+            case 9:
+                seeds = new Map();
+                i = 0;
+                _4.label = 10;
+            case 10:
+                if (!(i < nodes.length)) return [3 /*break*/, 14];
+                if (!(i % 1000 === 0)) return [3 /*break*/, 12];
+                return [4 /*yield*/, { fraction: 0.15 + (0.1 * i) / nodes.length, groups: 0 }];
+            case 11:
+                _4.sent();
+                _4.label = 12;
+            case 12:
+                try {
+                    for (_d = (e_2 = void 0, __values(nodes[i].neighbors)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        j = _e.value;
+                        if (j <= i)
+                            continue;
+                        ab = pairKey(nodes[i], nodes[j], allowMirror, allowScale);
+                        ba = pairKey(nodes[j], nodes[i], allowMirror, allowScale);
+                        if (!ab || !ba)
+                            continue;
+                        _f = __read(ab <= ba ? [ab, i, j] : [ba, j, i], 3), key = _f[0], a = _f[1], b = _f[2];
+                        list = seeds.get(key);
+                        if (list)
+                            list.push(a, b);
+                        else
+                            seeds.set(key, [a, b]);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_m = _d.return)) _m.call(_d);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                _4.label = 13;
+            case 13:
+                i++;
+                return [3 /*break*/, 10];
+            case 14:
+                keys = __spreadArray([], __read(seeds.entries()), false).filter(function (_a) {
+                    var _b = __read(_a, 2), pairs = _b[1];
+                    return pairs.length / 2 >= minInstances;
+                })
+                    .sort(function (x, y) { return y[1].length - x[1].length; })
+                    .slice(0, maxSeeds);
+                claimed = new Set();
+                index = new NodeIndex(nodes);
+                textGrid = new TextGrid(texts, medianRadius(nodes));
+                clusterOf = new Map();
+                context = {
+                    db: db,
+                    options: searchOptions,
+                    cache: cache,
+                    claimed: claimed
+                };
+                pool = AcApSmartBlockCandidatePool.fromDatabase(db, searchOptions.matchLayer, cache);
+                clusters = [];
+                k = 0;
+                _4.label = 15;
+            case 15:
+                if (!(k < keys.length)) return [3 /*break*/, 18];
+                return [4 /*yield*/, { fraction: 0.25 + (0.75 * k) / keys.length, groups: clusters.length }];
+            case 16:
+                _4.sent();
+                pairs = keys[k][1];
+                occurrences = pickOccurrences(nodes, pairs, claimed);
+                if (occurrences.length < minInstances)
+                    return [3 /*break*/, 17];
+                aligned = alignOccurrences(nodes, occurrences, allowMirror);
+                if (aligned.length < minInstances)
+                    return [3 /*break*/, 17];
+                need = Math.max(minInstances, Math.ceil(agreement * aligned.length));
+                idsOf = function (list) { return list.map(function (i) { return nodes[i].id; }); };
+                rounds = grow(nodes, aligned, claimed, need, maxEntities);
+                members = [];
+                localSaving = 0;
+                estimate = 0;
+                try {
+                    for (rounds_1 = (e_3 = void 0, __values(rounds)), rounds_1_1 = rounds_1.next(); !rounds_1_1.done; rounds_1_1 = rounds_1.next()) {
+                        round = rounds_1_1.value;
+                        if (round.members.length < minEntities)
+                            continue;
+                        if (round.complete < minInstances)
+                            continue;
+                        labels = textsInside(textGrid, round.members.map(function (i) { return nodes[i]; }), claimed).length;
+                        size = round.members.length + labels;
+                        if (round.complete * (size - 1) < minSavings)
+                            continue;
+                        if (isDegenerate(round.members.map(function (i) { return nodes[i].feature; })))
+                            continue;
+                        local = localCopies(nodes, round, searchOptions);
+                        saving = (local + 1) * (round.members.length - 1);
+                        if (local + 1 >= minInstances && saving >= localSaving) {
+                            members = round.members;
+                            localSaving = saving;
+                            estimate = (local + 1) * (size - 1);
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (rounds_1_1 && !rounds_1_1.done && (_o = rounds_1.return)) _o.call(rounds_1);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+                if (members.length === 0 || estimate < minSavings)
+                    return [3 /*break*/, 17];
+                best = verify(context, idsOf(members), pool);
+                if (best.length + 1 < minInstances)
+                    return [3 /*break*/, 17];
+                // The seed occurrences may play different roles inside one symbol
+                // (the same arc-and-line pair at a corner and at an end), which stops
+                // growth early. Verified copies are consistent, so grow again from them
+                // and keep the result while it saves more.
+                for (pass = 0; pass < 8 && members.length < maxEntities; pass++) {
+                    grown = refine(nodes, index, members, best, Math.max(minInstances, Math.ceil(agreement * (best.length + 1))), maxEntities);
+                    if (grown.length === members.length)
+                        break;
+                    absorbed = new Set();
+                    try {
+                        for (grown_1 = (e_4 = void 0, __values(grown)), grown_1_1 = grown_1.next(); !grown_1_1.done; grown_1_1 = grown_1.next()) {
+                            i = grown_1_1.value;
+                            owner = clusterOf.get(nodes[i].id);
+                            if (owner)
+                                absorbed.add(owner);
+                        }
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (grown_1_1 && !grown_1_1.done && (_p = grown_1.return)) _p.call(grown_1);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                    }
+                    released = __spreadArray([], __read(absorbed), false).flatMap(clusterIds);
+                    released.forEach(function (id) { return claimed.delete(id); });
+                    verified = verify(context, idsOf(grown), pool);
+                    before = (best.length + 1) * (members.length - 1) +
+                        __spreadArray([], __read(absorbed), false).reduce(function (sum, c) { return sum + c.savings; }, 0);
+                    after = (verified.length + 1) * (grown.length - 1);
+                    if (verified.length + 1 < minInstances || after <= before) {
+                        released.forEach(function (id) { return claimed.add(id); });
+                        break;
+                    }
+                    try {
+                        for (absorbed_1 = (e_5 = void 0, __values(absorbed)), absorbed_1_1 = absorbed_1.next(); !absorbed_1_1.done; absorbed_1_1 = absorbed_1.next()) {
+                            cluster_1 = absorbed_1_1.value;
+                            clusters.splice(clusters.indexOf(cluster_1), 1);
+                            try {
+                                for (_g = (e_6 = void 0, __values(clusterIds(cluster_1))), _h = _g.next(); !_h.done; _h = _g.next()) {
+                                    id = _h.value;
+                                    clusterOf.delete(id);
+                                }
+                            }
+                            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                            finally {
+                                try {
+                                    if (_h && !_h.done && (_r = _g.return)) _r.call(_g);
+                                }
+                                finally { if (e_6) throw e_6.error; }
+                            }
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (absorbed_1_1 && !absorbed_1_1.done && (_q = absorbed_1.return)) _q.call(absorbed_1);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                    members = grown;
+                    best = verified;
+                }
+                shapeIds = idsOf(members);
+                inside = textsInside(textGrid, members.map(function (i) { return nodes[i]; }), claimed);
+                if (inside.length > 0) {
+                    withTexts = verify(context, __spreadArray(__spreadArray([], __read(shapeIds), false), __read(inside), false), pool);
+                    if (withTexts.length + 1 >= Math.max(2, agreement * (best.length + 1))) {
+                        best = withTexts;
+                        shapeIds.push.apply(shapeIds, __spreadArray([], __read(inside), false));
+                    }
+                }
+                if (best.length + 1 < minInstances)
+                    return [3 /*break*/, 17];
+                if ((best.length + 1) * (shapeIds.length - 1) < minSavings)
+                    return [3 /*break*/, 17];
+                instanceCount = best.length + 1;
+                cluster = {
+                    ids: shapeIds,
+                    matches: best,
+                    instanceCount: instanceCount,
+                    entityCount: shapeIds.length,
+                    savings: instanceCount * (shapeIds.length - 1)
+                };
+                clusters.push(cluster);
+                try {
+                    for (_j = (e_7 = void 0, __values(clusterIds(cluster))), _k = _j.next(); !_k.done; _k = _j.next()) {
+                        id = _k.value;
+                        claimed.add(id);
+                        clusterOf.set(id, cluster);
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (_k && !_k.done && (_s = _j.return)) _s.call(_j);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+                _4.label = 17;
+            case 17:
+                k++;
+                return [3 /*break*/, 15];
+            case 18: return [2 /*return*/, clusters.sort(function (x, y) { return y.savings - x.savings; })];
+        }
+    });
+}
+function collect(db, matchLayer, cache) {
+    var e_8, _a, e_9, _b, e_10, _c;
+    var entities = new Map();
+    try {
+        for (var _d = __values(db.tables.blockTable.modelSpace.newIterator()), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var entity = _e.value;
+            if (entity.visibility)
+                entities.set(entity.objectId, entity);
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    var unlocked = excludeLockedLayerIds(db, __spreadArray([], __read(entities.keys()), false)).ids;
+    var nodes = [];
+    var texts = [];
+    try {
+        for (var unlocked_1 = __values(unlocked), unlocked_1_1 = unlocked_1.next(); !unlocked_1_1.done; unlocked_1_1 = unlocked_1.next()) {
+            var id = unlocked_1_1.value;
+            var entity = entities.get(id);
+            var feature = cache.get(entity, matchLayer);
+            if (!feature)
+                continue;
+            if (feature.label !== undefined) {
+                var ext = entity.geometricExtents;
+                texts.push({
+                    id: id,
+                    center: ext.isEmpty()
+                        ? feature.center
+                        : {
+                            x: (ext.min.x + ext.max.x) / 2,
+                            y: (ext.min.y + ext.max.y) / 2
+                        }
+                });
+                continue;
+            }
+            var radius = 0;
+            try {
+                for (var _f = (e_10 = void 0, __values(feature.points)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var p = _g.value;
+                    radius = Math.max(radius, dist(p, feature.center));
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+            if (feature.points.length === 0)
+                radius = feature.size;
+            nodes.push({ id: id, feature: feature, radius: radius, neighbors: [] });
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (unlocked_1_1 && !unlocked_1_1.done && (_b = unlocked_1.return)) _b.call(unlocked_1);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    return { nodes: nodes, texts: texts };
+}
+/**
+ * Links shapes that touch: a characteristic point (or center) of one lies
+ * in the other's padded bounds. Points are indexed in a uniform grid, so a
+ * lookup only scans the cells the bounds cover; very long shapes only look
+ * around their own points.
+ */
+function linkNeighbors(nodes, limit) {
+    var grid, points, found, scan, boxes, i, n, minX, minY, maxX, maxY, _a, _b, p, pad, cells, _c, _d, p, centers, extent, _loop_1, i;
+    var e_11, _e, e_12, _f;
+    return __generator(this, function (_g) {
+        switch (_g.label) {
+            case 0:
+                grid = new CellGrid(medianRadius(nodes));
+                points = nodes.map(function (n) { return __spreadArray([n.feature.center], __read(n.feature.points), false); });
+                points.forEach(function (list, i) {
+                    var e_13, _a;
+                    try {
+                        for (var list_1 = __values(list), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+                            var p = list_1_1.value;
+                            grid.add(p.x, p.y, i);
+                        }
+                    }
+                    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+                    finally {
+                        try {
+                            if (list_1_1 && !list_1_1.done && (_a = list_1.return)) _a.call(list_1);
+                        }
+                        finally { if (e_13) throw e_13.error; }
+                    }
+                });
+                found = nodes.map(function () { return new Set(); });
+                scan = function (i, minX, minY, maxX, maxY) {
+                    grid.forEachIn(minX, minY, maxX, maxY, function (j) {
+                        var e_14, _a;
+                        if (j === i || found[i].has(j))
+                            return;
+                        try {
+                            for (var _b = __values(points[j]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                var p = _c.value;
+                                if (p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY) {
+                                    found[i].add(j);
+                                    found[j].add(i);
+                                    return;
+                                }
+                            }
+                        }
+                        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+                        finally {
+                            try {
+                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                            }
+                            finally { if (e_14) throw e_14.error; }
+                        }
+                    });
+                };
+                boxes = [];
+                i = 0;
+                _g.label = 1;
+            case 1:
+                if (!(i < nodes.length)) return [3 /*break*/, 5];
+                if (!(i % 2000 === 0)) return [3 /*break*/, 3];
+                return [4 /*yield*/, (0.6 * i) / nodes.length];
+            case 2:
+                _g.sent();
+                _g.label = 3;
+            case 3:
+                n = nodes[i];
+                minX = Infinity;
+                minY = Infinity;
+                maxX = -Infinity;
+                maxY = -Infinity;
+                try {
+                    for (_a = (e_11 = void 0, __values(points[i])), _b = _a.next(); !_b.done; _b = _a.next()) {
+                        p = _b.value;
+                        minX = Math.min(minX, p.x);
+                        minY = Math.min(minY, p.y);
+                        maxX = Math.max(maxX, p.x);
+                        maxY = Math.max(maxY, p.y);
+                    }
+                }
+                catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                finally {
+                    try {
+                        if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                    }
+                    finally { if (e_11) throw e_11.error; }
+                }
+                if (n.feature.points.length === 0) {
+                    minX -= n.radius;
+                    minY -= n.radius;
+                    maxX += n.radius;
+                    maxY += n.radius;
+                }
+                boxes.push({ minX: minX, minY: minY, maxX: maxX, maxY: maxY });
+                pad = Math.max(n.radius * 0.05, grid.cell * 1e-3);
+                cells = ((maxX - minX) / grid.cell + 1) * ((maxY - minY) / grid.cell + 1);
+                if (cells <= 400) {
+                    scan(i, minX - pad, minY - pad, maxX + pad, maxY + pad);
+                }
+                else {
+                    try {
+                        // Long shapes only look around their own points.
+                        for (_c = (e_12 = void 0, __values(points[i])), _d = _c.next(); !_d.done; _d = _c.next()) {
+                            p = _d.value;
+                            scan(i, p.x - pad, p.y - pad, p.x + pad, p.y + pad);
+                        }
+                    }
+                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+                    finally {
+                        try {
+                            if (_d && !_d.done && (_f = _c.return)) _f.call(_c);
+                        }
+                        finally { if (e_12) throw e_12.error; }
+                    }
+                }
+                _g.label = 4;
+            case 4:
+                i++;
+                return [3 /*break*/, 1];
+            case 5:
+                centers = new CellGrid(grid.cell);
+                nodes.forEach(function (n, i) {
+                    return centers.add(n.feature.center.x, n.feature.center.y, i);
+                });
+                extent = function (b) { return Math.max(b.maxX - b.minX, b.maxY - b.minY); };
+                _loop_1 = function (i) {
+                    var n, reach, c, box;
+                    return __generator(this, function (_h) {
+                        switch (_h.label) {
+                            case 0:
+                                if (!(i % 2000 === 0)) return [3 /*break*/, 2];
+                                return [4 /*yield*/, 0.6 + (0.3 * i) / nodes.length];
+                            case 1:
+                                _h.sent();
+                                _h.label = 2;
+                            case 2:
+                                n = nodes[i];
+                                if (!(n.radius > 0) || n.radius > grid.cell * 10)
+                                    return [2 /*return*/, "continue"];
+                                reach = n.radius * 3;
+                                c = n.feature.center;
+                                box = boxes[i];
+                                centers.forEachIn(c.x - reach, c.y - reach, c.x + reach, c.y + reach, function (j) {
+                                    if (j === i || found[i].has(j))
+                                        return;
+                                    var other = boxes[j];
+                                    var gap = Math.max(other.minX - box.maxX, box.minX - other.maxX, other.minY - box.maxY, box.minY - other.maxY, 0);
+                                    if (gap <= Math.min(extent(box), extent(other))) {
+                                        found[i].add(j);
+                                        found[j].add(i);
+                                    }
+                                });
+                                return [2 /*return*/];
+                        }
+                    });
+                };
+                i = 0;
+                _g.label = 6;
+            case 6:
+                if (!(i < nodes.length)) return [3 /*break*/, 9];
+                return [5 /*yield**/, _loop_1(i)];
+            case 7:
+                _g.sent();
+                _g.label = 8;
+            case 8:
+                i++;
+                return [3 /*break*/, 6];
+            case 9: return [4 /*yield*/, 0.9];
+            case 10:
+                _g.sent();
+                nodes.forEach(function (n, i) {
+                    n.neighbors = __spreadArray([], __read(found[i]), false).sort(function (a, b) {
+                        return dist(nodes[a].feature.center, n.feature.center) -
+                            dist(nodes[b].feature.center, n.feature.center);
+                    })
+                        .slice(0, limit);
+                });
+                // Keep the relation symmetric after the cut.
+                nodes.forEach(function (n, i) {
+                    var e_15, _a;
+                    try {
+                        for (var _b = __values(n.neighbors), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            var j = _c.value;
+                            if (!nodes[j].neighbors.includes(i))
+                                nodes[j].neighbors.push(i);
+                        }
+                    }
+                    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        }
+                        finally { if (e_15) throw e_15.error; }
+                    }
+                });
+                return [2 /*return*/];
+        }
+    });
+}
+/**
+ * Frame of the pair `a → b`: the axis runs between the centers; for shapes
+ * sharing a center it points at `a`'s (else `b`'s) farthest point.
+ */
+function pairFrame(a, b) {
+    var _a;
+    var origin = a.feature.center;
+    var length = Math.max(dist(origin, b.feature.center), a.radius, b.radius);
+    if (!(length > 0))
+        return undefined;
+    // Centers closer than the key's resolution count as shared: the
+    // direction between them is noise (concentric arcs from PDF imports).
+    var eps = length * 0.01;
+    var v = sub(b.feature.center, origin);
+    if (Math.hypot(v.x, v.y) <= eps) {
+        var far = (_a = farthest(a)) !== null && _a !== void 0 ? _a : farthest(b);
+        v = far ? sub(far, origin) : { x: 1, y: 0 };
+    }
+    var len = Math.hypot(v.x, v.y);
+    if (!(len > 0))
+        return undefined;
+    return { origin: origin, u: { x: v.x / len, y: v.y / len }, length: length };
+}
+function farthest(n) {
+    var e_16, _a;
+    var max = 0;
+    try {
+        for (var _b = __values(n.feature.points), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var p = _c.value;
+            max = Math.max(max, dist(p, n.feature.center));
+        }
+    }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_16) throw e_16.error; }
+    }
+    if (!(max > 0))
+        return undefined;
+    // Near-ties (arc end points, symmetric outlines) go to the first point,
+    // so copies pick the same one despite rounding noise.
+    return n.feature.points.find(function (p) { return dist(p, n.feature.center) >= max * 0.999; });
+}
+/** Second moments of a shape's points about its center, in `frame`. */
+function moments(n, frame) {
+    var e_17, _a;
+    var points = n.feature.points;
+    if (points.length === 0)
+        return [0, 0, 0];
+    var xx = 0;
+    var yy = 0;
+    var xy = 0;
+    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;
+            var d = sub(p, n.feature.center);
+            var x = d.x * frame.u.x + d.y * frame.u.y;
+            var y = d.y * frame.u.x - d.x * frame.u.y;
+            xx += x * x;
+            yy += y * y;
+            xy += x * y;
+        }
+    }
+    catch (e_17_1) { e_17 = { error: e_17_1 }; }
+    finally {
+        try {
+            if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+        }
+        finally { if (e_17) throw e_17.error; }
+    }
+    var k = points.length * frame.length * frame.length;
+    return [xx / k, yy / k, xy / k];
+}
+/**
+ * Key of the ordered pair `a → b` that is invariant under translation and
+ * rotation, under mirroring when allowed, and under scaling when allowed.
+ */
+function pairKey(a, b, allowMirror, allowScale) {
+    var frame = pairFrame(a, b);
+    if (!frame)
+        return undefined;
+    var q = function (v) { return Math.round(v * 50); };
+    var qm = function (v) { return Math.round(v * 200); };
+    var ma = moments(a, frame).map(qm);
+    var mb = moments(b, frame).map(qm);
+    if (allowMirror) {
+        // Mirroring across the axis flips the xy moments of both shapes.
+        var first = ma[2] !== 0 ? ma[2] : mb[2];
+        if (first < 0) {
+            ma[2] = -ma[2];
+            mb[2] = -mb[2];
+        }
+    }
+    var scale = allowScale
+        ? 0
+        : Math.round(Math.log(frame.length) / Math.log(1.05));
+    return __spreadArray(__spreadArray(__spreadArray([
+        a.feature.kind,
+        b.feature.kind,
+        q(a.feature.size / frame.length),
+        q(b.feature.size / frame.length),
+        q(dist(a.feature.center, b.feature.center) / frame.length)
+    ], __read(ma), false), __read(mb), false), [
+        scale
+    ], false).join('|');
+}
+/** Free, non-overlapping occurrences of a seed key (evenly sampled). */
+function pickOccurrences(nodes, pairs, claimed) {
+    var used = new Set();
+    var result = [];
+    for (var k = 0; k < pairs.length; k += 2) {
+        var a = pairs[k];
+        var b = pairs[k + 1];
+        if (used.has(a) || used.has(b))
+            continue;
+        if (claimed.has(nodes[a].id) || claimed.has(nodes[b].id))
+            continue;
+        var frame = pairFrame(nodes[a], nodes[b]);
+        if (!frame)
+            continue;
+        used.add(a);
+        used.add(b);
+        result.push({ a: a, b: b, frame: frame });
+    }
+    // Voting on a sample keeps dense patterns cheap; verification later
+    // finds every copy anyway.
+    var max = 200;
+    if (result.length <= max)
+        return result;
+    var step = result.length / max;
+    return Array.from({ length: max }, function (_, i) { return result[Math.floor(i * step)]; });
+}
+/** Maps a frame's local coordinates (scaled) into the drawing. */
+function frameAffine(frame, scale) {
+    var u = frame.u, origin = frame.origin;
+    return {
+        a: u.x * scale,
+        b: u.y * scale,
+        c: -u.y * scale,
+        d: u.x * scale,
+        e: origin.x,
+        f: origin.y
+    };
+}
+/**
+ * Computes, for every occurrence, the similarity that maps the first
+ * occurrence onto it, checking that both seed shapes really land on their
+ * counterparts. Occurrences that do not fit are dropped.
+ */
+function alignOccurrences(nodes, occurrences, allowMirror) {
+    var e_18, _a, e_19, _b, e_20, _c;
+    var ref = occurrences[0];
+    var toLocal = acapInvertAffine2d(frameAffine(ref.frame, 1));
+    var flip = { a: 1, b: 0, c: 0, d: -1, e: 0, f: 0 };
+    var locals = allowMirror
+        ? [toLocal, acapComposeAffine2d(flip, toLocal)]
+        : [toLocal];
+    var result = [];
+    try {
+        for (var occurrences_1 = __values(occurrences), occurrences_1_1 = occurrences_1.next(); !occurrences_1_1.done; occurrences_1_1 = occurrences_1.next()) {
+            var occ = occurrences_1_1.value;
+            var scale = occ.frame.length / ref.frame.length;
+            var tol = occ.frame.length * 0.01;
+            // A pair of equal shapes may appear in either order.
+            var orders = [[occ.a, occ.b]];
+            if (nodes[occ.a].feature.kind === nodes[occ.b].feature.kind) {
+                orders.push([occ.b, occ.a]);
+            }
+            var transforms = [];
+            try {
+                for (var orders_1 = (e_19 = void 0, __values(orders)), orders_1_1 = orders_1.next(); !orders_1_1.done; orders_1_1 = orders_1.next()) {
+                    var _d = __read(orders_1_1.value, 2), a = _d[0], b = _d[1];
+                    var frame = pairFrame(nodes[a], nodes[b]);
+                    if (!frame)
+                        continue;
+                    var toWorld = frameAffine(frame, scale);
+                    try {
+                        for (var locals_1 = (e_20 = void 0, __values(locals)), locals_1_1 = locals_1.next(); !locals_1_1.done; locals_1_1 = locals_1.next()) {
+                            var local = locals_1_1.value;
+                            var t = acapComposeAffine2d(toWorld, local);
+                            if (lands(nodes[ref.a], nodes[a], t, scale, tol) &&
+                                lands(nodes[ref.b], nodes[b], t, scale, tol)) {
+                                transforms.push(t);
+                            }
+                        }
+                    }
+                    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                    finally {
+                        try {
+                            if (locals_1_1 && !locals_1_1.done && (_c = locals_1.return)) _c.call(locals_1);
+                        }
+                        finally { if (e_20) throw e_20.error; }
+                    }
+                }
+            }
+            catch (e_19_1) { e_19 = { error: e_19_1 }; }
+            finally {
+                try {
+                    if (orders_1_1 && !orders_1_1.done && (_b = orders_1.return)) _b.call(orders_1);
+                }
+                finally { if (e_19) throw e_19.error; }
+            }
+            if (transforms.length > 0)
+                result.push(__assign(__assign({}, occ), { transforms: transforms, scale: scale }));
+        }
+    }
+    catch (e_18_1) { e_18 = { error: e_18_1 }; }
+    finally {
+        try {
+            if (occurrences_1_1 && !occurrences_1_1.done && (_a = occurrences_1.return)) _a.call(occurrences_1);
+        }
+        finally { if (e_18) throw e_18.error; }
+    }
+    return result;
+}
+function lands(from, to, t, scale, tol) {
+    if (Math.abs(from.feature.size * scale - to.feature.size) > tol)
+        return false;
+    if (dist(acedApplyAffine2d(t, from.feature.center), to.feature.center) > tol)
+        return false;
+    return acedShapeLandsOn(from.feature, to.feature, t, tol);
+}
+/**
+ * Grows the seed pair into the shapes most occurrences share. Returns one
+ * snapshot per round (the seed pair first): the member nodes of the first
+ * (reference) occurrence and how many occurrences found all of them.
+ *
+ * Each round looks at the free shapes touching the reference occurrence's
+ * newest members. A shape joins when, in enough other occurrences, a
+ * touching shape lands on it under that occurrence's transform (same kind,
+ * size and characteristic points). Shapes that differ around each copy,
+ * such as walls of varying length, never collect enough votes.
+ */
+function grow(nodes, occurrences, claimed, need, maxEntities) {
+    var e_21, _a;
+    var ref = occurrences[0];
+    var members = occurrences.map(function (o) { return new Set([o.a, o.b]); });
+    var frontier = occurrences.map(function (o) { return [o.a, o.b]; });
+    // Every shape belongs to one occurrence only.
+    var owner = new Map();
+    occurrences.forEach(function (o, i) {
+        owner.set(o.a, i);
+        owner.set(o.b, i);
+    });
+    var free = function (i) {
+        var e_22, _a, e_23, _b;
+        var seen = new Set();
+        try {
+            for (var _c = __values(frontier[i]), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var f = _d.value;
+                try {
+                    for (var _e = (e_23 = void 0, __values(nodes[f].neighbors)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var nb = _f.value;
+                        if (members[i].has(nb) || claimed.has(nodes[nb].id))
+                            continue;
+                        var o = owner.get(nb);
+                        if (o === undefined || o === i)
+                            seen.add(nb);
+                    }
+                }
+                catch (e_23_1) { e_23 = { error: e_23_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_23) throw e_23.error; }
+                }
+            }
+        }
+        catch (e_22_1) { e_22 = { error: e_22_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_22) throw e_22.error; }
+        }
+        return __spreadArray([], __read(seen), false);
+    };
+    var rounds = [];
+    var snapshot = function () {
+        var size = members[0].size;
+        rounds.push({
+            members: __spreadArray([], __read(members[0]), false),
+            complete: members.filter(function (m) { return m.size === size; }).length,
+            collected: members.slice(1).flatMap(function (m) { return __spreadArray([], __read(m), false); })
+        });
+    };
+    snapshot();
+    while (members[0].size < maxEntities) {
+        var candidates = occurrences.map(function (_, i) { return free(i); });
+        var next = occurrences.map(function () { return []; });
+        var _loop_2 = function (r) {
+            var e_24, _d;
+            if (owner.has(r))
+                return "continue";
+            var hits = [];
+            // Transform errors grow with the distance from the seed.
+            var reach = dist(nodes[r].feature.center, ref.frame.origin);
+            var _loop_3 = function (i) {
+                var e_25, _f;
+                var occ = occurrences[i];
+                var tol = occ.scale * (ref.frame.length * 0.01 + reach * 0.03);
+                var _loop_4 = function (c) {
+                    if (owner.has(c))
+                        return "continue";
+                    if (nodes[c].feature.kind !== nodes[r].feature.kind)
+                        return "continue";
+                    var fits = occ.transforms.filter(function (t) {
+                        return lands(nodes[r], nodes[c], t, occ.scale, tol);
+                    });
+                    if (fits.length > 0) {
+                        hits.push([i, c, fits]);
+                        return "break";
+                    }
+                };
+                try {
+                    for (var _g = (e_25 = void 0, __values(candidates[i])), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var c = _h.value;
+                        var state_2 = _loop_4(c);
+                        if (state_2 === "break")
+                            break;
+                    }
+                }
+                catch (e_25_1) { e_25 = { error: e_25_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_f = _g.return)) _f.call(_g);
+                    }
+                    finally { if (e_25) throw e_25.error; }
+                }
+            };
+            for (var i = 1; i < occurrences.length; i++) {
+                _loop_3(i);
+            }
+            if (hits.length + 1 < need)
+                return "continue";
+            owner.set(r, 0);
+            members[0].add(r);
+            next[0].push(r);
+            try {
+                for (var hits_1 = (e_24 = void 0, __values(hits)), hits_1_1 = hits_1.next(); !hits_1_1.done; hits_1_1 = hits_1.next()) {
+                    var _e = __read(hits_1_1.value, 3), i = _e[0], x = _e[1], fits = _e[2];
+                    occurrences[i].transforms = fits;
+                    owner.set(x, i);
+                    members[i].add(x);
+                    next[i].push(x);
+                }
+            }
+            catch (e_24_1) { e_24 = { error: e_24_1 }; }
+            finally {
+                try {
+                    if (hits_1_1 && !hits_1_1.done && (_d = hits_1.return)) _d.call(hits_1);
+                }
+                finally { if (e_24) throw e_24.error; }
+            }
+            if (members[0].size >= maxEntities)
+                return "break";
+        };
+        try {
+            for (var _b = (e_21 = void 0, __values(candidates[0])), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var r = _c.value;
+                var state_1 = _loop_2(r);
+                if (state_1 === "break")
+                    break;
+            }
+        }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_21) throw e_21.error; }
+        }
+        if (next[0].length === 0)
+            break;
+        frontier = next;
+        snapshot();
+    }
+    return rounds;
+}
+/** Uniform grid of indices; cells are nested numeric maps (no string keys). */
+var CellGrid = /** @class */ (function () {
+    function CellGrid(cell) {
+        this.cell = cell;
+        this.cells = new Map();
+    }
+    /** Adds `index` at `(x, y)`; repeated adds of the same index are folded. */
+    CellGrid.prototype.add = function (x, y, index) {
+        var gx = Math.floor(x / this.cell);
+        var gy = Math.floor(y / this.cell);
+        var column = this.cells.get(gx);
+        if (!column)
+            this.cells.set(gx, (column = new Map()));
+        var list = column.get(gy);
+        if (!list)
+            column.set(gy, [index]);
+        else if (list[list.length - 1] !== index)
+            list.push(index);
+    };
+    /** Visits the indices of every cell the box touches (may repeat). */
+    CellGrid.prototype.forEachIn = function (minX, minY, maxX, maxY, visit) {
+        var e_26, _a;
+        var y0 = Math.floor(minY / this.cell);
+        var y1 = Math.floor(maxY / this.cell);
+        for (var gx = Math.floor(minX / this.cell); gx <= Math.floor(maxX / this.cell); gx++) {
+            var column = this.cells.get(gx);
+            if (!column)
+                continue;
+            for (var gy = y0; gy <= y1; gy++) {
+                var list = column.get(gy);
+                if (list)
+                    try {
+                        for (var list_2 = (e_26 = void 0, __values(list)), list_2_1 = list_2.next(); !list_2_1.done; list_2_1 = list_2.next()) {
+                            var index = list_2_1.value;
+                            visit(index);
+                        }
+                    }
+                    catch (e_26_1) { e_26 = { error: e_26_1 }; }
+                    finally {
+                        try {
+                            if (list_2_1 && !list_2_1.done && (_a = list_2.return)) _a.call(list_2);
+                        }
+                        finally { if (e_26) throw e_26.error; }
+                    }
+            }
+        }
+    };
+    return CellGrid;
+}());
+function medianRadius(nodes) {
+    var _a;
+    var radii = nodes
+        .map(function (n) { return n.radius; })
+        .filter(function (r) { return r > 0; })
+        .sort(function (a, b) { return a - b; });
+    return Math.max((_a = radii[Math.floor(radii.length / 2)]) !== null && _a !== void 0 ? _a : 1, 1e-9);
+}
+/** Node lookup by center position. */
+var NodeIndex = /** @class */ (function () {
+    function NodeIndex(nodes) {
+        var _this = this;
+        this.nodes = nodes;
+        this.grid = new CellGrid(medianRadius(nodes));
+        nodes.forEach(function (n, i) {
+            return _this.grid.add(n.feature.center.x, n.feature.center.y, i);
+        });
+    }
+    /** Nodes whose center is within `radius` of `p`. */
+    NodeIndex.prototype.near = function (p, radius) {
+        var _this = this;
+        var result = [];
+        this.grid.forEachIn(p.x - radius, p.y - radius, p.x + radius, p.y + radius, function (i) {
+            if (dist(_this.nodes[i].feature.center, p) <= radius)
+                result.push(i);
+        });
+        return result;
+    };
+    return NodeIndex;
+}());
+/**
+ * Grows a verified group: a shape touching the representative joins when
+ * enough verified copies have the same shape at the same place under their
+ * exact transform. Shapes of other groups may join too; the caller decides
+ * whether absorbing those groups pays off. Returns the member list.
+ */
+function refine(nodes, index, members, matches, need, maxEntities) {
+    var e_27, _a, e_28, _b, e_29, _c;
+    var result = new Set(members);
+    var frontier = members;
+    var extent = 0;
+    try {
+        for (var members_1 = __values(members), members_1_1 = members_1.next(); !members_1_1.done; members_1_1 = members_1.next()) {
+            var i = members_1_1.value;
+            extent = Math.max(extent, dist(nodes[i].feature.center, nodes[members[0]].feature.center) +
+                nodes[i].radius);
+        }
+    }
+    catch (e_27_1) { e_27 = { error: e_27_1 }; }
+    finally {
+        try {
+            if (members_1_1 && !members_1_1.done && (_a = members_1.return)) _a.call(members_1);
+        }
+        finally { if (e_27) throw e_27.error; }
+    }
+    while (frontier.length > 0 && result.size < maxEntities) {
+        var next = [];
+        var seen = new Set();
+        try {
+            for (var frontier_1 = (e_28 = void 0, __values(frontier)), frontier_1_1 = frontier_1.next(); !frontier_1_1.done; frontier_1_1 = frontier_1.next()) {
+                var f = frontier_1_1.value;
+                var _loop_5 = function (r) {
+                    var e_30, _f;
+                    if (seen.has(r) || result.has(r))
+                        return "continue";
+                    seen.add(r);
+                    var node = nodes[r];
+                    var tol = Math.max(extent, node.radius) * 0.01;
+                    var hits = 1;
+                    var _loop_6 = function (match) {
+                        if (match.blockReference)
+                            return "continue";
+                        var t = match.transform;
+                        var c = acedApplyAffine2d(t, node.feature.center);
+                        var found = index
+                            .near(c, tol * match.scale)
+                            .some(function (k) {
+                            return k !== r &&
+                                nodes[k].feature.kind === node.feature.kind &&
+                                lands(node, nodes[k], t, match.scale, tol * match.scale);
+                        });
+                        if (found)
+                            hits++;
+                    };
+                    try {
+                        for (var matches_1 = (e_30 = void 0, __values(matches)), matches_1_1 = matches_1.next(); !matches_1_1.done; matches_1_1 = matches_1.next()) {
+                            var match = matches_1_1.value;
+                            _loop_6(match);
+                        }
+                    }
+                    catch (e_30_1) { e_30 = { error: e_30_1 }; }
+                    finally {
+                        try {
+                            if (matches_1_1 && !matches_1_1.done && (_f = matches_1.return)) _f.call(matches_1);
+                        }
+                        finally { if (e_30) throw e_30.error; }
+                    }
+                    if (hits < need)
+                        return "continue";
+                    result.add(r);
+                    next.push(r);
+                    if (result.size >= maxEntities)
+                        return "break";
+                };
+                try {
+                    for (var _d = (e_29 = void 0, __values(nodes[f].neighbors)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var r = _e.value;
+                        var state_3 = _loop_5(r);
+                        if (state_3 === "break")
+                            break;
+                    }
+                }
+                catch (e_29_1) { e_29 = { error: e_29_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
+                    }
+                    finally { if (e_29) throw e_29.error; }
+                }
+                if (result.size >= maxEntities)
+                    break;
+            }
+        }
+        catch (e_28_1) { e_28 = { error: e_28_1 }; }
+        finally {
+            try {
+                if (frontier_1_1 && !frontier_1_1.done && (_b = frontier_1.return)) _b.call(frontier_1);
+            }
+            finally { if (e_28) throw e_28.error; }
+        }
+        frontier = next;
+    }
+    return __spreadArray([], __read(result), false);
+}
+/**
+ * Rejects groups that are only lines running in one direction (dashed
+ * line pieces, hatch strokes, grid lines) or just two lines (corners):
+ * they repeat everywhere but are not symbols.
+ */
+function isDegenerate(features) {
+    var e_31, _a;
+    // Two lines (a corner, a pair of strokes) occur everywhere in a drawing.
+    if (features.length <= 2 && features.every(isLine)) {
+        return true;
+    }
+    var dir;
+    try {
+        for (var features_1 = __values(features), features_1_1 = features_1.next(); !features_1_1.done; features_1_1 = features_1.next()) {
+            var f = features_1_1.value;
+            if (!isLine(f) || f.points.length !== 2)
+                return false;
+            var d = sub(f.points[1], f.points[0]);
+            var len = Math.hypot(d.x, d.y);
+            if (len === 0)
+                continue;
+            var u = { x: d.x / len, y: d.y / len };
+            if (!dir)
+                dir = u;
+            else if (Math.abs(dir.x * u.y - dir.y * u.x) > 1e-3)
+                return false;
+        }
+    }
+    catch (e_31_1) { e_31 = { error: e_31_1 }; }
+    finally {
+        try {
+            if (features_1_1 && !features_1_1.done && (_a = features_1.return)) _a.call(features_1);
+        }
+        finally { if (e_31) throw e_31.error; }
+    }
+    return true;
+}
+function isLine(f) {
+    return f.kind === 'line' || f.kind.endsWith('|line');
+}
+/**
+ * Copies of a growth round's template among the shapes the other
+ * occurrences collected, found by the exact matcher: a cheap lower bound
+ * of what searching the whole drawing finds.
+ */
+function localCopies(nodes, round, options) {
+    return acedFindShapeMatches(round.members.map(function (i) { return nodes[i].feature; }), round.collected.map(function (i) { return nodes[i].feature; }), {
+        tolerance: options.tolerance,
+        allowRotation: options.allowRotation,
+        allowMirror: options.allowMirror,
+        allowScale: options.allowScale
+    }).length;
+}
+/** Every entity a group uses: the representative and its copies. */
+function clusterIds(cluster) {
+    return __spreadArray(__spreadArray([], __read(cluster.ids), false), __read(cluster.matches.flatMap(function (m) { return m.ids; })), false);
+}
+/** Texts indexed by their extents center. */
+var TextGrid = /** @class */ (function () {
+    function TextGrid(texts, cell) {
+        var _this = this;
+        this.texts = texts;
+        this.grid = new CellGrid(cell);
+        texts.forEach(function (t, i) { return _this.grid.add(t.center.x, t.center.y, i); });
+    }
+    /** Texts whose center lies in the box. */
+    TextGrid.prototype.inBox = function (minX, minY, maxX, maxY) {
+        var _this = this;
+        var found = new Set();
+        this.grid.forEachIn(minX, minY, maxX, maxY, function (i) {
+            var c = _this.texts[i].center;
+            if (c.x >= minX && c.x <= maxX && c.y >= minY && c.y <= maxY) {
+                found.add(i);
+            }
+        });
+        return __spreadArray([], __read(found), false).map(function (i) { return _this.texts[i]; });
+    };
+    return TextGrid;
+}());
+/** Free texts whose extents center lies within the group's bounds. */
+function textsInside(texts, members, claimed) {
+    var e_32, _a;
+    var minX = Infinity;
+    var minY = Infinity;
+    var maxX = -Infinity;
+    var maxY = -Infinity;
+    try {
+        for (var members_2 = __values(members), members_2_1 = members_2.next(); !members_2_1.done; members_2_1 = members_2.next()) {
+            var n = members_2_1.value;
+            var c = n.feature.center;
+            minX = Math.min(minX, c.x - n.radius);
+            minY = Math.min(minY, c.y - n.radius);
+            maxX = Math.max(maxX, c.x + n.radius);
+            maxY = Math.max(maxY, c.y + n.radius);
+        }
+    }
+    catch (e_32_1) { e_32 = { error: e_32_1 }; }
+    finally {
+        try {
+            if (members_2_1 && !members_2_1.done && (_a = members_2.return)) _a.call(members_2);
+        }
+        finally { if (e_32) throw e_32.error; }
+    }
+    return texts
+        .inBox(minX, minY, maxX, maxY)
+        .filter(function (t) { return !claimed.has(t.id); })
+        .map(function (t) { return t.id; });
+}
+/** Verified copies of `ids` that use no claimed entity. */
+function verify(context, ids, pool) {
+    var db = context.db, options = context.options, cache = context.cache, claimed = context.claimed;
+    var template = acapBuildSmartBlockTemplate(db, ids, options);
+    var r = acapFindSmartBlockMatches(db, template, options, cache, pool);
+    return r.filter(function (m) { return m.ids.every(function (id) { return !claimed.has(id); }); });
+}
+function dist(a, b) {
+    var dx = a.x - b.x;
+    var dy = a.y - b.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+function sub(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y };
+}
+//# sourceMappingURL=AcApSmartBlockDetect.js.map