@jax-data-science/sci-image-visualizer 0.9.0 → 0.11.0

package/esm2022/lib/region-editor/region-editor.component.mjs

@@ -1,4 +1,4 @@
-import { ChangeDetectionStrategy, ChangeDetectorRef, Component, DestroyRef, Inject, ViewChild, inject, NgZone, } from '@angular/core';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, DestroyRef, Inject, Input, ViewChild, inject, NgZone, } from '@angular/core';
 import { markForCheckInZone } from '../util/mark-for-check';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { CommonModule } from '@angular/common';
@@ -12,17 +12,24 @@ import { ToolbarModule } from 'primeng/toolbar';
 import { TooltipModule } from 'primeng/tooltip';
 import { saveAs } from 'file-saver';
 import { Subject } from 'rxjs';
-import { Rectangle } from '../models/region';
+import { Rectangle, Region } from '../models/region';
 import { withRegionPatch } from '../models/region-clone';
 import { defaultPresetSet, parsePresetSet } from '../models/class-preset';
 import { colorForLabel, presetKey } from '../store/class-color.util';
 import { ConfirmationService, MessageService, SharedModule } from 'primeng/api';
 import { REGION_EDITOR_API } from '../contracts/region-editor-api.contract';
 import { VIZ_TOAST_KEY } from '../toast-outlets';
+import { HttpClient } from '@angular/common/http';
+import { openGeoJsonRegionSource } from '../region-source/worker-region-source';
+import { openHttpRegionSource } from '../region-source/http-region-source';
+import { readLabelVolume } from '../region-import/label-volume';
+import { labelClasses, labelSliceGeoJson } from '../region-import/label-classes';
+import { folderSliceGeoJson, importFile, planRegionImport, } from '../region-import/region-import';
 import { RegionPersistenceService } from './region-persistence.service';
 import { RegionColorDialogComponent } from './region-color-dialog/region-color-dialog.component';
 import { ClassesPanelComponent } from './classes-panel/classes-panel.component';
 import { RegionTableComponent } from './region-table/region-table.component';
+import { ClassTreeComponent } from './class-tree/class-tree.component';
 import { SaveRegionsDialogComponent } from './save-regions-dialog/save-regions-dialog.component';
 import { SaveMaskDialogComponent } from './save-mask-dialog/save-mask-dialog.component';
 import { ManageClassesDialogComponent } from './manage-classes-dialog/manage-classes-dialog.component';
@@ -33,14 +40,15 @@ import * as i0 from "@angular/core";
 import * as i1 from "primeng/api";
 import * as i2 from "./region-persistence.service";
 import * as i3 from "./mask-export.service";
-import * as i4 from "@angular/forms";
-import * as i5 from "primeng/button";
-import * as i6 from "primeng/confirmdialog";
-import * as i7 from "primeng/dropdown";
-import * as i8 from "primeng/inputtext";
-import * as i9 from "primeng/overlaypanel";
-import * as i10 from "primeng/toolbar";
-import * as i11 from "primeng/tooltip";
+import * as i4 from "@angular/common";
+import * as i5 from "@angular/forms";
+import * as i6 from "primeng/button";
+import * as i7 from "primeng/confirmdialog";
+import * as i8 from "primeng/dropdown";
+import * as i9 from "primeng/inputtext";
+import * as i10 from "primeng/overlaypanel";
+import * as i11 from "primeng/toolbar";
+import * as i12 from "primeng/tooltip";
 /**
  * The Region Editor (`<region-editor>`): the table of the active image's
  * annotation regions with class presets, colours, labels, GeoJSON import /
@@ -52,7 +60,25 @@ import * as i11 from "primeng/tooltip";
  * API's region / selection / preset / image-meta streams, save and mask-export
  * progress, file reads) marks it for check.
  */
