scan-engine 0.1.0

package/dist/index.js

@@ -0,0 +1,1823 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/Scanner.ts
+var OverscanState = /* @__PURE__ */ ((OverscanState2) => {
+  OverscanState2["FAST"] = "fast";
+  OverscanState2["SLOW_BACKWARD"] = "slow_backward";
+  return OverscanState2;
+})(OverscanState || {});
+var Scanner = class {
+  constructor(surface, config, callbacks = {}) {
+    __publicField(this, "surface");
+    __publicField(this, "config");
+    __publicField(this, "callbacks");
+    __publicField(this, "isRunning", false);
+    __publicField(this, "timer", null);
+    __publicField(this, "stepCount", 0);
+    __publicField(this, "overscanState", "fast" /* FAST */);
+    __publicField(this, "loopCount", 0);
+    this.surface = surface;
+    this.config = config;
+    this.callbacks = callbacks;
+  }
+  start() {
+    this.isRunning = true;
+    this.stepCount = 0;
+    this.loopCount = 0;
+    this.overscanState = "fast" /* FAST */;
+    this.reset();
+    this.scheduleNextStep();
+  }
+  stop() {
+    this.isRunning = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.surface.setFocus([]);
+  }
+  handleAction(action) {
+    if (action === "select") {
+      this.handleSelectAction();
+    } else if (action === "step") {
+      if (this.config.get().scanInputMode === "manual") {
+        this.step();
+        this.stepCount++;
+        this.callbacks.onScanStep?.();
+      }
+    } else if (action === "reset") {
+      this.loopCount = 0;
+      this.reset();
+      this.stepCount = 0;
+      this.overscanState = "fast" /* FAST */;
+      if (this.config.get().scanInputMode === "auto") {
+        this.isRunning = true;
+        if (this.timer) clearTimeout(this.timer);
+        this.scheduleNextStep();
+      }
+    }
+  }
+  handleSelectAction() {
+    const config = this.config.get();
+    if (config.criticalOverscan.enabled) {
+      if (this.overscanState === "fast" /* FAST */) {
+        this.overscanState = "slow_backward" /* SLOW_BACKWARD */;
+        if (this.timer) clearTimeout(this.timer);
+        this.scheduleNextStep();
+        return;
+      } else if (this.overscanState === "slow_backward" /* SLOW_BACKWARD */) {
+        this.overscanState = "fast" /* FAST */;
+        this.doSelection();
+        return;
+      }
+    }
+    this.doSelection();
+  }
+  reportCycleCompleted() {
+    this.loopCount++;
+    const config = this.config.get();
+    if (config.scanLoops > 0 && this.loopCount >= config.scanLoops) {
+      this.stop();
+      this.loopCount = 0;
+    }
+  }
+  scheduleNextStep() {
+    if (!this.isRunning) return;
+    const config = this.config.get();
+    if (config.scanInputMode === "manual") {
+      return;
+    }
+    let rate;
+    if (config.criticalOverscan.enabled && this.overscanState === "slow_backward" /* SLOW_BACKWARD */) {
+      rate = config.criticalOverscan.slowRate;
+    } else {
+      const isFirstItem = this.stepCount === 0;
+      rate = isFirstItem && config.initialItemPause > 0 ? config.initialItemPause : config.criticalOverscan.enabled ? config.criticalOverscan.fastRate : config.scanRate;
+    }
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = window.setTimeout(() => {
+      this.step();
+      this.callbacks.onScanStep?.();
+      this.stepCount++;
+      this.scheduleNextStep();
+    }, rate);
+  }
+  triggerSelection(index) {
+    const item = this.surface.getItemData?.(index);
+    if (item?.isEmpty) {
+      this.stepCount = 0;
+      if (this.timer) clearTimeout(this.timer);
+      this.scheduleNextStep();
+      return;
+    }
+    this.surface.setSelected(index);
+    this.callbacks.onSelect?.(index);
+  }
+  triggerRedraw() {
+    this.callbacks.onRedraw?.();
+  }
+  mapContentToGrid(content, _rows, _cols) {
+    return content;
+  }
+};
+
+// src/scanners/RowColumnScanner.ts
+var RowColumnScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "level", "rows");
+    __publicField(this, "currentRow", -1);
+    __publicField(this, "currentCol", -1);
+    __publicField(this, "totalRows", 0);
+    __publicField(this, "isColumnRow", false);
+    __publicField(this, "useBlockScanning", true);
+  }
+  start() {
+    const config = this.config.get();
+    this.isColumnRow = config.scanPattern === "column-row";
+    this.useBlockScanning = config.scanTechnique === "block";
+    this.recalcDimensions();
+    super.start();
+  }
+  recalcDimensions() {
+    const totalItems = this.surface.getItemsCount();
+    if (this.isColumnRow) {
+      this.totalRows = this.surface.getColumns();
+    } else {
+      this.totalRows = Math.ceil(totalItems / this.surface.getColumns());
+    }
+  }
+  reset() {
+    this.level = this.useBlockScanning ? "rows" : "cells";
+    this.currentRow = -1;
+    this.currentCol = -1;
+    this.surface.setFocus([]);
+  }
+  step() {
+    if (this.useBlockScanning && this.level === "rows") {
+      this.stepMajor();
+    } else {
+      this.stepMinor();
+    }
+  }
+  stepMajor() {
+    this.currentRow++;
+    if (this.currentRow >= this.totalRows) {
+      this.currentRow = 0;
+    }
+    this.highlightMajor(this.currentRow);
+  }
+  stepMinor() {
+    let maxMinor = 0;
+    const totalItems = this.surface.getItemsCount();
+    const cols = this.surface.getColumns();
+    const rows = Math.ceil(totalItems / cols);
+    if (this.useBlockScanning) {
+      if (this.isColumnRow) {
+        const colIdx = this.currentRow;
+        const lastRowLength = totalItems % cols || cols;
+        if (colIdx < lastRowLength) {
+          maxMinor = rows;
+        } else {
+          maxMinor = rows - 1;
+        }
+      } else {
+        const rowStart = this.currentRow * cols;
+        maxMinor = Math.min(cols, totalItems - rowStart);
+      }
+      this.currentCol++;
+      if (this.currentCol >= maxMinor) {
+        this.currentCol = 0;
+      }
+    } else {
+      this.currentCol++;
+      if (this.currentCol >= totalItems) {
+        this.currentCol = 0;
+      }
+    }
+    let index = -1;
+    if (this.useBlockScanning) {
+      if (this.isColumnRow) {
+        index = this.currentCol * cols + this.currentRow;
+      } else {
+        index = this.currentRow * cols + this.currentCol;
+      }
+    } else {
+      if (this.isColumnRow) {
+        const row = Math.floor(this.currentCol / cols);
+        const col = this.currentCol % cols;
+        index = row * cols + col;
+      } else {
+        index = this.currentCol;
+      }
+    }
+    if (index >= 0 && index < totalItems) {
+      const cfg = this.config.get();
+      this.surface.setFocus([index], {
+        phase: this.useBlockScanning ? "minor" : "item",
+        scanRate: cfg.scanRate,
+        scanPattern: cfg.scanPattern,
+        scanTechnique: cfg.scanTechnique,
+        scanDirection: cfg.scanDirection
+      });
+    }
+  }
+  highlightMajor(majorIndex) {
+    const cols = this.surface.getColumns();
+    const totalItems = this.surface.getItemsCount();
+    const indices = [];
+    if (this.isColumnRow) {
+      const rows = Math.ceil(totalItems / cols);
+      for (let r = 0; r < rows; r++) {
+        const idx = r * cols + majorIndex;
+        if (idx < totalItems) indices.push(idx);
+      }
+    } else {
+      const start = majorIndex * cols;
+      const end = Math.min(start + cols, totalItems);
+      for (let i = start; i < end; i++) indices.push(i);
+    }
+    const cfg = this.config.get();
+    this.surface.setFocus(indices, {
+      phase: "major",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  handleAction(action) {
+    if (action === "cancel") {
+      if (this.useBlockScanning && this.level === "cells") {
+        this.level = "rows";
+        this.currentCol = -1;
+        this.highlightMajor(this.currentRow);
+        if (this.timer) clearTimeout(this.timer);
+        this.scheduleNextStep();
+      } else {
+        this.reset();
+      }
+    } else {
+      super.handleAction(action);
+    }
+  }
+  doSelection() {
+    if (this.useBlockScanning && this.level === "rows") {
+      if (this.currentRow >= 0) {
+        this.level = "cells";
+        this.currentCol = -1;
+        this.surface.setSelected(-1);
+        if (this.timer) clearTimeout(this.timer);
+        this.scheduleNextStep();
+      }
+    } else {
+      let index = -1;
+      const cols = this.surface.getColumns();
+      if (this.useBlockScanning) {
+        if (this.isColumnRow) {
+          index = this.currentCol * cols + this.currentRow;
+        } else {
+          index = this.currentRow * cols + this.currentCol;
+        }
+      } else {
+        if (this.isColumnRow) {
+          const row = Math.floor(this.currentCol / cols);
+          const col = this.currentCol % cols;
+          index = row * cols + col;
+        } else {
+          index = this.currentCol;
+        }
+      }
+      if (index >= 0) {
+        this.triggerSelection(index);
+        this.reset();
+        if (this.timer) clearTimeout(this.timer);
+        this.scheduleNextStep();
+      }
+    }
+  }
+  getCost(itemIndex) {
+    const cols = this.surface.getColumns();
+    const row = Math.floor(itemIndex / cols);
+    const col = itemIndex % cols;
+    if (this.useBlockScanning) {
+      if (this.isColumnRow) {
+        return col + 1 + (row + 1);
+      }
+      return row + 1 + (col + 1);
+    } else {
+      if (this.isColumnRow) {
+        return col + 1 + row + 1;
+      }
+      return itemIndex + 1;
+    }
+  }
+  mapContentToGrid(content, rows, cols) {
+    if (this.config.get().scanPattern !== "column-row") {
+      return content;
+    }
+    const newContent = new Array(content.length);
+    let contentIdx = 0;
+    for (let c = 0; c < cols; c++) {
+      for (let r = 0; r < rows; r++) {
+        if (contentIdx >= content.length) break;
+        const gridIndex = r * cols + c;
+        if (gridIndex < newContent.length) {
+          newContent[gridIndex] = content[contentIdx++];
+        }
+      }
+    }
+    return newContent;
+  }
+};
+
+// src/scanners/LinearScanner.ts
+var LinearScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "currentIndex", -1);
+    __publicField(this, "totalItems", 0);
+    __publicField(this, "direction", 1);
+  }
+  // 1 for forward, -1 for reverse
+  start() {
+    this.totalItems = this.countItems();
+    this.direction = 1;
+    super.start();
+  }
+  countItems() {
+    return this.surface.getItemsCount();
+  }
+  reset() {
+    this.currentIndex = -1;
+    this.direction = 1;
+    this.loopCount = 0;
+    this.surface.setFocus([]);
+  }
+  step() {
+    const config = this.config.get();
+    if (config.criticalOverscan.enabled && this.overscanState === "slow_backward") {
+      this.currentIndex--;
+      if (this.currentIndex < 0) {
+        this.currentIndex = this.totalItems - 1;
+        this.reportCycleCompleted();
+      }
+      const cfg2 = this.config.get();
+      this.surface.setFocus([this.currentIndex], {
+        phase: "item",
+        scanRate: cfg2.scanRate,
+        scanPattern: cfg2.scanPattern,
+        scanTechnique: cfg2.scanTechnique,
+        scanDirection: cfg2.scanDirection
+      });
+      return;
+    }
+    switch (config.scanDirection) {
+      case "circular":
+        this.currentIndex++;
+        if (this.currentIndex >= this.totalItems) {
+          this.currentIndex = 0;
+          this.reportCycleCompleted();
+        }
+        break;
+      case "reverse":
+        this.currentIndex--;
+        if (this.currentIndex < 0) {
+          this.currentIndex = this.totalItems - 1;
+          this.reportCycleCompleted();
+        }
+        break;
+      case "oscillating":
+        if (this.currentIndex >= this.totalItems - 1 && this.direction === 1) {
+          this.direction = -1;
+          this.reportCycleCompleted();
+        } else if (this.currentIndex <= 0 && this.direction === -1) {
+          this.direction = 1;
+          this.reportCycleCompleted();
+        }
+        this.currentIndex += this.direction;
+        break;
+    }
+    const cfg = this.config.get();
+    this.surface.setFocus([this.currentIndex], {
+      phase: "item",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  handleAction(action) {
+    if (action === "step") {
+      if (this.timer) clearTimeout(this.timer);
+      this.step();
+      this.callbacks.onScanStep?.();
+      this.scheduleNextStep();
+    } else {
+      super.handleAction(action);
+    }
+  }
+  doSelection() {
+    if (this.currentIndex >= 0) {
+      if (this.currentIndex >= 0) {
+        this.triggerSelection(this.currentIndex);
+        this.reset();
+        if (this.timer) clearTimeout(this.timer);
+        this.scheduleNextStep();
+      }
+    }
+  }
+  getCost(itemIndex) {
+    const config = this.config.get();
+    switch (config.scanDirection) {
+      case "circular":
+        return itemIndex + 1;
+      case "reverse":
+        return this.totalItems - itemIndex;
+      case "oscillating":
+        return itemIndex + 1;
+      default:
+        return itemIndex + 1;
+    }
+  }
+};
+
+// src/scanners/SnakeScanner.ts
+var SnakeScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "currentRow", 0);
+    __publicField(this, "currentCol", 0);
+    __publicField(this, "direction", 1);
+    // 1 = Right, -1 = Left
+    __publicField(this, "maxRow", 0);
+    __publicField(this, "maxCol", 0);
+  }
+  start() {
+    this.updateDimensions();
+    super.start();
+  }
+  updateDimensions() {
+    const total = this.surface.getItemsCount();
+    this.maxCol = this.surface.getColumns();
+    this.maxRow = Math.ceil(total / this.maxCol);
+  }
+  reset() {
+    this.currentRow = 0;
+    this.currentCol = 0;
+    this.direction = 1;
+    const cfg = this.config.get();
+    this.surface.setFocus([0], {
+      phase: "item",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  step() {
+    this.currentCol += this.direction;
+    if (this.currentCol >= this.maxCol) {
+      this.currentCol = this.maxCol - 1;
+      this.currentRow++;
+      this.direction = -1;
+    } else if (this.currentCol < 0) {
+      this.currentCol = 0;
+      this.currentRow++;
+      this.direction = 1;
+    }
+    if (this.currentRow >= this.maxRow) {
+      this.currentRow = 0;
+      this.currentCol = 0;
+      this.direction = 1;
+    }
+    const index = this.currentRow * this.maxCol + this.currentCol;
+    if (index >= this.surface.getItemsCount()) {
+      this.reset();
+      return;
+    }
+    const cfg = this.config.get();
+    this.surface.setFocus([index], {
+      phase: "item",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  handleAction(action) {
+    if (action !== "select") {
+      super.handleAction(action);
+    } else {
+      super.handleAction(action);
+    }
+  }
+  doSelection() {
+    const index = this.currentRow * this.maxCol + this.currentCol;
+    if (index >= 0) {
+      this.triggerSelection(index);
+      this.reset();
+      if (this.timer) clearTimeout(this.timer);
+      this.scheduleNextStep();
+    }
+  }
+  getCost(itemIndex) {
+    return itemIndex;
+  }
+  mapContentToGrid(content, rows, cols) {
+    const newContent = new Array(content.length);
+    let r = 0, c = 0, dir = 1;
+    for (let i = 0; i < content.length; i++) {
+      const gridIndex = r * cols + c;
+      if (gridIndex < newContent.length) {
+        newContent[gridIndex] = content[i];
+      }
+      c += dir;
+      if (c >= cols) {
+        c = cols - 1;
+        r++;
+        dir = -1;
+      } else if (c < 0) {
+        c = 0;
+        r++;
+        dir = 1;
+      }
+      if (r >= rows) break;
+    }
+    return newContent;
+  }
+};
+
+// src/scanners/QuadrantScanner.ts
+var QuadrantScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "level", "quadrant");
+    __publicField(this, "currentQuad", -1);
+    // 0..3
+    __publicField(this, "currentRow", -1);
+    // relative to quad
+    __publicField(this, "currentCol", -1);
+    // relative to row
+    // Quadrant bounds (calculated at start)
+    __publicField(this, "quads", []);
+  }
+  start() {
+    this.calcQuadrants();
+    super.start();
+  }
+  calcQuadrants() {
+    const totalItems = this.surface.getItemsCount();
+    const cols = this.surface.getColumns();
+    const totalRows = Math.ceil(totalItems / cols);
+    const midRow = Math.ceil(totalRows / 2);
+    const midCol = Math.ceil(cols / 2);
+    this.quads = [
+      { rowStart: 0, rowEnd: midRow, colStart: 0, colEnd: midCol },
+      // TL
+      { rowStart: 0, rowEnd: midRow, colStart: midCol, colEnd: cols },
+      // TR
+      { rowStart: midRow, rowEnd: totalRows, colStart: 0, colEnd: midCol },
+      // BL
+      { rowStart: midRow, rowEnd: totalRows, colStart: midCol, colEnd: cols }
+      // BR
+    ];
+  }
+  reset() {
+    this.level = "quadrant";
+    this.currentQuad = -1;
+    this.currentRow = -1;
+    this.currentCol = -1;
+    this.surface.setFocus([]);
+  }
+  step() {
+    if (this.level === "quadrant") {
+      this.stepQuadrant();
+    } else if (this.level === "row") {
+      this.stepRow();
+    } else {
+      this.stepCell();
+    }
+  }
+  stepQuadrant() {
+    this.currentQuad++;
+    if (this.currentQuad >= 4) this.currentQuad = 0;
+    this.highlightQuad(this.currentQuad);
+  }
+  stepRow() {
+    const q = this.quads[this.currentQuad];
+    const rowsInQuad = q.rowEnd - q.rowStart;
+    this.currentRow++;
+    if (this.currentRow >= rowsInQuad) this.currentRow = 0;
+    const actualRow = q.rowStart + this.currentRow;
+    this.highlightRowSegment(actualRow, q.colStart, q.colEnd);
+  }
+  stepCell() {
+    const q = this.quads[this.currentQuad];
+    const colsInQuad = q.colEnd - q.colStart;
+    this.currentCol++;
+    if (this.currentCol >= colsInQuad) this.currentCol = 0;
+    const actualRow = q.rowStart + this.currentRow;
+    const actualCol = q.colStart + this.currentCol;
+    const index = actualRow * this.surface.getColumns() + actualCol;
+    if (index < this.surface.getItemsCount()) {
+      const cfg = this.config.get();
+      this.surface.setFocus([index], {
+        phase: "item",
+        scanRate: cfg.scanRate,
+        scanPattern: cfg.scanPattern,
+        scanTechnique: cfg.scanTechnique,
+        scanDirection: cfg.scanDirection
+      });
+    } else {
+      this.stepCell();
+    }
+  }
+  highlightQuad(qIndex) {
+    const q = this.quads[qIndex];
+    const indices = [];
+    const cols = this.surface.getColumns();
+    const totalItems = this.surface.getItemsCount();
+    for (let r = q.rowStart; r < q.rowEnd; r++) {
+      for (let c = q.colStart; c < q.colEnd; c++) {
+        const idx = r * cols + c;
+        if (idx < totalItems) indices.push(idx);
+      }
+    }
+    const cfg = this.config.get();
+    this.surface.setFocus(indices, {
+      phase: "major",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  highlightRowSegment(row, colStart, colEnd) {
+    const indices = [];
+    const cols = this.surface.getColumns();
+    const totalItems = this.surface.getItemsCount();
+    for (let c = colStart; c < colEnd; c++) {
+      const idx = row * cols + c;
+      if (idx < totalItems) indices.push(idx);
+    }
+    const cfg = this.config.get();
+    this.surface.setFocus(indices, {
+      phase: "minor",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  handleAction(action) {
+    if (action === "cancel") {
+      if (this.level === "cell") {
+        this.level = "row";
+        this.currentCol = -1;
+        this.restartTimer();
+      } else if (this.level === "row") {
+        this.level = "quadrant";
+        this.currentRow = -1;
+        this.restartTimer();
+      } else {
+        this.reset();
+      }
+    } else {
+      super.handleAction(action);
+    }
+  }
+  doSelection() {
+    if (this.level === "quadrant") {
+      if (this.currentQuad >= 0) {
+        this.level = "row";
+        this.currentRow = -1;
+        this.restartTimer();
+      }
+    } else if (this.level === "row") {
+      if (this.currentRow >= 0) {
+        this.level = "cell";
+        this.currentCol = -1;
+        this.restartTimer();
+      }
+    } else {
+      const q = this.quads[this.currentQuad];
+      const idx = (q.rowStart + this.currentRow) * this.surface.getColumns() + (q.colStart + this.currentCol);
+      if (idx >= 0) {
+        this.triggerSelection(idx);
+        this.reset();
+        this.restartTimer();
+      }
+    }
+  }
+  restartTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.scheduleNextStep();
+  }
+  getCost(itemIndex) {
+    const cols = this.surface.getColumns();
+    const totalItems = this.surface.getItemsCount();
+    const totalRows = Math.ceil(totalItems / cols);
+    const midRow = Math.ceil(totalRows / 2);
+    const midCol = Math.ceil(cols / 2);
+    const row = Math.floor(itemIndex / cols);
+    const col = itemIndex % cols;
+    let quadIndex = 0;
+    if (row < midRow) {
+      if (col < midCol) quadIndex = 0;
+      else quadIndex = 1;
+    } else {
+      if (col < midCol) quadIndex = 2;
+      else quadIndex = 3;
+    }
+    let rowInQuad = row;
+    if (row >= midRow) rowInQuad = row - midRow;
+    let colInQuad = col;
+    if (col >= midCol) colInQuad = col - midCol;
+    return quadIndex + 1 + (rowInQuad + 1) + (colInQuad + 1);
+  }
+  mapContentToGrid(content, rows, cols) {
+    const newContent = new Array(content.length);
+    let contentIdx = 0;
+    const midRow = Math.ceil(rows / 2);
+    const midCol = Math.ceil(cols / 2);
+    const quads = [
+      { rS: 0, rE: midRow, cS: 0, cE: midCol },
+      // TL
+      { rS: 0, rE: midRow, cS: midCol, cE: cols },
+      // TR
+      { rS: midRow, rE: rows, cS: 0, cE: midCol },
+      // BL
+      { rS: midRow, rE: rows, cS: midCol, cE: cols }
+      // BR
+    ];
+    for (const q of quads) {
+      for (let r = q.rS; r < q.rE; r++) {
+        for (let c = q.cS; c < q.cE; c++) {
+          if (contentIdx >= content.length) break;
+          const gridIndex = r * cols + c;
+          if (gridIndex < newContent.length) {
+            newContent[gridIndex] = content[contentIdx++];
+          }
+        }
+      }
+    }
+    return newContent;
+  }
+};
+
+// src/scanners/GroupScanner.ts
+var GroupScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "level", "group");
+    __publicField(this, "currentGroup", -1);
+    __publicField(this, "currentRow", -1);
+    // relative to group
+    __publicField(this, "currentCol", -1);
+    __publicField(this, "groups", []);
+  }
+  start() {
+    this.calcGroups();
+    super.start();
+  }
+  calcGroups() {
+    const totalItems = this.surface.getItemsCount();
+    const cols = this.surface.getColumns();
+    const totalRows = Math.ceil(totalItems / cols);
+    const groupSize = Math.ceil(totalRows / 3);
+    this.groups = [];
+    for (let i = 0; i < totalRows; i += groupSize) {
+      this.groups.push({
+        rowStart: i,
+        rowEnd: Math.min(i + groupSize, totalRows)
+      });
+    }
+  }
+  reset() {
+    this.level = "group";
+    this.currentGroup = -1;
+    this.currentRow = -1;
+    this.currentCol = -1;
+    this.surface.setFocus([]);
+  }
+  step() {
+    if (this.level === "group") this.stepGroup();
+    else if (this.level === "row") this.stepRow();
+    else this.stepCell();
+  }
+  stepGroup() {
+    this.currentGroup++;
+    if (this.currentGroup >= this.groups.length) this.currentGroup = 0;
+    this.highlightGroup(this.currentGroup);
+  }
+  stepRow() {
+    const g = this.groups[this.currentGroup];
+    const rowsInGroup = g.rowEnd - g.rowStart;
+    this.currentRow++;
+    if (this.currentRow >= rowsInGroup) this.currentRow = 0;
+    const actualRow = g.rowStart + this.currentRow;
+    this.highlightRow(actualRow);
+  }
+  stepCell() {
+    const cols = this.surface.getColumns();
+    this.currentCol++;
+    if (this.currentCol >= cols) this.currentCol = 0;
+    const g = this.groups[this.currentGroup];
+    const actualRow = g.rowStart + this.currentRow;
+    const idx = actualRow * cols + this.currentCol;
+    if (idx < this.surface.getItemsCount()) {
+      const cfg = this.config.get();
+      this.surface.setFocus([idx], {
+        phase: "item",
+        scanRate: cfg.scanRate,
+        scanPattern: cfg.scanPattern,
+        scanTechnique: cfg.scanTechnique,
+        scanDirection: cfg.scanDirection
+      });
+    } else {
+      if (this.currentCol < cols - 1) this.stepCell();
+    }
+  }
+  highlightGroup(gIndex) {
+    const g = this.groups[gIndex];
+    const indices = [];
+    const cols = this.surface.getColumns();
+    const totalItems = this.surface.getItemsCount();
+    for (let r = g.rowStart; r < g.rowEnd; r++) {
+      for (let c = 0; c < cols; c++) {
+        const idx = r * cols + c;
+        if (idx < totalItems) indices.push(idx);
+      }
+    }
+    const cfg = this.config.get();
+    this.surface.setFocus(indices, {
+      phase: "major",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  highlightRow(row) {
+    const cols = this.surface.getColumns();
+    const totalItems = this.surface.getItemsCount();
+    const indices = [];
+    for (let c = 0; c < cols; c++) {
+      const idx = row * cols + c;
+      if (idx < totalItems) indices.push(idx);
+    }
+    const cfg = this.config.get();
+    this.surface.setFocus(indices, {
+      phase: "minor",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  handleAction(action) {
+    if (action === "cancel") {
+      if (this.level === "cell") {
+        this.level = "row";
+        this.currentCol = -1;
+        this.restartTimer();
+      } else if (this.level === "row") {
+        this.level = "group";
+        this.currentRow = -1;
+        this.restartTimer();
+      } else {
+        this.reset();
+      }
+    } else {
+      super.handleAction(action);
+    }
+  }
+  doSelection() {
+    if (this.level === "group") {
+      if (this.currentGroup >= 0) {
+        this.level = "row";
+        this.currentRow = -1;
+        this.restartTimer();
+      }
+    } else if (this.level === "row") {
+      if (this.currentRow >= 0) {
+        this.level = "cell";
+        this.currentCol = -1;
+        this.restartTimer();
+      }
+    } else {
+      const g = this.groups[this.currentGroup];
+      const idx = (g.rowStart + this.currentRow) * this.surface.getColumns() + this.currentCol;
+      if (idx >= 0) {
+        this.triggerSelection(idx);
+        this.reset();
+        this.restartTimer();
+      }
+    }
+  }
+  restartTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.scheduleNextStep();
+  }
+  getCost(itemIndex) {
+    const cols = this.surface.getColumns();
+    const totalItems = this.surface.getItemsCount();
+    const totalRows = Math.ceil(totalItems / cols);
+    const groupSize = Math.ceil(totalRows / 3);
+    const row = Math.floor(itemIndex / cols);
+    const col = itemIndex % cols;
+    const groupIndex = Math.floor(row / groupSize);
+    const rowIndexInGroup = row % groupSize;
+    return groupIndex + 1 + (rowIndexInGroup + 1) + (col + 1);
+  }
+};
+
+// src/scanners/EliminationScanner.ts
+var SWITCH_COLORS = {
+  "switch-1": "#2196F3",
+  // Blue
+  "switch-2": "#F44336",
+  // Red
+  "switch-3": "#4CAF50",
+  // Green
+  "switch-4": "#FFEB3B",
+  // Yellow
+  "switch-5": "#9C27B0",
+  // Purple
+  "switch-6": "#FF9800",
+  // Orange
+  "switch-7": "#00BCD4",
+  // Cyan
+  "switch-8": "#E91E63"
+  // Magenta
+};
+var EliminationScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "rangeStart", 0);
+    __publicField(this, "rangeEnd", 0);
+    // Exclusive
+    __publicField(this, "currentBlock", 0);
+    // Which block is currently highlighted
+    __publicField(this, "numSwitches", 4);
+    // Default to 4-switch (quadrant)
+    __publicField(this, "partitionHistory", []);
+  }
+  start() {
+    const config = this.config.get();
+    this.numSwitches = config.eliminationSwitchCount || 4;
+    this.rangeStart = 0;
+    this.rangeEnd = this.surface.getItemsCount();
+    this.partitionHistory = [];
+    super.start();
+  }
+  reset() {
+    this.rangeStart = 0;
+    this.rangeEnd = this.surface.getItemsCount();
+    this.currentBlock = 0;
+    this.partitionHistory = [];
+    this.clearHighlights();
+  }
+  clearHighlights() {
+    this.surface.setFocus([]);
+    if (this.surface.clearItemStyles) {
+      this.surface.clearItemStyles();
+    }
+  }
+  step() {
+    this.currentBlock = (this.currentBlock + 1) % this.numSwitches;
+    this.highlightCurrentBlock();
+  }
+  highlightCurrentBlock() {
+    this.clearHighlights();
+    const partitions = this.calculatePartitions(this.rangeStart, this.rangeEnd, this.numSwitches);
+    const partition = partitions[this.currentBlock];
+    if (!partition) return;
+    for (let i = partition.start; i < partition.end; i++) {
+      const switchAction = this.getSwitchAction(this.currentBlock);
+      const color = SWITCH_COLORS[switchAction];
+      this.surface.setItemStyle?.(i, {
+        backgroundColor: color,
+        opacity: 0.4,
+        borderColor: color,
+        borderWidth: 2,
+        boxShadow: `inset 0 0 0 3px ${color}`
+      });
+    }
+  }
+  calculatePartitions(start, end, n) {
+    const partitions = [];
+    const total = end - start;
+    const baseSize = Math.floor(total / n);
+    const remainder = total % n;
+    let currentStart = start;
+    for (let i = 0; i < n; i++) {
+      const size = baseSize + (i < remainder ? 1 : 0);
+      partitions.push({ start: currentStart, end: currentStart + size });
+      currentStart += size;
+    }
+    return partitions;
+  }
+  getSwitchAction(blockIndex) {
+    const switchMap = {
+      0: "switch-1",
+      1: "switch-2",
+      2: "switch-3",
+      3: "switch-4",
+      4: "switch-5",
+      5: "switch-6",
+      6: "switch-7",
+      7: "switch-8"
+    };
+    return switchMap[blockIndex] || "switch-1";
+  }
+  handleAction(action) {
+    if (action === "select") {
+      this.doSelection();
+      return;
+    }
+    if (action.toString().startsWith("switch-")) {
+      const switchNum = parseInt(action.toString().split("-")[1]) - 1;
+      if (switchNum >= this.numSwitches) {
+        return;
+      }
+      const rangeSize = this.rangeEnd - this.rangeStart;
+      if (rangeSize <= 1) {
+        if (this.rangeStart >= 0) {
+          this.triggerSelection(this.rangeStart);
+          this.reset();
+          this.restartTimer();
+        }
+        return;
+      }
+      if (switchNum === this.currentBlock) {
+        const partitions = this.calculatePartitions(this.rangeStart, this.rangeEnd, this.numSwitches);
+        const selectedBlock = partitions[switchNum];
+        if (selectedBlock) {
+          this.partitionHistory.push({ start: this.rangeStart, end: this.rangeEnd });
+          this.rangeStart = selectedBlock.start;
+          this.rangeEnd = selectedBlock.end;
+          this.currentBlock = 0;
+          if (this.rangeEnd - this.rangeStart === 1) {
+            this.clearHighlights();
+            const color = SWITCH_COLORS["switch-1"];
+            this.surface.setItemStyle?.(this.rangeStart, {
+              backgroundColor: color,
+              opacity: 0.6,
+              boxShadow: `inset 0 0 0 4px ${color}, 0 0 10px ${color}`,
+              borderColor: color,
+              borderWidth: 2
+            });
+          }
+        }
+        this.restartTimer();
+      }
+      return;
+    }
+    if (action === "cancel" || action === "reset") {
+      if (this.partitionHistory.length > 0) {
+        const previous = this.partitionHistory.pop();
+        this.rangeStart = previous.start;
+        this.rangeEnd = previous.end;
+        this.currentBlock = 0;
+      } else {
+        this.reset();
+      }
+      this.restartTimer();
+    }
+  }
+  doSelection() {
+    const rangeSize = this.rangeEnd - this.rangeStart;
+    if (rangeSize <= 1) {
+      if (this.rangeStart >= 0) {
+        this.triggerSelection(this.rangeStart);
+        this.reset();
+        this.restartTimer();
+      }
+    }
+  }
+  restartTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.scheduleNextStep();
+  }
+  getCost(itemIndex) {
+    const n = this.numSwitches;
+    let start = 0;
+    let end = this.surface.getItemsCount();
+    let cost = 0;
+    while (end - start > 1) {
+      const partitions = this.calculatePartitions(start, end, n);
+      let foundPartition = 0;
+      for (let i = 0; i < partitions.length; i++) {
+        if (itemIndex >= partitions[i].start && itemIndex < partitions[i].end) {
+          foundPartition = i;
+          break;
+        }
+      }
+      cost += foundPartition + 1;
+      start = partitions[foundPartition].start;
+      end = partitions[foundPartition].end;
+    }
+    return cost;
+  }
+  // Override to disable step scheduling - elimination waits for specific switch input
+  scheduleNextStep() {
+    if (!this.isRunning) return;
+    if (this.config.get().scanInputMode === "manual") {
+      return;
+    }
+    if (this.timer) clearTimeout(this.timer);
+    const rate = this.config.get().scanRate;
+    this.timer = window.setTimeout(() => {
+      this.step();
+      this.scheduleNextStep();
+    }, rate);
+  }
+};
+
+// src/scanners/ContinuousScanner.ts
+var ContinuousScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    // States differ by technique:
+    // Crosshair: 'x-scan' → 'y-scan' → 'processing' (waits for switch)
+    // Gliding: 'x-scanning' → 'x-capturing' → 'y-scanning' → 'y-capturing' → 'processing' (continuous movement)
+    // Eight-Direction: 'direction-scan' → 'moving' → 'processing' (compass direction selection)
+    __publicField(this, "state", "x-scan");
+    __publicField(this, "xPos", 0);
+    // percentage 0-100
+    __publicField(this, "yPos", 0);
+    // percentage 0-100
+    __publicField(this, "technique", "crosshair");
+    __publicField(this, "numCols", 0);
+    __publicField(this, "numRows", 0);
+    // For gliding cursor
+    __publicField(this, "bufferWidth", 15);
+    // % of screen width for buffer zone
+    __publicField(this, "direction", 1);
+    // 1 = right/down, -1 = left/up
+    __publicField(this, "pauseTimer", null);
+    // For pause before reversing
+    __publicField(this, "bufferLeft", 0);
+    // Left edge of buffer zone (%)
+    __publicField(this, "bufferRight", 0);
+    // Right edge of buffer zone (%)
+    __publicField(this, "bufferTop", 0);
+    // Top edge of buffer zone (%)
+    __publicField(this, "bufferBottom", 0);
+    // Bottom edge of buffer zone (%)
+    __publicField(this, "fineXPos", 0);
+    // Fine line position within buffer zone (%)
+    __publicField(this, "fineYPos", 0);
+    // Fine line position within buffer zone (%)
+    __publicField(this, "lockedXPosition", 0);
+    // Actual X position when locked (%)
+    // Eight-direction mode
+    __publicField(this, "currentDirection", 0);
+    // 0-7 for 8 directions (N, NE, E, SE, S, SW, W, NW)
+    __publicField(this, "compassAngle", 0);
+    // Continuous angle 0-359 for fluid rotation
+    __publicField(this, "compassMode", "continuous");
+    // Fluid vs discrete
+    __publicField(this, "directionStepCounter", 0);
+    // Counter for slowing direction cycling
+    __publicField(this, "directionStepsPerChange", 10);
+    // How many steps before changing direction (fixed-8 mode)
+    __publicField(this, "directions", [
+      { name: "N", angle: 0, dx: 0, dy: -1 },
+      // North
+      { name: "NE", angle: 45, dx: 1, dy: -1 },
+      // Northeast
+      { name: "E", angle: 90, dx: 1, dy: 0 },
+      // East
+      { name: "SE", angle: 135, dx: 1, dy: 1 },
+      // Southeast
+      { name: "S", angle: 180, dx: 0, dy: 1 },
+      // South
+      { name: "SW", angle: 225, dx: -1, dy: 1 },
+      // Southwest
+      { name: "W", angle: 270, dx: -1, dy: 0 },
+      // West
+      { name: "NW", angle: 315, dx: -1, dy: -1 }
+      // Northwest
+    ]);
+  }
+  start() {
+    try {
+      const config = this.config.get();
+      this.technique = config.continuousTechnique || "crosshair";
+      const totalItems = this.surface.getItemsCount();
+      this.numCols = this.surface.getColumns();
+      this.numRows = Math.ceil(totalItems / this.numCols);
+      console.log("[ContinuousScanner] Starting:", {
+        technique: this.technique,
+        numCols: this.numCols,
+        numRows: this.numRows,
+        totalItems
+      });
+      if (this.technique === "gliding") {
+        this.state = "x-scanning";
+        this.xPos = 0;
+        this.yPos = 0;
+      } else if (this.technique === "eight-direction") {
+        this.state = "direction-scan";
+        this.xPos = 50;
+        this.yPos = 50;
+        this.compassMode = config.compassMode || "continuous";
+        this.compassAngle = 0;
+      } else {
+        this.state = "x-scan";
+        this.xPos = 0;
+        this.yPos = 0;
+      }
+      console.log("[ContinuousScanner] Initial state:", this.state);
+      this.emitUpdate();
+      super.start();
+    } catch (error) {
+      console.error("[ContinuousScanner] ERROR in start():", error);
+      throw error;
+    }
+  }
+  stop() {
+    super.stop();
+    if (this.pauseTimer) {
+      window.clearTimeout(this.pauseTimer);
+      this.pauseTimer = null;
+    }
+  }
+  reset() {
+    if (this.technique === "gliding") {
+      this.state = "x-scanning";
+      this.xPos = 0;
+      this.yPos = 0;
+    } else if (this.technique === "eight-direction") {
+      this.state = "direction-scan";
+      this.xPos = 50;
+      this.yPos = 50;
+    } else {
+      this.state = "x-scan";
+      this.xPos = 0;
+      this.yPos = 0;
+    }
+    this.direction = 1;
+    this.fineXPos = 0;
+    this.fineYPos = 0;
+    this.bufferLeft = 0;
+    this.bufferRight = this.bufferWidth;
+    this.bufferTop = 0;
+    this.bufferBottom = this.bufferWidth;
+    this.lockedXPosition = 0;
+    this.currentDirection = 0;
+    this.compassAngle = 0;
+    this.directionStepCounter = 0;
+    this.surface.setFocus([]);
+    this.emitUpdate();
+  }
+  step() {
+    if (this.technique === "eight-direction") {
+      if (this.state === "direction-scan") {
+        if (this.compassMode === "continuous") {
+          this.compassAngle = (this.compassAngle + 2) % 360;
+        } else {
+          this.directionStepCounter++;
+          if (this.directionStepCounter >= this.directionStepsPerChange) {
+            this.currentDirection = (this.currentDirection + 1) % 8;
+            this.directionStepCounter = 0;
+          }
+          this.compassAngle = this.directions[this.currentDirection].angle;
+        }
+      } else if (this.state === "moving") {
+        const dir = this.compassMode === "continuous" ? this.getDirectionFromAngle(this.compassAngle) : this.directions[this.currentDirection];
+        const speed = 0.5;
+        this.xPos += dir.dx * speed;
+        this.yPos += dir.dy * speed;
+        this.xPos = Math.max(0, Math.min(100, this.xPos));
+        this.yPos = Math.max(0, Math.min(100, this.yPos));
+      }
+    } else if (this.technique === "gliding") {
+      if (this.state === "x-scanning") {
+        this.xPos += 0.8 * this.direction;
+        if (this.xPos >= 100) {
+          this.xPos = 100;
+          if (!this.pauseTimer) {
+            this.pauseTimer = window.setTimeout(() => {
+              this.direction = -1;
+              this.pauseTimer = null;
+            }, 100);
+            return;
+          }
+        } else if (this.xPos <= 0) {
+          this.xPos = 0;
+          if (!this.pauseTimer) {
+            this.pauseTimer = window.setTimeout(() => {
+              this.direction = 1;
+              this.pauseTimer = null;
+            }, 100);
+            return;
+          }
+        }
+        this.bufferLeft = Math.max(0, this.xPos - this.bufferWidth / 2);
+        this.bufferRight = Math.min(100, this.xPos + this.bufferWidth / 2);
+      } else if (this.state === "x-capturing") {
+        this.fineXPos += 0.3 * this.direction;
+        if (this.fineXPos >= 100) {
+          this.fineXPos = 100;
+          this.direction = -1;
+        } else if (this.fineXPos <= 0) {
+          this.fineXPos = 0;
+          this.direction = 1;
+        }
+      } else if (this.state === "y-scanning") {
+        this.yPos += 0.8 * this.direction;
+        if (this.yPos >= 100) {
+          this.yPos = 100;
+          if (!this.pauseTimer) {
+            this.pauseTimer = window.setTimeout(() => {
+              this.direction = -1;
+              this.pauseTimer = null;
+            }, 100);
+            return;
+          }
+        } else if (this.yPos <= 0) {
+          this.yPos = 0;
+          if (!this.pauseTimer) {
+            this.pauseTimer = window.setTimeout(() => {
+              this.direction = 1;
+              this.pauseTimer = null;
+            }, 100);
+            return;
+          }
+        }
+        this.bufferTop = Math.max(0, this.yPos - this.bufferWidth / 2);
+        this.bufferBottom = Math.min(100, this.yPos + this.bufferWidth / 2);
+      } else if (this.state === "y-capturing") {
+        this.fineYPos += 0.3 * this.direction;
+        if (this.fineYPos >= 100) {
+          this.fineYPos = 100;
+          this.direction = -1;
+        } else if (this.fineYPos <= 0) {
+          this.fineYPos = 0;
+          this.direction = 1;
+        }
+      }
+    } else {
+      if (this.state === "x-scan") {
+        this.xPos += 0.5;
+        if (this.xPos > 100) this.xPos = 0;
+      } else if (this.state === "y-scan") {
+        this.yPos += 0.5;
+        if (this.yPos > 100) this.yPos = 0;
+      }
+    }
+    if (Math.floor(this.xPos * 2) % 50 === 0) {
+      console.log("[ContinuousScanner] Step:", {
+        state: this.state,
+        xPos: this.xPos,
+        yPos: this.yPos,
+        fineXPos: this.fineXPos,
+        fineYPos: this.fineYPos,
+        bufferLeft: this.bufferLeft,
+        bufferRight: this.bufferRight,
+        technique: this.technique,
+        direction: this.direction,
+        currentDirection: this.currentDirection
+      });
+    }
+    this.emitUpdate();
+  }
+  getDirectionFromAngle(angle) {
+    const radians = angle * Math.PI / 180;
+    const dx = Math.cos(radians);
+    const dy = Math.sin(radians);
+    const normalizedAngle = (angle + 22.5) % 360;
+    const directionIndex = Math.floor(normalizedAngle / 45);
+    const names = ["E", "SE", "S", "SW", "W", "NW", "N", "NE"];
+    const name = names[directionIndex] || "N";
+    return { dx, dy, name };
+  }
+  // Override scheduleNextStep for different refresh rates
+  scheduleNextStep() {
+    if (!this.isRunning) return;
+    if (this.config.get().scanInputMode === "manual") {
+      return;
+    }
+    if (this.timer) clearTimeout(this.timer);
+    const delay = 20;
+    this.timer = window.setTimeout(() => {
+      this.step();
+      this.scheduleNextStep();
+    }, delay);
+  }
+  handleAction(action) {
+    console.log("[ContinuousScanner] handleAction:", {
+      action,
+      state: this.state,
+      technique: this.technique
+    });
+    if (action === "cancel") {
+      console.log("[ContinuousScanner] Cancel - resetting");
+      this.reset();
+    } else {
+      super.handleAction(action);
+    }
+  }
+  doSelection() {
+    if (this.technique === "eight-direction") {
+      if (this.state === "direction-scan") {
+        const dirInfo = this.getDirectionFromAngle(this.compassAngle);
+        console.log("[ContinuousScanner] Transition: direction-scan -> moving, direction:", dirInfo.name, "angle:", this.compassAngle);
+        this.state = "moving";
+      } else if (this.state === "moving") {
+        console.log("[ContinuousScanner] Transition: moving -> processing");
+        this.state = "processing";
+        this.selectFocusedItem();
+      }
+    } else if (this.technique === "gliding") {
+      if (this.state === "x-scanning") {
+        console.log("[ContinuousScanner] Transition: x-scanning -> x-capturing");
+        this.state = "x-capturing";
+        this.fineXPos = 0;
+        this.direction = 1;
+      } else if (this.state === "x-capturing") {
+        console.log("[ContinuousScanner] Transition: x-capturing -> y-scanning");
+        this.state = "y-scanning";
+        this.lockedXPosition = this.bufferLeft + this.fineXPos / 100 * (this.bufferRight - this.bufferLeft);
+        this.yPos = 0;
+        this.fineYPos = 0;
+        this.direction = 1;
+      } else if (this.state === "y-scanning") {
+        console.log("[ContinuousScanner] Transition: y-scanning -> y-capturing");
+        this.state = "y-capturing";
+        this.fineYPos = 0;
+        this.direction = 1;
+      } else if (this.state === "y-capturing") {
+        console.log("[ContinuousScanner] Transition: y-capturing -> processing");
+        this.state = "processing";
+        this.selectFocusedItem();
+      }
+    } else {
+      if (this.state === "x-scan") {
+        console.log("[ContinuousScanner] Transition: x-scan -> y-scan");
+        this.state = "y-scan";
+        this.yPos = 0;
+      } else if (this.state === "y-scan") {
+        console.log("[ContinuousScanner] Transition: y-scan -> processing");
+        this.state = "processing";
+        this.selectAtPoint();
+      }
+    }
+  }
+  selectFocusedItem() {
+    if (this.technique === "eight-direction") {
+      this.selectAtPercent(this.xPos, this.yPos);
+      return;
+    }
+    const actualYPos = this.bufferTop + this.fineYPos / 100 * (this.bufferBottom - this.bufferTop);
+    this.selectAtPercent(this.lockedXPosition, actualYPos);
+  }
+  selectAtPoint() {
+    this.selectAtPercent(this.xPos, this.yPos);
+  }
+  selectAtPercent(xPercent, yPercent) {
+    let index = null;
+    if (this.surface.resolveIndexAtPoint) {
+      index = this.surface.resolveIndexAtPoint(xPercent, yPercent);
+    } else {
+      index = this.estimateIndexAtPercent(xPercent, yPercent);
+    }
+    if (index !== null && index >= 0) {
+      this.triggerSelection(index);
+    }
+    this.reset();
+  }
+  estimateIndexAtPercent(xPercent, yPercent) {
+    const totalItems = this.surface.getItemsCount();
+    if (!totalItems) return null;
+    const cols = Math.max(1, this.surface.getColumns());
+    const rows = Math.max(1, Math.ceil(totalItems / cols));
+    const col = Math.min(cols - 1, Math.max(0, Math.floor(xPercent / 100 * cols)));
+    const row = Math.min(rows - 1, Math.max(0, Math.floor(yPercent / 100 * rows)));
+    const index = row * cols + col;
+    if (index >= totalItems) return totalItems - 1;
+    return index;
+  }
+  emitUpdate() {
+    const dirInfo = this.getDirectionFromAngle(this.compassAngle);
+    const update = {
+      technique: this.technique,
+      state: this.state,
+      xPos: this.xPos,
+      yPos: this.yPos,
+      bufferLeft: this.bufferLeft,
+      bufferRight: this.bufferRight,
+      bufferTop: this.bufferTop,
+      bufferBottom: this.bufferBottom,
+      fineXPos: this.fineXPos,
+      fineYPos: this.fineYPos,
+      lockedXPosition: this.lockedXPosition,
+      compassAngle: this.compassAngle,
+      currentDirection: this.currentDirection,
+      directionName: dirInfo.name,
+      directionDx: dirInfo.dx,
+      directionDy: dirInfo.dy
+    };
+    this.callbacks.onContinuousUpdate?.(update);
+  }
+  getCost(itemIndex) {
+    const cols = this.surface.getColumns();
+    const row = Math.floor(itemIndex / cols);
+    const col = itemIndex % cols;
+    if (this.technique === "eight-direction") {
+      const itemCenterX = (col + 0.5) / cols * 100;
+      const itemCenterY = (row + 0.5) / Math.ceil(this.surface.getItemsCount() / cols) * 100;
+      const distance = Math.sqrt(Math.pow(itemCenterX, 2) + Math.pow(itemCenterY, 2));
+      return 4 + Math.round(distance / 0.5) + 1;
+    } else if (this.technique === "gliding") {
+      const itemCenter = (col + 0.5) / cols * 100;
+      return Math.round(itemCenter / 0.5) + 1;
+    } else {
+      const xPosition = (col + 0.5) / cols * 100;
+      const yPosition = (row + 0.5) / Math.ceil(this.surface.getItemsCount() / cols) * 100;
+      const xSteps = Math.round(xPosition / 0.5);
+      const ySteps = Math.round(yPosition / 0.5);
+      return xSteps + ySteps + 2;
+    }
+  }
+};
+
+// src/PredictorManager.ts
+import { createPredictor } from "@willwade/ppmpredictor";
+var PredictorManager = class {
+  constructor() {
+    __publicField(this, "predictor");
+    this.predictor = createPredictor({
+      adaptive: true,
+      maxOrder: 5
+    });
+    this.predictor.train("The quick brown fox jumps over the lazy dog. Hello world. How are you?");
+  }
+  addToContext(char) {
+    this.predictor.addToContext(char);
+  }
+  resetContext() {
+    this.predictor.resetContext();
+  }
+  predictNext() {
+    const preds = this.predictor.predictNextCharacter();
+    return preds;
+  }
+};
+
+// src/scanners/ProbabilityScanner.ts
+var ProbabilityScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "predictor", new PredictorManager());
+    __publicField(this, "scanOrder", []);
+    __publicField(this, "currentIndex", -1);
+  }
+  start() {
+    this.updateProbabilities();
+    super.start();
+  }
+  reset() {
+    this.currentIndex = -1;
+    this.surface.setFocus([]);
+  }
+  step() {
+    this.currentIndex++;
+    if (this.currentIndex >= this.scanOrder.length) {
+      this.currentIndex = 0;
+    }
+    const actualIndex = this.scanOrder[this.currentIndex];
+    const cfg = this.config.get();
+    this.surface.setFocus([actualIndex], {
+      phase: "item",
+      scanRate: cfg.scanRate,
+      scanPattern: cfg.scanPattern,
+      scanTechnique: cfg.scanTechnique,
+      scanDirection: cfg.scanDirection
+    });
+  }
+  handleAction(action) {
+    if (action === "cancel") {
+      this.reset();
+    } else {
+      super.handleAction(action);
+    }
+  }
+  doSelection() {
+    if (this.currentIndex >= 0) {
+      const actualIndex = this.scanOrder[this.currentIndex];
+      if (actualIndex >= 0) {
+        this.triggerSelection(actualIndex);
+        const data = this.surface.getItemData?.(actualIndex);
+        if (data?.label) {
+          this.predictor.addToContext(data.label.toLowerCase());
+        }
+        this.updateProbabilities();
+        this.triggerRedraw();
+        this.reset();
+        if (this.timer) clearTimeout(this.timer);
+        this.scheduleNextStep();
+      }
+    }
+  }
+  updateProbabilities() {
+    const preds = this.predictor.predictNext();
+    const itemsCount = this.surface.getItemsCount();
+    const itemProbs = [];
+    for (let i = 0; i < itemsCount; i++) {
+      let prob = 1e-4;
+      const data = this.surface.getItemData?.(i);
+      if (data?.label) {
+        const label = data.label.toLowerCase();
+        const p = preds.find((p2) => p2.text.toLowerCase() === label);
+        if (p) prob = p.probability;
+      }
+      itemProbs.push({ index: i, prob });
+    }
+    itemProbs.sort((a, b) => b.prob - a.prob);
+    this.scanOrder = itemProbs.map((ip) => ip.index);
+  }
+  getCost(itemIndex) {
+    const orderIndex = this.scanOrder.indexOf(itemIndex);
+    if (orderIndex === -1) return 999;
+    return orderIndex + 1;
+  }
+};
+
+// src/scanners/CauseEffectScanner.ts
+var CauseEffectScanner = class extends Scanner {
+  start() {
+    this.isRunning = true;
+    this.reset();
+    const count = this.surface.getItemsCount();
+    if (count > 0) {
+      const indices = Array.from({ length: count }, (_, i) => i);
+      const cfg = this.config.get();
+      this.surface.setFocus(indices, {
+        phase: "major",
+        scanRate: cfg.scanRate,
+        scanPattern: cfg.scanPattern,
+        scanTechnique: cfg.scanTechnique,
+        scanDirection: cfg.scanDirection
+      });
+    }
+  }
+  handleAction(action) {
+    if (action === "select" && this.isRunning) {
+      super.handleAction(action);
+    }
+  }
+  doSelection() {
+    const count = this.surface.getItemsCount();
+    if (count > 0) {
+      this.triggerSelection(0);
+    }
+  }
+  step() {
+  }
+  reset() {
+    const count = this.surface.getItemsCount();
+    if (count > 0) {
+      const indices = Array.from({ length: count }, (_, i) => i);
+      const cfg = this.config.get();
+      this.surface.setFocus(indices, {
+        phase: "major",
+        scanRate: cfg.scanRate,
+        scanPattern: cfg.scanPattern,
+        scanTechnique: cfg.scanTechnique,
+        scanDirection: cfg.scanDirection
+      });
+    }
+  }
+  getCost(_itemIndex) {
+    return 1;
+  }
+};
+
+// src/scanners/ColorCodeScanner.ts
+var ColorCodeScanner = class extends Scanner {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "probabilities", []);
+    __publicField(this, "colors", []);
+  }
+  start() {
+    this.isRunning = true;
+    this.initializeBelief();
+    this.assignColors();
+    this.applyColors();
+  }
+  stop() {
+    this.isRunning = false;
+    this.surface.setFocus([]);
+  }
+  handleAction(action) {
+    if (!this.isRunning) return;
+    let clicked = null;
+    if (action === "switch-1" || action === "select") {
+      clicked = "blue";
+    } else if (action === "switch-2" || action === "step") {
+      clicked = "red";
+    } else if (action === "reset") {
+      this.initializeBelief();
+      this.assignColors();
+      this.applyColors();
+      return;
+    } else {
+      return;
+    }
+    this.updateBelief(clicked);
+    this.assignColors();
+    this.applyColors();
+  }
+  step() {
+  }
+  reset() {
+    this.initializeBelief();
+    this.assignColors();
+    this.applyColors();
+  }
+  getCost(_itemIndex) {
+    return 1;
+  }
+  doSelection() {
+  }
+  initializeBelief() {
+    const count = this.surface.getItemsCount();
+    const value = count > 0 ? 1 / count : 0;
+    this.probabilities = new Array(count).fill(value);
+  }
+  assignColors() {
+    const indices = this.probabilities.map((p, i) => ({ p, i })).sort((a, b) => b.p - a.p);
+    let redSum = 0;
+    let blueSum = 0;
+    this.colors = new Array(this.probabilities.length).fill("blue");
+    for (const entry of indices) {
+      if (redSum <= blueSum) {
+        this.colors[entry.i] = "red";
+        redSum += entry.p;
+      } else {
+        this.colors[entry.i] = "blue";
+        blueSum += entry.p;
+      }
+    }
+  }
+  applyColors() {
+    const redColor = "#f9c6c6";
+    const blueColor = "#cfe3ff";
+    for (let i = 0; i < this.colors.length; i++) {
+      this.surface.setItemStyle?.(i, {
+        backgroundColor: this.colors[i] === "red" ? redColor : blueColor,
+        textColor: "#1e1e1e"
+      });
+    }
+  }
+  updateBelief(clicked) {
+    const { errorRate, selectThreshold } = this.config.get().colorCode;
+    const correctProb = 1 - errorRate;
+    let sum = 0;
+    for (let i = 0; i < this.probabilities.length; i++) {
+      const isMatch = this.colors[i] === clicked;
+      const likelihood = isMatch ? correctProb : errorRate;
+      this.probabilities[i] *= likelihood;
+      sum += this.probabilities[i];
+    }
+    if (sum > 0) {
+      for (let i = 0; i < this.probabilities.length; i++) {
+        this.probabilities[i] /= sum;
+      }
+    }
+    let maxIndex = 0;
+    for (let i = 1; i < this.probabilities.length; i++) {
+      if (this.probabilities[i] > this.probabilities[maxIndex]) {
+        maxIndex = i;
+      }
+    }
+    if (this.probabilities[maxIndex] >= selectThreshold) {
+      this.triggerSelection(maxIndex);
+      this.initializeBelief();
+    }
+  }
+};
+export {
+  CauseEffectScanner,
+  ColorCodeScanner,
+  ContinuousScanner,
+  EliminationScanner,
+  GroupScanner,
+  LinearScanner,
+  OverscanState,
+  PredictorManager,
+  ProbabilityScanner,
+  QuadrantScanner,
+  RowColumnScanner,
+  Scanner,
+  SnakeScanner
+};
+//# sourceMappingURL=index.js.map