main.js

/*
THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
if you want to view the source, please visit the github repository of this plugin
*/

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);

// main.ts
var main_exports = {};
__export(main_exports, {
  default: () => DashReaderPlugin
});
module.exports = __toCommonJS(main_exports);
var import_obsidian6 = require("obsidian");

// src/rsvp-view.ts
var import_obsidian4 = require("obsidian");

// src/services/micropause-service.ts
var _HeadingStrategy = class {
  getMultiplier(word) {
    const trimmed = word.trim();
    const match = trimmed.match(/^\[H(\d)\]/);
    if (!match)
      return 1;
    const level = parseInt(match[1]);
    return _HeadingStrategy.MULTIPLIERS[level] || 1.5;
  }
};
var HeadingStrategy = _HeadingStrategy;
HeadingStrategy.MULTIPLIERS = [0, 2, 1.8, 1.5, 1.3, 1.2, 1.1];
var CalloutStrategy = class {
  constructor(multiplier) {
    this.multiplier = multiplier;
  }
  getMultiplier(word) {
    const trimmed = word.trim();
    return /^\[CALLOUT:[\w-]+\]/.test(trimmed) ? this.multiplier : 1;
  }
};
var SectionMarkerStrategy = class {
  constructor(multiplier) {
    this.multiplier = multiplier;
  }
  getMultiplier(word) {
    const trimmed = word.trim();
    return /^(\d+\.|[IVXLCDM]+\.|\w\.)/.test(trimmed) ? this.multiplier : 1;
  }
};
var ListBulletStrategy = class {
  constructor(multiplier) {
    this.multiplier = multiplier;
  }
  getMultiplier(word) {
    const trimmed = word.trim();
    return /^[-*+•]/.test(trimmed) ? this.multiplier : 1;
  }
};
var SentencePunctuationStrategy = class {
  constructor(multiplier) {
    this.multiplier = multiplier;
  }
  getMultiplier(word) {
    return /[.!?]$/.test(word) ? this.multiplier : 1;
  }
};
var OtherPunctuationStrategy = class {
  constructor(multiplier) {
    this.multiplier = multiplier;
  }
  getMultiplier(word) {
    return /[;:,]$/.test(word) ? this.multiplier : 1;
  }
};
var NumberStrategy = class {
  constructor(multiplier) {
    this.multiplier = multiplier;
  }
  getMultiplier(word) {
    return /\d/.test(word) ? this.multiplier : 1;
  }
};
var LongWordStrategy = class {
  constructor(multiplier) {
    this.multiplier = multiplier;
  }
  getMultiplier(word) {
    return word.length > 8 ? this.multiplier : 1;
  }
};
var ParagraphBreakStrategy = class {
  constructor(multiplier) {
    this.multiplier = multiplier;
  }
  getMultiplier(word) {
    return word.includes("\n") ? this.multiplier : 1;
  }
};
var MicropauseService = class {
  constructor(settings) {
    this.enabled = settings.enableMicropause;
    this.strategies = [
      new HeadingStrategy(),
      new CalloutStrategy(settings.micropauseCallouts),
      new SectionMarkerStrategy(settings.micropauseSectionMarkers),
      new ListBulletStrategy(settings.micropauseListBullets),
      new SentencePunctuationStrategy(settings.micropausePunctuation),
      new OtherPunctuationStrategy(settings.micropauseOtherPunctuation),
      new NumberStrategy(settings.micropauseNumbers),
      new LongWordStrategy(settings.micropauseLongWords),
      new ParagraphBreakStrategy(settings.micropauseParagraph)
    ];
  }
  /**
   * Calculates the total multiplier for a word
   * Applies all strategies and multiplies the results
   *
   * @param word - The word to analyze
   * @returns Total multiplier (1.0 = no pause, >1.0 = longer pause)
   *
   * @example
   * ```typescript
   * const service = new MicropauseService(settings);
   *
   * service.calculateMultiplier("Hello");     // 1.0 (no special characteristics)
   * service.calculateMultiplier("Hello!");    // 2.5 (sentence punctuation)
   * service.calculateMultiplier("[H1]Title"); // 2.0 (heading)
   * service.calculateMultiplier("Hello!\n");  // 6.25 (2.5 * 2.5 = punctuation * paragraph)
   * ```
   */
  calculateMultiplier(word) {
    if (!this.enabled)
      return 1;
    let totalMultiplier = 1;
    for (const strategy of this.strategies) {
      const strategyMultiplier = strategy.getMultiplier(word);
      totalMultiplier *= strategyMultiplier;
    }
    return totalMultiplier;
  }
  /**
   * Updates service with new settings
   * Recreates strategies with updated multipliers
   *
   * @param settings - New settings
   * @param enableOverride - Optional override for enableMicropause (used by mobile profile)
   */
  updateSettings(settings, enableOverride) {
    this.enabled = enableOverride !== void 0 ? enableOverride : settings.enableMicropause;
    this.strategies = [
      new HeadingStrategy(),
      new CalloutStrategy(settings.micropauseCallouts),
      new SectionMarkerStrategy(settings.micropauseSectionMarkers),
      new ListBulletStrategy(settings.micropauseListBullets),
      new SentencePunctuationStrategy(settings.micropausePunctuation),
      new OtherPunctuationStrategy(settings.micropauseOtherPunctuation),
      new NumberStrategy(settings.micropauseNumbers),
      new LongWordStrategy(settings.micropauseLongWords),
      new ParagraphBreakStrategy(settings.micropauseParagraph)
    ];
  }
};

