js.foresight-devtools 1.4.0 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bart Spaans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -8,6 +8,8 @@
 
 These tools are built entirely using `ForesightJS`'s [built-in events](/docs/events), demonstrating how you can create your own monitoring and debugging tools using the same event system.
 
+Since the devtools observe the `ForesightManager` directly, they work with every Foresight integration: the [`js.foresight`](https://foresightjs.com/docs/getting-started/quick-start) core, the official [React](https://foresightjs.com/docs/react/installation) and [Vue](https://foresightjs.com/docs/vue/installation) packages, or your own [custom binding](https://foresightjs.com/docs/other-frameworks).
+
 ## Installation
 
 To install the `ForesightJS` Development Tools package, use your preferred package manager:
@@ -31,16 +33,19 @@ ForesightManager.initialize({})
 
 // Initialize the development tools (all options are optional)
 ForesightDevtools.initialize({
-  showDebugger: true,
+  show: {
+    controlPanel: true, // show the floating control panel
+    nameTags: true, // show the element name above each registered element
+    elementOverlays: true, // show the hit-slop boundary around each registered element
+    mouseTrajectory: true, // show the predicted mouse trajectory line
+    scrollTrajectory: true, // show the predicted scroll trajectory line
+  },
   isControlPanelDefaultMinimized: false, // optional setting which allows you to minimize the control panel on default
-  showNameTags: true, // optional setting which shows the name of the element
   sortElementList: "visibility", // optional setting for how the elements in the control panel are sorted
   logging: {
     logLocation: "controlPanel", // Where to log the Foresight Events
     callbackCompleted: true,
-    elementReactivated: true,
     callbackInvoked: true,
-    elementDataUpdated: false,
     elementRegistered: false,
     elementUnregistered: false,
     managerSettingsChanged: true,

package/dist/index.d.mts

@@ -0,0 +1,627 @@
+import { LitElement, PropertyValues, TemplateResult } from "lit";
+import { CallbackHitType, CallbackHits, ForesightElement, ForesightElementState, ForesightEvent, ForesightManagerData, ForesightManagerSettings, ForesightPoint, HitSlop, ScrollDirection, UpdatedManagerSetting } from "js.foresight";
+
+//#region src/types/types.d.ts
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+type ShowSettings = {
+  /**
+   * Show the debugger control panel.
+   * @default true
+   */
+  controlPanel: boolean;
+  /**
+   * Show name tags above each registered element.
+   * @default true
+   */
+  nameTags: boolean;
+  /**
+   * Show element hit-slop overlays (the expanded boundary around each registered element).
+   *
+   * Note: turning this off also hides name tags, since the labels live inside
+   * the same overlay host.
+   *
+   * @default true
+   */
+  elementOverlays: boolean;
+  /**
+   * Show the predicted mouse trajectory line.
+   * @default true
+   */
+  mouseTrajectory: boolean;
+  /**
+   * Show the predicted scroll trajectory line.
+   * @default true
+   */
+  scrollTrajectory: boolean;
+};
+type ShowKey = keyof ShowSettings;
+type DevtoolsSettings = {
+  /**
+   * Granular visibility flags for the devtools UI.
+   *
+   * @link https://foresightjs.com/docs/getting_started/debug
+   */
+  show: ShowSettings;
+  /**
+   * Determines if the debugger control panel should be initialized in a minimized state.
+   *
+   * @link https://foresightjs.com/docs/getting_started/debug
+   *
+   * @default false
+   */
+  isControlPanelDefaultMinimized: boolean;
+  /**
+   * Specifies the default sorting order for the list of registered elements in the debugger panel.
+   * - `'visibility'`: Sorts elements by their viewport visibility (visible elements first),
+   *   with a secondary documentOrder sort.
+   * - `'documentOrder'`: Sorts elements based on their order of appearance in the
+   *   document's structure (matching the HTML source).
+   * - `'insertionOrder'`: Sorts by registration order.
+   *
+   *
+   * @link https://foresightjs.com/docs/getting_started/debug
+   *
+   * @default 'visibility'
+   *
+   */
+  sortElementList: SortElementList;
+  logging: LogEvents & {
+    logLocation: LoggingLocations;
+  };
+};
+type LogEvents = { [K in ForesightEvent]: boolean };
+type LoggingLocations = "controlPanel" | "console" | "both" | "none";
+type SortElementList = "documentOrder" | "visibility" | "insertionOrder";
+type DebuggerBooleanSettingKeys = ShowKey;
+//#endregion
+//#region src/lit-entry/control-panel/base-tab/chip.d.ts
+declare class ChipElement extends LitElement {
+  static styles: any[];
+  title: string;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "chip-element": ChipElement;
+  }
+} //# sourceMappingURL=chip.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/base-tab/tab-content.d.ts
+declare class TabContent extends LitElement {
+  static styles: any[];
+  noContentMessage: string;
+  hasContent: boolean;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "tab-content": TabContent;
+  }
+} //# sourceMappingURL=tab-content.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/base-tab/tab-header.d.ts
+declare class TabHeader extends LitElement {
+  static styles: any[];
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "tab-header": TabHeader;
+  }
+} //# sourceMappingURL=tab-header.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/dropdown/base-dropdown.d.ts
+type DropdownOption = {
+  value: string;
+  label: string;
+  title: string;
+  icon: TemplateResult;
+};
+declare abstract class BaseDropdown extends LitElement {
+  private static currentlyOpen;
+  static styles: any[];
+  protected isDropdownOpen: boolean;
+  dropdownOptions: DropdownOption[];
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  protected _toggleDropdown: (event: MouseEvent) => void;
+  protected _closeDropdown(): void;
+  protected _positionDropdown(): void;
+  protected _handleOutsideClick: (event: MouseEvent) => void;
+  protected abstract _handleOptionClick(option: DropdownOption): void;
+  protected abstract _getTriggerIcon(): TemplateResult;
+  protected abstract _isOptionSelected(option: DropdownOption): boolean;
+  protected abstract _getTriggerTitle(): string;
+  protected abstract _getTriggerLabel(): string;
+  render(): any;
+}
+//#endregion
+//#region src/lit-entry/control-panel/dropdown/single-select-dropdown.d.ts
+declare class SingleSelectDropdown extends BaseDropdown {
+  selectedOptionValue: string;
+  onSelectionChange?: (value: string) => void;
+  connectedCallback(): void;
+  willUpdate(changedProperties: Map<PropertyKey, unknown>): void;
+  protected _handleOptionClick(option: DropdownOption): void;
+  protected _getTriggerIcon(): TemplateResult;
+  protected _isOptionSelected(option: DropdownOption): boolean;
+  protected _getTriggerTitle(): string;
+  protected _getTriggerLabel(): string;
+  private _getSelectedOption;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "single-select-dropdown": SingleSelectDropdown;
+  }
+} //# sourceMappingURL=single-select-dropdown.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/copy-icon/copy-icon.d.ts
+declare class CopyIcon extends LitElement {
+  static styles: any;
+  title: string;
+  onCopy?: (event: MouseEvent) => Promise<void> | void;
+  private isCopied;
+  private copyTimeout;
+  private handleClick;
+  disconnectedCallback(): void;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "copy-icon": CopyIcon;
+  }
+} //# sourceMappingURL=copy-icon.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/base-tab/expandable-item.d.ts
+declare class ExpandableItem extends LitElement {
+  static styles: any[];
+  borderColor: string;
+  showCopyButton: boolean;
+  itemId: string;
+  isExpanded: boolean;
+  onToggle: ((itemId: string) => void) | undefined;
+  private toggleExpand;
+  private handleCopy;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "expandable-item": ExpandableItem;
+  }
+} //# sourceMappingURL=expandable-item.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/element-tab/reactivate-countdown.d.ts
+declare class ReactivateCountdown extends LitElement {
+  static styles: any[];
+  element: ForesightElement;
+  state: ForesightElementState;
+  private remainingTime;
+  private isCountdownActive;
+  private intervalId;
+  private startTime;
+  private lastDisplayedTime;
+  private countdownForElement;
+  private countdownReactivateAfter;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  willUpdate(changedProperties: Map<string | number | symbol, unknown>): void;
+  private checkAndStartCountdown;
+  private startCountdown;
+  private clearCountdown;
+  private handleTimerClick;
+  private formatTime;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "reactivate-countdown": ReactivateCountdown;
+  }
+} //# sourceMappingURL=reactivate-countdown.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/element-tab/single-element.d.ts
+declare class SingleElement extends LitElement {
+  static styles: any[];
+  element: ForesightElement;
+  state: ForesightElementState;
+  isExpanded: boolean;
+  onToggle: ((elementId: string) => void) | undefined;
+  private currentDeviceStrategy;
+  private _abortController;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  private getInactiveReasons;
+  private getBorderColor;
+  private getStatusIndicatorClass;
+  private getStatusText;
+  private formatElementDetails;
+  private handleUnregister;
+  private handleToggleEnabled;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "single-element": SingleElement;
+  }
+} //# sourceMappingURL=single-element.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/element-tab/element-tab.d.ts
+declare class ElementTab extends LitElement {
+  static styles: any;
+  private hitCount;
+  private sortDropdown;
+  private sortOrder;
+  private elementListItems;
+  private noContentMessage;
+  private expandedElementIds;
+  private activeSectionCollapsed;
+  private inactiveSectionCollapsed;
+  private _abortController;
+  private _elementSubscriptions;
+  private _pendingElementUpdates;
+  private _updateDebounceId;
+  private _cachedActiveElements;
+  private _cachedInactiveElements;
+  private _elementsCacheDirty;
+  constructor();
+  private handleSortChange;
+  private handleElementToggle;
+  private _generateHitsChipTitle;
+  private _subscribeToElement;
+  private _unsubscribeFromElement;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  private _scheduleDebouncedUpdate;
+  private _flushPendingUpdates;
+  private updateElementListFromManager;
+  private handleCallbackCompleted;
+  private getSortedElements;
+  private _recomputeElementsCache;
+  private get activeElements();
+  private get inactiveElements();
+  private sortByDocumentPosition;
+  private renderElementSection;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "element-tab": ElementTab;
+  }
+} //# sourceMappingURL=element-tab.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/dropdown/multi-select-dropdown.d.ts
+declare class MultiSelectDropdown extends BaseDropdown {
+  static styles: any[];
+  selectedValues: string[];
+  onSelectionChange?: (changedValue: string, isSelected: boolean) => void;
+  protected _handleOptionClick(option: DropdownOption): void;
+  protected _getTriggerIcon(): TemplateResult;
+  protected _isOptionSelected(option: DropdownOption): boolean;
+  protected _getTriggerTitle(): string;
+  protected _getTriggerLabel(): string;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "multi-select-dropdown": MultiSelectDropdown;
+  }
+} //# sourceMappingURL=multi-select-dropdown.d.ts.map
+//#endregion
+//#region src/helpers/safeSerializeEventData.d.ts
+type SerializedEventType = ForesightEvent | "serializationError" | "managerDataPayload";
+interface PayloadBase {
+  type: SerializedEventType;
+  localizedTimestamp: string;
+  summary: string;
+  logId: string;
+}
+interface ElementRegisteredPayload extends PayloadBase {
+  type: "elementRegistered";
+  name: string;
+  id: string;
+  state: ForesightElementState;
+  hitslop: HitSlop;
+  meta: Record<string, unknown>;
+}
+interface ElementUnregisteredEvent extends PayloadBase {
+  type: "elementUnregistered";
+  name: string;
+  id: string;
+  state: ForesightElementState;
+  meta: Record<string, unknown>;
+  wasLastRegisteredElement: boolean;
+}
+interface CallbackInvokedPayload extends PayloadBase {
+  type: "callbackInvoked";
+  name: string;
+  hitType: CallbackHitType;
+  state: ForesightElementState;
+  meta: Record<string, unknown>;
+}
+interface CallbackCompletedPayload extends PayloadBase {
+  type: "callbackCompleted";
+  elapsed: string;
+  name: string;
+  hitType: CallbackHitType;
+  status: "success" | "error" | undefined;
+  errorMessage: string | undefined | null;
+  state: ForesightElementState;
+  wasLastActiveElement: boolean;
+  meta: Record<string, unknown>;
+}
+interface MouseTrajectoryUpdatePayload extends PayloadBase {
+  type: "mouseTrajectoryUpdate";
+  currentPoint: ForesightPoint;
+  predictedPoint: ForesightPoint;
+  positionCount: number;
+  mousePredictionEnabled: boolean;
+}
+interface ScrollTrajectoryUpdatePayload extends PayloadBase {
+  type: "scrollTrajectoryUpdate";
+  currentPoint: ForesightPoint;
+  predictedPoint: ForesightPoint;
+  scrollDirection: ScrollDirection;
+}
+interface ManagerSettingsChangedPayload extends PayloadBase {
+  type: "managerSettingsChanged";
+  globalSettings: ForesightManagerSettings;
+  settingsChanged: UpdatedManagerSetting[];
+}
+interface DeviceStrategyChangedPayload extends PayloadBase {
+  type: "deviceStrategyChanged";
+  oldStrategy: string;
+  newStrategy: string;
+}
+interface SerializationErrorPayload extends PayloadBase {
+  type: "serializationError";
+  error: "Failed to serialize event data";
+  errorMessage: string;
+}
+interface ManagerDataPayload extends PayloadBase {
+  type: "managerDataPayload";
+  warning: string;
+  globalCallbackHits: CallbackHits;
+  eventListenerCount: Record<string, number>;
+  managerSettings: ForesightManagerSettings;
+  registeredElements: Array<ForesightElementState & {
+    elementInfo: string;
+  }>;
+  loadedModules: ForesightManagerData["loadedModules"];
+}
+type SerializedEventData = ElementRegisteredPayload | ElementUnregisteredEvent | CallbackInvokedPayload | CallbackCompletedPayload | MouseTrajectoryUpdatePayload | ScrollTrajectoryUpdatePayload | ManagerSettingsChangedPayload | DeviceStrategyChangedPayload | ManagerDataPayload | SerializationErrorPayload;
+//#endregion
+//#region src/lit-entry/control-panel/log-tab/single-log.d.ts
+declare class SingleLog extends LitElement {
+  static styles: any[];
+  log: SerializedEventData;
+  constructor(log: SerializedEventData);
+  isExpanded: boolean;
+  onToggle: ((logId: string) => void) | undefined;
+  protected updated(changedProperties: PropertyValues<this>): void;
+  private serializeLogDataWithoutSummary;
+  private getLogTypeColor;
+  private getEventDisplayName;
+  private truncateLogSummary;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "single-log": SingleLog;
+  }
+} //# sourceMappingURL=single-log.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/log-tab/log-tab.d.ts
+declare class LogTab extends LitElement {
+  static styles: any[];
+  private logDropdown;
+  private filterDropdown;
+  private logLocation;
+  private eventsEnabled;
+  private logs;
+  private expandedLogIds;
+  private MAX_LOGS;
+  private logIdCounter;
+  noContentMessage: string;
+  private _abortController;
+  private _eventListeners;
+  constructor();
+  private handleLogLocationChange;
+  private handleFilterChange;
+  private getSelectedEventFilters;
+  private shouldShowPerformanceWarning;
+  private getNoLogsMessage;
+  private handleLogToggle;
+  private clearLogs;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  private setupDynamicEventListeners;
+  private addForesightEventListener;
+  private removeForesightEventListener;
+  private removeAllEventListeners;
+  private getEventColor;
+  private handleEvent;
+  private addLog;
+  private logManagerData;
+  private addManagerLog;
+  private addEventLog;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "log-tab": LogTab;
+  }
+} //# sourceMappingURL=log-tab.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/settings-tab/setting-item/setting-item.d.ts
+declare class SettingItem extends LitElement {
+  static styles: any[];
+  header: string;
+  description: string;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "setting-item": SettingItem;
+  }
+} //# sourceMappingURL=setting-item.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/settings-tab/setting-item/setting-item-checkbox.d.ts
+type ShowSettingKey = `show.${ShowKey}`;
+declare class SettingItemCheckbox extends LitElement {
+  static styles: any[];
+  isChecked: boolean;
+  header: string;
+  description: string;
+  setting: keyof ForesightManagerSettings | keyof DevtoolsSettings | ShowSettingKey;
+  private handleCheckboxChange;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "setting-item-checkbox": SettingItemCheckbox;
+  }
+}
+//#endregion
+//#region src/lit-entry/control-panel/settings-tab/setting-item/setting-item-range.d.ts
+declare class SettingItemRange extends LitElement {
+  static styles: any[];
+  minValue: number;
+  maxValue: number;
+  currentValue: number;
+  unit: string;
+  header: string;
+  description: string;
+  setting: keyof ForesightManagerSettings;
+  private displayValue;
+  private handleRangeInput;
+  private handleRangeChange;
+  willUpdate(changedProperties: PropertyValues): void;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "setting-item-range": SettingItemRange;
+  }
+} //# sourceMappingURL=setting-item-range.d.ts.map
+//#endregion
+//#region src/lit-entry/control-panel/settings-tab/settings-tab.d.ts
+declare class SettingsTab extends LitElement {
+  static styles: any;
+  private managerSettings;
+  private initialSettings;
+  private devtoolsSettings;
+  private changedSettings;
+  private currentCorner;
+  private touchDeviceStrategyOptions;
+  private minimumConnectionTypeOptions;
+  private cornerOptions;
+  private _abortController;
+  constructor();
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  private _updateChangedSettings;
+  private _checkManagerSettingsChanges;
+  private _checkDevtoolsSettingsChanges;
+  private _handleDevtoolsSettingChange;
+  private _handleTouchDeviceStrategyChange;
+  private _handleMinimumConnectionTypeChange;
+  private _handleCornerChange;
+  private getCurrentCorner;
+  private handleCopySettings;
+  private generateSettingsCode;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "settings-tab": SettingsTab;
+  }
+} //# sourceMappingURL=settings-tab.d.ts.map
+//#endregion
+//#region src/lit-entry/debug-overlay/element-overlays.d.ts
+declare class ElementOverlays extends LitElement {
+  private overlayMap;
+  private callbackAnimations;
+  private _elementSubscriptions;
+  private containerElement;
+  showNameTags: boolean;
+  static styles: any[];
+  private _abortController;
+  connectedCallback(): void;
+  protected willUpdate(changed: PropertyValues<this>): void;
+  private _subscribeToElement;
+  private _unsubscribeFromElement;
+  private createOverlay;
+  /**
+   * The slop area is the element's own shape offset outward by the hit slop:
+   * every corner keeps the element's border radius, grown by the slop on each
+   * axis. Sharp corners stay sharp, since offsetting a rectangle outward does
+   * not round its corners.
+   */
+  private expandedBorderRadius;
+  private updateSlopArea;
+  private updateNameLabel;
+  private createOrUpdateElementOverlay;
+  private removeElementOverlay;
+  private clearCallbackAnimationTimeout;
+  private highlightElementCallback;
+  private unhighlightElementCallback;
+  updateNameTagVisibility(showNameTags: boolean): void;
+  disconnectedCallback(): void;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "element-overlays": ElementOverlays;
+  }
+} //# sourceMappingURL=element-overlays.d.ts.map
+//#endregion
+//#region src/lit-entry/debug-overlay/debug-overlay.d.ts
+declare class DebugOverlay extends LitElement {
+  static styles: any[];
+  private _abortController;
+  private _strategy;
+  showElementOverlays: boolean;
+  showMouseTrajectory: boolean;
+  showScrollTrajectory: boolean;
+  showNameTags: boolean;
+  connectedCallback(): void;
+  private handleDeviceStrategyChange;
+  disconnectedCallback(): void;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "debug-overlay": DebugOverlay;
+  }
+} //# sourceMappingURL=debug-overlay.d.ts.map
+//#endregion
+//#region src/lit-entry/foresight-devtools.d.ts
+declare class ForesightDevtools extends LitElement {
+  static styles: any[];
+  private isInitialized;
+  private static _instance;
+  devtoolsSettings: Required<DevtoolsSettings>;
+  private constructor();
+  private static createAndAppendInstance;
+  static initialize(props?: DeepPartial<DevtoolsSettings>): ForesightDevtools;
+  static get instance(): ForesightDevtools;
+  disconnectedCallback(): void;
+  private shouldUpdateSetting;
+  private updateLoggingSetting;
+  private updateShowSetting;
+  /**
+   * Set every flag inside `show` to the same value. Useful for "turn the
+   * entire devtools UI off" without listing each key.
+   */
+  setAllShow(value: boolean): void;
+  alterDevtoolsSettings(props?: DeepPartial<DevtoolsSettings>): void;
+  private cleanup;
+  render(): any;
+}
+declare global {
+  interface HTMLElementTagNameMap {
+    "foresight-devtools": ForesightDevtools;
+  }
+} //# sourceMappingURL=foresight-devtools.d.ts.map
+//#endregion
+export { type DebuggerBooleanSettingKeys, type DevtoolsSettings, ForesightDevtools, type SortElementList };
+//# sourceMappingURL=index.d.mts.map