@datagrok-libraries/statistics 1.10.0 → 1.12.1

package/src/mpo/editors/mpo-line-editor.js

@@ -0,0 +1,600 @@
+/* eslint-disable max-len */
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import { Subject } from 'rxjs';
+let _konva;
+async function getKonva() {
+    if (!_konva)
+        _konva = (await import('konva')).default;
+    return _konva;
+}
+// Constants for the editor layout
+const EDITOR_PADDING = { top: 10, right: 10, bottom: 20, left: 30 };
+const POINT_RADIUS = 3;
+const COLORS = {
+    line: DG.Color.toHtml(DG.Color.filteredRows),
+    handle: DG.Color.toHtml(DG.Color.selectedRows),
+    barFill: DG.Color.toHtml(DG.Color.histogramBar),
+    barStroke: DG.Color.toHtml(DG.Color.lightGray),
+};
+class CoordMapper {
+    constructor(minX, maxX, width, height) {
+        this.minX = minX;
+        this.maxX = maxX;
+        this.width = width;
+        this.height = height;
+        this.plotWidth = width - EDITOR_PADDING.left - EDITOR_PADDING.right;
+        this.plotHeight = height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;
+        this.scaleX = (this.maxX - this.minX === 0) ? 1 : this.plotWidth / (this.maxX - this.minX);
+        this.scaleY = this.plotHeight;
+    }
+    toCanvasCoords(p) {
+        const canvasX = EDITOR_PADDING.left + (p[0] - this.minX) * this.scaleX;
+        const canvasY = EDITOR_PADDING.top + this.plotHeight - (p[1] * this.scaleY);
+        return { x: canvasX, y: canvasY };
+    }
+    toDataCoords(canvasX, canvasY) {
+        let dataX = this.minX + (canvasX - EDITOR_PADDING.left) / this.scaleX;
+        let dataY = (EDITOR_PADDING.top + this.plotHeight - canvasY) / this.scaleY;
+        dataX = Math.max(this.minX, Math.min(this.maxX, dataX));
+        dataY = Math.max(0, Math.min(1, dataY));
+        return { x: dataX, y: dataY };
+    }
+}
+export class MpoDesirabilityLineEditor {
+    constructor(prop, width, height) {
+        this.root = ui.div([], 'statistics-mpo-line-editor');
+        this.onChanged = new Subject();
+        this.supportsModeDialog = true;
+        // Flag to prevent touchpad right-click from adding a new point
+        this.ignoreNextClick = false;
+        this.dragScaleX = 0;
+        this.dragScaleY = 0;
+        this._prop = prop;
+        this._width = width;
+        this._height = height;
+        this.ensureDefaultLine();
+        this.root.style.width = `${width}px`;
+        this.root.style.height = `${height}px`;
+        this.root.style.position = 'relative';
+        requestAnimationFrame(() => this.initKonva(width, height));
+    }
+    ensureDefaultLine() {
+        var _a, _b;
+        if (this._prop.line.length > 0)
+            return;
+        const min = (_a = this._prop.min) !== null && _a !== void 0 ? _a : 0;
+        const max = (_b = this._prop.max) !== null && _b !== void 0 ? _b : 1;
+        this._prop.line = [[min, 0.5], [max, 0.5]];
+    }
+    updateDragScales() {
+        const plotWidth = this._width - EDITOR_PADDING.left - EDITOR_PADDING.right;
+        const plotHeight = this._height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;
+        this.dragScaleX = (this.getMaxX() - this.getMinX()) / plotWidth;
+        this.dragScaleY = 1 / plotHeight;
+    }
+    isInPlotArea(pos, width, height) {
+        return (pos.x >= EDITOR_PADDING.left &&
+            pos.x <= width - EDITOR_PADDING.right &&
+            pos.y >= EDITOR_PADDING.top &&
+            pos.y <= height - EDITOR_PADDING.bottom);
+    }
+    async initKonva(width, height) {
+        var _a;
+        if (!this.root.parentElement) {
+            console.warn('Konva container not attached to DOM yet.');
+            return;
+        }
+        const Konva = await getKonva();
+        this.barsLayer = new Konva.Layer();
+        this.stage = new Konva.Stage({
+            container: this.root,
+            width,
+            height,
+        });
+        this.stage.add(this.barsLayer);
+        this.layer = new Konva.Layer();
+        this.stage.add(this.layer);
+        const minX = this.getMinX();
+        const maxX = this.getMaxX();
+        // --- Draw Axes ---
+        this.drawAxes(minX, maxX, width, height);
+        // --- Draw Line and Points ---
+        this.konvaLine = new Konva.Line({
+            points: [],
+            stroke: COLORS.line,
+            strokeWidth: 2,
+            lineCap: 'round',
+            lineJoin: 'round',
+        });
+        this.layer.add(this.konvaLine);
+        this.pointsGroup = new Konva.Group();
+        this.layer.add(this.pointsGroup);
+        // --- Redraw Function ---
+        this.redrawFn = (notify = true) => {
+            const minX = this.getMinX();
+            const maxX = this.getMaxX();
+            if (this._prop.mode === 'freeform' && this._prop.freeformLine)
+                this._prop.line = this._prop.freeformLine;
+            if (this._prop.mode !== 'freeform') {
+                if (!this._prop.freeformLine)
+                    this._prop.freeformLine = [...this._prop.line];
+                this._prop.line = this.computeLine();
+            }
+            this.pointsGroup.destroyChildren();
+            const konvaPoints = [];
+            const mapper = new CoordMapper(minX, maxX, this._width, this._height);
+            const sortedIndices = [...this._prop.line.keys()]
+                .sort((a, b) => this._prop.line[a][0] - this._prop.line[b][0]);
+            const sortedLine = sortedIndices.map((idx) => this._prop.line[idx]);
+            sortedLine.forEach((p, index) => {
+                const coords = mapper.toCanvasCoords([p[0], p[1]]);
+                konvaPoints.push(coords.x, coords.y);
+                if (this._prop.mode !== 'freeform')
+                    return;
+                const pointCircle = new Konva.Circle({
+                    x: coords.x,
+                    y: coords.y,
+                    radius: POINT_RADIUS,
+                    fill: 'white',
+                    stroke: COLORS.line,
+                    strokeWidth: 1,
+                    draggable: true,
+                    hitStrokeWidth: 5,
+                });
+                // Store index directly on the node for easy access
+                pointCircle.setAttr('_dataIndex', sortedIndices[index]);
+                pointCircle.on('dragmove', (evt) => {
+                    const circle = evt.target;
+                    const pos = circle.position();
+                    const dataIndex = circle.getAttr('_dataIndex');
+                    const sortedPos = sortedIndices.indexOf(dataIndex);
+                    // Constrain dragging horizontally between neighbors (or bounds)
+                    const prevX = sortedPos > 0 ? this._prop.line[sortedIndices[sortedPos - 1]][0] : minX;
+                    const nextX = sortedPos < sortedIndices.length - 1 ?
+                        this._prop.line[sortedIndices[sortedPos + 1]][0] :
+                        maxX;
+                    // Add a small buffer to avoid points overlapping exactly
+                    const buffer = (maxX - minX === 0) ? 0 : 0.001 * (maxX - minX); // Avoid NaN if minX === maxX
+                    const minCanvasX = mapper.toCanvasCoords([prevX + (sortedPos > 0 ? buffer : 0), 0]).x;
+                    const maxCanvasX = mapper.toCanvasCoords([nextX - (sortedPos < sortedIndices.length - 1 ? buffer : 0), 0]).x;
+                    pos.x = Math.max(minCanvasX, Math.min(maxCanvasX, pos.x));
+                    const plotTop = EDITOR_PADDING.top;
+                    const plotBottom = this._height - EDITOR_PADDING.bottom;
+                    pos.y = Math.max(plotTop, Math.min(plotBottom, pos.y));
+                    circle.position(pos);
+                    const dataCoords = mapper.toDataCoords(pos.x, pos.y);
+                    this._prop.line[dataIndex][0] = dataCoords.x;
+                    this._prop.line[dataIndex][1] = dataCoords.y;
+                    const currentKonvaPoints = this._prop.line.map((pData, idx) => {
+                        // Use dragged circle position directly for the point being dragged
+                        if (idx === dataIndex)
+                            return [pos.x, pos.y];
+                        else {
+                            const c = mapper.toCanvasCoords([pData[0], pData[1]]);
+                            return [c.x, c.y];
+                        }
+                    }).flat();
+                    this.konvaLine.points(currentKonvaPoints);
+                    this.layer.batchDraw();
+                });
+                pointCircle.on('dragend', () => {
+                    var _a;
+                    this._prop.line.sort((a, b) => a[0] - b[0]);
+                    (_a = this.redrawFn) === null || _a === void 0 ? void 0 : _a.call(this);
+                });
+                pointCircle.on('contextmenu', (evt) => {
+                    var _a;
+                    evt.evt.preventDefault();
+                    if (this._prop.line.length <= 2) {
+                        grok.shell.warning('Cannot remove points, minimum of 2 required.');
+                        return;
+                    }
+                    this.ignoreNextClick = true;
+                    const circle = evt.target;
+                    const dataIndex = circle.getAttr('_dataIndex');
+                    if (dataIndex >= 0) {
+                        if (this._prop.min == null)
+                            this._prop.min = this.getMinX();
+                        if (this._prop.max == null)
+                            this._prop.max = this.getMaxX();
+                        this._prop.line.splice(dataIndex, 1);
+                        (_a = this.redrawFn) === null || _a === void 0 ? void 0 : _a.call(this);
+                    }
+                });
+                pointCircle.on('mouseenter', (evt) => {
+                    this.stage.container().style.cursor = 'pointer';
+                    const circle = evt.target;
+                    const pos = circle.position();
+                    const dataCoords = mapper.toDataCoords(pos.x, pos.y);
+                    const tooltipText = `X: ${dataCoords.x.toFixed(2)}, Y: ${dataCoords.y.toFixed(2)}<br><br>Drag to move, double-click to edit, right-click to delete`;
+                    ui.tooltip.show(tooltipText, evt.evt.clientX, evt.evt.clientY);
+                });
+                pointCircle.on('mouseleave', () => {
+                    this.stage.container().style.cursor = 'default';
+                    ui.tooltip.hide();
+                });
+                pointCircle.on('dblclick dbltap', (evt) => {
+                    this.ignoreNextClick = true;
+                    ui.tooltip.hide();
+                    const dataIndex = evt.target.getAttr('_dataIndex');
+                    this.showPointEditor(dataIndex, evt.evt.clientX, evt.evt.clientY);
+                });
+                this.pointsGroup.add(pointCircle);
+            });
+            this.konvaLine.points(konvaPoints);
+            this.layer.batchDraw();
+            // --- Add special handle (Gaussian peak / Sigmoid inflection) ---
+            this.addSpecialHandle(this._width, this._height);
+            if (notify)
+                this.onChanged.next(this._prop.line);
+        };
+        // --- Left-click to Add Point ---
+        this.stage.on('click tap', (evt) => {
+            var _a, _b;
+            if (this.ignoreNextClick) {
+                this.ignoreNextClick = false;
+                return;
+            }
+            if (evt.target instanceof Konva.Circle || evt.evt.button !== 0)
+                return;
+            const pos = (_a = this.stage) === null || _a === void 0 ? void 0 : _a.getPointerPosition();
+            if (!pos)
+                return;
+            const minX = this.getMinX();
+            const maxX = this.getMaxX();
+            if (!this.isInPlotArea(pos, this.stage.width(), this.stage.height()))
+                return;
+            const mapper = new CoordMapper(minX, maxX, this.stage.width(), this.stage.height());
+            const dataCoords = mapper.toDataCoords(pos.x, pos.y);
+            this._prop.line.push([dataCoords.x, dataCoords.y]);
+            this._prop.line.sort((a, b) => a[0] - b[0]);
+            (_b = this.redrawFn) === null || _b === void 0 ? void 0 : _b.call(this);
+        });
+        // Cursor change
+        this.stage.on('mousemove', (evt) => {
+            if (!this.stage)
+                return;
+            const pos = this.stage.getPointerPosition();
+            if (!pos)
+                return;
+            if (this._prop.mode !== 'freeform') {
+                if (this.isInPlotArea(pos, this._width, this._height))
+                    this.stage.container().style.cursor = 'grab';
+                else
+                    this.stage.container().style.cursor = 'default';
+            }
+        });
+        this.stage.on('mouseout', () => ui.tooltip.hide());
+        // Enable curve drag (smooth)
+        this.enableCurveDrag();
+        this.updateDragScales();
+        ui.onSizeChanged(this.root).subscribe((_) => {
+            const { clientWidth: w, clientHeight: h } = this.root;
+            if (w > 0 && h > 0)
+                this.resize(w, h);
+        });
+        // Initial draw
+        if (this.pendingBarValues) {
+            this.drawBars(this.pendingBarValues);
+            this.pendingBarValues = undefined;
+        }
+        (_a = this.redrawFn) === null || _a === void 0 ? void 0 : _a.call(this, false);
+    }
+    get line() {
+        return this._prop.line;
+    }
+    computeLine() {
+        var _a, _b, _c, _d;
+        var _e, _f, _g, _h;
+        if (this._prop.mode === 'freeform')
+            return this._prop.line;
+        const minX = this.getMinX();
+        const maxX = this.getMaxX();
+        const n = 60;
+        const line = [];
+        for (let i = 0; i <= n; i++) {
+            const x = minX + (maxX - minX) * (i / n);
+            let y = 0;
+            if (this._prop.mode === 'gaussian') {
+                (_a = (_e = this._prop).mean) !== null && _a !== void 0 ? _a : (_e.mean = (minX + maxX) / 2);
+                (_b = (_f = this._prop).sigma) !== null && _b !== void 0 ? _b : (_f.sigma = (maxX - minX) / 6);
+                const mean = this._prop.mean;
+                const sigma = this._prop.sigma;
+                const z = (x - mean) / sigma;
+                y = Math.exp(-0.5 * z * z);
+            }
+            if (this._prop.mode === 'sigmoid') {
+                (_c = (_g = this._prop).x0) !== null && _c !== void 0 ? _c : (_g.x0 = (minX + maxX) / 2);
+                (_d = (_h = this._prop).k) !== null && _d !== void 0 ? _d : (_h.k = 10);
+                const x0 = this._prop.x0;
+                const k = this._prop.k;
+                y = 1 / (1 + Math.exp(-k * (x - x0)));
+            }
+            line.push([x, y]);
+        }
+        return line;
+    }
+    drawAxes(minX, maxX, width, height) {
+        const axisColor = getComputedStyle(document.documentElement).getPropertyValue('--grey-2').trim() || '#DBDCDF';
+        this.layer.add(new _konva.Line({
+            points: [EDITOR_PADDING.left, height - EDITOR_PADDING.bottom, width - EDITOR_PADDING.right, height - EDITOR_PADDING.bottom],
+            stroke: axisColor,
+            strokeWidth: 1,
+        }), new _konva.Line({
+            points: [EDITOR_PADDING.left, EDITOR_PADDING.top, EDITOR_PADDING.left, height - EDITOR_PADDING.bottom],
+            stroke: axisColor,
+            strokeWidth: 1,
+        }), new _konva.Text({ x: EDITOR_PADDING.left, y: height - EDITOR_PADDING.bottom + 3, text: minX.toFixed(1), fontSize: 9, fill: 'grey' }), new _konva.Text({ x: width - EDITOR_PADDING.right - 15, y: height - EDITOR_PADDING.bottom + 3, text: maxX.toFixed(1), fontSize: 9, fill: 'grey' }));
+    }
+    getMinX() {
+        var _a, _b;
+        return (_b = (_a = this._prop.min) !== null && _a !== void 0 ? _a : Math.min(...this._prop.line.map((p) => p[0]))) !== null && _b !== void 0 ? _b : 0;
+    }
+    getMaxX() {
+        var _a, _b;
+        return (_b = (_a = this._prop.max) !== null && _a !== void 0 ? _a : Math.max(...this._prop.line.map((p) => p[0]))) !== null && _b !== void 0 ? _b : 1;
+    }
+    getDefaultMean() {
+        return (this.getMinX() + this.getMaxX()) / 2;
+    }
+    getDefaultSigma() {
+        return Math.max(0.01, (this.getMaxX() - this.getMinX()) / 6);
+    }
+    getDefaultX0() {
+        return (this.getMinX() + this.getMaxX()) / 2;
+    }
+    getDefaultK() {
+        return 10;
+    }
+    redrawAll(notify = true) {
+        if (!this.stage || !this.layer || !this.redrawFn)
+            return;
+        const width = this.stage.width();
+        const height = this.stage.height();
+        const minX = this.getMinX();
+        const maxX = this.getMaxX();
+        this.layer.destroyChildren();
+        this.drawAxes(minX, maxX, width, height);
+        this.layer.add(this.konvaLine, this.pointsGroup);
+        this.redrawFn(notify);
+        if (this.barValues)
+            this.drawBars();
+    }
+    resize(width, height) {
+        if (width === this._width && height === this._height)
+            return;
+        this._width = width;
+        this._height = height;
+        if (this.stage) {
+            this.stage.width(width);
+            this.stage.height(height);
+            this.updateDragScales();
+            this.redrawAll(false);
+        }
+    }
+    drawBars(values) {
+        var _a;
+        if (values)
+            this.barValues = values;
+        if (!this.barsLayer) {
+            this.pendingBarValues = values;
+            return;
+        }
+        this.barsLayer.destroyChildren();
+        if (!this.barValues || this.barValues.length === 0)
+            return;
+        const stage = this.barsLayer.getStage();
+        if (!stage) {
+            this.pendingBarValues = values;
+            return;
+        }
+        const width = stage.width();
+        const height = stage.height();
+        const minX = this.getMinX();
+        const maxX = this.getMaxX();
+        if (maxX === minX)
+            return;
+        const numBins = 20;
+        const plotWidth = width - EDITOR_PADDING.left - EDITOR_PADDING.right;
+        const plotHeight = height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;
+        const binWidth = Math.max(1e-9, (maxX - minX) / numBins);
+        const bins = new Array(numBins).fill(0);
+        ((_a = this.barValues) !== null && _a !== void 0 ? _a : []).forEach((v) => {
+            const idx = Math.min(Math.floor((v - minX) / binWidth), numBins - 1);
+            bins[idx]++;
+        });
+        const maxCount = Math.max(...bins) || 1;
+        bins.forEach((count, i) => {
+            const barX = EDITOR_PADDING.left + (i * binWidth / (maxX - minX)) * plotWidth;
+            const barW = (binWidth / (maxX - minX)) * plotWidth - 1;
+            const barH = (count / maxCount) * plotHeight;
+            const rect = new _konva.Rect({
+                x: barX,
+                y: EDITOR_PADDING.top + plotHeight - barH,
+                width: barW,
+                height: barH,
+                fill: COLORS.barFill,
+                opacity: 0.25,
+                stroke: COLORS.barStroke,
+                strokeWidth: 0.5,
+            });
+            this.barsLayer.add(rect);
+        });
+        this.barsLayer.batchDraw();
+    }
+    enableCurveDrag() {
+        if (!this.stage)
+            return;
+        let dragging = false;
+        let startPointer = null;
+        let startMean = 0;
+        let startSigma = 0;
+        let startX0 = 0;
+        let startK = 0;
+        this.stage.on('mousedown touchstart', (evt) => {
+            var _a, _b, _c, _d;
+            if (this._prop.mode === 'freeform')
+                return;
+            if (!evt.evt)
+                return;
+            const pos = this.stage.getPointerPosition();
+            if (!pos)
+                return;
+            if (!this.isInPlotArea(pos, this._width, this._height))
+                return;
+            dragging = true;
+            startPointer = pos;
+            startMean = (_a = this._prop.mean) !== null && _a !== void 0 ? _a : (this.getMinX() + this.getMaxX()) / 2;
+            startSigma = (_b = this._prop.sigma) !== null && _b !== void 0 ? _b : (this.getMaxX() - this.getMinX()) / 6;
+            startX0 = (_c = this._prop.x0) !== null && _c !== void 0 ? _c : (this.getMinX() + this.getMaxX()) / 2;
+            startK = (_d = this._prop.k) !== null && _d !== void 0 ? _d : 10;
+            this.stage.container().style.cursor = 'grabbing';
+        });
+        this.stage.on('mousemove touchmove', (evt) => {
+            var _a, _b;
+            if (!dragging || !startPointer)
+                return;
+            const pos = this.stage.getPointerPosition();
+            if (!pos)
+                return;
+            const dx = pos.x - startPointer.x;
+            const dy = pos.y - startPointer.y;
+            if (this._prop.mode === 'gaussian') {
+                this._prop.mean = startMean + dx * this.dragScaleX;
+                this._prop.sigma = Math.max(0.01, startSigma + (-dy) * this.dragScaleY * (this.getMaxX() - this.getMinX()));
+            }
+            if (this._prop.mode === 'sigmoid') {
+                this._prop.x0 = startX0 + dx * this.dragScaleX;
+                this._prop.k = Math.max(0.1, startK + (-dy) * this.dragScaleY * 50);
+            }
+            this._prop.line = this.computeLine();
+            (_a = this.redrawFn) === null || _a === void 0 ? void 0 : _a.call(this);
+            (_b = this.onParamsChanged) === null || _b === void 0 ? void 0 : _b.call(this, this._prop);
+        });
+        this.stage.on('mouseup touchend', () => {
+            dragging = false;
+            startPointer = null;
+            this.stage.container().style.cursor = 'default';
+        });
+    }
+    addSpecialHandle(width, height) {
+        var _a, _b;
+        const clamp = (v, min, max) => Math.max(min, Math.min(max, v));
+        if (this._prop.mode === 'freeform')
+            return;
+        const minX = this.getMinX();
+        const maxX = this.getMaxX();
+        const mapper = new CoordMapper(minX, maxX, width, height);
+        let x = (minX + maxX) / 2;
+        let y = 0.5;
+        if (this._prop.mode === 'gaussian') {
+            x = (_a = this._prop.mean) !== null && _a !== void 0 ? _a : (minX + maxX) / 2;
+            y = 1;
+        }
+        else if (this._prop.mode === 'sigmoid') {
+            x = (_b = this._prop.x0) !== null && _b !== void 0 ? _b : (minX + maxX) / 2;
+            y = 0.5;
+        }
+        const coords = mapper.toCanvasCoords([x, y]);
+        if (!this.specialHandle) {
+            this.specialHandle = new _konva.Circle({
+                x: coords.x,
+                y: coords.y,
+                radius: 7,
+                fill: COLORS.handle,
+                draggable: true,
+                hitStrokeWidth: 15,
+            });
+            this.specialHandle.on('dragmove', (evt) => {
+                var _a, _b;
+                const pos = evt.target.position();
+                const data = mapper.toDataCoords(pos.x, pos.y);
+                if (this._prop.mode === 'gaussian') {
+                    this._prop.mean = data.x;
+                    this._prop.sigma = Math.max(0.01, Math.abs(data.y - 1));
+                }
+                else if (this._prop.mode === 'sigmoid') {
+                    this._prop.x0 = data.x;
+                    this._prop.k = clamp(Math.abs(data.y - 0.5) * 30, 0.1, 30);
+                }
+                this._prop.line = this.computeLine();
+                (_a = this.redrawFn) === null || _a === void 0 ? void 0 : _a.call(this);
+                (_b = this.onParamsChanged) === null || _b === void 0 ? void 0 : _b.call(this, this._prop);
+            });
+            this.layer.add(this.specialHandle);
+        }
+        else {
+            if (!this.specialHandle.getLayer())
+                this.layer.add(this.specialHandle);
+            this.specialHandle.position(coords);
+        }
+        this.layer.batchDraw();
+    }
+    showPointEditor(dataIndex, clientX, clientY) {
+        const point = this._prop.line[dataIndex];
+        const xInput = ui.input.float('X', { value: point[0], min: this.getMinX(), max: this.getMaxX(), format: '#0.00', step: 0.01 });
+        const yInput = ui.input.float('Y', { value: point[1], min: 0, max: 1, format: '#0.00', step: 0.01 });
+        const close = () => {
+            content.removeEventListener('keydown', onKey);
+            popup.remove();
+        };
+        const apply = () => {
+            const x = xInput.value;
+            const y = yInput.value;
+            if (x == null || y == null || isNaN(x) || isNaN(y))
+                return;
+            this._prop.line[dataIndex] = [x, y];
+            this.redrawAll();
+        };
+        const onKey = (e) => {
+            if (e.key === 'Enter') {
+                apply();
+                close();
+            }
+            if (e.key === 'Escape')
+                close();
+        };
+        const content = ui.inputs([xInput, yInput]);
+        content.style.overflow = 'hidden';
+        content.addEventListener('keydown', onKey);
+        const rootRect = this.root.getBoundingClientRect();
+        const popup = ui.showPopup(content, this.root, { dx: clientX - rootRect.left, dy: clientY - rootRect.bottom, smart: false });
+    }
+    setRange(min, max) {
+        const oldMin = this.getMinX();
+        const oldMax = this.getMaxX();
+        const oldRange = oldMax - oldMin;
+        const newRange = max - min;
+        if (oldRange !== 0 && newRange !== 0) {
+            const scale = newRange / oldRange;
+            const remap = (x) => min + (x - oldMin) * scale;
+            if (this._prop.mean != null)
+                this._prop.mean = remap(this._prop.mean);
+            if (this._prop.sigma != null)
+                this._prop.sigma *= scale;
+            if (this._prop.x0 != null)
+                this._prop.x0 = remap(this._prop.x0);
+            if (this._prop.k != null)
+                this._prop.k /= scale;
+            for (const p of this._prop.line)
+                p[0] = remap(p[0]);
+            if (this._prop.freeformLine) {
+                for (const p of this._prop.freeformLine)
+                    p[0] = remap(p[0]);
+            }
+        }
+        this._prop.min = min;
+        this._prop.max = max;
+        this.updateDragScales();
+        this.redrawAll(false);
+    }
+    setColumn(col) {
+        if (!col)
+            return;
+        const values = col.toList();
+        this.drawBars(values);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mpo-line-editor.js","sourceRoot":"","sources":["mpo-line-editor.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,OAAO,KAAK,IAAI,MAAM,mBAAmB,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAItC,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAE7B,IAAI,MAAgC,CAAC;AAErC,KAAK,UAAU,QAAQ;IACrB,IAAI,CAAC,MAAM;QACT,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;IAC3C,OAAO,MAAM,CAAC;AAChB,CAAC;AAID,kCAAkC;AAClC,MAAM,cAAc,GAAG,EAAC,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAC,CAAC;AAClE,MAAM,YAAY,GAAG,CAAC,CAAC;AAEvB,MAAM,MAAM,GAAG;IACb,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC;IAC5C,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC;IAC9C,OAAO,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC;IAC/C,SAAS,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;CAC/C,CAAC;AAEF,MAAM,WAAW;IAMf,YACU,IAAY,EACZ,IAAY,EACZ,KAAa,EACb,MAAc;QAHd,SAAI,GAAJ,IAAI,CAAQ;QACZ,SAAI,GAAJ,IAAI,CAAQ;QACZ,UAAK,GAAL,KAAK,CAAQ;QACb,WAAM,GAAN,MAAM,CAAQ;QAEtB,IAAI,CAAC,SAAS,GAAG,KAAK,GAAG,cAAc,CAAC,IAAI,GAAG,cAAc,CAAC,KAAK,CAAC;QACpE,IAAI,CAAC,UAAU,GAAG,MAAM,GAAG,cAAc,CAAC,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC;QACtE,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3F,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;IAChC,CAAC;IAED,cAAc,CAAC,CAAQ;QACrB,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QACvE,MAAM,OAAO,GAAG,cAAc,CAAC,GAAG,GAAG,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAE5E,OAAO,EAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAC,CAAC;IAClC,CAAC;IAED,YAAY,CAAC,OAAe,EAAE,OAAe;QAC3C,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QACtE,IAAI,KAAK,GAAG,CAAC,cAAc,CAAC,GAAG,GAAG,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QAE3E,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;QACxD,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAExC,OAAO,EAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAC,CAAC;IAC9B,CAAC;CACF;AAED,MAAM,OAAO,yBAAyB;IA4BpC,YAAY,IAA2B,EAAE,KAAa,EAAE,MAAc;QA3BtE,SAAI,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,4BAA4B,CAAC,CAAC;QAChD,cAAS,GAAG,IAAI,OAAO,EAAoB,CAAC;QAC5C,uBAAkB,GAAY,IAAI,CAAC;QAkBnC,+DAA+D;QACvD,oBAAe,GAAG,KAAK,CAAC;QACxB,eAAU,GAAG,CAAC,CAAC;QACf,eAAU,GAAG,CAAC,CAAC;QAKrB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,KAAK,IAAI,CAAC;QACrC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC;QACvC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,UAAU,CAAC;QAEtC,qBAAqB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IAC7D,CAAC;IAEO,iBAAiB;;QACvB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;YAC5B,OAAO;QAET,MAAM,GAAG,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,GAAG,mCAAI,CAAC,CAAC;QAChC,MAAM,GAAG,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,GAAG,mCAAI,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IAC7C,CAAC;IAEO,gBAAgB;QACtB,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,GAAG,cAAc,CAAC,IAAI,GAAG,cAAc,CAAC,KAAK,CAAC;QAC3E,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC;QAC7E,IAAI,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,SAAS,CAAC;QAChE,IAAI,CAAC,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC;IACnC,CAAC;IAEO,YAAY,CAAC,GAA2B,EAAE,KAAa,EAAE,MAAc;QAC7E,OAAO,CACL,GAAG,CAAC,CAAC,IAAI,cAAc,CAAC,IAAI;YAC5B,GAAG,CAAC,CAAC,IAAI,KAAK,GAAG,cAAc,CAAC,KAAK;YACrC,GAAG,CAAC,CAAC,IAAI,cAAc,CAAC,GAAG;YAC3B,GAAG,CAAC,CAAC,IAAI,MAAM,GAAG,cAAc,CAAC,MAAM,CACxC,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,KAAa,EAAE,MAAc;;QACnD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YAC5B,OAAO,CAAC,IAAI,CAAC,0CAA0C,CAAC,CAAC;YACzD,OAAO;SACR;QAED,MAAM,KAAK,GAAG,MAAM,QAAQ,EAAE,CAAC;QAC/B,IAAI,CAAC,SAAS,GAAG,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAEnC,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,KAAK,CAAC;YAC3B,SAAS,EAAE,IAAI,CAAC,IAAI;YACpB,KAAK;YACL,MAAM;SACP,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC/B,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAC/B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE3B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAE5B,oBAAoB;QACpB,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QAEzC,+BAA+B;QAC/B,IAAI,CAAC,SAAS,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC;YAC9B,MAAM,EAAE,EAAE;YACV,MAAM,EAAE,MAAM,CAAC,IAAI;YACnB,WAAW,EAAE,CAAC;YACd,OAAO,EAAE,OAAO;YAChB,QAAQ,EAAE,OAAO;SAClB,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAE/B,IAAI,CAAC,WAAW,GAAG,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QACrC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEjC,0BAA0B;QAC1B,IAAI,CAAC,QAAQ,GAAG,CAAC,SAAkB,IAAI,EAAE,EAAE;YACzC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAE5B,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY;gBAC3D,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;YAE5C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE;gBAClC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY;oBAC1B,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACjD,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;aACtC;YAED,IAAI,CAAC,WAAY,CAAC,eAAe,EAAE,CAAC;YACpC,MAAM,WAAW,GAAa,EAAE,CAAC;YAEjC,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACtE,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;iBAC9C,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACjE,MAAM,UAAU,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;YAEpE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;gBAC9B,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACnD,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;gBAErC,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU;oBAChC,OAAO;gBAET,MAAM,WAAW,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC;oBACnC,CAAC,EAAE,MAAM,CAAC,CAAC;oBACX,CAAC,EAAE,MAAM,CAAC,CAAC;oBACX,MAAM,EAAE,YAAY;oBACpB,IAAI,EAAE,OAAO;oBACb,MAAM,EAAE,MAAM,CAAC,IAAI;oBACnB,WAAW,EAAE,CAAC;oBACd,SAAS,EAAE,IAAI;oBACf,cAAc,EAAE,CAAC;iBAClB,CAAC,CAAC;gBAEH,mDAAmD;gBACnD,WAAW,CAAC,OAAO,CAAC,YAAY,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;gBAExD,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,EAAE;oBACjC,MAAM,MAAM,GAAG,GAAG,CAAC,MAAsB,CAAC;oBAC1C,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;oBAC9B,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;oBAC/C,MAAM,SAAS,GAAG,aAAa,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;oBAEnD,gEAAgE;oBAChE,MAAM,KAAK,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;oBACtF,MAAM,KAAK,GAAG,SAAS,GAAG,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;wBAClD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;wBAClD,IAAI,CAAC;oBAEP,yDAAyD;oBACzD,MAAM,MAAM,GAAG,CAAC,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,6BAA6B;oBAC7F,MAAM,UAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,KAAK,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBACtF,MAAM,UAAU,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,KAAK,GAAG,CAAC,SAAS,GAAG,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAE7G,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBAE1D,MAAM,OAAO,GAAG,cAAc,CAAC,GAAG,CAAC;oBACnC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,GAAG,cAAc,CAAC,MAAM,CAAC;oBACxD,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBAEvD,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;oBAErB,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;oBACrD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;oBAC7C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;oBAE7C,MAAM,kBAAkB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;wBAC5D,mEAAmE;wBACnE,IAAI,GAAG,KAAK,SAAS;4BACnB,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;6BACnB;4BACH,MAAM,CAAC,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;4BACtD,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;yBACnB;oBACH,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;oBAEV,IAAI,CAAC,SAAU,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;oBAC3C,IAAI,CAAC,KAAM,CAAC,SAAS,EAAE,CAAC;gBAC1B,CAAC,CAAC,CAAC;gBAEH,WAAW,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;;oBAC7B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC5C,MAAA,IAAI,CAAC,QAAQ,oDAAI,CAAC;gBACpB,CAAC,CAAC,CAAC;gBAEH,WAAW,CAAC,EAAE,CAAC,aAAa,EAAE,CAAC,GAAG,EAAE,EAAE;;oBACpC,GAAG,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;oBACzB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE;wBAC/B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,8CAA8C,CAAC,CAAC;wBACnE,OAAO;qBACR;oBAED,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;oBAC5B,MAAM,MAAM,GAAG,GAAG,CAAC,MAAsB,CAAC;oBAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,YAAY,CAAW,CAAC;oBAEzD,IAAI,SAAS,IAAI,CAAC,EAAE;wBAClB,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI;4BACxB,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;wBAClC,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,IAAI;4BACxB,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;wBAClC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;wBACrC,MAAA,IAAI,CAAC,QAAQ,oDAAI,CAAC;qBACnB;gBACH,CAAC,CAAC,CAAC;gBAEH,WAAW,CAAC,EAAE,CAAC,YAAY,EAAE,CAAC,GAAG,EAAE,EAAE;oBACnC,IAAI,CAAC,KAAM,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC;oBACjD,MAAM,MAAM,GAAG,GAAG,CAAC,MAAsB,CAAC;oBAC1C,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;oBAC9B,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;oBACrD,MAAM,WAAW,GAAG,MAAM,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,mEAAmE,CAAC;oBACpJ,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBACjE,CAAC,CAAC,CAAC;gBAEH,WAAW,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,EAAE;oBAChC,IAAI,CAAC,KAAM,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC;oBACjD,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;gBACpB,CAAC,CAAC,CAAC;gBAEH,WAAW,CAAC,EAAE,CAAC,iBAAiB,EAAE,CAAC,GAAG,EAAE,EAAE;oBACxC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;oBAC5B,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;oBAClB,MAAM,SAAS,GAAI,GAAG,CAAC,MAAuB,CAAC,OAAO,CAAC,YAAY,CAAW,CAAC;oBAC/E,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBACpE,CAAC,CAAC,CAAC;gBAEH,IAAI,CAAC,WAAY,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YACrC,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,SAAU,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;YACpC,IAAI,CAAC,KAAM,CAAC,SAAS,EAAE,CAAC;YAExB,kEAAkE;YAClE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YAEjD,IAAI,MAAM;gBACR,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC,CAAC;QAEF,kCAAkC;QAClC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,EAAE;;YACjC,IAAI,IAAI,CAAC,eAAe,EAAE;gBACxB,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;gBAC7B,OAAO;aACR;YAED,IAAI,GAAG,CAAC,MAAM,YAAY,KAAK,CAAC,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,MAAM,KAAK,CAAC;gBAC5D,OAAO;YAET,MAAM,GAAG,GAAG,MAAA,IAAI,CAAC,KAAK,0CAAE,kBAAkB,EAAE,CAAC;YAC7C,IAAI,CAAC,GAAG;gBACN,OAAO;YAET,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;YAE5B,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,KAAM,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,KAAM,CAAC,MAAM,EAAE,CAAC;gBACpE,OAAO;YAET,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,KAAM,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,KAAM,CAAC,MAAM,EAAE,CAAC,CAAC;YACtF,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;YAErD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YACnD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5C,MAAA,IAAI,CAAC,QAAQ,oDAAI,CAAC;QACpB,CAAC,CAAC,CAAC;QAEH,gBAAgB;QAChB,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,GAAG,EAAE,EAAE;YACjC,IAAI,CAAC,IAAI,CAAC,KAAK;gBACb,OAAO;YACT,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC;YAC5C,IAAI,CAAC,GAAG;gBACN,OAAO;YAET,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE;gBAClC,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC;oBACnD,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;;oBAE7C,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC;aACnD;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;QAEnD,6BAA6B;QAC7B,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAExB,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;YAC1C,MAAM,EAAC,WAAW,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAC,GAAG,IAAI,CAAC,IAAI,CAAC;YACpD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC;gBAChB,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACtB,CAAC,CAAC,CAAC;QAEH,eAAe;QACf,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACzB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;YACrC,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;SACnC;QACD,MAAA,IAAI,CAAC,QAAQ,qDAAG,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;IACzB,CAAC;IAEO,WAAW;;;QACjB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU;YAChC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;QAEzB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,GAAqB,EAAE,CAAC;QAElC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YAC3B,MAAM,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACzC,IAAI,CAAC,GAAG,CAAC,CAAC;YAEV,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE;gBAClC,YAAA,IAAI,CAAC,KAAK,EAAC,IAAI,uCAAJ,IAAI,GAAK,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAC;gBACtC,YAAA,IAAI,CAAC,KAAK,EAAC,KAAK,uCAAL,KAAK,GAAK,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAC;gBACvC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;gBAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;gBAC/B,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC;gBAC7B,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;aAC5B;YAED,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE;gBACjC,YAAA,IAAI,CAAC,KAAK,EAAC,EAAE,uCAAF,EAAE,GAAK,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAC;gBACpC,YAAA,IAAI,CAAC,KAAK,EAAC,CAAC,uCAAD,CAAC,GAAK,EAAE,EAAC;gBACpB,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACzB,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBACvB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;aACvC;YAED,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SACnB;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,QAAQ,CAAC,IAAY,EAAE,IAAY,EAAE,KAAa,EAAE,MAAc;QACxE,MAAM,SAAS,GAAG,gBAAgB,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,SAAS,CAAC;QAC9G,IAAI,CAAC,KAAM,CAAC,GAAG,CACb,IAAI,MAAO,CAAC,IAAI,CAAC;YACf,MAAM,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAC,MAAM,EAAE,KAAK,GAAG,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC;YAC3H,MAAM,EAAE,SAAS;YACjB,WAAW,EAAE,CAAC;SACf,CAAC,EACF,IAAI,MAAO,CAAC,IAAI,CAAC;YACf,MAAM,EAAE,CAAC,cAAc,CAAC,IAAI,EAAE,cAAc,CAAC,GAAG,EAAE,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC;YACtG,MAAM,EAAE,SAAS;YACjB,WAAW,EAAE,CAAC;SACf,CAAC,EACF,IAAI,MAAO,CAAC,IAAI,CAAC,EAAC,CAAC,EAAE,cAAc,CAAC,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,EACnI,IAAI,MAAO,CAAC,IAAI,CAAC,EAAC,CAAC,EAAE,KAAK,GAAG,cAAc,CAAC,KAAK,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAC,CAAC,CAClJ,CAAC;IACJ,CAAC;IAED,OAAO;;QACL,OAAO,MAAA,MAAA,IAAI,CAAC,KAAK,CAAC,GAAG,mCAAI,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,mCAAI,CAAC,CAAC;IAC9E,CAAC;IAED,OAAO;;QACL,OAAO,MAAA,MAAA,IAAI,CAAC,KAAK,CAAC,GAAG,mCAAI,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,mCAAI,CAAC,CAAC;IAC9E,CAAC;IAED,cAAc;QACZ,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,YAAY;QACV,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IAED,WAAW;QACT,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,SAAS,CAAC,SAAkB,IAAI;QAC9B,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ;YAC9C,OAAO;QAET,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QACnC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAE5B,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC;QAE7B,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QAEzC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,SAAU,EAAE,IAAI,CAAC,WAAY,CAAC,CAAC;QAEnD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAEtB,IAAI,IAAI,CAAC,SAAS;YAChB,IAAI,CAAC,QAAQ,EAAE,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,KAAa,EAAE,MAAc;QAClC,IAAI,KAAK,KAAK,IAAI,CAAC,MAAM,IAAI,MAAM,KAAK,IAAI,CAAC,OAAO;YAClD,OAAO;QAET,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QAEtB,IAAI,IAAI,CAAC,KAAK,EAAE;YACd,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACxB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAC1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;SACvB;IACH,CAAC;IAED,QAAQ,CAAC,MAAiB;;QACxB,IAAI,MAAM;YACR,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC;QAE1B,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC;YAC/B,OAAO;SACR;QACD,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,CAAC;QAEjC,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;YAChD,OAAO;QAET,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QACxC,IAAI,CAAC,KAAK,EAAE;YACV,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC;YAC/B,OAAO;SACR;QAED,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QAE9B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAE5B,IAAI,IAAI,KAAK,IAAI;YACf,OAAO;QAET,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,MAAM,SAAS,GAAG,KAAK,GAAG,cAAc,CAAC,IAAI,GAAG,cAAc,CAAC,KAAK,CAAC;QACrE,MAAM,UAAU,GAAG,MAAM,GAAG,cAAc,CAAC,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC;QAEvE,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC;QACzD,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAExC,CAAC,MAAA,IAAI,CAAC,SAAS,mCAAI,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YACnC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,QAAQ,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;YACrE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACd,CAAC,CAAC,CAAC;QAEH,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC;QAExC,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACxB,MAAM,IAAI,GAAG,cAAc,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,QAAQ,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;YAC9E,MAAM,IAAI,GAAG,CAAC,QAAQ,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC;YACxD,MAAM,IAAI,GAAG,CAAC,KAAK,GAAG,QAAQ,CAAC,GAAG,UAAU,CAAC;YAE7C,MAAM,IAAI,GAAG,IAAI,MAAO,CAAC,IAAI,CAAC;gBAC5B,CAAC,EAAE,IAAI;gBACP,CAAC,EAAE,cAAc,CAAC,GAAG,GAAG,UAAU,GAAG,IAAI;gBACzC,KAAK,EAAE,IAAI;gBACX,MAAM,EAAE,IAAI;gBACZ,IAAI,EAAE,MAAM,CAAC,OAAO;gBACpB,OAAO,EAAE,IAAI;gBACb,MAAM,EAAE,MAAM,CAAC,SAAS;gBACxB,WAAW,EAAE,GAAG;aACjB,CAAC,CAAC;YAEH,IAAI,CAAC,SAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,SAAU,CAAC,SAAS,EAAE,CAAC;IAC9B,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,IAAI,CAAC,KAAK;YACb,OAAO;QAET,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,YAAY,GAAkC,IAAI,CAAC;QACvD,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,MAAM,GAAG,CAAC,CAAC;QAEf,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,sBAAsB,EAAE,CAAC,GAAG,EAAE,EAAE;;YAC5C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU;gBAChC,OAAO;YACT,IAAI,CAAC,GAAG,CAAC,GAAG;gBACV,OAAO;YAET,MAAM,GAAG,GAAG,IAAI,CAAC,KAAM,CAAC,kBAAkB,EAAE,CAAC;YAC7C,IAAI,CAAC,GAAG;gBACN,OAAO;YAET,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC;gBACpD,OAAO;YAET,QAAQ,GAAG,IAAI,CAAC;YAChB,YAAY,GAAG,GAAG,CAAC;YAEnB,SAAS,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,IAAI,mCAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;YACrE,UAAU,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,KAAK,mCAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;YACvE,OAAO,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,EAAE,mCAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC;YACjE,MAAM,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,CAAC,mCAAI,EAAE,CAAC;YAE5B,IAAI,CAAC,KAAM,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC;QACpD,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,qBAAqB,EAAE,CAAC,GAAG,EAAE,EAAE;;YAC3C,IAAI,CAAC,QAAQ,IAAI,CAAC,YAAY;gBAC5B,OAAO;YAET,MAAM,GAAG,GAAG,IAAI,CAAC,KAAM,CAAC,kBAAkB,EAAE,CAAC;YAC7C,IAAI,CAAC,GAAG;gBACN,OAAO;YAET,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;YAClC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;YAElC,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE;gBAClC,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC;gBACnD,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;aAC7G;YAED,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE;gBACjC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,OAAO,GAAG,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC;gBAC/C,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC,CAAC;aACrE;YAED,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;YACrC,MAAA,IAAI,CAAC,QAAQ,oDAAI,CAAC;YAClB,MAAA,IAAI,CAAC,eAAe,qDAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,kBAAkB,EAAE,GAAG,EAAE;YACrC,QAAQ,GAAG,KAAK,CAAC;YACjB,YAAY,GAAG,IAAI,CAAC;YACpB,IAAI,CAAC,KAAM,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC;QACnD,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,gBAAgB,CAAC,KAAa,EAAE,MAAc;;QACpD,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,GAAW,EAAE,GAAW,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAEvF,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU;YAChC,OAAO;QAET,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QAE1D,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;QAC1B,IAAI,CAAC,GAAG,GAAG,CAAC;QAEZ,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE;YAClC,CAAC,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,IAAI,mCAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;YACzC,CAAC,GAAG,CAAC,CAAC;SACP;aAAM,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE;YACxC,CAAC,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,EAAE,mCAAI,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;YACvC,CAAC,GAAG,GAAG,CAAC;SACT;QAED,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAE7C,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,IAAI,CAAC,aAAa,GAAG,IAAI,MAAO,CAAC,MAAM,CAAC;gBACtC,CAAC,EAAE,MAAM,CAAC,CAAC;gBACX,CAAC,EAAE,MAAM,CAAC,CAAC;gBACX,MAAM,EAAE,CAAC;gBACT,IAAI,EAAE,MAAM,CAAC,MAAM;gBACnB,SAAS,EAAE,IAAI;gBACf,cAAc,EAAE,EAAE;aACnB,CAAC,CAAC;YAEH,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,EAAE;;gBACxC,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;gBAClC,MAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;gBAE/C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,EAAE;oBAClC,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC;oBACzB,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;iBACzD;qBAAM,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE;oBACxC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC;oBACvB,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;iBAC5D;gBAED,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrC,MAAA,IAAI,CAAC,QAAQ,oDAAI,CAAC;gBAClB,MAAA,IAAI,CAAC,eAAe,qDAAG,IAAI,CAAC,KAAK,CAAC,CAAC;YACrC,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,KAAM,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SACrC;aAAM;YACL,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE;gBAChC,IAAI,CAAC,KAAM,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACtC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;SACrC;QACD,IAAI,CAAC,KAAM,CAAC,SAAS,EAAE,CAAC;IAC1B,CAAC;IAEO,eAAe,CAAC,SAAiB,EAAE,OAAe,EAAE,OAAe;QACzE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACzC,MAAM,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAC,CAAC,CAAC;QAC7H,MAAM,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,EAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAC,CAAC,CAAC;QAEnG,MAAM,KAAK,GAAG,GAAG,EAAE;YACjB,OAAO,CAAC,mBAAmB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YAC9C,KAAK,CAAC,MAAM,EAAE,CAAC;QACjB,CAAC,CAAC;QAEF,MAAM,KAAK,GAAG,GAAG,EAAE;YACjB,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;YACvB,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;YACvB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;gBAChD,OAAO;YACT,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACpC,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,CAAC,CAAC;QAEF,MAAM,KAAK,GAAG,CAAC,CAAgB,EAAE,EAAE;YACjC,IAAI,CAAC,CAAC,GAAG,KAAK,OAAO,EAAE;gBACrB,KAAK,EAAE,CAAC;gBACR,KAAK,EAAE,CAAC;aACT;YACD,IAAI,CAAC,CAAC,GAAG,KAAK,QAAQ;gBACpB,KAAK,EAAE,CAAC;QACZ,CAAC,CAAC;QAEF,MAAM,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAC5C,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAClC,OAAO,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAE3C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;QACnD,MAAM,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,EAAC,EAAE,EAAE,OAAO,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,OAAO,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAC,CAAC,CAAC;IAC7H,CAAC;IAED,QAAQ,CAAC,GAAW,EAAE,GAAW;QAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC9B,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;QACjC,MAAM,QAAQ,GAAG,GAAG,GAAG,GAAG,CAAC;QAE3B,IAAI,QAAQ,KAAK,CAAC,IAAI,QAAQ,KAAK,CAAC,EAAE;YACpC,MAAM,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;YAClC,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC;YAExD,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI;gBACzB,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI;gBAC1B,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC;YAC5B,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,IAAI;gBACvB,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACvC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,IAAI;gBACtB,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,CAAC;YAExB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI;gBAC7B,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAErB,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE;gBAC3B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY;oBACrC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;aACtB;SACF;QAED,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC;QACrB,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC;QACrB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAED,SAAS,CAAC,GAAqB;QAC7B,IAAI,CAAC,GAAG;YACN,OAAO;QAET,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC;QAC5B,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACxB,CAAC;CACF","sourcesContent":["/* eslint-disable max-len */\nimport * as grok from 'datagrok-api/grok';\nimport * as ui from 'datagrok-api/ui';\nimport * as DG from 'datagrok-api/dg';\n\nimport type Konva from 'konva';\nimport {DesirabilityLine, NumericalDesirability} from '../mpo';\nimport {Subject} from 'rxjs';\n\nlet _konva: typeof Konva | undefined;\n\nasync function getKonva(): Promise<typeof Konva> {\n  if (!_konva)\n    _konva = (await import('konva')).default;\n  return _konva;\n}\n\ntype Point = [number, number];\n\n// Constants for the editor layout\nconst EDITOR_PADDING = {top: 10, right: 10, bottom: 20, left: 30};\nconst POINT_RADIUS = 3;\n\nconst COLORS = {\n  line: DG.Color.toHtml(DG.Color.filteredRows),\n  handle: DG.Color.toHtml(DG.Color.selectedRows),\n  barFill: DG.Color.toHtml(DG.Color.histogramBar),\n  barStroke: DG.Color.toHtml(DG.Color.lightGray),\n};\n\nclass CoordMapper {\n  private plotWidth: number;\n  private plotHeight: number;\n  private scaleX: number;\n  private scaleY: number;\n\n  constructor(\n    private minX: number,\n    private maxX: number,\n    private width: number,\n    private height: number,\n  ) {\n    this.plotWidth = width - EDITOR_PADDING.left - EDITOR_PADDING.right;\n    this.plotHeight = height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;\n    this.scaleX = (this.maxX - this.minX === 0) ? 1 : this.plotWidth / (this.maxX - this.minX);\n    this.scaleY = this.plotHeight;\n  }\n\n  toCanvasCoords(p: Point): {x: number, y: number} {\n    const canvasX = EDITOR_PADDING.left + (p[0] - this.minX) * this.scaleX;\n    const canvasY = EDITOR_PADDING.top + this.plotHeight - (p[1] * this.scaleY);\n\n    return {x: canvasX, y: canvasY};\n  }\n\n  toDataCoords(canvasX: number, canvasY: number): {x: number, y: number} {\n    let dataX = this.minX + (canvasX - EDITOR_PADDING.left) / this.scaleX;\n    let dataY = (EDITOR_PADDING.top + this.plotHeight - canvasY) / this.scaleY;\n\n    dataX = Math.max(this.minX, Math.min(this.maxX, dataX));\n    dataY = Math.max(0, Math.min(1, dataY));\n\n    return {x: dataX, y: dataY};\n  }\n}\n\nexport class MpoDesirabilityLineEditor {\n  root = ui.div([], 'statistics-mpo-line-editor');\n  onChanged = new Subject<DesirabilityLine>();\n  supportsModeDialog: boolean = true;\n\n  private _prop: NumericalDesirability;\n  private barsLayer?: Konva.Layer;\n  private pendingBarValues?: number[];\n\n  private stage?: Konva.Stage;\n  private layer?: Konva.Layer;\n\n  private konvaLine?: Konva.Line;\n  private pointsGroup?: Konva.Group;\n  private barValues?: number[];\n\n  private redrawFn!: (notify?: boolean) => void;\n\n  private specialHandle?: Konva.Circle;\n  onParamsChanged?: (prop: NumericalDesirability) => void;\n\n  // Flag to prevent touchpad right-click from adding a new point\n  private ignoreNextClick = false;\n  private dragScaleX = 0;\n  private dragScaleY = 0;\n  private _width: number;\n  private _height: number;\n\n  constructor(prop: NumericalDesirability, width: number, height: number) {\n    this._prop = prop;\n    this._width = width;\n    this._height = height;\n    this.ensureDefaultLine();\n    this.root.style.width = `${width}px`;\n    this.root.style.height = `${height}px`;\n    this.root.style.position = 'relative';\n\n    requestAnimationFrame(() => this.initKonva(width, height));\n  }\n\n  private ensureDefaultLine(): void {\n    if (this._prop.line.length > 0)\n      return;\n\n    const min = this._prop.min ?? 0;\n    const max = this._prop.max ?? 1;\n    this._prop.line = [[min, 0.5], [max, 0.5]];\n  }\n\n  private updateDragScales(): void {\n    const plotWidth = this._width - EDITOR_PADDING.left - EDITOR_PADDING.right;\n    const plotHeight = this._height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;\n    this.dragScaleX = (this.getMaxX() - this.getMinX()) / plotWidth;\n    this.dragScaleY = 1 / plotHeight;\n  }\n\n  private isInPlotArea(pos: {x: number, y: number}, width: number, height: number) {\n    return (\n      pos.x >= EDITOR_PADDING.left &&\n      pos.x <= width - EDITOR_PADDING.right &&\n      pos.y >= EDITOR_PADDING.top &&\n      pos.y <= height - EDITOR_PADDING.bottom\n    );\n  }\n\n  private async initKonva(width: number, height: number) {\n    if (!this.root.parentElement) {\n      console.warn('Konva container not attached to DOM yet.');\n      return;\n    }\n\n    const Konva = await getKonva();\n    this.barsLayer = new Konva.Layer();\n\n    this.stage = new Konva.Stage({\n      container: this.root,\n      width,\n      height,\n    });\n\n    this.stage.add(this.barsLayer);\n    this.layer = new Konva.Layer();\n    this.stage.add(this.layer);\n\n    const minX = this.getMinX();\n    const maxX = this.getMaxX();\n\n    // --- Draw Axes ---\n    this.drawAxes(minX, maxX, width, height);\n\n    // --- Draw Line and Points ---\n    this.konvaLine = new Konva.Line({\n      points: [],\n      stroke: COLORS.line,\n      strokeWidth: 2,\n      lineCap: 'round',\n      lineJoin: 'round',\n    });\n    this.layer.add(this.konvaLine);\n\n    this.pointsGroup = new Konva.Group();\n    this.layer.add(this.pointsGroup);\n\n    // --- Redraw Function ---\n    this.redrawFn = (notify: boolean = true) => {\n      const minX = this.getMinX();\n      const maxX = this.getMaxX();\n\n      if (this._prop.mode === 'freeform' && this._prop.freeformLine)\n        this._prop.line = this._prop.freeformLine;\n\n      if (this._prop.mode !== 'freeform') {\n        if (!this._prop.freeformLine)\n          this._prop.freeformLine = [...this._prop.line];\n        this._prop.line = this.computeLine();\n      }\n\n      this.pointsGroup!.destroyChildren();\n      const konvaPoints: number[] = [];\n\n      const mapper = new CoordMapper(minX, maxX, this._width, this._height);\n      const sortedIndices = [...this._prop.line.keys()]\n        .sort((a, b) => this._prop.line[a][0] - this._prop.line[b][0]);\n      const sortedLine = sortedIndices.map((idx) => this._prop.line[idx]);\n\n      sortedLine.forEach((p, index) => {\n        const coords = mapper.toCanvasCoords([p[0], p[1]]);\n        konvaPoints.push(coords.x, coords.y);\n\n        if (this._prop.mode !== 'freeform')\n          return;\n\n        const pointCircle = new Konva.Circle({\n          x: coords.x,\n          y: coords.y,\n          radius: POINT_RADIUS,\n          fill: 'white',\n          stroke: COLORS.line,\n          strokeWidth: 1,\n          draggable: true,\n          hitStrokeWidth: 5,\n        });\n\n        // Store index directly on the node for easy access\n        pointCircle.setAttr('_dataIndex', sortedIndices[index]);\n\n        pointCircle.on('dragmove', (evt) => {\n          const circle = evt.target as Konva.Circle;\n          const pos = circle.position();\n          const dataIndex = circle.getAttr('_dataIndex');\n          const sortedPos = sortedIndices.indexOf(dataIndex);\n\n          // Constrain dragging horizontally between neighbors (or bounds)\n          const prevX = sortedPos > 0 ? this._prop.line[sortedIndices[sortedPos - 1]][0] : minX;\n          const nextX = sortedPos < sortedIndices.length - 1 ?\n            this._prop.line[sortedIndices[sortedPos + 1]][0] :\n            maxX;\n\n          // Add a small buffer to avoid points overlapping exactly\n          const buffer = (maxX - minX === 0) ? 0 : 0.001 * (maxX - minX); // Avoid NaN if minX === maxX\n          const minCanvasX = mapper.toCanvasCoords([prevX + (sortedPos > 0 ? buffer : 0), 0]).x;\n          const maxCanvasX = mapper.toCanvasCoords([nextX - (sortedPos < sortedIndices.length - 1 ? buffer : 0), 0]).x;\n\n          pos.x = Math.max(minCanvasX, Math.min(maxCanvasX, pos.x));\n\n          const plotTop = EDITOR_PADDING.top;\n          const plotBottom = this._height - EDITOR_PADDING.bottom;\n          pos.y = Math.max(plotTop, Math.min(plotBottom, pos.y));\n\n          circle.position(pos);\n\n          const dataCoords = mapper.toDataCoords(pos.x, pos.y);\n          this._prop.line[dataIndex][0] = dataCoords.x;\n          this._prop.line[dataIndex][1] = dataCoords.y;\n\n          const currentKonvaPoints = this._prop.line.map((pData, idx) => {\n            // Use dragged circle position directly for the point being dragged\n            if (idx === dataIndex)\n              return [pos.x, pos.y];\n            else {\n              const c = mapper.toCanvasCoords([pData[0], pData[1]]);\n              return [c.x, c.y];\n            }\n          }).flat();\n\n          this.konvaLine!.points(currentKonvaPoints);\n          this.layer!.batchDraw();\n        });\n\n        pointCircle.on('dragend', () => {\n          this._prop.line.sort((a, b) => a[0] - b[0]);\n          this.redrawFn?.();\n        });\n\n        pointCircle.on('contextmenu', (evt) => {\n          evt.evt.preventDefault();\n          if (this._prop.line.length <= 2) {\n            grok.shell.warning('Cannot remove points, minimum of 2 required.');\n            return;\n          }\n\n          this.ignoreNextClick = true;\n          const circle = evt.target as Konva.Circle;\n          const dataIndex = circle.getAttr('_dataIndex') as number;\n\n          if (dataIndex >= 0) {\n            if (this._prop.min == null)\n              this._prop.min = this.getMinX();\n            if (this._prop.max == null)\n              this._prop.max = this.getMaxX();\n            this._prop.line.splice(dataIndex, 1);\n            this.redrawFn?.();\n          }\n        });\n\n        pointCircle.on('mouseenter', (evt) => {\n          this.stage!.container().style.cursor = 'pointer';\n          const circle = evt.target as Konva.Circle;\n          const pos = circle.position();\n          const dataCoords = mapper.toDataCoords(pos.x, pos.y);\n          const tooltipText = `X: ${dataCoords.x.toFixed(2)}, Y: ${dataCoords.y.toFixed(2)}<br><br>Drag to move, double-click to edit, right-click to delete`;\n          ui.tooltip.show(tooltipText, evt.evt.clientX, evt.evt.clientY);\n        });\n\n        pointCircle.on('mouseleave', () => {\n          this.stage!.container().style.cursor = 'default';\n          ui.tooltip.hide();\n        });\n\n        pointCircle.on('dblclick dbltap', (evt) => {\n          this.ignoreNextClick = true;\n          ui.tooltip.hide();\n          const dataIndex = (evt.target as Konva.Circle).getAttr('_dataIndex') as number;\n          this.showPointEditor(dataIndex, evt.evt.clientX, evt.evt.clientY);\n        });\n\n        this.pointsGroup!.add(pointCircle);\n      });\n\n      this.konvaLine!.points(konvaPoints);\n      this.layer!.batchDraw();\n\n      // --- Add special handle (Gaussian peak / Sigmoid inflection) ---\n      this.addSpecialHandle(this._width, this._height);\n\n      if (notify)\n        this.onChanged.next(this._prop.line);\n    };\n\n    // --- Left-click to Add Point ---\n    this.stage.on('click tap', (evt) => {\n      if (this.ignoreNextClick) {\n        this.ignoreNextClick = false;\n        return;\n      }\n\n      if (evt.target instanceof Konva.Circle || evt.evt.button !== 0)\n        return;\n\n      const pos = this.stage?.getPointerPosition();\n      if (!pos)\n        return;\n\n      const minX = this.getMinX();\n      const maxX = this.getMaxX();\n\n      if (!this.isInPlotArea(pos, this.stage!.width(), this.stage!.height()))\n        return;\n\n      const mapper = new CoordMapper(minX, maxX, this.stage!.width(), this.stage!.height());\n      const dataCoords = mapper.toDataCoords(pos.x, pos.y);\n\n      this._prop.line.push([dataCoords.x, dataCoords.y]);\n      this._prop.line.sort((a, b) => a[0] - b[0]);\n      this.redrawFn?.();\n    });\n\n    // Cursor change\n    this.stage.on('mousemove', (evt) => {\n      if (!this.stage)\n        return;\n      const pos = this.stage.getPointerPosition();\n      if (!pos)\n        return;\n\n      if (this._prop.mode !== 'freeform') {\n        if (this.isInPlotArea(pos, this._width, this._height))\n          this.stage.container().style.cursor = 'grab';\n        else\n          this.stage.container().style.cursor = 'default';\n      }\n    });\n\n    this.stage.on('mouseout', () => ui.tooltip.hide());\n\n    // Enable curve drag (smooth)\n    this.enableCurveDrag();\n    this.updateDragScales();\n\n    ui.onSizeChanged(this.root).subscribe((_) => {\n      const {clientWidth: w, clientHeight: h} = this.root;\n      if (w > 0 && h > 0)\n        this.resize(w, h);\n    });\n\n    // Initial draw\n    if (this.pendingBarValues) {\n      this.drawBars(this.pendingBarValues);\n      this.pendingBarValues = undefined;\n    }\n    this.redrawFn?.(false);\n  }\n\n  get line(): DesirabilityLine {\n    return this._prop.line;\n  }\n\n  private computeLine(): DesirabilityLine {\n    if (this._prop.mode === 'freeform')\n      return this._prop.line;\n\n    const minX = this.getMinX();\n    const maxX = this.getMaxX();\n    const n = 60;\n    const line: DesirabilityLine = [];\n\n    for (let i = 0; i <= n; i++) {\n      const x = minX + (maxX - minX) * (i / n);\n      let y = 0;\n\n      if (this._prop.mode === 'gaussian') {\n        this._prop.mean ??= (minX + maxX) / 2;\n        this._prop.sigma ??= (maxX - minX) / 6;\n        const mean = this._prop.mean;\n        const sigma = this._prop.sigma;\n        const z = (x - mean) / sigma;\n        y = Math.exp(-0.5 * z * z);\n      }\n\n      if (this._prop.mode === 'sigmoid') {\n        this._prop.x0 ??= (minX + maxX) / 2;\n        this._prop.k ??= 10;\n        const x0 = this._prop.x0;\n        const k = this._prop.k;\n        y = 1 / (1 + Math.exp(-k * (x - x0)));\n      }\n\n      line.push([x, y]);\n    }\n\n    return line;\n  }\n\n  private drawAxes(minX: number, maxX: number, width: number, height: number) {\n    const axisColor = getComputedStyle(document.documentElement).getPropertyValue('--grey-2').trim() || '#DBDCDF';\n    this.layer!.add(\n      new _konva!.Line({\n        points: [EDITOR_PADDING.left, height - EDITOR_PADDING.bottom, width - EDITOR_PADDING.right, height - EDITOR_PADDING.bottom],\n        stroke: axisColor,\n        strokeWidth: 1,\n      }),\n      new _konva!.Line({\n        points: [EDITOR_PADDING.left, EDITOR_PADDING.top, EDITOR_PADDING.left, height - EDITOR_PADDING.bottom],\n        stroke: axisColor,\n        strokeWidth: 1,\n      }),\n      new _konva!.Text({x: EDITOR_PADDING.left, y: height - EDITOR_PADDING.bottom + 3, text: minX.toFixed(1), fontSize: 9, fill: 'grey'}),\n      new _konva!.Text({x: width - EDITOR_PADDING.right - 15, y: height - EDITOR_PADDING.bottom + 3, text: maxX.toFixed(1), fontSize: 9, fill: 'grey'}),\n    );\n  }\n\n  getMinX(): number {\n    return this._prop.min ?? Math.min(...this._prop.line.map((p) => p[0])) ?? 0;\n  }\n\n  getMaxX(): number {\n    return this._prop.max ?? Math.max(...this._prop.line.map((p) => p[0])) ?? 1;\n  }\n\n  getDefaultMean(): number {\n    return (this.getMinX() + this.getMaxX()) / 2;\n  }\n\n  getDefaultSigma(): number {\n    return Math.max(0.01, (this.getMaxX() - this.getMinX()) / 6);\n  }\n\n  getDefaultX0(): number {\n    return (this.getMinX() + this.getMaxX()) / 2;\n  }\n\n  getDefaultK(): number {\n    return 10;\n  }\n\n  redrawAll(notify: boolean = true): void {\n    if (!this.stage || !this.layer || !this.redrawFn)\n      return;\n\n    const width = this.stage.width();\n    const height = this.stage.height();\n    const minX = this.getMinX();\n    const maxX = this.getMaxX();\n\n    this.layer.destroyChildren();\n\n    this.drawAxes(minX, maxX, width, height);\n\n    this.layer.add(this.konvaLine!, this.pointsGroup!);\n\n    this.redrawFn(notify);\n\n    if (this.barValues)\n      this.drawBars();\n  }\n\n  resize(width: number, height: number): void {\n    if (width === this._width && height === this._height)\n      return;\n\n    this._width = width;\n    this._height = height;\n\n    if (this.stage) {\n      this.stage.width(width);\n      this.stage.height(height);\n      this.updateDragScales();\n      this.redrawAll(false);\n    }\n  }\n\n  drawBars(values?: number[]) {\n    if (values)\n      this.barValues = values;\n\n    if (!this.barsLayer) {\n      this.pendingBarValues = values;\n      return;\n    }\n    this.barsLayer.destroyChildren();\n\n    if (!this.barValues || this.barValues.length === 0)\n      return;\n\n    const stage = this.barsLayer.getStage();\n    if (!stage) {\n      this.pendingBarValues = values;\n      return;\n    }\n\n    const width = stage.width();\n    const height = stage.height();\n\n    const minX = this.getMinX();\n    const maxX = this.getMaxX();\n\n    if (maxX === minX)\n      return;\n\n    const numBins = 20;\n    const plotWidth = width - EDITOR_PADDING.left - EDITOR_PADDING.right;\n    const plotHeight = height - EDITOR_PADDING.top - EDITOR_PADDING.bottom;\n\n    const binWidth = Math.max(1e-9, (maxX - minX) / numBins);\n    const bins = new Array(numBins).fill(0);\n\n    (this.barValues ?? []).forEach((v) => {\n      const idx = Math.min(Math.floor((v - minX) / binWidth), numBins - 1);\n      bins[idx]++;\n    });\n\n    const maxCount = Math.max(...bins) || 1;\n\n    bins.forEach((count, i) => {\n      const barX = EDITOR_PADDING.left + (i * binWidth / (maxX - minX)) * plotWidth;\n      const barW = (binWidth / (maxX - minX)) * plotWidth - 1;\n      const barH = (count / maxCount) * plotHeight;\n\n      const rect = new _konva!.Rect({\n        x: barX,\n        y: EDITOR_PADDING.top + plotHeight - barH,\n        width: barW,\n        height: barH,\n        fill: COLORS.barFill,\n        opacity: 0.25,\n        stroke: COLORS.barStroke,\n        strokeWidth: 0.5,\n      });\n\n      this.barsLayer!.add(rect);\n    });\n\n    this.barsLayer!.batchDraw();\n  }\n\n  private enableCurveDrag() {\n    if (!this.stage)\n      return;\n\n    let dragging = false;\n    let startPointer: {x: number, y: number} | null = null;\n    let startMean = 0;\n    let startSigma = 0;\n    let startX0 = 0;\n    let startK = 0;\n\n    this.stage.on('mousedown touchstart', (evt) => {\n      if (this._prop.mode === 'freeform')\n        return;\n      if (!evt.evt)\n        return;\n\n      const pos = this.stage!.getPointerPosition();\n      if (!pos)\n        return;\n\n      if (!this.isInPlotArea(pos, this._width, this._height))\n        return;\n\n      dragging = true;\n      startPointer = pos;\n\n      startMean = this._prop.mean ?? (this.getMinX() + this.getMaxX()) / 2;\n      startSigma = this._prop.sigma ?? (this.getMaxX() - this.getMinX()) / 6;\n      startX0 = this._prop.x0 ?? (this.getMinX() + this.getMaxX()) / 2;\n      startK = this._prop.k ?? 10;\n\n      this.stage!.container().style.cursor = 'grabbing';\n    });\n\n    this.stage.on('mousemove touchmove', (evt) => {\n      if (!dragging || !startPointer)\n        return;\n\n      const pos = this.stage!.getPointerPosition();\n      if (!pos)\n        return;\n\n      const dx = pos.x - startPointer.x;\n      const dy = pos.y - startPointer.y;\n\n      if (this._prop.mode === 'gaussian') {\n        this._prop.mean = startMean + dx * this.dragScaleX;\n        this._prop.sigma = Math.max(0.01, startSigma + (-dy) * this.dragScaleY * (this.getMaxX() - this.getMinX()));\n      }\n\n      if (this._prop.mode === 'sigmoid') {\n        this._prop.x0 = startX0 + dx * this.dragScaleX;\n        this._prop.k = Math.max(0.1, startK + (-dy) * this.dragScaleY * 50);\n      }\n\n      this._prop.line = this.computeLine();\n      this.redrawFn?.();\n      this.onParamsChanged?.(this._prop);\n    });\n\n    this.stage.on('mouseup touchend', () => {\n      dragging = false;\n      startPointer = null;\n      this.stage!.container().style.cursor = 'default';\n    });\n  }\n\n  private addSpecialHandle(width: number, height: number) {\n    const clamp = (v: number, min: number, max: number) => Math.max(min, Math.min(max, v));\n\n    if (this._prop.mode === 'freeform')\n      return;\n\n    const minX = this.getMinX();\n    const maxX = this.getMaxX();\n    const mapper = new CoordMapper(minX, maxX, width, height);\n\n    let x = (minX + maxX) / 2;\n    let y = 0.5;\n\n    if (this._prop.mode === 'gaussian') {\n      x = this._prop.mean ?? (minX + maxX) / 2;\n      y = 1;\n    } else if (this._prop.mode === 'sigmoid') {\n      x = this._prop.x0 ?? (minX + maxX) / 2;\n      y = 0.5;\n    }\n\n    const coords = mapper.toCanvasCoords([x, y]);\n\n    if (!this.specialHandle) {\n      this.specialHandle = new _konva!.Circle({\n        x: coords.x,\n        y: coords.y,\n        radius: 7,\n        fill: COLORS.handle,\n        draggable: true,\n        hitStrokeWidth: 15,\n      });\n\n      this.specialHandle.on('dragmove', (evt) => {\n        const pos = evt.target.position();\n        const data = mapper.toDataCoords(pos.x, pos.y);\n\n        if (this._prop.mode === 'gaussian') {\n          this._prop.mean = data.x;\n          this._prop.sigma = Math.max(0.01, Math.abs(data.y - 1));\n        } else if (this._prop.mode === 'sigmoid') {\n          this._prop.x0 = data.x;\n          this._prop.k = clamp(Math.abs(data.y - 0.5) * 30, 0.1, 30);\n        }\n\n        this._prop.line = this.computeLine();\n        this.redrawFn?.();\n        this.onParamsChanged?.(this._prop);\n      });\n\n      this.layer!.add(this.specialHandle);\n    } else {\n      if (!this.specialHandle.getLayer())\n        this.layer!.add(this.specialHandle);\n      this.specialHandle.position(coords);\n    }\n    this.layer!.batchDraw();\n  }\n\n  private showPointEditor(dataIndex: number, clientX: number, clientY: number): void {\n    const point = this._prop.line[dataIndex];\n    const xInput = ui.input.float('X', {value: point[0], min: this.getMinX(), max: this.getMaxX(), format: '#0.00', step: 0.01});\n    const yInput = ui.input.float('Y', {value: point[1], min: 0, max: 1, format: '#0.00', step: 0.01});\n\n    const close = () => {\n      content.removeEventListener('keydown', onKey);\n      popup.remove();\n    };\n\n    const apply = () => {\n      const x = xInput.value;\n      const y = yInput.value;\n      if (x == null || y == null || isNaN(x) || isNaN(y))\n        return;\n      this._prop.line[dataIndex] = [x, y];\n      this.redrawAll();\n    };\n\n    const onKey = (e: KeyboardEvent) => {\n      if (e.key === 'Enter') {\n        apply();\n        close();\n      }\n      if (e.key === 'Escape')\n        close();\n    };\n\n    const content = ui.inputs([xInput, yInput]);\n    content.style.overflow = 'hidden';\n    content.addEventListener('keydown', onKey);\n\n    const rootRect = this.root.getBoundingClientRect();\n    const popup = ui.showPopup(content, this.root, {dx: clientX - rootRect.left, dy: clientY - rootRect.bottom, smart: false});\n  }\n\n  setRange(min: number, max: number): void {\n    const oldMin = this.getMinX();\n    const oldMax = this.getMaxX();\n    const oldRange = oldMax - oldMin;\n    const newRange = max - min;\n\n    if (oldRange !== 0 && newRange !== 0) {\n      const scale = newRange / oldRange;\n      const remap = (x: number) => min + (x - oldMin) * scale;\n\n      if (this._prop.mean != null)\n        this._prop.mean = remap(this._prop.mean);\n      if (this._prop.sigma != null)\n        this._prop.sigma *= scale;\n      if (this._prop.x0 != null)\n        this._prop.x0 = remap(this._prop.x0);\n      if (this._prop.k != null)\n        this._prop.k /= scale;\n\n      for (const p of this._prop.line)\n        p[0] = remap(p[0]);\n\n      if (this._prop.freeformLine) {\n        for (const p of this._prop.freeformLine)\n          p[0] = remap(p[0]);\n      }\n    }\n\n    this._prop.min = min;\n    this._prop.max = max;\n    this.updateDragScales();\n    this.redrawAll(false);\n  }\n\n  setColumn(col: DG.Column | null): void {\n    if (!col)\n      return;\n\n    const values = col.toList();\n    this.drawBars(values);\n  }\n}\n"]}