chromium-tabs 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2084 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AddTabFlags: () => AddTabFlags,
+  CloseTabFlags: () => CloseTabFlags,
+  GROUP_COLOR_VALUES: () => GROUP_COLOR_VALUES,
+  GroupHeader: () => GroupHeader,
+  ListSelectionModel: () => ListSelectionModel,
+  NO_TAB: () => NO_TAB,
+  TAB_GROUP_COLORS: () => TAB_GROUP_COLORS,
+  TabItem: () => TabItem,
+  TabLifecycleManager: () => TabLifecycleManager,
+  TabPanels: () => TabPanels,
+  TabStrip: () => TabStrip,
+  TabStripModel: () => TabStripModel,
+  Tabs: () => Tabs,
+  useTabDrag: () => useTabDrag,
+  useTabStrip: () => useTabStrip,
+  useTabStripModel: () => useTabStripModel,
+  useTabVisibility: () => useTabVisibility
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/list-selection-model.ts
+function indexAfterInsertion(insertPosition, originalIndex) {
+  return originalIndex >= insertPosition ? originalIndex + 1 : originalIndex;
+}
+function indexAfterRemoval(removePosition, originalIndex) {
+  if (originalIndex === removePosition) return null;
+  return originalIndex > removePosition ? originalIndex - 1 : originalIndex;
+}
+function indexAfterMove(sourcePosition, destinationPosition, rangeSize, originalIndex) {
+  if (originalIndex === null) return null;
+  if (destinationPosition <= originalIndex && originalIndex < sourcePosition + rangeSize) {
+    if (originalIndex < sourcePosition) {
+      return originalIndex + rangeSize;
+    }
+    return originalIndex - (sourcePosition - destinationPosition);
+  }
+  return originalIndex;
+}
+var ListSelectionModel = class _ListSelectionModel {
+  selectedIndices_ = /* @__PURE__ */ new Set();
+  active_ = null;
+  anchor_ = null;
+  get anchor() {
+    return this.anchor_;
+  }
+  setAnchor(anchor) {
+    this.anchor_ = anchor;
+  }
+  get active() {
+    return this.active_;
+  }
+  setActive(active) {
+    this.active_ = active;
+  }
+  /** True if nothing is selected. */
+  get empty() {
+    return this.selectedIndices_.size === 0;
+  }
+  get size() {
+    return this.selectedIndices_.size;
+  }
+  /** Selected indices in ascending order. */
+  selectedIndices() {
+    return [...this.selectedIndices_].sort((a, b) => a - b);
+  }
+  /**
+   * Increments all indices >= index. Used when a new item is inserted.
+   * list_selection_model.cc:112
+   */
+  incrementFrom(index) {
+    const next = /* @__PURE__ */ new Set();
+    for (const i of this.selectedIndices_) next.add(indexAfterInsertion(index, i));
+    this.selectedIndices_ = next;
+    this.anchor_ = this.anchor_ === null ? null : indexAfterInsertion(index, this.anchor_);
+    this.active_ = this.active_ === null ? null : indexAfterInsertion(index, this.active_);
+  }
+  /**
+   * Shifts all indices > index down by 1; index itself is removed from the
+   * selection. Used when an item is removed. list_selection_model.cc:122
+   */
+  decrementFrom(index) {
+    const next = /* @__PURE__ */ new Set();
+    for (const i of this.selectedIndices_) {
+      const v = indexAfterRemoval(index, i);
+      if (v !== null) next.add(v);
+    }
+    this.selectedIndices_ = next;
+    this.anchor_ = this.anchor_ === null ? null : indexAfterRemoval(index, this.anchor_);
+    this.active_ = this.active_ === null ? null : indexAfterRemoval(index, this.active_);
+  }
+  /** Sets the anchor, active and selection to index. */
+  setSelectedIndex(index) {
+    this.anchor_ = index;
+    this.active_ = index;
+    this.selectedIndices_.clear();
+    if (index !== null) this.selectedIndices_.add(index);
+  }
+  isSelected(index) {
+    return this.selectedIndices_.has(index);
+  }
+  /** Adds index to the selection without changing active or anchor. */
+  addIndexToSelection(index) {
+    this.selectedIndices_.add(index);
+  }
+  /** Adds [indexStart, indexEnd] inclusive without changing active or anchor. */
+  addIndexRangeToSelection(indexStart, indexEnd) {
+    if (indexStart > indexEnd) throw new RangeError("indexStart must be <= indexEnd");
+    for (let i = indexStart; i <= indexEnd; i++) this.selectedIndices_.add(i);
+  }
+  /** Removes index from the selection without changing active or anchor. */
+  removeIndexFromSelection(index) {
+    this.selectedIndices_.delete(index);
+  }
+  /**
+   * Sets the selection to the range anchor..index. If there is no anchor,
+   * behaves like setSelectedIndex. list_selection_model.cc:171
+   */
+  setSelectionFromAnchorTo(index) {
+    if (this.anchor_ === null) {
+      this.setSelectedIndex(index);
+      return;
+    }
+    this.selectedIndices_.clear();
+    const min = Math.min(index, this.anchor_);
+    const max = Math.max(index, this.anchor_);
+    for (let i = min; i <= max; i++) this.selectedIndices_.add(i);
+    this.active_ = index;
+  }
+  /**
+   * Makes sure anchor..index are selected, adding to the existing selection.
+   * list_selection_model.cc:186
+   */
+  addSelectionFromAnchorTo(index) {
+    if (this.anchor_ === null) {
+      this.setSelectedIndex(index);
+      return;
+    }
+    const min = Math.min(index, this.anchor_);
+    const max = Math.max(index, this.anchor_);
+    for (let i = min; i <= max; i++) this.selectedIndices_.add(i);
+    this.active_ = index;
+  }
+  /**
+   * Invoked when `length` items move from oldIndex to newIndex. If moving to
+   * a greater index, newIndex is the index *after* removing the moved range.
+   * list_selection_model.cc:199
+   */
+  move(oldIndex, newIndex, length) {
+    if (oldIndex === newIndex) throw new RangeError("oldIndex must differ from newIndex");
+    if (length <= 0) throw new RangeError("length must be > 0");
+    if (newIndex > oldIndex) {
+      this.move(oldIndex + length, oldIndex, newIndex - oldIndex);
+      return;
+    }
+    this.anchor_ = indexAfterMove(oldIndex, newIndex, length, this.anchor_);
+    this.active_ = indexAfterMove(oldIndex, newIndex, length, this.active_);
+    const next = /* @__PURE__ */ new Set();
+    for (const i of this.selectedIndices_) {
+      const v = indexAfterMove(oldIndex, newIndex, length, i);
+      if (v !== null) next.add(v);
+    }
+    this.selectedIndices_ = next;
+  }
+  /** Clears the selection, anchor and active. */
+  clear() {
+    this.anchor_ = null;
+    this.active_ = null;
+    this.selectedIndices_.clear();
+  }
+  clone() {
+    const copy = new _ListSelectionModel();
+    copy.selectedIndices_ = new Set(this.selectedIndices_);
+    copy.active_ = this.active_;
+    copy.anchor_ = this.anchor_;
+    return copy;
+  }
+  equals(other) {
+    if (this.active_ !== other.active_ || this.anchor_ !== other.anchor_) return false;
+    if (this.selectedIndices_.size !== other.selectedIndices_.size) return false;
+    for (const i of this.selectedIndices_) {
+      if (!other.selectedIndices_.has(i)) return false;
+    }
+    return true;
+  }
+  /** 'active=X anchor=X selection=X X X...' — matches the C++ ToString. */
+  toString() {
+    const opt = (v) => v === null ? "<none>" : String(v);
+    return `active=${opt(this.active_)} anchor=${opt(this.anchor_)} selection=${this.selectedIndices().join(" ")}`;
+  }
+};
+
+// src/core/types.ts
+var NO_TAB = -1;
+var AddTabFlags = {
+  NONE: 0,
+  /** The tab should become the active tab. */
+  ACTIVE: 1 << 0,
+  /** The tab should be pinned. */
+  PINNED: 1 << 1,
+  /**
+   * Use the caller-supplied index rather than letting the model determine
+   * the position from the open cause and opener relationships.
+   */
+  FORCE_INDEX: 1 << 2,
+  /** Set the new tab's opener to the currently active tab. */
+  INHERIT_OPENER: 1 << 3
+};
+var CloseTabFlags = {
+  NONE: 0,
+  /** The close was triggered directly by a user gesture. */
+  USER_GESTURE: 1 << 0
+};
+var TAB_GROUP_COLORS = [
+  "grey",
+  "blue",
+  "red",
+  "yellow",
+  "green",
+  "pink",
+  "purple",
+  "cyan",
+  "orange"
+];
+
+// src/core/tab-strip-model.ts
+function defaultGenerateId() {
+  return `t${Math.random().toString(36).slice(2, 10)}`;
+}
+var TabStripModel = class {
+  tabs_ = [];
+  groups_ = /* @__PURE__ */ new Map();
+  // Selection is tracked by tab identity, mirroring Chrome's
+  // TabStripModelSelectionState; index views are derived on demand.
+  selectedTabs_ = /* @__PURE__ */ new Set();
+  activeTab_ = null;
+  anchorTab_ = null;
+  observers_ = /* @__PURE__ */ new Set();
+  closingAll_ = false;
+  reentrancyGuard_ = false;
+  canCloseTab_;
+  supportsGroups_;
+  generateId_;
+  constructor(options = {}) {
+    this.canCloseTab_ = options.canCloseTab ?? (() => true);
+    this.supportsGroups_ = options.supportsGroups ?? true;
+    this.generateId_ = options.generateId ?? defaultGenerateId;
+  }
+  // Basic queries ////////////////////////////////////////////////////////////
+  get count() {
+    return this.tabs_.length;
+  }
+  get empty() {
+    return this.tabs_.length === 0;
+  }
+  /** True while closeAllTabs is in progress. */
+  get closingAll() {
+    return this.closingAll_;
+  }
+  containsIndex(index) {
+    return index >= 0 && index < this.tabs_.length;
+  }
+  getTabAt(index) {
+    const tab = this.tabs_[index];
+    if (!tab) throw new RangeError(`no tab at index ${index}`);
+    return tab;
+  }
+  indexOfTab(tab) {
+    if (!tab) return NO_TAB;
+    return this.tabs_.indexOf(tab);
+  }
+  getTabById(id) {
+    return this.tabs_.find((t) => t.id === id) ?? null;
+  }
+  /** Snapshot of the tabs in strip order. */
+  getTabs() {
+    return [...this.tabs_];
+  }
+  get activeTab() {
+    return this.activeTab_;
+  }
+  get activeIndex() {
+    return this.activeTab_ ? this.indexOfTab(this.activeTab_) : NO_TAB;
+  }
+  /** Index of the first non-pinned tab; count if all pinned. (cc:1418 area) */
+  indexOfFirstNonPinnedTab() {
+    const i = this.tabs_.findIndex((t) => !t.pinned);
+    return i === -1 ? this.tabs_.length : i;
+  }
+  isTabPinned(index) {
+    return this.getTabAt(index).pinned;
+  }
+  isTabBlocked(index) {
+    return this.getTabAt(index).blocked;
+  }
+  isTabSelected(index) {
+    return this.selectedTabs_.has(this.getTabAt(index));
+  }
+  /** Derived index-based view of the selection (Chrome: GetListSelectionModel). */
+  selectionModel() {
+    const model = new ListSelectionModel();
+    for (const tab of this.selectedTabs_) {
+      const i = this.indexOfTab(tab);
+      if (i !== NO_TAB) model.addIndexToSelection(i);
+    }
+    model.setActive(this.activeTab_ ? this.indexOfTab(this.activeTab_) : null);
+    model.setAnchor(this.anchorTab_ ? this.indexOfTab(this.anchorTab_) : null);
+    return model;
+  }
+  // Group queries //////////////////////////////////////////////////////////
+  get supportsTabGroups() {
+    return this.supportsGroups_;
+  }
+  getTabGroupForTab(index) {
+    if (!this.containsIndex(index)) return null;
+    return this.tabs_[index].group;
+  }
+  getGroups() {
+    return [...this.groups_.entries()].map(([id, visualData]) => ({ id, visualData }));
+  }
+  getGroupVisualData(group) {
+    return this.groups_.get(group) ?? null;
+  }
+  containsGroup(group) {
+    return this.groups_.has(group);
+  }
+  /** [start, end) range of the group's tabs. Mirrors TabGroup::ListTabs. */
+  listTabsInGroup(group) {
+    let start = -1;
+    let end = -1;
+    for (let i = 0; i < this.tabs_.length; i++) {
+      if (this.tabs_[i].group === group) {
+        if (start === -1) start = i;
+        end = i + 1;
+      }
+    }
+    if (start === -1) throw new Error(`no such group: ${group}`);
+    return { start, end };
+  }
+  isGroupCollapsed(group) {
+    return this.groups_.get(group)?.isCollapsed ?? false;
+  }
+  /** True if the tab is inside a collapsed group. (cc:1423) */
+  isTabCollapsed(index) {
+    const group = this.getTabGroupForTab(index);
+    return group !== null && this.isGroupCollapsed(group);
+  }
+  /**
+   * If a tab inserted at index would land inside a group, returns that group.
+   * Returns null at the first index of a group (a tab there sits between
+   * groups, not inside one). Mirrors GetSurroundingTabGroup.
+   */
+  getSurroundingTabGroup(index) {
+    const before = this.getTabGroupForTab(index - 1);
+    const at = this.getTabGroupForTab(index);
+    return before !== null && before === at ? before : null;
+  }
+  // Observers //////////////////////////////////////////////////////////////
+  addObserver(observer) {
+    this.observers_.add(observer);
+    return () => this.observers_.delete(observer);
+  }
+  removeObserver(observer) {
+    this.observers_.delete(observer);
+  }
+  // Add / insert ///////////////////////////////////////////////////////////
+  /**
+   * Command-level add: picks the position from the open cause and opener
+   * relationships, then inserts. Port of AddTab (cc:1715-1828).
+   */
+  addTab(data, options = {}) {
+    this.checkReentrancy_();
+    const cause = options.cause ?? "other";
+    const flags = options.flags ?? 0;
+    let index = options.index ?? NO_TAB;
+    let group = options.group ?? null;
+    let inheritOpener = (flags & AddTabFlags.INHERIT_OPENER) !== 0;
+    if (cause === "link" && (flags & AddTabFlags.FORCE_INDEX) === 0) {
+      index = this.determineInsertionIndex(cause, (flags & AddTabFlags.ACTIVE) !== 0);
+      inheritOpener = true;
+      if (group === null) {
+        group = this.getTabGroupForTab(this.activeIndex);
+      }
+    } else if (index < 0 || index > this.count) {
+      index = this.count;
+    }
+    if (this.supportsGroups_) {
+      if (group !== null && this.groups_.has(group)) {
+        const range = this.listTabsInGroup(group);
+        index = Math.min(Math.max(index, range.start), range.end);
+      } else if (group === null && this.getTabGroupForTab(index - 1) !== null && this.getTabGroupForTab(index - 1) === this.getTabGroupForTab(index)) {
+        group = this.getTabGroupForTab(index);
+      }
+      if (flags & AddTabFlags.PINNED) group = null;
+    } else {
+      group = null;
+    }
+    if (cause === "typed" && index === this.count) {
+      inheritOpener = true;
+    }
+    const tab = this.createTab_(data, options.id);
+    this.insertTabAtImpl_(
+      index,
+      tab,
+      flags | (inheritOpener ? AddTabFlags.INHERIT_OPENER : 0),
+      group
+    );
+    if (inheritOpener && cause === "typed") {
+      tab.resetOpenerOnActiveTabChange = true;
+    }
+    return tab;
+  }
+  /** Adds a tab at the end of the strip. Port of AppendTab. */
+  appendTab(data, foreground = true) {
+    return this.addTab(data, {
+      index: this.count,
+      cause: "other",
+      flags: AddTabFlags.FORCE_INDEX | (foreground ? AddTabFlags.ACTIVE : 0)
+    });
+  }
+  /**
+   * Inserts at the given index, only adjusting it to keep pinned tabs at the
+   * front. Does NOT consult the order controller. Port of InsertWebContentsAt.
+   * Returns the index actually used.
+   */
+  insertTabAt(index, data, options = {}) {
+    this.checkReentrancy_();
+    const group = options.group ?? null;
+    if (group !== null && !this.groups_.has(group)) {
+      throw new Error(`no such group: ${group}`);
+    }
+    const tab = this.createTab_(data, options.id);
+    this.insertTabAtImpl_(index, tab, options.flags ?? 0, group);
+    return tab;
+  }
+  // Activate / selection ///////////////////////////////////////////////////
+  /** Makes the tab at index active. Port of ActivateTabAt (cc:1022). */
+  activateTabAt(index, options = {}) {
+    this.checkReentrancy_();
+    if (!this.containsIndex(index)) throw new RangeError(`no tab at index ${index}`);
+    const tab = this.tabs_[index];
+    this.setSelection_(
+      () => this.setSelectedTab_(tab),
+      options.userGesture ? "userGesture" : "none"
+    );
+  }
+  /** Extends the selection from the anchor to index. Port of cc:1514. */
+  extendSelectionTo(index) {
+    this.checkReentrancy_();
+    const tab = this.getTabAt(index);
+    this.setSelection_(() => {
+      if (!this.anchorTab_) {
+        this.setSelectedTab_(tab);
+        return;
+      }
+      const anchorIndex = this.indexOfTab(this.anchorTab_);
+      const lo = Math.min(anchorIndex, index);
+      const hi = Math.max(anchorIndex, index);
+      this.selectedTabs_ = new Set(this.tabs_.slice(lo, hi + 1));
+      this.activeTab_ = tab;
+    }, "none");
+  }
+  /** Adds the tab at index to the selection and makes it active+anchor. (cc:1545) */
+  selectTabAt(index) {
+    this.checkReentrancy_();
+    const tab = this.getTabAt(index);
+    this.setSelection_(() => {
+      this.selectedTabs_.add(tab);
+      this.anchorTab_ = tab;
+      this.activeTab_ = tab;
+    }, "none");
+  }
+  /** Removes the tab at index from the selection. No-op if it's the last one. (cc:1570) */
+  deselectTabAt(index) {
+    this.checkReentrancy_();
+    const tab = this.getTabAt(index);
+    if (!this.selectedTabs_.has(tab)) return;
+    if (this.selectedTabs_.size === 1) return;
+    this.setSelection_(() => {
+      this.selectedTabs_.delete(tab);
+      const first = this.firstSelectedTab_();
+      if (!this.activeTab_ || this.activeTab_ === tab) this.activeTab_ = first;
+      if (!this.anchorTab_ || this.anchorTab_ === tab) this.anchorTab_ = first;
+    }, "none");
+  }
+  /** Selects anchor..index, adding to the current selection. (cc:1616) */
+  addSelectionFromAnchorTo(index) {
+    this.checkReentrancy_();
+    const tab = this.getTabAt(index);
+    this.setSelection_(() => {
+      if (!this.anchorTab_) {
+        this.setSelectedTab_(tab);
+        return;
+      }
+      const anchorIndex = this.indexOfTab(this.anchorTab_);
+      const lo = Math.min(anchorIndex, index);
+      const hi = Math.max(anchorIndex, index);
+      for (const t of this.tabs_.slice(lo, hi + 1)) this.selectedTabs_.add(t);
+      this.activeTab_ = tab;
+    }, "none");
+  }
+  /** Replaces the selection with the given index-based model. */
+  setSelectionFromModel(source) {
+    this.checkReentrancy_();
+    if (source.active === null) throw new Error("selection must have an active index");
+    this.setSelection_(() => {
+      this.selectedTabs_ = new Set(source.selectedIndices().map((i) => this.getTabAt(i)));
+      this.activeTab_ = this.getTabAt(source.active);
+      this.anchorTab_ = source.anchor === null ? null : this.getTabAt(source.anchor);
+    }, "none");
+  }
+  /**
+   * Activates the next/previous tab, wrapping around and skipping collapsed
+   * groups. Port of SelectRelativeTab (cc:3951).
+   */
+  selectNextTab(options = {}) {
+    this.selectRelativeTab_(1, options);
+  }
+  selectPreviousTab(options = {}) {
+    this.selectRelativeTab_(-1, options);
+  }
+  selectLastTab(options = {}) {
+    if (this.empty) return;
+    this.activateTabAt(this.count - 1, options);
+  }
+  selectRelativeTab_(delta, options) {
+    if (this.empty) return;
+    const startIndex = this.activeIndex;
+    let index = (startIndex + this.count + delta) % this.count;
+    let group = this.getTabGroupForTab(index);
+    while (group !== null && this.isGroupCollapsed(group)) {
+      index = (index + this.count + delta) % this.count;
+      group = this.getTabGroupForTab(index);
+    }
+    this.activateTabAt(index, options);
+  }
+  // Move ///////////////////////////////////////////////////////////////////
+  /**
+   * Moves the tab at index to toPosition (clamped so pinned tabs stay
+   * together). Group membership adjusts to keep groups contiguous. Port of
+   * MoveWebContentsAt (cc:1053). Returns the final index.
+   */
+  moveTabTo(index, toPosition, selectAfterMove = false) {
+    this.checkReentrancy_();
+    if (!this.containsIndex(index)) throw new RangeError(`no tab at index ${index}`);
+    const pinned = this.isTabPinned(index);
+    toPosition = this.constrainMoveIndex_(toPosition, pinned);
+    if (index === toPosition) return toPosition;
+    const group = this.getGroupToAssign_(index, toPosition);
+    this.moveTabToIndexImpl_(index, toPosition, group, pinned, selectAfterMove);
+    return toPosition;
+  }
+  /**
+   * Moves the selected tabs to index, pinned tabs first as a chunk, then
+   * unpinned. `index` is interpreted as if the strip did not contain the
+   * selected tabs. Port of MoveSelectedTabsTo (cc:1089).
+   */
+  moveSelectedTabsTo(index, group = null) {
+    this.checkReentrancy_();
+    const pinnedTabCount = this.indexOfFirstNonPinnedTab();
+    const pinnedSelected = this.selectedIndices_().filter((i) => i < pinnedTabCount);
+    const unpinnedSelected = this.selectedIndices_().filter((i) => i >= pinnedTabCount);
+    const lastPinnedIndex = clamp(
+      index + pinnedSelected.length - 1,
+      pinnedSelected.length - 1,
+      pinnedTabCount - 1
+    );
+    this.moveTabsToIndexImpl_(pinnedSelected, lastPinnedIndex - pinnedSelected.length + 1, "keep");
+    const firstUnpinnedIndex = clamp(
+      index + pinnedSelected.length,
+      pinnedTabCount,
+      this.count - unpinnedSelected.length
+    );
+    this.moveTabsToIndexImpl_(unpinnedSelected, firstUnpinnedIndex, group);
+  }
+  /** Moves all tabs of a group to toIndex. Port of MoveGroupTo (cc:1117). */
+  moveGroupTo(group, toIndex) {
+    this.checkReentrancy_();
+    if (!this.groups_.has(group)) throw new Error(`no such group: ${group}`);
+    toIndex = this.constrainMoveIndex_(toIndex, false);
+    const range = this.listTabsInGroup(group);
+    if (range.start === toIndex) return;
+    const indices = [];
+    for (let i = range.start; i < range.end; i++) indices.push(i);
+    const length = indices.length;
+    const dest = clamp(
+      toIndex > range.start ? toIndex - length + 1 : toIndex,
+      this.indexOfFirstNonPinnedTab() - countLessThan(indices, this.indexOfFirstNonPinnedTab()),
+      this.count - length
+    );
+    this.moveTabsToIndexImpl_(indices, dest, "keep");
+    this.notifyAll_((o) => o.onTabGroupChanged?.({ type: "moved", groupId: group }));
+  }
+  /**
+   * Moves the active tab one slot right/left. At a group boundary the tab
+   * first changes group membership without moving; collapsed neighbor groups
+   * are hopped over entirely. Port of MoveTabRelative (cc:3976).
+   */
+  moveTabNext() {
+    this.moveTabRelative_(1);
+  }
+  moveTabPrevious() {
+    this.moveTabRelative_(-1);
+  }
+  moveTabRelative_(delta) {
+    this.checkReentrancy_();
+    const start = this.activeIndex;
+    if (start === NO_TAB) throw new Error("no active tab");
+    let targetIndex = start;
+    const neighborIndex = delta === 1 ? start + 1 : start - 1;
+    if (this.containsIndex(neighborIndex) && this.isTabPinned(start) === this.isTabPinned(neighborIndex)) {
+      targetIndex += delta;
+    }
+    const currentGroup = this.getTabGroupForTab(start);
+    let targetGroup = targetIndex === start ? null : this.getTabGroupForTab(neighborIndex);
+    if (this.supportsGroups_ && currentGroup !== targetGroup) {
+      if (currentGroup !== null) {
+        targetIndex = start;
+        targetGroup = null;
+      } else if (targetGroup !== null) {
+        if (this.isGroupCollapsed(targetGroup)) {
+          const range = this.listTabsInGroup(targetGroup);
+          targetIndex = delta === 1 ? range.end - 1 : range.start;
+          targetGroup = null;
+        } else {
+          targetIndex = start;
+        }
+      }
+    }
+    this.moveTabsToIndexImpl_([start], targetIndex, targetGroup);
+  }
+  // Pinning ////////////////////////////////////////////////////////////////
+  /**
+   * Pins or unpins the tab, moving it to the pinned/unpinned boundary.
+   * Pinning removes the tab from its group. Returns the final index.
+   * Port of SetTabPinned (cc:1407) + SetTabPinnedImpl (cc:5052).
+   */
+  setTabPinned(index, pinned) {
+    this.checkReentrancy_();
+    if (!this.containsIndex(index)) throw new RangeError(`no tab at index ${index}`);
+    if (this.isTabPinned(index) === pinned) return index;
+    const finalIndex = pinned ? this.indexOfFirstNonPinnedTab() : this.indexOfFirstNonPinnedTab() - 1;
+    this.moveTabToIndexImpl_(index, finalIndex, null, pinned, false);
+    return finalIndex;
+  }
+  // Close //////////////////////////////////////////////////////////////////
+  /** Closes the tab at index. Returns true if it closed (not vetoed). */
+  closeTabAt(index) {
+    return this.closeTabs_([this.getTabAt(index)]);
+  }
+  /** Closes the tabs at the given indices. */
+  closeTabsAt(indices) {
+    return this.closeTabs_(indices.map((i) => this.getTabAt(i)));
+  }
+  /** Port of CloseSelectedTabs. */
+  closeSelectedTabs() {
+    return this.closeTabs_([...this.selectedTabs_]);
+  }
+  /** Port of CloseAllTabs (cc:455). */
+  closeAllTabs() {
+    return this.closeTabs_([...this.tabs_]);
+  }
+  /** Context-menu style helper: close every tab except the one at index. */
+  closeOtherTabs(index) {
+    const keep = this.getTabAt(index);
+    return this.closeTabs_(this.tabs_.filter((t) => t !== keep && !t.pinned));
+  }
+  /** Context-menu style helper: close unpinned tabs to the right of index. */
+  closeTabsToRight(index) {
+    return this.closeTabs_(this.tabs_.slice(index + 1).filter((t) => !t.pinned));
+  }
+  /** Closes all tabs in a group. Port of CloseAllTabsInGroup. */
+  closeAllTabsInGroup(group) {
+    const range = this.listTabsInGroup(group);
+    return this.closeTabs_(this.tabs_.slice(range.start, range.end));
+  }
+  closeTabs_(tabs, options = {}) {
+    this.checkReentrancy_();
+    const closable = [];
+    for (const tab of tabs) {
+      if (options.bypassVeto || this.canCloseTab_(tab)) {
+        closable.push(tab);
+      } else {
+        this.notifyAll_((o) => o.onTabCloseCancelled?.(tab));
+      }
+    }
+    if (closable.length === 0) return false;
+    const closingAll = closable.length === this.count;
+    if (closingAll) {
+      this.closingAll_ = true;
+      this.notifyAll_((o) => o.willCloseAllTabs?.());
+    }
+    const oldActive = this.activeTab_;
+    const oldModel = this.selectionModel();
+    const removed = [];
+    const groupNotifications = [];
+    for (const tab of closable) {
+      const index = this.indexOfTab(tab);
+      if (index === NO_TAB) continue;
+      this.removeTabFromIndexImpl_(index);
+      removed.push({ tab, index });
+      if (tab.group !== null) {
+        groupNotifications.push({ tab, index, group: tab.group });
+        tab.group = null;
+      }
+    }
+    this.validate_();
+    const selection = this.buildSelectionChange_(oldActive, oldModel, "none");
+    this.notifyAll_(
+      (o) => o.onTabStripModelChanged?.({ type: "removed", contents: removed }, selection)
+    );
+    for (const { tab, index, group } of groupNotifications) {
+      this.notifyAll_((o) => o.onTabGroupedStateChanged?.(group, null, tab, index));
+    }
+    for (const { group } of groupNotifications) {
+      if (this.groups_.has(group) && !this.tabs_.some((t) => t.group === group)) {
+        this.groups_.delete(group);
+        this.notifyAll_((o) => o.onTabGroupChanged?.({ type: "closed", groupId: group }));
+      }
+    }
+    this.handleActiveTabChanged_(selection);
+    if (closingAll) {
+      this.closingAll_ = false;
+      this.notifyAll_((o) => o.closeAllTabsStopped?.("completed"));
+    }
+    return true;
+  }
+  /**
+   * Removes the tab and fixes up the selection. Port of
+   * RemoveTabFromIndexImpl (cc:4551). Caller batches notifications.
+   */
+  removeTabFromIndexImpl_(index) {
+    const tab = this.tabs_[index];
+    const nextSelectedIndex = this.determineNewSelectedIndex_(index);
+    this.fixOpeners_(index);
+    this.tabs_.splice(index, 1);
+    this.selectedTabs_.delete(tab);
+    if (this.anchorTab_ === tab) this.anchorTab_ = null;
+    if (this.empty) {
+      this.selectedTabs_.clear();
+      this.activeTab_ = null;
+      this.anchorTab_ = null;
+    } else if (this.activeTab_ === tab) {
+      if (this.selectedTabs_.size > 0) {
+        const first = this.firstSelectedTab_();
+        this.activeTab_ = first;
+        this.anchorTab_ = first;
+      } else {
+        if (nextSelectedIndex === null) throw new Error("invariant: no next tab to select");
+        this.setSelectedTab_(this.tabs_[nextSelectedIndex]);
+      }
+    }
+    return tab;
+  }
+  // External-state reconciliation //////////////////////////////////////////
+  /**
+   * Converges the strip to an external source-of-truth list with minimal
+   * mutations (no remove-all/re-add), so an app whose canonical tab state
+   * lives elsewhere (a router, a store, another window) can mirror it into
+   * the model without losing tab identity, content state, or discard status.
+   *
+   * - tabs absent from `desired` are removed, bypassing `canCloseTab` (the
+   *   external state has already decided)
+   * - missing tabs are inserted at their position under the given id
+   * - `data` is swapped via setTabData where `dataEquals` reports a change
+   * - pinned state and order converge to the desired list; pass a
+   *   pinned-first-consistent list or Chrome's clamping rules win
+   * - `activeId`, when provided and present, is activated last
+   *
+   * Observers fire for each underlying mutation as usual; reconcile-driven
+   * activations carry reason 'none', so a consumer that also writes model
+   * changes back to the external store can tell them from user gestures.
+   * Groups are not reconciled. No Chrome equivalent: this is integration
+   * surface for embedding apps.
+   */
+  reconcile(desired, options = {}) {
+    this.checkReentrancy_();
+    const dataEquals = options.dataEquals ?? Object.is;
+    const desiredIds = /* @__PURE__ */ new Set();
+    for (const want of desired) {
+      if (desiredIds.has(want.id)) throw new Error(`duplicate tab id in reconcile: ${want.id}`);
+      desiredIds.add(want.id);
+    }
+    const toRemove = this.tabs_.filter((tab) => !desiredIds.has(tab.id));
+    if (toRemove.length > 0) this.closeTabs_(toRemove, { bypassVeto: true });
+    desired.forEach((want, position) => {
+      const existing = this.getTabById(want.id);
+      const pinned = want.pinned ?? false;
+      if (!existing) {
+        this.insertTabAt(position, want.data, {
+          id: want.id,
+          flags: pinned ? AddTabFlags.PINNED : AddTabFlags.NONE
+        });
+        return;
+      }
+      if (!dataEquals(existing.data, want.data)) {
+        this.setTabData(this.indexOfTab(existing), want.data);
+      }
+      if (existing.pinned !== pinned) {
+        this.setTabPinned(this.indexOfTab(existing), pinned);
+      }
+      const index = this.indexOfTab(existing);
+      if (index !== position) {
+        this.moveTabTo(index, position);
+      }
+    });
+    if (options.activeId != null) {
+      const activeIndex = this.indexOfTab(this.getTabById(options.activeId));
+      if (activeIndex !== NO_TAB && activeIndex !== this.activeIndex) {
+        this.activateTabAt(activeIndex);
+      }
+    }
+  }
+  // Openers ////////////////////////////////////////////////////////////////
+  getOpenerOfTabAt(index) {
+    return this.getTabAt(index).opener;
+  }
+  setOpenerOfTabAt(index, opener) {
+    const tab = this.getTabAt(index);
+    if (opener === tab) throw new Error("a tab cannot be its own opener");
+    if (opener && this.indexOfTab(opener) === NO_TAB) {
+      throw new Error("opener must be in this tab strip");
+    }
+    tab.opener = opener;
+  }
+  /** Port of ForgetAllOpeners (cc:3376). */
+  forgetAllOpeners() {
+    for (const tab of this.tabs_) tab.opener = null;
+  }
+  forgetOpener(tab) {
+    tab.opener = null;
+  }
+  /**
+   * Call when the user navigates a tab. Typed-style navigations reset all
+   * opener relationships (the user started a new task), except in a fresh
+   * end-of-strip tab. Port of TabNavigating (cc:1378).
+   */
+  tabNavigating(tab, cause) {
+    if (cause !== "typed") return;
+    const isNewTabAtEnd = tab === this.tabs_[this.tabs_.length - 1] && tab.resetOpenerOnActiveTabChange;
+    if (!isNewTabAtEnd) this.forgetAllOpeners();
+  }
+  /**
+   * Index of the last tab opened (transitively) by the tab at startIndex,
+   * scanning right, skipping pinned tabs, stopping at the first unrelated
+   * unpinned tab. Port of GetIndexOfLastWebContentsOpenedBy (cc:1351).
+   */
+  getIndexOfLastTabOpenedBy(opener, startIndex) {
+    const openerAndDescendants = /* @__PURE__ */ new Set([opener]);
+    let lastIndex = NO_TAB;
+    for (let i = startIndex + 1; i < this.count; i++) {
+      const tab = this.tabs_[i];
+      if (!tab.opener || !openerAndDescendants.has(tab.opener)) {
+        if (tab.pinned) continue;
+        break;
+      }
+      openerAndDescendants.add(tab);
+      lastIndex = i;
+    }
+    return lastIndex;
+  }
+  // Groups /////////////////////////////////////////////////////////////////
+  /**
+   * Creates a group containing the tabs at indices (ascending). Tabs are
+   * unpinned and made contiguous without splitting other groups. Returns the
+   * group id. Port of AddToNewGroup (cc:671) + AddToNewGroupImpl (cc:4344).
+   */
+  addToNewGroup(indices, visualData) {
+    this.checkReentrancy_();
+    this.requireGroups_();
+    assertAscending(indices);
+    if (indices.length === 0) throw new Error("indices must not be empty");
+    const groupId = this.generateId_();
+    this.groups_.set(groupId, {
+      title: visualData?.title ?? "",
+      color: visualData?.color ?? this.nextGroupColor_(),
+      isCollapsed: visualData?.isCollapsed ?? false
+    });
+    this.notifyAll_((o) => o.onTabGroupChanged?.({ type: "created", groupId }));
+    const firstGroup = this.getTabGroupForTab(indices[0]);
+    let destinationIndex = -1;
+    for (let i = indices[0]; i <= this.count; i++) {
+      if (!this.containsIndex(i)) {
+        destinationIndex = i;
+        break;
+      }
+      if (this.isTabPinned(i)) continue;
+      const destinationGroup = this.getTabGroupForTab(i);
+      if (destinationGroup === null || destinationGroup !== firstGroup) {
+        destinationIndex = i;
+        break;
+      }
+    }
+    this.moveTabsAndSetProperties_(indices, destinationIndex, groupId, false);
+    const range = this.listTabsInGroup(groupId);
+    for (let i = range.start; i < range.end; i++) {
+      if (this.activeIndex !== i && this.isTabSelected(i)) this.deselectTabAt(i);
+    }
+    return groupId;
+  }
+  /**
+   * Adds the tabs at indices (ascending) to an existing group. Tabs left of
+   * the group move to its start, tabs right of it to its end; addToEnd sends
+   * everything to the end. Port of AddToExistingGroup (cc:4415).
+   */
+  addToExistingGroup(indices, group, addToEnd = false) {
+    this.checkReentrancy_();
+    this.requireGroups_();
+    assertAscending(indices);
+    if (!this.groups_.has(group)) return;
+    const range = this.listTabsInGroup(group);
+    const firstTabIndex = range.start;
+    const lastTabIndex = range.end - 1;
+    const tabsLeftOfGroup = indices.filter((i) => i < firstTabIndex);
+    const tabsRightOfGroup = indices.filter((i) => i > lastTabIndex);
+    if (addToEnd) {
+      this.moveTabsAndSetProperties_(
+        [...tabsLeftOfGroup, ...tabsRightOfGroup],
+        lastTabIndex + 1,
+        group,
+        false
+      );
+    } else {
+      this.moveTabsAndSetProperties_(tabsLeftOfGroup, firstTabIndex, group, false);
+      this.moveTabsAndSetProperties_(tabsRightOfGroup, lastTabIndex + 1, group, false);
+    }
+  }
+  /**
+   * Removes the tabs at indices (ascending) from their groups. Tabs in the
+   * first half of a group exit left of it, the rest exit right. Port of
+   * RemoveFromGroup (cc:4253 area) + SeparateTabsByVisualPosition.
+   */
+  removeFromGroup(indices) {
+    this.checkReentrancy_();
+    this.requireGroups_();
+    assertAscending(indices);
+    const indicesPerGroup = /* @__PURE__ */ new Map();
+    for (const index of indices) {
+      const group = this.getTabGroupForTab(index);
+      if (group !== null) {
+        if (!indicesPerGroup.has(group)) indicesPerGroup.set(group, []);
+        indicesPerGroup.get(group).push(index);
+      }
+    }
+    for (const [group, groupIndices] of indicesPerGroup) {
+      const range = this.listTabsInGroup(group);
+      const firstTabIndex = range.start;
+      const lastTabIndex = range.end - 1;
+      const midpoint = Math.floor((range.end - range.start) / 2);
+      const leftOfGroup = groupIndices.filter((i) => i - firstTabIndex < midpoint);
+      const rightOfGroup = groupIndices.filter((i) => i - firstTabIndex >= midpoint);
+      this.moveTabsAndSetProperties_(leftOfGroup, firstTabIndex, null, false);
+      this.moveTabsAndSetProperties_(rightOfGroup, lastTabIndex + 1, null, false);
+    }
+  }
+  /** Updates a group's title/color/collapsed state. Port of ChangeTabGroupVisuals. */
+  updateGroupVisuals(group, visuals) {
+    const old = this.groups_.get(group);
+    if (!old) throw new Error(`no such group: ${group}`);
+    const next = { ...old, ...visuals };
+    if (old.isCollapsed !== next.isCollapsed && next.isCollapsed) {
+      const range = this.listTabsInGroup(group);
+      const active = this.activeIndex;
+      if (active >= range.start && active < range.end) {
+        this.groups_.set(group, next);
+        const fallback = this.getNextExpandedActiveTab_(range.start, range.end);
+        if (fallback === null) {
+          this.groups_.set(group, old);
+          throw new Error("cannot collapse the only expanded tabs in the strip");
+        }
+        this.activateTabAt(fallback);
+        this.notifyAll_(
+          (o) => o.onTabGroupChanged?.({ type: "visualsChanged", groupId: group, oldVisuals: old, newVisuals: next })
+        );
+        return;
+      }
+    }
+    this.groups_.set(group, next);
+    this.notifyAll_(
+      (o) => o.onTabGroupChanged?.({ type: "visualsChanged", groupId: group, oldVisuals: old, newVisuals: next })
+    );
+  }
+  setGroupCollapsed(group, collapsed) {
+    this.updateGroupVisuals(group, { isCollapsed: collapsed });
+  }
+  /** Chrome's TabGroupModel::GetNextColor: least-used color, in palette order. */
+  nextGroupColor_() {
+    const usage = /* @__PURE__ */ new Map();
+    for (const color of TAB_GROUP_COLORS) usage.set(color, 0);
+    for (const { color } of this.groups_.values()) {
+      usage.set(color, (usage.get(color) ?? 0) + 1);
+    }
+    let best = TAB_GROUP_COLORS[0];
+    for (const color of TAB_GROUP_COLORS) {
+      if (usage.get(color) < usage.get(best)) best = color;
+    }
+    return best;
+  }
+  // Tab data / state ///////////////////////////////////////////////////////
+  /** Swaps the tab's data payload. Emits a 'replaced' change (Chrome: Replace). */
+  setTabData(index, data) {
+    const tab = this.getTabAt(index);
+    const oldData = tab.data;
+    tab.data = data;
+    const selection = this.buildSelectionChange_(this.activeTab_, this.selectionModel(), "none");
+    this.notifyAll_(
+      (o) => o.onTabStripModelChanged?.(
+        { type: "replaced", tab, oldData, newData: data, index },
+        selection
+      )
+    );
+  }
+  /** Notify observers the tab changed in place (after mutating tab.data). */
+  notifyTabChanged(index) {
+    const tab = this.getTabAt(index);
+    this.notifyAll_((o) => o.onTabChanged?.(tab, index));
+  }
+  /** Port of SetTabBlocked (cc:1397). */
+  setTabBlocked(index, blocked) {
+    const tab = this.getTabAt(index);
+    if (tab.blocked === blocked) return;
+    tab.blocked = blocked;
+    this.notifyAll_((o) => o.onTabChanged?.(tab, index));
+  }
+  // Lifecycle (discarding) /////////////////////////////////////////////////
+  /**
+   * Drops the tab's content to save memory while keeping the tab in the
+   * strip. The active tab cannot be discarded (it's visible). Content
+   * remounts fresh on the next activation, like Chrome's reload-on-focus.
+   * Port of TabLifecycleUnit::Discard (tab_lifecycle_unit.cc:346) +
+   * TabStripModel::DiscardWebContentsAt semantics. Returns true on success.
+   */
+  discardTabAt(index) {
+    const tab = this.getTabAt(index);
+    if (tab.discarded) return false;
+    if (tab === this.activeTab_) return false;
+    tab.discarded = true;
+    this.notifyAll_((o) => o.onTabDiscardedStateChanged?.(tab, index, true));
+    return true;
+  }
+  /**
+   * Restores a discarded tab without activating it (Chrome: reloading a
+   * background discarded tab, DidStartLoading path).
+   */
+  restoreTabAt(index) {
+    const tab = this.getTabAt(index);
+    if (!tab.discarded) return false;
+    this.restoreTab_(tab);
+    return true;
+  }
+  /** Per-tab opt-out from automatic discarding (extensions setAutoDiscardable). */
+  setTabAutoDiscardable(index, autoDiscardable) {
+    this.getTabAt(index).autoDiscardable = autoDiscardable;
+  }
+  isTabDiscarded(index) {
+    return this.getTabAt(index).discarded;
+  }
+  /** Number of tabs whose content is currently live (not discarded). */
+  get loadedTabCount() {
+    return this.tabs_.reduce((n, t) => n + (t.discarded ? 0 : 1), 0);
+  }
+  restoreTab_(tab) {
+    tab.discarded = false;
+    const index = this.indexOfTab(tab);
+    this.notifyAll_((o) => o.onTabDiscardedStateChanged?.(tab, index, false));
+  }
+  // Order controller ///////////////////////////////////////////////////////
+  /**
+   * Where to place a newly opened tab. Port of DetermineInsertionIndex
+   * (cc:5329).
+   */
+  determineInsertionIndex(cause, foreground) {
+    if (this.count === 0) return 0;
+    if (cause === "link" && this.activeIndex !== NO_TAB) {
+      if (foreground) {
+        return this.activeIndex + 1;
+      }
+      const opener = this.activeTab_;
+      const index = this.getIndexOfLastTabOpenedBy(opener, this.activeIndex);
+      if (index === NO_TAB) return this.activeIndex + 1;
+      const openerGroup = this.getTabGroupForTab(this.activeIndex);
+      for (let i = this.activeIndex + 1; i <= index; i++) {
+        if (this.getTabGroupForTab(i) !== openerGroup) return i;
+      }
+      return index + 1;
+    }
+    return this.count;
+  }
+  /**
+   * Which tab should become active after the tab at `index` closes.
+   * Port of DetermineNewSelectedIndex (cc:5377), single-tab block, with the
+   * "parent collection" preference specialized to groups. Returns the index
+   * in post-close coordinates, or null if this is the last tab.
+   */
+  determineNewSelectedIndex_(index) {
+    if (this.count === 1) return null;
+    const blockStart = index;
+    const blockEnd = index + 1;
+    const afterClosing = (i) => i > blockEnd - 1 ? i - 1 : i;
+    let next = this.getIndexOfNextTabOpenedBy_(blockStart, blockEnd);
+    if (next !== NO_TAB && !this.isTabCollapsed(next)) return afterClosing(next);
+    next = this.getIndexOfNextTabOpenedByOpenerOf_(blockStart, blockEnd);
+    if (next !== NO_TAB && !this.isTabCollapsed(next)) return afterClosing(next);
+    const opener = this.tabs_[index].opener;
+    if (opener) {
+      const openerIndex = this.indexOfTab(opener);
+      if (openerIndex !== NO_TAB && openerIndex !== index && !this.isTabCollapsed(openerIndex)) {
+        return afterClosing(openerIndex);
+      }
+    }
+    const group = this.tabs_[index].group;
+    if (group !== null) {
+      const range = this.listTabsInGroup(group);
+      if (range.end !== blockEnd) return afterClosing(blockEnd);
+      if (range.start !== blockStart) return afterClosing(blockStart - 1);
+    }
+    const nextAvailable = this.getNextExpandedActiveTab_(blockStart, blockEnd);
+    if (nextAvailable !== null) return afterClosing(nextAvailable);
+    if (blockEnd - 1 >= this.count - 1) return blockStart - 1;
+    return blockEnd - 1;
+  }
+  /** Port of GetIndexOfNextWebContentsOpenedBy (cc:3286). */
+  getIndexOfNextTabOpenedBy_(blockStart, blockEnd) {
+    const blockTabs = new Set(this.tabs_.slice(blockStart, blockEnd));
+    for (let i = blockEnd; i < this.count; i++) {
+      const opener = this.tabs_[i].opener;
+      if (opener && blockTabs.has(opener)) return i;
+    }
+    for (let i = blockStart - 1; i >= 0; i--) {
+      const opener = this.tabs_[i].opener;
+      if (opener && blockTabs.has(opener)) return i;
+    }
+    return NO_TAB;
+  }
+  /** Port of GetIndexOfNextWebContentsOpenedByOpenerOf (cc:3312). */
+  getIndexOfNextTabOpenedByOpenerOf_(blockStart, blockEnd) {
+    const blockOpeners = /* @__PURE__ */ new Set();
+    for (let i = blockStart; i < blockEnd; i++) {
+      const opener = this.tabs_[i].opener;
+      if (opener) blockOpeners.add(opener);
+    }
+    if (blockOpeners.size === 0) return NO_TAB;
+    for (let i = blockEnd; i < this.count; i++) {
+      const opener = this.tabs_[i].opener;
+      if (opener && blockOpeners.has(opener)) return i;
+    }
+    for (let i = blockStart - 1; i >= 0; i--) {
+      const opener = this.tabs_[i].opener;
+      if (opener && blockOpeners.has(opener)) return i;
+    }
+    return NO_TAB;
+  }
+  /** Port of GetNextExpandedActiveTab (cc:3346): right of block, then left. */
+  getNextExpandedActiveTab_(blockStart, blockEnd) {
+    for (let i = blockEnd; i < this.count; i++) {
+      if (!this.isTabCollapsed(i)) return i;
+    }
+    for (let i = blockStart - 1; i >= 0; i--) {
+      if (!this.isTabCollapsed(i)) return i;
+    }
+    return null;
+  }
+  // Internal mechanics /////////////////////////////////////////////////////
+  createTab_(data, id) {
+    return {
+      id: id ?? this.generateId_(),
+      data,
+      opener: null,
+      resetOpenerOnActiveTabChange: false,
+      pinned: false,
+      group: null,
+      blocked: false,
+      discarded: false,
+      lastActiveAt: Date.now(),
+      autoDiscardable: true
+    };
+  }
+  /** Port of ConstrainInsertionIndex (cc:3408). */
+  constrainInsertionIndex_(index, pinned) {
+    return pinned ? clamp(index, 0, this.indexOfFirstNonPinnedTab()) : clamp(index, this.indexOfFirstNonPinnedTab(), this.count);
+  }
+  /** Port of ConstrainMoveIndex (cc:3413). */
+  constrainMoveIndex_(index, pinned) {
+    return pinned ? clamp(index, 0, this.indexOfFirstNonPinnedTab() - 1) : clamp(index, this.indexOfFirstNonPinnedTab(), this.count - 1);
+  }
+  /** Port of InsertTabAtImpl (cc:3575). Returns the index actually used. */
+  insertTabAtImpl_(index, tab, flags, group) {
+    const active = (flags & AddTabFlags.ACTIVE) !== 0 || this.empty;
+    const pin = (flags & AddTabFlags.PINNED) !== 0;
+    index = this.constrainInsertionIndex_(index, pin);
+    const activeTab = this.activeTab_;
+    if ((flags & AddTabFlags.INHERIT_OPENER) !== 0 && activeTab) {
+      if (active) this.forgetAllOpeners();
+      tab.opener = activeTab;
+    }
+    tab.pinned = pin;
+    tab.group = pin ? null : group;
+    const oldActive = this.activeTab_;
+    this.tabs_.splice(index, 0, tab);
+    const oldModel = this.selectionModel();
+    if (active) this.setSelectedTab_(tab);
+    this.validate_();
+    const selection = this.buildSelectionChange_(oldActive, oldModel, "none");
+    this.notifyAll_(
+      (o) => o.onTabStripModelChanged?.(
+        { type: "inserted", contents: [{ tab, index }] },
+        selection
+      )
+    );
+    if (tab.group !== null) {
+      this.notifyAll_((o) => o.onTabGroupedStateChanged?.(null, tab.group, tab, index));
+    }
+    this.handleActiveTabChanged_(selection);
+    return index;
+  }
+  /**
+   * Single-tab move with explicit final group/pin state. Port of
+   * MoveTabToIndexImpl (cc:4617).
+   */
+  moveTabToIndexImpl_(initialIndex, finalIndex, group, pin, selectAfterMove) {
+    const tab = this.tabs_[initialIndex];
+    const initialPinned = tab.pinned;
+    const initialGroup = tab.group;
+    if (initialIndex === finalIndex && group === initialGroup && pin === initialPinned) return;
+    if (initialIndex !== finalIndex) this.fixOpeners_(initialIndex);
+    const oldActive = this.activeTab_;
+    const oldModel = this.selectionModel();
+    this.tabs_.splice(initialIndex, 1);
+    this.tabs_.splice(finalIndex, 0, tab);
+    tab.pinned = pin;
+    tab.group = pin ? null : group;
+    if (selectAfterMove) this.setSelectedTab_(tab);
+    this.validate_();
+    const selection = this.buildSelectionChange_(oldActive, oldModel, "none");
+    if (initialIndex !== finalIndex) {
+      this.notifyAll_(
+        (o) => o.onTabStripModelChanged?.(
+          { type: "moved", tab, fromIndex: initialIndex, toIndex: finalIndex },
+          selection
+        )
+      );
+    }
+    if (initialPinned !== tab.pinned) {
+      this.notifyAll_((o) => o.onTabPinnedStateChanged?.(tab, finalIndex));
+    }
+    this.emitGroupStateChange_(tab, finalIndex, initialGroup, tab.group);
+    this.handleActiveTabChanged_(selection);
+  }
+  /**
+   * Block move: removes the tabs at `indices`, reinserts them contiguously at
+   * `destination` (post-removal coordinates), assigning the given group and
+   * the pinned state of the first moving tab. Port of MoveTabsToIndexImpl
+   * (cc:4698) + MoveTabsWithNotifications (cc:5081).
+   */
+  moveTabsToIndexImpl_(indices, destination, group) {
+    if (indices.length === 0) return;
+    assertAscending(indices);
+    const pin = this.tabs_[indices[0]].pinned;
+    const moving = indices.map((i) => this.tabs_[i]);
+    const initial = moving.map((tab, k) => ({
+      tab,
+      index: indices[k],
+      group: tab.group,
+      pinned: tab.pinned
+    }));
+    const oldActive = this.activeTab_;
+    const oldModel = this.selectionModel();
+    for (const i of indices) this.fixOpeners_(i);
+    const movingSet = new Set(moving);
+    const remaining = this.tabs_.filter((t) => !movingSet.has(t));
+    remaining.splice(destination, 0, ...moving);
+    this.tabs_ = remaining;
+    for (const tab of moving) {
+      tab.pinned = pin;
+      if (group !== "keep") tab.group = pin ? null : group;
+    }
+    this.validate_();
+    const selection = this.buildSelectionChange_(oldActive, oldModel, "none");
+    for (const note of initial) {
+      const finalIndex = this.indexOfTab(note.tab);
+      if (note.index !== finalIndex) {
+        this.notifyAll_(
+          (o) => o.onTabStripModelChanged?.(
+            { type: "moved", tab: note.tab, fromIndex: note.index, toIndex: finalIndex },
+            selection
+          )
+        );
+      }
+      if (note.pinned !== note.tab.pinned) {
+        this.notifyAll_((o) => o.onTabPinnedStateChanged?.(note.tab, finalIndex));
+      }
+      this.emitGroupStateChange_(note.tab, finalIndex, note.group, note.tab.group);
+    }
+    this.handleActiveTabChanged_(selection);
+  }
+  /**
+   * Port of MoveTabsAndSetPropertiesImpl (cc:4469): destination is given in
+   * pre-removal coordinates and adjusted here.
+   */
+  moveTabsAndSetProperties_(indices, destinationIndex, group, pinned) {
+    if (indices.length === 0) return;
+    let numTabsLeftOfDestination = 0;
+    for (const i of indices) {
+      if (i >= destinationIndex) break;
+      numTabsLeftOfDestination++;
+    }
+    void pinned;
+    this.moveTabsToIndexImpl_(indices, destinationIndex - numTabsLeftOfDestination, group);
+  }
+  /**
+   * Group to assign when a tab moves from index to toPosition so groups stay
+   * contiguous. Port of GetGroupToAssign (cc:5195).
+   */
+  getGroupToAssign_(index, toPosition) {
+    const tab = this.tabs_[index];
+    if (!this.supportsGroups_) return null;
+    let newLeftGroup = null;
+    let newRightGroup = null;
+    if (toPosition > index) {
+      newLeftGroup = this.getTabGroupForTab(toPosition);
+      newRightGroup = this.getTabGroupForTab(toPosition + 1);
+    } else if (toPosition < index) {
+      newLeftGroup = this.getTabGroupForTab(toPosition - 1);
+      newRightGroup = this.getTabGroupForTab(toPosition);
+    }
+    if (tab.group !== newLeftGroup && tab.group !== newRightGroup) {
+      if (newLeftGroup === newRightGroup && newLeftGroup !== null) {
+        return newLeftGroup;
+      }
+      if (tab.group !== null && this.tabs_.filter((t) => t.group === tab.group).length > 1) {
+        return null;
+      }
+    }
+    return tab.group;
+  }
+  /**
+   * Re-points the openers of any tab that referenced the tab at index at that
+   * tab's own opener. Port of FixOpeners (cc:5171).
+   */
+  fixOpeners_(index) {
+    const oldTab = this.tabs_[index];
+    const newOpener = oldTab.opener;
+    for (const tab of this.tabs_) {
+      if (tab.opener !== oldTab) continue;
+      tab.opener = newOpener === tab ? null : newOpener;
+    }
+  }
+  /** Selection helpers (Chrome: TabStripModelSelectionState). */
+  setSelectedTab_(tab) {
+    this.selectedTabs_ = /* @__PURE__ */ new Set([tab]);
+    this.activeTab_ = tab;
+    this.anchorTab_ = tab;
+  }
+  firstSelectedTab_() {
+    let best = null;
+    let bestIndex = Infinity;
+    for (const tab of this.selectedTabs_) {
+      const i = this.indexOfTab(tab);
+      if (i !== NO_TAB && i < bestIndex) {
+        bestIndex = i;
+        best = tab;
+      }
+    }
+    return best;
+  }
+  selectedIndices_() {
+    return [...this.selectedTabs_].map((t) => this.indexOfTab(t)).filter((i) => i !== NO_TAB).sort((a, b) => a - b);
+  }
+  /**
+   * Wraps a selection mutation in change tracking + notification. Mirrors
+   * SetSelection (cc:1178).
+   */
+  setSelection_(mutate, reason) {
+    const oldActive = this.activeTab_;
+    const oldModel = this.selectionModel();
+    mutate();
+    const selection = this.buildSelectionChange_(oldActive, oldModel, reason);
+    if (selection.activeTabChanged || selection.selectionChanged) {
+      this.notifyAll_(
+        (o) => o.onTabStripModelChanged?.({ type: "selectionOnly" }, selection)
+      );
+      this.handleActiveTabChanged_(selection);
+    }
+  }
+  buildSelectionChange_(oldTab, oldModel, reason) {
+    const newTab = this.activeTab_;
+    const newModel = this.selectionModel();
+    return {
+      oldTab,
+      newTab,
+      oldModel,
+      newModel,
+      reason,
+      get activeTabChanged() {
+        return oldTab !== newTab;
+      },
+      get selectionChanged() {
+        return !oldModel.equals(newModel);
+      }
+    };
+  }
+  /**
+   * Opener and lifecycle bookkeeping when the active tab changes. Port of
+   * OnActiveTabChanged (cc:5255) plus TabLifecycleUnit::SetFocused
+   * (tab_lifecycle_unit.cc:135).
+   */
+  handleActiveTabChanged_(selection) {
+    if (!selection.activeTabChanged || this.empty) return;
+    const oldTab = selection.oldTab;
+    const newTab = selection.newTab;
+    let oldOpener = null;
+    if (oldTab && this.indexOfTab(oldTab) !== NO_TAB) {
+      oldTab.lastActiveAt = Date.now();
+    }
+    if (newTab) {
+      newTab.lastActiveAt = Infinity;
+      if (newTab.discarded) this.restoreTab_(newTab);
+    }
+    if (oldTab && this.indexOfTab(oldTab) !== NO_TAB) {
+      oldOpener = oldTab.opener;
+      if (oldTab.resetOpenerOnActiveTabChange) {
+        oldTab.opener = null;
+        oldTab.resetOpenerOnActiveTabChange = false;
+      }
+    }
+    const newOpener = newTab?.opener ?? null;
+    if (selection.reason === "userGesture" && newOpener !== oldOpener && newOpener !== oldTab && oldOpener !== newTab) {
+      this.forgetAllOpeners();
+    }
+  }
+  emitGroupStateChange_(tab, index, oldGroup, newGroup) {
+    if (oldGroup === newGroup) return;
+    this.notifyAll_((o) => o.onTabGroupedStateChanged?.(oldGroup, newGroup, tab, index));
+    if (oldGroup !== null && this.groups_.has(oldGroup) && !this.tabs_.some((t) => t.group === oldGroup)) {
+      this.groups_.delete(oldGroup);
+      this.notifyAll_((o) => o.onTabGroupChanged?.({ type: "closed", groupId: oldGroup }));
+    }
+  }
+  notifyAll_(fn) {
+    this.reentrancyGuard_ = true;
+    try {
+      for (const observer of [...this.observers_]) fn(observer);
+    } finally {
+      this.reentrancyGuard_ = false;
+    }
+  }
+  requireGroups_() {
+    if (!this.supportsGroups_) throw new Error("tab groups are disabled for this model");
+  }
+  checkReentrancy_() {
+    if (this.reentrancyGuard_) {
+      throw new Error("TabStripModel is not re-entrant; do not mutate it from an observer");
+    }
+  }
+  /**
+   * Invariant validation. Port of CompleteModelUpdateTransaction; Chrome
+   * CHECKs, we throw.
+   */
+  validate_() {
+    const firstNonPinned = this.indexOfFirstNonPinnedTab();
+    for (let i = 0; i < this.tabs_.length; i++) {
+      const tab = this.tabs_[i];
+      if (tab.pinned !== i < firstNonPinned) {
+        throw new Error(`invariant violated: pinned tab at index ${i} after unpinned tabs`);
+      }
+      if (tab.pinned && tab.group !== null) {
+        throw new Error(`invariant violated: pinned tab at index ${i} is grouped`);
+      }
+    }
+    const seenGroups = /* @__PURE__ */ new Set();
+    let currentGroup = null;
+    for (const tab of this.tabs_) {
+      if (tab.group !== currentGroup) {
+        if (tab.group !== null && seenGroups.has(tab.group)) {
+          throw new Error(`invariant violated: group ${tab.group} is not contiguous`);
+        }
+        if (tab.group !== null) seenGroups.add(tab.group);
+        currentGroup = tab.group;
+      }
+    }
+    if (!this.empty && (!this.activeTab_ || this.indexOfTab(this.activeTab_) === NO_TAB)) {
+      throw new Error("invariant violated: no valid active tab");
+    }
+  }
+};
+function clamp(value, lo, hi) {
+  return Math.min(Math.max(value, lo), hi);
+}
+function countLessThan(sorted, threshold) {
+  let n = 0;
+  for (const v of sorted) {
+    if (v < threshold) n++;
+    else break;
+  }
+  return n;
+}
+function assertAscending(indices) {
+  for (let i = 1; i < indices.length; i++) {
+    if (indices[i] <= indices[i - 1]) {
+      throw new Error("indices must be sorted in ascending order");
+    }
+  }
+}
+
+// src/core/tab-lifecycle-manager.ts
+var DEFAULT_MAX_LOADED_TABS = 10;
+var DEFAULT_RECENTLY_ACTIVE_PROTECTION_MS = 10 * 60 * 1e3;
+var TabLifecycleManager = class {
+  model_;
+  maxLoadedTabs_;
+  recentlyActiveProtectionMs_;
+  protectPinnedTabs_;
+  canDiscardTab_;
+  onBeforeDiscard_;
+  exclusiveContentKey_;
+  detach_ = null;
+  enforcePending_ = false;
+  constructor(model, options = {}) {
+    this.model_ = model;
+    this.maxLoadedTabs_ = options.maxLoadedTabs === void 0 ? DEFAULT_MAX_LOADED_TABS : options.maxLoadedTabs;
+    this.recentlyActiveProtectionMs_ = options.recentlyActiveProtectionMs ?? DEFAULT_RECENTLY_ACTIVE_PROTECTION_MS;
+    this.protectPinnedTabs_ = options.protectPinnedTabs ?? true;
+    this.canDiscardTab_ = options.canDiscardTab ?? null;
+    this.onBeforeDiscard_ = options.onBeforeDiscard ?? null;
+    this.exclusiveContentKey_ = options.exclusiveContentKey ?? null;
+  }
+  /**
+   * Starts observing the model and enforcing the loaded-tab budget. Returns
+   * a stop function. Discards run on a microtask after model changes, never
+   * re-entrantly (Chrome posts discard tasks for the same reason).
+   */
+  start() {
+    if (this.detach_) return () => this.stop();
+    const schedule = () => this.scheduleEnforce_();
+    this.detach_ = this.model_.addObserver({
+      onTabStripModelChanged: (change) => {
+        if (change.type === "inserted" || change.type === "selectionOnly" || change.type === "replaced") {
+          schedule();
+        }
+      },
+      onTabChanged: () => schedule(),
+      onTabDiscardedStateChanged: (_tab, _index, discarded) => {
+        if (!discarded) schedule();
+      }
+    });
+    this.scheduleEnforce_();
+    return () => this.stop();
+  }
+  stop() {
+    this.detach_?.();
+    this.detach_ = null;
+  }
+  /**
+   * Tri-state discard eligibility for one tab. Port of
+   * DiscardEligibilityPolicy::CanDiscard.
+   */
+  canDiscard(tab) {
+    const reasons = [];
+    let result = "eligible";
+    const disallow = (r) => {
+      reasons.push(r);
+      result = "disallowed";
+    };
+    const protect = (r) => {
+      reasons.push(r);
+      if (result === "eligible") result = "protected";
+    };
+    if (tab.discarded) disallow("alreadyDiscarded");
+    if (tab === this.model_.activeTab) disallow("activeTab");
+    if (!tab.autoDiscardable) disallow("optedOut");
+    if (this.canDiscardTab_ && !this.canDiscardTab_(tab)) disallow("appVeto");
+    if (this.protectPinnedTabs_ && tab.pinned) protect("pinnedTab");
+    if (Date.now() - tab.lastActiveAt < this.recentlyActiveProtectionMs_) {
+      protect("recentlyActive");
+    }
+    return { result, reasons };
+  }
+  /**
+   * Discard candidates in Chrome's importance order, least important first:
+   * eligible before protected, each group least-recently-active first,
+   * disallowed never. Port of PageNodeSortProxy::operator<
+   * (discard_eligibility_policy.h:95) with focused/visible folded into
+   * 'activeTab' (a single-window strip has one visible tab).
+   */
+  getDiscardCandidates(includeProtected) {
+    const eligible = [];
+    const protectedTabs = [];
+    for (const tab of this.model_.getTabs()) {
+      const decision = this.canDiscard(tab);
+      if (decision.result === "eligible") eligible.push(tab);
+      else if (decision.result === "protected") protectedTabs.push(tab);
+    }
+    const byLeastRecentlyActive = (a, b) => a.lastActiveAt - b.lastActiveAt;
+    eligible.sort(byLeastRecentlyActive);
+    protectedTabs.sort(byLeastRecentlyActive);
+    return includeProtected ? [...eligible, ...protectedTabs] : eligible;
+  }
+  /**
+   * Discards the least important discardable tab. 'urgent' may take
+   * protected tabs (Chrome: urgent discarding under memory pressure);
+   * 'proactive' and 'external' only take eligible ones. Port of
+   * PageDiscardingHelper::DiscardAPage. Returns the discarded tab or null.
+   */
+  discardLeastImportant(reason = "proactive") {
+    const candidates = this.getDiscardCandidates(reason === "urgent");
+    const tab = candidates[0];
+    if (!tab) return null;
+    this.discardTab_(tab);
+    return tab;
+  }
+  /**
+   * Discards tabs until the loaded count fits the budget. Eligible tabs go
+   * first; protected tabs are taken only if the budget still isn't met
+   * (matching the sort order Chrome walks when reclaiming memory).
+   * Disallowed tabs are never discarded, so the budget can be exceeded when
+   * everything left is active/opted-out/vetoed.
+   */
+  enforceBudget() {
+    if (this.maxLoadedTabs_ === null) return 0;
+    let discarded = 0;
+    const overBudget = () => this.model_.loadedTabCount > this.maxLoadedTabs_;
+    if (!overBudget()) return 0;
+    for (const tab of this.getDiscardCandidates(true)) {
+      if (!overBudget()) break;
+      this.discardTab_(tab);
+      discarded++;
+    }
+    return discarded;
+  }
+  /**
+   * Enforces `exclusiveContentKey`: for every key shared by more than one
+   * loaded tab, keep the active tab (else the most recently active) and
+   * discard the rest. Returns the number of tabs discarded. Runs before the
+   * budget pass, so duplicates count toward freed budget first.
+   */
+  enforceExclusiveContent() {
+    if (!this.exclusiveContentKey_) return 0;
+    const groups = /* @__PURE__ */ new Map();
+    for (const tab of this.model_.getTabs()) {
+      if (tab.discarded) continue;
+      const key = this.exclusiveContentKey_(tab);
+      if (key === null || key === void 0) continue;
+      const group = groups.get(key);
+      if (group) group.push(tab);
+      else groups.set(key, [tab]);
+    }
+    const activeTab = this.model_.activeTab;
+    let discarded = 0;
+    for (const tabs of groups.values()) {
+      if (tabs.length < 2) continue;
+      const keep = tabs.includes(activeTab) ? activeTab : tabs.reduce((a, b) => b.lastActiveAt > a.lastActiveAt ? b : a);
+      for (const tab of tabs) {
+        if (tab === keep) continue;
+        this.discardTab_(tab);
+        discarded++;
+      }
+    }
+    return discarded;
+  }
+  discardTab_(tab) {
+    const index = this.model_.indexOfTab(tab);
+    if (index === -1) return;
+    this.onBeforeDiscard_?.(tab);
+    this.model_.discardTabAt(index);
+  }
+  scheduleEnforce_() {
+    if (this.enforcePending_) return;
+    this.enforcePending_ = true;
+    queueMicrotask(() => {
+      this.enforcePending_ = false;
+      if (this.detach_) {
+        this.enforceExclusiveContent();
+        this.enforceBudget();
+      }
+    });
+  }
+};
+
+// src/react/use-tab-strip.ts
+var import_react = require("react");
+function useTabStripModel(init, options) {
+  const ref = (0, import_react.useRef)(null);
+  if (ref.current === null) {
+    ref.current = new TabStripModel(options);
+    init?.(ref.current);
+  }
+  return ref.current;
+}
+function useTabStrip(model) {
+  const store = (0, import_react.useMemo)(() => {
+    let version = 0;
+    let snapshotVersion = -1;
+    let snapshot = null;
+    return {
+      subscribe(onStoreChange) {
+        return model.addObserver({
+          onTabStripModelChanged: () => {
+            version++;
+            onStoreChange();
+          },
+          onTabPinnedStateChanged: () => {
+            version++;
+            onStoreChange();
+          },
+          onTabGroupedStateChanged: () => {
+            version++;
+            onStoreChange();
+          },
+          onTabGroupChanged: () => {
+            version++;
+            onStoreChange();
+          },
+          onTabChanged: () => {
+            version++;
+            onStoreChange();
+          },
+          onTabDiscardedStateChanged: () => {
+            version++;
+            onStoreChange();
+          }
+        });
+      },
+      getSnapshot() {
+        if (snapshot === null || snapshotVersion !== version) {
+          snapshot = {
+            tabs: model.getTabs(),
+            activeTab: model.activeTab,
+            activeIndex: model.activeIndex,
+            selectedIndices: model.selectionModel().selectedIndices(),
+            groups: model.getGroups()
+          };
+          snapshotVersion = version;
+        }
+        return snapshot;
+      }
+    };
+  }, [model]);
+  return (0, import_react.useSyncExternalStore)(store.subscribe, store.getSnapshot, store.getSnapshot);
+}
+
+// src/react/use-tab-drag.ts
+var import_react2 = require("react");
+var DRAG_THRESHOLD_PX = 4;
+function useTabDrag(model, containerRef) {
+  const [draggingTabId, setDraggingTabId] = (0, import_react2.useState)(null);
+  const drag = (0, import_react2.useRef)(null);
+  const onTabPointerDown = (0, import_react2.useCallback)(
+    (event, tabId) => {
+      if (event.button !== 0) return;
+      drag.current = { tabId, startX: event.clientX, started: false };
+      const target = event.currentTarget;
+      target.setPointerCapture(event.pointerId);
+      const onMove = (e) => {
+        const state = drag.current;
+        if (!state) return;
+        if (!state.started) {
+          if (Math.abs(e.clientX - state.startX) < DRAG_THRESHOLD_PX) return;
+          state.started = true;
+          setDraggingTabId(state.tabId);
+        }
+        const container = containerRef.current;
+        if (!container) return;
+        const tab = model.getTabById(state.tabId);
+        if (!tab) return;
+        const currentIndex = model.indexOfTab(tab);
+        const elements = [...container.querySelectorAll("[data-tab-id]")];
+        let targetIndex = 0;
+        for (const el of elements) {
+          if (el.dataset["tabId"] === state.tabId) continue;
+          const rect = el.getBoundingClientRect();
+          if (e.clientX > rect.left + rect.width / 2) targetIndex++;
+        }
+        if (targetIndex !== currentIndex) {
+          model.moveTabTo(currentIndex, targetIndex);
+        }
+      };
+      const onUp = () => {
+        drag.current = null;
+        setDraggingTabId(null);
+        target.removeEventListener("pointermove", onMove);
+        target.removeEventListener("pointerup", onUp);
+        target.removeEventListener("pointercancel", onUp);
+      };
+      target.addEventListener("pointermove", onMove);
+      target.addEventListener("pointerup", onUp);
+      target.addEventListener("pointercancel", onUp);
+    },
+    [model, containerRef]
+  );
+  return { draggingTabId, onTabPointerDown };
+}
+
+// src/react/tab-panels.tsx
+var import_react3 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var TabVisibilityContext = (0, import_react3.createContext)("visible");
+function useTabVisibility() {
+  return (0, import_react3.useContext)(TabVisibilityContext);
+}
+function TabPanels({ model, children, className, hideMode = "display-none" }) {
+  const snapshot = useTabStrip(model);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: ["ctabs-panels", className].filter(Boolean).join(" "), children: snapshot.tabs.map((tab) => {
+    if (tab.discarded) return null;
+    const visible = tab === snapshot.activeTab;
+    const style = hideMode === "display-none" ? { display: visible ? void 0 : "none" } : {
+      visibility: visible ? void 0 : "hidden",
+      position: visible ? void 0 : "absolute",
+      inset: visible ? void 0 : 0
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "div",
+      {
+        role: "tabpanel",
+        "data-tab-panel-id": tab.id,
+        className: "ctabs-panel",
+        style,
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(TabVisibilityContext.Provider, { value: visible ? "visible" : "hidden", children: children(tab) })
+      },
+      tab.id
+    );
+  }) });
+}
+
+// src/react/tab-strip.tsx
+var import_react4 = require("react");
+
+// src/react/group-header.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var GROUP_COLOR_VALUES = {
+  grey: "#5f6368",
+  blue: "#1a73e8",
+  red: "#d93025",
+  yellow: "#f9ab00",
+  green: "#188038",
+  pink: "#d01884",
+  purple: "#a142f4",
+  cyan: "#007b83",
+  orange: "#fa903e"
+};
+function GroupHeader({ group, onToggleCollapsed }) {
+  const color = GROUP_COLOR_VALUES[group.visualData.color] ?? GROUP_COLOR_VALUES["grey"];
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    "button",
+    {
+      type: "button",
+      className: [
+        "ctabs-group-header",
+        group.visualData.isCollapsed && "ctabs-group-header--collapsed"
+      ].filter(Boolean).join(" "),
+      style: { ["--ctabs-group-color"]: color },
+      onClick: () => onToggleCollapsed(group.id),
+      title: group.visualData.isCollapsed ? "Expand group" : "Collapse group",
+      children: group.visualData.title || "\xA0"
+    }
+  );
+}
+
+// src/react/tab-item.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function TabItem({
+  tab,
+  index,
+  active,
+  selected,
+  dragging,
+  groupColor,
+  renderContent,
+  onPointerDown,
+  onActivate,
+  onClose,
+  onContextMenu
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    "div",
+    {
+      role: "tab",
+      "aria-selected": active,
+      "data-tab-id": tab.id,
+      className: [
+        "ctabs-tab",
+        active && "ctabs-tab--active",
+        selected && !active && "ctabs-tab--selected",
+        tab.pinned && "ctabs-tab--pinned",
+        tab.discarded && "ctabs-tab--discarded",
+        dragging && "ctabs-tab--dragging",
+        groupColor && "ctabs-tab--grouped"
+      ].filter(Boolean).join(" "),
+      style: groupColor ? { ["--ctabs-group-color"]: groupColor } : void 0,
+      onPointerDown: (e) => onPointerDown(e, tab.id),
+      onMouseDown: (e) => {
+        if (e.button === 1) {
+          e.preventDefault();
+          onClose(index);
+        }
+      },
+      onClick: (e) => onActivate(index, e),
+      onContextMenu: (e) => onContextMenu?.(index, e),
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "ctabs-tab__content", children: renderContent(tab) }),
+        !tab.pinned && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "ctabs-tab__close",
+            "aria-label": "Close tab",
+            onClick: (e) => {
+              e.stopPropagation();
+              onClose(index);
+            },
+            onPointerDown: (e) => e.stopPropagation(),
+            children: "\xD7"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/react/tab-strip.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function TabStrip({
+  model,
+  renderTab = (tab) => String(tab.data),
+  onNewTab,
+  onTabContextMenu,
+  className
+}) {
+  const snapshot = useTabStrip(model);
+  const containerRef = (0, import_react4.useRef)(null);
+  const { draggingTabId, onTabPointerDown } = useTabDrag(model, containerRef);
+  const onActivate = (index, event) => {
+    if (event.shiftKey) {
+      model.extendSelectionTo(index);
+    } else if (event.metaKey || event.ctrlKey) {
+      if (model.isTabSelected(index)) model.deselectTabAt(index);
+      else model.selectTabAt(index);
+    } else {
+      model.activateTabAt(index, { userGesture: true });
+    }
+  };
+  const onKeyDown = (event) => {
+    const move = event.metaKey || event.ctrlKey;
+    if (event.key === "ArrowRight") {
+      move ? model.moveTabNext() : model.selectNextTab({ userGesture: true });
+      event.preventDefault();
+    } else if (event.key === "ArrowLeft") {
+      move ? model.moveTabPrevious() : model.selectPreviousTab({ userGesture: true });
+      event.preventDefault();
+    }
+  };
+  const selected = new Set(snapshot.selectedIndices);
+  const groupById = new Map(snapshot.groups.map((g) => [g.id, g]));
+  const items = [];
+  let previousGroup = null;
+  snapshot.tabs.forEach((tab, index) => {
+    if (tab.group !== null && tab.group !== previousGroup) {
+      const group = groupById.get(tab.group);
+      if (group) {
+        items.push(
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+            GroupHeader,
+            {
+              group,
+              onToggleCollapsed: (id) => model.setGroupCollapsed(id, !model.isGroupCollapsed(id))
+            },
+            `group-${group.id}`
+          )
+        );
+      }
+    }
+    previousGroup = tab.group;
+    if (tab.group !== null && model.isGroupCollapsed(tab.group)) return;
+    const groupColor = tab.group ? GROUP_COLOR_VALUES[groupById.get(tab.group)?.visualData.color ?? "grey"] ?? null : null;
+    items.push(
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        TabItem,
+        {
+          tab,
+          index,
+          active: index === snapshot.activeIndex,
+          selected: selected.has(index),
+          dragging: tab.id === draggingTabId,
+          groupColor,
+          renderContent: renderTab,
+          onPointerDown: onTabPointerDown,
+          onActivate,
+          onClose: (i) => model.closeTabAt(i),
+          onContextMenu: onTabContextMenu
+        },
+        tab.id
+      )
+    );
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+    "div",
+    {
+      ref: containerRef,
+      role: "tablist",
+      tabIndex: 0,
+      className: ["ctabs-strip", className].filter(Boolean).join(" "),
+      onKeyDown,
+      children: [
+        items,
+        onNewTab && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          "button",
+          {
+            type: "button",
+            className: "ctabs-new-tab",
+            "aria-label": "New tab",
+            onClick: onNewTab,
+            children: "+"
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/react/tabs.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function Tabs({
+  model,
+  renderTab,
+  children,
+  onNewTab,
+  onTabContextMenu,
+  hideMode,
+  className
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: ["ctabs", className].filter(Boolean).join(" "), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      TabStrip,
+      {
+        model,
+        renderTab,
+        onNewTab,
+        onTabContextMenu
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TabPanels, { model, hideMode, children })
+  ] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddTabFlags,
+  CloseTabFlags,
+  GROUP_COLOR_VALUES,
+  GroupHeader,
+  ListSelectionModel,
+  NO_TAB,
+  TAB_GROUP_COLORS,
+  TabItem,
+  TabLifecycleManager,
+  TabPanels,
+  TabStrip,
+  TabStripModel,
+  Tabs,
+  useTabDrag,
+  useTabStrip,
+  useTabStripModel,
+  useTabVisibility
+});
+//# sourceMappingURL=index.cjs.map