+/** The opacity the fill toggle fills regions at. */
+const REGION_FILL_OPACITY = 0.6;
+/** "Select all" takes at most this many region-source features into the regions. */
+const SELECT_ALL_SOURCE_LIMIT = 5000;
 export class RegionEditorComponent {
+    /**
+     * Whether the editor is on screen (its dialog open). Closed, it asks the region source nothing:
+     * its page of features, its class counts and, in a volume view, its classes' volumes are each a
+     * request over the whole set (a stack's every slice), and they competed with the volume's own
+     * slice loading for nothing anyone could see. Opened, it reads them again.
+     */
+    set active(value) {
+        const was = this.isActive;
+        this.isActive = value;
+        if (value && !was) {
+            void this.refreshSource();
+            this.resetVolumes();
+        }
+    }
     /** Re-render this OnPush view, re-entering the zone when the change came from outside it. */
     changed() {
         markForCheckInZone(this.cdr, this.zone);
@@ -63,6 +89,9 @@ export class RegionEditorComponent {
         this.confirmationService = confirmationService;
         this.persistence = persistence;
         this.maskExport = maskExport;
+        this.isActive = true;
+        /** The host's HttpClient: a served region set's requests go through it (its auth). */
+        this.http = inject(HttpClient, { optional: true });
         this.regions = [];
         this.selectedRegions = [];
         this.displayHelpDialog = false;
@@ -97,6 +126,56 @@ export class RegionEditorComponent {
          *  avoids needing a unique id field. */
         this.editingLabelRegions = new Map();
         this.showSaveAsDialog = false;
+        /**
+         * The slice's region source (a large region set drawn by level of detail), or null. Its
+         * features are rows of the table after the regions — stand-ins until one is selected or edited,
+         * which takes it into the regions — and its classes count in the classes panel.
+         */
+        this.sourceView = null;
+        /** Features still in the source (the table's rows after the regions). */
+        this.sourceTotal = 0;
+        /** Stand-in rows for the source features on the current page. */
+        this.sourceRows = [];
+        /** Features per class still in the source. */
+        this.sourceClassCounts = {};
+        /** The stand-in rows (rows of a source feature, not of a region). */
+        this.standIns = new WeakSet();
+        this.standInSeq = 0;
+        /** Bumped per source refresh, so a late answer is dropped. */
+        this.sourceRequest = 0;
+        /** The classes the table's Class column offers: the presets and the region source's classes
+         *  (a dropdown can only show a value that is one of its options). */
+        this.tablePresetSet = defaultPresetSet();
+        /** Whether regions are drawn filled (the atlas look) rather than outlined. */
+        this.regionsFilled = false;
+        /** Whether a volume view is on screen (classes can then be shown in 3D). */
+        this.volumeView = false;
+        /** Whether the volume view's slice pane is wanted (one slice edited beside the 3D view). */
+        this.slicePane = false;
+        /** Whether the volume view draws the regions through the volume (see toggleThroughVolume). */
+        this.regionsThroughVolume = false;
+        /** Classes shown in 3D in the volume view, each with the classes its surface covers. */
+        this.shown3d = new Map();
+        /** The classes of the class tree's pick (it and its subtree), as long as the pick holds. */
+        this.pickedClasses = [];
+        /** The selected rows' classes, marked in the class lists. */
+        this.markedClasses = new Set();
+        /** The surfaces highlighted in the volume view (their keys, joined). */
+        this.highlighted3d = '';
+        /** The colour each shown surface was last drawn in. */
+        this.colors3d = new Map();
+        /** Their names, for the class lists' toggles (a new set per change, for OnPush). */
+        this.shown3dNames = new Set();
+        /** The classes hidden from view (their regions, source features and surfaces). */
+        this.hiddenClasses = new Set();
+        /** Whether a region set's class hierarchy is shown as a tree (rather than the class list). */
+        this.classTreeView = true;
+        /** The class picked last in the class tree. */
+        this.pickedClass = null;
+        /** Regions per class (the regions' and the source's), for the class tree. */
+        this.treeCounts = new Map();
+        /** A class's colour, for the class tree: a new function per colour change, so the tree repaints. */
+        this.treeColor = (name) => colorForLabel(name, this.presetSet);
         this.saveAsFilename = '';
         this.saveAsFileExists = false;
         /** True while a GeoJSON persist is serializing/uploading — drives the dialog's
@@ -132,8 +211,14 @@ export class RegionEditorComponent {
         /** Physical pixel size (µm/pixel) of the active image, for region areas in
          *  µm²; empty when the format reports no physical size. */
         this.mpp = {};
+        /** In a volume view, each class's volume over the whole stack, for the table (null: areas). */
+        this.tableVolumes = null;
+        /** Bumped when the regions change, so a volume computed before is dropped. */
+        this.volumeRequest = 0;
         this._pageKey = {};
         this._page = [];
+        /** An import from the server is in flight. */
+        this.importing = false;
     }
     ngOnInit() {
         this.showShapeLabel = this.regionApi.getShowShapeLabel();
@@ -150,7 +235,9 @@ export class RegionEditorComponent {
             presets$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((set) => {
                 if (set)
                     this.presetSet = set;
+                this.treeColor = (name) => colorForLabel(name, this.presetSet);
                 this.updateDisplayClasses();
+                this.recolor3d();
                 this.changed();
             });
         }
@@ -179,8 +266,77 @@ export class RegionEditorComponent {
             this.clampPaginatorFirst();
             this.syncClassesFromRegions(updated);
             this.recomputeClassCounts();
+            if (this.volumeView)
+                this.resetVolumes();
+            this.changed();
+            void this.refreshSource();
+        });
+        this.regionApi
+            .getRegionSourceView$?.()
+            ?.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((view) => {
+            if (view?.source !== this.sourceView?.source)
+                this.pickedClass = null;
+            this.sourceView = view;
+            void this.refreshSource();
+        });
+        this.regionApi
+            .getRegionStyle$?.()
+            ?.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((style) => {
+            this.regionsFilled = style.fillOpacity > 0;
             this.changed();
         });
+        this.regionApi
+            .getVolumeView$?.()
+            ?.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((volume) => {
+            const counting = this.stackCounts;
+            this.volumeView = volume;
+            this.resetVolumes();
+            this.changed();
+            if (this.stackCounts !== counting)
+                void this.refreshSource();
+        });
+        this.regionApi
+            .getRegionsThroughVolume$?.()
+            ?.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((through) => {
+            this.regionsThroughVolume = through;
+            this.changed();
+        });
+        this.regionApi
+            .getSliceEditor$?.()
+            ?.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((pane) => {
+            const counting = this.stackCounts;
+            this.slicePane = pane;
+            if (this.stackCounts !== counting)
+                void this.refreshSource();
+        });
+        // What is shown in 3D: the router clears it when another image is plotted.
+        this.regionApi
+            .getRegionClasses3d$?.()
+            ?.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((groups) => {
+            this.shown3d = new Map(groups.map((g) => [g.key, [...g.classes]]));
+            this.shown3dNames = new Set(this.shown3d.keys());
+            this.highlighted3d = '';
+            this.updateSelectionHighlight();
+            this.changed();
+        });
+        this.regionApi
+            .getHiddenClasses$?.()
+            ?.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((hidden) => {
+            this.hiddenClasses = hidden;
+            this.changed();
+        });
+        // A surface clicked in the volume view (with the selection tool) picks its class.
+        this.regionApi
+            .getRegionPicked3d$?.()
+            ?.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(({ key, additive }) => this.onPicked3d(key, additive));
         this.persistence
             .fileExists(this.saveAsCheck$)
             .pipe(takeUntilDestroyed(this.destroyRef))
@@ -208,6 +364,7 @@ export class RegionEditorComponent {
                 next.every((r, i) => r.id === this.selectedRegions[i]?.id);
             if (!same)
                 this.selectedRegions = next;
+            this.updateSelectionHighlight();
             // Scroll the paginator so the most-recently-selected row is visible.
             if (next.length > 0) {
                 const lastIdx = this.regions.findIndex((r) => r.id === next[next.length - 1].id);
@@ -233,13 +390,195 @@ export class RegionEditorComponent {
      * intensity-profile lines the editor never sees).
      */
     onSelectionChanged() {
+        const selected = this.selectedRegions ?? [];
+        // Rows picked in the table replace the class tree's pick.
+        this.pickedClasses = [];
+        this.updateSelectionHighlight();
+        const fromSource = selected.filter((r) => this.standIns.has(r));
         this._suppressSelectionSyncToPlot = true;
         try {
-            this.regionApi.setSelectedRegions(this.selectedRegions ?? []);
+            this.regionApi.setSelectedRegions(selected.filter((r) => !this.standIns.has(r)));
         }
         finally {
             this._suppressSelectionSyncToPlot = false;
         }
+        // A selected source row is taken into the regions (and so selected on the image too).
+        if (fromSource.length)
+            void this.regionApi.selectSourceFeatures?.(this.sourceIds(fromSource), true);
+    }
+    // ── The region source's features as table rows ───────────────────────
+    /** Whether the slice has a region source: it then has regions to save even with an empty table. */
+    get hasRegionSource() {
+        return !!this.sourceView;
+    }
+    /** Rows in the table: the regions, then the features still in the region source. */
+    get tableTotal() {
+        return this.regions.length + this.sourceTotal;
+    }
+    /** The class hierarchy of the slice's region source, when it has one (the classes as a tree). */
+    get classHierarchy() {
+        return this.sourceView?.source.info.hierarchy ?? null;
+    }
+    /** Whether `row` is a region-source feature's stand-in rather than a region. */
+    isSourceRow(row) {
+        return this.standIns.has(row);
+    }
+    sourceIds(rows) {
+        return rows.map((r) => r.sourceId).filter((id) => !!id);
+    }
+    /** A table row for a source feature: no geometry until it is taken. */
+    standIn(row) {
+        const r = Object.assign(new Region(), {
+            id: -++this.standInSeq,
+            name: row.label ?? row.id,
+            label: row.label ?? undefined,
+            color: this.sourceView?.colorOf(row) ?? row.color ?? this.shapeColor,
+            sourceId: row.id,
+            sourceArea: row.area,
+            bounds: null,
+        });
+        this.standIns.add(r);
+        return r;
+    }
+    /**
+     * Re-read the source part of the table (the stand-ins on the current page, the count) and the
+     * source's class counts. The page holds regions first, so its source rows start at
+     * `max(first, regions)` − regions.
+     */
+    async refreshSource() {
+        if (!this.isActive)
+            return;
+        const request = ++this.sourceRequest;
+        const view = this.sourceView;
+        let rows = [];
+        let total = 0;
+        let counts = {};
+        if (view && this.regionApi.getRegionSourceIndex) {
+            const own = this.regions.length;
+            const start = Math.max(this.paginatorFirst, own);
+            const limit = Math.max(0, this.paginatorFirst + this.paginatorRows - start);
+            try {
+                const [page, perClass] = await Promise.all([
+                    this.regionApi.getRegionSourceIndex({ offset: start - own, limit }),
+                    this.regionApi.getRegionSourceClassCounts?.(this.stackCounts),
+                ]);
+                rows = page?.rows ?? [];
+                total = page?.total ?? 0;
+                counts = perClass ?? {};
+            }
+            catch (err) {
+                console.warn('[regions] could not list the region source', err);
+            }
+        }
+        if (request !== this.sourceRequest)
+            return;
+        this.sourceTotal = total;
+        this.sourceRows = rows.map((r) => this.standIn(r));
+        this.sourceClassCounts = counts;
+        this.recomputeClassCounts();
+        this.changed();
+    }
+    /** Take a source row's feature into the regions, then run `then` on the region it became. */
+    async takeThen(row, then) {
+        const [id] = (await this.regionApi.selectSourceFeatures?.(this.sourceIds([row]))) ?? [];
+        const region = this.regions.find((r) => r.id === id);
+        if (region)
+            then(region);
+    }
+    /** Toggle the filled (atlas) look: each region filled in its colour, labels inside. */
+    /** In a volume view: the regions drawn through the volume, or hidden behind what it shows. */
+    toggleThroughVolume() {
+        this.regionApi.setRegionsThroughVolume?.(!this.regionsThroughVolume);
+    }
+    toggleFill() {
+        this.regionApi.setRegionStyle?.({ fillOpacity: this.regionsFilled ? 0 : REGION_FILL_OPACITY });
+    }
+    /**
+     * Show or hide a class in the volume view as a 3D reconstruction — a tree node with every class
+     * under it, as one surface in its colour.
+     */
+    toggleClass3d(name, classes = [name]) {
+        const next = new Map(this.shown3d);
+        if (next.has(name))
+            next.delete(name);
+        else
+            next.set(name, classes);
+        this.shown3d = next;
+        this.shown3dNames = new Set(next.keys());
+        this.changed();
+        this.show3d(this.groups3d());
+        this.updateSelectionHighlight();
+    }
+    /** Hide (or show again) these classes' regions, wherever they are drawn. */
+    setClassesHidden(classes, hidden) {
+        this.regionApi.setClassesHidden?.(classes, hidden);
+    }
+    /** The surfaces shown in 3D, in their classes' colours now. */
+    groups3d() {
+        const titles = new Map((this.classHierarchy ?? []).map((n) => [n.name, n.title]));
+        return [...this.shown3d].map(([key, classes]) => {
+            const title = titles.get(key);
+            return { key, classes, color: this.treeColor(key), label: title ? `${key} · ${title}` : key };
+        });
+    }
+    /** The classes selected now: the class tree's pick (with its subtree) and the selected rows'. */
+    selectedClassNames() {
+        const names = new Set(this.pickedClasses);
+        for (const r of this.selectedRegions ?? [])
+            if (r.label)
+                names.add(r.label);
+        return names;
+    }
+    /**
+     * Highlight, in the volume view, the surfaces holding a selected class (focus + context: they
+     * turn near opaque, the others fade), and mark the selected rows' classes in the class lists.
+     */
+    updateSelectionHighlight() {
+        const names = this.selectedClassNames();
+        const marked = new Set((this.selectedRegions ?? []).map((r) => r.label).filter((l) => !!l));
+        if ([...marked].join('\n') !== [...this.markedClasses].join('\n'))
+            this.markedClasses = marked;
+        const keys = [...this.shown3d].filter(([, classes]) => classes.some((c) => names.has(c))).map(([k]) => k);
+        const id = keys.join('\n');
+        if (id === this.highlighted3d)
+            return;
+        this.highlighted3d = id;
+        this.regionApi.highlightRegionClasses3d?.(keys);
+    }
+    /** A surface clicked in the volume view: pick its class as the tree would; beside them, clear. */
+    onPicked3d(key, additive) {
+        if (key === null) {
+            if (additive)
+                return;
+            this.pickedClass = null;
+            this.pickedClasses = [];
+            this.selectedRegions = [];
+            this.onSelectionChanged();
+            this.changed();
+            return;
+        }
+        void this.pickClasses({ name: key, classes: this.shown3d.get(key) ?? [key], additive });
+    }
+    /** A class colour changed (its swatch, or Manage): repaint the surfaces shown in 3D whose colour it changed. */
+    recolor3d() {
+        const groups = this.groups3d();
+        if (!groups.some((g) => g.color !== this.colors3d.get(g.key)))
+            return;
+        this.show3d(groups);
+    }
+    show3d(groups) {
+        this.colors3d = new Map(groups.map((g) => [g.key, g.color]));
+        this.regionApi.showRegionClasses3d?.(groups).catch((err) => {
+            this.toast('error', 'Could not show the region in 3D', `${err?.message ?? err}`);
+        });
+    }
+    /** Pick a class in the class tree: select its regions and its subclasses', the source's taken. */
+    async pickClasses(pick) {
+        this.pickedClass = pick.name;
+        this.pickedClasses = pick.additive ? [...new Set([...this.pickedClasses, ...pick.classes])] : pick.classes;
+        this.updateSelectionHighlight();
+        this.changed();
+        await this.regionApi.selectRegionClasses?.(pick.classes, pick.additive);
     }
     /**
      * Rows for regions coming from the visualizer: neutral `Region`s with bounds,
@@ -327,23 +666,94 @@ export class RegionEditorComponent {
      *  change detection doesn't hand p-table a new array every tick (RT-20). */
     get pagedRegions() {
         const key = this._pageKey;
-        if (key.regions !== this.regions || key.first !== this.paginatorFirst || key.rows !== this.paginatorRows) {
-            this._pageKey = { regions: this.regions, first: this.paginatorFirst, rows: this.paginatorRows };
-            this._page = this.regions.slice(this.paginatorFirst, this.paginatorFirst + this.paginatorRows);
+        if (key.regions !== this.regions ||
+            key.source !== this.sourceRows ||
+            key.first !== this.paginatorFirst ||
+            key.rows !== this.paginatorRows) {
+            this._pageKey = {
+                regions: this.regions,
+                source: this.sourceRows,
+                first: this.paginatorFirst,
+                rows: this.paginatorRows,
+            };
+            const own = this.regions.slice(this.paginatorFirst, this.paginatorFirst + this.paginatorRows);
+            this._page =
+                own.length >= this.paginatorRows
+                    ? own
+                    : [...own, ...this.sourceRows.slice(0, this.paginatorRows - own.length)];
+            // A new page may show classes whose volume is not known yet (after this check).
+            if (this.volumeView)
+                queueMicrotask(() => this.requestVolumes());
         }
         return this._page;
     }
+    /** Compute the volumes of the classes on the table's page that are not known yet. */
+    requestVolumes() {
+        const api = this.regionApi.getClassVolumes?.bind(this.regionApi);
+        // Closed: asked for again when it opens (see active).
+        if (!this.isActive)
+            return;
+        if (!this.volumeView || !api) {
+            if (this.tableVolumes) {
+                this.tableVolumes = null;
+                this.changed();
+            }
+            return;
+        }
+        const known = this.tableVolumes ?? new Map();
+        const labels = new Set(this.pagedRegions.map((r) => r.label).filter((l) => !!l));
+        const missing = [...labels].filter((l) => !known.has(l));
+        if (!missing.length && this.tableVolumes)
+            return;
+        this.tableVolumes = new Map([...known, ...missing.map((l) => [l, null])]);
+        this.changed();
+        if (!missing.length)
+            return;
+        const request = this.volumeRequest;
+        api(missing).then((volumes) => {
+            if (request !== this.volumeRequest || !this.tableVolumes)
+                return;
+            this.tableVolumes = new Map([...this.tableVolumes, ...Object.entries(volumes)]);
+            this.changed();
+        }, (err) => {
+            if (request !== this.volumeRequest || !this.tableVolumes)
+                return;
+            // Leave them unknown ('—') rather than computing forever.
+            const next = new Map(this.tableVolumes);
+            for (const l of missing)
+                next.delete(l);
+            this.tableVolumes = next;
+            this.changed();
+            console.warn('[regions] could not compute class volumes', err);
+        });
+    }
+    /** The regions changed (or the view did): forget the volumes and compute the page's again. */
+    resetVolumes() {
+        this.volumeRequest++;
+        this.tableVolumes = null;
+        this.requestVolumes();
+    }
     onPageChange(event) {
         this.paginatorFirst = event.first ?? 0;
         this.paginatorRows = event.rows ?? this.paginatorRows;
+        void this.refreshSource();
     }
-    /** Select every region in the table (and highlight them on the diagram). */
-    selectAllRegions() {
+    /** Select every region in the table (and highlight them on the diagram), the source's taken. */
+    async selectAllRegions() {
         this.selectedRegions = [...this.regions];
         this.onSelectionChanged();
+        if (!this.sourceTotal || !this.regionApi.getRegionSourceIndex)
+            return;
+        const page = await this.regionApi.getRegionSourceIndex({ offset: 0, limit: SELECT_ALL_SOURCE_LIMIT });
+        const ids = (page?.rows ?? []).map((r) => r.id);
+        if (ids.length)
+            await this.regionApi.selectSourceFeatures?.(ids, true);
     }
     deleteSelectedRegions() {
         if (this.selectedRegions && this.selectedRegions.length > 0) {
+            const fromSource = this.selectedRegions.filter((r) => this.standIns.has(r));
+            if (fromSource.length)
+                this.regionApi.deleteSourceFeatures?.(this.sourceIds(fromSource));
             // Filter by id — object identity isn't reliable across re-parses,
             // and name is a user-editable label that may collide.
             const removed = new Set(this.selectedRegions.map((r) => r.id));
@@ -363,10 +773,28 @@ export class RegionEditorComponent {
                 this.paginatorFirst = 0;
                 this.commit([]);
                 this.onSelectionChanged();
+                if (this.hasRegionSource)
+                    void this.deleteAllSourceFeatures();
             },
         });
     }
+    /** Delete every feature still in the slice's region source (with "Delete all regions"). */
+    async deleteAllSourceFeatures() {
+        const index = this.regionApi.getRegionSourceIndex;
+        if (!index || !this.regionApi.deleteSourceFeatures)
+            return;
+        const page = await index.call(this.regionApi, { offset: 0, limit: Number.MAX_SAFE_INTEGER });
+        if (page?.rows.length)
+            this.regionApi.deleteSourceFeatures(page.rows.map((r) => r.id));
+    }
     deleteRegion(shapeIdx) {
+        // A row past the regions is a source feature: delete it from the source.
+        if (shapeIdx >= this.regions.length) {
+            const row = this.sourceRows[shapeIdx - Math.max(this.paginatorFirst, this.regions.length)];
+            if (row)
+                this.regionApi.deleteSourceFeatures?.(this.sourceIds([row]));
+            return;
+        }
         const removed = this.regions[shapeIdx];
         if (removed) {
             this.selectedRegions = this.selectedRegions.filter((r) => r.id !== removed.id);
@@ -378,7 +806,7 @@ export class RegionEditorComponent {
         this.onSelectionChanged();
     }
     clampPaginatorFirst() {
-        const maxFirst = Math.max(0, Math.floor((this.regions.length - 1) / this.paginatorRows) * this.paginatorRows);
+        const maxFirst = Math.max(0, Math.floor((this.tableTotal - 1) / this.paginatorRows) * this.paginatorRows);
         if (this.paginatorFirst > maxFirst) {
             this.paginatorFirst = maxFirst;
         }
@@ -391,6 +819,10 @@ export class RegionEditorComponent {
     }
     startEditLabel(region, event) {
         event?.stopPropagation(); // don't toggle row selection
+        if (this.standIns.has(region)) {
+            void this.takeThen(region, (r) => this.startEditLabel(r));
+            return;
+        }
         // A new map per start/stop, so the OnPush table sees the change.
         this.editingLabelRegions = new Map(this.editingLabelRegions).set(region, region.label ?? '');
     }
@@ -507,21 +939,49 @@ export class RegionEditorComponent {
         }
     }
     // ── Docked Classes panel (jit-ui#70) ─────────────────────────────────
-    /** Rebuild the per-class region counts shown in the panel. */
+    /**
+     * Whether the classes count every slice of the stack: in a volume view (the whole stack on
+     * screen), unless its slice pane shows one slice. The table lists the slice's regions anyway.
+     */
+    get stackCounts() {
+        return this.volumeView && !this.slicePane;
+    }
+    /** Rebuild the per-class region counts shown in the panel (the stack's, see stackCounts). */
     recomputeClassCounts() {
         const counts = new Map();
-        for (const r of this.regions) {
-            if (!r.label)
-                continue;
-            const k = presetKey(this.presetSet, r.label);
-            counts.set(k, (counts.get(k) ?? 0) + 1);
-        }
+        const tree = new Map();
+        const add = (label, n) => {
+            const k = presetKey(this.presetSet, label);
+            counts.set(k, (counts.get(k) ?? 0) + n);
+            tree.set(label, (tree.get(label) ?? 0) + n);
+        };
+        const regions = this.stackCounts ? this.regionApi.getSliceAnnotationRegions() : this.regions;
+        for (const r of regions)
+            if (r.label)
+                add(r.label, 1);
+        // The region source's classes count too (its features are rows of the table).
+        for (const [label, n] of Object.entries(this.sourceClassCounts))
+            add(label, n);
         this.classCounts = counts;
+        this.treeCounts = tree;
         this.updateDisplayClasses();
     }
-    /** Rebuild the panel's display order — most-used classes first, then by name. */
+    /** Rebuild the panel's display order — most-used classes first, then by name. A class only
+     *  the region source has is listed too, in its colour. */
     updateDisplayClasses() {
-        this.displayClasses = [...this.presetSet.classes].sort((a, b) => {
+        const known = new Set(this.presetSet.classes.map((c) => presetKey(this.presetSet, c.name)));
+        const fromSource = [];
+        for (const label of Object.keys(this.sourceClassCounts)) {
+            const k = presetKey(this.presetSet, label);
+            if (known.has(k))
+                continue;
+            known.add(k);
+            fromSource.push({ name: label, color: colorForLabel(label, this.presetSet) });
+        }
+        this.tablePresetSet = fromSource.length
+            ? { ...this.presetSet, classes: [...this.presetSet.classes, ...fromSource] }
+            : this.presetSet;
+        this.displayClasses = [...this.presetSet.classes, ...fromSource].sort((a, b) => {
             const d = this.classCount(b.name) - this.classCount(a.name);
             return d !== 0 ? d : a.name.localeCompare(b.name);
         });
@@ -564,6 +1024,10 @@ export class RegionEditorComponent {
     /** Stamp a class (and its preset/fallback colour) onto one region from the Class
      *  dropdown; choosing a class opts the region back into the preset colour. */
     applyPresetToRegion(region, className) {
+        if (this.standIns.has(region)) {
+            void this.takeThen(region, (r) => this.applyPresetToRegion(r, className));
+            return;
+        }
         const name = (className ?? '').trim();
         const patch = { label: name, colorOverridden: false };
         if (name)
@@ -657,7 +1121,7 @@ export class RegionEditorComponent {
         this.commit();
     }
     exportPresets() {
-        const json = JSON.stringify(this.regionApi.getPresetSet(), null, 2);
+        const json = JSON.stringify(this.clonePresetSet(this.regionApi.getPresetSet()), null, 2);
         saveAs(new Blob([json], { type: 'application/json' }), 'annotation-classes.json');
     }
     importPresets(event) {
@@ -689,13 +1153,160 @@ export class RegionEditorComponent {
         }
         this.changed();
     }
+    /** The files chosen in the import inputs: one GeoJSON, a label volume with its ontology, or a
+     *  folder of per-slice GeoJSON files. */
     importRois(event) {
-        this.persistence.readChosenFile(event, (text) => this.applyImportedRois(text));
+        const files = Array.from(event.target.files ?? []);
+        if (files.length)
+            void this.importRegionFiles(files.map((f) => importFile(f, f.webkitRelativePath || f.name)));
     }
-    /** Replace the regions with an imported GeoJSON file's. */
-    applyImportedRois(text) {
+    /** Whether the host can pick regions on its server ("Import regions from server"). */
+    get canImportFromServer() {
+        return this.persistence.canPickServerRegions();
+    }
+    /** "Import regions from server": the host picks files or a served region set; they import as chosen files do. */
+    importFromServer() {
+        this.importing = true;
+        this.changed();
+        this.persistence.pickServerRegions().subscribe({
+            next: (pick) => {
+                if (!pick)
+                    return;
+                if (pick.kind === 'files') {
+                    void this.importRegionFiles(pick.files.map((f) => importFile(f.data, f.name)));
+                    return;
+                }
+                void this.importServedRegionSet(pick.url, pick.name);
+            },
+            error: (err) => this.importFailed(err),
+            complete: () => {
+                this.importing = false;
+                this.changed();
+            },
+        });
+    }
+    /**
+     * Import `files` (see planRegionImport): one GeoJSON file as before; a label volume as one
+     * region source per slice, traced from it the first time the slice is shown, its classes named
+     * (and treed) by the ontology chosen with it; a folder as one source per slice file. Either
+     * replaces the regions and sources of every slice.
+     */
+    async importRegionFiles(files) {
+        const plan = planRegionImport(files);
+        if (!plan) {
+            this.importFailed(new Error('Choose a GeoJSON file, a folder of GeoJSON files, or a .nii, .nii.gz or .nrrd label volume.'));
+            return;
+        }
+        if (plan.kind === 'single') {
+            await this.applyImportedRois(await plan.file.text());
+            return;
+        }
+        const attach = this.regionApi.importSliceRegionSources?.bind(this.regionApi);
+        if (!attach) {
+            this.importFailed(new Error('This viewer cannot hold region sources.'));
+            return;
+        }
+        // Taken before the files are read: decoding a volume takes a while, and the import must land
+        // on the image it was started for, not on one shown meanwhile.
+        const ticket = this.regionApi.regionImportTicket?.();
         try {
-            this.regions = this.regionApi.importRegions(text);
+            const openers = new Map();
+            let summary;
+            if (plan.kind === 'volume') {
+                const volume = await readLabelVolume(plan.volume.name, await plan.volume.bytes());
+                const classes = labelClasses(plan.ontology ? JSON.parse(await plan.ontology.text()) : undefined);
+                for (let z = 0; z < volume.slices; z++) {
+                    openers.set(z, () => openGeoJsonRegionSource(labelSliceGeoJson(volume, z, classes)));
+                }
+                summary = `${volume.slices} slices of ${volume.width} × ${volume.height}`;
+                this.warnIfSizeDiffers(volume.width, volume.height);
+            }
+            else {
+                const regionSet = plan.regionSet ? JSON.parse(await plan.regionSet.text()) : null;
+                plan.slices.forEach((file, z) => openers.set(z, async () => openGeoJsonRegionSource(await folderSliceGeoJson(file, regionSet))));
+                summary = `${plan.slices.length} slice files`;
+            }
+            const attached = attach(openers, ticket);
+            if (attached === null) {
+                this.importStale();
+                return;
+            }
+            this.afterSourceImport();
+            this.toast('success', 'Regions imported', `${summary}; ${attached} slice${attached === 1 ? '' : 's'} annotated.`);
+        }
+        catch (err) {
+            this.importFailed(err);
+        }
+    }
+    /** A region set the host's server serves (jit-service's /regions/{id}/), read through its HttpClient. */
+    async importServedRegionSet(url, name) {
+        const importSource = this.regionApi.importRegionSourceOpener?.bind(this.regionApi);
+        if (!importSource) {
+            this.importFailed(new Error('This viewer cannot hold region sources.'));
+            return;
+        }
+        const ticket = this.regionApi.regionImportTicket?.();
+        try {
+            const applied = await importSource(() => openHttpRegionSource(url, { http: this.http ?? undefined }), ticket);
+            if (applied === false) {
+                this.importStale();
+                return;
+            }
+            this.afterSourceImport();
+            this.toast('success', 'Regions imported', name ?? url);
+        }
+        catch (err) {
+            this.importFailed(err);
+        }
+    }
+    /** An import that finished after another image was shown (or another import began): dropped. */
+    importStale() {
+        this.toast('info', 'Import discarded', 'The image changed while the regions were being read.');
+        this.changed();
+    }
+    /** The table and selection after the regions were replaced by imported sources. */
+    afterSourceImport() {
+        this.selectedRegions = [];
+        this.paginatorFirst = 0;
+        this.commit([]);
+        this.onSelectionChanged();
+    }
+    /** Warn when an imported volume's slices are not the image's size: its outlines would not fit. */
+    warnIfSizeDiffers(width, height) {
+        const meta = this.regionApi.getMaskImageSize();
+        if (meta && (meta.width !== width || meta.height !== height)) {
+            this.toast('info', 'Different size', `The volume's slices are ${width} × ${height}; the image is ${meta.width} × ${meta.height}.`);
+        }
+    }
+    importFailed(err) {
+        this.importing = false;
+        this.messageService.add({
+            key: VIZ_TOAST_KEY,
+            severity: 'error',
+            summary: 'Error importing regions',
+            detail: `${err?.message ?? err}`,
+        });
+        console.error('Error importing regions:', err);
+        this.changed();
+    }
+    /**
+     * Replace the regions with an imported GeoJSON file's, and the slice's region source with them.
+     * A large file becomes the slice's region source instead (drawn by level of detail; listed above
+     * the table), the table emptied.
+     */
+    async applyImportedRois(text) {
+        try {
+            if (await this.regionApi.importRegionSource?.(text)) {
+                this.selectedRegions = [];
+                this.paginatorFirst = 0;
+                this.commit([]);
+                this.onSelectionChanged();
+                return;
+            }
+            // Parsed first: a file that is not GeoJSON leaves the source alone.
+            const regions = this.regionApi.importRegions(text);
+            await this.regionApi.dropRegionSource?.();
+            this.regions = regions;
             this.fillClassColors();
             this.commit();
         }
@@ -714,7 +1325,7 @@ export class RegionEditorComponent {
         return this.persistence.regionsForSave(this.regions);
     }
     exportRois() {
-        if (!this.regionsForSave().length)
+        if (!this.regionsForSave().length && !this.hasRegionSource)
             return;
         this.exportFilename = this.persistence.defaultExportName();
         this.showExportDialog = true;
@@ -722,10 +1333,12 @@ export class RegionEditorComponent {
     confirmExport() {
         const filename = this.exportFilename.trim();
         const regions = this.regionsForSave();
-        if (!filename || !regions.length)
+        if (!filename || (!regions.length && !this.hasRegionSource))
             return;
         this.showExportDialog = false;
-        this.persistence.download(regions, filename);
+        this.persistence
+            .download(regions, filename)
+            .catch((err) => this.toast('error', 'Error exporting regions', `${err?.message ?? err}`));
     }
     /** Open the "Save mask" dialog, seeded with `<image-stem>_mask.png`. */
     openSaveMaskDialog() {
@@ -825,7 +1438,7 @@ export class RegionEditorComponent {
             return;
         }
         const filename = this.persistence.defaultSaveName();
-        if (!filename || !this.regionsForSave().length)
+        if (!filename || (!this.regionsForSave().length && !this.hasRegionSource))
             return;
         this.saveAsFilename = filename;
         this.saveAsFileExists = false;
@@ -835,13 +1448,25 @@ export class RegionEditorComponent {
     /** Save a folder stack's regions as one geojson per slice-file (jit-ui#93).
      *  No dialog covers the toolbar meanwhile, so a Save while one is uploading
      *  is ignored rather than starting a second write (and orphaning the first). */
-    saveStackSlices() {
+    async saveStackSlices() {
         if (this.saveAsBusy)
             return;
-        const slices = this.persistence.sliceGeoJsons();
-        if (!slices.length)
-            return;
         this.saveAsBusy = true;
+        let slices;
+        try {
+            slices = await this.persistence.sliceGeoJsons();
+        }
+        catch (err) {
+            this.saveAsBusy = false;
+            this.changed();
+            this.toast('error', 'Error saving regions', `${err?.message ?? err}`);
+            return;
+        }
+        // Cancelled while the slices serialized, or nothing to write.
+        if (!this.saveAsBusy || !slices.length) {
+            this.saveAsBusy = false;
+            return;
+        }
         this._saveAsSub = this.persistence.saveSlices(slices).subscribe({
             next: () => {
                 this.saveAsBusy = false;
@@ -909,7 +1534,7 @@ export class RegionEditorComponent {
         this.messageService.add({ key: VIZ_TOAST_KEY, severity, summary, detail });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionEditorComponent, deps: [{ token: REGION_EDITOR_API }, { token: i1.MessageService }, { token: i1.ConfirmationService }, { token: i2.RegionPersistenceService }, { token: i3.MaskExportService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: RegionEditorComponent, isStandalone: true, selector: "region-editor", providers: [RegionPersistenceService], viewQueries: [{ propertyName: "overlayPanel", first: true, predicate: ["op"], descendants: true }], ngImport: i0, template: "<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button\n      icon=\"pi pi-tag\"\n      size=\"small\"\n      [text]=\"!showShapeLabel\"\n      pTooltip=\"Show region labels.\"\n      tooltipPosition=\"bottom\"\n      (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\"\n    >\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button\n      icon=\"pi pi-upload\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Upload and display regions from geojson file.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roiFileInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFileInput\n      type=\"file\"\n      accept=\".geojson,.json\"\n      hidden\n      (change)=\"importRois($event); roiFileInput.value = ''\"\n    />\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download regions as geojson file.\"\n      tooltipPosition=\"bottom\"\n      icon=\"pi pi-download\"\n      (click)=\"exportRois()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-save\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Save regions to server.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"persistRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download mask of the regions as PNG\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openSaveMaskDialog()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img\n        src=\"assets/plotting/mask.svg\"\n        class=\"toolbar-icon-dark\"\n        style=\"width: 1rem; height: 1rem; vertical-align: middle\"\n        alt=\"Download mask\"\n      />\n    </p-button>\n    <p-button\n      label=\"x512\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roundRectangleLengths()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-check-square\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Select all regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"selectAllRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-tags\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit class on selected rows\"\n      tooltipPosition=\"bottom\"\n      (click)=\"!selectedRegions || !selectedRegions.length ? op.hide() : op.toggle($event)\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-palette\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit colour of selected regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openColorDialog()\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass = ''; newBulkClass = ''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\"\n          >Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span\n        >\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown\n          styleClass=\"w-full\"\n          appendTo=\"body\"\n          [options]=\"presetSet.classes\"\n          optionLabel=\"name\"\n          optionValue=\"name\"\n          [(ngModel)]=\"bulkClass\"\n          placeholder=\"Choose a class\u2026\"\n          [filter]=\"presetSet.classes.length > 8\"\n          filterBy=\"name\"\n          (onChange)=\"applyBulkClass()\"\n        >\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"\n              ><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span\n            >\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input\n            type=\"text\"\n            pInputText\n            placeholder=\"\u2026or a new class\"\n            [(ngModel)]=\"newBulkClass\"\n            (keydown.enter)=\"addAndApplyBulkClass()\"\n          />\n          <button\n            pButton\n            type=\"button\"\n            icon=\"pi pi-plus\"\n            pTooltip=\"Add class &amp; set it\"\n            tooltipPosition=\"bottom\"\n            [disabled]=\"!newBulkClass.trim()\"\n            (click)=\"addAndApplyBulkClass()\"\n          ></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button\n      icon=\"pi pi-trash\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"deleteSelectedRegions()\"\n      pTooltip=\"Delete selected regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-times-circle\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"clearAllRegions()\"\n      pTooltip=\"Delete all regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!regions || !regions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-question\"\n      size=\"small\"\n      [text]=\"true\"\n      (click)=\"showHelp()\"\n      pTooltip=\"Help\"\n      tooltipPosition=\"bottom\"\n    ></p-button>\n  </div>\n</p-toolbar>\n\n<region-classes-panel\n  [classes]=\"displayClasses\"\n  [counts]=\"classCounts\"\n  [matchMode]=\"presetSet.matchMode\"\n  [activeClass]=\"activeClass\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  [defaultClassName]=\"defaultClassName\"\n  (pick)=\"selectActiveClass($event)\"\n  (recolor)=\"setClassColor($event.name, $event.color)\"\n  (remove)=\"deleteClass($event)\"\n  (manage)=\"openManageDialog()\"\n>\n</region-classes-panel>\n\n<region-table\n  [page]=\"pagedRegions\"\n  [total]=\"regions.length\"\n  [first]=\"paginatorFirst\"\n  [rows]=\"paginatorRows\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [metaKey]=\"metaKey\"\n  [selection]=\"selectedRegions\"\n  (selectionChange)=\"selectedRegions = $event\"\n  (rowSelect)=\"onSelectionChanged()\"\n  [presetSet]=\"presetSet\"\n  [defaultColor]=\"shapeColor\"\n  [mpp]=\"mpp\"\n  [labelDrafts]=\"editingLabelRegions\"\n  (labelEditStart)=\"startEditLabel($event)\"\n  (labelDraftChange)=\"setLabelDraft($event.region, $event.value)\"\n  (labelEditStop)=\"stopEditLabel($event.region, $event.commit)\"\n  (classPick)=\"applyPresetToRegion($event.region, $event.name)\"\n  (deleteRow)=\"deleteRegion($event)\"\n  (pageChange)=\"onPageChange($event)\"\n>\n</region-table>\n\n<!-- Live-edit mode: no Save/Cancel \u2014 every edit commits immediately to the\n     active image's region cache. -->\n\n<p-confirmDialog\n  #cd\n  [style]=\"{ width: '24rem', height: '14rem' }\"\n  key=\"positionDialog\"\n  [baseZIndex]=\"10000\"\n  rejectButtonStyleClass=\"p-button-outlined\"\n>\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button\n      type=\"button\"\n      class=\"p-button-outlined\"\n      pButton\n      icon=\"pi pi-times\"\n      label=\"No\"\n      (click)=\"cd.reject()\"\n    ></button>\n  </ng-template>\n</p-confirmDialog>\n\n<region-save-regions-dialog\n  [(visible)]=\"showSaveAsDialog\"\n  [filename]=\"saveAsFilename\"\n  (filenameChange)=\"saveAsFilename = $event; checkSaveAsFileExists()\"\n  [fileExists]=\"saveAsFileExists\"\n  [busy]=\"saveAsBusy\"\n  (confirm)=\"confirmSaveAs()\"\n  (cancelSave)=\"cancelSaveAs()\"\n>\n</region-save-regions-dialog>\n\n<region-save-regions-dialog\n  header=\"Export Regions\"\n  confirmLabel=\"Export\"\n  confirmIcon=\"pi pi-download\"\n  inputId=\"export-filename\"\n  [(visible)]=\"showExportDialog\"\n  [(filename)]=\"exportFilename\"\n  (confirm)=\"confirmExport()\"\n>\n</region-save-regions-dialog>\n\n<region-save-mask-dialog\n  [(visible)]=\"showSaveMaskDialog\"\n  [(filename)]=\"saveMaskFilename\"\n  [(mode)]=\"maskMode\"\n  [busy]=\"maskBusy\"\n  [progress]=\"maskProgress\"\n  [encoding]=\"maskEncoding\"\n  (confirm)=\"confirmSaveMask()\"\n  (cancelExport)=\"cancelSaveMask()\"\n>\n</region-save-mask-dialog>\n\n<region-color-dialog\n  [(visible)]=\"showColorDialog\"\n  [edits]=\"classColorEdits\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  (apply)=\"applyColorToSelected($event)\"\n>\n</region-color-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): edits a working copy, committed on Apply. -->\n<region-manage-classes-dialog\n  [(visible)]=\"showManageDialog\"\n  [(draft)]=\"presetDraft\"\n  (apply)=\"applyManageDialog(true)\"\n  (resetDefaults)=\"resetPresetsToDefaults()\"\n  (importFile)=\"importPresets($event)\"\n  (export)=\"exportPresets()\"\n>\n</region-manage-classes-dialog>\n\n<region-editor-help [(visible)]=\"displayHelpDialog\"></region-editor-help>\n", styles: ["@charset \"UTF-8\";.chip-swatch{display:inline-block;width:.75rem;height:.75rem;border-radius:50%;border:1px solid rgba(0,0,0,.2);flex:0 0 auto}.dd-value{display:inline-flex;align-items:center;gap:.4rem;min-width:0}.dd-value .class-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}:host{display:flex;flex-direction:column;height:100%;min-height:0;overflow:hidden}::ng-deep region-editor .p-toolbar.region-toolbar{padding:.25rem .5rem;border-radius:0;border-left:none;border-right:none;border-top:none}::ng-deep region-editor .p-toolbar.region-toolbar .p-button.p-button-icon-only{width:auto;padding:.25rem .5rem}::ng-deep region-editor .p-toolbar.region-toolbar .p-button{padding:.25rem .5rem}.toolbar-icon-dark{filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}.toolbar-separator{border-left:1px solid var(--surface-border);height:1.5rem;margin:0 .25rem;align-self:center}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: SharedModule }, { kind: "directive", type: i1.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i5.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading", "severity", "raised", "rounded", "text", "outlined", "size", "plain"] }, { kind: "component", type: i5.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "style", "styleClass", "badgeClass", "ariaLabel", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "ngmodule", type: ConfirmDialogModule }, { kind: "component", type: i6.ConfirmDialog, selector: "p-confirmDialog", inputs: ["header", "icon", "message", "style", "styleClass", "maskStyleClass", "acceptIcon", "acceptLabel", "closeAriaLabel", "acceptAriaLabel", "acceptVisible", "rejectIcon", "rejectLabel", "rejectAriaLabel", "rejectVisible", "acceptButtonStyleClass", "rejectButtonStyleClass", "closeOnEscape", "dismissableMask", "blockScroll", "rtl", "closable", "appendTo", "key", "autoZIndex", "baseZIndex", "transitionOptions", "focusTrap", "defaultFocus", "breakpoints", "visible", "position"], outputs: ["onHide"] }, { kind: "ngmodule", type: DropdownModule }, { kind: "component", type: i7.Dropdown, selector: "p-dropdown", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "autoShowPanelOnPrintableCharacterKeyDown", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i8.InputText, selector: "[pInputText]", inputs: ["variant"] }, { kind: "ngmodule", type: OverlayPanelModule }, { kind: "component", type: i9.OverlayPanel, selector: "p-overlayPanel", inputs: ["ariaLabel", "ariaLabelledBy", "dismissable", "showCloseIcon", "style", "styleClass", "appendTo", "autoZIndex", "ariaCloseLabel", "baseZIndex", "focusOnShow", "showTransitionOptions", "hideTransitionOptions"], outputs: ["onShow", "onHide"] }, { kind: "ngmodule", type: ToolbarModule }, { kind: "component", type: i10.Toolbar, selector: "p-toolbar", inputs: ["style", "styleClass", "ariaLabelledBy"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i11.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "component", type: ClassesPanelComponent, selector: "region-classes-panel", inputs: ["classes", "counts", "matchMode", "activeClass", "selectedCount", "defaultClassName"], outputs: ["pick", "recolor", "remove", "manage"] }, { kind: "component", type: RegionTableComponent, selector: "region-table", inputs: ["page", "total", "first", "rows", "rowsPerPageOptions", "metaKey", "selection", "presetSet", "defaultColor", "mpp", "labelDrafts"], outputs: ["selectionChange", "rowSelect", "labelEditStart", "labelDraftChange", "labelEditStop", "classPick", "deleteRow", "pageChange"] }, { kind: "component", type: SaveRegionsDialogComponent, selector: "region-save-regions-dialog", inputs: ["header", "confirmLabel", "confirmIcon", "inputId", "visible", "filename", "fileExists", "busy"], outputs: ["visibleChange", "filenameChange", "confirm", "cancelSave"] }, { kind: "component", type: SaveMaskDialogComponent, selector: "region-save-mask-dialog", inputs: ["visible", "filename", "mode", "busy", "progress", "encoding"], outputs: ["visibleChange", "filenameChange", "modeChange", "confirm", "cancelExport"] }, { kind: "component", type: RegionColorDialogComponent, selector: "region-color-dialog", inputs: ["visible", "selectedCount", "edits"], outputs: ["visibleChange", "apply"] }, { kind: "component", type: ManageClassesDialogComponent, selector: "region-manage-classes-dialog", inputs: ["visible", "draft"], outputs: ["visibleChange", "draftChange", "apply", "resetDefaults", "importFile", "export"] }, { kind: "component", type: RegionEditorHelpComponent, selector: "region-editor-help", inputs: ["visible"], outputs: ["visibleChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: RegionEditorComponent, isStandalone: true, selector: "region-editor", inputs: { active: "active" }, providers: [RegionPersistenceService], viewQueries: [{ propertyName: "overlayPanel", first: true, predicate: ["op"], descendants: true }], ngImport: i0, template: "<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button\n      icon=\"pi pi-tag\"\n      size=\"small\"\n      [text]=\"!showShapeLabel\"\n      pTooltip=\"Show region labels.\"\n      tooltipPosition=\"bottom\"\n      (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-stop-circle\"\n      size=\"small\"\n      [text]=\"!regionsFilled\"\n      pTooltip=\"Fill regions in their colour (an atlas's look); labels sit inside.\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Fill regions\"\n      (onClick)=\"toggleFill()\"\n    >\n    </p-button>\n    <p-button\n      *ngIf=\"volumeView\"\n      icon=\"pi pi-eye\"\n      size=\"small\"\n      [text]=\"!regionsThroughVolume\"\n      [attr.aria-pressed]=\"regionsThroughVolume\"\n      pTooltip=\"See the regions through the volume. Off, the volume hides the parts of them behind what it shows; on, none (layers traced inside bright structures, such as an OCT's).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Regions through volume\"\n      (onClick)=\"toggleThroughVolume()\"\n    >\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button\n      icon=\"pi pi-upload\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import regions: a GeoJSON file, or a label volume (.nii, .nii.gz, .nrrd) chosen with its ontology JSON for the class tree.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roiFileInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFileInput\n      type=\"file\"\n      accept=\".geojson,.json,.nii,.gz,.nrrd\"\n      multiple\n      hidden\n      (change)=\"importRois($event); roiFileInput.value = ''\"\n    />\n    <p-button\n      icon=\"pi pi-folder-open\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import a folder of per-slice GeoJSON files (one per slice, in name order, with its regionset.json class tree).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Import a folder of regions\"\n      (click)=\"roiFolderInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFolderInput\n      type=\"file\"\n      webkitdirectory\n      multiple\n      hidden\n      (change)=\"importRois($event); roiFolderInput.value = ''\"\n    />\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download regions as geojson file.\"\n      tooltipPosition=\"bottom\"\n      icon=\"pi pi-download\"\n      (click)=\"exportRois()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-save\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Save regions to server.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"persistRegions()\"\n      [disabled]=\"(!regions || !regions.length) && !hasRegionSource\"\n    >\n    </p-button>\n    <p-button\n      *ngIf=\"canImportFromServer\"\n      icon=\"pi pi-cloud-download\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import regions from server: a GeoJSON file, a folder of per-slice GeoJSON files or a label volume (.nii, .nii.gz, .nrrd).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Import regions from server\"\n      [loading]=\"importing\"\n      (click)=\"importFromServer()\"\n    >\n    </p-button>\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download mask of the regions as PNG\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openSaveMaskDialog()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img\n        src=\"assets/plotting/mask.svg\"\n        class=\"toolbar-icon-dark\"\n        style=\"width: 1rem; height: 1rem; vertical-align: middle\"\n        alt=\"Download mask\"\n      />\n    </p-button>\n    <p-button\n      label=\"x512\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roundRectangleLengths()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-check-square\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Select all regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"selectAllRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-tags\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit class on selected rows\"\n      tooltipPosition=\"bottom\"\n      (click)=\"!selectedRegions || !selectedRegions.length ? op.hide() : op.toggle($event)\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-palette\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit colour of selected regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openColorDialog()\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass = ''; newBulkClass = ''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\"\n          >Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span\n        >\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown\n          styleClass=\"w-full\"\n          appendTo=\"body\"\n          [options]=\"presetSet.classes\"\n          optionLabel=\"name\"\n          optionValue=\"name\"\n          [(ngModel)]=\"bulkClass\"\n          placeholder=\"Choose a class\u2026\"\n          [filter]=\"presetSet.classes.length > 8\"\n          filterBy=\"name\"\n          (onChange)=\"applyBulkClass()\"\n        >\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"\n              ><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span\n            >\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input\n            type=\"text\"\n            pInputText\n            placeholder=\"\u2026or a new class\"\n            [(ngModel)]=\"newBulkClass\"\n            (keydown.enter)=\"addAndApplyBulkClass()\"\n          />\n          <button\n            pButton\n            type=\"button\"\n            icon=\"pi pi-plus\"\n            pTooltip=\"Add class &amp; set it\"\n            tooltipPosition=\"bottom\"\n            [disabled]=\"!newBulkClass.trim()\"\n            (click)=\"addAndApplyBulkClass()\"\n          ></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button\n      icon=\"pi pi-trash\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"deleteSelectedRegions()\"\n      pTooltip=\"Delete selected regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-times-circle\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"clearAllRegions()\"\n      pTooltip=\"Delete all regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"(!regions || !regions.length) && !hasRegionSource\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-question\"\n      size=\"small\"\n      [text]=\"true\"\n      (click)=\"showHelp()\"\n      pTooltip=\"Help\"\n      tooltipPosition=\"bottom\"\n    ></p-button>\n  </div>\n</p-toolbar>\n\n<region-classes-panel\n  [classes]=\"displayClasses\"\n  [counts]=\"classCounts\"\n  [matchMode]=\"presetSet.matchMode\"\n  [activeClass]=\"activeClass\"\n  [picked]=\"pickedClass\"\n  [marked]=\"markedClasses\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  [defaultClassName]=\"defaultClassName\"\n  (pick)=\"selectActiveClass($event)\"\n  (recolor)=\"setClassColor($event.name, $event.color)\"\n  (remove)=\"deleteClass($event)\"\n  (manage)=\"openManageDialog()\"\n  [volume]=\"volumeView\"\n  [shown3d]=\"shown3dNames\"\n  (toggle3d)=\"toggleClass3d($event)\"\n  [hidden]=\"hiddenClasses\"\n  (toggleHidden)=\"setClassesHidden([$event], !hiddenClasses.has($event))\"\n  [treeView]=\"classHierarchy ? classTreeView : null\"\n  (treeViewChange)=\"classTreeView = $event\"\n>\n  <!-- A region set with a class hierarchy (an atlas ontology) can show its classes as a tree. -->\n  <region-class-tree\n    *ngIf=\"classHierarchy as hierarchy\"\n    [nodes]=\"hierarchy\"\n    [counts]=\"treeCounts\"\n    [colorOf]=\"treeColor\"\n    [picked]=\"pickedClass\"\n    [marked]=\"markedClasses\"\n    [volume]=\"volumeView\"\n    [shown3d]=\"shown3dNames\"\n    (pick)=\"pickClasses($event)\"\n    (recolor)=\"setClassColor($event.name, $event.color)\"\n    (toggle3d)=\"toggleClass3d($event.name, $event.classes)\"\n    [hidden]=\"hiddenClasses\"\n    (toggleHidden)=\"setClassesHidden($event.classes, $event.hidden)\"\n  >\n  </region-class-tree>\n</region-classes-panel>\n\n<region-table\n  [page]=\"pagedRegions\"\n  [total]=\"tableTotal\"\n  [first]=\"paginatorFirst\"\n  [rows]=\"paginatorRows\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [metaKey]=\"metaKey\"\n  [selection]=\"selectedRegions\"\n  (selectionChange)=\"selectedRegions = $event\"\n  (rowSelect)=\"onSelectionChanged()\"\n  [presetSet]=\"tablePresetSet\"\n  [defaultColor]=\"shapeColor\"\n  [mpp]=\"mpp\"\n  [volumes]=\"tableVolumes\"\n  [labelDrafts]=\"editingLabelRegions\"\n  (labelEditStart)=\"startEditLabel($event)\"\n  (labelDraftChange)=\"setLabelDraft($event.region, $event.value)\"\n  (labelEditStop)=\"stopEditLabel($event.region, $event.commit)\"\n  (classPick)=\"applyPresetToRegion($event.region, $event.name)\"\n  (deleteRow)=\"deleteRegion($event)\"\n  (pageChange)=\"onPageChange($event)\"\n>\n</region-table>\n\n<!-- Live-edit mode: no Save/Cancel \u2014 every edit commits immediately to the\n     active image's region cache. -->\n\n<p-confirmDialog\n  #cd\n  [style]=\"{ width: '24rem', height: '14rem' }\"\n  key=\"positionDialog\"\n  [baseZIndex]=\"10000\"\n  rejectButtonStyleClass=\"p-button-outlined\"\n>\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button\n      type=\"button\"\n      class=\"p-button-outlined\"\n      pButton\n      icon=\"pi pi-times\"\n      label=\"No\"\n      (click)=\"cd.reject()\"\n    ></button>\n  </ng-template>\n</p-confirmDialog>\n\n<region-save-regions-dialog\n  [(visible)]=\"showSaveAsDialog\"\n  [filename]=\"saveAsFilename\"\n  (filenameChange)=\"saveAsFilename = $event; checkSaveAsFileExists()\"\n  [fileExists]=\"saveAsFileExists\"\n  [busy]=\"saveAsBusy\"\n  (confirm)=\"confirmSaveAs()\"\n  (cancelSave)=\"cancelSaveAs()\"\n>\n</region-save-regions-dialog>\n\n<region-save-regions-dialog\n  header=\"Export Regions\"\n  confirmLabel=\"Export\"\n  confirmIcon=\"pi pi-download\"\n  inputId=\"export-filename\"\n  [(visible)]=\"showExportDialog\"\n  [(filename)]=\"exportFilename\"\n  (confirm)=\"confirmExport()\"\n>\n</region-save-regions-dialog>\n\n<region-save-mask-dialog\n  [(visible)]=\"showSaveMaskDialog\"\n  [(filename)]=\"saveMaskFilename\"\n  [(mode)]=\"maskMode\"\n  [busy]=\"maskBusy\"\n  [progress]=\"maskProgress\"\n  [encoding]=\"maskEncoding\"\n  (confirm)=\"confirmSaveMask()\"\n  (cancelExport)=\"cancelSaveMask()\"\n>\n</region-save-mask-dialog>\n\n<region-color-dialog\n  [(visible)]=\"showColorDialog\"\n  [edits]=\"classColorEdits\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  (apply)=\"applyColorToSelected($event)\"\n>\n</region-color-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): edits a working copy, committed on Apply. -->\n<region-manage-classes-dialog\n  [(visible)]=\"showManageDialog\"\n  [(draft)]=\"presetDraft\"\n  (apply)=\"applyManageDialog(true)\"\n  (resetDefaults)=\"resetPresetsToDefaults()\"\n  (importFile)=\"importPresets($event)\"\n  (export)=\"exportPresets()\"\n>\n</region-manage-classes-dialog>\n\n<region-editor-help [(visible)]=\"displayHelpDialog\"></region-editor-help>\n", styles: ["@charset \"UTF-8\";.chip-swatch{display:inline-block;width:.75rem;height:.75rem;border-radius:50%;border:1px solid rgba(0,0,0,.2);flex:0 0 auto}.dd-value{display:inline-flex;align-items:center;gap:.4rem;min-width:0}.dd-value .class-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}:host{display:flex;flex-direction:column;height:100%;min-height:0;overflow:hidden}::ng-deep region-editor .p-toolbar.region-toolbar{padding:.25rem .5rem;border-radius:0;border-left:none;border-right:none;border-top:none}::ng-deep region-editor .p-toolbar.region-toolbar .p-button.p-button-icon-only{width:auto;padding:.25rem .5rem}::ng-deep region-editor .p-toolbar.region-toolbar .p-button{padding:.25rem .5rem}.toolbar-icon-dark{filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}.toolbar-separator{border-left:1px solid var(--surface-border);height:1.5rem;margin:0 .25rem;align-self:center}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i5.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: SharedModule }, { kind: "directive", type: i1.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "ngmodule", type: ButtonModule }, { kind: "directive", type: i6.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading", "severity", "raised", "rounded", "text", "outlined", "size", "plain"] }, { kind: "component", type: i6.Button, selector: "p-button", inputs: ["type", "iconPos", "icon", "badge", "label", "disabled", "loading", "loadingIcon", "raised", "rounded", "text", "plain", "severity", "outlined", "link", "tabindex", "size", "style", "styleClass", "badgeClass", "ariaLabel", "autofocus"], outputs: ["onClick", "onFocus", "onBlur"] }, { kind: "ngmodule", type: ConfirmDialogModule }, { kind: "component", type: i7.ConfirmDialog, selector: "p-confirmDialog", inputs: ["header", "icon", "message", "style", "styleClass", "maskStyleClass", "acceptIcon", "acceptLabel", "closeAriaLabel", "acceptAriaLabel", "acceptVisible", "rejectIcon", "rejectLabel", "rejectAriaLabel", "rejectVisible", "acceptButtonStyleClass", "rejectButtonStyleClass", "closeOnEscape", "dismissableMask", "blockScroll", "rtl", "closable", "appendTo", "key", "autoZIndex", "baseZIndex", "transitionOptions", "focusTrap", "defaultFocus", "breakpoints", "visible", "position"], outputs: ["onHide"] }, { kind: "ngmodule", type: DropdownModule }, { kind: "component", type: i8.Dropdown, selector: "p-dropdown", inputs: ["id", "scrollHeight", "filter", "name", "style", "panelStyle", "styleClass", "panelStyleClass", "readonly", "required", "editable", "appendTo", "tabindex", "placeholder", "loadingIcon", "filterPlaceholder", "filterLocale", "variant", "inputId", "dataKey", "filterBy", "filterFields", "autofocus", "resetFilterOnHide", "checkmark", "dropdownIcon", "loading", "optionLabel", "optionValue", "optionDisabled", "optionGroupLabel", "optionGroupChildren", "autoDisplayFirst", "group", "showClear", "emptyFilterMessage", "emptyMessage", "lazy", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "overlayOptions", "ariaFilterLabel", "ariaLabel", "ariaLabelledBy", "filterMatchMode", "maxlength", "tooltip", "tooltipPosition", "tooltipPositionStyle", "tooltipStyleClass", "focusOnHover", "selectOnFocus", "autoOptionFocus", "autofocusFilter", "autoShowPanelOnPrintableCharacterKeyDown", "disabled", "itemSize", "autoZIndex", "baseZIndex", "showTransitionOptions", "hideTransitionOptions", "filterValue", "options"], outputs: ["onChange", "onFilter", "onFocus", "onBlur", "onClick", "onShow", "onHide", "onClear", "onLazyLoad"] }, { kind: "ngmodule", type: InputTextModule }, { kind: "directive", type: i9.InputText, selector: "[pInputText]", inputs: ["variant"] }, { kind: "ngmodule", type: OverlayPanelModule }, { kind: "component", type: i10.OverlayPanel, selector: "p-overlayPanel", inputs: ["ariaLabel", "ariaLabelledBy", "dismissable", "showCloseIcon", "style", "styleClass", "appendTo", "autoZIndex", "ariaCloseLabel", "baseZIndex", "focusOnShow", "showTransitionOptions", "hideTransitionOptions"], outputs: ["onShow", "onHide"] }, { kind: "ngmodule", type: ToolbarModule }, { kind: "component", type: i11.Toolbar, selector: "p-toolbar", inputs: ["style", "styleClass", "ariaLabelledBy"] }, { kind: "ngmodule", type: TooltipModule }, { kind: "directive", type: i12.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "component", type: ClassesPanelComponent, selector: "region-classes-panel", inputs: ["classes", "counts", "matchMode", "activeClass", "picked", "marked", "selectedCount", "defaultClassName", "volume", "shown3d", "hidden", "treeView"], outputs: ["toggleHidden", "toggle3d", "treeViewChange", "pick", "recolor", "remove", "manage"] }, { kind: "component", type: RegionTableComponent, selector: "region-table", inputs: ["page", "total", "first", "rows", "rowsPerPageOptions", "metaKey", "selection", "presetSet", "defaultColor", "mpp", "volumes", "labelDrafts"], outputs: ["selectionChange", "rowSelect", "labelEditStart", "labelDraftChange", "labelEditStop", "classPick", "deleteRow", "pageChange"] }, { kind: "component", type: ClassTreeComponent, selector: "region-class-tree", inputs: ["nodes", "counts", "colorOf", "picked", "marked", "volume", "shown3d", "hidden"], outputs: ["pick", "recolor", "toggle3d", "toggleHidden"] }, { kind: "component", type: SaveRegionsDialogComponent, selector: "region-save-regions-dialog", inputs: ["header", "confirmLabel", "confirmIcon", "inputId", "visible", "filename", "fileExists", "busy"], outputs: ["visibleChange", "filenameChange", "confirm", "cancelSave"] }, { kind: "component", type: SaveMaskDialogComponent, selector: "region-save-mask-dialog", inputs: ["visible", "filename", "mode", "busy", "progress", "encoding"], outputs: ["visibleChange", "filenameChange", "modeChange", "confirm", "cancelExport"] }, { kind: "component", type: RegionColorDialogComponent, selector: "region-color-dialog", inputs: ["visible", "selectedCount", "edits"], outputs: ["visibleChange", "apply"] }, { kind: "component", type: ManageClassesDialogComponent, selector: "region-manage-classes-dialog", inputs: ["visible", "draft"], outputs: ["visibleChange", "draftChange", "apply", "resetDefaults", "importFile", "export"] }, { kind: "component", type: RegionEditorHelpComponent, selector: "region-editor-help", inputs: ["visible"], outputs: ["visibleChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RegionEditorComponent, decorators: [{
             type: Component,
@@ -926,17 +1551,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
                         TooltipModule,
                         ClassesPanelComponent,
                         RegionTableComponent,
+                        ClassTreeComponent,
                         SaveRegionsDialogComponent,
                         SaveMaskDialogComponent,
                         RegionColorDialogComponent,
                         ManageClassesDialogComponent,
                         RegionEditorHelpComponent,
-                    ], changeDetection: ChangeDetectionStrategy.OnPush, providers: [RegionPersistenceService], template: "<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button\n      icon=\"pi pi-tag\"\n      size=\"small\"\n      [text]=\"!showShapeLabel\"\n      pTooltip=\"Show region labels.\"\n      tooltipPosition=\"bottom\"\n      (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\"\n    >\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button\n      icon=\"pi pi-upload\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Upload and display regions from geojson file.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roiFileInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFileInput\n      type=\"file\"\n      accept=\".geojson,.json\"\n      hidden\n      (change)=\"importRois($event); roiFileInput.value = ''\"\n    />\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download regions as geojson file.\"\n      tooltipPosition=\"bottom\"\n      icon=\"pi pi-download\"\n      (click)=\"exportRois()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-save\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Save regions to server.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"persistRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download mask of the regions as PNG\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openSaveMaskDialog()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img\n        src=\"assets/plotting/mask.svg\"\n        class=\"toolbar-icon-dark\"\n        style=\"width: 1rem; height: 1rem; vertical-align: middle\"\n        alt=\"Download mask\"\n      />\n    </p-button>\n    <p-button\n      label=\"x512\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roundRectangleLengths()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-check-square\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Select all regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"selectAllRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-tags\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit class on selected rows\"\n      tooltipPosition=\"bottom\"\n      (click)=\"!selectedRegions || !selectedRegions.length ? op.hide() : op.toggle($event)\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-palette\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit colour of selected regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openColorDialog()\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass = ''; newBulkClass = ''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\"\n          >Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span\n        >\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown\n          styleClass=\"w-full\"\n          appendTo=\"body\"\n          [options]=\"presetSet.classes\"\n          optionLabel=\"name\"\n          optionValue=\"name\"\n          [(ngModel)]=\"bulkClass\"\n          placeholder=\"Choose a class\u2026\"\n          [filter]=\"presetSet.classes.length > 8\"\n          filterBy=\"name\"\n          (onChange)=\"applyBulkClass()\"\n        >\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"\n              ><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span\n            >\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input\n            type=\"text\"\n            pInputText\n            placeholder=\"\u2026or a new class\"\n            [(ngModel)]=\"newBulkClass\"\n            (keydown.enter)=\"addAndApplyBulkClass()\"\n          />\n          <button\n            pButton\n            type=\"button\"\n            icon=\"pi pi-plus\"\n            pTooltip=\"Add class &amp; set it\"\n            tooltipPosition=\"bottom\"\n            [disabled]=\"!newBulkClass.trim()\"\n            (click)=\"addAndApplyBulkClass()\"\n          ></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button\n      icon=\"pi pi-trash\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"deleteSelectedRegions()\"\n      pTooltip=\"Delete selected regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-times-circle\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"clearAllRegions()\"\n      pTooltip=\"Delete all regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!regions || !regions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-question\"\n      size=\"small\"\n      [text]=\"true\"\n      (click)=\"showHelp()\"\n      pTooltip=\"Help\"\n      tooltipPosition=\"bottom\"\n    ></p-button>\n  </div>\n</p-toolbar>\n\n<region-classes-panel\n  [classes]=\"displayClasses\"\n  [counts]=\"classCounts\"\n  [matchMode]=\"presetSet.matchMode\"\n  [activeClass]=\"activeClass\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  [defaultClassName]=\"defaultClassName\"\n  (pick)=\"selectActiveClass($event)\"\n  (recolor)=\"setClassColor($event.name, $event.color)\"\n  (remove)=\"deleteClass($event)\"\n  (manage)=\"openManageDialog()\"\n>\n</region-classes-panel>\n\n<region-table\n  [page]=\"pagedRegions\"\n  [total]=\"regions.length\"\n  [first]=\"paginatorFirst\"\n  [rows]=\"paginatorRows\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [metaKey]=\"metaKey\"\n  [selection]=\"selectedRegions\"\n  (selectionChange)=\"selectedRegions = $event\"\n  (rowSelect)=\"onSelectionChanged()\"\n  [presetSet]=\"presetSet\"\n  [defaultColor]=\"shapeColor\"\n  [mpp]=\"mpp\"\n  [labelDrafts]=\"editingLabelRegions\"\n  (labelEditStart)=\"startEditLabel($event)\"\n  (labelDraftChange)=\"setLabelDraft($event.region, $event.value)\"\n  (labelEditStop)=\"stopEditLabel($event.region, $event.commit)\"\n  (classPick)=\"applyPresetToRegion($event.region, $event.name)\"\n  (deleteRow)=\"deleteRegion($event)\"\n  (pageChange)=\"onPageChange($event)\"\n>\n</region-table>\n\n<!-- Live-edit mode: no Save/Cancel \u2014 every edit commits immediately to the\n     active image's region cache. -->\n\n<p-confirmDialog\n  #cd\n  [style]=\"{ width: '24rem', height: '14rem' }\"\n  key=\"positionDialog\"\n  [baseZIndex]=\"10000\"\n  rejectButtonStyleClass=\"p-button-outlined\"\n>\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button\n      type=\"button\"\n      class=\"p-button-outlined\"\n      pButton\n      icon=\"pi pi-times\"\n      label=\"No\"\n      (click)=\"cd.reject()\"\n    ></button>\n  </ng-template>\n</p-confirmDialog>\n\n<region-save-regions-dialog\n  [(visible)]=\"showSaveAsDialog\"\n  [filename]=\"saveAsFilename\"\n  (filenameChange)=\"saveAsFilename = $event; checkSaveAsFileExists()\"\n  [fileExists]=\"saveAsFileExists\"\n  [busy]=\"saveAsBusy\"\n  (confirm)=\"confirmSaveAs()\"\n  (cancelSave)=\"cancelSaveAs()\"\n>\n</region-save-regions-dialog>\n\n<region-save-regions-dialog\n  header=\"Export Regions\"\n  confirmLabel=\"Export\"\n  confirmIcon=\"pi pi-download\"\n  inputId=\"export-filename\"\n  [(visible)]=\"showExportDialog\"\n  [(filename)]=\"exportFilename\"\n  (confirm)=\"confirmExport()\"\n>\n</region-save-regions-dialog>\n\n<region-save-mask-dialog\n  [(visible)]=\"showSaveMaskDialog\"\n  [(filename)]=\"saveMaskFilename\"\n  [(mode)]=\"maskMode\"\n  [busy]=\"maskBusy\"\n  [progress]=\"maskProgress\"\n  [encoding]=\"maskEncoding\"\n  (confirm)=\"confirmSaveMask()\"\n  (cancelExport)=\"cancelSaveMask()\"\n>\n</region-save-mask-dialog>\n\n<region-color-dialog\n  [(visible)]=\"showColorDialog\"\n  [edits]=\"classColorEdits\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  (apply)=\"applyColorToSelected($event)\"\n>\n</region-color-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): edits a working copy, committed on Apply. -->\n<region-manage-classes-dialog\n  [(visible)]=\"showManageDialog\"\n  [(draft)]=\"presetDraft\"\n  (apply)=\"applyManageDialog(true)\"\n  (resetDefaults)=\"resetPresetsToDefaults()\"\n  (importFile)=\"importPresets($event)\"\n  (export)=\"exportPresets()\"\n>\n</region-manage-classes-dialog>\n\n<region-editor-help [(visible)]=\"displayHelpDialog\"></region-editor-help>\n", styles: ["@charset \"UTF-8\";.chip-swatch{display:inline-block;width:.75rem;height:.75rem;border-radius:50%;border:1px solid rgba(0,0,0,.2);flex:0 0 auto}.dd-value{display:inline-flex;align-items:center;gap:.4rem;min-width:0}.dd-value .class-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}:host{display:flex;flex-direction:column;height:100%;min-height:0;overflow:hidden}::ng-deep region-editor .p-toolbar.region-toolbar{padding:.25rem .5rem;border-radius:0;border-left:none;border-right:none;border-top:none}::ng-deep region-editor .p-toolbar.region-toolbar .p-button.p-button-icon-only{width:auto;padding:.25rem .5rem}::ng-deep region-editor .p-toolbar.region-toolbar .p-button{padding:.25rem .5rem}.toolbar-icon-dark{filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}.toolbar-separator{border-left:1px solid var(--surface-border);height:1.5rem;margin:0 .25rem;align-self:center}\n"] }]
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, providers: [RegionPersistenceService], template: "<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button\n      icon=\"pi pi-tag\"\n      size=\"small\"\n      [text]=\"!showShapeLabel\"\n      pTooltip=\"Show region labels.\"\n      tooltipPosition=\"bottom\"\n      (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-stop-circle\"\n      size=\"small\"\n      [text]=\"!regionsFilled\"\n      pTooltip=\"Fill regions in their colour (an atlas's look); labels sit inside.\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Fill regions\"\n      (onClick)=\"toggleFill()\"\n    >\n    </p-button>\n    <p-button\n      *ngIf=\"volumeView\"\n      icon=\"pi pi-eye\"\n      size=\"small\"\n      [text]=\"!regionsThroughVolume\"\n      [attr.aria-pressed]=\"regionsThroughVolume\"\n      pTooltip=\"See the regions through the volume. Off, the volume hides the parts of them behind what it shows; on, none (layers traced inside bright structures, such as an OCT's).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Regions through volume\"\n      (onClick)=\"toggleThroughVolume()\"\n    >\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button\n      icon=\"pi pi-upload\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import regions: a GeoJSON file, or a label volume (.nii, .nii.gz, .nrrd) chosen with its ontology JSON for the class tree.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roiFileInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFileInput\n      type=\"file\"\n      accept=\".geojson,.json,.nii,.gz,.nrrd\"\n      multiple\n      hidden\n      (change)=\"importRois($event); roiFileInput.value = ''\"\n    />\n    <p-button\n      icon=\"pi pi-folder-open\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import a folder of per-slice GeoJSON files (one per slice, in name order, with its regionset.json class tree).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Import a folder of regions\"\n      (click)=\"roiFolderInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFolderInput\n      type=\"file\"\n      webkitdirectory\n      multiple\n      hidden\n      (change)=\"importRois($event); roiFolderInput.value = ''\"\n    />\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download regions as geojson file.\"\n      tooltipPosition=\"bottom\"\n      icon=\"pi pi-download\"\n      (click)=\"exportRois()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-save\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Save regions to server.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"persistRegions()\"\n      [disabled]=\"(!regions || !regions.length) && !hasRegionSource\"\n    >\n    </p-button>\n    <p-button\n      *ngIf=\"canImportFromServer\"\n      icon=\"pi pi-cloud-download\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import regions from server: a GeoJSON file, a folder of per-slice GeoJSON files or a label volume (.nii, .nii.gz, .nrrd).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Import regions from server\"\n      [loading]=\"importing\"\n      (click)=\"importFromServer()\"\n    >\n    </p-button>\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download mask of the regions as PNG\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openSaveMaskDialog()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img\n        src=\"assets/plotting/mask.svg\"\n        class=\"toolbar-icon-dark\"\n        style=\"width: 1rem; height: 1rem; vertical-align: middle\"\n        alt=\"Download mask\"\n      />\n    </p-button>\n    <p-button\n      label=\"x512\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roundRectangleLengths()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-check-square\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Select all regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"selectAllRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-tags\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit class on selected rows\"\n      tooltipPosition=\"bottom\"\n      (click)=\"!selectedRegions || !selectedRegions.length ? op.hide() : op.toggle($event)\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-palette\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit colour of selected regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openColorDialog()\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass = ''; newBulkClass = ''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\"\n          >Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span\n        >\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown\n          styleClass=\"w-full\"\n          appendTo=\"body\"\n          [options]=\"presetSet.classes\"\n          optionLabel=\"name\"\n          optionValue=\"name\"\n          [(ngModel)]=\"bulkClass\"\n          placeholder=\"Choose a class\u2026\"\n          [filter]=\"presetSet.classes.length > 8\"\n          filterBy=\"name\"\n          (onChange)=\"applyBulkClass()\"\n        >\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"\n              ><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span\n            >\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input\n            type=\"text\"\n            pInputText\n            placeholder=\"\u2026or a new class\"\n            [(ngModel)]=\"newBulkClass\"\n            (keydown.enter)=\"addAndApplyBulkClass()\"\n          />\n          <button\n            pButton\n            type=\"button\"\n            icon=\"pi pi-plus\"\n            pTooltip=\"Add class &amp; set it\"\n            tooltipPosition=\"bottom\"\n            [disabled]=\"!newBulkClass.trim()\"\n            (click)=\"addAndApplyBulkClass()\"\n          ></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button\n      icon=\"pi pi-trash\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"deleteSelectedRegions()\"\n      pTooltip=\"Delete selected regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-times-circle\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"clearAllRegions()\"\n      pTooltip=\"Delete all regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"(!regions || !regions.length) && !hasRegionSource\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-question\"\n      size=\"small\"\n      [text]=\"true\"\n      (click)=\"showHelp()\"\n      pTooltip=\"Help\"\n      tooltipPosition=\"bottom\"\n    ></p-button>\n  </div>\n</p-toolbar>\n\n<region-classes-panel\n  [classes]=\"displayClasses\"\n  [counts]=\"classCounts\"\n  [matchMode]=\"presetSet.matchMode\"\n  [activeClass]=\"activeClass\"\n  [picked]=\"pickedClass\"\n  [marked]=\"markedClasses\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  [defaultClassName]=\"defaultClassName\"\n  (pick)=\"selectActiveClass($event)\"\n  (recolor)=\"setClassColor($event.name, $event.color)\"\n  (remove)=\"deleteClass($event)\"\n  (manage)=\"openManageDialog()\"\n  [volume]=\"volumeView\"\n  [shown3d]=\"shown3dNames\"\n  (toggle3d)=\"toggleClass3d($event)\"\n  [hidden]=\"hiddenClasses\"\n  (toggleHidden)=\"setClassesHidden([$event], !hiddenClasses.has($event))\"\n  [treeView]=\"classHierarchy ? classTreeView : null\"\n  (treeViewChange)=\"classTreeView = $event\"\n>\n  <!-- A region set with a class hierarchy (an atlas ontology) can show its classes as a tree. -->\n  <region-class-tree\n    *ngIf=\"classHierarchy as hierarchy\"\n    [nodes]=\"hierarchy\"\n    [counts]=\"treeCounts\"\n    [colorOf]=\"treeColor\"\n    [picked]=\"pickedClass\"\n    [marked]=\"markedClasses\"\n    [volume]=\"volumeView\"\n    [shown3d]=\"shown3dNames\"\n    (pick)=\"pickClasses($event)\"\n    (recolor)=\"setClassColor($event.name, $event.color)\"\n    (toggle3d)=\"toggleClass3d($event.name, $event.classes)\"\n    [hidden]=\"hiddenClasses\"\n    (toggleHidden)=\"setClassesHidden($event.classes, $event.hidden)\"\n  >\n  </region-class-tree>\n</region-classes-panel>\n\n<region-table\n  [page]=\"pagedRegions\"\n  [total]=\"tableTotal\"\n  [first]=\"paginatorFirst\"\n  [rows]=\"paginatorRows\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [metaKey]=\"metaKey\"\n  [selection]=\"selectedRegions\"\n  (selectionChange)=\"selectedRegions = $event\"\n  (rowSelect)=\"onSelectionChanged()\"\n  [presetSet]=\"tablePresetSet\"\n  [defaultColor]=\"shapeColor\"\n  [mpp]=\"mpp\"\n  [volumes]=\"tableVolumes\"\n  [labelDrafts]=\"editingLabelRegions\"\n  (labelEditStart)=\"startEditLabel($event)\"\n  (labelDraftChange)=\"setLabelDraft($event.region, $event.value)\"\n  (labelEditStop)=\"stopEditLabel($event.region, $event.commit)\"\n  (classPick)=\"applyPresetToRegion($event.region, $event.name)\"\n  (deleteRow)=\"deleteRegion($event)\"\n  (pageChange)=\"onPageChange($event)\"\n>\n</region-table>\n\n<!-- Live-edit mode: no Save/Cancel \u2014 every edit commits immediately to the\n     active image's region cache. -->\n\n<p-confirmDialog\n  #cd\n  [style]=\"{ width: '24rem', height: '14rem' }\"\n  key=\"positionDialog\"\n  [baseZIndex]=\"10000\"\n  rejectButtonStyleClass=\"p-button-outlined\"\n>\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button\n      type=\"button\"\n      class=\"p-button-outlined\"\n      pButton\n      icon=\"pi pi-times\"\n      label=\"No\"\n      (click)=\"cd.reject()\"\n    ></button>\n  </ng-template>\n</p-confirmDialog>\n\n<region-save-regions-dialog\n  [(visible)]=\"showSaveAsDialog\"\n  [filename]=\"saveAsFilename\"\n  (filenameChange)=\"saveAsFilename = $event; checkSaveAsFileExists()\"\n  [fileExists]=\"saveAsFileExists\"\n  [busy]=\"saveAsBusy\"\n  (confirm)=\"confirmSaveAs()\"\n  (cancelSave)=\"cancelSaveAs()\"\n>\n</region-save-regions-dialog>\n\n<region-save-regions-dialog\n  header=\"Export Regions\"\n  confirmLabel=\"Export\"\n  confirmIcon=\"pi pi-download\"\n  inputId=\"export-filename\"\n  [(visible)]=\"showExportDialog\"\n  [(filename)]=\"exportFilename\"\n  (confirm)=\"confirmExport()\"\n>\n</region-save-regions-dialog>\n\n<region-save-mask-dialog\n  [(visible)]=\"showSaveMaskDialog\"\n  [(filename)]=\"saveMaskFilename\"\n  [(mode)]=\"maskMode\"\n  [busy]=\"maskBusy\"\n  [progress]=\"maskProgress\"\n  [encoding]=\"maskEncoding\"\n  (confirm)=\"confirmSaveMask()\"\n  (cancelExport)=\"cancelSaveMask()\"\n>\n</region-save-mask-dialog>\n\n<region-color-dialog\n  [(visible)]=\"showColorDialog\"\n  [edits]=\"classColorEdits\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  (apply)=\"applyColorToSelected($event)\"\n>\n</region-color-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): edits a working copy, committed on Apply. -->\n<region-manage-classes-dialog\n  [(visible)]=\"showManageDialog\"\n  [(draft)]=\"presetDraft\"\n  (apply)=\"applyManageDialog(true)\"\n  (resetDefaults)=\"resetPresetsToDefaults()\"\n  (importFile)=\"importPresets($event)\"\n  (export)=\"exportPresets()\"\n>\n</region-manage-classes-dialog>\n\n<region-editor-help [(visible)]=\"displayHelpDialog\"></region-editor-help>\n", styles: ["@charset \"UTF-8\";.chip-swatch{display:inline-block;width:.75rem;height:.75rem;border-radius:50%;border:1px solid rgba(0,0,0,.2);flex:0 0 auto}.dd-value{display:inline-flex;align-items:center;gap:.4rem;min-width:0}.dd-value .class-name{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}:host{display:flex;flex-direction:column;height:100%;min-height:0;overflow:hidden}::ng-deep region-editor .p-toolbar.region-toolbar{padding:.25rem .5rem;border-radius:0;border-left:none;border-right:none;border-top:none}::ng-deep region-editor .p-toolbar.region-toolbar .p-button.p-button-icon-only{width:auto;padding:.25rem .5rem}::ng-deep region-editor .p-toolbar.region-toolbar .p-button{padding:.25rem .5rem}.toolbar-icon-dark{filter:brightness(0) invert(47%) sepia(98%) saturate(567%) hue-rotate(181deg) brightness(103%) contrast(98%)}.toolbar-separator{border-left:1px solid var(--surface-border);height:1.5rem;margin:0 .25rem;align-self:center}\n"] }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [REGION_EDITOR_API]
                 }] }, { type: i1.MessageService }, { type: i1.ConfirmationService }, { type: i2.RegionPersistenceService }, { type: i3.MaskExportService }], propDecorators: { overlayPanel: [{
                 type: ViewChild,
                 args: ['op']
+            }], active: [{
+                type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-editor.component.js","sourceRoot":"","sources":["../../../../src/lib/region-editor/region-editor.component.ts","../../../../src/lib/region-editor/region-editor.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  DestroyRef,\n  Inject,\n  OnDestroy,\n  OnInit,\n  ViewChild,\n  inject,\n  NgZone,\n} from '@angular/core';\nimport { markForCheckInZone } from '../util/mark-for-check';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport { ButtonModule } from 'primeng/button';\nimport { ConfirmDialogModule } from 'primeng/confirmdialog';\nimport { DropdownModule } from 'primeng/dropdown';\nimport { InputTextModule } from 'primeng/inputtext';\nimport { OverlayPanel, OverlayPanelModule } from 'primeng/overlaypanel';\nimport { ToolbarModule } from 'primeng/toolbar';\nimport { TooltipModule } from 'primeng/tooltip';\nimport { saveAs } from 'file-saver';\nimport { Subject, Subscription } from 'rxjs';\n\nimport { Rectangle, Region } from '../models/region';\nimport { withRegionPatch } from '../models/region-clone';\nimport { PresetSet, ClassPreset, defaultPresetSet, parsePresetSet } from '../models/class-preset';\nimport { colorForLabel, presetKey } from '../store/class-color.util';\nimport { ConfirmationService, MessageService, SharedModule } from 'primeng/api';\nimport { IRegionEditorApi, REGION_EDITOR_API } from '../contracts/region-editor-api.contract';\nimport { VIZ_TOAST_KEY } from '../toast-outlets';\nimport { RegionPersistenceService } from './region-persistence.service';\nimport { ClassColorEdit, RegionColorDialogComponent } from './region-color-dialog/region-color-dialog.component';\nimport { ClassesPanelComponent } from './classes-panel/classes-panel.component';\nimport { RegionTableComponent } from './region-table/region-table.component';\nimport { SaveRegionsDialogComponent } from './save-regions-dialog/save-regions-dialog.component';\nimport { SaveMaskDialogComponent } from './save-mask-dialog/save-mask-dialog.component';\nimport { ManageClassesDialogComponent } from './manage-classes-dialog/manage-classes-dialog.component';\nimport { RegionEditorHelpComponent } from './region-editor-help/region-editor-help.component';\nimport { MaskExportService, MaskMode } from './mask-export.service';\nimport { PixelSize, formatArea, pickMpp, regionAreaPx } from './region-metrics';\n\n/**\n * The Region Editor (`<region-editor>`): the table of the active image's\n * annotation regions with class presets, colours, labels, GeoJSON import /\n * export / server save and mask export. Self-contained: it talks to the viewer\n * only through {@link REGION_EDITOR_API} (and the host's REGION_IO_PORT), so it\n * has no inputs or outputs.\n *\n * OnPush: template events re-render it; state that lands asynchronously (the\n * API's region / selection / preset / image-meta streams, save and mask-export\n * progress, file reads) marks it for check.\n */\n@Component({\n  selector: 'region-editor',\n  standalone: true,\n  imports: [\n    CommonModule,\n    FormsModule,\n    SharedModule,\n    ButtonModule,\n    ConfirmDialogModule,\n    DropdownModule,\n    InputTextModule,\n    OverlayPanelModule,\n    ToolbarModule,\n    TooltipModule,\n    ClassesPanelComponent,\n    RegionTableComponent,\n    SaveRegionsDialogComponent,\n    SaveMaskDialogComponent,\n    RegionColorDialogComponent,\n    ManageClassesDialogComponent,\n    RegionEditorHelpComponent,\n  ],\n  templateUrl: './region-editor.component.html',\n  styleUrls: ['./region-editor.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [RegionPersistenceService],\n})\nexport class RegionEditorComponent implements OnInit, OnDestroy {\n  @ViewChild('op') private overlayPanel!: OverlayPanel;\n\n  protected regions: Region[] = [];\n  protected selectedRegions: Region[] = [];\n  protected showShapeLabel!: boolean;\n  protected shapeColor!: string;\n  protected fillColor!: string;\n  protected displayHelpDialog = false;\n  protected showColorDialog = false;\n  /** One colour editor per unique class among the selected regions, shown in the\n   *  \"edit colour of selected regions\" dialog. Unclassified regions (no label)\n   *  are grouped under a single entry with an empty `label`. */\n  protected classColorEdits: ClassColorEdit[] = [];\n  /** \"Edit class on selected rows\" popup: chosen existing class, and a new-class name. */\n  protected bulkClass = '';\n  protected newBulkClass = '';\n\n  // ── annotation-class presets (jit-ui#70) ──\n  /** Local mirror of the per-user preset set (chip strip, Class dropdown, dialog). */\n  protected presetSet: PresetSet = defaultPresetSet();\n  /** The class last picked in the panel; a chip-click applies it to the selected rows. */\n  protected activeClass: string | null = null;\n  protected showManageDialog = false;\n  /** Working copy edited inside the Manage-classes dialog; committed on Apply/Done. */\n  protected presetDraft: PresetSet | null = null;\n  /** class name (match-mode keyed) → number of regions currently using it. */\n  protected classCounts = new Map<string, number>();\n  /** Fallback class that a region reverts to when its class is deleted (jit-ui#70). */\n  protected readonly defaultClassName = 'Region';\n  /** Classes as shown in the panel: sorted by region count (desc), then name. */\n  protected displayClasses: ClassPreset[] = [];\n\n  protected paginatorFirst = 0;\n  protected paginatorRows = 10;\n  protected readonly rowsPerPageOptions = [10, 25, 50];\n  /** Regions whose Class cell is currently in edit mode → the label being typed.\n   *  The draft is committed on Enter and discarded on Escape/✕, so typing never\n   *  writes into the store's region (RT-18). Keyed by object identity, which\n   *  avoids needing a unique id field. */\n  protected editingLabelRegions = new Map<Region, string>();\n\n  protected showSaveAsDialog = false;\n  protected saveAsFilename = '';\n  protected saveAsFileExists = false;\n  /** True while a GeoJSON persist is serializing/uploading — drives the dialog's\n   *  progress bar and Cancel button (parity with the Save-mask dialog). */\n  protected saveAsBusy = false;\n  /** The running GeoJSON save; unsubscribing cancels it (Cancel / destroy). */\n  private _saveAsSub?: Subscription;\n  /** Save-as file names to check for an existing file (debounced). */\n  private readonly saveAsCheck$ = new Subject<string>();\n\n  protected showExportDialog = false;\n  protected exportFilename = '';\n\n  protected showSaveMaskDialog = false;\n  protected saveMaskFilename = '';\n  /** Mask type chosen in the Save-mask dialog: a binary foreground/background\n   *  mask, or a multi-class mask with a distinct id per region. */\n  protected maskMode: MaskMode = 'binary';\n  /** True while the mask worker is rasterizing/encoding — drives the progress\n   *  bar and the Cancel button in the dialog. */\n  protected maskBusy = false;\n  /** 0–100 rasterization progress; switches to indeterminate during encoding. */\n  protected maskProgress = 0;\n  protected maskEncoding = false;\n  /** The running mask export; unsubscribing cancels it (terminates its worker). */\n  private maskJob?: Subscription;\n\n  /**\n   * PrimeNG p-table multi-selection mode toggle. When true, single-click\n   * selects one row (replacing prior); meta/ctrl-click toggles a row in/out\n   * of the selection. When false, every click toggles. Default true to\n   * match the most common spreadsheet-like UX.\n   */\n  protected metaKey = true;\n\n  private _updatingFromEditor = false;\n  private _suppressSelectionSyncToPlot = false;\n  private readonly destroyRef = inject(DestroyRef);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly zone = inject(NgZone);\n\n  /** Re-render this OnPush view, re-entering the zone when the change came from outside it. */\n  private changed(): void {\n    markForCheckInZone(this.cdr, this.zone);\n  }\n\n  /** Physical pixel size (µm/pixel) of the active image, for region areas in\n   *  µm²; empty when the format reports no physical size. */\n  protected mpp: PixelSize = {};\n\n  constructor(\n    @Inject(REGION_EDITOR_API) private regionApi: IRegionEditorApi,\n    private messageService: MessageService,\n    private confirmationService: ConfirmationService,\n    private persistence: RegionPersistenceService,\n    private maskExport: MaskExportService,\n  ) {}\n\n  ngOnInit() {\n    this.showShapeLabel = this.regionApi.getShowShapeLabel();\n    this.shapeColor = this.regionApi.getShapeColor();\n    this.fillColor = this.regionApi.getFillColor();\n\n    // Annotation-class presets (jit-ui#70): mirror the set for the chip strip,\n    // the Class dropdown and the manage dialog. Guarded with optional calls so\n    // partial API mocks in tests (which omit the preset methods) don't throw.\n    const initialPresets = this.regionApi.getPresetSet?.();\n    if (initialPresets) this.presetSet = initialPresets;\n    const presets$ = this.regionApi.getPresetSet$?.();\n    if (presets$) {\n      presets$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((set) => {\n        if (set) this.presetSet = set;\n        this.updateDisplayClasses();\n        this.changed();\n      });\n    }\n    // Seed from the visualizer's current regions — already scoped to the\n    // active image by the per-image cache, and handed back as neutral Region\n    // objects (no backend shape format involved).\n    // Annotation regions only — intensity-profile lines are owned by the\n    // intensity tool and excluded by the contract, so the editor never sees them.\n    this.regions = this.applyRegionColors(this.regionApi.getAnnotationRegions());\n    this.syncClassesFromRegions(this.regions);\n    this.recomputeClassCounts();\n\n    // The update event is just a change signal; re-read the regions from the\n    // visualizer rather than parsing whatever payload it carries.\n    this.regionApi\n      .getRegionUpdateEvent()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => {\n        if (this._updatingFromEditor) return;\n        const updated = this.applyRegionColors(this.regionApi.getAnnotationRegions());\n        // preserve selection for regions that still exist (by id, since name\n        // is a user-editable display label and may collide)\n        const selectedIds = new Set(this.selectedRegions.map((r) => r.id));\n        this.regions = updated;\n        this.selectedRegions = updated.filter((r) => selectedIds.has(r.id));\n        this.clampPaginatorFirst();\n        this.syncClassesFromRegions(updated);\n        this.recomputeClassCounts();\n        this.changed();\n      });\n\n    this.persistence\n      .fileExists(this.saveAsCheck$)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((exists) => {\n        this.saveAsFileExists = exists;\n        this.changed();\n      });\n\n    // Physical pixel size of the active image (for region areas in µm²/mm²).\n    this.regionApi\n      .getImageMeta()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((meta) => {\n        this.mpp = pickMpp(meta);\n        this.changed();\n      });\n\n    this.regionApi\n      .getSelectedRegions$()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((selected) => {\n        if (this._suppressSelectionSyncToPlot) return;\n        // Map the contract's selected regions to the editor's own instances by id.\n        const next = selected.map((s) => this.regions.find((r) => r.id === s.id)).filter((r): r is Region => !!r);\n        const same =\n          next.length === this.selectedRegions.length &&\n          next.every((r, i) => r.id === this.selectedRegions[i]?.id);\n        if (!same) this.selectedRegions = next;\n        // Scroll the paginator so the most-recently-selected row is visible.\n        if (next.length > 0) {\n          const lastIdx = this.regions.findIndex((r) => r.id === next[next.length - 1].id);\n          if (lastIdx >= 0) {\n            const pageStart = Math.floor(lastIdx / this.paginatorRows) * this.paginatorRows;\n            if (pageStart !== this.paginatorFirst) this.paginatorFirst = pageStart;\n          }\n        }\n        this.changed();\n      });\n  }\n\n  /** Cancels a running GeoJSON save (aborts its upload) and mask export (terminates\n   *  its worker); the API subscriptions end through `takeUntilDestroyed`. */\n  ngOnDestroy() {\n    this._saveAsSub?.unsubscribe();\n    this.maskJob?.unsubscribe();\n  }\n\n  /**\n   * Table → Plot: PrimeNG fires onRowSelect/onRowUnselect after updating\n   * `selectedRegions`. Push the selected regions to the contract by identity —\n   * the package maps them to its internal index space (which includes the\n   * intensity-profile lines the editor never sees).\n   */\n  protected onSelectionChanged() {\n    this._suppressSelectionSyncToPlot = true;\n    try {\n      this.regionApi.setSelectedRegions(this.selectedRegions ?? []);\n    } finally {\n      this._suppressSelectionSyncToPlot = false;\n    }\n  }\n\n  /**\n   * Rows for regions coming from the visualizer: neutral `Region`s with bounds,\n   * colour and label already populated. A region without a colour is shown with\n   * its classification colour (or the default shape colour) — as a copy: the\n   * store's instances are shared with its undo history and must not be changed\n   * in place (RT-1).\n   */\n  private applyRegionColors(regions: Region[]): Region[] {\n    const classColors = this.regionApi.getClassificationColors();\n    return regions.map((region) =>\n      region.color\n        ? region\n        : withRegionPatch(region, { color: classColors.get(region.label ?? '') || this.shapeColor }),\n    );\n  }\n\n  /**\n   * The editor's one write path (RT-1): make `next` the table's rows and commit\n   * them to the store — live, as one undoable step (isRegionSaveOn=true; the\n   * router keeps the intensity-profile lines). Rows are the store's instances,\n   * so an edit passes copies ({@link patchRegions}), never changed rows. The\n   * resulting region-update event is ignored (`_updatingFromEditor`), so the\n   * class list and counts are refreshed here (a typed class is added; jit-ui#70).\n   */\n  private commit(next: Region[] = this.regions): void {\n    this.regions = next;\n    this._updatingFromEditor = true;\n    try {\n      this.regionApi.setAnnotationRegions(next, this.showShapeLabel, true, this.fillColor);\n    } finally {\n      this._updatingFromEditor = false;\n    }\n    this.syncClassesFromRegions(next);\n    this.recomputeClassCounts();\n    this.changed();\n  }\n\n  /**\n   * Copy-on-write edit (review RT-1). The editor's rows are the region store's\n   * live instances, and the store takes its undo snapshot only when the edit is\n   * committed — so an edit must replace a region with a patched copy (and any\n   * bounds it changes with new bounds), never mutate the instance the store\n   * holds. Returns the copies by original; the selection and an open label edit\n   * follow them.\n   */\n  private patchRegions(patchFor: (r: Region) => Partial<Region> | null): Map<Region, Region> {\n    const copies = new Map<Region, Region>();\n    this.regions = this.regions.map((r) => {\n      const patch = patchFor(r);\n      if (!patch) return r;\n      const copy = withRegionPatch(r, patch);\n      copies.set(r, copy);\n      return copy;\n    });\n    if (copies.size) {\n      this.selectedRegions = (this.selectedRegions ?? []).map((r) => copies.get(r) ?? r);\n      if ([...copies.keys()].some((r) => this.editingLabelRegions.has(r))) {\n        this.editingLabelRegions = new Map([...this.editingLabelRegions].map(([r, d]) => [copies.get(r) ?? r, d]));\n      }\n    }\n    return copies;\n  }\n\n  /** Set one region's outline colour (an explicit override) and commit live. */\n  protected changeRegionColor(region: Region, color: string): void {\n    if (!color || region.color === color) return;\n    // colorOverridden: explicit per-region colour — preserve it against preset (re)apply (jit-ui#70)\n    this.patchRegions((r) => (r === region ? { color, colorOverridden: true } : null));\n    this.commit();\n  }\n\n  /**\n   * After a label edit on `region`: give every labelled row without a colour its\n   * class colour (preset or fallback, as the store will), and commit when\n   * `commit` is set.\n   */\n  protected labelRegionUpdate(region: Region, commit = false) {\n    this.fillClassColors();\n    if (commit) this.commit();\n  }\n\n  /** Labelled rows without a colour get their class colour (copies). */\n  private fillClassColors(): void {\n    this.patchRegions((r) => (!r.color && r.label ? { color: this.colorForName(r.label) } : null));\n  }\n\n  /** The current page of the table. Memoized on (regions, first, rows), so\n   *  change detection doesn't hand p-table a new array every tick (RT-20). */\n  protected get pagedRegions(): Region[] {\n    const key = this._pageKey;\n    if (key.regions !== this.regions || key.first !== this.paginatorFirst || key.rows !== this.paginatorRows) {\n      this._pageKey = { regions: this.regions, first: this.paginatorFirst, rows: this.paginatorRows };\n      this._page = this.regions.slice(this.paginatorFirst, this.paginatorFirst + this.paginatorRows);\n    }\n    return this._page;\n  }\n  private _pageKey: { regions?: Region[]; first?: number; rows?: number } = {};\n  private _page: Region[] = [];\n\n  protected onPageChange(event: { first?: number; rows?: number }) {\n    this.paginatorFirst = event.first ?? 0;\n    this.paginatorRows = event.rows ?? this.paginatorRows;\n  }\n\n  /** Select every region in the table (and highlight them on the diagram). */\n  protected selectAllRegions() {\n    this.selectedRegions = [...this.regions];\n    this.onSelectionChanged();\n  }\n\n  protected deleteSelectedRegions() {\n    if (this.selectedRegions && this.selectedRegions.length > 0) {\n      // Filter by id — object identity isn't reliable across re-parses,\n      // and name is a user-editable label that may collide.\n      const removed = new Set(this.selectedRegions.map((r) => r.id));\n      this.selectedRegions = [];\n      this.commit(this.regions.filter((r) => !removed.has(r.id)));\n      this.clampPaginatorFirst();\n      // Sync the cleared selection with the plot's highlight state.\n      this.onSelectionChanged();\n    }\n  }\n\n  protected clearAllRegions() {\n    this.confirmationService.confirm({\n      key: 'positionDialog',\n      message: 'Are you sure you want to delete all regions?',\n      accept: () => {\n        this.selectedRegions = [];\n        this.paginatorFirst = 0;\n        this.commit([]);\n        this.onSelectionChanged();\n      },\n    });\n  }\n\n  protected deleteRegion(shapeIdx: number) {\n    const removed = this.regions[shapeIdx];\n    if (removed) {\n      this.selectedRegions = this.selectedRegions.filter((r) => r.id !== removed.id);\n    }\n    this.commit(this.regions.filter((_, i) => i !== shapeIdx));\n    this.clampPaginatorFirst();\n    // Re-emit the (possibly trimmed) selection so the plot's highlight stays\n    // in sync with what's still in the table.\n    this.onSelectionChanged();\n  }\n\n  private clampPaginatorFirst() {\n    const maxFirst = Math.max(0, Math.floor((this.regions.length - 1) / this.paginatorRows) * this.paginatorRows);\n    if (this.paginatorFirst > maxFirst) {\n      this.paginatorFirst = maxFirst;\n    }\n  }\n  protected changeShowShapeLabel(showLabel: boolean) {\n    this.commit();\n  }\n\n  protected isEditingLabel(region: Region): boolean {\n    return this.editingLabelRegions.has(region);\n  }\n\n  protected startEditLabel(region: Region, event?: Event): void {\n    event?.stopPropagation(); // don't toggle row selection\n    // A new map per start/stop, so the OnPush table sees the change.\n    this.editingLabelRegions = new Map(this.editingLabelRegions).set(region, region.label ?? '');\n  }\n\n  /** The label typed so far for a row in edit mode (no re-render needed). */\n  protected setLabelDraft(region: Region, value: string): void {\n    if (this.editingLabelRegions.has(region)) this.editingLabelRegions.set(region, value);\n  }\n\n  protected stopEditLabel(region: Region, commit: boolean, event?: Event): void {\n    event?.stopPropagation();\n    const draft = this.editingLabelRegions.get(region);\n    if (this.editingLabelRegions.has(region)) {\n      const next = new Map(this.editingLabelRegions);\n      next.delete(region);\n      this.editingLabelRegions = next;\n    }\n    if (commit) {\n      // A changed label commits as a replacement region, so it is undoable (RT-1).\n      const edited =\n        draft !== undefined && draft !== region.label\n          ? (this.patchRegions((r) => (r === region ? { label: draft } : null)).get(region) ?? region)\n          : region;\n      this.labelRegionUpdate(edited, true);\n    }\n  }\n\n  /** Region area for display (µm²/mm² when the image is scaled, else px²);\n   *  empty for a degenerate region. See `region-metrics`. */\n  protected regionArea(region: Region): string {\n    return formatArea(regionAreaPx(region), this.mpp);\n  }\n\n  /**\n   * This method rounds all the rectangle regions lengths to multiple of 512\n   */\n  protected roundRectangleLengths() {\n    this.patchRegions((region) => {\n      const rect = region.bounds;\n      if (!(rect instanceof Rectangle)) return null;\n      return {\n        bounds: Object.assign(new Rectangle(), rect, {\n          height: Math.round(rect.height / 512) * 512,\n          width: Math.round(rect.width / 512) * 512,\n        }),\n      };\n    });\n    this.commit();\n  }\n\n  protected showHelp() {\n    this.displayHelpDialog = true;\n  }\n\n  /** Open the colour dialog for the currently-selected region(s), building one\n   *  colour picker per unique class in the selection. Each picker is seeded with\n   *  the first selected region of that class's colour (else the class colour). */\n  protected openColorDialog() {\n    if (!this.selectedRegions?.length) return;\n    const seedByLabel = new Map<string, string>();\n    for (const region of this.selectedRegions) {\n      const label = region.label?.trim() ?? '';\n      if (seedByLabel.has(label)) continue;\n      seedByLabel.set(label, region.color ?? (label ? this.colorForName(label) : this.shapeColor));\n    }\n    this.classColorEdits = [...seedByLabel].map(([label, color]) => ({ label, color }));\n    this.showColorDialog = true;\n  }\n\n  /** Apply each class's chosen colour to the selected regions of that class (an\n   *  explicit override) and commit live. */\n  protected applyColorToSelected(edits: ClassColorEdit[] = this.classColorEdits) {\n    const colorByLabel = new Map(edits.map((e) => [e.label, e.color]));\n    const selected = new Set(this.selectedRegions ?? []);\n    this.patchRegions((region) => {\n      if (!selected.has(region)) return null;\n      const label = region.label?.trim() ?? '';\n      const color = colorByLabel.get(label);\n      if (!color) return null;\n      // explicit colour — preserve against preset (re)apply (jit-ui#70)\n      return { color, colorOverridden: true };\n    });\n    this.commit();\n    this.showColorDialog = false;\n  }\n\n  // ── annotation-class presets (jit-ui#70) ─────────────────────────────\n\n  /** Resolve the display colour for a class name (preset colour or deterministic fallback). */\n  protected colorForName(name?: string): string {\n    return name ? colorForLabel(name, this.presetSet) : this.shapeColor;\n  }\n\n  /**\n   * Ensure every class label present in the loaded regions exists in the preset\n   * list, auto-adding any that are missing (using the region's already-resolved\n   * colour). This makes classes carried in a loaded/imported GeoJSON show up as\n   * chips + Class-dropdown options (a p-dropdown can't display a value that isn't\n   * an option) and lets the user manage them. The placeholder 'legend' and empty\n   * labels are ignored. (jit-ui#70)\n   */\n  private syncClassesFromRegions(regions: Region[]): void {\n    const keyOf = (l: string) => presetKey(this.presetSet, l);\n    const known = new Set(this.presetSet.classes.map((c) => keyOf(c.name)));\n    const added = new Set<string>();\n    for (const r of regions) {\n      const label = r.label?.trim();\n      if (!label || label === 'legend') continue;\n      const k = keyOf(label);\n      if (known.has(k) || added.has(k)) continue;\n      added.add(k);\n      this.regionApi.upsertClass({\n        name: label,\n        color: r.color || colorForLabel(label, this.presetSet),\n        source: 'auto',\n      });\n    }\n  }\n\n  // ── Docked Classes panel (jit-ui#70) ─────────────────────────────────\n\n  /** Rebuild the per-class region counts shown in the panel. */\n  private recomputeClassCounts(): void {\n    const counts = new Map<string, number>();\n    for (const r of this.regions) {\n      if (!r.label) continue;\n      const k = presetKey(this.presetSet, r.label);\n      counts.set(k, (counts.get(k) ?? 0) + 1);\n    }\n    this.classCounts = counts;\n    this.updateDisplayClasses();\n  }\n\n  /** Rebuild the panel's display order — most-used classes first, then by name. */\n  private updateDisplayClasses(): void {\n    this.displayClasses = [...this.presetSet.classes].sort((a, b) => {\n      const d = this.classCount(b.name) - this.classCount(a.name);\n      return d !== 0 ? d : a.name.localeCompare(b.name);\n    });\n  }\n\n  /** Number of regions currently using a class (keyed by the active match mode). */\n  protected classCount(name: string): number {\n    return this.classCounts.get(presetKey(this.presetSet, name)) ?? 0;\n  }\n\n  /** Recolour a class from its panel swatch and repaint its (non-overridden) regions. */\n  protected setClassColor(name: string, color: string): void {\n    if (!color) return;\n    this.regionApi.setClassificationColor(name, color);\n    this.commit();\n  }\n\n  /** Remove a class. Any regions still using it fall back to the default\n   *  \"Region\" class, so they aren't orphaned (and the class isn't immediately\n   *  re-added from its regions by syncClassesFromRegions). */\n  protected deleteClass(name: string): void {\n    this.reassignRegionsToDefaultClass([name]);\n    this.regionApi.removeClass(name);\n    if (this.activeClass === name) this.activeClass = null;\n    this.commit();\n  }\n\n  /** Regions labelled with any of `removedNames` revert to the default\n   *  {@link defaultClassName} (\"Region\"): its class colour, override cleared.\n   *  Skips the default itself so deleting \"Region\" can't self-reassign. (jit-ui#70) */\n  private reassignRegionsToDefaultClass(removedNames: string[]): void {\n    const keyOf = (s: string) => presetKey(this.presetSet, s);\n    const removed = new Set(removedNames.map(keyOf));\n    removed.delete(keyOf(this.defaultClassName));\n    if (!removed.size) return;\n    const color = colorForLabel(this.defaultClassName, this.presetSet);\n    this.patchRegions((r) =>\n      r.label && removed.has(keyOf(r.label))\n        ? { label: this.defaultClassName, colorOverridden: false, color }\n        : null,\n    );\n  }\n\n  /** Stamp a class (and its preset/fallback colour) onto one region from the Class\n   *  dropdown; choosing a class opts the region back into the preset colour. */\n  protected applyPresetToRegion(region: Region, className: string): void {\n    const name = (className ?? '').trim();\n    const patch: Partial<Region> = { label: name, colorOverridden: false };\n    if (name) patch.color = colorForLabel(name, this.presetSet);\n    this.patchRegions((r) => (r === region ? patch : null));\n    this.commit();\n  }\n\n  /** Make a class active (used for new regions) and, if rows are selected, apply\n   *  it to them in one commit. */\n  protected selectActiveClass(name: string): void {\n    this.activeClass = name;\n    this.applyClassToSelected(name);\n  }\n\n  /** Apply a class (label + preset/fallback colour) to the current selection and commit. */\n  private applyClassToSelected(name: string): void {\n    const selected = new Set(this.selectedRegions ?? []);\n    if (!selected.size) return;\n    const color = colorForLabel(name, this.presetSet);\n    this.patchRegions((r) => (selected.has(r) ? { label: name, colorOverridden: false, color } : null));\n    this.commit();\n  }\n\n  /** \"Edit class on selected rows\" popup — apply the chosen existing class. */\n  protected applyBulkClass(): void {\n    if (!this.bulkClass) return;\n    this.applyClassToSelected(this.bulkClass);\n    this.overlayPanel?.hide();\n  }\n\n  /** \"Edit class on selected rows\" popup — add a new class and set it on the selection. */\n  protected addAndApplyBulkClass(): void {\n    const name = this.newBulkClass.trim();\n    if (!name) return;\n    const key = presetKey(this.presetSet, name);\n    const exists = this.presetSet.classes.some((c) => presetKey(this.presetSet, c.name) === key);\n    if (!exists) {\n      this.regionApi.upsertClass({ name, color: colorForLabel(name, this.presetSet), source: 'user' });\n    }\n    this.applyClassToSelected(name);\n    this.bulkClass = name;\n    this.newBulkClass = '';\n    this.overlayPanel?.hide();\n  }\n\n  // ── Manage-classes dialog ──\n  protected openManageDialog(): void {\n    this.presetDraft = this.clonePresetSet(this.presetSet);\n    this.showManageDialog = true;\n  }\n  private clonePresetSet(s: PresetSet): PresetSet {\n    return {\n      classes: (s.classes ?? []).map((c) => ({ ...c })),\n      fallbackPalette: [...(s.fallbackPalette ?? [])],\n      autoPromote: !!s.autoPromote,\n      matchMode: s.matchMode === 'normalized' ? 'normalized' : 'exact',\n    };\n  }\n  /** Commit the draft: drop blank/duplicate names, persist, and recolour\n   *  non-overridden regions with the updated presets. */\n  protected applyManageDialog(close: boolean): void {\n    if (!this.presetDraft) return;\n    // De-duplicate using the active match mode's key so normalized mode can't keep\n    // both \"Tumor\" and \"tumor\" (which would collide at runtime in findPreset()).\n    const draft = this.presetDraft;\n    const keyOf = (s: string) => presetKey(draft, s);\n    const seen = new Set<string>();\n    const classes: ClassPreset[] = [];\n    for (const c of draft.classes) {\n      const name = (c.name ?? '').trim();\n      const key = keyOf(name);\n      if (!name || seen.has(key)) continue;\n      seen.add(key);\n      classes.push({ ...c, name });\n    }\n    this.presetDraft = { ...draft, classes };\n    // Classes dropped in the dialog: their regions revert to the default \"Region\"\n    // class (else syncClassesFromRegions would just re-add them) (jit-ui#70).\n    const kept = new Set(classes.map((c) => keyOf(c.name)));\n    const removed = this.presetSet.classes.map((c) => c.name).filter((n) => !kept.has(keyOf(n)));\n    this.reassignRegionsToDefaultClass(removed);\n    this.regionApi.setPresetSet(this.presetDraft);\n    this.commit(); // recolour existing (non-overridden) regions from the new presets\n    if (close) this.showManageDialog = false;\n  }\n  protected resetPresetsToDefaults(): void {\n    this.regionApi.resetPresets();\n    this.presetDraft = this.clonePresetSet(this.regionApi.getPresetSet());\n    this.commit();\n  }\n  protected exportPresets(): void {\n    const json = JSON.stringify(this.regionApi.getPresetSet(), null, 2);\n    saveAs(new Blob([json], { type: 'application/json' }), 'annotation-classes.json');\n  }\n  protected importPresets(event: Event): void {\n    this.persistence.readChosenFile(event, (text) => this.applyImportedPresets(text));\n  }\n\n  /** Validate and apply an imported annotation-classes JSON file. */\n  private applyImportedPresets(text: string): void {\n    try {\n      const set = parsePresetSet(JSON.parse(text));\n      if (!set) throw new Error('The file is not an annotation-class list (no valid classes).');\n      this.regionApi.setPresetSet(set);\n      this.presetDraft = this.clonePresetSet(this.regionApi.getPresetSet());\n      this.commit();\n      this.messageService.add({\n        key: VIZ_TOAST_KEY,\n        severity: 'success',\n        summary: 'Classes imported',\n        detail: 'Annotation classes loaded.',\n      });\n    } catch (err) {\n      this.messageService.add({\n        key: VIZ_TOAST_KEY,\n        severity: 'error',\n        summary: 'Import failed',\n        detail: `${(err as Error)?.message ?? err}`,\n      });\n    }\n    this.changed();\n  }\n\n  protected importRois(event: Event) {\n    this.persistence.readChosenFile(event, (text) => this.applyImportedRois(text));\n  }\n\n  /** Replace the regions with an imported GeoJSON file's. */\n  private applyImportedRois(text: string): void {\n    try {\n      this.regions = this.regionApi.importRegions(text);\n      this.fillClassColors();\n      this.commit();\n    } catch (err) {\n      this.messageService.add({\n        key: VIZ_TOAST_KEY,\n        severity: 'error',\n        summary: 'Error importing the file',\n        detail: `${(err as Error)?.message ?? err}`,\n      });\n      console.error('Error reading the file:', err);\n    }\n  }\n\n  /** Regions to serialize on save/export (every slice for a combined z-stack). */\n  private regionsForSave(): Region[] {\n    return this.persistence.regionsForSave(this.regions);\n  }\n\n  protected exportRois() {\n    if (!this.regionsForSave().length) return;\n    this.exportFilename = this.persistence.defaultExportName();\n    this.showExportDialog = true;\n  }\n\n  protected confirmExport() {\n    const filename = this.exportFilename.trim();\n    const regions = this.regionsForSave();\n    if (!filename || !regions.length) return;\n    this.showExportDialog = false;\n    this.persistence.download(regions, filename);\n  }\n\n  /** Open the \"Save mask\" dialog, seeded with `<image-stem>_mask.png`. */\n  protected openSaveMaskDialog() {\n    if (!this.regions.length) return;\n    this.saveMaskFilename = this.persistence.defaultMaskName();\n    this.maskMode = 'binary';\n    this.showSaveMaskDialog = true;\n  }\n\n  /**\n   * Rasterize the regions to the chosen mask type and download as a PNG. The\n   * heavy work runs in a Web Worker ({@link MaskExportService}) so the UI never\n   * freezes on whole-slide images and the job can be cancelled (jit-ui#95);\n   * the dialog stays open with a progress bar until done.\n   */\n  protected confirmSaveMask() {\n    const filename = this.saveMaskFilename.trim();\n    if (!filename || !this.regions.length || this.maskBusy) return;\n\n    const size = this.regionApi.getMaskImageSize();\n    if (!size) {\n      this.maskError('No image size is available, so the mask cannot be sized.');\n      return;\n    }\n    this.maskBusy = true;\n    this.maskEncoding = false;\n    this.maskProgress = 0;\n    this.maskJob = this.maskExport\n      .export({\n        regions: this.regions,\n        imageSize: size,\n        mode: this.maskMode,\n        sourceName: this.persistence.selectedFileName(),\n      })\n      .subscribe({\n        next: (e) => {\n          this.changed();\n          switch (e.type) {\n            case 'planned':\n              if (e.scale < 1) {\n                this.messageService.add({\n                  key: VIZ_TOAST_KEY,\n                  severity: 'info',\n                  summary: 'Mask downscaled',\n                  detail: `Image too large for a full-resolution mask; saving at ${e.width}×${e.height}.`,\n                });\n              }\n              break;\n            case 'progress':\n              this.maskProgress = e.percent;\n              break;\n            case 'encoding':\n              this.maskEncoding = true;\n              break;\n            case 'done':\n              this.finishMask(e.blob, filename);\n              break;\n          }\n        },\n        error: (err: Error) => {\n          this.maskError(err.message);\n          this.changed();\n        },\n      });\n  }\n\n  /** Cancel an in-progress mask export (terminates its worker) and reset state. */\n  protected cancelSaveMask() {\n    this.maskJob?.unsubscribe();\n    this.maskJob = undefined;\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.maskProgress = 0;\n  }\n\n  private finishMask(blob: Blob, filename: string) {\n    this.maskJob = undefined;\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.showSaveMaskDialog = false;\n    saveAs(blob, filename);\n  }\n\n  private maskError(detail: string) {\n    this.maskJob = undefined;\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.messageService.add({\n      key: VIZ_TOAST_KEY,\n      severity: 'error',\n      summary: 'Could not create mask',\n      detail,\n    });\n  }\n\n  protected persistRegions() {\n    // Folder stack: write each slice's regions back to its own slice-file's\n    // sibling geojson — no single-filename prompt (jit-ui#93).\n    if (this.persistence.savesPerSlice()) {\n      this.saveStackSlices();\n      return;\n    }\n    const filename = this.persistence.defaultSaveName();\n    if (!filename || !this.regionsForSave().length) return;\n\n    this.saveAsFilename = filename;\n    this.saveAsFileExists = false;\n    this.showSaveAsDialog = true;\n    this.saveAsCheck$.next(this.saveAsFilename);\n  }\n\n  /** Save a folder stack's regions as one geojson per slice-file (jit-ui#93).\n   *  No dialog covers the toolbar meanwhile, so a Save while one is uploading\n   *  is ignored rather than starting a second write (and orphaning the first). */\n  private saveStackSlices() {\n    if (this.saveAsBusy) return;\n    const slices = this.persistence.sliceGeoJsons();\n    if (!slices.length) return;\n    this.saveAsBusy = true;\n    this._saveAsSub = this.persistence.saveSlices(slices).subscribe({\n      next: () => {\n        this.saveAsBusy = false;\n        this.changed();\n        this.toast(\n          'success',\n          'Regions saved',\n          `Saved ROIs for ${slices.length} slice${slices.length === 1 ? '' : 's'}`,\n        );\n      },\n      error: (err) => {\n        this.saveAsBusy = false;\n        this.changed();\n        this.toast('error', 'Error saving regions', `${(err as Error)?.message ?? err}`);\n      },\n    });\n  }\n\n  protected checkSaveAsFileExists() {\n    this.saveAsCheck$.next(this.saveAsFilename);\n  }\n\n  protected confirmSaveAs() {\n    if (!this.persistence.selectedFileName()) return;\n\n    const filename = this.saveAsFilename.trim();\n    if (!filename) return;\n\n    // Keep the dialog open showing an (indeterminate) progress bar while the\n    // regions serialize and upload, then close on success.\n    const doSave = () => {\n      this.saveAsBusy = true;\n      // Also run from the overwrite confirmation, which the host's dialog may answer.\n      this.changed();\n      this._saveAsSub = this.persistence\n        .save(() => this.regionsForSave(), filename)\n        .subscribe({\n          next: () => {\n            this.saveAsBusy = false;\n            this.showSaveAsDialog = false;\n            this.changed();\n            this.toast('success', 'Regions saved', `Saved as ${filename}`);\n          },\n          error: (err) => {\n            this.saveAsBusy = false;\n            this.changed();\n            this.toast('error', 'Error saving regions', `${(err as Error)?.message || err}`);\n          },\n        });\n    };\n\n    if (this.saveAsFileExists) {\n      this.confirmationService.confirm({\n        message: `\"${filename}\" already exists. Do you want to overwrite it?`,\n        header: 'Confirm Overwrite',\n        icon: 'pi pi-exclamation-triangle',\n        accept: doSave,\n      });\n    } else {\n      doSave();\n    }\n  }\n\n  /** Cancel an in-progress GeoJSON persist: abort the deferred serialize and/or\n   *  the in-flight upload, and reset state. */\n  protected cancelSaveAs() {\n    this._saveAsSub?.unsubscribe();\n    this._saveAsSub = undefined;\n    this.saveAsBusy = false;\n  }\n\n  private toast(severity: 'success' | 'error' | 'info', summary: string, detail: string): void {\n    this.messageService.add({ key: VIZ_TOAST_KEY, severity, summary, detail });\n  }\n}\n","<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button\n      icon=\"pi pi-tag\"\n      size=\"small\"\n      [text]=\"!showShapeLabel\"\n      pTooltip=\"Show region labels.\"\n      tooltipPosition=\"bottom\"\n      (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\"\n    >\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button\n      icon=\"pi pi-upload\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Upload and display regions from geojson file.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roiFileInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFileInput\n      type=\"file\"\n      accept=\".geojson,.json\"\n      hidden\n      (change)=\"importRois($event); roiFileInput.value = ''\"\n    />\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download regions as geojson file.\"\n      tooltipPosition=\"bottom\"\n      icon=\"pi pi-download\"\n      (click)=\"exportRois()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-save\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Save regions to server.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"persistRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download mask of the regions as PNG\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openSaveMaskDialog()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img\n        src=\"assets/plotting/mask.svg\"\n        class=\"toolbar-icon-dark\"\n        style=\"width: 1rem; height: 1rem; vertical-align: middle\"\n        alt=\"Download mask\"\n      />\n    </p-button>\n    <p-button\n      label=\"x512\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roundRectangleLengths()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-check-square\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Select all regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"selectAllRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-tags\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit class on selected rows\"\n      tooltipPosition=\"bottom\"\n      (click)=\"!selectedRegions || !selectedRegions.length ? op.hide() : op.toggle($event)\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-palette\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit colour of selected regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openColorDialog()\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass = ''; newBulkClass = ''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\"\n          >Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span\n        >\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown\n          styleClass=\"w-full\"\n          appendTo=\"body\"\n          [options]=\"presetSet.classes\"\n          optionLabel=\"name\"\n          optionValue=\"name\"\n          [(ngModel)]=\"bulkClass\"\n          placeholder=\"Choose a class…\"\n          [filter]=\"presetSet.classes.length > 8\"\n          filterBy=\"name\"\n          (onChange)=\"applyBulkClass()\"\n        >\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"\n              ><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span\n            >\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input\n            type=\"text\"\n            pInputText\n            placeholder=\"…or a new class\"\n            [(ngModel)]=\"newBulkClass\"\n            (keydown.enter)=\"addAndApplyBulkClass()\"\n          />\n          <button\n            pButton\n            type=\"button\"\n            icon=\"pi pi-plus\"\n            pTooltip=\"Add class &amp; set it\"\n            tooltipPosition=\"bottom\"\n            [disabled]=\"!newBulkClass.trim()\"\n            (click)=\"addAndApplyBulkClass()\"\n          ></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button\n      icon=\"pi pi-trash\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"deleteSelectedRegions()\"\n      pTooltip=\"Delete selected regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-times-circle\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"clearAllRegions()\"\n      pTooltip=\"Delete all regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!regions || !regions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-question\"\n      size=\"small\"\n      [text]=\"true\"\n      (click)=\"showHelp()\"\n      pTooltip=\"Help\"\n      tooltipPosition=\"bottom\"\n    ></p-button>\n  </div>\n</p-toolbar>\n\n<region-classes-panel\n  [classes]=\"displayClasses\"\n  [counts]=\"classCounts\"\n  [matchMode]=\"presetSet.matchMode\"\n  [activeClass]=\"activeClass\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  [defaultClassName]=\"defaultClassName\"\n  (pick)=\"selectActiveClass($event)\"\n  (recolor)=\"setClassColor($event.name, $event.color)\"\n  (remove)=\"deleteClass($event)\"\n  (manage)=\"openManageDialog()\"\n>\n</region-classes-panel>\n\n<region-table\n  [page]=\"pagedRegions\"\n  [total]=\"regions.length\"\n  [first]=\"paginatorFirst\"\n  [rows]=\"paginatorRows\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [metaKey]=\"metaKey\"\n  [selection]=\"selectedRegions\"\n  (selectionChange)=\"selectedRegions = $event\"\n  (rowSelect)=\"onSelectionChanged()\"\n  [presetSet]=\"presetSet\"\n  [defaultColor]=\"shapeColor\"\n  [mpp]=\"mpp\"\n  [labelDrafts]=\"editingLabelRegions\"\n  (labelEditStart)=\"startEditLabel($event)\"\n  (labelDraftChange)=\"setLabelDraft($event.region, $event.value)\"\n  (labelEditStop)=\"stopEditLabel($event.region, $event.commit)\"\n  (classPick)=\"applyPresetToRegion($event.region, $event.name)\"\n  (deleteRow)=\"deleteRegion($event)\"\n  (pageChange)=\"onPageChange($event)\"\n>\n</region-table>\n\n<!-- Live-edit mode: no Save/Cancel — every edit commits immediately to the\n     active image's region cache. -->\n\n<p-confirmDialog\n  #cd\n  [style]=\"{ width: '24rem', height: '14rem' }\"\n  key=\"positionDialog\"\n  [baseZIndex]=\"10000\"\n  rejectButtonStyleClass=\"p-button-outlined\"\n>\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button\n      type=\"button\"\n      class=\"p-button-outlined\"\n      pButton\n      icon=\"pi pi-times\"\n      label=\"No\"\n      (click)=\"cd.reject()\"\n    ></button>\n  </ng-template>\n</p-confirmDialog>\n\n<region-save-regions-dialog\n  [(visible)]=\"showSaveAsDialog\"\n  [filename]=\"saveAsFilename\"\n  (filenameChange)=\"saveAsFilename = $event; checkSaveAsFileExists()\"\n  [fileExists]=\"saveAsFileExists\"\n  [busy]=\"saveAsBusy\"\n  (confirm)=\"confirmSaveAs()\"\n  (cancelSave)=\"cancelSaveAs()\"\n>\n</region-save-regions-dialog>\n\n<region-save-regions-dialog\n  header=\"Export Regions\"\n  confirmLabel=\"Export\"\n  confirmIcon=\"pi pi-download\"\n  inputId=\"export-filename\"\n  [(visible)]=\"showExportDialog\"\n  [(filename)]=\"exportFilename\"\n  (confirm)=\"confirmExport()\"\n>\n</region-save-regions-dialog>\n\n<region-save-mask-dialog\n  [(visible)]=\"showSaveMaskDialog\"\n  [(filename)]=\"saveMaskFilename\"\n  [(mode)]=\"maskMode\"\n  [busy]=\"maskBusy\"\n  [progress]=\"maskProgress\"\n  [encoding]=\"maskEncoding\"\n  (confirm)=\"confirmSaveMask()\"\n  (cancelExport)=\"cancelSaveMask()\"\n>\n</region-save-mask-dialog>\n\n<region-color-dialog\n  [(visible)]=\"showColorDialog\"\n  [edits]=\"classColorEdits\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  (apply)=\"applyColorToSelected($event)\"\n>\n</region-color-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): edits a working copy, committed on Apply. -->\n<region-manage-classes-dialog\n  [(visible)]=\"showManageDialog\"\n  [(draft)]=\"presetDraft\"\n  (apply)=\"applyManageDialog(true)\"\n  (resetDefaults)=\"resetPresetsToDefaults()\"\n  (importFile)=\"importPresets($event)\"\n  (export)=\"exportPresets()\"\n>\n</region-manage-classes-dialog>\n\n<region-editor-help [(visible)]=\"displayHelpDialog\"></region-editor-help>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-editor.component.js","sourceRoot":"","sources":["../../../../src/lib/region-editor/region-editor.component.ts","../../../../src/lib/region-editor/region-editor.component.html"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,UAAU,EACV,MAAM,EACN,KAAK,EAGL,SAAS,EACT,MAAM,EACN,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACpC,OAAO,EAAE,OAAO,EAAgB,MAAM,MAAM,CAAC;AAE7C,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAA0B,gBAAgB,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,EAAoB,iBAAiB,EAAE,MAAM,yCAAyC,CAAC;AAC9F,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACjF,OAAO,EAEL,kBAAkB,EAClB,UAAU,EACV,gBAAgB,GACjB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,wBAAwB,EAAgB,MAAM,8BAA8B,CAAC;AACtF,OAAO,EAAkB,0BAA0B,EAAE,MAAM,qDAAqD,CAAC;AACjH,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAiB,MAAM,mCAAmC,CAAC;AAGtF,OAAO,EAAE,0BAA0B,EAAE,MAAM,qDAAqD,CAAC;AACjG,OAAO,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AACxF,OAAO,EAAE,4BAA4B,EAAE,MAAM,yDAAyD,CAAC;AACvG,OAAO,EAAE,yBAAyB,EAAE,MAAM,mDAAmD,CAAC;AAC9F,OAAO,EAAE,iBAAiB,EAAY,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAa,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;;;;;;;;;;;;;;AAEhF;;;;;;;;;;GAUG;AACH,oDAAoD;AACpD,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEhC,oFAAoF;AACpF,MAAM,uBAAuB,GAAG,IAAI,CAAC;AA8BrC,MAAM,OAAO,qBAAqB;IAGhC;;;;;OAKG;IACH,IAAa,MAAM,CAAC,KAAc;QAChC,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC1B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;YAClB,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;YAC1B,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;IACH,CAAC;IAwID,6FAA6F;IACrF,OAAO;QACb,kBAAkB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAMD,YACqC,SAA2B,EACtD,cAA8B,EAC9B,mBAAwC,EACxC,WAAqC,EACrC,UAA6B;QAJF,cAAS,GAAT,SAAS,CAAkB;QACtD,mBAAc,GAAd,cAAc,CAAgB;QAC9B,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,gBAAW,GAAX,WAAW,CAA0B;QACrC,eAAU,GAAV,UAAU,CAAmB;QArJ/B,aAAQ,GAAG,IAAI,CAAC;QACxB,sFAAsF;QACrE,SAAI,GAAG,MAAM,CAAC,UAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QAErD,YAAO,GAAa,EAAE,CAAC;QACvB,oBAAe,GAAa,EAAE,CAAC;QAI/B,sBAAiB,GAAG,KAAK,CAAC;QAC1B,oBAAe,GAAG,KAAK,CAAC;QAClC;;sEAE8D;QACpD,oBAAe,GAAqB,EAAE,CAAC;QACjD,wFAAwF;QAC9E,cAAS,GAAG,EAAE,CAAC;QACf,iBAAY,GAAG,EAAE,CAAC;QAE5B,6CAA6C;QAC7C,oFAAoF;QAC1E,cAAS,GAAc,gBAAgB,EAAE,CAAC;QACpD,wFAAwF;QAC9E,gBAAW,GAAkB,IAAI,CAAC;QAClC,qBAAgB,GAAG,KAAK,CAAC;QACnC,qFAAqF;QAC3E,gBAAW,GAAqB,IAAI,CAAC;QAC/C,4EAA4E;QAClE,gBAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;QAClD,qFAAqF;QAClE,qBAAgB,GAAG,QAAQ,CAAC;QAC/C,+EAA+E;QACrE,mBAAc,GAAkB,EAAE,CAAC;QAEnC,mBAAc,GAAG,CAAC,CAAC;QACnB,kBAAa,GAAG,EAAE,CAAC;QACV,uBAAkB,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACrD;;;gDAGwC;QAC9B,wBAAmB,GAAG,IAAI,GAAG,EAAkB,CAAC;QAEhD,qBAAgB,GAAG,KAAK,CAAC;QACnC;;;;WAIG;QACO,eAAU,GAA4B,IAAI,CAAC;QACrD,yEAAyE;QACjE,gBAAW,GAAG,CAAC,CAAC;QACxB,iEAAiE;QACzD,eAAU,GAAa,EAAE,CAAC;QAClC,8CAA8C;QACtC,sBAAiB,GAA2B,EAAE,CAAC;QACvD,qEAAqE;QACpD,aAAQ,GAAG,IAAI,OAAO,EAAU,CAAC;QAC1C,eAAU,GAAG,CAAC,CAAC;QACvB,8DAA8D;QACtD,kBAAa,GAAG,CAAC,CAAC;QAC1B;6EACqE;QAC3D,mBAAc,GAAc,gBAAgB,EAAE,CAAC;QACzD,8EAA8E;QACpE,kBAAa,GAAG,KAAK,CAAC;QAChC,4EAA4E;QAClE,eAAU,GAAG,KAAK,CAAC;QAC7B,4FAA4F;QACpF,cAAS,GAAG,KAAK,CAAC;QAC1B,8FAA8F;QACpF,yBAAoB,GAAG,KAAK,CAAC;QACvC,wFAAwF;QAC9E,YAAO,GAAG,IAAI,GAAG,EAAoB,CAAC;QAChD,4FAA4F;QACpF,kBAAa,GAAsB,EAAE,CAAC;QAC9C,6DAA6D;QACnD,kBAAa,GAAwB,IAAI,GAAG,EAAE,CAAC;QACzD,wEAAwE;QAChE,kBAAa,GAAG,EAAE,CAAC;QAC3B,uDAAuD;QAC/C,aAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;QAC7C,oFAAoF;QAC1E,iBAAY,GAAwB,IAAI,GAAG,EAAE,CAAC;QACxD,kFAAkF;QACxE,kBAAa,GAAwB,IAAI,GAAG,EAAE,CAAC;QACzD,8FAA8F;QACpF,kBAAa,GAAG,IAAI,CAAC;QAC/B,+CAA+C;QACrC,gBAAW,GAAkB,IAAI,CAAC;QAC5C,6EAA6E;QACnE,eAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;QACjD,oGAAoG;QAC1F,cAAS,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1E,mBAAc,GAAG,EAAE,CAAC;QACpB,qBAAgB,GAAG,KAAK,CAAC;QACnC;iFACyE;QAC/D,eAAU,GAAG,KAAK,CAAC;QAG7B,oEAAoE;QACnD,iBAAY,GAAG,IAAI,OAAO,EAAU,CAAC;QAE5C,qBAAgB,GAAG,KAAK,CAAC;QACzB,mBAAc,GAAG,EAAE,CAAC;QAEpB,uBAAkB,GAAG,KAAK,CAAC;QAC3B,qBAAgB,GAAG,EAAE,CAAC;QAChC;yEACiE;QACvD,aAAQ,GAAa,QAAQ,CAAC;QACxC;uDAC+C;QACrC,aAAQ,GAAG,KAAK,CAAC;QAC3B,+EAA+E;QACrE,iBAAY,GAAG,CAAC,CAAC;QACjB,iBAAY,GAAG,KAAK,CAAC;QAI/B;;;;;WAKG;QACO,YAAO,GAAG,IAAI,CAAC;QAEjB,wBAAmB,GAAG,KAAK,CAAC;QAC5B,iCAA4B,GAAG,KAAK,CAAC;QAC5B,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAChC,QAAG,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAChC,SAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAOvC;mEAC2D;QACjD,QAAG,GAAc,EAAE,CAAC;QAgf9B,+FAA+F;QACrF,iBAAY,GAA8C,IAAI,CAAC;QACzE,8EAA8E;QACtE,kBAAa,GAAG,CAAC,CAAC;QA8ClB,aAAQ,GAA6E,EAAE,CAAC;QACxF,UAAK,GAAa,EAAE,CAAC;QAub7B,8CAA8C;QACpC,cAAS,GAAG,KAAK,CAAC;IAl9BzB,CAAC;IAEJ,QAAQ;QACN,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,CAAC;QACzD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC;QACjD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QAE/C,2EAA2E;QAC3E,2EAA2E;QAC3E,0EAA0E;QAC1E,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,EAAE,CAAC;QACvD,IAAI,cAAc;YAAE,IAAI,CAAC,SAAS,GAAG,cAAc,CAAC;QACpD,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,EAAE,CAAC;QAClD,IAAI,QAAQ,EAAE,CAAC;YACb,QAAQ,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;gBACnE,IAAI,GAAG;oBAAE,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC;gBAC9B,IAAI,CAAC,SAAS,GAAG,CAAC,IAAY,EAAU,EAAE,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;gBAC/E,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAC5B,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,CAAC,CAAC,CAAC;QACL,CAAC;QACD,qEAAqE;QACrE,yEAAyE;QACzE,8CAA8C;QAC9C,qEAAqE;QACrE,8EAA8E;QAC9E,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC,CAAC;QAC7E,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC1C,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAE5B,yEAAyE;QACzE,8DAA8D;QAC9D,IAAI,CAAC,SAAS;aACX,oBAAoB,EAAE;aACtB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACzC,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,IAAI,CAAC,mBAAmB;gBAAE,OAAO;YACrC,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC,CAAC;YAC9E,qEAAqE;YACrE,oDAAoD;YACpD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACnE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;YACvB,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACpE,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC,CAAC;YACrC,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,UAAU;gBAAE,IAAI,CAAC,YAAY,EAAE,CAAC;YACzC,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,SAAS;aACX,oBAAoB,EAAE,EAAE;YACzB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;YAClB,IAAI,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC,UAAU,EAAE,MAAM;gBAAE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YACtE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,SAAS;aACX,eAAe,EAAE,EAAE;YACpB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC;YAC3C,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,SAAS;aACX,cAAc,EAAE,EAAE;YACnB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC;YAClC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;YACzB,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,IAAI,CAAC,WAAW,KAAK,QAAQ;gBAAE,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;QAC/D,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,SAAS;aACX,wBAAwB,EAAE,EAAE;YAC7B,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;YACrB,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC;YACpC,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,SAAS;aACX,eAAe,EAAE,EAAE;YACpB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;YAClB,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC;YAClC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,IAAI,IAAI,CAAC,WAAW,KAAK,QAAQ;gBAAE,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;QAC/D,CAAC,CAAC,CAAC;QAEL,2EAA2E;QAC3E,IAAI,CAAC,SAAS;aACX,mBAAmB,EAAE,EAAE;YACxB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YACpB,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YACnE,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;YACjD,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;YACxB,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,SAAS;aACX,iBAAiB,EAAE,EAAE;YACtB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YACpB,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC;YAC5B,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;QAEL,kFAAkF;QAClF,IAAI,CAAC,SAAS;aACX,kBAAkB,EAAE,EAAE;YACvB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aAC1C,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;QAEpE,IAAI,CAAC,WAAW;aACb,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC;aAC7B,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACzC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YACpB,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC;YAC/B,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;QAEL,yEAAyE;QACzE,IAAI,CAAC,SAAS;aACX,YAAY,EAAE;aACd,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACzC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;YAClB,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,SAAS;aACX,mBAAmB,EAAE;aACrB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACzC,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE;YACtB,IAAI,IAAI,CAAC,4BAA4B;gBAAE,OAAO;YAC9C,2EAA2E;YAC3E,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1G,MAAM,IAAI,GACR,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,eAAe,CAAC,MAAM;gBAC3C,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YAC7D,IAAI,CAAC,IAAI;gBAAE,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;YACvC,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAChC,qEAAqE;YACrE,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACpB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACjF,IAAI,OAAO,IAAI,CAAC,EAAE,CAAC;oBACjB,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC;oBAChF,IAAI,SAAS,KAAK,IAAI,CAAC,cAAc;wBAAE,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;gBACzE,CAAC;YACH,CAAC;YACD,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,CAAC,CAAC;IACP,CAAC;IAED;+EAC2E;IAC3E,WAAW;QACT,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;QAC/B,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;OAKG;IACO,kBAAkB;QAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC;QAC5C,0DAA0D;QAC1D,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;QACxB,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,4BAA4B,GAAG,IAAI,CAAC;QACzC,IAAI,CAAC;YACH,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACnF,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,4BAA4B,GAAG,KAAK,CAAC;QAC5C,CAAC;QACD,sFAAsF;QACtF,IAAI,UAAU,CAAC,MAAM;YAAE,KAAK,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC,CAAC;IACtG,CAAC;IAED,wEAAwE;IAExE,mGAAmG;IACnG,IAAc,eAAe;QAC3B,OAAO,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAED,oFAAoF;IACpF,IAAc,UAAU;QACtB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC;IAChD,CAAC;IAED,iGAAiG;IACjG,IAAc,cAAc;QAC1B,OAAO,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC;IACxD,CAAC;IAED,gFAAgF;IACtE,WAAW,CAAC,GAAW;QAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IAEO,SAAS,CAAC,IAAc;QAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,EAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACxE,CAAC;IAED,uEAAuE;IAC/D,OAAO,CAAC,GAAmB;QACjC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,EAAE,EAAE;YACpC,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC,UAAU;YACtB,IAAI,EAAE,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,EAAE;YACzB,KAAK,EAAE,GAAG,CAAC,KAAK,IAAI,SAAS;YAC7B,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,KAAK,IAAI,IAAI,CAAC,UAAU;YACpE,QAAQ,EAAE,GAAG,CAAC,EAAE;YAChB,UAAU,EAAE,GAAG,CAAC,IAAI;YACpB,MAAM,EAAE,IAAI;SACb,CAAC,CAAC;QACH,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACrB,OAAO,CAAC,CAAC;IACX,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,aAAa;QACzB,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC3B,MAAM,OAAO,GAAG,EAAE,IAAI,CAAC,aAAa,CAAC;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;QAC7B,IAAI,IAAI,GAAqB,EAAE,CAAC;QAChC,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,MAAM,GAA2B,EAAE,CAAC;QACxC,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC;YAChD,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;YAChC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;YACjD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,CAAC;YAC5E,IAAI,CAAC;gBACH,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;oBACzC,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,KAAK,GAAG,GAAG,EAAE,KAAK,EAAE,CAAC;oBACnE,IAAI,CAAC,SAAS,CAAC,0BAA0B,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC;iBAC9D,CAAC,CAAC;gBACH,IAAI,GAAG,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;gBACxB,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,CAAC,CAAC;gBACzB,MAAM,GAAG,QAAQ,IAAI,EAAE,CAAC;YAC1B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,IAAI,CAAC,4CAA4C,EAAE,GAAG,CAAC,CAAC;YAClE,CAAC;QACH,CAAC;QACD,IAAI,OAAO,KAAK,IAAI,CAAC,aAAa;YAAE,OAAO;QAC3C,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC;QAChC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED,6FAA6F;IACrF,KAAK,CAAC,QAAQ,CAAC,GAAW,EAAE,IAA8B;QAChE,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QACxF,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QACrD,IAAI,MAAM;YAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3B,CAAC;IAED,uFAAuF;IACvF,8FAA8F;IACpF,mBAAmB;QAC3B,IAAI,CAAC,SAAS,CAAC,uBAAuB,EAAE,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;IACvE,CAAC;IAES,UAAU;QAClB,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,mBAAmB,EAAE,CAAC,CAAC;IACjG,CAAC;IAED;;;OAGG;IACO,aAAa,CAAC,IAAY,EAAE,UAAoB,CAAC,IAAI,CAAC;QAC9D,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACnC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;;YACjC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACzC,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC7B,IAAI,CAAC,wBAAwB,EAAE,CAAC;IAClC,CAAC;IAED,4EAA4E;IAClE,gBAAgB,CAAC,OAA0B,EAAE,MAAe;QACpE,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IACrD,CAAC;IAED,+DAA+D;IACvD,QAAQ;QACd,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAClF,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,OAAO,CAAC,EAAE,EAAE;YAC9C,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC9B,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAChG,CAAC,CAAC,CAAC;IACL,CAAC;IAED,iGAAiG;IACzF,kBAAkB;QACxB,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC1C,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,eAAe,IAAI,EAAE;YAAE,IAAI,CAAC,CAAC,KAAK;gBAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC5E,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACK,wBAAwB;QAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QACxC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACzG,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;YAAE,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC;QAC/F,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QAC1G,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,EAAE,KAAK,IAAI,CAAC,aAAa;YAAE,OAAO;QACtC,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;QACxB,IAAI,CAAC,SAAS,CAAC,wBAAwB,EAAE,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,kGAAkG;IAC1F,UAAU,CAAC,GAAkB,EAAE,QAAiB;QACtD,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YACjB,IAAI,QAAQ;gBAAE,OAAO;YACrB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;YACxB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC1B,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO;QACT,CAAC;QACD,KAAK,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1F,CAAC;IAED,gHAAgH;IACxG,SAAS;QACf,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YAAE,OAAO;QACtE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACtB,CAAC;IAEO,MAAM,CAAC,MAAgE;QAC7E,IAAI,CAAC,QAAQ,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS,CAAC,mBAAmB,EAAE,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACzD,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,iCAAiC,EAAE,GAAI,GAAa,EAAE,OAAO,IAAI,GAAG,EAAE,CAAC,CAAC;QAC9F,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kGAAkG;IACxF,KAAK,CAAC,WAAW,CAAC,IAAmB;QAC7C,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC;QAC7B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QAC3G,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAChC,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,MAAM,IAAI,CAAC,SAAS,CAAC,mBAAmB,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC;IAED;;;;;;OAMG;IACK,iBAAiB,CAAC,OAAiB;QACzC,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,uBAAuB,EAAE,CAAC;QAC7D,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAC5B,MAAM,CAAC,KAAK;YACV,CAAC,CAAC,MAAM;YACR,CAAC,CAAC,eAAe,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC,CAC/F,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACK,MAAM,CAAC,OAAiB,IAAI,CAAC,OAAO;QAC1C,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAChC,IAAI,CAAC;YACH,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACvF,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QACnC,CAAC;QACD,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED;;;;;;;OAOG;IACK,YAAY,CAAC,QAA+C;QAClE,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;QACzC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACpC,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC1B,IAAI,CAAC,KAAK;gBAAE,OAAO,CAAC,CAAC;YACrB,MAAM,IAAI,GAAG,eAAe,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YACvC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YACpB,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;QACH,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;YAChB,IAAI,CAAC,eAAe,GAAG,CAAC,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;YACnF,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBACpE,IAAI,CAAC,mBAAmB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,mBAAmB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7G,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,8EAA8E;IACpE,iBAAiB,CAAC,MAAc,EAAE,KAAa;QACvD,IAAI,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK;YAAE,OAAO;QAC7C,iGAAiG;QACjG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACnF,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACO,iBAAiB,CAAC,MAAc,EAAE,MAAM,GAAG,KAAK;QACxD,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,MAAM;YAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IAC5B,CAAC;IAED,sEAAsE;IAC9D,eAAe;QACrB,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IACjG,CAAC;IAED;gFAC4E;IAC5E,IAAc,YAAY;QACxB,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC1B,IACE,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO;YAC5B,GAAG,CAAC,MAAM,KAAK,IAAI,CAAC,UAAU;YAC9B,GAAG,CAAC,KAAK,KAAK,IAAI,CAAC,cAAc;YACjC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,aAAa,EAC/B,CAAC;YACD,IAAI,CAAC,QAAQ,GAAG;gBACd,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,MAAM,EAAE,IAAI,CAAC,UAAU;gBACvB,KAAK,EAAE,IAAI,CAAC,cAAc;gBAC1B,IAAI,EAAE,IAAI,CAAC,aAAa;aACzB,CAAC;YACF,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC;YAC9F,IAAI,CAAC,KAAK;gBACR,GAAG,CAAC,MAAM,IAAI,IAAI,CAAC,aAAa;oBAC9B,CAAC,CAAC,GAAG;oBACL,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;YAC7E,gFAAgF;YAChF,IAAI,IAAI,CAAC,UAAU;gBAAE,cAAc,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QACnE,CAAC;QACD,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAOD,qFAAqF;IAC7E,cAAc;QACpB,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACjE,sDAAsD;QACtD,IAAI,CAAC,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC3B,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,GAAG,EAAE,CAAC;YAC7B,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;gBACzB,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,CAAC;YACD,OAAO;QACT,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,IAAI,IAAI,GAAG,EAAyB,CAAC;QACpE,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9F,MAAM,OAAO,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,YAAY;YAAE,OAAO;QACjD,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAkB,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1F,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,IAAI,CAAC,OAAO,CAAC,MAAM;YAAE,OAAO;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC;QACnC,GAAG,CAAC,OAAO,CAAC,CAAC,IAAI,CACf,CAAC,OAAO,EAAE,EAAE;YACV,IAAI,OAAO,KAAK,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,YAAY;gBAAE,OAAO;YACjE,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAChF,IAAI,CAAC,OAAO,EAAE,CAAC;QACjB,CAAC,EACD,CAAC,GAAG,EAAE,EAAE;YACN,IAAI,OAAO,KAAK,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,YAAY;gBAAE,OAAO;YACjE,0DAA0D;YAC1D,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACxC,KAAK,MAAM,CAAC,IAAI,OAAO;gBAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;YACxC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,CAAC,IAAI,CAAC,2CAA2C,EAAE,GAAG,CAAC,CAAC;QACjE,CAAC,CACF,CAAC;IACJ,CAAC;IAED,8FAA8F;IACtF,YAAY;QAClB,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,cAAc,EAAE,CAAC;IACxB,CAAC;IAIS,YAAY,CAAC,KAAwC;QAC7D,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,aAAa,CAAC;QACtD,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;IAC5B,CAAC;IAED,gGAAgG;IACtF,KAAK,CAAC,gBAAgB;QAC9B,IAAI,CAAC,eAAe,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;QACzC,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,oBAAoB;YAAE,OAAO;QACtE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,uBAAuB,EAAE,CAAC,CAAC;QACtG,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAChD,IAAI,GAAG,CAAC,MAAM;YAAE,MAAM,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IACzE,CAAC;IAES,qBAAqB;QAC7B,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5D,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5E,IAAI,UAAU,CAAC,MAAM;gBAAE,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;YACzF,kEAAkE;YAClE,sDAAsD;YACtD,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAC/D,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC5D,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,8DAA8D;YAC9D,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IAES,eAAe;QACvB,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC;YAC/B,GAAG,EAAE,gBAAgB;YACrB,OAAO,EAAE,8CAA8C;YACvD,MAAM,EAAE,GAAG,EAAE;gBACX,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;gBAC1B,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;gBACxB,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAChB,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC1B,IAAI,IAAI,CAAC,eAAe;oBAAE,KAAK,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAChE,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,2FAA2F;IACnF,KAAK,CAAC,uBAAuB;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC;QAClD,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,oBAAoB;YAAE,OAAO;QAC3D,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,gBAAgB,EAAE,CAAC,CAAC;QAC7F,IAAI,IAAI,EAAE,IAAI,CAAC,MAAM;YAAE,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACzF,CAAC;IAES,YAAY,CAAC,QAAgB;QACrC,yEAAyE;QACzE,IAAI,QAAQ,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACpC,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;YAC3F,IAAI,GAAG;gBAAE,IAAI,CAAC,SAAS,CAAC,oBAAoB,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACtE,OAAO;QACT,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACvC,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC;QAC3D,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,yEAAyE;QACzE,0CAA0C;QAC1C,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAEO,mBAAmB;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC;QAC1G,IAAI,IAAI,CAAC,cAAc,GAAG,QAAQ,EAAE,CAAC;YACnC,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;QACjC,CAAC;IACH,CAAC;IACS,oBAAoB,CAAC,SAAkB;QAC/C,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAES,cAAc,CAAC,MAAc;QACrC,OAAO,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAES,cAAc,CAAC,MAAc,EAAE,KAAa;QACpD,KAAK,EAAE,eAAe,EAAE,CAAC,CAAC,6BAA6B;QACvD,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YAC9B,KAAK,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1D,OAAO;QACT,CAAC;QACD,iEAAiE;QACjE,IAAI,CAAC,mBAAmB,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;IAC/F,CAAC;IAED,2EAA2E;IACjE,aAAa,CAAC,MAAc,EAAE,KAAa;QACnD,IAAI,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC;YAAE,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACxF,CAAC;IAES,aAAa,CAAC,MAAc,EAAE,MAAe,EAAE,KAAa;QACpE,KAAK,EAAE,eAAe,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnD,IAAI,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YAC/C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACpB,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;QAClC,CAAC;QACD,IAAI,MAAM,EAAE,CAAC;YACX,6EAA6E;YAC7E,MAAM,MAAM,GACV,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,MAAM,CAAC,KAAK;gBAC3C,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC;gBAC5F,CAAC,CAAC,MAAM,CAAC;YACb,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAED;+DAC2D;IACjD,UAAU,CAAC,MAAc;QACjC,OAAO,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACO,qBAAqB;QAC7B,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,EAAE;YAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC;YAC3B,IAAI,CAAC,CAAC,IAAI,YAAY,SAAS,CAAC;gBAAE,OAAO,IAAI,CAAC;YAC9C,OAAO;gBACL,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,SAAS,EAAE,EAAE,IAAI,EAAE;oBAC3C,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,GAAG,GAAG;oBAC3C,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,GAAG;iBAC1C,CAAC;aACH,CAAC;QACJ,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAES,QAAQ;QAChB,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAChC,CAAC;IAED;;oFAEgF;IACtE,eAAe;QACvB,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM;YAAE,OAAO;QAC1C,MAAM,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;QAC9C,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1C,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;YACzC,IAAI,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC;gBAAE,SAAS;YACrC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QAC/F,CAAC;QACD,IAAI,CAAC,eAAe,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QACpF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED;8CAC0C;IAChC,oBAAoB,CAAC,QAA0B,IAAI,CAAC,eAAe;QAC3E,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACnE,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;QACrD,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,EAAE;YAC3B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC;gBAAE,OAAO,IAAI,CAAC;YACvC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;YACzC,MAAM,KAAK,GAAG,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YACtC,IAAI,CAAC,KAAK;gBAAE,OAAO,IAAI,CAAC;YACxB,kEAAkE;YAClE,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;QAC1C,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IAED,wEAAwE;IAExE,6FAA6F;IACnF,YAAY,CAAC,IAAa;QAClC,OAAO,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC;IACtE,CAAC;IAED;;;;;;;OAOG;IACK,sBAAsB,CAAC,OAAiB;QAC9C,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QAC1D,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxE,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;QAChC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;YACxB,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,KAAK,IAAI,KAAK,KAAK,QAAQ;gBAAE,SAAS;YAC3C,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;YACvB,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;gBAAE,SAAS;YAC3C,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACb,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;gBACzB,IAAI,EAAE,KAAK;gBACX,KAAK,EAAE,CAAC,CAAC,KAAK,IAAI,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC;gBACtD,MAAM,EAAE,MAAM;aACf,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,wEAAwE;IAExE;;;OAGG;IACH,IAAY,WAAW;QACrB,OAAO,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;IAC5C,CAAC;IAED,6FAA6F;IACrF,oBAAoB;QAC1B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;QACzC,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;QACvC,MAAM,GAAG,GAAG,CAAC,KAAa,EAAE,CAAS,EAAE,EAAE;YACvC,MAAM,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YAC3C,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACxC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC9C,CAAC,CAAC;QACF,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,yBAAyB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC;QAC7F,KAAK,MAAM,CAAC,IAAI,OAAO;YAAE,IAAI,CAAC,CAAC,KAAK;gBAAE,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACtD,8EAA8E;QAC9E,KAAK,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC;YAAE,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED;8DAC0D;IAClD,oBAAoB;QAC1B,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC5F,MAAM,UAAU,GAAkB,EAAE,CAAC;QACrC,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC;YACxD,MAAM,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YAC3C,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;gBAAE,SAAS;YAC3B,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACb,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAChF,CAAC;QACD,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,MAAM;YACrC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC,EAAE;YAC5E,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;QACnB,IAAI,CAAC,cAAc,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,GAAG,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YAC7E,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAC5D,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kFAAkF;IACxE,UAAU,CAAC,IAAY;QAC/B,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC;IACpE,CAAC;IAED,uFAAuF;IAC7E,aAAa,CAAC,IAAY,EAAE,KAAa;QACjD,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACnD,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED;;gEAE4D;IAClD,WAAW,CAAC,IAAY;QAChC,IAAI,CAAC,6BAA6B,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC3C,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,IAAI,CAAC,WAAW,KAAK,IAAI;YAAE,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACvD,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED;;yFAEqF;IAC7E,6BAA6B,CAAC,YAAsB;QAC1D,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;QAC1D,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;QACjD,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,CAAC,IAAI;YAAE,OAAO;QAC1B,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACnE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CACtB,CAAC,CAAC,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,gBAAgB,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE;YACjE,CAAC,CAAC,IAAI,CACT,CAAC;IACJ,CAAC;IAED;kFAC8E;IACpE,mBAAmB,CAAC,MAAc,EAAE,SAAiB;QAC7D,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YAC9B,KAAK,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;YAC1E,OAAO;QACT,CAAC;QACD,MAAM,IAAI,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACtC,MAAM,KAAK,GAAoB,EAAE,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;QACvE,IAAI,IAAI;YAAE,KAAK,CAAC,KAAK,GAAG,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED;oCACgC;IACtB,iBAAiB,CAAC,IAAY;QACtC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED,0FAA0F;IAClF,oBAAoB,CAAC,IAAY;QACvC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,CAAC,IAAI;YAAE,OAAO;QAC3B,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAClD,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACpG,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IAED,6EAA6E;IACnE,cAAc;QACtB,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,OAAO;QAC5B,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,CAAC;IAC5B,CAAC;IAED,yFAAyF;IAC/E,oBAAoB;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QACtC,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QAC7F,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACnG,CAAC;QACD,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;QACvB,IAAI,CAAC,YAAY,EAAE,IAAI,EAAE,CAAC;IAC5B,CAAC;IAED,8BAA8B;IACpB,gBAAgB;QACxB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAC/B,CAAC;IACO,cAAc,CAAC,CAAY;QACjC,OAAO;YACL,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;YACjD,eAAe,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;YAC/C,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,WAAW;YAC5B,SAAS,EAAE,CAAC,CAAC,SAAS,KAAK,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO;SACjE,CAAC;IACJ,CAAC;IACD;2DACuD;IAC7C,iBAAiB,CAAC,KAAc;QACxC,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAC9B,+EAA+E;QAC/E,6EAA6E;QAC7E,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC;QAC/B,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QACjD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;QAC/B,MAAM,OAAO,GAAkB,EAAE,CAAC;QAClC,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YAC9B,MAAM,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;YACnC,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YACxB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;gBAAE,SAAS;YACrC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACd,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/B,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,CAAC;QACzC,8EAA8E;QAC9E,0EAA0E;QAC1E,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7F,IAAI,CAAC,6BAA6B,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC9C,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,kEAAkE;QACjF,IAAI,KAAK;YAAE,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAC3C,CAAC;IACS,sBAAsB;QAC9B,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC;QAC9B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC;QACtE,IAAI,CAAC,MAAM,EAAE,CAAC;IAChB,CAAC;IACS,aAAa;QACrB,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QACzF,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC,EAAE,yBAAyB,CAAC,CAAC;IACpF,CAAC;IACS,aAAa,CAAC,KAAY;QAClC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC;IACpF,CAAC;IAED,mEAAmE;IAC3D,oBAAoB,CAAC,IAAY;QACvC,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;YAC7C,IAAI,CAAC,GAAG;gBAAE,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;YAC1F,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YACjC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC;YACtE,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBACtB,GAAG,EAAE,aAAa;gBAClB,QAAQ,EAAE,SAAS;gBACnB,OAAO,EAAE,kBAAkB;gBAC3B,MAAM,EAAE,4BAA4B;aACrC,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBACtB,GAAG,EAAE,aAAa;gBAClB,QAAQ,EAAE,OAAO;gBACjB,OAAO,EAAE,eAAe;gBACxB,MAAM,EAAE,GAAI,GAAa,EAAE,OAAO,IAAI,GAAG,EAAE;aAC5C,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED;6CACyC;IAC/B,UAAU,CAAC,KAAY;QAC/B,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAE,KAAK,CAAC,MAA2B,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;QACzE,IAAI,KAAK,CAAC,MAAM;YAAE,KAAK,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,kBAAkB,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACjH,CAAC;IAED,sFAAsF;IACtF,IAAc,mBAAmB;QAC/B,OAAO,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;IACjD,CAAC;IAID,iHAAiH;IACvG,gBAAgB;QACxB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,OAAO,EAAE,CAAC;QACf,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC,SAAS,CAAC;YAC7C,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;gBACb,IAAI,CAAC,IAAI;oBAAE,OAAO;gBAClB,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;oBAC1B,KAAK,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBAC/E,OAAO;gBACT,CAAC;gBACD,KAAK,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACvD,CAAC;YACD,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC;YACtC,QAAQ,EAAE,GAAG,EAAE;gBACb,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;gBACvB,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,iBAAiB,CAAC,KAAyB;QACvD,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,IAAI,CAAC,YAAY,CACf,IAAI,KAAK,CAAC,6FAA6F,CAAC,CACzG,CAAC;YACF,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3B,MAAM,IAAI,CAAC,iBAAiB,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YACrD,OAAO;QACT,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,wBAAwB,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC7E,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,IAAI,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC,CAAC;YACxE,OAAO;QACT,CAAC;QACD,6FAA6F;QAC7F,+DAA+D;QAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,kBAAkB,EAAE,EAAE,CAAC;QACrD,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,IAAI,GAAG,EAA8B,CAAC;YACtD,IAAI,OAAe,CAAC;YACpB,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC3B,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;gBAClF,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;gBACjG,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACvC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;gBACvF,CAAC;gBACD,OAAO,GAAG,GAAG,MAAM,CAAC,MAAM,cAAc,MAAM,CAAC,KAAK,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC;gBAC1E,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACtD,CAAC;iBAAM,CAAC;gBACN,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;gBAClF,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAC9B,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC,uBAAuB,CAAC,MAAM,kBAAkB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,CAC/F,CAAC;gBACF,OAAO,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,cAAc,CAAC;YAChD,CAAC;YACD,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YACzC,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;gBACtB,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnB,OAAO;YACT,CAAC;YACD,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CACR,SAAS,EACT,kBAAkB,EAClB,GAAG,OAAO,KAAK,QAAQ,SAAS,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,aAAa,CACvE,CAAC;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IAED,yGAAyG;IACjG,KAAK,CAAC,qBAAqB,CAAC,GAAW,EAAE,IAAa;QAC5D,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,wBAAwB,EAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACnF,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,IAAI,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC,CAAC;YACxE,OAAO;QACT,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,kBAAkB,EAAE,EAAE,CAAC;QACrD,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,YAAY,CAChC,GAAG,EAAE,CAAC,oBAAoB,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC,EACjE,MAAM,CACP,CAAC;YACF,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;gBACtB,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnB,OAAO;YACT,CAAC;YACD,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,kBAAkB,EAAE,IAAI,IAAI,GAAG,CAAC,CAAC;QACzD,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IAED,gGAAgG;IACxF,WAAW;QACjB,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,kBAAkB,EAAE,sDAAsD,CAAC,CAAC;QAC/F,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED,mFAAmF;IAC3E,iBAAiB;QACvB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAChB,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED,kGAAkG;IAC1F,iBAAiB,CAAC,KAAa,EAAE,MAAc;QACrD,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;QAC/C,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,KAAK,KAAK,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,EAAE,CAAC;YAC7D,IAAI,CAAC,KAAK,CACR,MAAM,EACN,gBAAgB,EAChB,2BAA2B,KAAK,MAAM,MAAM,kBAAkB,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,MAAM,GAAG,CAC7F,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,YAAY,CAAC,GAAY;QAC/B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;YACtB,GAAG,EAAE,aAAa;YAClB,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,yBAAyB;YAClC,MAAM,EAAE,GAAI,GAAa,EAAE,OAAO,IAAI,GAAG,EAAE;SAC5C,CAAC,CAAC;QACH,OAAO,CAAC,KAAK,CAAC,0BAA0B,EAAE,GAAG,CAAC,CAAC;QAC/C,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,iBAAiB,CAAC,IAAY;QAC1C,IAAI,CAAC;YACH,IAAI,MAAM,IAAI,CAAC,SAAS,CAAC,kBAAkB,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBACpD,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;gBAC1B,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;gBACxB,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAChB,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC1B,OAAO;YACT,CAAC;YACD,oEAAoE;YACpE,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;YACnD,MAAM,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,EAAE,CAAC;YAC1C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;YACvB,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBACtB,GAAG,EAAE,aAAa;gBAClB,QAAQ,EAAE,OAAO;gBACjB,OAAO,EAAE,0BAA0B;gBACnC,MAAM,EAAE,GAAI,GAAa,EAAE,OAAO,IAAI,GAAG,EAAE;aAC5C,CAAC,CAAC;YACH,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,GAAG,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAED,gFAAgF;IACxE,cAAc;QACpB,OAAO,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvD,CAAC;IAES,UAAU;QAClB,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,eAAe;YAAE,OAAO;QACnE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;QAC3D,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAC/B,CAAC;IAES,aAAa;QACrB,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;QAC5C,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACtC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC;YAAE,OAAO;QACpE,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,WAAW;aACb,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;aAC3B,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,yBAAyB,EAAE,GAAI,GAAa,EAAE,OAAO,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC;IACzG,CAAC;IAED,wEAAwE;IAC9D,kBAAkB;QAC1B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM;YAAE,OAAO;QACjC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;QAC3D,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;IACjC,CAAC;IAED;;;;;OAKG;IACO,eAAe;QACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;QAC9C,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAE/D,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,CAAC;QAC/C,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,IAAI,CAAC,SAAS,CAAC,0DAA0D,CAAC,CAAC;YAC3E,OAAO;QACT,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,UAAU;aAC3B,MAAM,CAAC;YACN,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,SAAS,EAAE,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE;SAChD,CAAC;aACD,SAAS,CAAC;YACT,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE;gBACV,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;oBACf,KAAK,SAAS;wBACZ,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;4BAChB,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gCACtB,GAAG,EAAE,aAAa;gCAClB,QAAQ,EAAE,MAAM;gCAChB,OAAO,EAAE,iBAAiB;gCAC1B,MAAM,EAAE,yDAAyD,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,MAAM,GAAG;6BACxF,CAAC,CAAC;wBACL,CAAC;wBACD,MAAM;oBACR,KAAK,UAAU;wBACb,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,OAAO,CAAC;wBAC9B,MAAM;oBACR,KAAK,UAAU;wBACb,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;wBACzB,MAAM;oBACR,KAAK,MAAM;wBACT,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;wBAClC,MAAM;gBACV,CAAC;YACH,CAAC;YACD,KAAK,EAAE,CAAC,GAAU,EAAE,EAAE;gBACpB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC5B,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,CAAC;SACF,CAAC,CAAC;IACP,CAAC;IAED,iFAAiF;IACvE,cAAc;QACtB,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC;IACxB,CAAC;IAEO,UAAU,CAAC,IAAU,EAAE,QAAgB;QAC7C,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IACzB,CAAC;IAEO,SAAS,CAAC,MAAc;QAC9B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC1B,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;YACtB,GAAG,EAAE,aAAa;YAClB,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,uBAAuB;YAChC,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAES,cAAc;QACtB,wEAAwE;QACxE,2DAA2D;QAC3D,IAAI,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,EAAE,CAAC;YACrC,IAAI,CAAC,eAAe,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC;QACpD,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC;YAAE,OAAO;QAElF,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;QAC/B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAC9C,CAAC;IAED;;oFAEgF;IACxE,KAAK,CAAC,eAAe;QAC3B,IAAI,IAAI,CAAC,UAAU;YAAE,OAAO;QAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,MAAsB,CAAC;QAC3B,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;QAClD,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,sBAAsB,EAAE,GAAI,GAAa,EAAE,OAAO,IAAI,GAAG,EAAE,CAAC,CAAC;YACjF,OAAO;QACT,CAAC;QACD,8DAA8D;QAC9D,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACvC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC;YAC9D,IAAI,EAAE,GAAG,EAAE;gBACT,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;gBACxB,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,IAAI,CAAC,KAAK,CACR,SAAS,EACT,eAAe,EACf,kBAAkB,MAAM,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CACzE,CAAC;YACJ,CAAC;YACD,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;gBACb,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;gBACxB,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,sBAAsB,EAAE,GAAI,GAAa,EAAE,OAAO,IAAI,GAAG,EAAE,CAAC,CAAC;YACnF,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAES,qBAAqB;QAC7B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IAC9C,CAAC;IAES,aAAa;QACrB,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE;YAAE,OAAO;QAEjD,MAAM,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;QAC5C,IAAI,CAAC,QAAQ;YAAE,OAAO;QAEtB,yEAAyE;QACzE,uDAAuD;QACvD,MAAM,MAAM,GAAG,GAAG,EAAE;YAClB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,gFAAgF;YAChF,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW;iBAC/B,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,QAAQ,CAAC;iBAC3C,SAAS,CAAC;gBACT,IAAI,EAAE,GAAG,EAAE;oBACT,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;oBACxB,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;oBAC9B,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,eAAe,EAAE,YAAY,QAAQ,EAAE,CAAC,CAAC;gBACjE,CAAC;gBACD,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;oBACb,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;oBACxB,IAAI,CAAC,OAAO,EAAE,CAAC;oBACf,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,sBAAsB,EAAE,GAAI,GAAa,EAAE,OAAO,IAAI,GAAG,EAAE,CAAC,CAAC;gBACnF,CAAC;aACF,CAAC,CAAC;QACP,CAAC,CAAC;QAEF,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC;gBAC/B,OAAO,EAAE,IAAI,QAAQ,gDAAgD;gBACrE,MAAM,EAAE,mBAAmB;gBAC3B,IAAI,EAAE,4BAA4B;gBAClC,MAAM,EAAE,MAAM;aACf,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,MAAM,EAAE,CAAC;QACX,CAAC;IACH,CAAC;IAED;iDAC6C;IACnC,YAAY;QACpB,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;QAC5B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAEO,KAAK,CAAC,QAAsC,EAAE,OAAe,EAAE,MAAc;QACnF,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IAC7E,CAAC;8GAzgDU,qBAAqB,kBAkKtB,iBAAiB;kGAlKhB,qBAAqB,0FAFrB,CAAC,wBAAwB,CAAC,8HCvGvC,gpZAoYA,6+BDnTI,YAAY,kIACZ,WAAW,8mBACX,YAAY,qIACZ,YAAY,2kBACZ,mBAAmB,omBACnB,cAAc,utCACd,eAAe,wHACf,kBAAkB,mWAClB,aAAa,kJACb,aAAa,uXACb,qBAAqB,gUACrB,oBAAoB,2VACpB,kBAAkB,mNAClB,0BAA0B,yPAC1B,uBAAuB,oOACvB,0BAA0B,oJAC1B,4BAA4B,oMAC5B,yBAAyB;;2FAOhB,qBAAqB;kBA5BjC,SAAS;+BACE,eAAe,cACb,IAAI,WACP;wBACP,YAAY;wBACZ,WAAW;wBACX,YAAY;wBACZ,YAAY;wBACZ,mBAAmB;wBACnB,cAAc;wBACd,eAAe;wBACf,kBAAkB;wBAClB,aAAa;wBACb,aAAa;wBACb,qBAAqB;wBACrB,oBAAoB;wBACpB,kBAAkB;wBAClB,0BAA0B;wBAC1B,uBAAuB;wBACvB,0BAA0B;wBAC1B,4BAA4B;wBAC5B,yBAAyB;qBAC1B,mBAGgB,uBAAuB,CAAC,MAAM,aACpC,CAAC,wBAAwB,CAAC;;0BAoKlC,MAAM;2BAAC,iBAAiB;+KAjKF,YAAY;sBAApC,SAAS;uBAAC,IAAI;gBAQF,MAAM;sBAAlB,KAAK","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  DestroyRef,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  ViewChild,\n  inject,\n  NgZone,\n} from '@angular/core';\nimport { markForCheckInZone } from '../util/mark-for-check';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule } from '@angular/forms';\nimport { ButtonModule } from 'primeng/button';\nimport { ConfirmDialogModule } from 'primeng/confirmdialog';\nimport { DropdownModule } from 'primeng/dropdown';\nimport { InputTextModule } from 'primeng/inputtext';\nimport { OverlayPanel, OverlayPanelModule } from 'primeng/overlaypanel';\nimport { ToolbarModule } from 'primeng/toolbar';\nimport { TooltipModule } from 'primeng/tooltip';\nimport { saveAs } from 'file-saver';\nimport { Subject, Subscription } from 'rxjs';\n\nimport { Rectangle, Region } from '../models/region';\nimport { withRegionPatch } from '../models/region-clone';\nimport { PresetSet, ClassPreset, defaultPresetSet, parsePresetSet } from '../models/class-preset';\nimport { colorForLabel, presetKey } from '../store/class-color.util';\nimport { ConfirmationService, MessageService, SharedModule } from 'primeng/api';\nimport { IRegionEditorApi, REGION_EDITOR_API } from '../contracts/region-editor-api.contract';\nimport { VIZ_TOAST_KEY } from '../toast-outlets';\nimport { HttpClient } from '@angular/common/http';\nimport type { RegionSourceOpener } from '../store/region-source-scope';\nimport { openGeoJsonRegionSource } from '../region-source/worker-region-source';\nimport { openHttpRegionSource } from '../region-source/http-region-source';\nimport { readLabelVolume } from '../region-import/label-volume';\nimport { labelClasses, labelSliceGeoJson } from '../region-import/label-classes';\nimport {\n  RegionImportFile,\n  folderSliceGeoJson,\n  importFile,\n  planRegionImport,\n} from '../region-import/region-import';\nimport { RegionPersistenceService, SliceGeoJson } from './region-persistence.service';\nimport { ClassColorEdit, RegionColorDialogComponent } from './region-color-dialog/region-color-dialog.component';\nimport { ClassesPanelComponent } from './classes-panel/classes-panel.component';\nimport { RegionTableComponent } from './region-table/region-table.component';\nimport { ClassTreeComponent, ClassTreePick } from './class-tree/class-tree.component';\nimport type { RegionSourceView } from '../region-source/region-source';\nimport type { RegionClassNode, RegionIndexRow } from '../region-source/region-tiles';\nimport { SaveRegionsDialogComponent } from './save-regions-dialog/save-regions-dialog.component';\nimport { SaveMaskDialogComponent } from './save-mask-dialog/save-mask-dialog.component';\nimport { ManageClassesDialogComponent } from './manage-classes-dialog/manage-classes-dialog.component';\nimport { RegionEditorHelpComponent } from './region-editor-help/region-editor-help.component';\nimport { MaskExportService, MaskMode } from './mask-export.service';\nimport { PixelSize, formatArea, pickMpp, regionAreaPx } from './region-metrics';\n\n/**\n * The Region Editor (`<region-editor>`): the table of the active image's\n * annotation regions with class presets, colours, labels, GeoJSON import /\n * export / server save and mask export. Self-contained: it talks to the viewer\n * only through {@link REGION_EDITOR_API} (and the host's REGION_IO_PORT), so it\n * has no inputs or outputs.\n *\n * OnPush: template events re-render it; state that lands asynchronously (the\n * API's region / selection / preset / image-meta streams, save and mask-export\n * progress, file reads) marks it for check.\n */\n/** The opacity the fill toggle fills regions at. */\nconst REGION_FILL_OPACITY = 0.6;\n\n/** \"Select all\" takes at most this many region-source features into the regions. */\nconst SELECT_ALL_SOURCE_LIMIT = 5000;\n\n@Component({\n  selector: 'region-editor',\n  standalone: true,\n  imports: [\n    CommonModule,\n    FormsModule,\n    SharedModule,\n    ButtonModule,\n    ConfirmDialogModule,\n    DropdownModule,\n    InputTextModule,\n    OverlayPanelModule,\n    ToolbarModule,\n    TooltipModule,\n    ClassesPanelComponent,\n    RegionTableComponent,\n    ClassTreeComponent,\n    SaveRegionsDialogComponent,\n    SaveMaskDialogComponent,\n    RegionColorDialogComponent,\n    ManageClassesDialogComponent,\n    RegionEditorHelpComponent,\n  ],\n  templateUrl: './region-editor.component.html',\n  styleUrls: ['./region-editor.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [RegionPersistenceService],\n})\nexport class RegionEditorComponent implements OnInit, OnDestroy {\n  @ViewChild('op') private overlayPanel!: OverlayPanel;\n\n  /**\n   * Whether the editor is on screen (its dialog open). Closed, it asks the region source nothing:\n   * its page of features, its class counts and, in a volume view, its classes' volumes are each a\n   * request over the whole set (a stack's every slice), and they competed with the volume's own\n   * slice loading for nothing anyone could see. Opened, it reads them again.\n   */\n  @Input() set active(value: boolean) {\n    const was = this.isActive;\n    this.isActive = value;\n    if (value && !was) {\n      void this.refreshSource();\n      this.resetVolumes();\n    }\n  }\n  private isActive = true;\n  /** The host's HttpClient: a served region set's requests go through it (its auth). */\n  private readonly http = inject(HttpClient, { optional: true });\n\n  protected regions: Region[] = [];\n  protected selectedRegions: Region[] = [];\n  protected showShapeLabel!: boolean;\n  protected shapeColor!: string;\n  protected fillColor!: string;\n  protected displayHelpDialog = false;\n  protected showColorDialog = false;\n  /** One colour editor per unique class among the selected regions, shown in the\n   *  \"edit colour of selected regions\" dialog. Unclassified regions (no label)\n   *  are grouped under a single entry with an empty `label`. */\n  protected classColorEdits: ClassColorEdit[] = [];\n  /** \"Edit class on selected rows\" popup: chosen existing class, and a new-class name. */\n  protected bulkClass = '';\n  protected newBulkClass = '';\n\n  // ── annotation-class presets (jit-ui#70) ──\n  /** Local mirror of the per-user preset set (chip strip, Class dropdown, dialog). */\n  protected presetSet: PresetSet = defaultPresetSet();\n  /** The class last picked in the panel; a chip-click applies it to the selected rows. */\n  protected activeClass: string | null = null;\n  protected showManageDialog = false;\n  /** Working copy edited inside the Manage-classes dialog; committed on Apply/Done. */\n  protected presetDraft: PresetSet | null = null;\n  /** class name (match-mode keyed) → number of regions currently using it. */\n  protected classCounts = new Map<string, number>();\n  /** Fallback class that a region reverts to when its class is deleted (jit-ui#70). */\n  protected readonly defaultClassName = 'Region';\n  /** Classes as shown in the panel: sorted by region count (desc), then name. */\n  protected displayClasses: ClassPreset[] = [];\n\n  protected paginatorFirst = 0;\n  protected paginatorRows = 10;\n  protected readonly rowsPerPageOptions = [10, 25, 50];\n  /** Regions whose Class cell is currently in edit mode → the label being typed.\n   *  The draft is committed on Enter and discarded on Escape/✕, so typing never\n   *  writes into the store's region (RT-18). Keyed by object identity, which\n   *  avoids needing a unique id field. */\n  protected editingLabelRegions = new Map<Region, string>();\n\n  protected showSaveAsDialog = false;\n  /**\n   * The slice's region source (a large region set drawn by level of detail), or null. Its\n   * features are rows of the table after the regions — stand-ins until one is selected or edited,\n   * which takes it into the regions — and its classes count in the classes panel.\n   */\n  protected sourceView: RegionSourceView | null = null;\n  /** Features still in the source (the table's rows after the regions). */\n  private sourceTotal = 0;\n  /** Stand-in rows for the source features on the current page. */\n  private sourceRows: Region[] = [];\n  /** Features per class still in the source. */\n  private sourceClassCounts: Record<string, number> = {};\n  /** The stand-in rows (rows of a source feature, not of a region). */\n  private readonly standIns = new WeakSet<Region>();\n  private standInSeq = 0;\n  /** Bumped per source refresh, so a late answer is dropped. */\n  private sourceRequest = 0;\n  /** The classes the table's Class column offers: the presets and the region source's classes\n   *  (a dropdown can only show a value that is one of its options). */\n  protected tablePresetSet: PresetSet = defaultPresetSet();\n  /** Whether regions are drawn filled (the atlas look) rather than outlined. */\n  protected regionsFilled = false;\n  /** Whether a volume view is on screen (classes can then be shown in 3D). */\n  protected volumeView = false;\n  /** Whether the volume view's slice pane is wanted (one slice edited beside the 3D view). */\n  private slicePane = false;\n  /** Whether the volume view draws the regions through the volume (see toggleThroughVolume). */\n  protected regionsThroughVolume = false;\n  /** Classes shown in 3D in the volume view, each with the classes its surface covers. */\n  protected shown3d = new Map<string, string[]>();\n  /** The classes of the class tree's pick (it and its subtree), as long as the pick holds. */\n  private pickedClasses: readonly string[] = [];\n  /** The selected rows' classes, marked in the class lists. */\n  protected markedClasses: ReadonlySet<string> = new Set();\n  /** The surfaces highlighted in the volume view (their keys, joined). */\n  private highlighted3d = '';\n  /** The colour each shown surface was last drawn in. */\n  private colors3d = new Map<string, string>();\n  /** Their names, for the class lists' toggles (a new set per change, for OnPush). */\n  protected shown3dNames: ReadonlySet<string> = new Set();\n  /** The classes hidden from view (their regions, source features and surfaces). */\n  protected hiddenClasses: ReadonlySet<string> = new Set();\n  /** Whether a region set's class hierarchy is shown as a tree (rather than the class list). */\n  protected classTreeView = true;\n  /** The class picked last in the class tree. */\n  protected pickedClass: string | null = null;\n  /** Regions per class (the regions' and the source's), for the class tree. */\n  protected treeCounts = new Map<string, number>();\n  /** A class's colour, for the class tree: a new function per colour change, so the tree repaints. */\n  protected treeColor = (name: string): string => colorForLabel(name, this.presetSet);\n  protected saveAsFilename = '';\n  protected saveAsFileExists = false;\n  /** True while a GeoJSON persist is serializing/uploading — drives the dialog's\n   *  progress bar and Cancel button (parity with the Save-mask dialog). */\n  protected saveAsBusy = false;\n  /** The running GeoJSON save; unsubscribing cancels it (Cancel / destroy). */\n  private _saveAsSub?: Subscription;\n  /** Save-as file names to check for an existing file (debounced). */\n  private readonly saveAsCheck$ = new Subject<string>();\n\n  protected showExportDialog = false;\n  protected exportFilename = '';\n\n  protected showSaveMaskDialog = false;\n  protected saveMaskFilename = '';\n  /** Mask type chosen in the Save-mask dialog: a binary foreground/background\n   *  mask, or a multi-class mask with a distinct id per region. */\n  protected maskMode: MaskMode = 'binary';\n  /** True while the mask worker is rasterizing/encoding — drives the progress\n   *  bar and the Cancel button in the dialog. */\n  protected maskBusy = false;\n  /** 0–100 rasterization progress; switches to indeterminate during encoding. */\n  protected maskProgress = 0;\n  protected maskEncoding = false;\n  /** The running mask export; unsubscribing cancels it (terminates its worker). */\n  private maskJob?: Subscription;\n\n  /**\n   * PrimeNG p-table multi-selection mode toggle. When true, single-click\n   * selects one row (replacing prior); meta/ctrl-click toggles a row in/out\n   * of the selection. When false, every click toggles. Default true to\n   * match the most common spreadsheet-like UX.\n   */\n  protected metaKey = true;\n\n  private _updatingFromEditor = false;\n  private _suppressSelectionSyncToPlot = false;\n  private readonly destroyRef = inject(DestroyRef);\n  private readonly cdr = inject(ChangeDetectorRef);\n  private readonly zone = inject(NgZone);\n\n  /** Re-render this OnPush view, re-entering the zone when the change came from outside it. */\n  private changed(): void {\n    markForCheckInZone(this.cdr, this.zone);\n  }\n\n  /** Physical pixel size (µm/pixel) of the active image, for region areas in\n   *  µm²; empty when the format reports no physical size. */\n  protected mpp: PixelSize = {};\n\n  constructor(\n    @Inject(REGION_EDITOR_API) private regionApi: IRegionEditorApi,\n    private messageService: MessageService,\n    private confirmationService: ConfirmationService,\n    private persistence: RegionPersistenceService,\n    private maskExport: MaskExportService,\n  ) {}\n\n  ngOnInit() {\n    this.showShapeLabel = this.regionApi.getShowShapeLabel();\n    this.shapeColor = this.regionApi.getShapeColor();\n    this.fillColor = this.regionApi.getFillColor();\n\n    // Annotation-class presets (jit-ui#70): mirror the set for the chip strip,\n    // the Class dropdown and the manage dialog. Guarded with optional calls so\n    // partial API mocks in tests (which omit the preset methods) don't throw.\n    const initialPresets = this.regionApi.getPresetSet?.();\n    if (initialPresets) this.presetSet = initialPresets;\n    const presets$ = this.regionApi.getPresetSet$?.();\n    if (presets$) {\n      presets$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe((set) => {\n        if (set) this.presetSet = set;\n        this.treeColor = (name: string): string => colorForLabel(name, this.presetSet);\n        this.updateDisplayClasses();\n        this.recolor3d();\n        this.changed();\n      });\n    }\n    // Seed from the visualizer's current regions — already scoped to the\n    // active image by the per-image cache, and handed back as neutral Region\n    // objects (no backend shape format involved).\n    // Annotation regions only — intensity-profile lines are owned by the\n    // intensity tool and excluded by the contract, so the editor never sees them.\n    this.regions = this.applyRegionColors(this.regionApi.getAnnotationRegions());\n    this.syncClassesFromRegions(this.regions);\n    this.recomputeClassCounts();\n\n    // The update event is just a change signal; re-read the regions from the\n    // visualizer rather than parsing whatever payload it carries.\n    this.regionApi\n      .getRegionUpdateEvent()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(() => {\n        if (this._updatingFromEditor) return;\n        const updated = this.applyRegionColors(this.regionApi.getAnnotationRegions());\n        // preserve selection for regions that still exist (by id, since name\n        // is a user-editable display label and may collide)\n        const selectedIds = new Set(this.selectedRegions.map((r) => r.id));\n        this.regions = updated;\n        this.selectedRegions = updated.filter((r) => selectedIds.has(r.id));\n        this.clampPaginatorFirst();\n        this.syncClassesFromRegions(updated);\n        this.recomputeClassCounts();\n        if (this.volumeView) this.resetVolumes();\n        this.changed();\n        void this.refreshSource();\n      });\n\n    this.regionApi\n      .getRegionSourceView$?.()\n      ?.pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((view) => {\n        if (view?.source !== this.sourceView?.source) this.pickedClass = null;\n        this.sourceView = view;\n        void this.refreshSource();\n      });\n\n    this.regionApi\n      .getRegionStyle$?.()\n      ?.pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((style) => {\n        this.regionsFilled = style.fillOpacity > 0;\n        this.changed();\n      });\n\n    this.regionApi\n      .getVolumeView$?.()\n      ?.pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((volume) => {\n        const counting = this.stackCounts;\n        this.volumeView = volume;\n        this.resetVolumes();\n        this.changed();\n        if (this.stackCounts !== counting) void this.refreshSource();\n      });\n\n    this.regionApi\n      .getRegionsThroughVolume$?.()\n      ?.pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((through) => {\n        this.regionsThroughVolume = through;\n        this.changed();\n      });\n\n    this.regionApi\n      .getSliceEditor$?.()\n      ?.pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((pane) => {\n        const counting = this.stackCounts;\n        this.slicePane = pane;\n        if (this.stackCounts !== counting) void this.refreshSource();\n      });\n\n    // What is shown in 3D: the router clears it when another image is plotted.\n    this.regionApi\n      .getRegionClasses3d$?.()\n      ?.pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((groups) => {\n        this.shown3d = new Map(groups.map((g) => [g.key, [...g.classes]]));\n        this.shown3dNames = new Set(this.shown3d.keys());\n        this.highlighted3d = '';\n        this.updateSelectionHighlight();\n        this.changed();\n      });\n\n    this.regionApi\n      .getHiddenClasses$?.()\n      ?.pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((hidden) => {\n        this.hiddenClasses = hidden;\n        this.changed();\n      });\n\n    // A surface clicked in the volume view (with the selection tool) picks its class.\n    this.regionApi\n      .getRegionPicked3d$?.()\n      ?.pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe(({ key, additive }) => this.onPicked3d(key, additive));\n\n    this.persistence\n      .fileExists(this.saveAsCheck$)\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((exists) => {\n        this.saveAsFileExists = exists;\n        this.changed();\n      });\n\n    // Physical pixel size of the active image (for region areas in µm²/mm²).\n    this.regionApi\n      .getImageMeta()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((meta) => {\n        this.mpp = pickMpp(meta);\n        this.changed();\n      });\n\n    this.regionApi\n      .getSelectedRegions$()\n      .pipe(takeUntilDestroyed(this.destroyRef))\n      .subscribe((selected) => {\n        if (this._suppressSelectionSyncToPlot) return;\n        // Map the contract's selected regions to the editor's own instances by id.\n        const next = selected.map((s) => this.regions.find((r) => r.id === s.id)).filter((r): r is Region => !!r);\n        const same =\n          next.length === this.selectedRegions.length &&\n          next.every((r, i) => r.id === this.selectedRegions[i]?.id);\n        if (!same) this.selectedRegions = next;\n        this.updateSelectionHighlight();\n        // Scroll the paginator so the most-recently-selected row is visible.\n        if (next.length > 0) {\n          const lastIdx = this.regions.findIndex((r) => r.id === next[next.length - 1].id);\n          if (lastIdx >= 0) {\n            const pageStart = Math.floor(lastIdx / this.paginatorRows) * this.paginatorRows;\n            if (pageStart !== this.paginatorFirst) this.paginatorFirst = pageStart;\n          }\n        }\n        this.changed();\n      });\n  }\n\n  /** Cancels a running GeoJSON save (aborts its upload) and mask export (terminates\n   *  its worker); the API subscriptions end through `takeUntilDestroyed`. */\n  ngOnDestroy() {\n    this._saveAsSub?.unsubscribe();\n    this.maskJob?.unsubscribe();\n  }\n\n  /**\n   * Table → Plot: PrimeNG fires onRowSelect/onRowUnselect after updating\n   * `selectedRegions`. Push the selected regions to the contract by identity —\n   * the package maps them to its internal index space (which includes the\n   * intensity-profile lines the editor never sees).\n   */\n  protected onSelectionChanged() {\n    const selected = this.selectedRegions ?? [];\n    // Rows picked in the table replace the class tree's pick.\n    this.pickedClasses = [];\n    this.updateSelectionHighlight();\n    const fromSource = selected.filter((r) => this.standIns.has(r));\n    this._suppressSelectionSyncToPlot = true;\n    try {\n      this.regionApi.setSelectedRegions(selected.filter((r) => !this.standIns.has(r)));\n    } finally {\n      this._suppressSelectionSyncToPlot = false;\n    }\n    // A selected source row is taken into the regions (and so selected on the image too).\n    if (fromSource.length) void this.regionApi.selectSourceFeatures?.(this.sourceIds(fromSource), true);\n  }\n\n  // ── The region source's features as table rows ───────────────────────\n\n  /** Whether the slice has a region source: it then has regions to save even with an empty table. */\n  protected get hasRegionSource(): boolean {\n    return !!this.sourceView;\n  }\n\n  /** Rows in the table: the regions, then the features still in the region source. */\n  protected get tableTotal(): number {\n    return this.regions.length + this.sourceTotal;\n  }\n\n  /** The class hierarchy of the slice's region source, when it has one (the classes as a tree). */\n  protected get classHierarchy(): RegionClassNode[] | null {\n    return this.sourceView?.source.info.hierarchy ?? null;\n  }\n\n  /** Whether `row` is a region-source feature's stand-in rather than a region. */\n  protected isSourceRow(row: Region): boolean {\n    return this.standIns.has(row);\n  }\n\n  private sourceIds(rows: Region[]): string[] {\n    return rows.map((r) => r.sourceId).filter((id): id is string => !!id);\n  }\n\n  /** A table row for a source feature: no geometry until it is taken. */\n  private standIn(row: RegionIndexRow): Region {\n    const r = Object.assign(new Region(), {\n      id: -++this.standInSeq,\n      name: row.label ?? row.id,\n      label: row.label ?? undefined,\n      color: this.sourceView?.colorOf(row) ?? row.color ?? this.shapeColor,\n      sourceId: row.id,\n      sourceArea: row.area,\n      bounds: null,\n    });\n    this.standIns.add(r);\n    return r;\n  }\n\n  /**\n   * Re-read the source part of the table (the stand-ins on the current page, the count) and the\n   * source's class counts. The page holds regions first, so its source rows start at\n   * `max(first, regions)` − regions.\n   */\n  private async refreshSource(): Promise<void> {\n    if (!this.isActive) return;\n    const request = ++this.sourceRequest;\n    const view = this.sourceView;\n    let rows: RegionIndexRow[] = [];\n    let total = 0;\n    let counts: Record<string, number> = {};\n    if (view && this.regionApi.getRegionSourceIndex) {\n      const own = this.regions.length;\n      const start = Math.max(this.paginatorFirst, own);\n      const limit = Math.max(0, this.paginatorFirst + this.paginatorRows - start);\n      try {\n        const [page, perClass] = await Promise.all([\n          this.regionApi.getRegionSourceIndex({ offset: start - own, limit }),\n          this.regionApi.getRegionSourceClassCounts?.(this.stackCounts),\n        ]);\n        rows = page?.rows ?? [];\n        total = page?.total ?? 0;\n        counts = perClass ?? {};\n      } catch (err) {\n        console.warn('[regions] could not list the region source', err);\n      }\n    }\n    if (request !== this.sourceRequest) return;\n    this.sourceTotal = total;\n    this.sourceRows = rows.map((r) => this.standIn(r));\n    this.sourceClassCounts = counts;\n    this.recomputeClassCounts();\n    this.changed();\n  }\n\n  /** Take a source row's feature into the regions, then run `then` on the region it became. */\n  private async takeThen(row: Region, then: (region: Region) => void): Promise<void> {\n    const [id] = (await this.regionApi.selectSourceFeatures?.(this.sourceIds([row]))) ?? [];\n    const region = this.regions.find((r) => r.id === id);\n    if (region) then(region);\n  }\n\n  /** Toggle the filled (atlas) look: each region filled in its colour, labels inside. */\n  /** In a volume view: the regions drawn through the volume, or hidden behind what it shows. */\n  protected toggleThroughVolume(): void {\n    this.regionApi.setRegionsThroughVolume?.(!this.regionsThroughVolume);\n  }\n\n  protected toggleFill(): void {\n    this.regionApi.setRegionStyle?.({ fillOpacity: this.regionsFilled ? 0 : REGION_FILL_OPACITY });\n  }\n\n  /**\n   * Show or hide a class in the volume view as a 3D reconstruction — a tree node with every class\n   * under it, as one surface in its colour.\n   */\n  protected toggleClass3d(name: string, classes: string[] = [name]): void {\n    const next = new Map(this.shown3d);\n    if (next.has(name)) next.delete(name);\n    else next.set(name, classes);\n    this.shown3d = next;\n    this.shown3dNames = new Set(next.keys());\n    this.changed();\n    this.show3d(this.groups3d());\n    this.updateSelectionHighlight();\n  }\n\n  /** Hide (or show again) these classes' regions, wherever they are drawn. */\n  protected setClassesHidden(classes: readonly string[], hidden: boolean): void {\n    this.regionApi.setClassesHidden?.(classes, hidden);\n  }\n\n  /** The surfaces shown in 3D, in their classes' colours now. */\n  private groups3d(): Array<{ key: string; classes: string[]; color: string; label: string }> {\n    const titles = new Map((this.classHierarchy ?? []).map((n) => [n.name, n.title]));\n    return [...this.shown3d].map(([key, classes]) => {\n      const title = titles.get(key);\n      return { key, classes, color: this.treeColor(key), label: title ? `${key} · ${title}` : key };\n    });\n  }\n\n  /** The classes selected now: the class tree's pick (with its subtree) and the selected rows'. */\n  private selectedClassNames(): Set<string> {\n    const names = new Set(this.pickedClasses);\n    for (const r of this.selectedRegions ?? []) if (r.label) names.add(r.label);\n    return names;\n  }\n\n  /**\n   * Highlight, in the volume view, the surfaces holding a selected class (focus + context: they\n   * turn near opaque, the others fade), and mark the selected rows' classes in the class lists.\n   */\n  private updateSelectionHighlight(): void {\n    const names = this.selectedClassNames();\n    const marked = new Set((this.selectedRegions ?? []).map((r) => r.label).filter((l): l is string => !!l));\n    if ([...marked].join('\\n') !== [...this.markedClasses].join('\\n')) this.markedClasses = marked;\n    const keys = [...this.shown3d].filter(([, classes]) => classes.some((c) => names.has(c))).map(([k]) => k);\n    const id = keys.join('\\n');\n    if (id === this.highlighted3d) return;\n    this.highlighted3d = id;\n    this.regionApi.highlightRegionClasses3d?.(keys);\n  }\n\n  /** A surface clicked in the volume view: pick its class as the tree would; beside them, clear. */\n  private onPicked3d(key: string | null, additive: boolean): void {\n    if (key === null) {\n      if (additive) return;\n      this.pickedClass = null;\n      this.pickedClasses = [];\n      this.selectedRegions = [];\n      this.onSelectionChanged();\n      this.changed();\n      return;\n    }\n    void this.pickClasses({ name: key, classes: this.shown3d.get(key) ?? [key], additive });\n  }\n\n  /** A class colour changed (its swatch, or Manage): repaint the surfaces shown in 3D whose colour it changed. */\n  private recolor3d(): void {\n    const groups = this.groups3d();\n    if (!groups.some((g) => g.color !== this.colors3d.get(g.key))) return;\n    this.show3d(groups);\n  }\n\n  private show3d(groups: Array<{ key: string; classes: string[]; color: string }>): void {\n    this.colors3d = new Map(groups.map((g) => [g.key, g.color]));\n    this.regionApi.showRegionClasses3d?.(groups).catch((err) => {\n      this.toast('error', 'Could not show the region in 3D', `${(err as Error)?.message ?? err}`);\n    });\n  }\n\n  /** Pick a class in the class tree: select its regions and its subclasses', the source's taken. */\n  protected async pickClasses(pick: ClassTreePick): Promise<void> {\n    this.pickedClass = pick.name;\n    this.pickedClasses = pick.additive ? [...new Set([...this.pickedClasses, ...pick.classes])] : pick.classes;\n    this.updateSelectionHighlight();\n    this.changed();\n    await this.regionApi.selectRegionClasses?.(pick.classes, pick.additive);\n  }\n\n  /**\n   * Rows for regions coming from the visualizer: neutral `Region`s with bounds,\n   * colour and label already populated. A region without a colour is shown with\n   * its classification colour (or the default shape colour) — as a copy: the\n   * store's instances are shared with its undo history and must not be changed\n   * in place (RT-1).\n   */\n  private applyRegionColors(regions: Region[]): Region[] {\n    const classColors = this.regionApi.getClassificationColors();\n    return regions.map((region) =>\n      region.color\n        ? region\n        : withRegionPatch(region, { color: classColors.get(region.label ?? '') || this.shapeColor }),\n    );\n  }\n\n  /**\n   * The editor's one write path (RT-1): make `next` the table's rows and commit\n   * them to the store — live, as one undoable step (isRegionSaveOn=true; the\n   * router keeps the intensity-profile lines). Rows are the store's instances,\n   * so an edit passes copies ({@link patchRegions}), never changed rows. The\n   * resulting region-update event is ignored (`_updatingFromEditor`), so the\n   * class list and counts are refreshed here (a typed class is added; jit-ui#70).\n   */\n  private commit(next: Region[] = this.regions): void {\n    this.regions = next;\n    this._updatingFromEditor = true;\n    try {\n      this.regionApi.setAnnotationRegions(next, this.showShapeLabel, true, this.fillColor);\n    } finally {\n      this._updatingFromEditor = false;\n    }\n    this.syncClassesFromRegions(next);\n    this.recomputeClassCounts();\n    this.changed();\n  }\n\n  /**\n   * Copy-on-write edit (review RT-1). The editor's rows are the region store's\n   * live instances, and the store takes its undo snapshot only when the edit is\n   * committed — so an edit must replace a region with a patched copy (and any\n   * bounds it changes with new bounds), never mutate the instance the store\n   * holds. Returns the copies by original; the selection and an open label edit\n   * follow them.\n   */\n  private patchRegions(patchFor: (r: Region) => Partial<Region> | null): Map<Region, Region> {\n    const copies = new Map<Region, Region>();\n    this.regions = this.regions.map((r) => {\n      const patch = patchFor(r);\n      if (!patch) return r;\n      const copy = withRegionPatch(r, patch);\n      copies.set(r, copy);\n      return copy;\n    });\n    if (copies.size) {\n      this.selectedRegions = (this.selectedRegions ?? []).map((r) => copies.get(r) ?? r);\n      if ([...copies.keys()].some((r) => this.editingLabelRegions.has(r))) {\n        this.editingLabelRegions = new Map([...this.editingLabelRegions].map(([r, d]) => [copies.get(r) ?? r, d]));\n      }\n    }\n    return copies;\n  }\n\n  /** Set one region's outline colour (an explicit override) and commit live. */\n  protected changeRegionColor(region: Region, color: string): void {\n    if (!color || region.color === color) return;\n    // colorOverridden: explicit per-region colour — preserve it against preset (re)apply (jit-ui#70)\n    this.patchRegions((r) => (r === region ? { color, colorOverridden: true } : null));\n    this.commit();\n  }\n\n  /**\n   * After a label edit on `region`: give every labelled row without a colour its\n   * class colour (preset or fallback, as the store will), and commit when\n   * `commit` is set.\n   */\n  protected labelRegionUpdate(region: Region, commit = false) {\n    this.fillClassColors();\n    if (commit) this.commit();\n  }\n\n  /** Labelled rows without a colour get their class colour (copies). */\n  private fillClassColors(): void {\n    this.patchRegions((r) => (!r.color && r.label ? { color: this.colorForName(r.label) } : null));\n  }\n\n  /** The current page of the table. Memoized on (regions, first, rows), so\n   *  change detection doesn't hand p-table a new array every tick (RT-20). */\n  protected get pagedRegions(): Region[] {\n    const key = this._pageKey;\n    if (\n      key.regions !== this.regions ||\n      key.source !== this.sourceRows ||\n      key.first !== this.paginatorFirst ||\n      key.rows !== this.paginatorRows\n    ) {\n      this._pageKey = {\n        regions: this.regions,\n        source: this.sourceRows,\n        first: this.paginatorFirst,\n        rows: this.paginatorRows,\n      };\n      const own = this.regions.slice(this.paginatorFirst, this.paginatorFirst + this.paginatorRows);\n      this._page =\n        own.length >= this.paginatorRows\n          ? own\n          : [...own, ...this.sourceRows.slice(0, this.paginatorRows - own.length)];\n      // A new page may show classes whose volume is not known yet (after this check).\n      if (this.volumeView) queueMicrotask(() => this.requestVolumes());\n    }\n    return this._page;\n  }\n\n  /** In a volume view, each class's volume over the whole stack, for the table (null: areas). */\n  protected tableVolumes: ReadonlyMap<string, number | null> | null = null;\n  /** Bumped when the regions change, so a volume computed before is dropped. */\n  private volumeRequest = 0;\n\n  /** Compute the volumes of the classes on the table's page that are not known yet. */\n  private requestVolumes(): void {\n    const api = this.regionApi.getClassVolumes?.bind(this.regionApi);\n    // Closed: asked for again when it opens (see active).\n    if (!this.isActive) return;\n    if (!this.volumeView || !api) {\n      if (this.tableVolumes) {\n        this.tableVolumes = null;\n        this.changed();\n      }\n      return;\n    }\n    const known = this.tableVolumes ?? new Map<string, number | null>();\n    const labels = new Set(this.pagedRegions.map((r) => r.label).filter((l): l is string => !!l));\n    const missing = [...labels].filter((l) => !known.has(l));\n    if (!missing.length && this.tableVolumes) return;\n    this.tableVolumes = new Map([...known, ...missing.map((l): [string, null] => [l, null])]);\n    this.changed();\n    if (!missing.length) return;\n    const request = this.volumeRequest;\n    api(missing).then(\n      (volumes) => {\n        if (request !== this.volumeRequest || !this.tableVolumes) return;\n        this.tableVolumes = new Map([...this.tableVolumes, ...Object.entries(volumes)]);\n        this.changed();\n      },\n      (err) => {\n        if (request !== this.volumeRequest || !this.tableVolumes) return;\n        // Leave them unknown ('—') rather than computing forever.\n        const next = new Map(this.tableVolumes);\n        for (const l of missing) next.delete(l);\n        this.tableVolumes = next;\n        this.changed();\n        console.warn('[regions] could not compute class volumes', err);\n      },\n    );\n  }\n\n  /** The regions changed (or the view did): forget the volumes and compute the page's again. */\n  private resetVolumes(): void {\n    this.volumeRequest++;\n    this.tableVolumes = null;\n    this.requestVolumes();\n  }\n  private _pageKey: { regions?: Region[]; source?: Region[]; first?: number; rows?: number } = {};\n  private _page: Region[] = [];\n\n  protected onPageChange(event: { first?: number; rows?: number }) {\n    this.paginatorFirst = event.first ?? 0;\n    this.paginatorRows = event.rows ?? this.paginatorRows;\n    void this.refreshSource();\n  }\n\n  /** Select every region in the table (and highlight them on the diagram), the source's taken. */\n  protected async selectAllRegions() {\n    this.selectedRegions = [...this.regions];\n    this.onSelectionChanged();\n    if (!this.sourceTotal || !this.regionApi.getRegionSourceIndex) return;\n    const page = await this.regionApi.getRegionSourceIndex({ offset: 0, limit: SELECT_ALL_SOURCE_LIMIT });\n    const ids = (page?.rows ?? []).map((r) => r.id);\n    if (ids.length) await this.regionApi.selectSourceFeatures?.(ids, true);\n  }\n\n  protected deleteSelectedRegions() {\n    if (this.selectedRegions && this.selectedRegions.length > 0) {\n      const fromSource = this.selectedRegions.filter((r) => this.standIns.has(r));\n      if (fromSource.length) this.regionApi.deleteSourceFeatures?.(this.sourceIds(fromSource));\n      // Filter by id — object identity isn't reliable across re-parses,\n      // and name is a user-editable label that may collide.\n      const removed = new Set(this.selectedRegions.map((r) => r.id));\n      this.selectedRegions = [];\n      this.commit(this.regions.filter((r) => !removed.has(r.id)));\n      this.clampPaginatorFirst();\n      // Sync the cleared selection with the plot's highlight state.\n      this.onSelectionChanged();\n    }\n  }\n\n  protected clearAllRegions() {\n    this.confirmationService.confirm({\n      key: 'positionDialog',\n      message: 'Are you sure you want to delete all regions?',\n      accept: () => {\n        this.selectedRegions = [];\n        this.paginatorFirst = 0;\n        this.commit([]);\n        this.onSelectionChanged();\n        if (this.hasRegionSource) void this.deleteAllSourceFeatures();\n      },\n    });\n  }\n\n  /** Delete every feature still in the slice's region source (with \"Delete all regions\"). */\n  private async deleteAllSourceFeatures(): Promise<void> {\n    const index = this.regionApi.getRegionSourceIndex;\n    if (!index || !this.regionApi.deleteSourceFeatures) return;\n    const page = await index.call(this.regionApi, { offset: 0, limit: Number.MAX_SAFE_INTEGER });\n    if (page?.rows.length) this.regionApi.deleteSourceFeatures(page.rows.map((r) => r.id));\n  }\n\n  protected deleteRegion(shapeIdx: number) {\n    // A row past the regions is a source feature: delete it from the source.\n    if (shapeIdx >= this.regions.length) {\n      const row = this.sourceRows[shapeIdx - Math.max(this.paginatorFirst, this.regions.length)];\n      if (row) this.regionApi.deleteSourceFeatures?.(this.sourceIds([row]));\n      return;\n    }\n    const removed = this.regions[shapeIdx];\n    if (removed) {\n      this.selectedRegions = this.selectedRegions.filter((r) => r.id !== removed.id);\n    }\n    this.commit(this.regions.filter((_, i) => i !== shapeIdx));\n    this.clampPaginatorFirst();\n    // Re-emit the (possibly trimmed) selection so the plot's highlight stays\n    // in sync with what's still in the table.\n    this.onSelectionChanged();\n  }\n\n  private clampPaginatorFirst() {\n    const maxFirst = Math.max(0, Math.floor((this.tableTotal - 1) / this.paginatorRows) * this.paginatorRows);\n    if (this.paginatorFirst > maxFirst) {\n      this.paginatorFirst = maxFirst;\n    }\n  }\n  protected changeShowShapeLabel(showLabel: boolean) {\n    this.commit();\n  }\n\n  protected isEditingLabel(region: Region): boolean {\n    return this.editingLabelRegions.has(region);\n  }\n\n  protected startEditLabel(region: Region, event?: Event): void {\n    event?.stopPropagation(); // don't toggle row selection\n    if (this.standIns.has(region)) {\n      void this.takeThen(region, (r) => this.startEditLabel(r));\n      return;\n    }\n    // A new map per start/stop, so the OnPush table sees the change.\n    this.editingLabelRegions = new Map(this.editingLabelRegions).set(region, region.label ?? '');\n  }\n\n  /** The label typed so far for a row in edit mode (no re-render needed). */\n  protected setLabelDraft(region: Region, value: string): void {\n    if (this.editingLabelRegions.has(region)) this.editingLabelRegions.set(region, value);\n  }\n\n  protected stopEditLabel(region: Region, commit: boolean, event?: Event): void {\n    event?.stopPropagation();\n    const draft = this.editingLabelRegions.get(region);\n    if (this.editingLabelRegions.has(region)) {\n      const next = new Map(this.editingLabelRegions);\n      next.delete(region);\n      this.editingLabelRegions = next;\n    }\n    if (commit) {\n      // A changed label commits as a replacement region, so it is undoable (RT-1).\n      const edited =\n        draft !== undefined && draft !== region.label\n          ? (this.patchRegions((r) => (r === region ? { label: draft } : null)).get(region) ?? region)\n          : region;\n      this.labelRegionUpdate(edited, true);\n    }\n  }\n\n  /** Region area for display (µm²/mm² when the image is scaled, else px²);\n   *  empty for a degenerate region. See `region-metrics`. */\n  protected regionArea(region: Region): string {\n    return formatArea(regionAreaPx(region), this.mpp);\n  }\n\n  /**\n   * This method rounds all the rectangle regions lengths to multiple of 512\n   */\n  protected roundRectangleLengths() {\n    this.patchRegions((region) => {\n      const rect = region.bounds;\n      if (!(rect instanceof Rectangle)) return null;\n      return {\n        bounds: Object.assign(new Rectangle(), rect, {\n          height: Math.round(rect.height / 512) * 512,\n          width: Math.round(rect.width / 512) * 512,\n        }),\n      };\n    });\n    this.commit();\n  }\n\n  protected showHelp() {\n    this.displayHelpDialog = true;\n  }\n\n  /** Open the colour dialog for the currently-selected region(s), building one\n   *  colour picker per unique class in the selection. Each picker is seeded with\n   *  the first selected region of that class's colour (else the class colour). */\n  protected openColorDialog() {\n    if (!this.selectedRegions?.length) return;\n    const seedByLabel = new Map<string, string>();\n    for (const region of this.selectedRegions) {\n      const label = region.label?.trim() ?? '';\n      if (seedByLabel.has(label)) continue;\n      seedByLabel.set(label, region.color ?? (label ? this.colorForName(label) : this.shapeColor));\n    }\n    this.classColorEdits = [...seedByLabel].map(([label, color]) => ({ label, color }));\n    this.showColorDialog = true;\n  }\n\n  /** Apply each class's chosen colour to the selected regions of that class (an\n   *  explicit override) and commit live. */\n  protected applyColorToSelected(edits: ClassColorEdit[] = this.classColorEdits) {\n    const colorByLabel = new Map(edits.map((e) => [e.label, e.color]));\n    const selected = new Set(this.selectedRegions ?? []);\n    this.patchRegions((region) => {\n      if (!selected.has(region)) return null;\n      const label = region.label?.trim() ?? '';\n      const color = colorByLabel.get(label);\n      if (!color) return null;\n      // explicit colour — preserve against preset (re)apply (jit-ui#70)\n      return { color, colorOverridden: true };\n    });\n    this.commit();\n    this.showColorDialog = false;\n  }\n\n  // ── annotation-class presets (jit-ui#70) ─────────────────────────────\n\n  /** Resolve the display colour for a class name (preset colour or deterministic fallback). */\n  protected colorForName(name?: string): string {\n    return name ? colorForLabel(name, this.presetSet) : this.shapeColor;\n  }\n\n  /**\n   * Ensure every class label present in the loaded regions exists in the preset\n   * list, auto-adding any that are missing (using the region's already-resolved\n   * colour). This makes classes carried in a loaded/imported GeoJSON show up as\n   * chips + Class-dropdown options (a p-dropdown can't display a value that isn't\n   * an option) and lets the user manage them. The placeholder 'legend' and empty\n   * labels are ignored. (jit-ui#70)\n   */\n  private syncClassesFromRegions(regions: Region[]): void {\n    const keyOf = (l: string) => presetKey(this.presetSet, l);\n    const known = new Set(this.presetSet.classes.map((c) => keyOf(c.name)));\n    const added = new Set<string>();\n    for (const r of regions) {\n      const label = r.label?.trim();\n      if (!label || label === 'legend') continue;\n      const k = keyOf(label);\n      if (known.has(k) || added.has(k)) continue;\n      added.add(k);\n      this.regionApi.upsertClass({\n        name: label,\n        color: r.color || colorForLabel(label, this.presetSet),\n        source: 'auto',\n      });\n    }\n  }\n\n  // ── Docked Classes panel (jit-ui#70) ─────────────────────────────────\n\n  /**\n   * Whether the classes count every slice of the stack: in a volume view (the whole stack on\n   * screen), unless its slice pane shows one slice. The table lists the slice's regions anyway.\n   */\n  private get stackCounts(): boolean {\n    return this.volumeView && !this.slicePane;\n  }\n\n  /** Rebuild the per-class region counts shown in the panel (the stack's, see stackCounts). */\n  private recomputeClassCounts(): void {\n    const counts = new Map<string, number>();\n    const tree = new Map<string, number>();\n    const add = (label: string, n: number) => {\n      const k = presetKey(this.presetSet, label);\n      counts.set(k, (counts.get(k) ?? 0) + n);\n      tree.set(label, (tree.get(label) ?? 0) + n);\n    };\n    const regions = this.stackCounts ? this.regionApi.getSliceAnnotationRegions() : this.regions;\n    for (const r of regions) if (r.label) add(r.label, 1);\n    // The region source's classes count too (its features are rows of the table).\n    for (const [label, n] of Object.entries(this.sourceClassCounts)) add(label, n);\n    this.classCounts = counts;\n    this.treeCounts = tree;\n    this.updateDisplayClasses();\n  }\n\n  /** Rebuild the panel's display order — most-used classes first, then by name. A class only\n   *  the region source has is listed too, in its colour. */\n  private updateDisplayClasses(): void {\n    const known = new Set(this.presetSet.classes.map((c) => presetKey(this.presetSet, c.name)));\n    const fromSource: ClassPreset[] = [];\n    for (const label of Object.keys(this.sourceClassCounts)) {\n      const k = presetKey(this.presetSet, label);\n      if (known.has(k)) continue;\n      known.add(k);\n      fromSource.push({ name: label, color: colorForLabel(label, this.presetSet) });\n    }\n    this.tablePresetSet = fromSource.length\n      ? { ...this.presetSet, classes: [...this.presetSet.classes, ...fromSource] }\n      : this.presetSet;\n    this.displayClasses = [...this.presetSet.classes, ...fromSource].sort((a, b) => {\n      const d = this.classCount(b.name) - this.classCount(a.name);\n      return d !== 0 ? d : a.name.localeCompare(b.name);\n    });\n  }\n\n  /** Number of regions currently using a class (keyed by the active match mode). */\n  protected classCount(name: string): number {\n    return this.classCounts.get(presetKey(this.presetSet, name)) ?? 0;\n  }\n\n  /** Recolour a class from its panel swatch and repaint its (non-overridden) regions. */\n  protected setClassColor(name: string, color: string): void {\n    if (!color) return;\n    this.regionApi.setClassificationColor(name, color);\n    this.commit();\n  }\n\n  /** Remove a class. Any regions still using it fall back to the default\n   *  \"Region\" class, so they aren't orphaned (and the class isn't immediately\n   *  re-added from its regions by syncClassesFromRegions). */\n  protected deleteClass(name: string): void {\n    this.reassignRegionsToDefaultClass([name]);\n    this.regionApi.removeClass(name);\n    if (this.activeClass === name) this.activeClass = null;\n    this.commit();\n  }\n\n  /** Regions labelled with any of `removedNames` revert to the default\n   *  {@link defaultClassName} (\"Region\"): its class colour, override cleared.\n   *  Skips the default itself so deleting \"Region\" can't self-reassign. (jit-ui#70) */\n  private reassignRegionsToDefaultClass(removedNames: string[]): void {\n    const keyOf = (s: string) => presetKey(this.presetSet, s);\n    const removed = new Set(removedNames.map(keyOf));\n    removed.delete(keyOf(this.defaultClassName));\n    if (!removed.size) return;\n    const color = colorForLabel(this.defaultClassName, this.presetSet);\n    this.patchRegions((r) =>\n      r.label && removed.has(keyOf(r.label))\n        ? { label: this.defaultClassName, colorOverridden: false, color }\n        : null,\n    );\n  }\n\n  /** Stamp a class (and its preset/fallback colour) onto one region from the Class\n   *  dropdown; choosing a class opts the region back into the preset colour. */\n  protected applyPresetToRegion(region: Region, className: string): void {\n    if (this.standIns.has(region)) {\n      void this.takeThen(region, (r) => this.applyPresetToRegion(r, className));\n      return;\n    }\n    const name = (className ?? '').trim();\n    const patch: Partial<Region> = { label: name, colorOverridden: false };\n    if (name) patch.color = colorForLabel(name, this.presetSet);\n    this.patchRegions((r) => (r === region ? patch : null));\n    this.commit();\n  }\n\n  /** Make a class active (used for new regions) and, if rows are selected, apply\n   *  it to them in one commit. */\n  protected selectActiveClass(name: string): void {\n    this.activeClass = name;\n    this.applyClassToSelected(name);\n  }\n\n  /** Apply a class (label + preset/fallback colour) to the current selection and commit. */\n  private applyClassToSelected(name: string): void {\n    const selected = new Set(this.selectedRegions ?? []);\n    if (!selected.size) return;\n    const color = colorForLabel(name, this.presetSet);\n    this.patchRegions((r) => (selected.has(r) ? { label: name, colorOverridden: false, color } : null));\n    this.commit();\n  }\n\n  /** \"Edit class on selected rows\" popup — apply the chosen existing class. */\n  protected applyBulkClass(): void {\n    if (!this.bulkClass) return;\n    this.applyClassToSelected(this.bulkClass);\n    this.overlayPanel?.hide();\n  }\n\n  /** \"Edit class on selected rows\" popup — add a new class and set it on the selection. */\n  protected addAndApplyBulkClass(): void {\n    const name = this.newBulkClass.trim();\n    if (!name) return;\n    const key = presetKey(this.presetSet, name);\n    const exists = this.presetSet.classes.some((c) => presetKey(this.presetSet, c.name) === key);\n    if (!exists) {\n      this.regionApi.upsertClass({ name, color: colorForLabel(name, this.presetSet), source: 'user' });\n    }\n    this.applyClassToSelected(name);\n    this.bulkClass = name;\n    this.newBulkClass = '';\n    this.overlayPanel?.hide();\n  }\n\n  // ── Manage-classes dialog ──\n  protected openManageDialog(): void {\n    this.presetDraft = this.clonePresetSet(this.presetSet);\n    this.showManageDialog = true;\n  }\n  private clonePresetSet(s: PresetSet): PresetSet {\n    return {\n      classes: (s.classes ?? []).map((c) => ({ ...c })),\n      fallbackPalette: [...(s.fallbackPalette ?? [])],\n      autoPromote: !!s.autoPromote,\n      matchMode: s.matchMode === 'normalized' ? 'normalized' : 'exact',\n    };\n  }\n  /** Commit the draft: drop blank/duplicate names, persist, and recolour\n   *  non-overridden regions with the updated presets. */\n  protected applyManageDialog(close: boolean): void {\n    if (!this.presetDraft) return;\n    // De-duplicate using the active match mode's key so normalized mode can't keep\n    // both \"Tumor\" and \"tumor\" (which would collide at runtime in findPreset()).\n    const draft = this.presetDraft;\n    const keyOf = (s: string) => presetKey(draft, s);\n    const seen = new Set<string>();\n    const classes: ClassPreset[] = [];\n    for (const c of draft.classes) {\n      const name = (c.name ?? '').trim();\n      const key = keyOf(name);\n      if (!name || seen.has(key)) continue;\n      seen.add(key);\n      classes.push({ ...c, name });\n    }\n    this.presetDraft = { ...draft, classes };\n    // Classes dropped in the dialog: their regions revert to the default \"Region\"\n    // class (else syncClassesFromRegions would just re-add them) (jit-ui#70).\n    const kept = new Set(classes.map((c) => keyOf(c.name)));\n    const removed = this.presetSet.classes.map((c) => c.name).filter((n) => !kept.has(keyOf(n)));\n    this.reassignRegionsToDefaultClass(removed);\n    this.regionApi.setPresetSet(this.presetDraft);\n    this.commit(); // recolour existing (non-overridden) regions from the new presets\n    if (close) this.showManageDialog = false;\n  }\n  protected resetPresetsToDefaults(): void {\n    this.regionApi.resetPresets();\n    this.presetDraft = this.clonePresetSet(this.regionApi.getPresetSet());\n    this.commit();\n  }\n  protected exportPresets(): void {\n    const json = JSON.stringify(this.clonePresetSet(this.regionApi.getPresetSet()), null, 2);\n    saveAs(new Blob([json], { type: 'application/json' }), 'annotation-classes.json');\n  }\n  protected importPresets(event: Event): void {\n    this.persistence.readChosenFile(event, (text) => this.applyImportedPresets(text));\n  }\n\n  /** Validate and apply an imported annotation-classes JSON file. */\n  private applyImportedPresets(text: string): void {\n    try {\n      const set = parsePresetSet(JSON.parse(text));\n      if (!set) throw new Error('The file is not an annotation-class list (no valid classes).');\n      this.regionApi.setPresetSet(set);\n      this.presetDraft = this.clonePresetSet(this.regionApi.getPresetSet());\n      this.commit();\n      this.messageService.add({\n        key: VIZ_TOAST_KEY,\n        severity: 'success',\n        summary: 'Classes imported',\n        detail: 'Annotation classes loaded.',\n      });\n    } catch (err) {\n      this.messageService.add({\n        key: VIZ_TOAST_KEY,\n        severity: 'error',\n        summary: 'Import failed',\n        detail: `${(err as Error)?.message ?? err}`,\n      });\n    }\n    this.changed();\n  }\n\n  /** The files chosen in the import inputs: one GeoJSON, a label volume with its ontology, or a\n   *  folder of per-slice GeoJSON files. */\n  protected importRois(event: Event) {\n    const files = Array.from((event.target as HTMLInputElement).files ?? []);\n    if (files.length) void this.importRegionFiles(files.map((f) => importFile(f, f.webkitRelativePath || f.name)));\n  }\n\n  /** Whether the host can pick regions on its server (\"Import regions from server\"). */\n  protected get canImportFromServer(): boolean {\n    return this.persistence.canPickServerRegions();\n  }\n  /** An import from the server is in flight. */\n  protected importing = false;\n\n  /** \"Import regions from server\": the host picks files or a served region set; they import as chosen files do. */\n  protected importFromServer(): void {\n    this.importing = true;\n    this.changed();\n    this.persistence.pickServerRegions().subscribe({\n      next: (pick) => {\n        if (!pick) return;\n        if (pick.kind === 'files') {\n          void this.importRegionFiles(pick.files.map((f) => importFile(f.data, f.name)));\n          return;\n        }\n        void this.importServedRegionSet(pick.url, pick.name);\n      },\n      error: (err) => this.importFailed(err),\n      complete: () => {\n        this.importing = false;\n        this.changed();\n      },\n    });\n  }\n\n  /**\n   * Import `files` (see planRegionImport): one GeoJSON file as before; a label volume as one\n   * region source per slice, traced from it the first time the slice is shown, its classes named\n   * (and treed) by the ontology chosen with it; a folder as one source per slice file. Either\n   * replaces the regions and sources of every slice.\n   */\n  private async importRegionFiles(files: RegionImportFile[]): Promise<void> {\n    const plan = planRegionImport(files);\n    if (!plan) {\n      this.importFailed(\n        new Error('Choose a GeoJSON file, a folder of GeoJSON files, or a .nii, .nii.gz or .nrrd label volume.'),\n      );\n      return;\n    }\n    if (plan.kind === 'single') {\n      await this.applyImportedRois(await plan.file.text());\n      return;\n    }\n    const attach = this.regionApi.importSliceRegionSources?.bind(this.regionApi);\n    if (!attach) {\n      this.importFailed(new Error('This viewer cannot hold region sources.'));\n      return;\n    }\n    // Taken before the files are read: decoding a volume takes a while, and the import must land\n    // on the image it was started for, not on one shown meanwhile.\n    const ticket = this.regionApi.regionImportTicket?.();\n    try {\n      const openers = new Map<number, RegionSourceOpener>();\n      let summary: string;\n      if (plan.kind === 'volume') {\n        const volume = await readLabelVolume(plan.volume.name, await plan.volume.bytes());\n        const classes = labelClasses(plan.ontology ? JSON.parse(await plan.ontology.text()) : undefined);\n        for (let z = 0; z < volume.slices; z++) {\n          openers.set(z, () => openGeoJsonRegionSource(labelSliceGeoJson(volume, z, classes)));\n        }\n        summary = `${volume.slices} slices of ${volume.width} × ${volume.height}`;\n        this.warnIfSizeDiffers(volume.width, volume.height);\n      } else {\n        const regionSet = plan.regionSet ? JSON.parse(await plan.regionSet.text()) : null;\n        plan.slices.forEach((file, z) =>\n          openers.set(z, async () => openGeoJsonRegionSource(await folderSliceGeoJson(file, regionSet))),\n        );\n        summary = `${plan.slices.length} slice files`;\n      }\n      const attached = attach(openers, ticket);\n      if (attached === null) {\n        this.importStale();\n        return;\n      }\n      this.afterSourceImport();\n      this.toast(\n        'success',\n        'Regions imported',\n        `${summary}; ${attached} slice${attached === 1 ? '' : 's'} annotated.`,\n      );\n    } catch (err) {\n      this.importFailed(err);\n    }\n  }\n\n  /** A region set the host's server serves (jit-service's /regions/{id}/), read through its HttpClient. */\n  private async importServedRegionSet(url: string, name?: string): Promise<void> {\n    const importSource = this.regionApi.importRegionSourceOpener?.bind(this.regionApi);\n    if (!importSource) {\n      this.importFailed(new Error('This viewer cannot hold region sources.'));\n      return;\n    }\n    const ticket = this.regionApi.regionImportTicket?.();\n    try {\n      const applied = await importSource(\n        () => openHttpRegionSource(url, { http: this.http ?? undefined }),\n        ticket,\n      );\n      if (applied === false) {\n        this.importStale();\n        return;\n      }\n      this.afterSourceImport();\n      this.toast('success', 'Regions imported', name ?? url);\n    } catch (err) {\n      this.importFailed(err);\n    }\n  }\n\n  /** An import that finished after another image was shown (or another import began): dropped. */\n  private importStale(): void {\n    this.toast('info', 'Import discarded', 'The image changed while the regions were being read.');\n    this.changed();\n  }\n\n  /** The table and selection after the regions were replaced by imported sources. */\n  private afterSourceImport(): void {\n    this.selectedRegions = [];\n    this.paginatorFirst = 0;\n    this.commit([]);\n    this.onSelectionChanged();\n  }\n\n  /** Warn when an imported volume's slices are not the image's size: its outlines would not fit. */\n  private warnIfSizeDiffers(width: number, height: number): void {\n    const meta = this.regionApi.getMaskImageSize();\n    if (meta && (meta.width !== width || meta.height !== height)) {\n      this.toast(\n        'info',\n        'Different size',\n        `The volume's slices are ${width} × ${height}; the image is ${meta.width} × ${meta.height}.`,\n      );\n    }\n  }\n\n  private importFailed(err: unknown): void {\n    this.importing = false;\n    this.messageService.add({\n      key: VIZ_TOAST_KEY,\n      severity: 'error',\n      summary: 'Error importing regions',\n      detail: `${(err as Error)?.message ?? err}`,\n    });\n    console.error('Error importing regions:', err);\n    this.changed();\n  }\n\n  /**\n   * Replace the regions with an imported GeoJSON file's, and the slice's region source with them.\n   * A large file becomes the slice's region source instead (drawn by level of detail; listed above\n   * the table), the table emptied.\n   */\n  private async applyImportedRois(text: string): Promise<void> {\n    try {\n      if (await this.regionApi.importRegionSource?.(text)) {\n        this.selectedRegions = [];\n        this.paginatorFirst = 0;\n        this.commit([]);\n        this.onSelectionChanged();\n        return;\n      }\n      // Parsed first: a file that is not GeoJSON leaves the source alone.\n      const regions = this.regionApi.importRegions(text);\n      await this.regionApi.dropRegionSource?.();\n      this.regions = regions;\n      this.fillClassColors();\n      this.commit();\n    } catch (err) {\n      this.messageService.add({\n        key: VIZ_TOAST_KEY,\n        severity: 'error',\n        summary: 'Error importing the file',\n        detail: `${(err as Error)?.message ?? err}`,\n      });\n      console.error('Error reading the file:', err);\n    }\n  }\n\n  /** Regions to serialize on save/export (every slice for a combined z-stack). */\n  private regionsForSave(): Region[] {\n    return this.persistence.regionsForSave(this.regions);\n  }\n\n  protected exportRois() {\n    if (!this.regionsForSave().length && !this.hasRegionSource) return;\n    this.exportFilename = this.persistence.defaultExportName();\n    this.showExportDialog = true;\n  }\n\n  protected confirmExport() {\n    const filename = this.exportFilename.trim();\n    const regions = this.regionsForSave();\n    if (!filename || (!regions.length && !this.hasRegionSource)) return;\n    this.showExportDialog = false;\n    this.persistence\n      .download(regions, filename)\n      .catch((err) => this.toast('error', 'Error exporting regions', `${(err as Error)?.message ?? err}`));\n  }\n\n  /** Open the \"Save mask\" dialog, seeded with `<image-stem>_mask.png`. */\n  protected openSaveMaskDialog() {\n    if (!this.regions.length) return;\n    this.saveMaskFilename = this.persistence.defaultMaskName();\n    this.maskMode = 'binary';\n    this.showSaveMaskDialog = true;\n  }\n\n  /**\n   * Rasterize the regions to the chosen mask type and download as a PNG. The\n   * heavy work runs in a Web Worker ({@link MaskExportService}) so the UI never\n   * freezes on whole-slide images and the job can be cancelled (jit-ui#95);\n   * the dialog stays open with a progress bar until done.\n   */\n  protected confirmSaveMask() {\n    const filename = this.saveMaskFilename.trim();\n    if (!filename || !this.regions.length || this.maskBusy) return;\n\n    const size = this.regionApi.getMaskImageSize();\n    if (!size) {\n      this.maskError('No image size is available, so the mask cannot be sized.');\n      return;\n    }\n    this.maskBusy = true;\n    this.maskEncoding = false;\n    this.maskProgress = 0;\n    this.maskJob = this.maskExport\n      .export({\n        regions: this.regions,\n        imageSize: size,\n        mode: this.maskMode,\n        sourceName: this.persistence.selectedFileName(),\n      })\n      .subscribe({\n        next: (e) => {\n          this.changed();\n          switch (e.type) {\n            case 'planned':\n              if (e.scale < 1) {\n                this.messageService.add({\n                  key: VIZ_TOAST_KEY,\n                  severity: 'info',\n                  summary: 'Mask downscaled',\n                  detail: `Image too large for a full-resolution mask; saving at ${e.width}×${e.height}.`,\n                });\n              }\n              break;\n            case 'progress':\n              this.maskProgress = e.percent;\n              break;\n            case 'encoding':\n              this.maskEncoding = true;\n              break;\n            case 'done':\n              this.finishMask(e.blob, filename);\n              break;\n          }\n        },\n        error: (err: Error) => {\n          this.maskError(err.message);\n          this.changed();\n        },\n      });\n  }\n\n  /** Cancel an in-progress mask export (terminates its worker) and reset state. */\n  protected cancelSaveMask() {\n    this.maskJob?.unsubscribe();\n    this.maskJob = undefined;\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.maskProgress = 0;\n  }\n\n  private finishMask(blob: Blob, filename: string) {\n    this.maskJob = undefined;\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.showSaveMaskDialog = false;\n    saveAs(blob, filename);\n  }\n\n  private maskError(detail: string) {\n    this.maskJob = undefined;\n    this.maskBusy = false;\n    this.maskEncoding = false;\n    this.messageService.add({\n      key: VIZ_TOAST_KEY,\n      severity: 'error',\n      summary: 'Could not create mask',\n      detail,\n    });\n  }\n\n  protected persistRegions() {\n    // Folder stack: write each slice's regions back to its own slice-file's\n    // sibling geojson — no single-filename prompt (jit-ui#93).\n    if (this.persistence.savesPerSlice()) {\n      this.saveStackSlices();\n      return;\n    }\n    const filename = this.persistence.defaultSaveName();\n    if (!filename || (!this.regionsForSave().length && !this.hasRegionSource)) return;\n\n    this.saveAsFilename = filename;\n    this.saveAsFileExists = false;\n    this.showSaveAsDialog = true;\n    this.saveAsCheck$.next(this.saveAsFilename);\n  }\n\n  /** Save a folder stack's regions as one geojson per slice-file (jit-ui#93).\n   *  No dialog covers the toolbar meanwhile, so a Save while one is uploading\n   *  is ignored rather than starting a second write (and orphaning the first). */\n  private async saveStackSlices() {\n    if (this.saveAsBusy) return;\n    this.saveAsBusy = true;\n    let slices: SliceGeoJson[];\n    try {\n      slices = await this.persistence.sliceGeoJsons();\n    } catch (err) {\n      this.saveAsBusy = false;\n      this.changed();\n      this.toast('error', 'Error saving regions', `${(err as Error)?.message ?? err}`);\n      return;\n    }\n    // Cancelled while the slices serialized, or nothing to write.\n    if (!this.saveAsBusy || !slices.length) {\n      this.saveAsBusy = false;\n      return;\n    }\n    this._saveAsSub = this.persistence.saveSlices(slices).subscribe({\n      next: () => {\n        this.saveAsBusy = false;\n        this.changed();\n        this.toast(\n          'success',\n          'Regions saved',\n          `Saved ROIs for ${slices.length} slice${slices.length === 1 ? '' : 's'}`,\n        );\n      },\n      error: (err) => {\n        this.saveAsBusy = false;\n        this.changed();\n        this.toast('error', 'Error saving regions', `${(err as Error)?.message ?? err}`);\n      },\n    });\n  }\n\n  protected checkSaveAsFileExists() {\n    this.saveAsCheck$.next(this.saveAsFilename);\n  }\n\n  protected confirmSaveAs() {\n    if (!this.persistence.selectedFileName()) return;\n\n    const filename = this.saveAsFilename.trim();\n    if (!filename) return;\n\n    // Keep the dialog open showing an (indeterminate) progress bar while the\n    // regions serialize and upload, then close on success.\n    const doSave = () => {\n      this.saveAsBusy = true;\n      // Also run from the overwrite confirmation, which the host's dialog may answer.\n      this.changed();\n      this._saveAsSub = this.persistence\n        .save(() => this.regionsForSave(), filename)\n        .subscribe({\n          next: () => {\n            this.saveAsBusy = false;\n            this.showSaveAsDialog = false;\n            this.changed();\n            this.toast('success', 'Regions saved', `Saved as ${filename}`);\n          },\n          error: (err) => {\n            this.saveAsBusy = false;\n            this.changed();\n            this.toast('error', 'Error saving regions', `${(err as Error)?.message || err}`);\n          },\n        });\n    };\n\n    if (this.saveAsFileExists) {\n      this.confirmationService.confirm({\n        message: `\"${filename}\" already exists. Do you want to overwrite it?`,\n        header: 'Confirm Overwrite',\n        icon: 'pi pi-exclamation-triangle',\n        accept: doSave,\n      });\n    } else {\n      doSave();\n    }\n  }\n\n  /** Cancel an in-progress GeoJSON persist: abort the deferred serialize and/or\n   *  the in-flight upload, and reset state. */\n  protected cancelSaveAs() {\n    this._saveAsSub?.unsubscribe();\n    this._saveAsSub = undefined;\n    this.saveAsBusy = false;\n  }\n\n  private toast(severity: 'success' | 'error' | 'info', summary: string, detail: string): void {\n    this.messageService.add({ key: VIZ_TOAST_KEY, severity, summary, detail });\n  }\n}\n","<p-toolbar styleClass=\"region-toolbar\">\n  <div class=\"p-toolbar-group-start align-items-center flex-wrap gap-1\">\n    <p-button\n      icon=\"pi pi-tag\"\n      size=\"small\"\n      [text]=\"!showShapeLabel\"\n      pTooltip=\"Show region labels.\"\n      tooltipPosition=\"bottom\"\n      (onClick)=\"showShapeLabel = !showShapeLabel; changeShowShapeLabel(showShapeLabel)\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-stop-circle\"\n      size=\"small\"\n      [text]=\"!regionsFilled\"\n      pTooltip=\"Fill regions in their colour (an atlas's look); labels sit inside.\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Fill regions\"\n      (onClick)=\"toggleFill()\"\n    >\n    </p-button>\n    <p-button\n      *ngIf=\"volumeView\"\n      icon=\"pi pi-eye\"\n      size=\"small\"\n      [text]=\"!regionsThroughVolume\"\n      [attr.aria-pressed]=\"regionsThroughVolume\"\n      pTooltip=\"See the regions through the volume. Off, the volume hides the parts of them behind what it shows; on, none (layers traced inside bright structures, such as an OCT's).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Regions through volume\"\n      (onClick)=\"toggleThroughVolume()\"\n    >\n    </p-button>\n    <span class=\"toolbar-separator\"></span>\n    <!-- New regions are now created from the diagram toolbar\n         (rectangle, polyline, freeform, wand). -->\n    <p-button\n      icon=\"pi pi-upload\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import regions: a GeoJSON file, or a label volume (.nii, .nii.gz, .nrrd) chosen with its ontology JSON for the class tree.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roiFileInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFileInput\n      type=\"file\"\n      accept=\".geojson,.json,.nii,.gz,.nrrd\"\n      multiple\n      hidden\n      (change)=\"importRois($event); roiFileInput.value = ''\"\n    />\n    <p-button\n      icon=\"pi pi-folder-open\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import a folder of per-slice GeoJSON files (one per slice, in name order, with its regionset.json class tree).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Import a folder of regions\"\n      (click)=\"roiFolderInput.click()\"\n    >\n    </p-button>\n    <input\n      #roiFolderInput\n      type=\"file\"\n      webkitdirectory\n      multiple\n      hidden\n      (change)=\"importRois($event); roiFolderInput.value = ''\"\n    />\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download regions as geojson file.\"\n      tooltipPosition=\"bottom\"\n      icon=\"pi pi-download\"\n      (click)=\"exportRois()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-save\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Save regions to server.\"\n      tooltipPosition=\"bottom\"\n      (click)=\"persistRegions()\"\n      [disabled]=\"(!regions || !regions.length) && !hasRegionSource\"\n    >\n    </p-button>\n    <p-button\n      *ngIf=\"canImportFromServer\"\n      icon=\"pi pi-cloud-download\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Import regions from server: a GeoJSON file, a folder of per-slice GeoJSON files or a label volume (.nii, .nii.gz, .nrrd).\"\n      tooltipPosition=\"bottom\"\n      ariaLabel=\"Import regions from server\"\n      [loading]=\"importing\"\n      (click)=\"importFromServer()\"\n    >\n    </p-button>\n    <p-button\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Download mask of the regions as PNG\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openSaveMaskDialog()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n      <!-- References the file so Inkscape edits to mask.svg show up directly\n           (the lib's assets/** are served at assets/plotting/). The\n           toolbar-icon-dark filter recolours the black SVG to the theme blue,\n           same as region-editor.svg and the other SVG toolbar icons. -->\n      <img\n        src=\"assets/plotting/mask.svg\"\n        class=\"toolbar-icon-dark\"\n        style=\"width: 1rem; height: 1rem; vertical-align: middle\"\n        alt=\"Download mask\"\n      />\n    </p-button>\n    <p-button\n      label=\"x512\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Round all rectangle regions\n                    to width and height that are multiple of 512\"\n      tooltipPosition=\"bottom\"\n      (click)=\"roundRectangleLengths()\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-check-square\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Select all regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"selectAllRegions()\"\n      [disabled]=\"!regions || !regions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-tags\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit class on selected rows\"\n      tooltipPosition=\"bottom\"\n      (click)=\"!selectedRegions || !selectedRegions.length ? op.hide() : op.toggle($event)\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-button\n      icon=\"pi pi-palette\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      pTooltip=\"Edit colour of selected regions\"\n      tooltipPosition=\"bottom\"\n      (click)=\"openColorDialog()\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    >\n    </p-button>\n    <p-overlayPanel #op (onHide)=\"bulkClass = ''; newBulkClass = ''\">\n      <div class=\"flex flex-column gap-2\" style=\"width: 18rem\">\n        <span class=\"font-medium text-900\"\n          >Set class on {{ selectedRegions?.length || 0 }} selected region(s)</span\n        >\n        <!-- Selecting a class applies it immediately (choosing an option closes the\n             overlay, so there's no separate Apply button). -->\n        <p-dropdown\n          styleClass=\"w-full\"\n          appendTo=\"body\"\n          [options]=\"presetSet.classes\"\n          optionLabel=\"name\"\n          optionValue=\"name\"\n          [(ngModel)]=\"bulkClass\"\n          placeholder=\"Choose a class…\"\n          [filter]=\"presetSet.classes.length > 8\"\n          filterBy=\"name\"\n          (onChange)=\"applyBulkClass()\"\n        >\n          <ng-template let-c pTemplate=\"item\">\n            <span class=\"dd-value\"\n              ><span class=\"chip-swatch\" [style.background]=\"c.color\"></span>{{ c.name }}</span\n            >\n          </ng-template>\n        </p-dropdown>\n        <div class=\"p-inputgroup\">\n          <input\n            type=\"text\"\n            pInputText\n            placeholder=\"…or a new class\"\n            [(ngModel)]=\"newBulkClass\"\n            (keydown.enter)=\"addAndApplyBulkClass()\"\n          />\n          <button\n            pButton\n            type=\"button\"\n            icon=\"pi pi-plus\"\n            pTooltip=\"Add class &amp; set it\"\n            tooltipPosition=\"bottom\"\n            [disabled]=\"!newBulkClass.trim()\"\n            (click)=\"addAndApplyBulkClass()\"\n          ></button>\n        </div>\n      </div>\n    </p-overlayPanel>\n    <p-button\n      icon=\"pi pi-trash\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"deleteSelectedRegions()\"\n      pTooltip=\"Delete selected regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"!selectedRegions || !selectedRegions.length\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-times-circle\"\n      size=\"small\"\n      [text]=\"true\"\n      styleClass=\"mr-2\"\n      (click)=\"clearAllRegions()\"\n      pTooltip=\"Delete all regions\"\n      tooltipPosition=\"bottom\"\n      [disabled]=\"(!regions || !regions.length) && !hasRegionSource\"\n    ></p-button>\n    <p-button\n      icon=\"pi pi-question\"\n      size=\"small\"\n      [text]=\"true\"\n      (click)=\"showHelp()\"\n      pTooltip=\"Help\"\n      tooltipPosition=\"bottom\"\n    ></p-button>\n  </div>\n</p-toolbar>\n\n<region-classes-panel\n  [classes]=\"displayClasses\"\n  [counts]=\"classCounts\"\n  [matchMode]=\"presetSet.matchMode\"\n  [activeClass]=\"activeClass\"\n  [picked]=\"pickedClass\"\n  [marked]=\"markedClasses\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  [defaultClassName]=\"defaultClassName\"\n  (pick)=\"selectActiveClass($event)\"\n  (recolor)=\"setClassColor($event.name, $event.color)\"\n  (remove)=\"deleteClass($event)\"\n  (manage)=\"openManageDialog()\"\n  [volume]=\"volumeView\"\n  [shown3d]=\"shown3dNames\"\n  (toggle3d)=\"toggleClass3d($event)\"\n  [hidden]=\"hiddenClasses\"\n  (toggleHidden)=\"setClassesHidden([$event], !hiddenClasses.has($event))\"\n  [treeView]=\"classHierarchy ? classTreeView : null\"\n  (treeViewChange)=\"classTreeView = $event\"\n>\n  <!-- A region set with a class hierarchy (an atlas ontology) can show its classes as a tree. -->\n  <region-class-tree\n    *ngIf=\"classHierarchy as hierarchy\"\n    [nodes]=\"hierarchy\"\n    [counts]=\"treeCounts\"\n    [colorOf]=\"treeColor\"\n    [picked]=\"pickedClass\"\n    [marked]=\"markedClasses\"\n    [volume]=\"volumeView\"\n    [shown3d]=\"shown3dNames\"\n    (pick)=\"pickClasses($event)\"\n    (recolor)=\"setClassColor($event.name, $event.color)\"\n    (toggle3d)=\"toggleClass3d($event.name, $event.classes)\"\n    [hidden]=\"hiddenClasses\"\n    (toggleHidden)=\"setClassesHidden($event.classes, $event.hidden)\"\n  >\n  </region-class-tree>\n</region-classes-panel>\n\n<region-table\n  [page]=\"pagedRegions\"\n  [total]=\"tableTotal\"\n  [first]=\"paginatorFirst\"\n  [rows]=\"paginatorRows\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [metaKey]=\"metaKey\"\n  [selection]=\"selectedRegions\"\n  (selectionChange)=\"selectedRegions = $event\"\n  (rowSelect)=\"onSelectionChanged()\"\n  [presetSet]=\"tablePresetSet\"\n  [defaultColor]=\"shapeColor\"\n  [mpp]=\"mpp\"\n  [volumes]=\"tableVolumes\"\n  [labelDrafts]=\"editingLabelRegions\"\n  (labelEditStart)=\"startEditLabel($event)\"\n  (labelDraftChange)=\"setLabelDraft($event.region, $event.value)\"\n  (labelEditStop)=\"stopEditLabel($event.region, $event.commit)\"\n  (classPick)=\"applyPresetToRegion($event.region, $event.name)\"\n  (deleteRow)=\"deleteRegion($event)\"\n  (pageChange)=\"onPageChange($event)\"\n>\n</region-table>\n\n<!-- Live-edit mode: no Save/Cancel — every edit commits immediately to the\n     active image's region cache. -->\n\n<p-confirmDialog\n  #cd\n  [style]=\"{ width: '24rem', height: '14rem' }\"\n  key=\"positionDialog\"\n  [baseZIndex]=\"10000\"\n  rejectButtonStyleClass=\"p-button-outlined\"\n>\n  <ng-template pTemplate=\"footer\">\n    <button type=\"button\" pButton icon=\"pi pi-check\" label=\"Yes\" (click)=\"cd.accept()\"></button>\n    <button\n      type=\"button\"\n      class=\"p-button-outlined\"\n      pButton\n      icon=\"pi pi-times\"\n      label=\"No\"\n      (click)=\"cd.reject()\"\n    ></button>\n  </ng-template>\n</p-confirmDialog>\n\n<region-save-regions-dialog\n  [(visible)]=\"showSaveAsDialog\"\n  [filename]=\"saveAsFilename\"\n  (filenameChange)=\"saveAsFilename = $event; checkSaveAsFileExists()\"\n  [fileExists]=\"saveAsFileExists\"\n  [busy]=\"saveAsBusy\"\n  (confirm)=\"confirmSaveAs()\"\n  (cancelSave)=\"cancelSaveAs()\"\n>\n</region-save-regions-dialog>\n\n<region-save-regions-dialog\n  header=\"Export Regions\"\n  confirmLabel=\"Export\"\n  confirmIcon=\"pi pi-download\"\n  inputId=\"export-filename\"\n  [(visible)]=\"showExportDialog\"\n  [(filename)]=\"exportFilename\"\n  (confirm)=\"confirmExport()\"\n>\n</region-save-regions-dialog>\n\n<region-save-mask-dialog\n  [(visible)]=\"showSaveMaskDialog\"\n  [(filename)]=\"saveMaskFilename\"\n  [(mode)]=\"maskMode\"\n  [busy]=\"maskBusy\"\n  [progress]=\"maskProgress\"\n  [encoding]=\"maskEncoding\"\n  (confirm)=\"confirmSaveMask()\"\n  (cancelExport)=\"cancelSaveMask()\"\n>\n</region-save-mask-dialog>\n\n<region-color-dialog\n  [(visible)]=\"showColorDialog\"\n  [edits]=\"classColorEdits\"\n  [selectedCount]=\"selectedRegions?.length || 0\"\n  (apply)=\"applyColorToSelected($event)\"\n>\n</region-color-dialog>\n\n<!-- Manage annotation classes (jit-ui#70): edits a working copy, committed on Apply. -->\n<region-manage-classes-dialog\n  [(visible)]=\"showManageDialog\"\n  [(draft)]=\"presetDraft\"\n  (apply)=\"applyManageDialog(true)\"\n  (resetDefaults)=\"resetPresetsToDefaults()\"\n  (importFile)=\"importPresets($event)\"\n  (export)=\"exportPresets()\"\n>\n</region-manage-classes-dialog>\n\n<region-editor-help [(visible)]=\"displayHelpDialog\"></region-editor-help>\n"]}