@readium/navigator 2.4.0-alpha.8 → 2.4.0-beta.1

package/src/epub/fxl/FXLFramePoolManager.ts

@@ -1,7 +1,7 @@
 import { ModuleName } from "@readium/navigator-html-injectables";
 import { Locator, Publication, ReadingProgression, Page, Link } from "@readium/shared";
 import { FrameCommsListener } from "../frame";
-import FrameBlobBuilder from "../frame/FrameBlobBuilder";
+import FrameBlobBuider from "../frame/FrameBlobBuilder";
 import { FXLFrameManager } from "./FXLFrameManager";
 import { FXLPeripherals } from "./FXLPeripherals";
 import { FXLSpreader, Orientation, Spread } from "./FXLSpreader";
@@ -21,7 +21,7 @@ export class FXLFramePoolManager {
     private readonly container: HTMLElement;
     private readonly positions: Locator[];
     private readonly pool: Map<string, FXLFrameManager> = new Map();
-    private readonly blobs: Map<string, FrameBlobBuilder> = new Map();
+    private readonly blobs: Map<string, string> = new Map();
     private readonly inprogress: Map<string, Promise<void>> = new Map();
     private readonly delayedShow: Map<string, Promise<void>> = new Map();
     private readonly delayedTimeout: Map<string, number> = new Map();
@@ -86,18 +86,16 @@ export class FXLFramePoolManager {
 
         this.peripherals = new FXLPeripherals(this);
 
-        const fragment = document.createDocumentFragment();
         this.pub.readingOrder.items.forEach((link) => {
             // Create <iframe>
             const fm = new FXLFrameManager(this.peripherals, this.pub.metadata.effectiveReadingProgression, link.href, this.contentProtectionConfig, this.keyboardPeripheralsConfig);
+            this.spineElement.appendChild(fm.element);
 
+            // this.pages.push(fm);
             this.pool.set(link.href, fm);
             fm.width = 100 / this.length * (link.properties?.otherProperties["orientation"] === Orientation.landscape || link.properties?.otherProperties["addBlank"] ? this.perPage : 1);
             fm.height = this.height;
-            fragment.appendChild(fm.wrapper);
         });
-        this.spineElement.appendChild(fragment);
-
     }
 
     private _listener!: FrameCommsListener;
@@ -136,18 +134,15 @@ export class FXLFramePoolManager {
 
         clearTimeout(this.resizeTimeout);
         this.resizeTimeout = window.setTimeout(() => {
-            const baseWidthFactor = 100 / this.length;
-            const itemLookup = new Map(this.pub.readingOrder.items.map(item => [item.href, item]));
+            // TODO optimize this expensive set of loops and operations 
             this.pool.forEach((frm, linkHref) => {
-                const link = itemLookup.get(linkHref);
-                if(!link) return;
-                requestAnimationFrame(() => {
-                    frm.width = baseWidthFactor * (link.properties?.otherProperties["orientation"] === Orientation.landscape || link.properties?.otherProperties["addBlank"] ? this.perPage : 1);
-                    frm.height = this.height;
-                    if(!frm.loaded) return;
-                    const spread = this.spreader.findByLink(link)!;
-                    frm.update(this.spreadPosition(spread, link));
-                });
+                let i = this.pub.readingOrder.items.findIndex(l => l.href === linkHref);
+                const link = this.pub.readingOrder.items[i];
+                frm.width = 100 / this.length * (link.properties?.otherProperties["orientation"] === Orientation.landscape || link.properties?.otherProperties["addBlank"] ? this.perPage : 1);
+                frm.height = this.height;
+                if(!frm.loaded) return;
+                const spread = this.spreader.findByLink(link)!;
+                frm.update(this.spreadPosition(spread, link));
             });
         }, RESIZE_UPDATE_TIMEOUT);
     }
@@ -410,8 +405,7 @@ export class FXLFramePoolManager {
         this.pool.clear();
 
         // Revoke all blobs
-        this.blobs.forEach(v => v.reset());
-        this.blobs.clear();
+        this.blobs.forEach(v => URL.revokeObjectURL(v));
 
         // Clean up injector if it exists
         this.injector?.dispose();
@@ -502,13 +496,13 @@ export class FXLFramePoolManager {
                 if(!this.pool.has(href)) return;
                 this.cancelShowing(href);
                 await this.pool.get(href)?.unload();
-                this.blobs.get(href)?.reset();
+                // this.pool.delete(href);
             });
 
             // Check if base URL of publication has changed
             if(this.currentBaseURL !== undefined && pub.baseURL !== this.currentBaseURL) {
                 // Revoke all blobs
-                this.blobs.forEach(v => v.reset());
+                this.blobs.forEach(v => URL.revokeObjectURL(v));
                 this.blobs.clear();
             }
             this.currentBaseURL = pub.baseURL;
@@ -518,14 +512,16 @@ export class FXLFramePoolManager {
                 const itm = pub.readingOrder.items[index];
                 if(!itm) return; // TODO throw?
                 if(!this.blobs.has(href)) {
-                    this.blobs.set(href, new FrameBlobBuilder(
+                    const blobBuilder = new FrameBlobBuider(
                         pub, 
                         this.currentBaseURL || "", 
                         itm,
                         {
                             injector: this.injector
                         }
-                    ));
+                    );
+                    const blobURL = await blobBuilder.build(true);
+                    this.blobs.set(href, blobURL);
                 }
 
                 // Show future offscreen frame in advance after a delay
@@ -539,7 +535,7 @@ export class FXLFramePoolManager {
                             const spread = this.makeSpread(this.reAlign(index));
                             const page = this.spreadPosition(spread, itm);
                             const fm = this.pool.get(href)!;
-                            await fm.load(modules, await this.blobs.get(href)!.build(true));
+                            await fm.load(modules, this.blobs.get(href)!);
                             if(!this.peripherals.isScaled) // When scaled, positioning is screwed up, so wait to show
                                 await fm.show(page); // Show/activate new frame
                             this.delayedShow.delete(href);
@@ -563,10 +559,10 @@ export class FXLFramePoolManager {
             for (const s of spread) {
                 const newFrame = this.pool.get(s.href)!;
                 const source = this.blobs.get(s.href);
-                if(!source) continue; // Thfis can get destroyed
+                if(!source) continue; // This can get destroyed
 
                 this.cancelShowing(s.href);
-                await newFrame.load(modules, await source.build(true)); // In order to ensure modules match the latest configuration
+                await newFrame.load(modules, source); // In order to ensure modules match the latest configuration
                 await newFrame.show(this.spreadPosition(spread, s)); // Show/activate new frame
                 this.previousFrames.push(newFrame);
                 await newFrame.activate();

package/src/epub/preferences/EpubPreferences.ts

@@ -59,7 +59,7 @@ export interface IEpubPreferences {
   wordSpacing?: number | null
 }
 
-export class EpubPreferences implements ConfigurablePreferences {
+export class EpubPreferences implements ConfigurablePreferences<EpubPreferences> {
   backgroundColor?: string | null;
   blendFilter?: boolean | null;
   constraint?: number | null;
@@ -160,7 +160,7 @@ export class EpubPreferences implements ConfigurablePreferences {
     }
   }
 
-  merging(other: ConfigurablePreferences): ConfigurablePreferences {
+  merging(other: EpubPreferences): EpubPreferences {
     const merged: IEpubPreferences = { ...this };
     for (const key of Object.keys(other) as (keyof IEpubPreferences)[]) {
       if (
@@ -172,11 +172,11 @@ export class EpubPreferences implements ConfigurablePreferences {
         ) &&
         (
           key !== "minimalLineLength" ||
-          other[key] === null || 
+          other[key] === null ||
           (other[key] <= (other.optimalLineLength ?? merged.optimalLineLength ?? 65))
         )
       ) {
-        merged[key] = other[key];
+        (merged as Record<string, unknown>)[key] = other[key];
       }
     }
     return new EpubPreferences(merged);

package/src/injection/Injector.ts

@@ -155,7 +155,7 @@ export class Injector implements IInjector {
         return [...this.allowedDomains]; // Return a copy to prevent external modification
     }
 
-    public async injectForDocument(doc: Document, link: Link): Promise<void> {
+    public async injectForDocument(doc: Document, link: Link): Promise<void> {        
         for (const rule of this.rules) {
             if (this.matchesRule(rule, link)) {
                 await this.applyRule(doc, rule);
@@ -178,7 +178,7 @@ export class Injector implements IInjector {
     private async getOrCreateBlobUrl(resource: IInjectable): Promise<string> {
         // Use the injectable ID as the cache key
         const cacheKey = resource.id!; // ID is guaranteed to exist after constructor
-
+        
         if (this.blobStore.has(cacheKey)) {
             const entry = this.blobStore.get(cacheKey)!;
             entry.refCount++;
@@ -191,7 +191,7 @@ export class Injector implements IInjector {
             this.createdBlobUrls.add(url);
             return url;
         }
-
+        
         throw new Error("Resource must have a blob property");
     }
 
@@ -304,13 +304,13 @@ export class Injector implements IInjector {
         let url: string | null = null;
         try {
             url = await this.getResourceUrl(resource, doc);
-
+            
             if (resource.rel === "preload" && "url" in resource) {
                 this.createPreloadLink(doc, resource, url);
             } else {
                 const element = this.createElement(doc, resource, url);
                 createdElements.push({ element, url });
-
+                
                 if (position === "prepend") {
                     target.prepend(element);
                 } else {

package/src/preferences/Configurable.ts

@@ -4,9 +4,8 @@ export interface ConfigurableSettings {
   [key: string]: any;
 }
 
-export interface ConfigurablePreferences {
-  [key: string]: any;
-  merging(other: ConfigurablePreferences): ConfigurablePreferences;
+export interface ConfigurablePreferences<T> {
+  merging(other: T): T;
 }
 
 export interface Configurable<ConfigurableSettings, ConfigurablePreferences> {

package/src/preferences/PreferencesEditor.ts

@@ -1,6 +1,6 @@
 import { ConfigurablePreferences } from "./Configurable";
 
 export interface IPreferencesEditor {
-  preferences: ConfigurablePreferences;
+  preferences: ConfigurablePreferences<unknown>;
   clear(): void;
 }

package/src/preferences/Types.ts

@@ -16,6 +16,8 @@ export type RangeConfig = {
   step: number
 }
 
+// ReadiumCSS preferences
+
 export const filterRangeConfig: RangeConfig = {
   range: [0, 100],
   step: 1
@@ -69,4 +71,21 @@ export const wordSpacingRangeConfig: RangeConfig = {
 export const zoomRangeConfig: RangeConfig = {
   range: [0.7, 4],
   step: 0.05
+}
+
+// Audio preferences
+
+export const volumeRangeConfig: RangeConfig = {
+  range: [0, 1],
+  step: 0.1
+}
+
+export const playbackRateRangeConfig: RangeConfig = {
+  range: [0.5, 2],
+  step: 0.25
+}
+
+export const skipIntervalRangeConfig: RangeConfig = {
+  range: [5, 60],
+  step: 5
 }

package/src/webpub/WebPubNavigator.ts

@@ -12,7 +12,6 @@ import { WebUserProperties, WebRSProperties } from "./css/Properties";
 import { IWebPubPreferences, WebPubPreferences } from "./preferences/WebPubPreferences";
 import { IWebPubDefaults, WebPubDefaults } from "./preferences/WebPubDefaults";
 import { WebPubSettings } from "./preferences/WebPubSettings";
-import { IPreferencesEditor } from "../preferences/PreferencesEditor";
 import { WebPubPreferencesEditor } from "./preferences/WebPubPreferencesEditor";
 import { Injector } from "../injection/Injector";
 import { createReadiumWebPubRules } from "../injection/webpubInjectables";
@@ -181,7 +180,7 @@ export class WebPubNavigator extends VisualNavigator implements Configurable<Web
         return Object.freeze({ ...this._settings });
     }
 
-    public get preferencesEditor(): IPreferencesEditor {
+    public get preferencesEditor(): WebPubPreferencesEditor {
         if (this._preferencesEditor === null) {
             this._preferencesEditor = new WebPubPreferencesEditor(this._preferences, this.settings, this.pub.metadata);
         }

package/src/webpub/preferences/WebPubPreferences.ts

@@ -32,7 +32,7 @@ export interface IWebPubPreferences {
   zoom?: number | null
 }
 
-export class WebPubPreferences implements ConfigurablePreferences {
+export class WebPubPreferences implements ConfigurablePreferences<WebPubPreferences> {
   fontFamily?: string | null;
   fontWeight?: number | null;
   hyphens?: boolean | null;
@@ -82,11 +82,11 @@ export class WebPubPreferences implements ConfigurablePreferences {
     }
   }
 
-  merging(other: ConfigurablePreferences): ConfigurablePreferences {
+  merging(other: WebPubPreferences): WebPubPreferences {
     const merged: IWebPubPreferences = { ...this };
     for (const key of Object.keys(other) as (keyof IWebPubPreferences)[]) {
       if (other[key] !== undefined) {
-        merged[key] = other[key];
+        (merged as Record<string, unknown>)[key] = other[key];
       }
     }
     return new WebPubPreferences(merged);

package/types/src/Navigator.d.ts

@@ -61,4 +61,50 @@ export declare abstract class VisualNavigator extends Navigator {
      */
     goRight(animated: boolean | undefined, completion: cbb): void;
 }
+export declare abstract class MediaNavigator extends Navigator {
+    /**
+     * Current playback state - is media currently playing?
+     */
+    abstract get isPlaying(): boolean;
+    /**
+     * Current playback state - is media currently paused?
+     */
+    abstract get isPaused(): boolean;
+    /**
+     * Duration of current media resource in seconds
+     */
+    abstract get duration(): number;
+    /**
+     * Current time in seconds within the media resource
+     */
+    abstract get currentTime(): number;
+    /**
+     * Play the current media resource
+     */
+    abstract play(): void;
+    /**
+     * Pause the currently playing media
+     */
+    abstract pause(): void;
+    /**
+     * Stop playback and reset to beginning
+     */
+    abstract stop(): void;
+    /**
+     * Seek to specific time in seconds
+     */
+    abstract seek(time: number): void;
+    /**
+     * Jump forward or backward by specified seconds
+     */
+    abstract jump(seconds: number): void;
+    /**
+     * Skip forward by the configured interval
+     */
+    abstract skipForward(): void;
+    /**
+     * Skip backward by the configured interval
+     */
+    abstract skipBackward(): void;
+}
 export {};

package/types/src/audio/AudioNavigator.d.ts

@@ -0,0 +1,79 @@
+import { Link, Locator, Publication } from "@readium/shared";
+import { MediaNavigator } from "../Navigator";
+import { Configurable } from "../preferences";
+import { AudioPreferences, AudioSettings, AudioPreferencesEditor, IAudioPreferences, IAudioDefaults } from "./preferences";
+export interface AudioNavigatorListeners {
+    trackLoaded: (media: HTMLMediaElement) => void;
+    positionChanged: (locator: Locator) => void;
+    error: (error: any, locator: Locator) => void;
+    trackEnded: (locator: Locator) => void;
+    play: (locator: Locator) => void;
+    pause: (locator: Locator) => void;
+    metadataLoaded: (duration: number) => void;
+    stalled: (isStalled: boolean) => void;
+    seeking: (isSeeking: boolean) => void;
+    seekable: (seekable: TimeRanges) => void;
+}
+export interface AudioNavigatorConfiguration {
+    preferences: IAudioPreferences;
+    defaults: IAudioDefaults;
+}
+export declare class AudioNavigator extends MediaNavigator implements Configurable<AudioSettings, AudioPreferences> {
+    private readonly pub;
+    private positionPollInterval;
+    private navigationId;
+    private listeners;
+    private currentLocation;
+    private _preferences;
+    private _defaults;
+    private _settings;
+    private _preferencesEditor;
+    private pool;
+    constructor(publication: Publication, listeners: AudioNavigatorListeners, initialPosition?: Locator, configuration?: AudioNavigatorConfiguration);
+    get settings(): AudioSettings;
+    get preferencesEditor(): AudioPreferencesEditor;
+    submitPreferences(preferences: AudioPreferences): Promise<void>;
+    private applyPreferences;
+    get publication(): Publication;
+    private ensureLocatorLocations;
+    /** Resolves a bare href (no fragment) to its index in the reading order. Returns -1 if not found. */
+    private hrefToTrackIndex;
+    /** Current track index derived from the current location's href. */
+    private currentTrackIndex;
+    get currentLocator(): Locator;
+    get isPlaying(): boolean;
+    get isPaused(): boolean;
+    get duration(): number;
+    get currentTime(): number;
+    private createLocator;
+    /**
+     * Waits for the current audio to be ready to play, then seeks to seekTime if > 0.
+     * Rejects if an error event fires before the audio is ready.
+     * When navId is provided, skips the seek if that navigation has been superseded.
+     */
+    private waitForLoadedAndSeeked;
+    private setupEventListeners;
+    private setupMediaSession;
+    private updateMediaSessionMetadata;
+    private startPositionPolling;
+    private stopPositionPolling;
+    go(locator: Locator, _animated: boolean, cb: (ok: boolean) => void): Promise<void>;
+    goLink(link: Link, _animated: boolean, cb: (ok: boolean) => void): Promise<void>;
+    goForward(_animated: boolean, cb: (ok: boolean) => void): Promise<void>;
+    goBackward(_animated: boolean, cb: (ok: boolean) => void): Promise<void>;
+    play(): void;
+    pause(): void;
+    stop(): void;
+    private nextTrack;
+    private previousTrack;
+    seek(time: number): void;
+    jump(seconds: number): void;
+    skipForward(): void;
+    skipBackward(): void;
+    get isTrackStart(): boolean;
+    get isTrackEnd(): boolean;
+    get canGoBackward(): boolean;
+    get canGoForward(): boolean;
+    private destroyMediaSession;
+    destroy(): void;
+}

package/types/src/audio/AudioPoolManager.d.ts

@@ -0,0 +1,52 @@
+import { Publication } from "@readium/shared";
+import { WebAudioEngine } from "./engine/WebAudioEngine";
+export declare class AudioPoolManager {
+    private preloadedElements;
+    private _audioEngine;
+    constructor(audioEngine: WebAudioEngine);
+    get audioEngine(): WebAudioEngine;
+    /**
+     * Sets the current audio by href, using preloaded element if available or loading otherwise,
+     * and preloads adjacent tracks.
+     * @param href The URL of the audio resource.
+     * @param publication The publication containing the reading order.
+     * @param currentIndex The current track index.
+     * @param direction The navigation direction ('forward' or 'backward').
+     */
+    setCurrentAudio(href: string, publication: Publication, currentIndex: number, direction: 'forward' | 'backward'): void;
+    preload(href: string): void;
+    /**
+     * Retrieves a preloaded audio element by URL.
+     * @param href The URL of the audio resource.
+     * @returns The preloaded HTMLAudioElement, or undefined if not preloaded.
+     */
+    get(href: string): HTMLAudioElement | undefined;
+    /**
+     * Removes a preloaded element from the pool.
+     * @param href The URL of the audio resource.
+     */
+    clear(href: string): void;
+    /**
+     * Preloads the next track in the reading order.
+     * @param publication The publication containing the reading order.
+     * @param currentIndex The current track index.
+     */
+    preloadNext(publication: Publication, currentIndex: number): void;
+    /**
+     * Preloads the previous track in the reading order.
+     * @param publication The publication containing the reading order.
+     * @param currentIndex The current track index.
+     */
+    preloadPrevious(publication: Publication, currentIndex: number): void;
+    /**
+     * Preloads adjacent tracks (previous and next) for smoother navigation.
+     * @param publication The publication containing the reading order.
+     * @param currentIndex The current track index.
+     * @param direction The navigation direction ('forward' or 'backward').
+     */
+    preloadAdjacent(publication: Publication, currentIndex: number, direction?: 'forward' | 'backward'): void;
+    /**
+     * Destroys the pool by stopping the engine and clearing all preloaded elements.
+     */
+    destroy(): void;
+}

package/types/src/audio/engine/AudioEngine.d.ts

@@ -1,5 +1,3 @@
-import { Locator } from '@readium/shared';
-import { Publication } from '@readium/shared';
 /**
  * Initial state of the audio engine playback.
  */
@@ -43,9 +41,10 @@ export interface AudioEngine {
      */
     playback: Playback;
     /**
-     * Plays the audio resource at the given locator.
+     * Loads the audio resource at the given URL.
+     * @param url The URL of the audio resource.
      */
-    playLocator(publication: Publication, locator: Locator): Promise<void>;
+    loadAudio(url: string): void;
     /**
      * Adds an event listener to the audio engine.
      * @param event The event name to listen.
@@ -59,10 +58,10 @@ export interface AudioEngine {
      */
     off(event: string, callback: (data: any) => void): void;
     /**
-     * Loads the audio resource at the given URL.
-     * @param url The URL of the audio resource.
+     * Sets the media element for playback, enabling use of preloaded elements from the pool.
+     * @param element The HTML audio element to use for playback.
      */
-    loadAudio(url: string): void;
+    setMediaElement(element: HTMLAudioElement): void;
     /**
      * Plays the current audio resource.
      */
@@ -83,6 +82,17 @@ export interface AudioEngine {
      * Returns the duration of the audio resource.
      */
     duration(): number;
+    /**
+     * Sets the volume of the audio resource.
+     * @param volume The volume to set, in the range [0, 1].
+     */
+    setVolume(volume: number): void;
+    /**
+     * Sets the playback rate of the audio resource.
+     * @param rate The playback rate to set.
+     * @param preservePitch Whether to preserve pitch when changing playback rate.
+     */
+    setPlaybackRate(rate: number, preservePitch: boolean): void;
     /**
      * Returns whether the audio resource is currently playing.
      */
@@ -91,6 +101,10 @@ export interface AudioEngine {
      * Returns whether the audio resource is currently paused.
      */
     isPaused(): boolean;
+    /**
+     * Returns the HTML media element used for playback.
+     */
+    getMediaElement(): HTMLMediaElement;
     /**
      * Returns whether the audio resource is currently stopped.
      */

package/types/src/audio/engine/PreservePitchWorklet.d.ts

@@ -0,0 +1,18 @@
+interface PreservePitchWorkletOptions {
+    ctx: AudioContext;
+    mediaElement?: HTMLMediaElement;
+    pitchFactor?: number;
+    modulePath?: string;
+}
+export declare class PreservePitchWorklet {
+    mediaElement: HTMLMediaElement | null;
+    source: MediaElementAudioSourceNode | null;
+    ctx: AudioContext;
+    workletNode: AudioWorkletNode | null;
+    url: string | null;
+    static createWorklet(options: PreservePitchWorkletOptions): Promise<PreservePitchWorklet>;
+    constructor(ctx: AudioContext);
+    updatePitchFactor(factor: number): void;
+    destroy(): void;
+}
+export {};

package/types/src/audio/engine/WebAudioEngine.d.ts

@@ -1,6 +1,4 @@
 import { AudioEngine, Playback } from "./AudioEngine";
-import { Publication } from "@readium/shared";
-import { Locator } from "@readium/shared";
 type EventCallback = (data: any) => void;
 export declare class WebAudioEngine implements AudioEngine {
     readonly playback: Playback;
@@ -9,15 +7,33 @@ export declare class WebAudioEngine implements AudioEngine {
     private sourceNode;
     private gainNode;
     private listeners;
+    private currentPlaybackRate;
     private isMutedValue;
     private isPlayingValue;
     private isPausedValue;
     private isLoadingValue;
     private isLoadedValue;
     private isEndedValue;
+    private isStoppedValue;
+    private worklet;
+    private webAudioActive;
+    private readonly boundOnCanPlayThrough;
+    private readonly boundOnTimeUpdate;
+    private readonly boundOnError;
+    private readonly boundOnEnded;
+    private readonly boundOnStalled;
+    private readonly boundOnEmptied;
+    private readonly boundOnSuspend;
+    private readonly boundOnWaiting;
+    private readonly boundOnLoadedMetadata;
+    private readonly boundOnSeeking;
+    private readonly boundOnSeeked;
+    private readonly boundOnPlay;
+    private readonly boundOnPlaying;
+    private readonly boundOnPause;
+    private readonly boundOnProgress;
     constructor(values: {
         playback: Playback;
-        audioContext: AudioContext;
     });
     /**
      * Adds an event listener to the audio engine.
@@ -36,16 +52,30 @@ export declare class WebAudioEngine implements AudioEngine {
      * @param url The URL of the audio resource.
      * */
     loadAudio(url: string): void;
+    private deactivateWebAudio;
+    /**
+     * Sets the media element for playback.
+     * @param element The HTML audio element to use.
+     */
+    setMediaElement(element: HTMLAudioElement): void;
     private ensureAudioContextRunning;
+    private getOrCreateAudioContext;
     private onTimeUpdate;
     private onCanPlayThrough;
     private onError;
     private onEnded;
+    private onStalled;
+    private onEmptied;
+    private onSuspend;
+    private onWaiting;
+    private onLoadedMetadata;
+    private onSeeking;
+    private onSeeked;
+    private onPlay;
+    private onPlaying;
+    private onPause;
+    private onProgress;
     private emit;
-    /**
-     * Plays the audio resource at the given locator.
-     */
-    playLocator(_publication: Publication, _locator: Locator): Promise<void>;
     /**
      * Plays the current audio resource.
      */
@@ -103,5 +133,20 @@ export declare class WebAudioEngine implements AudioEngine {
      * Returns whether the audio resource is currently muted.
      */
     isMuted(): boolean;
+    /**
+     * Sets the playback rate of the audio resource with pitch preservation.
+     */
+    setPlaybackRate(rate: number, preservePitch: boolean): void;
+    /**
+     * Activates the Web Audio graph for the current media element.
+     * Sets crossOrigin = "anonymous" and reloads so MediaElementAudioSourceNode can be used.
+     * No-ops if Web Audio is already active.
+     */
+    private activateWebAudio;
+    get isWebAudioActive(): boolean;
+    /**
+     * Returns the HTML media element used for playback.
+     */
+    getMediaElement(): HTMLMediaElement;
 }
 export {};

package/types/src/audio/index.d.ts

@@ -1 +1,3 @@
 export * from './engine';
+export * from './preferences';
+export * from './AudioNavigator';