// src/rsvp-engine.ts
var RSVPEngine = class {
  constructor(settings, onWordChange, onComplete, timeoutManager) {
    this.words = [];
    this.currentIndex = 0;
    this.isPlaying = false;
    this.timer = null;
    this.startTime = 0;
    this.startWpm = 0;
    this.pausedTime = 0;
    this.lastPauseTime = 0;
    this.headings = [];
    this.wordsReadInSession = 0;
    // Virtual Timeline: pre-calculated cumulative times for each word
    this.virtualTimeAtIndexMs = [];
    this.virtualTotalMs = 0;
    // Precise timing with drift compensation
    this.tickGen = 0;
    this.nextDueMs = null;
    // Mobile profile mode
    this.useMobileProfile = false;
    this.settings = settings;
    this.onWordChange = onWordChange;
    this.onComplete = onComplete;
    this.timeoutManager = timeoutManager;
    this.micropauseService = new MicropauseService(settings);
  }
  setText(text, startPosition, startWordIndex) {
    const cleaned = text.replace(/\n+/g, " \xA7\xA7LINEBREAK\xA7\xA7 ").replace(/[ \t]+/g, " ").trim();
    this.words = cleaned.split(/\s+/);
    this.extractHeadings();
    this.words = this.words.map(
      (word) => word === "\xA7\xA7LINEBREAK\xA7\xA7" ? "\n" : word
    );
    if (startWordIndex !== void 0) {
      this.currentIndex = Math.max(0, Math.min(startWordIndex, this.words.length - 1));
    } else if (startPosition !== void 0 && startPosition > 0) {
      const textUpToCursor = text.substring(0, startPosition);
      const wordsBeforeCursor = textUpToCursor.trim().split(/\s+/).length;
      this.currentIndex = Math.min(wordsBeforeCursor, this.words.length - 1);
    } else {
      this.currentIndex = 0;
    }
    this.rebuildVirtualTimeline();
  }
  /**
   * Pre-calculates cumulative times for all words
   * This enables accurate time estimation and time-based navigation
   */
  rebuildVirtualTimeline() {
    const n = this.words.length;
    this.virtualTimeAtIndexMs = new Array(n).fill(0);
    this.virtualTotalMs = 0;
    if (n === 0)
      return;
    let tMs = 0;
    let sessionWordCount = 0;
    const SLOW_START_WORDS = 5;
    for (let i = 0; i < n; i++) {
      this.virtualTimeAtIndexMs[i] = tMs;
      const word = this.words[i];
      if (word === "\n")
        continue;
      const wpm = this.getWpmAtElapsedSeconds(tMs / 1e3);
      const baseDelay = 60 / wpm * 1e3;
      const multiplier = this.micropauseService.calculateMultiplier(word);
      let delay = baseDelay * multiplier;
      if (this.getEnableSlowStartSetting() && sessionWordCount < SLOW_START_WORDS) {
        const remainingSlowWords = SLOW_START_WORDS - sessionWordCount;
        const slowStartMultiplier = 1 + remainingSlowWords / SLOW_START_WORDS;
        delay *= slowStartMultiplier;
      }
      sessionWordCount++;
      tMs += Math.max(0, delay);
    }
    this.virtualTotalMs = tMs;
  }
  /**
   * Gets the WPM at a given elapsed time (for acceleration calculation)
   * Uses mobile-aware base WPM
   * @param elapsedSeconds - Virtual elapsed time in seconds
   */
  getWpmAtElapsedSeconds(elapsedSeconds) {
    const baseWpm = this.getWpmSetting();
    if (!this.settings.enableAcceleration) {
      return baseWpm;
    }
    if (elapsedSeconds >= this.settings.accelerationDuration) {
      return this.settings.accelerationTargetWpm;
    }
    const progress = elapsedSeconds / this.settings.accelerationDuration;
    const wpmDiff = this.settings.accelerationTargetWpm - baseWpm;
    return Math.round(baseWpm + wpmDiff * progress);
  }
  /**
   * Returns monotonic time in milliseconds (more precise than Date.now())
   */
  nowMs() {
    return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
  }
  play() {
    if (this.isPlaying)
      return;
    if (this.currentIndex >= this.words.length) {
      this.currentIndex = 0;
    }
    this.isPlaying = true;
    this.tickGen++;
    if (this.startTime === 0) {
      this.startTime = Date.now();
      this.startWpm = this.settings.wpm;
      this.wordsReadInSession = 0;
      this.nextDueMs = null;
    } else if (this.lastPauseTime > 0) {
      this.pausedTime += Date.now() - this.lastPauseTime;
      this.lastPauseTime = 0;
      this.nextDueMs = null;
    }
    this.displayNextWord();
  }
  pause() {
    this.isPlaying = false;
    if (this.timer !== null) {
      this.timeoutManager.clearTimeout(this.timer);
      this.timer = null;
    }
    this.lastPauseTime = Date.now();
  }
  stop() {
    this.pause();
    this.currentIndex = 0;
    this.startTime = 0;
    this.pausedTime = 0;
    this.lastPauseTime = 0;
    this.startWpm = 0;
    this.wordsReadInSession = 0;
    this.nextDueMs = null;
  }
  reset() {
    this.stop();
  }
  rewind(steps = 10) {
    this.currentIndex = Math.max(0, this.currentIndex - steps);
    if (this.isPlaying) {
      this.pause();
      this.play();
    } else {
      this.displayCurrentWord();
    }
  }
  forward(steps = 10) {
    this.currentIndex = Math.min(this.words.length - 1, this.currentIndex + steps);
    if (this.isPlaying) {
      this.pause();
      this.play();
    } else {
      this.displayCurrentWord();
    }
  }
  displayCurrentWord() {
    if (this.currentIndex >= this.words.length) {
      return;
    }
    const chunk = this.getChunk(this.currentIndex);
    this.onWordChange(chunk);
  }
  displayNextWord() {
    if (!this.isPlaying || this.currentIndex >= this.words.length) {
      if (this.currentIndex >= this.words.length) {
        this.isPlaying = false;
        this.onComplete();
      }
      return;
    }
    const gen = this.tickGen;
    const chunk = this.getChunk(this.currentIndex);
    this.onWordChange(chunk);
    let delay = this.calculateDelay(chunk.text);
    if (this.getEnableSlowStartSetting()) {
      const SLOW_START_WORDS = 5;
      if (this.wordsReadInSession < SLOW_START_WORDS) {
        const remainingSlowWords = SLOW_START_WORDS - this.wordsReadInSession;
        const slowStartMultiplier = 1 + remainingSlowWords / SLOW_START_WORDS;
        delay *= slowStartMultiplier;
      }
    }
    this.wordsReadInSession++;
    this.currentIndex += this.getChunkSizeSetting();
    const now = this.nowMs();
    if (this.nextDueMs === null) {
      this.nextDueMs = now;
    }
    this.nextDueMs += delay;
    let waitMs = this.nextDueMs - now;
    if (waitMs < -250) {
      this.nextDueMs = now + delay;
      waitMs = delay;
    }
    this.timer = this.timeoutManager.setTimeout(() => {
      if (gen !== this.tickGen)
        return;
      this.displayNextWord();
    }, Math.max(0, waitMs));
  }
  getChunk(startIndex) {
    const chunkSize = this.getChunkSizeSetting();
    const endIndex = Math.min(
      startIndex + chunkSize,
      this.words.length
    );
    const chunkWords = this.words.slice(startIndex, endIndex);
    const text = chunkWords.join(" ");
    return {
      text,
      index: startIndex,
      delay: this.calculateDelay(text),
      isEnd: endIndex >= this.words.length,
      headingContext: this.getCurrentHeadingContext(startIndex)
    };
  }
  getCurrentWpm() {
    const baseWpm = this.getWpmSetting();
    if (!this.settings.enableAcceleration || this.startTime === 0) {
      return baseWpm;
    }
    const elapsed = (Date.now() - this.startTime - this.pausedTime) / 1e3;
    if (elapsed >= this.settings.accelerationDuration) {
      return this.settings.accelerationTargetWpm;
    }
    const progress = elapsed / this.settings.accelerationDuration;
    const wpmDiff = this.settings.accelerationTargetWpm - this.startWpm;
    const currentWpm = this.startWpm + wpmDiff * progress;
    return Math.round(currentWpm);
  }
  calculateDelay(text) {
    const currentWpm = this.getCurrentWpm();
    const baseDelay = 60 / currentWpm * 1e3;
    const multiplier = this.micropauseService.calculateMultiplier(text);
    return baseDelay * multiplier;
  }
  /**
   * Extract all headings and callouts from the words array
   * Headings are marked with [H1], [H2], etc.
   * Callouts are marked with [CALLOUT:type] by the markdown parser
   *
   * Since text is split into words, we need to collect all words
   * that belong to the same heading/callout title.
   */
  extractHeadings() {
    this.headings = [];
    for (let i = 0; i < this.words.length; i++) {
      const word = this.words[i];
      const headingMatch = word.match(/^\[H(\d)\](.+)/);
      if (headingMatch) {
        const level = parseInt(headingMatch[1]);
        const firstWord = headingMatch[2];
        const titleWords = [firstWord];
        let j = i + 1;
        while (j < this.words.length) {
          const nextWord = this.words[j];
          if (nextWord === "\xA7\xA7LINEBREAK\xA7\xA7") {
            break;
          }
          if (/^\[H\d\]/.test(nextWord) || /^\[CALLOUT:/.test(nextWord)) {
            break;
          }
          titleWords.push(nextWord);
          j++;
          if (titleWords.length >= 20) {
            break;
          }
        }
        const text = titleWords.join(" ").trim();
        this.headings.push({
          level,
          text,
          wordIndex: i
        });
        continue;
      }
      const calloutMatch = word.match(/^\[CALLOUT:([\w-]+)\](.+)/);
      if (calloutMatch) {
        const calloutType = calloutMatch[1];
        const firstWord = calloutMatch[2];
        const titleWords = [firstWord];
        let j = i + 1;
        while (j < this.words.length) {
          const nextWord = this.words[j];
          if (nextWord === "\xA7\xA7LINEBREAK\xA7\xA7") {
            break;
          }
          if (/^\[H\d\]/.test(nextWord) || /^\[CALLOUT:/.test(nextWord)) {
            break;
          }
          titleWords.push(nextWord);
          j++;
          if (titleWords.length >= 20) {
            break;
          }
        }
        const text = titleWords.join(" ").trim();
        this.headings.push({
          level: 0,
          // Special level for callouts
          text,
          wordIndex: i,
          calloutType
        });
      }
    }
  }
  /**
   * Get the current heading context (breadcrumb) for a given word index
   * Returns the hierarchical path of headings leading to the current position
   *
   * @param wordIndex - Word index to get context for
   * @returns Heading context with breadcrumb path and current heading
   */
  getCurrentHeadingContext(wordIndex) {
    if (this.headings.length === 0) {
      return { breadcrumb: [], current: null };
    }
    const relevantHeadings = this.headings.filter((h) => h.wordIndex <= wordIndex);
    if (relevantHeadings.length === 0) {
      return { breadcrumb: [], current: null };
    }
    const breadcrumb = [];
    let currentLevel = 0;
    for (const heading of relevantHeadings) {
      if (heading.level <= currentLevel) {
        while (breadcrumb.length > 0 && breadcrumb[breadcrumb.length - 1].level >= heading.level) {
          breadcrumb.pop();
        }
      }
      breadcrumb.push(heading);
      currentLevel = heading.level;
    }
    return {
      breadcrumb,
      current: breadcrumb[breadcrumb.length - 1] || null
    };
  }
  getProgress() {
    return this.words.length > 0 ? this.currentIndex / this.words.length * 100 : 0;
  }
  getCurrentIndex() {
    return this.currentIndex;
  }
  getTotalWords() {
    return this.words.length;
  }
  getIsPlaying() {
    return this.isPlaying;
  }
  setWpm(wpm) {
    this.settings.wpm = Math.max(50, Math.min(1e3, wpm));
  }
  getWpm() {
    return this.settings.wpm;
  }
  setChunkSize(size) {
    this.settings.chunkSize = Math.max(1, Math.min(5, size));
  }
  getChunkSize() {
    return this.settings.chunkSize;
  }
  getContext(contextWords = 3) {
    const beforeStart = Math.max(0, this.currentIndex - contextWords);
    const afterEnd = Math.min(this.words.length, this.currentIndex + this.settings.chunkSize + contextWords);
    return {
      before: this.words.slice(beforeStart, this.currentIndex),
      after: this.words.slice(this.currentIndex + this.settings.chunkSize, afterEnd)
    };
  }
  updateSettings(settings) {
    this.settings = settings;
    this.micropauseService.updateSettings(settings, this.getEnableMicropauseSetting());
    this.rebuildVirtualTimeline();
  }
  // ============================================================================
  // MOBILE PROFILE SUPPORT
  // ============================================================================
  /**
   * Enables or disables mobile profile mode
   * When enabled, mobile-specific settings override desktop settings
   */
  setUseMobileProfile(useMobile) {
    this.useMobileProfile = useMobile;
    this.micropauseService.updateSettings(this.settings, this.getEnableMicropauseSetting());
    this.rebuildVirtualTimeline();
  }
  /**
   * Returns whether mobile profile is active
   */
  getUseMobileProfile() {
    return this.useMobileProfile;
  }
  /**
   * Gets the effective WPM setting (mobile or desktop)
   */
  getWpmSetting() {
    return this.useMobileProfile ? this.settings.mobileWpm : this.settings.wpm;
  }
  /**
   * Gets the effective chunk size setting (mobile or desktop)
   */
  getChunkSizeSetting() {
    return this.useMobileProfile ? this.settings.mobileChunkSize : this.settings.chunkSize;
  }
  /**
   * Gets the effective slow start setting (mobile or desktop)
   */
  getEnableSlowStartSetting() {
    return this.useMobileProfile ? this.settings.mobileEnableSlowStart : this.settings.enableSlowStart;
  }
  /**
   * Gets the effective micropause setting (mobile or desktop)
   */
  getEnableMicropauseSetting() {
    return this.useMobileProfile ? this.settings.mobileEnableMicropause : this.settings.enableMicropause;
  }
  /**
   * Gets the effective font size setting (mobile or desktop)
   * Note: This is used by the view, not the engine
   */
  getEffectiveFontSize() {
    return this.useMobileProfile ? this.settings.mobileFontSize : this.settings.fontSize;
  }
  /**
   * Gets the effective show breadcrumb setting (mobile or desktop)
   * Note: This is used by the view, not the engine
   */
  getEffectiveShowBreadcrumb() {
    return this.useMobileProfile ? this.settings.mobileShowBreadcrumb : this.settings.showBreadcrumb;
  }
  /**
   * Gets the effective context words setting (mobile or desktop)
   * Note: This is used by the view, not the engine
   */
  getEffectiveContextWords() {
    return this.useMobileProfile ? this.settings.mobileContextWords : this.settings.contextWords;
  }
  /**
   * Gets the effective context font size setting (mobile or desktop)
   * Note: This is used by the view, not the engine
   */
  getEffectiveContextFontSize() {
    return this.useMobileProfile ? this.settings.mobileContextFontSize : this.settings.contextFontSize;
  }
  getEstimatedDuration() {
    if (this.words.length === 0)
      return 0;
    const remainingWords = Math.max(0, this.words.length - this.currentIndex);
    if (remainingWords === 0)
      return 0;
    const averageWpm = this.settings.enableAcceleration ? (this.settings.wpm + this.settings.accelerationTargetWpm) / 2 : this.settings.wpm;
    return this.calculateAccurateRemainingTime(averageWpm);
  }
  calculateAccurateRemainingTime(wpm) {
    if (this.words.length === 0 || this.currentIndex >= this.words.length)
      return 0;
    let totalTimeMs = 0;
    const baseDelay = 60 / wpm * 1e3;
    for (let i = this.currentIndex; i < this.words.length; i++) {
      const word = this.words[i];
      const multiplier = this.micropauseService.calculateMultiplier(word);
      totalTimeMs += baseDelay * multiplier;
    }
    return Math.ceil(totalTimeMs / 1e3);
  }
  getRemainingWords() {
    return Math.max(0, this.words.length - this.currentIndex);
  }
  getElapsedTime() {
    if (this.startTime === 0)
      return 0;
    const now = this.isPlaying ? Date.now() : this.lastPauseTime || Date.now();
    return Math.floor((now - this.startTime - this.pausedTime) / 1e3);
  }
  getRemainingTime() {
    if (this.words.length === 0 || this.currentIndex >= this.words.length)
      return 0;
    const currentWpm = this.getCurrentWpm();
    return this.calculateAccurateRemainingTime(currentWpm);
  }
  /**
   * Returns the total estimated duration for the entire document (from start to end)
   * This is a fixed value that doesn't change with current position
   */
  getTotalEstimatedDuration() {
    if (this.words.length === 0)
      return 0;
    const averageWpm = this.settings.enableAcceleration ? (this.settings.wpm + this.settings.accelerationTargetWpm) / 2 : this.settings.wpm;
    return this.calculateTimeForRange(0, this.words.length, averageWpm);
  }
  /**
   * Returns the estimated time to reach the current position (from start)
   * Used for displaying "elapsed" time based on position, not real time
   */
  getEstimatedTimeAtCurrentPosition() {
    if (this.words.length === 0 || this.currentIndex === 0)
      return 0;
    const averageWpm = this.settings.enableAcceleration ? (this.settings.wpm + this.settings.accelerationTargetWpm) / 2 : this.settings.wpm;
    return this.calculateTimeForRange(0, this.currentIndex, averageWpm);
  }
  /**
   * Calculates the estimated reading time for a range of words
   */
  calculateTimeForRange(startIndex, endIndex, wpm) {
    if (startIndex >= endIndex)
      return 0;
    let totalTimeMs = 0;
    const baseDelay = 60 / wpm * 1e3;
    for (let i = startIndex; i < endIndex; i++) {
      const word = this.words[i];
      const multiplier = this.micropauseService.calculateMultiplier(word);
      totalTimeMs += baseDelay * multiplier;
    }
    return Math.ceil(totalTimeMs / 1e3);
  }
  getCurrentWpmPublic() {
    return this.getCurrentWpm();
  }
  /**
   * Returns all headings extracted from the document
   * Useful for navigation and section counting
   */
  getHeadings() {
    return this.headings;
  }
  /**
   * Returns the words array for direct access
   * Used by fullscreen modal to display current word
   */
  getWords() {
    return this.words;
  }
  /**
   * Returns the current onWordChange callback
   * Used by fullscreen modal to save and restore callbacks
   */
  getOnWordChangeCallback() {
    return this.onWordChange;
  }
  /**
   * Returns the current onComplete callback
   * Used by fullscreen modal to save and restore callbacks
   */
  getOnCompleteCallback() {
    return this.onComplete;
  }
  /**
   * Sets new callbacks for word change and completion
   * Used by fullscreen modal to redirect engine events
   */
  setCallbacks(onWordChange, onComplete) {
    this.onWordChange = onWordChange;
    this.onComplete = onComplete;
  }
  /**
   * Navigates to a specific word index
   * Used by minimap and fullscreen navigation
   */
  goToIndex(index) {
    this.currentIndex = Math.max(0, Math.min(index, this.words.length - 1));
    if (this.isPlaying) {
      this.pause();
      this.play();
    } else {
      this.displayCurrentWord();
    }
  }
  // ============================================================================
  // VIRTUAL TIMELINE PUBLIC METHODS
  // ============================================================================
  /**
   * Returns the total virtual duration in seconds
   * Pre-calculated for accuracy
   */
  getVirtualTotalSeconds() {
    return Math.round(this.virtualTotalMs / 1e3);
  }
  /**
   * Returns the virtual elapsed time at a specific word index
   * @param index - Word index
   */
  getVirtualElapsedSecondsAtIndex(index) {
    const idx = Math.max(0, Math.min(index, this.words.length - 1));
    return Math.round((this.virtualTimeAtIndexMs[idx] || 0) / 1e3);
  }
  /**
   * Returns the virtual elapsed time at current position
   */
  getVirtualElapsedSeconds() {
    return this.getVirtualElapsedSecondsAtIndex(this.currentIndex);
  }
  /**
   * Returns the virtual remaining time from current position
   */
  getVirtualRemainingSeconds() {
    return Math.max(0, this.getVirtualTotalSeconds() - this.getVirtualElapsedSeconds());
  }
  /**
   * Finds the word index closest to a target time (in seconds)
   * Uses binary search for efficiency
   * @param targetSeconds - Target time in seconds
   */
  findIndexAtTime(targetSeconds) {
    const targetMs = targetSeconds * 1e3;
    const n = this.virtualTimeAtIndexMs.length;
    if (n === 0)
      return 0;
    if (targetMs <= 0)
      return 0;
    if (targetMs >= this.virtualTotalMs)
      return n - 1;
    let lo = 0;
    let hi = n - 1;
    while (lo < hi) {
      const mid = Math.floor((lo + hi + 1) / 2);
      if (this.virtualTimeAtIndexMs[mid] <= targetMs) {
        lo = mid;
      } else {
        hi = mid - 1;
      }
    }
    return lo;
  }
  /**
   * Navigate to a specific time position (in seconds)
   * @param seconds - Target time in seconds
   */
  goToTime(seconds) {
    const index = this.findIndexAtTime(seconds);
    this.goToIndex(index);
  }
  /**
   * Rewind by a specified number of seconds
   * @param seconds - Seconds to rewind (default: 10)
   */
  rewindSeconds(seconds = 10) {
    const currentTime = this.getVirtualElapsedSeconds();
    const targetTime = Math.max(0, currentTime - seconds);
    this.goToTime(targetTime);
  }
  /**
   * Forward by a specified number of seconds
   * @param seconds - Seconds to forward (default: 10)
   */
  forwardSeconds(seconds = 10) {
    const currentTime = this.getVirtualElapsedSeconds();
    const targetTime = currentTime + seconds;
    this.goToTime(targetTime);
  }
};

// src/markdown-parser.ts
var MarkdownParser = class {
  static parseToPlainText(markdown) {
    let text = markdown;
    text = text.replace(/^---[\s\S]*?---\n?/m, "");
    const codeBlocks = [];
    text = text.replace(/```[\w-]*\n?([\s\S]*?)```/g, (_match, code) => {
      const index = codeBlocks.length;
      codeBlocks.push(code);
      return `___CODE_BLOCK_${index}___`;
    });
    text = text.replace(/`([^`]+)`/g, "$1");
    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "");
    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
    text = text.replace(/\[\[([^\]|]+)(\|([^\]]+))?\]\]/g, (_match, link, _pipe, alias) => {
      return alias || link;
    });
    text = text.replace(/\*\*\*([^*]+)\*\*\*/g, "$1");
    text = text.replace(/\*\*([^*]+)\*\*/g, "$1");
    text = text.replace(/__([^_]+)__/g, "$1");
    text = text.replace(/\*([^*\n]+)\*/g, "$1");
    text = text.replace(/_([^_\n]+)_/g, "$1");
    text = text.replace(/~~([^~]+)~~/g, "$1");
    text = text.replace(/==([^=]+)==/g, "$1");
    text = text.replace(/^(#{1,6})\s+(.+)$/gm, (_match, hashes, content) => {
      const level = hashes.length;
      return `[H${level}]${content}`;
    });
    text = text.replace(/^>\s*\[!([\w-]+)\]\s*(.*)$/gm, (_match, type, title) => {
      const displayTitle = title.trim() || type;
      return `[CALLOUT:${type}]${displayTitle}`;
    });
    text = text.replace(/^>\s*/gm, "");
    text = text.replace(/^[\s]*[-*+]\s+/gm, "");
    text = text.replace(/^[\s]*\d+\.\s+/gm, "");
    text = text.replace(/^[\s]*[-*_]{3,}[\s]*$/gm, "");
    text = text.replace(/(?:^|\s)(#[a-zA-Z0-9_/-]+)/g, "");
    text = text.replace(/\[\^[^\]]+\]/g, "");
    text = text.replace(/^\[\^[^\]]+\]:.*$/gm, "");
    text = text.replace(/^---\s*Backlinks?\s*---[\s\S]*$/m, "");
    text = text.replace(/^##?\s*Backlinks?[\s\S]*$/m, "");
    text = text.replace(/<!--[\s\S]*?-->/g, "");
    text = text.replace(/<[^>]+>/g, "");
    text = text.replace(/\n{3,}/g, "\n\n");
    text = text.replace(/^[ \t]+/gm, "");
    text = text.replace(/[ \t]+$/gm, "");
    text = text.replace(/___CODE_BLOCK_(\d+)___/g, (_match, index) => {
      return codeBlocks[parseInt(index)] || "";
    });
    text = text.trim();
    return text;
  }
  /**
   * Parse le texte sélectionné en tenant compte du contexte Obsidian
   */
  static parseSelection(text) {
    return this.parseToPlainText(text);
  }
};

// src/view-state.ts
var DEFAULT_VIEW_STATE = {
  wordsRead: 0,
  startTime: 0,
  showingControls: false,
  showingSettings: false,
  showingStats: false,
  currentWpm: 0,
  currentChunkSize: 0,
  currentFontSize: 0,
  isLoading: false
};
var ViewState = class {
  /**
   * Creates a new ViewState instance
   *
   * @param initialState - Optional partial state to merge with defaults
   *
   * @example
   * ```typescript
   * // Default state
   * const state = new ViewState();
   *
   * // With initial values
   * const state = new ViewState({
   *   currentWpm: 300,
   *   showingControls: true
   * });
   * ```
   */
  constructor(initialState = {}) {
    this.listeners = /* @__PURE__ */ new Set();
    this.state = { ...DEFAULT_VIEW_STATE, ...initialState };
  }
  /**
   * Get a state value (type-safe)
   *
   * Uses TypeScript generics to ensure return type matches the requested key.
   *
   * @param key - State property to get
   * @returns Current value of the property
   *
   * @example
   * ```typescript
   * const wpm: number = state.get('currentWpm');
   * const showing: boolean = state.get('showingControls');
   * ```
   */
  get(key) {
    return this.state[key];
  }
  /**
   * Set a state value and notify listeners (type-safe)
   *
   * Updates the state property and notifies all subscribers if the value changed.
   * Automatically skips notification if the new value equals the old value.
   *
   * @param key - State property to set
   * @param value - New value for the property
   *
   * @example
   * ```typescript
   * state.set('currentWpm', 350);
   * state.set('showingControls', true);
   * state.set('loadedFileName', 'My Note.md');
   * ```
   */
  set(key, value) {
    const oldValue = this.state[key];
    if (oldValue === value)
      return;
    this.state[key] = value;
    this.notify(key, value, oldValue);
  }
  /**
   * Update multiple state values at once (batch update)
   *
   * Efficiently updates multiple properties in a single call. Each changed
   * property will trigger its own notification to listeners.
   *
   * @param updates - Partial state object with properties to update
   *
   * @example
   * ```typescript
   * state.update({
   *   currentWpm: 350,
   *   showingControls: true,
   *   wordsRead: 42
   * });
   * ```
   */
  update(updates) {
    Object.entries(updates).forEach(([key, value]) => {
      this.set(key, value);
    });
  }
  /**
   * Reset all state to default values
   *
   * Sets every state property back to its default value from DEFAULT_VIEW_STATE.
   * Each reset property triggers a notification to listeners.
   *
   * @example
   * ```typescript
   * // After reading session, reset to defaults
   * state.reset();
   * ```
   */
  reset() {
    Object.entries(DEFAULT_VIEW_STATE).forEach(([key, value]) => {
      this.set(key, value);
    });
  }
  /**
   * Subscribe to state changes (observer pattern)
   *
   * Registers a listener function that will be called whenever any state
   * property changes. Returns an unsubscribe function for cleanup.
   *
   * **Error Handling**: Listener errors are caught and logged to prevent
   * one broken listener from breaking all listeners.
   *
   * @param listener - Callback function to call on state changes
   * @returns Unsubscribe function to remove the listener
   *
   * @example
   * ```typescript
   * // Subscribe and get unsubscribe function
   * const unsubscribe = state.subscribe((key, value, oldValue) => {
   *   if (key === 'currentWpm') {
   *     console.log(`WPM changed from ${oldValue} to ${value}`);
   *   }
   * });
   *
   * // Later, cleanup
   * unsubscribe();
   * ```
   */
  subscribe(listener) {
    this.listeners.add(listener);
    return () => this.listeners.delete(listener);
  }
  /**
   * Notify all listeners of a state change (internal)
   *
   * Calls each registered listener with the changed property details.
   * Catches and logs errors to prevent one broken listener from affecting others.
   *
   * @param key - Name of the property that changed
   * @param value - New value of the property
   * @param oldValue - Previous value of the property
   *
   * @private
   */
  notify(key, value, oldValue) {
    this.listeners.forEach((listener) => {
      try {
        listener(key, value, oldValue);
      } catch (error) {
        console.error("DashReader: Error in state listener", error);
      }
    });
  }
  /**
   * Get all state as a plain object (for debugging)
   *
   * Returns a shallow copy of the entire state object. Useful for logging
   * or debugging state issues.
   *
   * @returns Readonly copy of the full state
   *
   * @example
   * ```typescript
   * console.log('Current state:', state.getAll());
   * // Output: { wordsRead: 42, currentWpm: 350, showingControls: true, ... }
   * ```
   */
  getAll() {
    return { ...this.state };
  }
  /**
   * Toggle a boolean state value (helper)
   *
   * Convenience method for toggling boolean properties. Flips the value
   * from true to false or false to true.
   *
   * @param key - Boolean property to toggle (showingControls, showingSettings, showingStats, isLoading)
   *
   * @example
   * ```typescript
   * // Toggle control panel visibility
   * state.toggle('showingControls');
   *
   * // Toggle settings panel
   * state.toggle('showingSettings');
   * ```
   */
  toggle(key) {
    const currentValue = this.get(key);
    this.set(key, !currentValue);
  }
  /**
   * Increment a numeric state value (helper)
   *
   * Convenience method for incrementing numeric properties. Can add positive
   * or negative deltas.
   *
   * @param key - Numeric property to increment (currently only wordsRead)
   * @param delta - Amount to add (default: 1, can be negative)
   *
   * @example
   * ```typescript
   * // Increment words read by 1
   * state.increment('wordsRead');
   *
   * // Increment by 5
   * state.increment('wordsRead', 5);
   *
   * // Decrement by 1
   * state.increment('wordsRead', -1);
   * ```
   */
  increment(key, delta = 1) {
    const currentValue = this.get(key);
    this.set(key, currentValue + delta);
  }
};

// src/constants.ts
var CSS_CLASSES = {
  // Main container
  container: "dashreader-container",
  // Toggle bar
  toggleBar: "dashreader-toggle-bar",
  toggleBtn: "dashreader-toggle-btn",
  // Display area
  display: "dashreader-display",
  word: "dashreader-word",
  welcome: "dashreader-welcome",
  highlight: "dashreader-highlight",
  // Context
  contextBefore: "dashreader-context-before",
  contextAfter: "dashreader-context-after",
  // Progress
  progressContainer: "dashreader-progress-container",
  progressBar: "dashreader-progress-bar",
  // Controls
  controls: "dashreader-controls",
  controlGroup: "dashreader-control-group",
  controlLabel: "control-label",
  // Settings
  settings: "dashreader-settings",
  settingGroup: "dashreader-setting-group",
  settingLabel: "setting-label",
  settingToggle: "setting-toggle",
  // Stats
  stats: "dashreader-stats",
  statsText: "dashreader-stats-text",
  wpmDisplay: "dashreader-wpm-display",
  // Buttons
  btn: "dashreader-btn",
  playBtn: "play-btn",
  pauseBtn: "pause-btn",
  smallBtn: "small-btn",
  // Value displays
  wpmValue: "wpm-value",
  wpmInlineValue: "wpm-inline-value",
  chunkValue: "chunk-value",
  fontValue: "font-value",
  accelDurationValue: "accel-duration-value",
  accelTargetValue: "accel-target-value",
  // State classes
  hidden: "hidden"
};
var TIMING = {
  /** Delay before auto-loading content from editor (file-open event) */
  autoLoadDelay: 300,
  /** Shorter delay for leaf-change events (editor already active) */
  autoLoadDelayShort: 200,
  /** Very short delay for immediate operations */
  autoLoadDelayVeryShort: 50,
  /** Throttle interval for cursor/selection checks (prevents excessive checks) */
  throttleDelay: 150,
  /** CSS transition duration for smooth animations */
  transitionDuration: 300
};
var TEXT_LIMITS = {
  /** Minimum characters in selection to trigger auto-load */
  minSelectionLength: 30,
  /** Minimum characters in full document to load */
  minContentLength: 50,
  /** Minimum words in parsed text to display */
  minParsedLength: 10
};
var INCREMENTS = {
  /** WPM increment (25 = noticeable speed change) */
  wpm: 25,
  /** Chunk size increment (1 word at a time) */
  chunkSize: 1,
  /** Font size increment in pixels (4px = visible change) */
  fontSize: 4,
  /** Acceleration duration increment in seconds */
  accelDuration: 5
};
var LIMITS = {
  /** Font size range in pixels (20 = readable minimum, 120 = fills viewport) */
  fontSize: { min: 20, max: 120 },
  /** WPM range (50 = very slow, 5000 = ultra-fast speed reading limit) */
  wpm: { min: 50, max: 5e3 },
  /** Acceleration duration in seconds (10 = quick ramp, 120 = gradual) */
  accelDuration: { min: 10, max: 120 }
};
var ICONS = {
  /** Rewind to start button */
  rewind: "\u23EE",
  /** Play button */
  play: "\u25B6",
  /** Pause button */
  pause: "\u23F8",
  /** Skip forward button */
  forward: "\u23ED",
  /** Stop button */
  stop: "\u23F9",
  /** Increment (+) button */
  increment: "+",
  /** Decrement (−) button (using minus sign, not hyphen) */
  decrement: "\u2212",
  /** Settings toggle button */
  settings: "\u2699\uFE0F",
  /** Statistics toggle button */
  stats: "\u{1F4CA}",
  /** File/document indicator */
  file: "\u{1F4C4}",
  /** Celebration (reading complete) */
  celebration: "\u{1F389}",
  /** Book/reading indicator */
  book: "\u{1F4D6}",
  /** Expand to new tab */
  expand: "\u2922",
  // Lucide icons for fullscreen controls
  /** Jump to start (Lucide) */
  jumpStart: "lucide:chevrons-left",
  /** Previous heading (Lucide) */
  prevHeading: "lucide:arrow-up",
  /** Rewind/left arrow (Lucide) */
  arrowLeft: "lucide:arrow-left",
  /** Forward/right arrow (Lucide) */
  arrowRight: "lucide:arrow-right",
  /** Next heading (Lucide) */
  nextHeading: "lucide:arrow-down",
  /** Jump to end (Lucide) */
  jumpEnd: "lucide:chevrons-right",
  /** Play (Lucide) */
  playLucide: "lucide:play",
  /** Pause (Lucide) */
  pauseLucide: "lucide:pause"
};
var HEADING_MULTIPLIERS = {
  /** H1 heading multiplier (1.5x base font = major section) */
  h1: 1.5,
  /** H2 heading multiplier (1.3x base font) */
  h2: 1.3,
  /** H3 heading multiplier (1.2x base font) */
  h3: 1.2,
  /** H4 heading multiplier (1.1x base font) */
  h4: 1.1,
  /** H5 heading multiplier (1.05x base font) */
  h5: 1.05,
  /** H6 heading multiplier (1x base font = same as body text) */
  h6: 1
};

// src/dom-registry.ts
var DOMRegistry = class {
  constructor() {
    this.elements = /* @__PURE__ */ new Map();
  }
  /**
   * Register a DOM element by key
   *
   * Stores an element reference for later retrieval and updates. Should be
   * called once per element during UI construction.
   *
   * @param key - Type-safe key for the element (from DOMElementKey union)
   * @param element - HTMLElement to store
   *
   * @example
   * ```typescript
   * const wpmValue = controlGroup.createSpan({ cls: CSS_CLASSES.wpmValue });
   * this.dom.register('wpmValue', wpmValue);
   * ```
   */
  register(key, element) {
    this.elements.set(key, element);
  }
  /**
   * Get a registered DOM element
   *
   * Retrieves the stored element reference. Returns undefined if the key
   * was never registered.
   *
   * @param key - Key of the element to retrieve
   * @returns The HTMLElement if registered, undefined otherwise
   *
   * @example
   * ```typescript
   * const wpmEl = this.dom.get('wpmValue');
   * if (wpmEl) {
   *   // Do something with the element
   * }
   * ```
   */
  get(key) {
    return this.elements.get(key);
  }
  /**
   * Update text content of a registered element (XSS-safe)
   *
   * Uses Obsidian's setText() method which safely escapes HTML.
   * Preferred over updateHTML() for displaying user-generated content.
   *
   * @param key - Key of the element to update
   * @param text - Text content to set (string or number)
   *
   * @example
   * ```typescript
   * this.dom.updateText('wpmValue', 350);
   * this.dom.updateText('statsText', 'Words: 42 / 1000');
   * ```
   */
  updateText(key, text) {
    const element = this.elements.get(key);
    if (element) {
      element.setText(String(text));
    }
  }
  /**
   * @deprecated REMOVED for Obsidian security compliance.
   *
   * Using innerHTML with any content is discouraged by Obsidian plugin guidelines.
   * Instead, use DOM API methods to build HTML structures:
   * - element.createEl(), element.createSpan(), element.createDiv()
   * - element.setText() for text content (automatically escapes)
   * - element.empty() to clear contents
   *
   * See: https://docs.obsidian.md/Plugins/Releasing/Plugin+guidelines
   *
   * Migration example:
   * ```typescript
   * // OLD (unsafe):
   * this.dom.updateHTML('wordEl', `<span class="highlight">${word}</span>`);
   *
   * // NEW (safe):
   * const element = this.dom.get('wordEl');
   * element.empty();
   * element.createSpan({ text: word, cls: 'highlight' });
   * ```
   */
  /**
   * Update a CSS style property of a registered element
   *
   * Modifies inline styles. Useful for dynamic styling like font size,
   * colors, or positioning.
   *
   * @param key - Key of the element to update
   * @param property - CSS property name (camelCase, e.g., 'fontSize')
   * @param value - CSS value as string (e.g., '48px', '#ff0000')
   *
   * @example
   * ```typescript
   * this.dom.updateStyle('wordEl', 'fontSize', '48px');
   * this.dom.updateStyle('wordEl', 'color', '#ff0000');
   * this.dom.updateStyle('progressBar', 'width', '50%');
   * ```
   */
  updateStyle(key, property, value) {
    const element = this.elements.get(key);
    if (element) {
      element.style.setProperty(property, value);
    }
  }
  /**
   * Toggle CSS class on a registered element
   *
   * Conditionally adds or removes a CSS class. Commonly used for show/hide
   * functionality with CSS_CLASSES.hidden.
   *
   * @param key - Key of the element to update
   * @param className - CSS class name to toggle
   * @param force - True to add class, false to remove it
   *
   * @example
   * ```typescript
   * // Show controls (remove 'hidden' class)
   * this.dom.toggleClass('controlsEl', CSS_CLASSES.hidden, false);
   *
   * // Hide controls (add 'hidden' class)
   * this.dom.toggleClass('controlsEl', CSS_CLASSES.hidden, true);
   * ```
   */
  toggleClass(key, className, force) {
    const element = this.elements.get(key);
    if (element) {
      element.classList.toggle(className, force);
    }
  }
  /**
   * Add CSS class to a registered element
   *
   * Adds a CSS class if not already present. Use for state changes like
   * highlighting, active states, etc.
   *
   * @param key - Key of the element to update
   * @param className - CSS class name to add
   *
   * @example
   * ```typescript
   * this.dom.addClass('playBtn', 'active');
   * this.dom.addClass('wordEl', CSS_CLASSES.highlight);
   * ```
   */
  addClass(key, className) {
    const element = this.elements.get(key);
    if (element) {
      element.classList.add(className);
    }
  }
  /**
   * Remove CSS class from a registered element
   *
   * Removes a CSS class if present. Use for removing state classes.
   *
   * @param key - Key of the element to update
   * @param className - CSS class name to remove
   *
   * @example
   * ```typescript
   * this.dom.removeClass('playBtn', 'active');
   * this.dom.removeClass('wordEl', CSS_CLASSES.highlight);
   * ```
   */
  removeClass(key, className) {
    const element = this.elements.get(key);
    if (element) {
      element.classList.remove(className);
    }
  }
  /**
   * Empty the content of a registered element
   *
   * Removes all child nodes and text content. Useful for clearing containers
   * before re-rendering.
   *
   * @param key - Key of the element to empty
   *
   * @example
   * ```typescript
   * // Clear the word display before loading new text
   * this.dom.empty('wordEl');
   * ```
   */
  empty(key) {
    const element = this.elements.get(key);
    if (element) {
      element.empty();
    }
  }
  /**
   * Check if an element is registered
   *
   * Returns true if an element with the given key has been registered.
   *
   * @param key - Key to check
   * @returns True if the key is registered, false otherwise
   *
   * @example
   * ```typescript
   * if (this.dom.has('statsEl')) {
   *   this.dom.updateText('statsEl', 'New stats');
   * }
   * ```
   */
  has(key) {
    return this.elements.has(key);
  }
  /**
   * Clear all registered elements
   *
   * Removes all element references from the registry. Typically used during
   * cleanup or when rebuilding the entire UI.
   *
   * @example
   * ```typescript
   * // During onunload
   * this.dom.clear();
   * ```
   */
  clear() {
    this.elements.clear();
  }
  /**
   * Update multiple text elements at once (batch update)
   *
   * Efficiently updates text content of multiple elements in a single call.
   * More readable than multiple individual updateText() calls.
   *
   * @param updates - Object mapping element keys to new text values
   *
   * @example
   * ```typescript
   * // Update all WPM displays at once
   * this.dom.updateMultipleText({
   *   wpmDisplay: `${wpm} WPM`,
   *   wpmValue: String(wpm),
   *   wpmInlineValue: String(wpm)
   * });
   *
   * // Update stats panel
   * this.dom.updateMultipleText({
   *   statsText: `Words: ${wordsRead} / ${totalWords}`,
   *   progressBar: `${percent}%`
   * });
   * ```
   */
  updateMultipleText(updates) {
    Object.entries(updates).forEach(([key, value]) => {
      if (value !== void 0) {
        this.updateText(key, value);
      }
    });
  }
  /**
   * Toggle visibility of multiple elements (batch visibility)
   *
   * Efficiently shows or hides multiple elements using CSS_CLASSES.hidden.
   * More readable than multiple individual toggleClass() calls.
   *
   * @param toggles - Object mapping element keys to visibility booleans (true = visible, false = hidden)
   *
   * @example
   * ```typescript
   * // Show play button, hide pause button
   * this.dom.toggleMultipleVisibility({
   *   playBtn: true,
   *   pauseBtn: false
   * });
   *
   * // Hide all panels
   * this.dom.toggleMultipleVisibility({
   *   controlsEl: false,
   *   settingsEl: false,
   *   statsEl: false
   * });
   * ```
   */
  toggleMultipleVisibility(toggles) {
    Object.entries(toggles).forEach(([key, visible]) => {
      if (typeof visible === "boolean") {
        this.toggleClass(key, CSS_CLASSES.hidden, !visible);
      }
    });
  }
};

// src/menu-builder.ts
var MenuBuilder = class {
  /**
   * Creates a dropdown menu near an anchor element
   *
   * @param options - Menu configuration
   * @returns The created menu element
   */
  static createMenu(options) {
    const {
      anchorEl,
      cssClass,
      title,
      items,
      onItemClick,
      showLevel = false,
      indentByLevel = false,
      timeoutManager
    } = options;
    const menu = document.body.createDiv({ cls: cssClass });
    const anchorRect = anchorEl.getBoundingClientRect();
    menu.style.top = `${anchorRect.bottom + 5}px`;
    if (cssClass.includes("heading-menu")) {
      const menuWidth = 300;
      const centerLeft = anchorRect.left + (anchorRect.width - menuWidth) / 2;
      const viewportWidth = window.innerWidth;
      const finalLeft = Math.max(10, Math.min(centerLeft, viewportWidth - menuWidth - 10));
      menu.style.left = `${finalLeft}px`;
    } else {
      menu.style.left = `${anchorRect.left}px`;
    }
    if (title) {
      menu.createDiv({
        text: title,
        cls: "dashreader-menu-title"
      });
    }
    items.forEach((item, index) => {
      const menuItem = menu.createDiv({
        cls: item.isCurrent ? "dashreader-menu-item dashreader-menu-item-current" : "dashreader-menu-item"
      });
      if (indentByLevel && item.level) {
        const indent = (item.level - 1) * 16;
        menuItem.style.paddingLeft = item.isCurrent ? `${8 + indent - 3}px` : `${8 + indent}px`;
      }
      if (showLevel && item.level) {
        menuItem.createSpan({
          text: `H${item.level}`,
          cls: "dashreader-outline-level"
        });
      } else if (!showLevel) {
        menuItem.createSpan({
          text: `${index + 1}.`,
          cls: "dashreader-outline-level"
        });
      }
      menuItem.createSpan({
        text: item.text,
        cls: "dashreader-outline-text"
      });
      menuItem.addEventListener("click", () => {
        onItemClick(item.wordIndex);
        menu.remove();
      });
    });
    const closeMenu = (e) => {
      if (!menu.contains(e.target)) {
        menu.remove();
        document.removeEventListener("click", closeMenu);
      }
    };
    timeoutManager.setTimeout(() => {
      document.addEventListener("click", closeMenu);
    }, 10);
    return menu;
  }
  /**
   * Scrolls to the current item in the menu (for outline menu)
   *
   * @param menu - The menu element
   * @param timeoutManager - Timeout manager for proper cleanup
   */
  static scrollToCurrentItem(menu, timeoutManager) {
    timeoutManager.setTimeout(() => {
      const currentItem = menu.querySelector(".dashreader-menu-item-current");
      if (currentItem) {
        currentItem.scrollIntoView({ block: "center" });
      }
    }, 10);
  }
};

// src/breadcrumb-manager.ts
var BreadcrumbManager = class {
  constructor(breadcrumbEl, engine, timeoutManager) {
    this.lastHeadingContext = null;
    /**
     * Callout icon mapping (consistent with WordDisplay)
     */
    this.calloutIcons = {
      note: "\u{1F4DD}",
      abstract: "\u{1F4C4}",
      info: "\u2139\uFE0F",
      tip: "\u{1F4A1}",
      success: "\u2705",
      question: "\u2753",
      warning: "\u26A0\uFE0F",
      failure: "\u274C",
      danger: "\u26A1",
      bug: "\u{1F41B}",
      example: "\u{1F4CB}",
      quote: "\u{1F4AC}"
    };
    this.breadcrumbEl = breadcrumbEl;
    this.engine = engine;
    this.timeoutManager = timeoutManager;
  }
  /**
   * Updates the breadcrumb navigation bar with current heading context
   * Shows hierarchical path (H1 > H2 > H3) and makes it clickable for navigation
   *
   * @param context - Current heading context from engine
   */
  updateBreadcrumb(context) {
    if (!context || context.breadcrumb.length === 0) {
      this.breadcrumbEl.toggleClass(CSS_CLASSES.hidden, true);
      return;
    }
    this.breadcrumbEl.toggleClass(CSS_CLASSES.hidden, false);
    this.breadcrumbEl.empty();
    this.breadcrumbEl.createSpan({
      text: "\u{1F4D1}",
      cls: "dashreader-breadcrumb-icon"
    });
    context.breadcrumb.forEach((heading, index) => {
      if (index > 0) {
        this.breadcrumbEl.createSpan({
          text: "\u203A",
          cls: "dashreader-breadcrumb-separator"
        });
      }
      const itemSpan = this.breadcrumbEl.createSpan({
        cls: "dashreader-breadcrumb-item"
      });
      const calloutMatch = heading.text.match(/^\[CALLOUT:([\w-]+)\]/);
      let displayText = heading.text;
      let icon = "";
      if (calloutMatch) {
        const calloutType = calloutMatch[1];
        icon = this.calloutIcons[calloutType.toLowerCase()] || "\u{1F4CC}";
        displayText = heading.text.replace(/^\[CALLOUT:[\w-]+\]/, "").trim();
      }
      itemSpan.textContent = icon ? `${icon} ${displayText}` : displayText;
      itemSpan.addEventListener("click", () => {
        this.navigateToHeading(heading.wordIndex);
      });
    });
    const dropdown = this.breadcrumbEl.createSpan({
      text: "\u25BC",
      cls: "dashreader-breadcrumb-dropdown"
    });
    dropdown.addEventListener("click", () => {
      this.showOutlineMenu(dropdown);
    });
    this.lastHeadingContext = context;
  }
  /**
   * Closes all open menus (outline menus)
   * Called before opening a new menu to ensure only one menu is visible
   */
  closeAllMenus() {
    document.querySelectorAll(".dashreader-outline-menu").forEach((menu) => {
      menu.remove();
    });
  }
  /**
   * Checks if heading context has changed (to avoid unnecessary updates)
   *
   * @param newContext - New heading context to check
   * @returns True if context has changed, false otherwise
   */
  hasHeadingContextChanged(newContext) {
    if (!this.lastHeadingContext)
      return true;
    if (this.lastHeadingContext.breadcrumb.length !== newContext.breadcrumb.length) {
      return true;
    }
    for (let i = 0; i < newContext.breadcrumb.length; i++) {
      if (this.lastHeadingContext.breadcrumb[i].wordIndex !== newContext.breadcrumb[i].wordIndex) {
        return true;
      }
    }
    return false;
  }
  /**
   * Shows outline menu with all headings in the document
   * Displays complete document structure with indentation by level
   * Highlights current position in the list
   *
   * @param anchorEl - The element to position the menu relative to
   */
  showOutlineMenu(anchorEl) {
    this.closeAllMenus();
    const allHeadings = this.engine.getHeadings();
    if (allHeadings.length === 0) {
      return;
    }
    const currentIndex = this.engine.getCurrentIndex();
    const relevantHeadings = allHeadings.filter((h) => h.wordIndex <= currentIndex);
    const currentHeading = relevantHeadings.length > 0 ? relevantHeadings[relevantHeadings.length - 1] : null;
    const menu = MenuBuilder.createMenu({
      anchorEl,
      cssClass: "dashreader-outline-menu",
      title: "Document Outline",
      items: allHeadings.map((h) => ({
        text: h.text,
        wordIndex: h.wordIndex,
        level: h.level,
        isCurrent: currentHeading ? h.wordIndex === currentHeading.wordIndex : false
      })),
      onItemClick: (wordIndex) => this.navigateToHeading(wordIndex),
      showLevel: true,
      indentByLevel: true,
      timeoutManager: this.timeoutManager
    });
    if (currentHeading) {
      MenuBuilder.scrollToCurrentItem(menu, this.timeoutManager);
    }
  }
  /**
   * Navigates to a specific heading by word index
   * Pauses playback, jumps to the heading position, and resumes if it was playing
   *
   * @param wordIndex - Word index to navigate to
   */
  navigateToHeading(wordIndex) {
    const wasPlaying = this.engine.getIsPlaying();
    if (wasPlaying) {
      this.engine.pause();
    }
    const currentIndex = this.engine.getCurrentIndex();
    const delta = wordIndex - currentIndex;
    if (delta < 0) {
      this.engine.rewind(Math.abs(delta));
    } else if (delta > 0) {
      this.engine.forward(delta);
    }
    if (wasPlaying) {
      this.engine.play();
    }
  }
  /**
   * Resets the breadcrumb state (for new text loading)
   */
  reset() {
    this.lastHeadingContext = null;
  }
};

// src/word-display.ts
var WordDisplay = class {
  constructor(wordEl, settings, displayArea) {
    /**
     * Callout icon mapping
     */
    this.calloutIcons = {
      note: "\u{1F4DD}",
      abstract: "\u{1F4C4}",
      info: "\u2139\uFE0F",
      tip: "\u{1F4A1}",
      success: "\u2705",
      question: "\u2753",
      warning: "\u26A0\uFE0F",
      failure: "\u274C",
      danger: "\u26A1",
      bug: "\u{1F41B}",
      example: "\u{1F4CB}",
      quote: "\u{1F4AC}"
    };
    this.wordEl = wordEl;
    this.settings = settings;
    this.baseFontSizePx = settings.fontSize;
    this.baseChunkSize = settings.chunkSize || 1;
    this.wordEl.empty();
    this.wordEl.style.position = "relative";
    this.wordEl.setAttribute("data-running", "false");
    this.overlayEl = this.wordEl.createDiv({ cls: "dashreader-focus-overlay" });
    this.overlayEl.createDiv({ cls: "dashreader-focus-lines" });
    this.focusDashesEl = this.overlayEl.createDiv({ cls: "dashreader-focus-dashes" });
    this.contentEl = this.wordEl.createDiv({ cls: "dashreader-word-content" });
    this.wordEl.style.setProperty("--dashreader-focus-left", "48%");
  }
  /**
   * Sets the display area reference (kept for API compatibility)
   */
  setDisplayArea(displayArea) {
  }
  /**
   * Sets base font size for calculations
   */
  setBaseFontSize(px) {
    this.baseFontSizePx = px;
  }
  /**
   * Sets chunk size for focus position calculations
   */
  setChunkSize(n) {
    this.baseChunkSize = Math.max(1, n);
  }
  /**
   * Updates settings (when user changes font size, etc.)
   */
  updateSettings(settings) {
    this.settings = settings;
    this.baseFontSizePx = settings.fontSize;
    this.baseChunkSize = settings.chunkSize || 1;
  }
  /**
   * Displays a word with optional heading level or callout type
   * Handles font size adjustment, icons, separators, and ORP anchoring
   */
  displayWord(word, headingLevel, showSeparator = false, calloutType) {
    let fontSizeMultiplier = 1;
    let fontWeight = "normal";
    let iconPrefix = "";
    if (calloutType) {
      fontSizeMultiplier = 1.2;
      fontWeight = "bold";
      iconPrefix = this.calloutIcons[calloutType.toLowerCase()] || "\u{1F4CC}";
    } else if (headingLevel > 0) {
      const multipliers = [
        0,
        HEADING_MULTIPLIERS.h1,
        HEADING_MULTIPLIERS.h2,
        HEADING_MULTIPLIERS.h3,
        HEADING_MULTIPLIERS.h4,
        HEADING_MULTIPLIERS.h5,
        HEADING_MULTIPLIERS.h6
      ];
      fontSizeMultiplier = multipliers[headingLevel] || 1;
      fontWeight = "bold";
    }
    const adjustedFontSize = this.baseFontSizePx * fontSizeMultiplier;
    const cleaned = this.stripMarkers(word).trim();
    const displayText = cleaned.length ? cleaned : word.trim();
    const chunkSize = Math.max(1, this.baseChunkSize);
    const center = 48;
    const left = 15;
    const maxChunkForFullShift = 5;
    const t = Math.min(1, Math.max(0, (chunkSize - 1) / (maxChunkForFullShift - 1)));
    const focus = center - t * (center - left);
    this.wordEl.style.setProperty("--dashreader-focus-left", `${focus}%`);
    this.wordEl.setAttribute("data-running", "true");
    this.wordEl.querySelectorAll(".dashreader-welcome-message, .dashreader-ready-message").forEach((el) => el.remove());
    this.contentEl.empty();
    const wordContainer = this.contentEl.createDiv({ cls: "dashreader-word-with-heading" });
    wordContainer.style.fontSize = `${adjustedFontSize}px`;
    wordContainer.style.fontWeight = fontWeight;
    if (iconPrefix) {
      wordContainer.createSpan({
        text: iconPrefix,
        cls: "dashreader-callout-icon"
      });
    }
    const viewport = wordContainer.createDiv({ cls: "dashreader-orp-viewport" });
    const line = viewport.createDiv({ cls: "dashreader-orp-line" });
    const orpEl = this.buildWordSpans(line, displayText);
    const focusWordEl = line.querySelector(".dashreader-focus-word");
    const shouldShrink = false;
    requestAnimationFrame(() => {
      wordContainer.style.fontSize = `${adjustedFontSize}px`;
      if (viewport.clientWidth === 0) {
        requestAnimationFrame(() => {
          wordContainer.style.fontSize = `${adjustedFontSize}px`;
          if (shouldShrink) {
            const minSize = Math.max(8, this.settings.minTokenFontSize || 12);
            this.shrinkFocusWordToFit(viewport, line, focusWordEl, orpEl, adjustedFontSize, minSize);
          }
          this.applyOrpAnchoring(viewport, line, orpEl);
        });
        return;
      }
      if (shouldShrink) {
        const minSize = Math.max(8, this.settings.minTokenFontSize || 12);
        this.shrinkFocusWordToFit(viewport, line, focusWordEl, orpEl, adjustedFontSize, minSize);
      }
      this.applyOrpAnchoring(viewport, line, orpEl);
    });
  }
  /**
   * Strip heading and callout markers from word
   */
  stripMarkers(rawWord) {
    return rawWord.replace(/^\[H\d\]/, "").replace(/^\[CALLOUT:[\w-]+\]/, "");
  }
  /**
   * Calculates the Optimal Recognition Point (ORP) index for a word
   * Based on the Squirt speed reading algorithm
   */
  getORPIndex(word) {
    const str = word.endsWith("\n") ? word.slice(0, -1) : word;
    const len = str.length;
    if (len <= 0)
      return 0;
    let point = 4;
    if (len < 2)
      point = 0;
    else if (len < 6)
      point = 1;
    else if (len < 10)
      point = 2;
    else if (len < 14)
      point = 3;
    const isLetterOrDigit = (ch) => !!ch && (/\d/.test(ch) || ch.toLowerCase() !== ch.toUpperCase());
    if (!isLetterOrDigit(str[point])) {
      if (isLetterOrDigit(str[point - 1]))
        point--;
      else if (isLetterOrDigit(str[point + 1]))
        point++;
    }
    if (point < 0)
      point = 0;
    if (point >= str.length)
      point = str.length - 1;
    return point;
  }
  /**
   * Builds spans for the word with ORP highlighting
   * Returns the ORP span element
   */
  buildWordSpans(lineEl, displayWord) {
    lineEl.empty();
    if (!displayWord || displayWord === "\n")
      return null;
    const focusWordEl = lineEl.createSpan({ cls: "dashreader-focus-word" });
    const orpIndex = this.getORPIndex(displayWord);
    for (let i = 0; i < displayWord.length; i++) {
      const ch = displayWord.charAt(i);
      const span = focusWordEl.createSpan({ text: ch });
      if (i === orpIndex) {
        span.addClass("dashreader-highlight");
        span.addClass("dashreader-orp");
      }
    }
    return focusWordEl.querySelector(".dashreader-orp");
  }
  /**
   * Applies ORP anchoring by shifting the line so ORP aligns with the focus dashes.
   * Uses viewport-local coordinates like the fork does.
   */
  applyOrpAnchoring(viewportEl, lineEl, orpEl) {
    if (!orpEl) {
      lineEl.style.transform = "translateX(0px)";
      return;
    }
    lineEl.style.transform = "translateX(0px)";
    const viewportRect = viewportEl.getBoundingClientRect();
    if (viewportRect.width === 0) {
      lineEl.style.transform = "translateX(0px)";
      return;
    }
    const focusRect = this.focusDashesEl.getBoundingClientRect();
    if (focusRect.width === 0) {
      const orpCenterInLine2 = orpEl.offsetLeft + orpEl.offsetWidth / 2;
      const lineLeft2 = lineEl.offsetLeft;
      const viewportCenter = viewportRect.width / 2;
      const delta2 = viewportCenter - (lineLeft2 + orpCenterInLine2);
      const maxDelta2 = viewportRect.width / 2;
      const clampedDelta2 = Math.max(-maxDelta2, Math.min(maxDelta2, delta2));
      lineEl.style.transform = `translateX(${Math.round(clampedDelta2)}px)`;
      return;
    }
    const focusX = focusRect.left + focusRect.width / 2 - viewportRect.left;
    const lineLeft = lineEl.offsetLeft;
    const orpCenterInLine = orpEl.offsetLeft + orpEl.offsetWidth / 2;
    const delta = focusX - (lineLeft + orpCenterInLine);
    const maxDelta = viewportRect.width;
    const clampedDelta = Math.max(-maxDelta, Math.min(maxDelta, delta));
    lineEl.style.transform = `translateX(${Math.round(clampedDelta)}px)`;
  }
  /**
   * Binary-search shrink for a single token if it overflows the viewport
   */
  shrinkFocusWordToFit(viewportEl, lineEl, focusWordEl, orpEl, startSize, minSize) {
    if (!focusWordEl || !orpEl)
      return startSize;
    const prevTransition = focusWordEl.style.transition;
    focusWordEl.style.transition = "none";
    const fitsFocusWord = () => {
      const vw = viewportEl.clientWidth;
      if (vw <= 0)
        return true;
      const viewportRect = viewportEl.getBoundingClientRect();
      const fRect = this.focusDashesEl.getBoundingClientRect();
      const focusX = fRect.left + fRect.width / 2 - viewportRect.left;
      if (focusX < 0 || focusX > vw)
        return true;
      const orpCenter = orpEl.offsetLeft + orpEl.offsetWidth / 2;
      const wordLeft = focusWordEl.offsetLeft;
      const wordRight = wordLeft + focusWordEl.offsetWidth;
      const leftDist = orpCenter - wordLeft;
      const rightDist = wordRight - orpCenter;
      const leftEdge = focusX - leftDist;
      const rightEdge = focusX + rightDist;
      return leftEdge >= 0 && rightEdge <= vw;
    };
    focusWordEl.style.fontSize = `${startSize}px`;
    lineEl.getBoundingClientRect();
    if (fitsFocusWord()) {
      focusWordEl.style.transition = prevTransition;
      return startSize;
    }
    let lo = Math.max(8, minSize);
    let hi = startSize;
    let best = lo;
    while (lo <= hi) {
      const mid = Math.floor((lo + hi) / 2);
      focusWordEl.style.fontSize = `${mid}px`;
      lineEl.getBoundingClientRect();
      if (fitsFocusWord()) {
        best = mid;
        lo = mid + 1;
      } else {
        hi = mid - 1;
      }
    }
    focusWordEl.style.fontSize = `${best}px`;
    lineEl.getBoundingClientRect();
    focusWordEl.style.transition = prevTransition;
    return best;
  }
  /**
   * Displays a welcome message (no text loaded)
   */
  displayWelcomeMessage(icon, mainText, subText) {
    this.contentEl.empty();
    this.wordEl.setAttribute("data-running", "false");
    const welcomeDiv = this.contentEl.createDiv({ cls: "dashreader-welcome-message" });
    welcomeDiv.createDiv({
      text: `${icon} ${mainText}`,
      cls: "dashreader-welcome-icon"
    });
    welcomeDiv.createDiv({
      text: subText,
      cls: "dashreader-welcome-instruction"
    });
  }
  /**
   * Displays a ready message (text loaded, ready to start)
   */
  displayReadyMessage(wordsToRead, totalWords, startIndex, durationText, fileName, lineNumber) {
    this.contentEl.empty();
    this.wordEl.setAttribute("data-running", "false");
    const readyDiv = this.contentEl.createDiv({ cls: "dashreader-ready-message" });
    if (fileName) {
      const sourceDiv = readyDiv.createDiv({ cls: "dashreader-ready-source" });
      sourceDiv.createSpan({ text: "\u{1F4C4} " });
      sourceDiv.createSpan({ text: fileName });
      if (lineNumber) {
        sourceDiv.createSpan({ text: ` (line ${lineNumber})` });
      }
    }
    const mainText = readyDiv.createSpan();
    mainText.createSpan({ text: `Ready to read ${wordsToRead} words` });
    if (startIndex !== void 0 && startIndex > 0) {
      const startInfo = mainText.createSpan({ cls: "dashreader-ready-start-info" });
      startInfo.setText(` (starting at word ${startIndex + 1}/${totalWords})`);
    }
    readyDiv.createEl("br");
    readyDiv.createSpan({
      text: `Estimated time: ~${durationText}`,
      cls: "dashreader-ready-duration"
    });
    readyDiv.createEl("br");
    readyDiv.createSpan({
      text: "Press Shift+Space to start",
      cls: "dashreader-ready-duration"
    });
  }
  /**
   * Clears the word display
   */
  clear() {
    this.contentEl.empty();
    this.wordEl.setAttribute("data-running", "false");
  }
};

// src/hotkey-handler.ts
var HotkeyHandler = class {
  constructor(settings, callbacks) {
    this.settings = settings;
    this.callbacks = callbacks;
  }
  /**
   * Updates settings (when user changes hotkey preferences)
   *
   * @param settings - New settings to apply
   */
  updateSettings(settings) {
    this.settings = settings;
  }
  /**
   * Handles keyboard events
   * Called from keydown event listener in the view
   *
   * @param e - Keyboard event
   */
  handleKeyPress(e) {
    const keyCode = e.code || e.key;
    if (keyCode === "Space" && e.shiftKey) {
      e.preventDefault();
      this.callbacks.onTogglePlay();
      return;
    }
    if (this.isInputFocused()) {
      return;
    }
    if (keyCode === this.settings.hotkeyRewind) {
      e.preventDefault();
      this.callbacks.onRewind();
      return;
    }
    if (keyCode === this.settings.hotkeyForward) {
      e.preventDefault();
      this.callbacks.onForward();
      return;
    }
    if (keyCode === this.settings.hotkeyIncrementWpm) {
      e.preventDefault();
      this.callbacks.onIncrementWpm();
      return;
    }
    if (keyCode === this.settings.hotkeyDecrementWpm) {
      e.preventDefault();
      this.callbacks.onDecrementWpm();
      return;
    }
    if (keyCode === this.settings.hotkeyQuit) {
      e.preventDefault();
      this.callbacks.onQuit();
      return;
    }
  }
  /**
   * Checks if an input element is currently focused
   * Prevents hotkeys from interfering with typing
   *
   * @returns True if input/textarea is focused
   */
  isInputFocused() {
    const activeElement = document.activeElement;
    if (!activeElement)
      return false;
    const tagName = activeElement.tagName.toLowerCase();
    return tagName === "input" || tagName === "textarea";
  }
};

// src/services/stats-formatter.ts
var StatsFormatter = class {
  /**
   * Format time in seconds to MM:SS format
   *
   * @param seconds - Time in seconds
   * @returns Formatted time string (MM:SS)
   *
   * @example
   * ```typescript
   * formatTime(0);    // "0:00"
   * formatTime(45);   // "0:45"
   * formatTime(90);   // "1:30"
   * formatTime(3661); // "61:01"
   * ```
   */
  formatTime(seconds) {
    const mins = Math.floor(seconds / 60);
    const secs = seconds % 60;
    return `${mins}:${secs.toString().padStart(2, "0")}`;
  }
  /**
   * Format reading statistics for display during reading
   *
   * Shows: words read/total, elapsed time, current WPM, remaining time
   *
   * @param stats - Reading statistics
   * @returns Formatted stats string
   *
   * @example
   * ```typescript
   * formatReadingStats({
   *   wordsRead: 150,
   *   totalWords: 500,
   *   elapsedTime: 45,
   *   currentWpm: 200,
   *   remainingTime: 105
   * });
   * // Returns: "150/500 words | 0:45 | 200 WPM | 1:45 left"
   * ```
   */
  formatReadingStats(stats) {
    const { wordsRead, totalWords, elapsedTime, currentWpm, remainingTime } = stats;
    return [
      `${wordsRead}/${totalWords} words`,
      this.formatTime(elapsedTime),
      `${currentWpm} WPM`,
      `${this.formatTime(remainingTime)} left`
    ].join(" | ");
  }
  /**
   * Format loaded statistics for display after loading text
   *
   * Shows: words loaded, estimated duration, file info, instructions
   *
   * @param stats - Loaded statistics
   * @returns Formatted stats string
   *
   * @example
   * ```typescript
   * // From beginning
   * formatLoadedStats({
   *   remainingWords: 500,
   *   totalWords: 500,
   *   estimatedDuration: 150
   * });
   * // Returns: "500 words loaded - ~2:30 - Shift+Space to start"
   *
   * // From cursor position
   * formatLoadedStats({
   *   remainingWords: 300,
   *   totalWords: 500,
   *   estimatedDuration: 90,
   *   fileName: 'document.md',
   *   startWordIndex: 200
   * });
   * // Returns: "300/500 words loaded from document.md - ~1:30 - Shift+Space to start"
   * ```
   */
  formatLoadedStats(stats) {
    const { remainingWords, totalWords, estimatedDuration, fileName, startWordIndex } = stats;
    const wordInfo = startWordIndex && startWordIndex > 0 ? `${remainingWords}/${totalWords} words` : `${totalWords} words`;
    const fileInfo = fileName ? ` from ${fileName}` : "";
    const durationText = this.formatTime(estimatedDuration);
    return `${wordInfo} loaded${fileInfo} - ~${durationText} - Shift+Space to start`;
  }
  /**
   * Format word count for display
   *
   * @param wordsRead - Words read so far
   * @param totalWords - Total words in document
   * @returns Formatted word count string
   *
   * @example
   * ```typescript
   * formatWordCount(150, 500);  // "150/500 words"
   * formatWordCount(0, 500);    // "0/500 words"
   * formatWordCount(500, 500);  // "500/500 words"
   * ```
   */
  formatWordCount(wordsRead, totalWords) {
    return `${wordsRead}/${totalWords} words`;
  }
  /**
   * Format WPM (words per minute) for display
   *
   * @param wpm - Words per minute
   * @returns Formatted WPM string
   *
   * @example
   * ```typescript
   * formatWpm(200);  // "200 WPM"
   * formatWpm(350);  // "350 WPM"
   * ```
   */
  formatWpm(wpm) {
    return `${wpm} WPM`;
  }
};

// src/minimap-manager.ts
var MinimapManager = class {
  constructor(containerEl, engine, timeoutManager, orientation = "vertical") {
    this.positionIndicatorEl = null;
    this.currentWordIndex = 0;
    this.totalWords = 0;
    this.containerEl = containerEl;
    this.engine = engine;
    this.timeoutManager = timeoutManager;
    this.orientation = orientation;
    this.statsFormatter = new StatsFormatter();
    this.minimapEl = this.containerEl.createDiv({
      cls: `dashreader-minimap dashreader-minimap-${orientation}`
    });
    this.progressEl = this.minimapEl.createDiv({
      cls: "dashreader-minimap-progress"
    });
    if (orientation === "vertical") {
      this.minimapEl.createDiv({
        cls: "dashreader-minimap-line"
      });
    } else {
      this.positionIndicatorEl = this.minimapEl.createDiv({
        cls: "dashreader-minimap-position"
      });
      this.minimapEl.addEventListener("click", (e) => this.handleTimelineClick(e));
      this.minimapEl.addEventListener("mousemove", (e) => this.handleTimelineHover(e));
      this.minimapEl.addEventListener("mouseleave", () => this.hideTooltip());
    }
    this.tooltipEl = document.body.createDiv({
      cls: "dashreader-minimap-tooltip"
    });
  }
  /**
   * Render the minimap with heading points/sections
   * Called when text is loaded or structure changes
   */
  render() {
    if (!this.minimapEl)
      return;
    const existingElements = this.minimapEl.querySelectorAll(".dashreader-minimap-point, .dashreader-minimap-section");
    existingElements.forEach((el) => el.remove());
    const headings = this.engine.getHeadings();
    this.totalWords = this.engine.getTotalWords();
    if (this.totalWords === 0) {
      this.minimapEl.toggleClass(CSS_CLASSES.hidden, true);
      return;
    }
    this.minimapEl.toggleClass(CSS_CLASSES.hidden, false);
    if (this.orientation === "horizontal") {
      this.renderHorizontal(headings);
    } else {
      this.renderVertical(headings);
    }
    this.updateCurrentPosition(this.currentWordIndex);
  }
  /**
   * Render vertical minimap with points
   */
  renderVertical(headings) {
    if (headings.length === 0)
      return;
    headings.forEach((heading, index) => {
      this.createPoint(heading, index);
    });
  }
  /**
   * Render horizontal minimap with sections and heading labels
   */
  renderHorizontal(headings) {
    const sections = [];
    if (headings.length === 0) {
      sections.push({ start: 0, end: this.totalWords, heading: null });
    } else {
      if (headings[0].wordIndex > 0) {
        sections.push({ start: 0, end: headings[0].wordIndex, heading: null });
      }
      for (let i = 0; i < headings.length; i++) {
        const start = headings[i].wordIndex;
        const end = i < headings.length - 1 ? headings[i + 1].wordIndex : this.totalWords;
        sections.push({ start, end, heading: headings[i] });
      }
    }
    sections.forEach((section) => {
      const sectionEl = this.minimapEl.createDiv({
        cls: "dashreader-minimap-section"
      });
      const widthPercent = (section.end - section.start) / this.totalWords * 100;
      sectionEl.style.width = `${widthPercent}%`;
      sectionEl.setAttribute("data-start", section.start.toString());
      sectionEl.setAttribute("data-end", section.end.toString());
      if (section.heading) {
        sectionEl.setAttribute("data-level", section.heading.level.toString());
        sectionEl.setAttribute("data-heading-text", section.heading.text);
        sectionEl.classList.add("dashreader-minimap-section-heading");
        const labelEl = sectionEl.createDiv({
          cls: "dashreader-minimap-section-label",
          text: section.heading.text
        });
        labelEl.setAttribute("data-level", section.heading.level.toString());
      }
    });
  }
  /**
   * Create a point for a heading
   */
  createPoint(heading, index) {
    const point = this.minimapEl.createDiv({
      cls: "dashreader-minimap-point"
    });
    const percentage = heading.wordIndex / this.totalWords * 100;
    point.style.top = `${percentage}%`;
    point.setAttribute("data-level", heading.level.toString());
    point.setAttribute("data-index", index.toString());
    point.setAttribute("data-word-index", heading.wordIndex.toString());
    point.setAttribute("data-heading-text", heading.text);
    point.addEventListener("click", (e) => {
      e.stopPropagation();
      this.navigateToHeading(heading.wordIndex);
    });
    point.addEventListener("mouseenter", () => {
      this.showTooltip(heading.text, point);
    });
    point.addEventListener("mouseleave", () => {
      this.hideTooltip();
    });
  }
  /**
   * Update which point/section is highlighted as current
   */
  updateCurrentPosition(wordIndex) {
    this.currentWordIndex = wordIndex;
    if (!this.minimapEl)
      return;
    const progressPercentage = this.totalWords > 0 ? wordIndex / this.totalWords * 100 : 0;
    if (this.orientation === "horizontal") {
      if (this.progressEl) {
        this.progressEl.style.width = `${Math.min(100, Math.max(0, progressPercentage))}%`;
      }
      if (this.positionIndicatorEl) {
        this.positionIndicatorEl.style.left = `${Math.min(100, Math.max(0, progressPercentage))}%`;
      }
      const sections = this.minimapEl.querySelectorAll(".dashreader-minimap-section");
      sections.forEach((section) => {
        const start = parseInt(section.getAttribute("data-start") || "0");
        const end = parseInt(section.getAttribute("data-end") || "0");
        if (wordIndex >= start && wordIndex < end) {
          section.classList.add("dashreader-minimap-section-current");
        } else {
          section.classList.remove("dashreader-minimap-section-current");
        }
      });
    } else {
      if (this.progressEl) {
        this.progressEl.style.height = `${Math.min(100, Math.max(0, progressPercentage))}%`;
      }
      const headings = this.engine.getHeadings();
      if (headings.length === 0)
        return;
      const relevantHeadings = headings.filter((h) => h.wordIndex <= wordIndex);
      const currentHeading = relevantHeadings.length > 0 ? relevantHeadings[relevantHeadings.length - 1] : null;
      const points = this.minimapEl.querySelectorAll(".dashreader-minimap-point");
      points.forEach((point) => {
        const pointWordIndex = parseInt(point.getAttribute("data-word-index") || "0");
        if (currentHeading && pointWordIndex === currentHeading.wordIndex) {
          point.classList.add("dashreader-minimap-point-current");
        } else {
          point.classList.remove("dashreader-minimap-point-current");
        }
      });
    }
  }
  /**
   * Handle click on horizontal timeline
   */
  handleTimelineClick(e) {
    if (this.totalWords === 0)
      return;
    const rect = this.minimapEl.getBoundingClientRect();
    const clickX = e.clientX - rect.left;
    const ratio = clickX / rect.width;
    const targetIndex = Math.floor(ratio * this.totalWords);
    this.navigateToHeading(Math.max(0, Math.min(targetIndex, this.totalWords - 1)));
  }
  /**
   * Handle hover on horizontal timeline (show tooltip with time/heading)
   */
  handleTimelineHover(e) {
    if (this.totalWords === 0)
      return;
    const rect = this.minimapEl.getBoundingClientRect();
    const hoverX = e.clientX - rect.left;
    const ratio = hoverX / rect.width;
    const hoverIndex = Math.floor(ratio * this.totalWords);
    const timeAtIndex = this.engine.getVirtualElapsedSecondsAtIndex(hoverIndex);
    const totalTime = this.engine.getVirtualTotalSeconds();
    const timeText = `${this.statsFormatter.formatTime(timeAtIndex)} / ${this.statsFormatter.formatTime(totalTime)}`;
    const headings = this.engine.getHeadings();
    const relevantHeadings = headings.filter((h) => h.wordIndex <= hoverIndex);
    const heading = relevantHeadings.length > 0 ? relevantHeadings[relevantHeadings.length - 1] : null;
    let tooltipText = timeText;
    if (heading) {
      const cleanHeading = heading.text.replace(/^\[H\d\]/, "").replace(/^\[CALLOUT:[\w-]+\]/, "").trim();
      tooltipText = `${cleanHeading} \u2022 ${timeText}`;
    }
    this.tooltipEl.textContent = tooltipText;
    this.tooltipEl.style.left = `${e.clientX}px`;
    this.tooltipEl.style.top = `${rect.top - 40}px`;
    this.tooltipEl.classList.add("visible");
  }
  /**
   * Navigate to a specific word index
   */
  navigateToHeading(wordIndex) {
    const wasPlaying = this.engine.getIsPlaying();
    this.engine.goToIndex(wordIndex);
    if (wasPlaying) {
      this.timeoutManager.setTimeout(() => {
        this.engine.play();
      }, 300);
    }
  }
  /**
   * Show tooltip with heading text (slides from right)
   */
  showTooltip(text, pointEl) {
    if (!this.tooltipEl)
      return;
    const cleanText = text.replace(/^\[H\d\]/, "").replace(/^\[CALLOUT:[\w-]+\]/, "").trim();
    this.tooltipEl.textContent = cleanText;
    const pointRect = pointEl.getBoundingClientRect();
    const tooltipHeight = 32;
    this.tooltipEl.style.top = `${pointRect.top + pointRect.height / 2 - tooltipHeight / 2}px`;
    this.tooltipEl.classList.add("visible");
  }
  /**
   * Hide tooltip
   */
  hideTooltip() {
    if (!this.tooltipEl)
      return;
    this.tooltipEl.classList.remove("visible");
  }
  /**
   * Show the minimap
   */
  show() {
    if (this.minimapEl) {
      this.minimapEl.toggleClass(CSS_CLASSES.hidden, false);
    }
  }
  /**
   * Hide the minimap
   */
  hide() {
    if (this.minimapEl) {
      this.minimapEl.toggleClass(CSS_CLASSES.hidden, true);
    }
  }
  /**
   * Setup wheel navigation on the minimap
   * @param onForward - Callback when scrolling forward (down)
   * @param onBackward - Callback when scrolling backward (up)
   */
  setupWheelNavigation(onForward, onBackward) {
    let wheelAccum = 0;
    let wheelDir = 0;
    const WHEEL_THRESHOLD = 80;
    this.minimapEl.addEventListener("wheel", (e) => {
      if (e.ctrlKey || e.metaKey)
        return;
      e.preventDefault();
      let dy = e.deltaY;
      if (e.deltaMode === 1) {
        dy *= 16;
      } else if (e.deltaMode === 2) {
        dy *= 800;
      }
      const dir = Math.sign(dy);
      if (dir !== 0 && dir !== wheelDir) {
        wheelAccum = 0;
        wheelDir = dir;
      }
      wheelAccum += dy;
      if (wheelAccum >= WHEEL_THRESHOLD) {
        wheelAccum -= WHEEL_THRESHOLD;
        wheelAccum = Math.min(wheelAccum, WHEEL_THRESHOLD - 1);
        onForward();
      } else if (wheelAccum <= -WHEEL_THRESHOLD) {
        wheelAccum += WHEEL_THRESHOLD;
        wheelAccum = Math.max(wheelAccum, -(WHEEL_THRESHOLD - 1));
        onBackward();
      }
    }, { passive: false });
  }
  /**
   * Clean up
   */
  destroy() {
    if (this.minimapEl) {
      this.minimapEl.remove();
    }
    if (this.tooltipEl) {
      this.tooltipEl.remove();
    }
  }
};

// src/services/timeout-manager.ts
var TimeoutManager = class {
  constructor() {
    this.timeouts = /* @__PURE__ */ new Map();
    this.intervals = /* @__PURE__ */ new Map();
  }
  /**
   * Create a timeout that will be automatically tracked
   *
   * @param callback - Function to execute after delay
   * @param delay - Delay in milliseconds
   * @returns Timeout ID (can be used with clearTimeout)
   *
   * @example
   * ```typescript
   * const id = this.timeoutManager.setTimeout(() => {
   *   console.log('Hello!');
   * }, 1000);
   * ```
   */
  setTimeout(callback, delay) {
    const id = window.setTimeout(() => {
      callback();
      this.timeouts.delete(id);
    }, delay);
    this.timeouts.set(id, id);
    return id;
  }
  /**
   * Create an interval that will be automatically tracked
   *
   * @param callback - Function to execute repeatedly
   * @param delay - Delay between executions in milliseconds
   * @returns Interval ID (can be used with clearInterval)
   *
   * @example
   * ```typescript
   * const id = this.timeoutManager.setInterval(() => {
   *   console.log('Tick');
   * }, 1000);
   * ```
   */
  setInterval(callback, delay) {
    const id = window.setInterval(callback, delay);
    this.intervals.set(id, id);
    return id;
  }
  /**
   * Clear a specific timeout
   *
   * @param id - Timeout ID returned by setTimeout
   *
   * @example
   * ```typescript
   * const id = this.timeoutManager.setTimeout(...);
   * this.timeoutManager.clearTimeout(id); // Cancel it
   * ```
   */
  clearTimeout(id) {
    window.clearTimeout(id);
    this.timeouts.delete(id);
  }
  /**
   * Clear a specific interval
   *
   * @param id - Interval ID returned by setInterval
   *
   * @example
   * ```typescript
   * const id = this.timeoutManager.setInterval(...);
   * this.timeoutManager.clearInterval(id); // Stop it
   * ```
   */
  clearInterval(id) {
    window.clearInterval(id);
    this.intervals.delete(id);
  }
  /**
   * Clear all pending timeouts and intervals
   *
   * IMPORTANT: Call this in your component's destroy/cleanup method
   * to prevent memory leaks.
   *
   * @example
   * ```typescript
   * destroy() {
   *   this.timeoutManager.clearAll();
   * }
   * ```
   */
  clearAll() {
    this.timeouts.forEach((id) => window.clearTimeout(id));
    this.timeouts.clear();
    this.intervals.forEach((id) => window.clearInterval(id));
    this.intervals.clear();
  }
  /**
   * Get the number of active timers (for debugging/testing)
   *
   * @returns Number of active timeouts + intervals
   *
   * @example
   * ```typescript
   * console.log(`Active timers: ${this.timeoutManager.activeCount}`);
   * ```
   */
  get activeCount() {
    return this.timeouts.size + this.intervals.size;
  }
  /**
   * Get the number of active timeouts only (for debugging/testing)
   */
  get activeTimeouts() {
    return this.timeouts.size;
  }
  /**
   * Get the number of active intervals only (for debugging/testing)
   */
  get activeIntervals() {
    return this.intervals.size;
  }
};

// src/fullscreen-modal.ts
var import_obsidian2 = require("obsidian");

// src/ui-builders.ts
var import_obsidian = require("obsidian");
function createButton(parent, config) {
  const className = config.className ? `${CSS_CLASSES.btn} ${config.className}` : CSS_CLASSES.btn;
  const btn = parent.createEl("button", {
    cls: className,
    attr: {
      title: config.title,
      "aria-label": config.title,
      type: "button"
    }
  });
  if (config.icon.startsWith("lucide:")) {
    (0, import_obsidian.setIcon)(btn, config.icon.slice("lucide:".length));
  } else {
    btn.setText(config.icon);
  }
  btn.addEventListener("click", config.onClick);
  return btn;
}
function createNumberControl(parent, config, registry) {
  const container = parent.createDiv({ cls: CSS_CLASSES.controlGroup });
  container.createEl("span", {
    text: config.label,
    cls: CSS_CLASSES.controlLabel
  });
  createButton(container, {
    icon: config.decrementIcon || ICONS.decrement,
    title: config.decrementTitle || `Decrease (${config.increment || 1})`,
    onClick: config.onDecrement,
    className: CSS_CLASSES.smallBtn
  });
  const valueEl = container.createEl("span", {
    text: String(config.value),
    cls: config.registryKey || "value-display"
  });
  if (config.registryKey && registry) {
    registry.register(config.registryKey, valueEl);
  }
  createButton(container, {
    icon: config.incrementIcon || ICONS.increment,
    title: config.incrementTitle || `Increase (+${config.increment || 1})`,
    onClick: config.onIncrement,
    className: CSS_CLASSES.smallBtn
  });
  return { container, valueEl };
}
function createToggleControl(parent, config) {
  const container = parent.createDiv({ cls: CSS_CLASSES.settingGroup });
  const toggle = container.createEl("label", { cls: CSS_CLASSES.settingToggle });
  const checkbox = toggle.createEl("input", { type: "checkbox" });
  checkbox.checked = config.checked;
  checkbox.addEventListener("change", () => {
    config.onChange(checkbox.checked);
  });
  toggle.createEl("span", { text: ` ${config.label}` });
  return { container, checkbox };
}
function createPlayPauseButtons(parent, onPlay, onPause, registry) {
  const playBtn = createButton(parent, {
    icon: ICONS.play,
    title: "Play (Shift+Space)",
    onClick: onPlay,
    className: CSS_CLASSES.playBtn
  });
  const pauseBtn = createButton(parent, {
    icon: ICONS.pause,
    title: "Pause (Shift+Space)",
    onClick: onPause,
    className: `${CSS_CLASSES.pauseBtn} ${CSS_CLASSES.hidden}`
  });
  registry.register("playBtn", playBtn);
  registry.register("pauseBtn", pauseBtn);
}
function updatePlayPauseButtons(registry, isPlaying) {
  if (isPlaying) {
    registry.addClass("playBtn", CSS_CLASSES.hidden);
    registry.removeClass("pauseBtn", CSS_CLASSES.hidden);
  } else {
    registry.removeClass("playBtn", CSS_CLASSES.hidden);
    registry.addClass("pauseBtn", CSS_CLASSES.hidden);
  }
}

// src/fullscreen-modal.ts
var FullscreenModal = class extends import_obsidian2.Modal {
  constructor(app, engine, settings, onModalClose, timeoutManager) {
    super(app);
    this.originalOnWordChange = null;
    this.originalOnComplete = null;
    /**
     * Sets up wheel/trackpad navigation for word-by-word scrubbing
     * Based on fork implementation for smooth, responsive scrolling
     * Only works when paused
     */
    // Timer for resuming after scroll navigation
    this.scrollResumeTimerId = null;
    this.SCROLL_RESUME_DELAY = 800;
    // ms before resuming after scroll
    // Timer for updating stats display every second during playback
    this.statsIntervalId = null;
    this.STATS_UPDATE_INTERVAL = 1e3;
    this.engine = engine;
    this.settings = settings;
    this.onModalClose = onModalClose;
    this.timeoutManager = timeoutManager;
    this.wasPlayingOnOpen = engine.getIsPlaying();
    this.statsFormatter = new StatsFormatter();
    this.dom = new DOMRegistry();
  }
  onOpen() {
    this.originalOnWordChange = this.engine.getOnWordChangeCallback();
    this.originalOnComplete = this.engine.getOnCompleteCallback();
    this.modalEl.addClass("dashreader-fullscreen-modal");
    this.containerEl.addClass("dashreader-fullscreen-backdrop");
    this.buildFullscreenUI();
    this.wordDisplay = new WordDisplay(this.wordEl, this.settings, this.displayArea);
    const fullscreenFontSize = this.engine.getEffectiveFontSize() * 2;
    this.wordDisplay.setBaseFontSize(fullscreenFontSize);
    this.breadcrumbManager = new BreadcrumbManager(
      this.breadcrumbEl,
      this.engine,
      this.timeoutManager
    );
    this.hotkeyHandler = new HotkeyHandler(this.settings, {
      onTogglePlay: () => this.togglePlay(),
      onRewind: () => this.engine.rewind(),
      onForward: () => this.engine.forward(),
      onIncrementWpm: () => this.changeWpm(10),
      onDecrementWpm: () => this.changeWpm(-10),
      onQuit: () => this.close()
    });
    this.engine.setCallbacks(
      this.onWordChange.bind(this),
      this.onComplete.bind(this)
    );
    this.setupKeyboardEvents();
    this.setupWheelNavigation();
    this.displayCurrentState();
    const currentIndex = this.engine.getCurrentIndex();
    const context = this.engine.getCurrentHeadingContext(currentIndex);
    if (context.breadcrumb.length > 0) {
      this.breadcrumbManager.updateBreadcrumb(context);
    }
    if (this.wasPlayingOnOpen && !this.engine.getIsPlaying()) {
      this.engine.play();
    }
    if (this.engine.getIsPlaying()) {
      this.startStatsTimer();
    }
    this.updatePlayPauseIcon();
  }
  onClose() {
    var _a, _b;
    if (this.scrollResumeTimerId) {
      clearTimeout(this.scrollResumeTimerId);
      this.scrollResumeTimerId = null;
    }
    this.stopStatsTimer();
    if (this.engine.getIsPlaying()) {
      this.engine.pause();
    }
    if (this.originalOnWordChange || this.originalOnComplete) {
      this.engine.setCallbacks(
        (_a = this.originalOnWordChange) != null ? _a : () => {
        },
        (_b = this.originalOnComplete) != null ? _b : () => {
        }
      );
    }
    if (this.minimapManager) {
      this.minimapManager.destroy();
    }
    this.dom.clear();
    this.onModalClose();
  }
  /**
   * Builds the fullscreen UI layout
   */
  buildFullscreenUI() {
    const { contentEl } = this;
    contentEl.empty();
    contentEl.addClass("dashreader-fullscreen-content");
    const settingsBtn = contentEl.createDiv({ cls: "dashreader-fullscreen-settings-btn" });
    (0, import_obsidian2.setIcon)(settingsBtn, "settings");
    settingsBtn.setAttribute("aria-label", "Settings");
    settingsBtn.addEventListener("click", () => this.toggleSettingsPanel());
    this.breadcrumbEl = contentEl.createDiv({
      cls: "dashreader-breadcrumb dashreader-fullscreen-breadcrumb"
    });
    this.displayArea = contentEl.createDiv({ cls: "dashreader-fullscreen-display" });
    this.wordEl = this.displayArea.createDiv({ cls: "dashreader-fullscreen-word" });
    const fullscreenInitFontSize = this.engine.getEffectiveFontSize() * 2;
    this.wordEl.style.fontSize = `${fullscreenInitFontSize}px`;
    this.wordEl.style.fontFamily = this.settings.fontFamily;
    this.wordEl.style.color = this.settings.fontColor;
    this.dom.register("wordEl", this.wordEl);
    if (this.settings.showFocusBars) {
      this.wordEl.addClass("dashreader-focus-enabled");
    }
    this.statsEl = contentEl.createDiv({ cls: "dashreader-fullscreen-stats-row" });
    this.statsLeftEl = this.statsEl.createDiv({ cls: "dashreader-fullscreen-stats-left" });
    this.statsRightEl = this.statsEl.createDiv({ cls: "dashreader-fullscreen-stats-right" });
    this.dom.register("statsLeftEl", this.statsLeftEl);
    this.dom.register("statsRightEl", this.statsRightEl);
    this.minimapContainer = contentEl.createDiv({
      cls: "dashreader-fullscreen-minimap-container"
    });
    this.minimapManager = new MinimapManager(
      this.minimapContainer,
      this.engine,
      this.timeoutManager,
      "horizontal"
    );
    this.minimapManager.render();
    this.setupMinimapInteraction();
    this.controlsEl = contentEl.createDiv({ cls: "dashreader-fullscreen-controls" });
    this.buildControls();
  }
  /**
   * Builds playback controls and settings panel
   */
  buildControls() {
    const controlGroup = this.controlsEl.createDiv({ cls: CSS_CLASSES.controlGroup });
    createButton(controlGroup, {
      icon: ICONS.arrowLeft,
      title: "Previous heading (\u2190)",
      onClick: () => this.jumpHeading("up"),
      className: CSS_CLASSES.toggleBtn
    });
    const playPauseBtn = controlGroup.createEl("button", {
      cls: `${CSS_CLASSES.btn} ${CSS_CLASSES.toggleBtn}`,
      attr: {
        title: "Play/Pause (Shift+Space)",
        "aria-label": "Play/Pause",
        type: "button"
      }
    });
    (0, import_obsidian2.setIcon)(playPauseBtn, this.engine.getIsPlaying() ? "pause" : "play");
    playPauseBtn.addEventListener("click", () => this.togglePlay());
    this.dom.register("playPauseBtn", playPauseBtn);
    createButton(controlGroup, {
      icon: ICONS.arrowRight,
      title: "Next heading (\u2192)",
      onClick: () => this.jumpHeading("down"),
      className: CSS_CLASSES.toggleBtn
    });
    const settingsPanel = this.controlsEl.createDiv({
      cls: `dashreader-fullscreen-settings ${CSS_CLASSES.hidden}`
    });
    this.dom.register("settingsPanel", settingsPanel);
    createNumberControl(
      settingsPanel,
      {
        label: "WPM: ",
        value: this.engine.getWpm(),
        onIncrement: () => this.changeWpm(25),
        onDecrement: () => this.changeWpm(-25),
        registryKey: "wpmValue",
        decrementTitle: "Slower (-25)",
        incrementTitle: "Faster (+25)"
      },
      this.dom
    );
    createNumberControl(
      settingsPanel,
      {
        label: "Font: ",
        value: Math.round(this.engine.getEffectiveFontSize() * 2),
        onIncrement: () => this.changeFontSize(4),
        onDecrement: () => this.changeFontSize(-4),
        registryKey: "fontValue",
        decrementTitle: "Smaller",
        incrementTitle: "Larger"
      },
      this.dom
    );
    const togglesRow = settingsPanel.createDiv({ cls: "dashreader-fullscreen-toggles" });
    createToggleControl(togglesRow, {
      label: "Slow start",
      checked: this.settings.enableSlowStart,
      onChange: (checked) => {
        this.settings.enableSlowStart = checked;
        this.engine.updateSettings(this.settings);
      }
    });
    createToggleControl(togglesRow, {
      label: "Micropause",
      checked: this.settings.enableMicropause,
      onChange: (checked) => {
        this.settings.enableMicropause = checked;
        this.engine.updateSettings(this.settings);
      }
    });
    createToggleControl(togglesRow, {
      label: "Focus bars",
      checked: this.settings.showFocusBars,
      onChange: (checked) => {
        this.settings.showFocusBars = checked;
        this.toggleFocusBarsDisplay();
      }
    });
  }
  /**
   * Toggles settings panel visibility
   */
  toggleSettingsPanel() {
    const panel = this.dom.get("settingsPanel");
    if (panel) {
      panel.toggleClass(CSS_CLASSES.hidden, !panel.hasClass(CSS_CLASSES.hidden));
    }
  }
  /**
   * Changes font size by delta
   */
  changeFontSize(delta) {
    const currentSize = parseFloat(this.wordEl.style.fontSize) || this.engine.getEffectiveFontSize() * 2;
    const newSize = Math.max(24, Math.min(200, currentSize + delta));
    this.wordEl.style.fontSize = `${newSize}px`;
    this.dom.updateText("fontValue", String(Math.round(newSize)));
  }
  /**
   * Toggles focus bars visibility
   */
  toggleFocusBarsDisplay() {
    this.wordEl.toggleClass("dashreader-focus-enabled", this.settings.showFocusBars);
  }
  /**
   * Sets up keyboard event handling
   */
  setupKeyboardEvents() {
    this.contentEl.addEventListener("keydown", (e) => {
      if (e.key === "Escape") {
        e.preventDefault();
        this.close();
        return;
      }
      if ((e.ctrlKey || e.metaKey) && e.key === "ArrowLeft") {
        e.preventDefault();
        this.engine.goToIndex(0);
        this.updateAfterNavigation();
        return;
      }
      if ((e.ctrlKey || e.metaKey) && e.key === "ArrowRight") {
        e.preventDefault();
        this.engine.goToIndex(this.engine.getTotalWords() - 1);
        this.updateAfterNavigation();
        return;
      }
      if (e.key === "ArrowUp" || e.key === "ArrowLeft") {
        e.preventDefault();
        this.jumpHeading("up");
        return;
      }
      if (e.key === "ArrowDown" || e.key === "ArrowRight") {
        e.preventDefault();
        this.jumpHeading("down");
        return;
      }
      this.hotkeyHandler.handleKeyPress(e);
    });
    this.contentEl.setAttribute("tabindex", "0");
    this.contentEl.focus();
  }
  /**
   * Displays the current reading state
   */
  displayCurrentState() {
    const currentIndex = this.engine.getCurrentIndex();
    const totalWords = this.engine.getTotalWords();
    if (currentIndex > 0 && currentIndex < totalWords) {
      const words = this.engine.getWords();
      if (words[currentIndex]) {
        this.displayWord(words[currentIndex]);
      }
    } else {
      const remainingWords = this.engine.getRemainingWords();
      const durationText = this.statsFormatter.formatTime(
        this.engine.getEstimatedDuration()
      );
      this.wordDisplay.displayReadyMessage(
        remainingWords,
        totalWords,
        currentIndex > 0 ? currentIndex : void 0,
        durationText
      );
    }
    this.updateProgress();
    this.updateStats();
  }
  /**
   * Engine callback: word changed
   */
  onWordChange(chunk) {
    this.displayWord(chunk.text);
    if (chunk.headingContext && this.breadcrumbManager) {
      if (this.breadcrumbManager.hasHeadingContextChanged(chunk.headingContext)) {
        this.breadcrumbManager.updateBreadcrumb(chunk.headingContext);
      }
    }
    this.updateProgress();
    this.updateStats();
  }
  /**
   * Displays a word with heading/callout detection
   */
  displayWord(text) {
    const headingMatch = text.match(/^\[H(\d)\]/);
    const calloutMatch = text.match(/^\[CALLOUT:([\w-]+)\]/);
    let displayText = text;
    let headingLevel = 0;
    let showSeparator = false;
    let calloutType;
    if (headingMatch) {
      headingLevel = parseInt(headingMatch[1]);
      displayText = text.replace(/^\[H\d\]/, "");
      showSeparator = true;
    } else if (calloutMatch) {
      calloutType = calloutMatch[1];
      displayText = text.replace(/^\[CALLOUT:[\w-]+\]/, "");
      showSeparator = true;
    }
    this.wordDisplay.displayWord(displayText, headingLevel, showSeparator, calloutType);
  }
  /**
   * Engine callback: reading complete
   */
  onComplete() {
    this.updatePlayPauseIcon();
    this.statsEl.setText("Reading complete! \u{1F389}");
  }
  /**
   * Updates the minimap position
   */
  updateProgress() {
    const currentIndex = this.engine.getCurrentIndex();
    this.minimapManager.updateCurrentPosition(currentIndex);
  }
  /**
   * Updates the stats display with split layout (words left, time right)
   */
  updateStats() {
    const currentIndex = this.engine.getCurrentIndex();
    const totalWords = this.engine.getTotalWords();
    this.statsLeftEl.setText(`${currentIndex}/${totalWords}`);
    const remainingTime = this.engine.getRemainingTime();
    const remainingText = this.statsFormatter.formatTime(remainingTime);
    this.statsRightEl.setText(remainingText);
  }
  /**
   * Sets up click/drag interaction on the minimap for scrubbing when paused
   */
  setupMinimapInteraction() {
    let isDragging = false;
    const seekToPosition = (e) => {
      const rect = this.minimapContainer.getBoundingClientRect();
      const x = Math.max(0, Math.min(e.clientX - rect.left, rect.width));
      const ratio = x / rect.width;
      const targetIndex = Math.floor(ratio * this.engine.getTotalWords());
      this.engine.goToIndex(targetIndex);
      this.updateAfterNavigation();
    };
    this.minimapContainer.addEventListener("mousedown", (e) => {
      if (this.engine.getIsPlaying())
        return;
      isDragging = true;
      seekToPosition(e);
      this.minimapContainer.addClass("scrubbing");
    });
    document.addEventListener("mousemove", (e) => {
      if (!isDragging)
        return;
      seekToPosition(e);
    });
    document.addEventListener("mouseup", () => {
      if (isDragging) {
        isDragging = false;
        this.minimapContainer.removeClass("scrubbing");
      }
    });
    this.minimapContainer.addEventListener("click", (e) => {
      if (this.engine.getIsPlaying())
        return;
      seekToPosition(e);
    });
    let wheelAccum = 0;
    let wheelDir = 0;
    let wasPlayingBeforeScroll = false;
    const WHEEL_THRESHOLD = 80;
    this.minimapContainer.addEventListener("wheel", (e) => {
      if (e.ctrlKey || e.metaKey)
        return;
      e.preventDefault();
      let dy = e.deltaY;
      if (e.deltaMode === 1) {
        dy *= 16;
      } else if (e.deltaMode === 2) {
        dy *= 800;
      }
      const dir = Math.sign(dy);
      if (dir !== 0 && dir !== wheelDir) {
        wheelAccum = 0;
        wheelDir = dir;
      }
      wheelAccum += dy;
      if (wheelAccum >= WHEEL_THRESHOLD) {
        wheelAccum -= WHEEL_THRESHOLD;
        wheelAccum = Math.min(wheelAccum, WHEEL_THRESHOLD - 1);
        if (this.engine.getIsPlaying()) {
          wasPlayingBeforeScroll = true;
          this.engine.pause();
          this.updatePlayPauseIcon();
        }
        this.engine.forward(1);
        this.updateAfterNavigation();
        this.scheduleResumeAfterScroll(wasPlayingBeforeScroll, () => {
          wasPlayingBeforeScroll = false;
        });
      } else if (wheelAccum <= -WHEEL_THRESHOLD) {
        wheelAccum += WHEEL_THRESHOLD;
        wheelAccum = Math.max(wheelAccum, -(WHEEL_THRESHOLD - 1));
        if (this.engine.getIsPlaying()) {
          wasPlayingBeforeScroll = true;
          this.engine.pause();
          this.updatePlayPauseIcon();
        }
        this.engine.rewind(1);
        this.updateAfterNavigation();
        this.scheduleResumeAfterScroll(wasPlayingBeforeScroll, () => {
          wasPlayingBeforeScroll = false;
        });
      }
    }, { passive: false });
  }
  // ms between stats updates
  setupWheelNavigation() {
    let wheelAccum = 0;
    let wheelDir = 0;
    let wasPlayingBeforeScroll = false;
    const WHEEL_THRESHOLD = 80;
    this.contentEl.addEventListener("wheel", (e) => {
      if (e.ctrlKey || e.metaKey)
        return;
      const target = e.target;
      if (target == null ? void 0 : target.closest("button, a, input, textarea, select"))
        return;
      e.preventDefault();
      let dy = e.deltaY;
      if (e.deltaMode === 1) {
        dy *= 16;
      } else if (e.deltaMode === 2) {
        dy *= 800;
      }
      const dir = Math.sign(dy);
      if (dir !== 0 && dir !== wheelDir) {
        wheelAccum = 0;
        wheelDir = dir;
      }
      wheelAccum += dy;
      if (wheelAccum >= WHEEL_THRESHOLD) {
        wheelAccum -= WHEEL_THRESHOLD;
        wheelAccum = Math.min(wheelAccum, WHEEL_THRESHOLD - 1);
        if (this.engine.getIsPlaying()) {
          wasPlayingBeforeScroll = true;
          this.engine.pause();
          this.updatePlayPauseIcon();
        }
        this.engine.forward(1);
        this.updateAfterNavigation();
        this.scheduleResumeAfterScroll(wasPlayingBeforeScroll, () => {
          wasPlayingBeforeScroll = false;
        });
      } else if (wheelAccum <= -WHEEL_THRESHOLD) {
        wheelAccum += WHEEL_THRESHOLD;
        wheelAccum = Math.max(wheelAccum, -(WHEEL_THRESHOLD - 1));
        if (this.engine.getIsPlaying()) {
          wasPlayingBeforeScroll = true;
          this.engine.pause();
          this.updatePlayPauseIcon();
        }
        this.engine.rewind(1);
        this.updateAfterNavigation();
        this.scheduleResumeAfterScroll(wasPlayingBeforeScroll, () => {
          wasPlayingBeforeScroll = false;
        });
      }
    }, { passive: false, capture: true });
  }
  /**
   * Updates display after navigation
   * Adjusts position to avoid pauses (line breaks)
   */
  updateAfterNavigation() {
    let currentIndex = this.engine.getCurrentIndex();
    const words = this.engine.getWords();
    currentIndex = this.adjustIndexToAvoidPause(currentIndex, words);
    if (currentIndex !== this.engine.getCurrentIndex()) {
      this.engine.goToIndex(currentIndex);
    }
    this.updateProgress();
    this.updateStats();
    if (words[currentIndex]) {
      this.displayWord(words[currentIndex]);
    }
    const context = this.engine.getCurrentHeadingContext(currentIndex);
    if (context.breadcrumb.length > 0 && this.breadcrumbManager) {
      this.breadcrumbManager.updateBreadcrumb(context);
    }
  }
  /**
   * Adjusts index to avoid landing on pause words ('\n')
   * Moves forward to next non-pause word
   */
  adjustIndexToAvoidPause(index, words) {
    const maxIndex = words.length - 1;
    let adjusted = index;
    while (adjusted < maxIndex && words[adjusted] === "\n") {
      adjusted++;
    }
    if (adjusted >= maxIndex && words[adjusted] === "\n") {
      adjusted = index;
      while (adjusted > 0 && words[adjusted] === "\n") {
        adjusted--;
      }
    }
    return adjusted;
  }
  /**
   * Schedules resuming playback after scroll navigation
   * Uses debounce - resets timer on each scroll
   */
  scheduleResumeAfterScroll(wasPlaying, resetCallback) {
    if (this.scrollResumeTimerId) {
      clearTimeout(this.scrollResumeTimerId);
      this.scrollResumeTimerId = null;
    }
    if (!wasPlaying)
      return;
    this.scrollResumeTimerId = setTimeout(() => {
      this.scrollResumeTimerId = null;
      resetCallback();
      this.engine.play();
      this.startStatsTimer();
      this.updatePlayPauseIcon();
    }, this.SCROLL_RESUME_DELAY);
  }
  /**
   * Starts the stats update timer for linear time display during playback
   */
  startStatsTimer() {
    if (this.statsIntervalId)
      return;
    this.statsIntervalId = setInterval(() => {
      if (this.engine.getIsPlaying()) {
        this.updateStats();
      } else {
        this.stopStatsTimer();
      }
    }, this.STATS_UPDATE_INTERVAL);
  }
  /**
   * Stops the stats update timer
   */
  stopStatsTimer() {
    if (this.statsIntervalId) {
      clearInterval(this.statsIntervalId);
      this.statsIntervalId = null;
    }
  }
  /**
   * Toggles play/pause state
   */
  togglePlay() {
    const btn = this.dom.get("playPauseBtn");
    if (this.engine.getIsPlaying()) {
      this.engine.pause();
      this.stopStatsTimer();
      if (btn)
        (0, import_obsidian2.setIcon)(btn, "play");
    } else {
      this.engine.play();
      this.startStatsTimer();
      if (btn)
        (0, import_obsidian2.setIcon)(btn, "pause");
    }
  }
  /**
   * Updates the play/pause button icon based on engine state
   * @param forceState - Optional: force icon to specific state ('play' or 'pause')
   */
  updatePlayPauseIcon(forceState) {
    const btn = this.dom.get("playPauseBtn");
    if (btn) {
      const icon = forceState != null ? forceState : this.engine.getIsPlaying() ? "pause" : "play";
      (0, import_obsidian2.setIcon)(btn, icon);
    }
  }
  /**
   * Changes WPM by delta
   */
  changeWpm(delta) {
    const newWpm = Math.max(50, Math.min(5e3, this.engine.getWpm() + delta));
    this.engine.setWpm(newWpm);
    this.dom.updateText("wpmValue", String(newWpm));
    this.updateStats();
  }
  /**
   * Jumps to the previous or next heading
   * @param direction - 'up' for previous, 'down' for next
   */
  jumpHeading(direction) {
    const headings = this.engine.getHeadings();
    if (headings.length === 0)
      return;
    const currentIndex = this.engine.getCurrentIndex();
    let targetHeading;
    if (direction === "up") {
      for (let i = headings.length - 1; i >= 0; i--) {
        if (headings[i].wordIndex < currentIndex) {
          targetHeading = headings[i];
          break;
        }
      }
      if (!targetHeading) {
        this.engine.goToIndex(0);
        this.updateAfterNavigation();
        return;
      }
    } else {
      for (const heading of headings) {
        if (heading.wordIndex > currentIndex) {
          targetHeading = heading;
          break;
        }
      }
      if (!targetHeading) {
        this.engine.goToIndex(this.engine.getTotalWords() - 1);
        this.updateAfterNavigation();
        return;
      }
    }
    this.engine.goToIndex(targetHeading.wordIndex);
    this.updateAfterNavigation();
  }
};

// src/auto-load-manager.ts
var import_obsidian3 = require("obsidian");
function isNavigationKey(evt) {
  return (
    // Arrow keys
    evt.key === "ArrowUp" || evt.key === "ArrowDown" || evt.key === "ArrowLeft" || evt.key === "ArrowRight" || // Home/End/PageUp/PageDown
    evt.key === "Home" || evt.key === "End" || evt.key === "PageUp" || evt.key === "PageDown" || // Enter
    evt.key === "Enter" || // Vim-style navigation
    evt.key === "j" && evt.ctrlKey || evt.key === "k" && evt.ctrlKey || evt.key === "d" && evt.ctrlKey || evt.key === "u" && evt.ctrlKey || // Cmd/Ctrl + arrows
    (evt.key === "ArrowUp" || evt.key === "ArrowDown") && (evt.metaKey || evt.ctrlKey)
  );
}
function isSelectionKey(evt) {
  return evt.shiftKey || evt.key === "a" && (evt.metaKey || evt.ctrlKey);
}
function extractEditorContent(app) {
  const activeView = app.workspace.getActiveViewOfType(import_obsidian3.MarkdownView);
  if (!activeView) {
    return { activeView: null, currentFile: null };
  }
  const currentFile = app.workspace.getActiveFile();
  if (!currentFile) {
    return { activeView, currentFile: null };
  }
  const fileName = currentFile.name;
  const editor = activeView.editor;
  let selection;
  let lineNumber;
  if (editor.somethingSelected()) {
    selection = editor.getSelection();
    const cursor2 = editor.getCursor("from");
    lineNumber = cursor2.line + 1;
  }
  const fullContent = editor.getValue();
  const cursor = editor.getCursor();
  const cursorPosition = editor.posToOffset(cursor);
  return {
    activeView,
    currentFile,
    fileName,
    selection,
    fullContent,
    cursorPosition,
    lineNumber
  };
}
var AutoLoadManager = class {
  /**
   * Creates a new AutoLoadManager instance
   *
   * @param app - Obsidian App instance for accessing workspace and editor
   * @param loadTextCallback - Callback function to load text into DashReader view
   * @param isViewShown - Function that returns true if DashReader view is currently visible
   * @param timeoutManager - Timeout manager for proper cleanup
   *
   * @example
   * ```typescript
   * this.autoLoadManager = new AutoLoadManager(
   *   this.app,
   *   (text, source) => this.loadText(text, source),
   *   () => this.isViewShown,
   *   this.timeoutManager
   * );
   * ```
   */
  constructor(app, loadTextCallback, isViewShown, timeoutManager) {
    this.app = app;
    this.loadTextCallback = loadTextCallback;
    this.isViewShown = isViewShown;
    this.timeoutManager = timeoutManager;
    this.state = {
      lastSelection: "",
      lastFilePath: "",
      lastCursorPosition: -1,
      lastCheckTime: 0
    };
  }
  /**
   * Check for selection or cursor changes and load text if needed
   *
   * This is the main method called by keyboard and mouse event handlers.
   * It implements throttling (150ms) to avoid performance issues from
   * rapid event firing.
   *
   * **Logic Flow**:
   * 1. Throttle: Skip if less than 150ms since last check
   * 2. Extract editor content (selection, cursor position, etc.)
   * 3. Priority 1: If selection exists and changed → load selection
   * 4. Priority 2: If cursor moved → reload from new cursor position
   *
   * **Prevents Redundant Loads**:
   * - Tracks lastSelection to avoid reloading same text
   * - Tracks lastCursorPosition to avoid reload on unchanged position
   *
   * **Typical Usage**: Called on keyup and mouseup events
   *
   * @example
   * ```typescript
   * // In rsvp-view.ts setupAutoLoad()
   * this.registerDomEvent(document, 'keyup', (evt) => {
   *   if (isNavigationKey(evt) || isSelectionKey(evt)) {
   *     this.autoLoadManager.checkSelectionOrCursor();
   *   }
   * });
   *
   * this.registerDomEvent(document, 'mouseup', () => {
   *   this.autoLoadManager.checkSelectionOrCursor();
   * });
   * ```
   */
  checkSelectionOrCursor() {
    const now = Date.now();
    if (now - this.state.lastCheckTime < TIMING.throttleDelay) {
      return;
    }
    this.state.lastCheckTime = now;
    const content = extractEditorContent(this.app);
    if (!content.activeView || !content.currentFile) {
      return;
    }
    if (content.selection && content.selection.length > TEXT_LIMITS.minSelectionLength) {
      if (content.selection !== this.state.lastSelection) {
        this.state.lastSelection = content.selection;
        this.loadTextCallback(content.selection, {
          fileName: content.fileName,
          lineNumber: content.lineNumber
        });
      }
      return;
    }
    if (content.fullContent && content.fullContent.trim().length > TEXT_LIMITS.minContentLength) {
      if (content.cursorPosition !== this.state.lastCursorPosition) {
        this.loadTextCallback(content.fullContent, {
          fileName: content.fileName,
          cursorPosition: content.cursorPosition
        });
        this.state.lastSelection = "";
        this.state.lastCursorPosition = content.cursorPosition;
      }
    }
  }
  /**
   * Load content from the active editor with a configurable delay
   *
   * Used by file-open and leaf-change events to load content after a short
   * delay, giving Obsidian time to fully activate the editor.
   *
   * **Priority Logic**:
   * 1. If text is selected → load selection (rare on file open)
   * 2. Otherwise → load full document from cursor position
   *
   * **Delay Rationale**:
   * - file-open: 300ms default - editor needs time to initialize
   * - leaf-change: Can use shorter delay (200ms) - editor already active
   *
   * @param delay - Delay in milliseconds before loading (default: 300ms from TIMING.autoLoadDelay)
   *
   * @example
   * ```typescript
   * // File-open event (use default 300ms delay)
   * this.registerEvent(
   *   this.app.workspace.on('file-open', () => {
   *     this.autoLoadManager.loadFromEditor();
   *   })
   * );
   *
   * // Leaf-change event (use shorter 200ms delay)
   * this.registerEvent(
   *   this.app.workspace.on('active-leaf-change', () => {
   *     this.autoLoadManager.loadFromEditor(TIMING.autoLoadDelayShort);
   *   })
   * );
   * ```
   */
  loadFromEditor(delay = TIMING.autoLoadDelay) {
    this.timeoutManager.setTimeout(() => {
      if (!this.isViewShown())
        return;
      const content = extractEditorContent(this.app);
      if (!content.activeView || !content.currentFile)
        return;
      if (content.selection && content.selection.length > TEXT_LIMITS.minSelectionLength) {
        this.loadTextCallback(content.selection, {
          fileName: content.fileName,
          lineNumber: content.lineNumber
        });
        return;
      }
      if (content.fullContent && content.fullContent.trim().length > TEXT_LIMITS.minContentLength) {
        this.loadTextCallback(content.fullContent, {
          fileName: content.fileName,
          cursorPosition: content.cursorPosition
        });
      }
    }, delay);
  }
  /**
   * Reset tracking state for a new file
   *
   * Called when the active file changes to clear previous selection and
   * cursor tracking. This prevents attempting to reload content from the
   * previous file's state.
   *
   * @param filePath - Path of the newly opened file
   *
   * @example
   * ```typescript
   * this.registerEvent(
   *   this.app.workspace.on('file-open', (file) => {
   *     if (file && this.autoLoadManager.hasFileChanged(file.path)) {
   *       this.autoLoadManager.resetForNewFile(file.path);
   *       this.autoLoadManager.loadFromEditor();
   *     }
   *   })
   * );
   * ```
   */
  resetForNewFile(filePath) {
    this.state.lastSelection = "";
    this.state.lastFilePath = filePath;
    this.state.lastCursorPosition = -1;
  }
  /**
   * Check if the file has changed
   *
   * Compares the given file path with the last tracked file path to determine
   * if the user has switched to a different file.
   *
   * @param filePath - File path to check
   * @returns True if the file path is different from the last tracked path
   *
   * @example
   * ```typescript
   * if (this.autoLoadManager.hasFileChanged(currentFile.path)) {
   *   console.log('User switched to a different file');
   *   this.autoLoadManager.resetForNewFile(currentFile.path);
   * }
   * ```
   */
  hasFileChanged(filePath) {
    return filePath !== this.state.lastFilePath;
  }
  /**
   * Get current state (for debugging)
   *
   * Returns a readonly copy of the internal state for debugging purposes.
   * Useful for understanding why auto-load is or isn't triggering.
   *
   * @returns Readonly copy of the current AutoLoadState
   *
   * @example
   * ```typescript
   * const state = this.autoLoadManager.getState();
   * console.log('AutoLoad state:', {
   *   lastSelection: state.lastSelection.substring(0, 50) + '...',
   *   lastFilePath: state.lastFilePath,
   *   lastCursorPosition: state.lastCursorPosition,
   *   lastCheckTime: new Date(state.lastCheckTime).toISOString()
   * });
   * ```
   */
  getState() {
    return { ...this.state };
  }
};

// src/rsvp-view.ts
var VIEW_TYPE_DASHREADER = "dashreader-view";
var DashReaderView = class extends import_obsidian4.ItemView {
  // ──────────────────────────────────────────────────────────────────────
  // Constructor
  // ──────────────────────────────────────────────────────────────────────
  /**
   * Creates a new DashReaderView instance
   *
   * @param leaf - Obsidian workspace leaf to attach to
   * @param settings - Plugin settings
   */
  constructor(leaf, settings) {
    super(leaf);
    /** Currently open fullscreen modal (null if none) */
    this.fullscreenModal = null;
    // Timer for resuming after scroll navigation
    this.scrollResumeTimerId = null;
    this.SCROLL_RESUME_DELAY = 800;
    this.settings = settings;
    this.state = new ViewState({
      currentWpm: settings.wpm,
      currentChunkSize: settings.chunkSize,
      currentFontSize: settings.fontSize
    });
    this.dom = new DOMRegistry();
    this.timeoutManager = new TimeoutManager();
    this.statsFormatter = new StatsFormatter();
    this.engine = new RSVPEngine(
      settings,
      this.onWordChange.bind(this),
      this.onComplete.bind(this),
      this.timeoutManager
    );
    this.autoLoadManager = new AutoLoadManager(
      this.app,
      this.loadText.bind(this),
      () => {
        var _a, _b;
        return (_b = (_a = this.mainContainerEl) == null ? void 0 : _a.isShown()) != null ? _b : false;
      },
      this.timeoutManager
    );
  }
  // ──────────────────────────────────────────────────────────────────────
  // Mobile Detection
  // ──────────────────────────────────────────────────────────────────────
  /**
   * Detects if running on a mobile device (iOS/Android)
   * Uses Obsidian's Platform API with fallback to media query
   * @returns true if on mobile device
   */
  isMobileUI() {
    var _a, _b, _c;
    if (import_obsidian4.Platform.isMobileApp || import_obsidian4.Platform.isMobile) {
      return true;
    }
    return (_c = (_b = (_a = window.matchMedia) == null ? void 0 : _a.call(window, "(hover: none) and (pointer: coarse)")) == null ? void 0 : _b.matches) != null ? _c : false;
  }
  // ──────────────────────────────────────────────────────────────────────
  // Obsidian View Lifecycle
  // ──────────────────────────────────────────────────────────────────────
  /**
   * Returns the unique view type identifier
   * @returns View type string
   */
  getViewType() {
    return VIEW_TYPE_DASHREADER;
  }
  /**
   * Returns the display name shown in Obsidian UI
   * @returns Display name
   */
  getDisplayText() {
    return "Speed reader";
  }
  /**
   * Returns the icon identifier for this view
   * @returns Icon name
   */
  getIcon() {
    return "zap";
  }
  /**
   * Called when the view is opened
   * Builds UI, sets up hotkeys, and registers auto-load
   */
  async onOpen() {
    await Promise.resolve();
    const isMobile = this.isMobileUI();
    this.engine.setUseMobileProfile(isMobile);
    this.mainContainerEl = this.contentEl.createDiv({ cls: CSS_CLASSES.container });
    this.buildUI();
    this.breadcrumbManager = new BreadcrumbManager(this.breadcrumbEl, this.engine, this.timeoutManager);
    const displayArea = this.dom.get("displayArea");
    this.wordDisplay = new WordDisplay(this.wordEl, this.settings, displayArea || void 0);
    this.hotkeyHandler = new HotkeyHandler(this.settings, {
      onTogglePlay: () => this.togglePlay(),
      onRewind: () => this.engine.rewind(),
      onForward: () => this.engine.forward(),
      onIncrementWpm: () => this.changeValue("wpm", 10),
      onDecrementWpm: () => this.changeValue("wpm", -10),
      onQuit: () => this.engine.stop()
    });
    this.minimapManager = new MinimapManager(this.mainContainerEl, this.engine, this.timeoutManager);
    this.setupMinimapWheelNavigation();
    this.wordDisplay.displayWelcomeMessage(
      ICONS.book,
      "Select text to start reading",
      'or use Cmd+P \u2192 "Read selected text"'
    );
    this.toggleContextDisplay();
    this.toggleMinimapDisplay();
    this.toggleBreadcrumbDisplay();
    this.setupHotkeys();
    this.app.workspace.onLayoutReady(() => {
      this.setupAutoLoad();
    });
  }
  /**
   * Called when the view is closed
   * Stops reading and cleans up resources
   */
  async onClose() {
    await Promise.resolve();
    this.engine.stop();
    this.timeoutManager.clearAll();
    this.dom.clear();
  }
  // ============================================================================
  // SECTION 3: UI CONSTRUCTION
  // ============================================================================
  /**
   * Orchestrates the construction of all UI components
   * Called once during view initialization
   *
   * Order matters: toggle bar, breadcrumb, stats, display, progress, controls, settings
   */
  buildUI() {
    this.buildToggleBar();
    this.buildBreadcrumb();
    this.buildStats();
    this.buildDisplayArea();
    this.buildProgressBar();
    this.buildControls();
    this.buildInlineSettings();
  }
  /**
   * Builds the toggle bar with settings and stats buttons
   * Located at the top of the view
   */
  buildToggleBar() {
    this.toggleBar = this.mainContainerEl.createDiv({ cls: CSS_CLASSES.toggleBar });
    createButton(this.toggleBar, {
      icon: ICONS.settings,
      title: "Toggle controls (C)",
      onClick: () => this.togglePanel("controls"),
      className: CSS_CLASSES.toggleBtn
    });
    createButton(this.toggleBar, {
      icon: ICONS.stats,
      title: "Toggle stats (S)",
      onClick: () => this.togglePanel("stats"),
      className: CSS_CLASSES.toggleBtn
    });
    createButton(this.toggleBar, {
      icon: ICONS.expand,
      title: "Fullscreen mode (F)",
      onClick: () => this.openFullscreen(),
      className: CSS_CLASSES.toggleBtn
    });
  }
  /**
   * Builds the breadcrumb navigation bar
   * Shows the hierarchical position in the document (H1 > H2 > H3 etc.)
   * Updated automatically as reading progresses through headings
   */
  buildBreadcrumb() {
    this.breadcrumbEl = this.mainContainerEl.createDiv({
      cls: `dashreader-breadcrumb ${CSS_CLASSES.hidden}`
    });
  }
  /**
   * Builds the statistics display panel
   * Shows WPM, words read, time elapsed, etc.
   */
  buildStats() {
    this.statsEl = this.mainContainerEl.createDiv({
      cls: `${CSS_CLASSES.stats} ${CSS_CLASSES.hidden}`
    });
    this.dom.register("statsEl", this.statsEl);
    const wpmDisplay = this.statsEl.createDiv({ cls: CSS_CLASSES.wpmDisplay });
    wpmDisplay.setText(`${this.settings.wpm} WPM`);
    this.dom.register("wpmDisplay", wpmDisplay);
    const statsText = this.statsEl.createDiv({ cls: CSS_CLASSES.statsText });
    statsText.setText("Ready");
    this.dom.register("statsText", statsText);
  }
  /**
   * Builds the main display area for word presentation
   * Includes context before/after if enabled
   */
  buildDisplayArea() {
    const displayArea = this.mainContainerEl.createDiv({ cls: CSS_CLASSES.display });
    this.dom.register("displayArea", displayArea);
    if (this.settings.showContext) {
      this.contextBeforeEl = displayArea.createDiv({ cls: CSS_CLASSES.contextBefore });
      this.dom.register("contextBeforeEl", this.contextBeforeEl);
    }
    this.wordEl = displayArea.createDiv({ cls: CSS_CLASSES.word });
    this.wordEl.style.fontSize = `${this.engine.getEffectiveFontSize()}px`;
    this.wordEl.style.fontFamily = this.settings.fontFamily;
    this.wordEl.style.color = this.settings.fontColor;
    this.dom.register("wordEl", this.wordEl);
    if (this.settings.showFocusBars) {
      this.wordEl.addClass("dashreader-focus-enabled");
    }
    if (this.settings.showContext) {
      this.contextAfterEl = displayArea.createDiv({ cls: CSS_CLASSES.contextAfter });
      this.dom.register("contextAfterEl", this.contextAfterEl);
    }
    this.setupWheelNavigation(displayArea);
  }
  /**
   * Sets up wheel/trackpad navigation for word-by-word scrubbing
   * Based on fork implementation for smooth, responsive scrolling
   * Only works when paused
   */
  setupWheelNavigation(displayArea) {
    let wheelAccum = 0;
    let wheelDir = 0;
    let wasPlayingBeforeScroll = false;
    const WHEEL_THRESHOLD = 80;
    displayArea.addEventListener("wheel", (e) => {
      if (e.ctrlKey || e.metaKey)
        return;
      const target = e.target;
      if (target == null ? void 0 : target.closest("button, a, input, textarea, select"))
        return;
      e.preventDefault();
      let dy = e.deltaY;
      if (e.deltaMode === 1) {
        dy *= 16;
      } else if (e.deltaMode === 2) {
        dy *= 800;
      }
      const dir = Math.sign(dy);
      if (dir !== 0 && dir !== wheelDir) {
        wheelAccum = 0;
        wheelDir = dir;
      }
      wheelAccum += dy;
      if (wheelAccum >= WHEEL_THRESHOLD) {
        wheelAccum -= WHEEL_THRESHOLD;
        wheelAccum = Math.min(wheelAccum, WHEEL_THRESHOLD - 1);
        if (this.engine.getIsPlaying()) {
          wasPlayingBeforeScroll = true;
          this.engine.pause();
          updatePlayPauseButtons(this.dom, false);
        }
        this.engine.forward(1);
        this.updateAfterWheelNavigation();
        this.scheduleResumeAfterScroll(wasPlayingBeforeScroll, () => {
          wasPlayingBeforeScroll = false;
        });
      } else if (wheelAccum <= -WHEEL_THRESHOLD) {
        wheelAccum += WHEEL_THRESHOLD;
        wheelAccum = Math.max(wheelAccum, -(WHEEL_THRESHOLD - 1));
        if (this.engine.getIsPlaying()) {
          wasPlayingBeforeScroll = true;
          this.engine.pause();
          updatePlayPauseButtons(this.dom, false);
        }
        this.engine.rewind(1);
        this.updateAfterWheelNavigation();
        this.scheduleResumeAfterScroll(wasPlayingBeforeScroll, () => {
          wasPlayingBeforeScroll = false;
        });
      }
    }, { passive: false, capture: true });
  }
  /**
   * Updates display after wheel navigation
   */
  updateAfterWheelNavigation() {
    const currentIndex = this.engine.getCurrentIndex();
    const words = this.engine.getWords();
    if (this.minimapManager) {
      this.minimapManager.updateCurrentPosition(currentIndex);
    }
    const progress = this.engine.getProgress();
    this.dom.updateStyle("progressBar", "width", `${progress}%`);
    this.updateStats();
    if (words[currentIndex]) {
      const word = words[currentIndex];
      const headingMatch = word.match(/^\[H(\d)\]/);
      const calloutMatch = word.match(/^\[CALLOUT:([\w-]+)\]/);
      let displayText = word;
      let headingLevel = 0;
      let calloutType;
      if (headingMatch) {
        headingLevel = parseInt(headingMatch[1]);
        displayText = word.replace(/^\[H\d\]/, "");
      } else if (calloutMatch) {
        calloutType = calloutMatch[1];
        displayText = word.replace(/^\[CALLOUT:[\w-]+\]/, "");
      }
      this.wordDisplay.displayWord(displayText, headingLevel, false, calloutType);
      const context = this.engine.getCurrentHeadingContext(currentIndex);
      if (context.breadcrumb.length > 0 && this.breadcrumbManager) {
        this.breadcrumbManager.updateBreadcrumb(context);
      }
    }
  }
  // ms before resuming after scroll
  /**
   * Sets up wheel navigation on the minimap
   * Uses the same pause/resume logic as the main display area
   */
  setupMinimapWheelNavigation() {
    let wasPlayingBeforeScroll = false;
    this.minimapManager.setupWheelNavigation(
      // On forward (scroll down)
      () => {
        if (this.engine.getIsPlaying()) {
          wasPlayingBeforeScroll = true;
          this.engine.pause();
          updatePlayPauseButtons(this.dom, false);
        }
        this.engine.forward(1);
        this.updateAfterWheelNavigation();
        this.scheduleResumeAfterScroll(wasPlayingBeforeScroll, () => {
          wasPlayingBeforeScroll = false;
        });
      },
      // On backward (scroll up)
      () => {
        if (this.engine.getIsPlaying()) {
          wasPlayingBeforeScroll = true;
          this.engine.pause();
          updatePlayPauseButtons(this.dom, false);
        }
        this.engine.rewind(1);
        this.updateAfterWheelNavigation();
        this.scheduleResumeAfterScroll(wasPlayingBeforeScroll, () => {
          wasPlayingBeforeScroll = false;
        });
      }
    );
  }
  /**
   * Schedules resuming playback after scroll navigation
   * Uses debounce - resets timer on each scroll
   */
  scheduleResumeAfterScroll(wasPlaying, resetCallback) {
    if (this.scrollResumeTimerId) {
      clearTimeout(this.scrollResumeTimerId);
      this.scrollResumeTimerId = null;
    }
    if (!wasPlaying)
      return;
    this.scrollResumeTimerId = setTimeout(() => {
      this.scrollResumeTimerId = null;
      resetCallback();
      this.engine.play();
      updatePlayPauseButtons(this.dom, true);
    }, this.SCROLL_RESUME_DELAY);
  }
  /**
   * Builds the progress bar at the bottom of display
   * Updates during reading to show progress
   */
  buildProgressBar() {
    this.progressEl = this.mainContainerEl.createDiv({ cls: CSS_CLASSES.progressContainer });
    const progressBar = this.progressEl.createDiv({ cls: CSS_CLASSES.progressBar });
    progressBar.setAttr("style", `width: 0%; background: ${this.settings.highlightColor}`);
    this.dom.register("progressBar", progressBar);
  }
  /**
   * Builds the playback controls panel
   * Includes play/pause, rewind, forward, stop, WPM, and chunk size controls
   */
  buildControls() {
    this.controlsEl = this.mainContainerEl.createDiv({
      cls: `${CSS_CLASSES.controls} ${CSS_CLASSES.hidden}`
    });
    this.dom.register("controlsEl", this.controlsEl);
    const playControls = this.controlsEl.createDiv({ cls: CSS_CLASSES.controlGroup });
    createButton(playControls, {
      icon: ICONS.rewind,
      title: "Rewind (\u2190)",
      onClick: () => this.engine.rewind()
    });
    createPlayPauseButtons(playControls, () => this.togglePlay(), () => this.engine.pause(), this.dom);
    createButton(playControls, {
      icon: ICONS.forward,
      title: "Forward (\u2192)",
      onClick: () => this.engine.forward()
    });
    createButton(playControls, {
      icon: ICONS.stop,
      title: "Stop (Esc)",
      onClick: () => this.engine.reset()
    });
    createNumberControl(
      this.controlsEl,
      {
        label: "WPM: ",
        value: this.settings.wpm,
        onIncrement: () => this.changeValue("wpm", INCREMENTS.wpm),
        onDecrement: () => this.changeValue("wpm", -INCREMENTS.wpm),
        increment: INCREMENTS.wpm,
        registryKey: "wpmValue"
      },
      this.dom
    );
    createNumberControl(
      this.controlsEl,
      {
        label: "Words: ",
        value: this.settings.chunkSize,
        onIncrement: () => this.changeValue("chunkSize", INCREMENTS.chunkSize),
        onDecrement: () => this.changeValue("chunkSize", -INCREMENTS.chunkSize),
        registryKey: "chunkValue"
      },
      this.dom
    );
  }
  /**
   * Builds the inline settings panel
   * Allows quick adjustments to WPM, acceleration, font size, etc.
   */
  buildInlineSettings() {
    this.settingsEl = this.mainContainerEl.createDiv({
      cls: `${CSS_CLASSES.settings} ${CSS_CLASSES.hidden}`
    });
    this.dom.register("settingsEl", this.settingsEl);
    createNumberControl(
      this.settingsEl,
      {
        label: "Speed (WPM): ",
        value: this.settings.wpm,
        onIncrement: () => this.changeValue("wpm", INCREMENTS.wpm),
        onDecrement: () => this.changeValue("wpm", -INCREMENTS.wpm),
        increment: INCREMENTS.wpm,
        registryKey: "wpmInlineValue",
        decrementTitle: "Slower (-25)",
        incrementTitle: "Faster (+25)"
      },
      this.dom
    );
    createToggleControl(this.settingsEl, {
      label: "Slow Start",
      checked: this.settings.enableSlowStart,
      onChange: (checked) => {
        this.settings.enableSlowStart = checked;
        this.engine.updateSettings(this.settings);
      }
    });
    createNumberControl(
      this.settingsEl,
      {
        label: "Font Size: ",
        value: this.settings.fontSize,
        onIncrement: () => this.changeValue("fontSize", INCREMENTS.fontSize),
        onDecrement: () => this.changeValue("fontSize", -INCREMENTS.fontSize),
        registryKey: "fontValue",
        decrementTitle: "Smaller",
        incrementTitle: "Larger"
      },
      this.dom
    );
    createToggleControl(this.settingsEl, {
      label: "Show context",
      checked: this.settings.showContext,
      onChange: (checked) => {
        this.settings.showContext = checked;
        this.toggleContextDisplay();
      }
    });
    createToggleControl(this.settingsEl, {
      label: "Minimap",
      checked: this.settings.showMinimap,
      onChange: (checked) => {
        this.settings.showMinimap = checked;
        this.toggleMinimapDisplay();
      }
    });
    createToggleControl(this.settingsEl, {
      label: "Breadcrumb",
      checked: this.settings.showBreadcrumb,
      onChange: (checked) => {
        this.settings.showBreadcrumb = checked;
        this.toggleBreadcrumbDisplay();
      }
    });
    createToggleControl(this.settingsEl, {
      label: "Micropause",
      checked: this.settings.enableMicropause,
      onChange: (checked) => {
        this.settings.enableMicropause = checked;
        this.engine.updateSettings(this.settings);
      }
    });
    createToggleControl(this.settingsEl, {
      label: "Focus bars",
      checked: this.settings.showFocusBars,
      onChange: (checked) => {
        this.settings.showFocusBars = checked;
        this.toggleFocusBarsDisplay();
      }
    });
  }
  /**
   * Toggle focus bars visibility
   */
  toggleFocusBarsDisplay() {
    const wordEl = this.dom.get("wordEl");
    if (wordEl) {
      wordEl.toggleClass("dashreader-focus-enabled", this.settings.showFocusBars);
    }
  }
  // ============================================================================
  // SECTION 4: USER INTERACTIONS
  // ============================================================================
  /**
   * Unified value change handler
   * Replaces 5 separate change functions (changeWpm, changeWpmInline, etc.)
   *
   * @param type - Type of value to change
   * @param delta - Amount to change (positive or negative)
   */
  changeValue(type, delta) {
    switch (type) {
      case "wpm": {
        const newWpm = this.engine.getWpm() + delta;
        this.engine.setWpm(newWpm);
        this.settings.wpm = this.engine.getWpm();
        this.state.set("currentWpm", this.settings.wpm);
        this.dom.updateMultipleText({
          wpmDisplay: `${this.settings.wpm} WPM`,
          wpmValue: String(this.settings.wpm),
          wpmInlineValue: String(this.settings.wpm)
        });
        break;
      }
      case "chunkSize": {
        const newSize = this.engine.getChunkSize() + delta;
        this.engine.setChunkSize(newSize);
        this.settings.chunkSize = this.engine.getChunkSize();
        this.state.set("currentChunkSize", this.settings.chunkSize);
        this.dom.updateText("chunkValue", this.settings.chunkSize);
        break;
      }
      case "fontSize": {
        const newSize = Math.max(
          LIMITS.fontSize.min,
          Math.min(LIMITS.fontSize.max, this.settings.fontSize + delta)
        );
        this.settings.fontSize = newSize;
        this.state.set("currentFontSize", newSize);
        this.wordEl.style.fontSize = `${newSize}px`;
        this.dom.updateText("fontValue", newSize);
        break;
      }
    }
  }
  /**
   * Unified panel toggle handler
   * Replaces 3 separate toggle functions (toggleControls, toggleStats, etc.)
   *
   * @param panel - Panel to toggle ('controls' or 'stats')
   */
  togglePanel(panel) {
    if (panel === "controls") {
      this.state.toggle("showingControls");
      const showing = this.state.get("showingControls");
      this.controlsEl.toggleClass(CSS_CLASSES.hidden, !showing);
      this.settingsEl.toggleClass(CSS_CLASSES.hidden, !showing);
    } else if (panel === "stats") {
      this.state.toggle("showingStats");
      const showing = this.state.get("showingStats");
      this.statsEl.toggleClass(CSS_CLASSES.hidden, !showing);
    }
  }
  /**
   * Toggles the visibility of context before/after current word
   */
  toggleContextDisplay() {
    const shouldHide = !this.settings.showContext;
    if (this.contextBeforeEl) {
      this.contextBeforeEl.toggleClass(CSS_CLASSES.hidden, shouldHide);
    }
    if (this.contextAfterEl) {
      this.contextAfterEl.toggleClass(CSS_CLASSES.hidden, shouldHide);
    }
  }
  /**
   * Toggle minimap visibility
   */
  toggleMinimapDisplay() {
    if (this.minimapManager) {
      if (this.settings.showMinimap) {
        this.minimapManager.show();
      } else {
        this.minimapManager.hide();
      }
    }
  }
  /**
   * Toggle breadcrumb visibility
   * Uses effective setting (respects mobile profile)
   */
  toggleBreadcrumbDisplay() {
    const shouldHide = !this.engine.getEffectiveShowBreadcrumb();
    if (this.breadcrumbEl) {
      this.breadcrumbEl.toggleClass(CSS_CLASSES.hidden, shouldHide);
    }
  }
  /**
   * Toggles fullscreen modal for immersive reading experience
   * If modal is open, closes it. Otherwise opens a new one.
   * Shares the current engine state with the modal.
   */
  openFullscreen() {
    if (this.fullscreenModal) {
      this.fullscreenModal.close();
      return;
    }
    if (this.engine.getTotalWords() === 0) {
      return;
    }
    const modal = new FullscreenModal(
      this.app,
      this.engine,
      this.settings,
      () => {
        this.fullscreenModal = null;
        this.engine.setCallbacks(
          this.onWordChange.bind(this),
          this.onComplete.bind(this)
        );
        updatePlayPauseButtons(this.dom, this.engine.getIsPlaying());
        this.refreshDisplayAfterFullscreen();
      },
      this.timeoutManager
    );
    this.fullscreenModal = modal;
    modal.open();
  }
  /**
   * Refreshes the sidebar display after returning from fullscreen
   * Shows the current word position and updates all UI elements
   */
  refreshDisplayAfterFullscreen() {
    const currentIndex = this.engine.getCurrentIndex();
    const totalWords = this.engine.getTotalWords();
    const words = this.engine.getWords();
    if (this.minimapManager) {
      this.minimapManager.updateCurrentPosition(currentIndex);
    }
    const progress = this.engine.getProgress();
    this.dom.updateStyle("progressBar", "width", `${progress}%`);
    this.updateStats();
    if (currentIndex > 0 && currentIndex < totalWords && words[currentIndex]) {
      const word = words[currentIndex];
      const headingMatch = word.match(/^\[H(\d)\]/);
      const calloutMatch = word.match(/^\[CALLOUT:([\w-]+)\]/);
      let displayText = word;
      let headingLevel = 0;
      let showSeparator = false;
      let calloutType;
      if (headingMatch) {
        headingLevel = parseInt(headingMatch[1]);
        displayText = word.replace(/^\[H\d\]/, "");
        showSeparator = true;
      } else if (calloutMatch) {
        calloutType = calloutMatch[1];
        displayText = word.replace(/^\[CALLOUT:[\w-]+\]/, "");
        showSeparator = true;
      }
      this.wordDisplay.displayWord(displayText, headingLevel, showSeparator, calloutType);
      const context = this.engine.getCurrentHeadingContext(currentIndex);
      if (context.breadcrumb.length > 0 && this.breadcrumbManager) {
        this.breadcrumbManager.updateBreadcrumb(context);
      }
    } else {
      const remainingWords = this.engine.getRemainingWords();
      const durationText = this.statsFormatter.formatTime(this.engine.getEstimatedDuration());
      this.wordDisplay.displayReadyMessage(
        remainingWords,
        totalWords,
        currentIndex > 0 ? currentIndex : void 0,
        durationText
      );
    }
  }
  // ============================================================================
  // SECTION 5: AUTO-LOAD SYSTEM
  // ============================================================================
  /**
   * Sets up automatic text loading from editor
   *
   * Registers event handlers for:
   * - file-open: Load text when opening a file
   * - active-leaf-change: Load text when switching files
   * - mouseup: Check for selection/cursor changes
   * - keyup: Check for navigation/selection keys
   *
   * Actual tracking logic is encapsulated in AutoLoadManager
   */
  setupAutoLoad() {
    this.registerEvent(
      this.app.workspace.on("file-open", (file) => {
        if (!file)
          return;
        this.autoLoadManager.resetForNewFile(file.path);
        this.autoLoadManager.loadFromEditor(TIMING.autoLoadDelay);
      })
    );
    this.registerEvent(
      this.app.workspace.on("active-leaf-change", () => {
        if (!this.mainContainerEl || !this.mainContainerEl.isShown())
          return;
        const currentFile = this.app.workspace.getActiveFile();
        if (currentFile && this.autoLoadManager.hasFileChanged(currentFile.path)) {
          this.autoLoadManager.resetForNewFile(currentFile.path);
          this.autoLoadManager.loadFromEditor(TIMING.autoLoadDelayShort);
        }
      })
    );
    this.registerDomEvent(document, "mouseup", () => {
      this.timeoutManager.setTimeout(() => {
        if (this.mainContainerEl.isShown()) {
          this.autoLoadManager.checkSelectionOrCursor();
        }
      }, TIMING.autoLoadDelayVeryShort);
    });
    this.registerDomEvent(document, "keyup", (evt) => {
      if (isNavigationKey(evt) || isSelectionKey(evt)) {
        this.timeoutManager.setTimeout(() => {
          if (this.mainContainerEl.isShown()) {
            this.autoLoadManager.checkSelectionOrCursor();
          }
        }, TIMING.autoLoadDelayVeryShort);
      }
    });
  }
  // ============================================================================
  // SECTION 6: HOTKEYS & KEYBOARD
  // ============================================================================
  /**
   * Sets up keyboard shortcuts for playback control
   */
  setupHotkeys() {
    document.addEventListener("keydown", this.handleKeyPress.bind(this));
  }
  /**
   * Handles keyboard shortcuts
   *
   * Shortcuts:
   * - C: Toggle controls (when not playing)
   * - S: Toggle stats (when not playing)
   * - F: Open fullscreen mode
   * - Shift+Space: Play/Pause
   * - Arrow keys: Rewind/Forward, WPM adjustment
   * - Escape: Stop reading
   *
   * @param e - Keyboard event
   */
  handleKeyPress(e) {
    if (!this.mainContainerEl.isShown())
      return;
    if (e.key === "c" && !this.engine.getIsPlaying()) {
      e.preventDefault();
      this.togglePanel("controls");
      return;
    }
    if (e.key === "s" && !this.engine.getIsPlaying()) {
      e.preventDefault();
      this.togglePanel("stats");
      return;
    }
    if (e.key === "f" || e.key === "F") {
      e.preventDefault();
      this.openFullscreen();
      return;
    }
    this.hotkeyHandler.handleKeyPress(e);
  }
  /**
   * Toggles play/pause state
   * Updates UI buttons accordingly
   */
  togglePlay() {
    if (this.engine.getIsPlaying()) {
      this.engine.pause();
      updatePlayPauseButtons(this.dom, false);
    } else {
      if (this.state.get("startTime") === 0) {
        this.state.set("startTime", Date.now());
      }
      this.engine.play();
      updatePlayPauseButtons(this.dom, true);
    }
  }
  // ============================================================================
  // SECTION 7: READING ENGINE CALLBACKS
  // ============================================================================
  /**
   * Called by engine when a new word is displayed
   * Updates the UI with the current word, context, progress, and stats
   *
   * @param chunk - Word chunk with text, index, delay info
   */
  onWordChange(chunk) {
    const headingMatch = chunk.text.match(/^\[H(\d)\]/);
    const calloutMatch = chunk.text.match(/^\[CALLOUT:([\w-]+)\]/);
    let displayText = chunk.text;
    let headingLevel = 0;
    let showSeparator = false;
    let calloutType;
    if (headingMatch) {
      headingLevel = parseInt(headingMatch[1]);
      displayText = chunk.text.replace(/^\[H\d\]/, "");
      showSeparator = true;
    } else if (calloutMatch) {
      calloutType = calloutMatch[1];
      displayText = chunk.text.replace(/^\[CALLOUT:[\w-]+\]/, "");
      showSeparator = true;
    }
    this.wordDisplay.displayWord(displayText, headingLevel, showSeparator, calloutType);
    if (chunk.headingContext && this.breadcrumbManager) {
      if (this.breadcrumbManager.hasHeadingContextChanged(chunk.headingContext)) {
        this.breadcrumbManager.updateBreadcrumb(chunk.headingContext);
      }
    }
    if (this.minimapManager) {
      this.minimapManager.updateCurrentPosition(chunk.index);
    }
    if (this.settings.showContext && this.contextBeforeEl && this.contextAfterEl) {
      const context = this.engine.getContext(this.settings.contextWords);
      this.contextBeforeEl.setText(context.before.join(" "));
      this.contextAfterEl.setText(context.after.join(" "));
    }
    const progress = this.engine.getProgress();
    this.dom.updateStyle("progressBar", "width", `${progress}%`);
    this.state.increment("wordsRead");
    this.updateStats();
  }
  /**
   * Called by engine when reading is complete
   * Updates UI to show completion message
   */
  onComplete() {
    updatePlayPauseButtons(this.dom, false);
    this.dom.updateText("statsText", `Completed! ${ICONS.celebration}`);
  }
  /**
   * Updates the stats display with current reading statistics
   * Shows: words read, elapsed time, current WPM, remaining time
   */
  updateStats() {
    const statsText = this.statsFormatter.formatReadingStats({
      wordsRead: this.state.get("wordsRead"),
      totalWords: this.engine.getTotalWords(),
      elapsedTime: this.engine.getElapsedTime(),
      currentWpm: this.engine.getCurrentWpmPublic(),
      remainingTime: this.engine.getRemainingTime()
    });
    this.dom.updateText("statsText", statsText);
  }
  // ============================================================================
  // SECTION 8: TEXT LOADING
  // ============================================================================
  /**
   * Parses markdown and calculates start position from cursor
   *
   * @param text - Raw markdown text
   * @param cursorPosition - Optional cursor position in raw text
   * @returns Object with plainText and wordIndex
   */
  parseAndCalculateStartPosition(text, cursorPosition) {
    const plainText = MarkdownParser.parseToPlainText(text);
    let wordIndex;
    if (cursorPosition !== void 0) {
      const textUpToCursor = text.substring(0, cursorPosition);
      const parsedUpToCursor = MarkdownParser.parseToPlainText(textUpToCursor);
      const wordsBeforeCursor = parsedUpToCursor.trim().split(/\s+/).filter((w) => w.length > 0);
      wordIndex = wordsBeforeCursor.length;
    }
    return { plainText, wordIndex };
  }
  /**
   * Updates stats display and word display with ready message
   *
   * @param wordIndex - Starting word index (if resuming from cursor)
   * @param source - Optional source information (filename, line number)
   */
  updateStatsDisplay(wordIndex, source) {
    const statsText = this.statsFormatter.formatLoadedStats({
      remainingWords: this.engine.getRemainingWords(),
      totalWords: this.engine.getTotalWords(),
      estimatedDuration: this.engine.getEstimatedDuration(),
      fileName: source == null ? void 0 : source.fileName,
      startWordIndex: wordIndex
    });
    this.dom.updateText("statsText", statsText);
    const durationText = this.statsFormatter.formatTime(this.engine.getEstimatedDuration());
    this.wordDisplay.displayReadyMessage(
      this.engine.getRemainingWords(),
      this.engine.getTotalWords(),
      wordIndex,
      durationText,
      source == null ? void 0 : source.fileName,
      source == null ? void 0 : source.lineNumber
    );
  }
  /**
   * Builds and displays initial breadcrumb based on starting position
   *
   * @param wordIndex - Starting word index (0 if starting from beginning)
   */
  buildInitialBreadcrumb(wordIndex) {
    const context = this.engine.getCurrentHeadingContext(wordIndex);
    if (context.breadcrumb.length > 0) {
      this.breadcrumbManager.updateBreadcrumb(context);
    }
  }
  /**
   * Handles auto-start functionality if enabled in settings
   * Starts reading after the configured delay
   */
  handleAutoStart() {
    if (!this.settings.autoStart)
      return;
    this.timeoutManager.setTimeout(() => {
      this.engine.play();
      updatePlayPauseButtons(this.dom, true);
      this.state.set("startTime", Date.now());
    }, this.settings.autoStartDelay * 1e3);
  }
  /**
   * Loads text for reading
   *
   * Process:
   * 1. Stop current reading if playing
   * 2. Parse markdown to plain text
   * 3. Calculate word index from cursor position (if provided)
   * 4. Validate text length
   * 5. Load into engine
   * 6. Update UI with ready message
   * 7. Auto-start if enabled
   *
   * @param text - Text to load (raw markdown)
   * @param source - Optional source information (filename, line, cursor position)
   */
  loadText(text, source) {
    if (this.engine.getIsPlaying()) {
      this.engine.stop();
      updatePlayPauseButtons(this.dom, false);
    }
    this.breadcrumbManager.reset();
    const { plainText, wordIndex: wordIndexFromCursor } = this.parseAndCalculateStartPosition(
      text,
      source == null ? void 0 : source.cursorPosition
    );
    if (!plainText || plainText.trim().length < TEXT_LIMITS.minParsedLength) {
      return;
    }
    this.engine.setText(plainText, void 0, wordIndexFromCursor);
    this.state.update({ wordsRead: 0, startTime: 0 });
    this.updateStatsDisplay(wordIndexFromCursor, source);
    this.buildInitialBreadcrumb(wordIndexFromCursor != null ? wordIndexFromCursor : 0);
    this.minimapManager.render();
    this.handleAutoStart();
  }
  // ============================================================================
  // SECTION 9: SETTINGS & LIFECYCLE
  // ============================================================================
  /**
   * Updates settings from plugin settings tab
   * Called when user changes settings in main settings panel
   *
   * @param settings - New settings
   */
  updateSettings(settings) {
    this.settings = settings;
    this.engine.updateSettings(settings);
    if (this.wordEl) {
      this.wordEl.style.fontSize = `${this.engine.getEffectiveFontSize()}px`;
      this.wordEl.style.fontFamily = settings.fontFamily;
      this.wordEl.style.color = settings.fontColor;
    }
    const wordEl = this.dom.get("wordEl");
    if (wordEl) {
      wordEl.toggleClass("dashreader-focus-enabled", settings.showFocusBars);
    }
    this.toggleBreadcrumbDisplay();
    this.dom.updateText("wpmDisplay", `${settings.wpm} WPM`);
  }
};

// src/settings.ts
var import_obsidian5 = require("obsidian");

// src/services/font-family.ts
var cachedFonts = null;
var COMMON_FONTS = [
  // Sans-serif
  "Arial",
  "Helvetica",
  "Helvetica Neue",
  "Verdana",
  "Trebuchet MS",
  "Tahoma",
  "Segoe UI",
  "Roboto",
  "Open Sans",
  "Inter",
  "SF Pro",
  "SF Pro Display",
  // Serif
  "Times New Roman",
  "Georgia",
  "Palatino",
  "Garamond",
  "Book Antiqua",
  "Literata",
  "Merriweather",
  // Monospace
  "Courier New",
  "Monaco",
  "Consolas",
  "Menlo",
  "SF Mono",
  "JetBrains Mono",
  "Fira Code",
  "Source Code Pro",
  // System defaults
  "system-ui",
  "-apple-system",
  "BlinkMacSystemFont"
];
async function getInstalledFontFamilies() {
  if (cachedFonts !== null) {
    return cachedFonts;
  }
  const queryLocalFonts = window.queryLocalFonts;
  if (typeof queryLocalFonts === "function") {
    try {
      const fonts = await queryLocalFonts();
      const families = /* @__PURE__ */ new Set();
      for (const font of fonts) {
        if (font.family) {
          families.add(font.family);
        }
      }
      cachedFonts = Array.from(families).sort(
        (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
      );
      return cachedFonts;
    } catch (e) {
    }
  }
  cachedFonts = [...COMMON_FONTS].sort(
    (a, b) => a.toLowerCase().localeCompare(b.toLowerCase())
  );
  return cachedFonts;
}

// src/settings.ts
var FontFamilySuggest = class {
  constructor(containerEl, currentValue, onSelect) {
    this.fonts = [];
    this.filteredFonts = [];
    this.selectedIndex = -1;
    this.isOpen = false;
    this.onSelect = onSelect;
    const inputContainer = containerEl.createDiv({
      cls: "dashreader-font-suggest-container"
    });
    this.inputEl = inputContainer.createEl("input", {
      type: "text",
      value: currentValue === "inherit" ? "" : currentValue,
      placeholder: "Type to search fonts...",
      cls: "dashreader-font-suggest-input"
    });
    if (currentValue && currentValue !== "inherit") {
      this.inputEl.style.fontFamily = currentValue;
    }
    this.suggestEl = inputContainer.createDiv({
      cls: "dashreader-font-suggest-dropdown"
    });
    void this.loadFonts();
    this.setupEvents();
  }
  async loadFonts() {
    this.fonts = [
      "inherit",
      "system-ui",
      "serif",
      "sans-serif",
      "monospace",
      "---",
      // separator
      ...await getInstalledFontFamilies()
    ];
    this.filteredFonts = this.fonts;
  }
  setupEvents() {
    this.inputEl.addEventListener("input", () => this.onInput());
    this.inputEl.addEventListener("focus", () => this.open());
    this.inputEl.addEventListener("blur", () => {
      setTimeout(() => this.close(), 150);
    });
    this.inputEl.addEventListener("keydown", (e) => this.onKeydown(e));
  }
  onInput() {
    const query = this.inputEl.value.toLowerCase().trim();
    if (!query) {
      this.filteredFonts = this.fonts;
    } else {
      this.filteredFonts = this.fonts.filter(
        (font) => font !== "---" && font.toLowerCase().includes(query)
      );
    }
    this.selectedIndex = -1;
    this.render();
    this.open();
  }
  onKeydown(e) {
    if (!this.isOpen) {
      if (e.key === "ArrowDown" || e.key === "Enter") {
        this.open();
        e.preventDefault();
      }
      return;
    }
    switch (e.key) {
      case "ArrowDown":
        e.preventDefault();
        this.selectNext();
        break;
      case "ArrowUp":
        e.preventDefault();
        this.selectPrevious();
        break;
      case "Enter":
        e.preventDefault();
        if (this.selectedIndex >= 0 && this.filteredFonts[this.selectedIndex]) {
          this.selectFont(this.filteredFonts[this.selectedIndex]);
        }
        break;
      case "Escape":
        e.preventDefault();
        this.close();
        break;
    }
  }
  selectNext() {
    let next = this.selectedIndex + 1;
    while (next < this.filteredFonts.length && this.filteredFonts[next] === "---") {
      next++;
    }
    if (next < this.filteredFonts.length) {
      this.selectedIndex = next;
      this.render();
      this.scrollToSelected();
    }
  }
  selectPrevious() {
    let prev = this.selectedIndex - 1;
    while (prev >= 0 && this.filteredFonts[prev] === "---") {
      prev--;
    }
    if (prev >= 0) {
      this.selectedIndex = prev;
      this.render();
      this.scrollToSelected();
    }
  }
  scrollToSelected() {
    const items = this.suggestEl.querySelectorAll(".dashreader-font-suggest-item");
    if (this.selectedIndex >= 0 && items[this.selectedIndex]) {
      items[this.selectedIndex].scrollIntoView({ block: "nearest" });
    }
  }
  selectFont(font) {
    if (font === "---")
      return;
    const displayValue = font === "inherit" ? "" : font;
    this.inputEl.value = displayValue;
    if (font !== "inherit" && font !== "system-ui") {
      this.inputEl.style.fontFamily = font;
    } else {
      this.inputEl.style.fontFamily = "";
    }
    this.onSelect(font);
    this.close();
  }
  open() {
    if (this.isOpen)
      return;
    this.isOpen = true;
    this.render();
    this.suggestEl.classList.add("is-open");
  }
  close() {
    this.isOpen = false;
    this.suggestEl.classList.remove("is-open");
  }
  render() {
    this.suggestEl.empty();
    const maxItems = 15;
    const itemsToShow = this.filteredFonts.slice(0, maxItems);
    itemsToShow.forEach((font, index) => {
      if (font === "---") {
        this.suggestEl.createDiv({ cls: "dashreader-font-suggest-separator" });
        return;
      }
      const item = this.suggestEl.createDiv({
        cls: "dashreader-font-suggest-item"
      });
      if (index === this.selectedIndex) {
        item.classList.add("is-selected");
      }
      const displayName = font === "inherit" ? "Default (theme)" : font;
      item.setText(displayName);
      if (!["inherit", "system-ui", "serif", "sans-serif", "monospace"].includes(font)) {
        item.style.fontFamily = font;
      }
      item.addEventListener("mousedown", (e) => {
        e.preventDefault();
        this.selectFont(font);
      });
      item.addEventListener("mouseenter", () => {
        this.selectedIndex = index;
        this.render();
      });
    });
    if (this.filteredFonts.length > maxItems) {
      const hint = this.suggestEl.createDiv({
        cls: "dashreader-font-suggest-hint",
        text: `${this.filteredFonts.length - maxItems} more fonts...`
      });
    }
  }
};
var DashReaderSettingTab = class extends import_obsidian5.PluginSettingTab {
  constructor(app, plugin) {
    super(app, plugin);
    this.plugin = plugin;
  }
  /**
   * Helper method to create a slider with an editable numeric display
   */
  createSliderWithInput(setting, min, max, step, value, unit = "", onChange) {
    const inputEl = setting.controlEl.createEl("input", {
      type: "text",
      value: value.toString(),
      cls: "dashreader-slider-input"
    });
    if (unit) {
      setting.controlEl.createSpan({
        text: unit,
        cls: "dashreader-slider-unit"
      });
    }
    setting.addSlider((slider) => slider.setLimits(min, max, step).setValue(value).setDynamicTooltip().onChange(async (newValue) => {
      inputEl.value = newValue.toString();
      await onChange(newValue);
    }));
    inputEl.addEventListener("change", () => void (async () => {
      let newValue = parseFloat(inputEl.value);
      if (isNaN(newValue)) {
        newValue = value;
      } else {
        newValue = Math.max(min, Math.min(max, newValue));
        newValue = Math.round(newValue / step) * step;
      }
      inputEl.value = newValue.toString();
      const sliderEl = setting.controlEl.querySelector('input[type="range"]');
      if (sliderEl) {
        sliderEl.value = newValue.toString();
      }
      await onChange(newValue);
    })());
  }
  display() {
    const { containerEl } = this;
    containerEl.empty();
    new import_obsidian5.Setting(containerEl).setName("Speed reader").setHeading();
    new import_obsidian5.Setting(containerEl).setName("Reading").setHeading();
    const wpmSetting = new import_obsidian5.Setting(containerEl).setName("Words per minute").setDesc("Reading speed (50-5000)");
    this.createSliderWithInput(
      wpmSetting,
      50,
      5e3,
      25,
      this.plugin.settings.wpm,
      "",
      async (value) => {
        this.plugin.settings.wpm = value;
        await this.plugin.saveSettings();
      }
    );
    const chunkSetting = new import_obsidian5.Setting(containerEl).setName("Words at a time").setDesc("Number of words displayed simultaneously (1-5)");
    this.createSliderWithInput(
      chunkSetting,
      1,
      5,
      1,
      this.plugin.settings.chunkSize,
      "",
      async (value) => {
        this.plugin.settings.chunkSize = value;
        await this.plugin.saveSettings();
      }
    );
    const fontSizeSetting = new import_obsidian5.Setting(containerEl).setName("Font size").setDesc("Font size in pixels (20-120px)");
    this.createSliderWithInput(
      fontSizeSetting,
      20,
      120,
      4,
      this.plugin.settings.fontSize,
      "px",
      async (value) => {
        this.plugin.settings.fontSize = value;
        await this.plugin.saveSettings();
      }
    );
    const fontSetting = new import_obsidian5.Setting(containerEl).setName("Font family").setDesc("Type to search system fonts, or choose a generic family");
    new FontFamilySuggest(
      fontSetting.controlEl,
      this.plugin.settings.fontFamily,
      async (value) => {
        this.plugin.settings.fontFamily = value;
        await this.plugin.saveSettings();
      }
    );
    new import_obsidian5.Setting(containerEl).setName("Mobile override").setHeading();
    containerEl.createEl("p", {
      text: "These settings override desktop values when running on iOS/Android.",
      cls: "setting-item-description"
    });
    const mobileWpmSetting = new import_obsidian5.Setting(containerEl).setName("Mobile: Words per minute").setDesc("Reading speed on mobile (50-5000)");
    this.createSliderWithInput(
      mobileWpmSetting,
      50,
      5e3,
      25,
      this.plugin.settings.mobileWpm,
      "",
      async (value) => {
        this.plugin.settings.mobileWpm = value;
        await this.plugin.saveSettings();
      }
    );
    const mobileFontSizeSetting = new import_obsidian5.Setting(containerEl).setName("Mobile: Font size").setDesc("Font size on mobile in pixels (20-120px)");
    this.createSliderWithInput(
      mobileFontSizeSetting,
      20,
      120,
      4,
      this.plugin.settings.mobileFontSize,
      "px",
      async (value) => {
        this.plugin.settings.mobileFontSize = value;
        await this.plugin.saveSettings();
      }
    );
    const mobileChunkSetting = new import_obsidian5.Setting(containerEl).setName("Mobile: Words at a time").setDesc("Number of words displayed on mobile (1-5)");
    this.createSliderWithInput(
      mobileChunkSetting,
      1,
      5,
      1,
      this.plugin.settings.mobileChunkSize,
      "",
      async (value) => {
        this.plugin.settings.mobileChunkSize = value;
        await this.plugin.saveSettings();
      }
    );
    new import_obsidian5.Setting(containerEl).setName("Mobile: Show breadcrumb").setDesc("Display breadcrumb navigation on mobile").addToggle((toggle) => toggle.setValue(this.plugin.settings.mobileShowBreadcrumb).onChange(async (value) => {
      this.plugin.settings.mobileShowBreadcrumb = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Mobile: Slow start").setDesc("Enable slow start on mobile").addToggle((toggle) => toggle.setValue(this.plugin.settings.mobileEnableSlowStart).onChange(async (value) => {
      this.plugin.settings.mobileEnableSlowStart = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Mobile: Micropause").setDesc("Enable micropause on mobile").addToggle((toggle) => toggle.setValue(this.plugin.settings.mobileEnableMicropause).onChange(async (value) => {
      this.plugin.settings.mobileEnableMicropause = value;
      await this.plugin.saveSettings();
    }));
    const mobileContextWordsSetting = new import_obsidian5.Setting(containerEl).setName("Mobile: Context words").setDesc("Number of context words on mobile (0-20)");
    this.createSliderWithInput(
      mobileContextWordsSetting,
      0,
      20,
      1,
      this.plugin.settings.mobileContextWords,
      "",
      async (value) => {
        this.plugin.settings.mobileContextWords = value;
        await this.plugin.saveSettings();
      }
    );
    const mobileContextFontSizeSetting = new import_obsidian5.Setting(containerEl).setName("Mobile: Context font size").setDesc("Font size for context text on mobile (10-32 px)");
    this.createSliderWithInput(
      mobileContextFontSizeSetting,
      10,
      32,
      1,
      this.plugin.settings.mobileContextFontSize,
      "px",
      async (value) => {
        this.plugin.settings.mobileContextFontSize = value;
        await this.plugin.saveSettings();
      }
    );
    new import_obsidian5.Setting(containerEl).setName("Reading enhancements").setHeading();
    new import_obsidian5.Setting(containerEl).setName("Slow start").setDesc("Gradually increase speed over first 5 words for comfortable start").addToggle((toggle) => toggle.setValue(this.plugin.settings.enableSlowStart).onChange(async (value) => {
      this.plugin.settings.enableSlowStart = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Enable acceleration").setDesc("Gradually increase reading speed over time").addToggle((toggle) => toggle.setValue(this.plugin.settings.enableAcceleration).onChange(async (value) => {
      this.plugin.settings.enableAcceleration = value;
      await this.plugin.saveSettings();
    }));
    const accelDurationSetting = new import_obsidian5.Setting(containerEl).setName("Acceleration duration").setDesc("Duration to reach target speed (seconds)");
    this.createSliderWithInput(
      accelDurationSetting,
      10,
      120,
      5,
      this.plugin.settings.accelerationDuration,
      "s",
      async (value) => {
        this.plugin.settings.accelerationDuration = value;
        await this.plugin.saveSettings();
      }
    );
    const accelTargetSetting = new import_obsidian5.Setting(containerEl).setName("Target wpm").setDesc("Target reading speed to reach (50-5000)");
    this.createSliderWithInput(
      accelTargetSetting,
      50,
      5e3,
      25,
      this.plugin.settings.accelerationTargetWpm,
      "",
      async (value) => {
        this.plugin.settings.accelerationTargetWpm = value;
        await this.plugin.saveSettings();
      }
    );
    new import_obsidian5.Setting(containerEl).setName("Appearance").setHeading();
    new import_obsidian5.Setting(containerEl).setName("Highlight color").setDesc("Color for the center character highlight").addText((text) => text.setPlaceholder("#4a9eff").setValue(this.plugin.settings.highlightColor).onChange(async (value) => {
      this.plugin.settings.highlightColor = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Font color").setDesc("Text color").addText((text) => text.setPlaceholder("#ffffff").setValue(this.plugin.settings.fontColor).onChange(async (value) => {
      this.plugin.settings.fontColor = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Background color").setDesc("Background color").addText((text) => text.setPlaceholder("#1e1e1e").setValue(this.plugin.settings.backgroundColor).onChange(async (value) => {
      this.plugin.settings.backgroundColor = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Context display").setHeading();
    new import_obsidian5.Setting(containerEl).setName("Show context").setDesc("Display words before and after current word").addToggle((toggle) => toggle.setValue(this.plugin.settings.showContext).onChange(async (value) => {
      this.plugin.settings.showContext = value;
      await this.plugin.saveSettings();
    }));
    const contextSetting = new import_obsidian5.Setting(containerEl).setName("Context words").setDesc("Number of context words to display (1-10)");
    this.createSliderWithInput(
      contextSetting,
      1,
      10,
      1,
      this.plugin.settings.contextWords,
      "",
      async (value) => {
        this.plugin.settings.contextWords = value;
        await this.plugin.saveSettings();
      }
    );
    const contextFontSizeSetting = new import_obsidian5.Setting(containerEl).setName("Context font size").setDesc("Font size for context text (10-32 px)");
    this.createSliderWithInput(
      contextFontSizeSetting,
      10,
      32,
      1,
      this.plugin.settings.contextFontSize,
      "px",
      async (value) => {
        this.plugin.settings.contextFontSize = value;
        await this.plugin.saveSettings();
      }
    );
    const minTokenFontSizeSetting = new import_obsidian5.Setting(containerEl).setName("Minimum token font size").setDesc("Minimum font size for long words that need shrinking (8-48 px)");
    this.createSliderWithInput(
      minTokenFontSizeSetting,
      8,
      48,
      1,
      this.plugin.settings.minTokenFontSize,
      "px",
      async (value) => {
        this.plugin.settings.minTokenFontSize = value;
        await this.plugin.saveSettings();
      }
    );
    new import_obsidian5.Setting(containerEl).setName("Show focus bars").setDesc("Display Reedy-style horizontal bars and vertical ORP indicator for enhanced focus").addToggle((toggle) => toggle.setValue(this.plugin.settings.showFocusBars).onChange(async (value) => {
      this.plugin.settings.showFocusBars = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Navigation").setHeading();
    new import_obsidian5.Setting(containerEl).setName("Show minimap").setDesc("Display vertical minimap with document structure and progress").addToggle((toggle) => toggle.setValue(this.plugin.settings.showMinimap).onChange(async (value) => {
      this.plugin.settings.showMinimap = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Show breadcrumb").setDesc("Display breadcrumb navigation at the top").addToggle((toggle) => toggle.setValue(this.plugin.settings.showBreadcrumb).onChange(async (value) => {
      this.plugin.settings.showBreadcrumb = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Micropause").setHeading();
    new import_obsidian5.Setting(containerEl).setName("Enable micropause").setDesc("Automatic pauses based on punctuation and word length").addToggle((toggle) => toggle.setValue(this.plugin.settings.enableMicropause).onChange(async (value) => {
      this.plugin.settings.enableMicropause = value;
      await this.plugin.saveSettings();
    }));
    const punctuationSetting = new import_obsidian5.Setting(containerEl).setName("Sentence-ending punctuation pause").setDesc("Pause multiplier for .,!? (1.0-3.0)");
    this.createSliderWithInput(
      punctuationSetting,
      1,
      3,
      0.1,
      this.plugin.settings.micropausePunctuation,
      "x",
      async (value) => {
        this.plugin.settings.micropausePunctuation = value;
        await this.plugin.saveSettings();
      }
    );
    const otherPunctuationSetting = new import_obsidian5.Setting(containerEl).setName("Other punctuation pause").setDesc("Pause multiplier for ;:, (1.0-3.0)");
    this.createSliderWithInput(
      otherPunctuationSetting,
      1,
      3,
      0.1,
      this.plugin.settings.micropauseOtherPunctuation,
      "x",
      async (value) => {
        this.plugin.settings.micropauseOtherPunctuation = value;
        await this.plugin.saveSettings();
      }
    );
    const longWordsSetting = new import_obsidian5.Setting(containerEl).setName("Long words pause").setDesc("Pause multiplier for long words >8 chars (1.0-2.0)");
    this.createSliderWithInput(
      longWordsSetting,
      1,
      2,
      0.1,
      this.plugin.settings.micropauseLongWords,
      "x",
      async (value) => {
        this.plugin.settings.micropauseLongWords = value;
        await this.plugin.saveSettings();
      }
    );
    const paragraphSetting = new import_obsidian5.Setting(containerEl).setName("Paragraph pause").setDesc("Pause multiplier for paragraph breaks (1.0-5.0)");
    this.createSliderWithInput(
      paragraphSetting,
      1,
      5,
      0.1,
      this.plugin.settings.micropauseParagraph,
      "x",
      async (value) => {
        this.plugin.settings.micropauseParagraph = value;
        await this.plugin.saveSettings();
      }
    );
    const numbersSetting = new import_obsidian5.Setting(containerEl).setName("Numbers pause").setDesc("Pause multiplier for numbers and dates (1.0-3.0)");
    this.createSliderWithInput(
      numbersSetting,
      1,
      3,
      0.1,
      this.plugin.settings.micropauseNumbers,
      "x",
      async (value) => {
        this.plugin.settings.micropauseNumbers = value;
        await this.plugin.saveSettings();
      }
    );
    const sectionMarkersSetting = new import_obsidian5.Setting(containerEl).setName("Section markers pause").setDesc("Pause multiplier for 1., i., a., etc. (1.0-3.0)");
    this.createSliderWithInput(
      sectionMarkersSetting,
      1,
      3,
      0.1,
      this.plugin.settings.micropauseSectionMarkers,
      "x",
      async (value) => {
        this.plugin.settings.micropauseSectionMarkers = value;
        await this.plugin.saveSettings();
      }
    );
    const listBulletsSetting = new import_obsidian5.Setting(containerEl).setName("List bullets pause").setDesc("Pause multiplier for -, *, +, \u2022 (1.0-3.0)");
    this.createSliderWithInput(
      listBulletsSetting,
      1,
      3,
      0.1,
      this.plugin.settings.micropauseListBullets,
      "x",
      async (value) => {
        this.plugin.settings.micropauseListBullets = value;
        await this.plugin.saveSettings();
      }
    );
    const calloutsSetting = new import_obsidian5.Setting(containerEl).setName("Callouts pause").setDesc("Pause multiplier for Obsidian callouts (1.0-3.0)");
    this.createSliderWithInput(
      calloutsSetting,
      1,
      3,
      0.1,
      this.plugin.settings.micropauseCallouts,
      "x",
      async (value) => {
        this.plugin.settings.micropauseCallouts = value;
        await this.plugin.saveSettings();
      }
    );
    new import_obsidian5.Setting(containerEl).setName("Auto-start").setHeading();
    new import_obsidian5.Setting(containerEl).setName("Auto-start reading").setDesc("Automatically start reading after text loads").addToggle((toggle) => toggle.setValue(this.plugin.settings.autoStart).onChange(async (value) => {
      this.plugin.settings.autoStart = value;
      await this.plugin.saveSettings();
    }));
    const autoStartDelaySetting = new import_obsidian5.Setting(containerEl).setName("Auto-start delay").setDesc("Delay before auto-start (seconds)");
    this.createSliderWithInput(
      autoStartDelaySetting,
      1,
      10,
      1,
      this.plugin.settings.autoStartDelay,
      "s",
      async (value) => {
        this.plugin.settings.autoStartDelay = value;
        await this.plugin.saveSettings();
      }
    );
    new import_obsidian5.Setting(containerEl).setName("Display").setHeading();
    new import_obsidian5.Setting(containerEl).setName("Show progress bar").setDesc("Display reading progress bar").addToggle((toggle) => toggle.setValue(this.plugin.settings.showProgress).onChange(async (value) => {
      this.plugin.settings.showProgress = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Show statistics").setDesc("Display reading statistics").addToggle((toggle) => toggle.setValue(this.plugin.settings.showStats).onChange(async (value) => {
      this.plugin.settings.showStats = value;
      await this.plugin.saveSettings();
    }));
    new import_obsidian5.Setting(containerEl).setName("Keyboard shortcuts").setHeading();
    containerEl.createEl("p", {
      text: "Note: hotkey customization is available in Obsidian's hotkeys settings.",
      cls: "setting-item-description"
    });
  }
};

// src/types.ts
var DEFAULT_SETTINGS = {
  // Desktop settings
  wpm: 400,
  // Increased from 300 (inspired by Stutter: 400-800 range)
  chunkSize: 1,
  fontSize: 48,
  highlightColor: "#4a9eff",
  backgroundColor: "#1e1e1e",
  fontColor: "#ffffff",
  fontFamily: "inherit",
  showContext: false,
  contextWords: 3,
  contextFontSize: 14,
  // Context text font size
  minTokenFontSize: 12,
  // Minimum font size for long word shrinking
  showFocusBars: false,
  // Reedy-style focus bars (off by default)
  showMinimap: true,
  showBreadcrumb: true,
  enableMicropause: true,
  micropausePunctuation: 2.5,
  // Sentence-ending punctuation (.,!?) - Stutter-inspired
  micropauseOtherPunctuation: 1.5,
  // Other punctuation (;:,) - lighter pause
  micropauseLongWords: 1.4,
  // Words >8 chars - Stutter-inspired
  micropauseParagraph: 2.5,
  // Paragraph breaks - better section separation
  micropauseNumbers: 1.8,
  // Numbers and dates - comprehension aid
  micropauseSectionMarkers: 2,
  // Section numbers (1., I., etc.)
  micropauseListBullets: 1.8,
  // List bullets (-, *, +, •)
  micropauseCallouts: 2,
  // Obsidian callouts
  autoStart: false,
  autoStartDelay: 3,
  showProgress: true,
  showStats: true,
  hotkeyPlay: "Space",
  hotkeyRewind: "ArrowLeft",
  hotkeyForward: "ArrowRight",
  hotkeyIncrementWpm: "ArrowUp",
  hotkeyDecrementWpm: "ArrowDown",
  hotkeyQuit: "Escape",
  enableSlowStart: true,
  // Enable slow start by default
  enableAcceleration: false,
  accelerationDuration: 30,
  accelerationTargetWpm: 600,
  // Increased from 450 (Stutter suggests 600-800)
  // Mobile overrides (smaller font, slower speed for better mobile experience)
  mobileFontSize: 32,
  mobileWpm: 350,
  mobileChunkSize: 1,
  mobileShowBreadcrumb: true,
  mobileEnableSlowStart: true,
  mobileEnableMicropause: true,
  mobileContextWords: 2,
  // Fewer context words on mobile
  mobileContextFontSize: 12
  // Smaller context font on mobile
};

// src/services/settings-validator.ts
var LIMITS2 = {
  wpm: { min: 50, max: 5e3 },
  chunkSize: { min: 1, max: 10 },
  fontSize: { min: 12, max: 120 },
  contextWords: { min: 0, max: 20 },
  contextFontSize: { min: 10, max: 32 },
  minTokenFontSize: { min: 8, max: 48 },
  autoStartDelay: { min: 0, max: 60 },
  accelerationDuration: { min: 1, max: 300 },
  accelerationTargetWpm: { min: 50, max: 5e3 },
  micropauseMultiplier: { min: 1, max: 10 }
};
function clamp(value, min, max) {
  return Math.max(min, Math.min(max, value));
}
function validateColor(color, defaultColor) {
  if (typeof color !== "string")
    return defaultColor;
  if (/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(color)) {
    return color;
  }
  return defaultColor;
}
function validateNumber(value, defaultValue, min, max) {
  if (typeof value !== "number" || isNaN(value)) {
    return defaultValue;
  }
  return clamp(value, min, max);
}
function validateBoolean(value, defaultValue) {
  if (typeof value === "boolean")
    return value;
  return defaultValue;
}
function validateString(value, defaultValue) {
  if (typeof value === "string")
    return value;
  return defaultValue;
}
function validateSettings(partial) {
  if (!partial || typeof partial !== "object") {
    return { ...DEFAULT_SETTINGS };
  }
  return {
    // Numeric settings with range validation
    wpm: validateNumber(
      partial.wpm,
      DEFAULT_SETTINGS.wpm,
      LIMITS2.wpm.min,
      LIMITS2.wpm.max
    ),
    chunkSize: validateNumber(
      partial.chunkSize,
      DEFAULT_SETTINGS.chunkSize,
      LIMITS2.chunkSize.min,
      LIMITS2.chunkSize.max
    ),
    fontSize: validateNumber(
      partial.fontSize,
      DEFAULT_SETTINGS.fontSize,
      LIMITS2.fontSize.min,
      LIMITS2.fontSize.max
    ),
    contextWords: validateNumber(
      partial.contextWords,
      DEFAULT_SETTINGS.contextWords,
      LIMITS2.contextWords.min,
      LIMITS2.contextWords.max
    ),
    contextFontSize: validateNumber(
      partial.contextFontSize,
      DEFAULT_SETTINGS.contextFontSize,
      LIMITS2.contextFontSize.min,
      LIMITS2.contextFontSize.max
    ),
    minTokenFontSize: validateNumber(
      partial.minTokenFontSize,
      DEFAULT_SETTINGS.minTokenFontSize,
      LIMITS2.minTokenFontSize.min,
      LIMITS2.minTokenFontSize.max
    ),
    autoStartDelay: validateNumber(
      partial.autoStartDelay,
      DEFAULT_SETTINGS.autoStartDelay,
      LIMITS2.autoStartDelay.min,
      LIMITS2.autoStartDelay.max
    ),
    accelerationDuration: validateNumber(
      partial.accelerationDuration,
      DEFAULT_SETTINGS.accelerationDuration,
      LIMITS2.accelerationDuration.min,
      LIMITS2.accelerationDuration.max
    ),
    accelerationTargetWpm: validateNumber(
      partial.accelerationTargetWpm,
      DEFAULT_SETTINGS.accelerationTargetWpm,
      LIMITS2.accelerationTargetWpm.min,
      LIMITS2.accelerationTargetWpm.max
    ),
    // Micropause multipliers
    micropausePunctuation: validateNumber(
      partial.micropausePunctuation,
      DEFAULT_SETTINGS.micropausePunctuation,
      LIMITS2.micropauseMultiplier.min,
      LIMITS2.micropauseMultiplier.max
    ),
    micropauseOtherPunctuation: validateNumber(
      partial.micropauseOtherPunctuation,
      DEFAULT_SETTINGS.micropauseOtherPunctuation,
      LIMITS2.micropauseMultiplier.min,
      LIMITS2.micropauseMultiplier.max
    ),
    micropauseLongWords: validateNumber(
      partial.micropauseLongWords,
      DEFAULT_SETTINGS.micropauseLongWords,
      LIMITS2.micropauseMultiplier.min,
      LIMITS2.micropauseMultiplier.max
    ),
    micropauseParagraph: validateNumber(
      partial.micropauseParagraph,
      DEFAULT_SETTINGS.micropauseParagraph,
      LIMITS2.micropauseMultiplier.min,
      LIMITS2.micropauseMultiplier.max
    ),
    micropauseNumbers: validateNumber(
      partial.micropauseNumbers,
      DEFAULT_SETTINGS.micropauseNumbers,
      LIMITS2.micropauseMultiplier.min,
      LIMITS2.micropauseMultiplier.max
    ),
    micropauseSectionMarkers: validateNumber(
      partial.micropauseSectionMarkers,
      DEFAULT_SETTINGS.micropauseSectionMarkers,
      LIMITS2.micropauseMultiplier.min,
      LIMITS2.micropauseMultiplier.max
    ),
    micropauseListBullets: validateNumber(
      partial.micropauseListBullets,
      DEFAULT_SETTINGS.micropauseListBullets,
      LIMITS2.micropauseMultiplier.min,
      LIMITS2.micropauseMultiplier.max
    ),
    micropauseCallouts: validateNumber(
      partial.micropauseCallouts,
      DEFAULT_SETTINGS.micropauseCallouts,
      LIMITS2.micropauseMultiplier.min,
      LIMITS2.micropauseMultiplier.max
    ),
    // Color settings
    highlightColor: validateColor(partial.highlightColor, DEFAULT_SETTINGS.highlightColor),
    backgroundColor: validateColor(partial.backgroundColor, DEFAULT_SETTINGS.backgroundColor),
    fontColor: validateColor(partial.fontColor, DEFAULT_SETTINGS.fontColor),
    // String settings
    fontFamily: validateString(partial.fontFamily, DEFAULT_SETTINGS.fontFamily),
    hotkeyPlay: validateString(partial.hotkeyPlay, DEFAULT_SETTINGS.hotkeyPlay),
    hotkeyRewind: validateString(partial.hotkeyRewind, DEFAULT_SETTINGS.hotkeyRewind),
    hotkeyForward: validateString(partial.hotkeyForward, DEFAULT_SETTINGS.hotkeyForward),
    hotkeyIncrementWpm: validateString(partial.hotkeyIncrementWpm, DEFAULT_SETTINGS.hotkeyIncrementWpm),
    hotkeyDecrementWpm: validateString(partial.hotkeyDecrementWpm, DEFAULT_SETTINGS.hotkeyDecrementWpm),
    hotkeyQuit: validateString(partial.hotkeyQuit, DEFAULT_SETTINGS.hotkeyQuit),
    // Boolean settings
    showContext: validateBoolean(partial.showContext, DEFAULT_SETTINGS.showContext),
    showFocusBars: validateBoolean(partial.showFocusBars, DEFAULT_SETTINGS.showFocusBars),
    showMinimap: validateBoolean(partial.showMinimap, DEFAULT_SETTINGS.showMinimap),
    showBreadcrumb: validateBoolean(partial.showBreadcrumb, DEFAULT_SETTINGS.showBreadcrumb),
    enableMicropause: validateBoolean(partial.enableMicropause, DEFAULT_SETTINGS.enableMicropause),
    autoStart: validateBoolean(partial.autoStart, DEFAULT_SETTINGS.autoStart),
    showProgress: validateBoolean(partial.showProgress, DEFAULT_SETTINGS.showProgress),
    showStats: validateBoolean(partial.showStats, DEFAULT_SETTINGS.showStats),
    enableSlowStart: validateBoolean(partial.enableSlowStart, DEFAULT_SETTINGS.enableSlowStart),
    enableAcceleration: validateBoolean(partial.enableAcceleration, DEFAULT_SETTINGS.enableAcceleration),
    // Mobile override settings
    mobileFontSize: validateNumber(
      partial.mobileFontSize,
      DEFAULT_SETTINGS.mobileFontSize,
      LIMITS2.fontSize.min,
      LIMITS2.fontSize.max
    ),
    mobileWpm: validateNumber(
      partial.mobileWpm,
      DEFAULT_SETTINGS.mobileWpm,
      LIMITS2.wpm.min,
      LIMITS2.wpm.max
    ),
    mobileChunkSize: validateNumber(
      partial.mobileChunkSize,
      DEFAULT_SETTINGS.mobileChunkSize,
      LIMITS2.chunkSize.min,
      LIMITS2.chunkSize.max
    ),
    mobileShowBreadcrumb: validateBoolean(partial.mobileShowBreadcrumb, DEFAULT_SETTINGS.mobileShowBreadcrumb),
    mobileEnableSlowStart: validateBoolean(partial.mobileEnableSlowStart, DEFAULT_SETTINGS.mobileEnableSlowStart),
    mobileEnableMicropause: validateBoolean(partial.mobileEnableMicropause, DEFAULT_SETTINGS.mobileEnableMicropause),
    mobileContextWords: validateNumber(
      partial.mobileContextWords,
      DEFAULT_SETTINGS.mobileContextWords,
      LIMITS2.contextWords.min,
      LIMITS2.contextWords.max
    ),
    mobileContextFontSize: validateNumber(
      partial.mobileContextFontSize,
      DEFAULT_SETTINGS.mobileContextFontSize,
      LIMITS2.contextFontSize.min,
      LIMITS2.contextFontSize.max
    )
  };
}

// main.ts
var DashReaderPlugin = class extends import_obsidian6.Plugin {
  async onload() {
    await this.loadSettings();
    this.registerView(
      VIEW_TYPE_DASHREADER,
      (leaf) => new DashReaderView(leaf, this.settings)
    );
    this.addRibbonIcon("zap", "RSVP sidebar", () => {
      void this.activateView();
    });
    this.addRibbonIcon("scan", "RSVP fullscreen", () => {
      const text = this.getActiveTextOrSelection();
      if (!text) {
        new import_obsidian6.Notice("No text to read. Open a note or select text first.");
        return;
      }
      const plainText = MarkdownParser.parseToPlainText(text);
      if (!plainText || plainText.trim().length < 10) {
        new import_obsidian6.Notice("Text too short to read");
        return;
      }
      const timeoutManager = new TimeoutManager();
      const engine = new RSVPEngine(
        this.settings,
        () => {
        },
        // Will be overridden by modal
        () => {
        },
        // Will be overridden by modal
        timeoutManager
      );
      engine.setText(plainText);
      const modal = new FullscreenModal(
        this.app,
        engine,
        this.settings,
        () => {
          timeoutManager.clearAll();
        },
        timeoutManager
      );
      modal.open();
      engine.play();
    });
    this.addCommand({
      id: "open",
      name: "Open speed reader",
      callback: () => {
        void this.activateView();
      }
    });
    this.addCommand({
      id: "read-selection",
      name: "Read selected text",
      editorCallback: (editor) => {
        const selection = editor.getSelection();
        if (selection) {
          void this.activateView().then(() => {
            const view = this.getView();
            if (view) {
              view.loadText(selection);
            }
          });
        } else {
          new import_obsidian6.Notice("Please select some text first");
        }
      }
    });
    this.addCommand({
      id: "read-note",
      name: "Read entire note",
      callback: () => {
        const activeView = this.app.workspace.getActiveViewOfType(import_obsidian6.MarkdownView);
        if (activeView) {
          const content = activeView.editor.getValue();
          void this.activateView().then(() => {
            const view = this.getView();
            if (view) {
              view.loadText(content);
            }
          });
        } else {
          new import_obsidian6.Notice("No active note found");
        }
      }
    });
    this.addCommand({
      id: "read-fullscreen",
      name: "Read in fullscreen mode",
      callback: () => {
        const text = this.getActiveTextOrSelection();
        if (!text) {
          new import_obsidian6.Notice("No text to read. Open a note or select text first.");
          return;
        }
        const plainText = MarkdownParser.parseToPlainText(text);
        if (!plainText || plainText.trim().length < 10) {
          new import_obsidian6.Notice("Text too short to read");
          return;
        }
        const timeoutManager = new TimeoutManager();
        const engine = new RSVPEngine(
          this.settings,
          () => {
          },
          // Will be overridden by modal
          () => {
          },
          // Will be overridden by modal
          timeoutManager
        );
        engine.setText(plainText);
        const modal = new FullscreenModal(
          this.app,
          engine,
          this.settings,
          () => {
            timeoutManager.clearAll();
          },
          timeoutManager
        );
        modal.open();
        engine.play();
      }
    });
    this.addCommand({
      id: "toggle-play-pause",
      name: "Toggle play/pause",
      callback: () => {
        new import_obsidian6.Notice("Use Shift+Space key when speed reader is active");
      }
    });
    this.registerEvent(
      this.app.workspace.on("editor-menu", (menu, editor) => {
        const selection = editor.getSelection();
        if (selection) {
          menu.addItem((item) => {
            item.setTitle("Read with speed reader").setIcon("zap").onClick(() => {
              void this.activateView().then(() => {
                const view = this.getView();
                if (view) {
                  view.loadText(selection);
                }
              });
            });
          });
        }
      })
    );
    this.addSettingTab(new DashReaderSettingTab(this.app, this));
    this.registerEvent(
      this.app.workspace.on("layout-change", () => {
        const view = this.getView();
        if (view) {
          view.updateSettings(this.settings);
        }
      })
    );
  }
  onunload() {
  }
  getView() {
    const leaves = this.app.workspace.getLeavesOfType(VIEW_TYPE_DASHREADER);
    if (leaves.length > 0) {
      return leaves[0].view;
    }
    return null;
  }
  /**
   * Gets text from selection or active note
   * Prioritizes selection over full note content
   */
  getActiveTextOrSelection() {
    const activeView = this.app.workspace.getActiveViewOfType(import_obsidian6.MarkdownView);
    if (!activeView) {
      return null;
    }
    const editor = activeView.editor;
    const selection = editor.getSelection();
    if (selection && selection.trim().length > 0) {
      return selection;
    }
    const content = editor.getValue();
    if (content && content.trim().length > 0) {
      return content;
    }
    return null;
  }
  async loadSettings() {
    const rawSettings = await this.loadData();
    this.settings = validateSettings(rawSettings);
  }
  async saveSettings() {
    await this.saveData(this.settings);
    const view = this.getView();
    if (view) {
      view.updateSettings(this.settings);
    }
  }
  async activateView() {
    const { workspace } = this.app;
    let leaf = null;
    const leaves = workspace.getLeavesOfType(VIEW_TYPE_DASHREADER);
    if (leaves.length > 0) {
      leaf = leaves[0];
    } else {
      leaf = workspace.getRightLeaf(false);
      if (leaf) {
        await leaf.setViewState({
          type: VIEW_TYPE_DASHREADER,
          active: true
        });
      }
    }
    if (leaf) {
      void workspace.revealLeaf(leaf);
    }
  }
};