wavesurfer.js 7.10.3 → 7.11.1

package/dist/plugins/zoom.min.js

@@ -1 +1 @@
-!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):((t="undefined"!=typeof globalThis?globalThis:t||self).WaveSurfer=t.WaveSurfer||{},t.WaveSurfer.Zoom=e())}(this,(function(){"use strict";class t{constructor(){this.listeners={}}on(t,e,s){if(this.listeners[t]||(this.listeners[t]=new Set),this.listeners[t].add(e),null==s?void 0:s.once){const s=()=>{this.un(t,s),this.un(t,e)};return this.on(t,s),s}return()=>this.un(t,e)}un(t,e){var s;null===(s=this.listeners[t])||void 0===s||s.delete(e)}once(t,e){return this.on(t,e,{once:!0})}unAll(){this.listeners={}}emit(t,...e){this.listeners[t]&&this.listeners[t].forEach((t=>t(...e)))}}class e extends t{constructor(t){super(),this.subscriptions=[],this.isDestroyed=!1,this.options=t}onInit(){}_init(t){this.isDestroyed&&(this.subscriptions=[],this.isDestroyed=!1),this.wavesurfer=t,this.onInit()}destroy(){this.emit("destroy"),this.subscriptions.forEach((t=>t())),this.subscriptions=[],this.isDestroyed=!0,this.wavesurfer=void 0}}const s={scale:.5,deltaThreshold:5,exponentialZooming:!1,iterations:20};class i extends e{constructor(t){super(t||{}),this.wrapper=void 0,this.container=null,this.accumulatedDelta=0,this.pointerTime=0,this.oldX=0,this.endZoom=0,this.startZoom=0,this.onWheel=t=>{if(this.wavesurfer&&this.container&&!(Math.abs(t.deltaX)>=Math.abs(t.deltaY))&&(t.preventDefault(),this.accumulatedDelta+=-t.deltaY,0===this.startZoom&&this.options.exponentialZooming&&(this.startZoom=this.wavesurfer.getWrapper().clientWidth/this.wavesurfer.getDuration()),0===this.options.deltaThreshold||Math.abs(this.accumulatedDelta)>=this.options.deltaThreshold)){const e=this.wavesurfer.getDuration(),s=0===this.wavesurfer.options.minPxPerSec?this.wavesurfer.getWrapper().scrollWidth/e:this.wavesurfer.options.minPxPerSec,i=t.clientX-this.container.getBoundingClientRect().left,o=this.container.clientWidth,n=this.wavesurfer.getScroll();i===this.oldX&&0!==this.oldX||(this.pointerTime=(n+i)/s),this.oldX=i;const r=this.calculateNewZoom(s,this.accumulatedDelta),h=o/r*(i/o);r*e<o?(this.wavesurfer.zoom(o/e),this.container.scrollLeft=0):(this.wavesurfer.zoom(r),this.container.scrollLeft=(this.pointerTime-h)*r),this.accumulatedDelta=0}},this.calculateNewZoom=(t,e)=>{let s;if(this.options.exponentialZooming){const i=e>0?Math.pow(this.endZoom/this.startZoom,1/(this.options.iterations-1)):Math.pow(this.startZoom/this.endZoom,1/(this.options.iterations-1));s=Math.max(0,t*i)}else s=Math.max(0,t+e*this.options.scale);return Math.min(s,this.options.maxZoom)},this.options=Object.assign({},s,t)}static create(t){return new i(t)}onInit(){var t;this.wrapper=null===(t=this.wavesurfer)||void 0===t?void 0:t.getWrapper(),this.wrapper&&(this.container=this.wrapper.parentElement,this.container.addEventListener("wheel",this.onWheel),void 0===this.options.maxZoom&&(this.options.maxZoom=this.container.clientWidth),this.endZoom=this.options.maxZoom)}destroy(){this.wrapper&&this.wrapper.removeEventListener("wheel",this.onWheel),super.destroy()}}return i}));
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):((t="undefined"!=typeof globalThis?globalThis:t||self).WaveSurfer=t.WaveSurfer||{},t.WaveSurfer.Zoom=e())}(this,(function(){"use strict";class t{constructor(){this.listeners={}}on(t,e,i){if(this.listeners[t]||(this.listeners[t]=new Set),null==i?void 0:i.once){const i=(...s)=>{this.un(t,i),e(...s)};return this.listeners[t].add(i),()=>this.un(t,i)}return this.listeners[t].add(e),()=>this.un(t,e)}un(t,e){var i;null===(i=this.listeners[t])||void 0===i||i.delete(e)}once(t,e){return this.on(t,e,{once:!0})}unAll(){this.listeners={}}emit(t,...e){this.listeners[t]&&this.listeners[t].forEach((t=>t(...e)))}}class e extends t{constructor(t){super(),this.subscriptions=[],this.isDestroyed=!1,this.options=t}onInit(){}_init(t){this.isDestroyed&&(this.subscriptions=[],this.isDestroyed=!1),this.wavesurfer=t,this.onInit()}destroy(){this.emit("destroy"),this.subscriptions.forEach((t=>t())),this.subscriptions=[],this.isDestroyed=!0,this.wavesurfer=void 0}}const i={scale:.5,deltaThreshold:5,exponentialZooming:!1,iterations:20};class s extends e{constructor(t){super(t||{}),this.wrapper=void 0,this.container=null,this.accumulatedDelta=0,this.pointerTime=0,this.oldX=0,this.endZoom=0,this.startZoom=0,this.isPinching=!1,this.initialPinchDistance=0,this.initialZoom=0,this.onWheel=t=>{if(this.wavesurfer&&this.container&&!(Math.abs(t.deltaX)>=Math.abs(t.deltaY))&&(t.preventDefault(),this.accumulatedDelta+=-t.deltaY,0===this.startZoom&&this.options.exponentialZooming&&(this.startZoom=this.wavesurfer.getWrapper().clientWidth/this.wavesurfer.getDuration()),0===this.options.deltaThreshold||Math.abs(this.accumulatedDelta)>=this.options.deltaThreshold)){const e=this.wavesurfer.getDuration(),i=0===this.wavesurfer.options.minPxPerSec?this.wavesurfer.getWrapper().scrollWidth/e:this.wavesurfer.options.minPxPerSec,s=t.clientX-this.container.getBoundingClientRect().left,n=this.container.clientWidth,o=this.wavesurfer.getScroll();s===this.oldX&&0!==this.oldX||(this.pointerTime=(o+s)/i),this.oldX=s;const h=this.calculateNewZoom(i,this.accumulatedDelta),r=n/h*(s/n);h*e<n?(this.wavesurfer.zoom(n/e),this.container.scrollLeft=0):(this.wavesurfer.zoom(h),this.container.scrollLeft=(this.pointerTime-r)*h),this.accumulatedDelta=0}},this.calculateNewZoom=(t,e)=>{let i;if(this.options.exponentialZooming){const s=e>0?Math.pow(this.endZoom/this.startZoom,1/(this.options.iterations-1)):Math.pow(this.startZoom/this.endZoom,1/(this.options.iterations-1));i=Math.max(0,t*s)}else i=Math.max(0,t+e*this.options.scale);return Math.min(i,this.options.maxZoom)},this.onTouchStart=t=>{if(this.wavesurfer&&this.container&&2===t.touches.length){t.preventDefault(),this.isPinching=!0,this.initialPinchDistance=this.getTouchDistance(t);const e=this.wavesurfer.getDuration();this.initialZoom=0===this.wavesurfer.options.minPxPerSec?this.wavesurfer.getWrapper().scrollWidth/e:this.wavesurfer.options.minPxPerSec;const i=this.getTouchCenterX(t)-this.container.getBoundingClientRect().left,s=this.wavesurfer.getScroll();this.pointerTime=(s+i)/this.initialZoom,this.oldX=i}},this.onTouchMove=t=>{if(!this.isPinching||2!==t.touches.length||!this.wavesurfer||!this.container)return;t.preventDefault();const e=this.getTouchDistance(t)/this.initialPinchDistance;let i=this.initialZoom*e;i=Math.min(i,this.options.maxZoom);const s=this.wavesurfer.getDuration(),n=this.container.clientWidth,o=n/s;i<o&&(i=o);const h=n/i*(this.oldX/n);i===o?(this.wavesurfer.zoom(o),this.container.scrollLeft=0):(this.wavesurfer.zoom(i),this.container.scrollLeft=(this.pointerTime-h)*i)},this.onTouchEnd=t=>{this.isPinching&&t.touches.length<2&&(this.isPinching=!1,this.initialPinchDistance=0,this.initialZoom=0)},this.options=Object.assign({},i,t)}static create(t){return new s(t)}onInit(){var t;this.wrapper=null===(t=this.wavesurfer)||void 0===t?void 0:t.getWrapper(),this.wrapper&&(this.container=this.wrapper.parentElement,this.container.addEventListener("wheel",this.onWheel),this.container.addEventListener("touchstart",this.onTouchStart,{passive:!1,capture:!0}),this.container.addEventListener("touchmove",this.onTouchMove,{passive:!1,capture:!0}),this.container.addEventListener("touchend",this.onTouchEnd,{passive:!1,capture:!0}),this.container.addEventListener("touchcancel",this.onTouchEnd,{passive:!1,capture:!0}),void 0===this.options.maxZoom&&(this.options.maxZoom=this.container.clientWidth),this.endZoom=this.options.maxZoom)}getTouchDistance(t){const e=t.touches[0],i=t.touches[1];return Math.sqrt(Math.pow(i.clientX-e.clientX,2)+Math.pow(i.clientY-e.clientY,2))}getTouchCenterX(t){const e=t.touches[0],i=t.touches[1];return(e.clientX+i.clientX)/2}destroy(){this.container&&(this.container.removeEventListener("wheel",this.onWheel),this.container.removeEventListener("touchstart",this.onTouchStart),this.container.removeEventListener("touchmove",this.onTouchMove),this.container.removeEventListener("touchend",this.onTouchEnd),this.container.removeEventListener("touchcancel",this.onTouchEnd)),super.destroy()}}return s}));

package/dist/renderer-utils.d.ts

@@ -0,0 +1,117 @@
+import type { WaveSurferOptions } from './wavesurfer.js';
+export type ChannelData = Array<Float32Array | number[]>;
+export type BarSegment = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type LinePath = Array<{
+    x: number;
+    y: number;
+}>;
+export declare const DEFAULT_HEIGHT = 128;
+export declare const MAX_CANVAS_WIDTH = 8000;
+export declare const MAX_NODES = 10;
+export declare function clampToUnit(value: number): number;
+export declare function calculateBarRenderConfig({ width, height, length, options, pixelRatio, }: {
+    width: number;
+    height: number;
+    length: number;
+    options: WaveSurferOptions;
+    pixelRatio: number;
+}): {
+    halfHeight: number;
+    barWidth: number;
+    barGap: number;
+    barRadius: number;
+    barIndexScale: number;
+    barSpacing: number;
+};
+export declare function calculateBarHeights({ maxTop, maxBottom, halfHeight, vScale, }: {
+    maxTop: number;
+    maxBottom: number;
+    halfHeight: number;
+    vScale: number;
+}): {
+    topHeight: number;
+    totalHeight: number;
+};
+export declare function resolveBarYPosition({ barAlign, halfHeight, topHeight, totalHeight, canvasHeight, }: {
+    barAlign: WaveSurferOptions['barAlign'];
+    halfHeight: number;
+    topHeight: number;
+    totalHeight: number;
+    canvasHeight: number;
+}): number;
+export declare function calculateBarSegments({ channelData, barIndexScale, barSpacing, barWidth, halfHeight, vScale, canvasHeight, barAlign, }: {
+    channelData: ChannelData;
+    barIndexScale: number;
+    barSpacing: number;
+    barWidth: number;
+    halfHeight: number;
+    vScale: number;
+    canvasHeight: number;
+    barAlign: WaveSurferOptions['barAlign'];
+}): BarSegment[];
+export declare function getRelativePointerPosition(rect: DOMRect, clientX: number, clientY: number): [number, number];
+export declare function resolveChannelHeight({ optionsHeight, optionsSplitChannels, parentHeight, numberOfChannels, defaultHeight, }: {
+    optionsHeight?: WaveSurferOptions['height'];
+    optionsSplitChannels?: WaveSurferOptions['splitChannels'];
+    parentHeight: number;
+    numberOfChannels: number;
+    defaultHeight?: number;
+}): number;
+export declare function getPixelRatio(devicePixelRatio?: number): number;
+export declare function shouldRenderBars(options: WaveSurferOptions): boolean;
+export declare function resolveColorValue(color: WaveSurferOptions['waveColor'], devicePixelRatio: number): string | CanvasGradient;
+export declare function calculateWaveformLayout({ duration, minPxPerSec, parentWidth, fillParent, pixelRatio, }: {
+    duration: number;
+    minPxPerSec?: number;
+    parentWidth: number;
+    fillParent?: boolean;
+    pixelRatio: number;
+}): {
+    scrollWidth: number;
+    isScrollable: boolean;
+    useParentWidth: boolean;
+    width: number;
+};
+export declare function clampWidthToBarGrid(width: number, options: WaveSurferOptions): number;
+export declare function calculateSingleCanvasWidth({ clientWidth, totalWidth, options, }: {
+    clientWidth: number;
+    totalWidth: number;
+    options: WaveSurferOptions;
+}): number;
+export declare function sliceChannelData({ channelData, offset, clampedWidth, totalWidth, }: {
+    channelData: ChannelData;
+    offset: number;
+    clampedWidth: number;
+    totalWidth: number;
+}): ChannelData;
+export declare function shouldClearCanvases(currentNodeCount: number): boolean;
+export declare function getLazyRenderRange({ scrollLeft, totalWidth, numCanvases, }: {
+    scrollLeft: number;
+    totalWidth: number;
+    numCanvases: number;
+}): number[];
+export declare function calculateVerticalScale({ channelData, barHeight, normalize, }: {
+    channelData: ChannelData;
+    barHeight?: WaveSurferOptions['barHeight'];
+    normalize?: WaveSurferOptions['normalize'];
+}): number;
+export declare function calculateLinePaths({ channelData, width, height, vScale, }: {
+    channelData: ChannelData;
+    width: number;
+    height: number;
+    vScale: number;
+}): LinePath[];
+export declare function calculateScrollPercentages({ scrollLeft, clientWidth, scrollWidth, }: {
+    scrollLeft: number;
+    clientWidth: number;
+    scrollWidth: number;
+}): {
+    startX: number;
+    endX: number;
+};
+export declare function roundToHalfAwayFromZero(value: number): number;

package/dist/renderer-utils.js

@@ -0,0 +1,232 @@
+export const DEFAULT_HEIGHT = 128;
+export const MAX_CANVAS_WIDTH = 8000;
+export const MAX_NODES = 10;
+export function clampToUnit(value) {
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+export function calculateBarRenderConfig({ width, height, length, options, pixelRatio, }) {
+    const halfHeight = height / 2;
+    const barWidth = options.barWidth ? options.barWidth * pixelRatio : 1;
+    const barGap = options.barGap ? options.barGap * pixelRatio : options.barWidth ? barWidth / 2 : 0;
+    const barRadius = options.barRadius || 0;
+    const spacing = barWidth + barGap || 1;
+    const barIndexScale = length > 0 ? width / spacing / length : 0;
+    return {
+        halfHeight,
+        barWidth,
+        barGap,
+        barRadius,
+        barIndexScale,
+        barSpacing: spacing,
+    };
+}
+export function calculateBarHeights({ maxTop, maxBottom, halfHeight, vScale, }) {
+    const topHeight = Math.round(maxTop * halfHeight * vScale);
+    const bottomHeight = Math.round(maxBottom * halfHeight * vScale);
+    const totalHeight = topHeight + bottomHeight || 1;
+    return { topHeight, totalHeight };
+}
+export function resolveBarYPosition({ barAlign, halfHeight, topHeight, totalHeight, canvasHeight, }) {
+    if (barAlign === 'top')
+        return 0;
+    if (barAlign === 'bottom')
+        return canvasHeight - totalHeight;
+    return halfHeight - topHeight;
+}
+export function calculateBarSegments({ channelData, barIndexScale, barSpacing, barWidth, halfHeight, vScale, canvasHeight, barAlign, }) {
+    const topChannel = channelData[0] || [];
+    const bottomChannel = channelData[1] || topChannel;
+    const length = topChannel.length;
+    const segments = [];
+    let prevX = 0;
+    let maxTop = 0;
+    let maxBottom = 0;
+    for (let i = 0; i <= length; i++) {
+        const x = Math.round(i * barIndexScale);
+        if (x > prevX) {
+            const { topHeight, totalHeight } = calculateBarHeights({
+                maxTop,
+                maxBottom,
+                halfHeight,
+                vScale,
+            });
+            const y = resolveBarYPosition({
+                barAlign,
+                halfHeight,
+                topHeight,
+                totalHeight,
+                canvasHeight,
+            });
+            segments.push({
+                x: prevX * barSpacing,
+                y,
+                width: barWidth,
+                height: totalHeight,
+            });
+            prevX = x;
+            maxTop = 0;
+            maxBottom = 0;
+        }
+        const magnitudeTop = Math.abs(topChannel[i] || 0);
+        const magnitudeBottom = Math.abs(bottomChannel[i] || 0);
+        if (magnitudeTop > maxTop)
+            maxTop = magnitudeTop;
+        if (magnitudeBottom > maxBottom)
+            maxBottom = magnitudeBottom;
+    }
+    return segments;
+}
+export function getRelativePointerPosition(rect, clientX, clientY) {
+    const x = clientX - rect.left;
+    const y = clientY - rect.top;
+    const relativeX = x / rect.width;
+    const relativeY = y / rect.height;
+    return [relativeX, relativeY];
+}
+export function resolveChannelHeight({ optionsHeight, optionsSplitChannels, parentHeight, numberOfChannels, defaultHeight = DEFAULT_HEIGHT, }) {
+    if (optionsHeight == null)
+        return defaultHeight;
+    const numericHeight = Number(optionsHeight);
+    if (!isNaN(numericHeight))
+        return numericHeight;
+    if (optionsHeight === 'auto') {
+        const height = parentHeight || defaultHeight;
+        if (optionsSplitChannels === null || optionsSplitChannels === void 0 ? void 0 : optionsSplitChannels.every((channel) => !channel.overlay)) {
+            return height / numberOfChannels;
+        }
+        return height;
+    }
+    return defaultHeight;
+}
+export function getPixelRatio(devicePixelRatio) {
+    return Math.max(1, devicePixelRatio || 1);
+}
+export function shouldRenderBars(options) {
+    return Boolean(options.barWidth || options.barGap || options.barAlign);
+}
+export function resolveColorValue(color, devicePixelRatio) {
+    if (!Array.isArray(color))
+        return color || '';
+    if (color.length === 0)
+        return '#999';
+    if (color.length < 2)
+        return color[0] || '';
+    const canvasElement = document.createElement('canvas');
+    const ctx = canvasElement.getContext('2d');
+    const gradientHeight = canvasElement.height * devicePixelRatio;
+    const gradient = ctx.createLinearGradient(0, 0, 0, gradientHeight || devicePixelRatio);
+    const colorStopPercentage = 1 / (color.length - 1);
+    color.forEach((value, index) => {
+        gradient.addColorStop(index * colorStopPercentage, value);
+    });
+    return gradient;
+}
+export function calculateWaveformLayout({ duration, minPxPerSec = 0, parentWidth, fillParent, pixelRatio, }) {
+    const scrollWidth = Math.ceil(duration * minPxPerSec);
+    const isScrollable = scrollWidth > parentWidth;
+    const useParentWidth = Boolean(fillParent && !isScrollable);
+    const width = (useParentWidth ? parentWidth : scrollWidth) * pixelRatio;
+    return {
+        scrollWidth,
+        isScrollable,
+        useParentWidth,
+        width,
+    };
+}
+export function clampWidthToBarGrid(width, options) {
+    if (!shouldRenderBars(options))
+        return width;
+    const barWidth = options.barWidth || 0.5;
+    const barGap = options.barGap || barWidth / 2;
+    const totalBarWidth = barWidth + barGap;
+    if (totalBarWidth === 0)
+        return width;
+    return Math.floor(width / totalBarWidth) * totalBarWidth;
+}
+export function calculateSingleCanvasWidth({ clientWidth, totalWidth, options, }) {
+    const baseWidth = Math.min(MAX_CANVAS_WIDTH, clientWidth, totalWidth);
+    return clampWidthToBarGrid(baseWidth, options);
+}
+export function sliceChannelData({ channelData, offset, clampedWidth, totalWidth, }) {
+    return channelData.map((channel) => {
+        const start = Math.floor((offset / totalWidth) * channel.length);
+        const end = Math.floor(((offset + clampedWidth) / totalWidth) * channel.length);
+        return channel.slice(start, end);
+    });
+}
+export function shouldClearCanvases(currentNodeCount) {
+    return currentNodeCount > MAX_NODES;
+}
+export function getLazyRenderRange({ scrollLeft, totalWidth, numCanvases, }) {
+    if (totalWidth === 0)
+        return [0];
+    const viewPosition = scrollLeft / totalWidth;
+    const startCanvas = Math.floor(viewPosition * numCanvases);
+    return [startCanvas - 1, startCanvas, startCanvas + 1];
+}
+export function calculateVerticalScale({ channelData, barHeight, normalize, }) {
+    var _a;
+    const baseScale = barHeight || 1;
+    if (!normalize)
+        return baseScale;
+    const firstChannel = channelData[0];
+    if (!firstChannel || firstChannel.length === 0)
+        return baseScale;
+    let max = 0;
+    for (let i = 0; i < firstChannel.length; i++) {
+        const value = (_a = firstChannel[i]) !== null && _a !== void 0 ? _a : 0;
+        const magnitude = Math.abs(value);
+        if (magnitude > max)
+            max = magnitude;
+    }
+    if (!max)
+        return baseScale;
+    return baseScale / max;
+}
+export function calculateLinePaths({ channelData, width, height, vScale, }) {
+    const halfHeight = height / 2;
+    const primaryChannel = channelData[0] || [];
+    const secondaryChannel = channelData[1] || primaryChannel;
+    const channels = [primaryChannel, secondaryChannel];
+    return channels.map((channel, index) => {
+        const length = channel.length;
+        const hScale = length ? width / length : 0;
+        const baseY = halfHeight;
+        const direction = index === 0 ? -1 : 1;
+        const path = [{ x: 0, y: baseY }];
+        let prevX = 0;
+        let max = 0;
+        for (let i = 0; i <= length; i++) {
+            const x = Math.round(i * hScale);
+            if (x > prevX) {
+                const heightDelta = Math.round(max * halfHeight * vScale) || 1;
+                const y = baseY + heightDelta * direction;
+                path.push({ x: prevX, y });
+                prevX = x;
+                max = 0;
+            }
+            const value = Math.abs(channel[i] || 0);
+            if (value > max)
+                max = value;
+        }
+        path.push({ x: prevX, y: baseY });
+        return path;
+    });
+}
+export function calculateScrollPercentages({ scrollLeft, clientWidth, scrollWidth, }) {
+    if (scrollWidth === 0) {
+        return { startX: 0, endX: 0 };
+    }
+    const startX = scrollLeft / scrollWidth;
+    const endX = (scrollLeft + clientWidth) / scrollWidth;
+    return { startX, endX };
+}
+export function roundToHalfAwayFromZero(value) {
+    const scaled = value * 2;
+    const rounded = scaled < 0 ? Math.floor(scaled) : Math.ceil(scaled);
+    return rounded / 2;
+}

package/dist/renderer.d.ts

@@ -9,10 +9,9 @@ type RendererEvents = {
     scroll: [relativeStart: number, relativeEnd: number, scrollLeft: number, scrollRight: number];
     render: [];
     rendered: [];
+    resize: [];
 };
 declare class Renderer extends EventEmitter<RendererEvents> {
-    private static MAX_CANVAS_WIDTH;
-    private static MAX_NODES;
     private options;
     private parent;
     private container;
@@ -29,12 +28,12 @@ declare class Renderer extends EventEmitter<RendererEvents> {
     private isDragging;
     private subscriptions;
     private unsubscribeOnScroll;
+    private dragUnsubscribe;
     constructor(options: WaveSurferOptions, audioElement?: HTMLElement);
     private parentFromOptionsContainer;
     private initEvents;
     private onContainerResize;
     private initDrag;
-    private getHeight;
     private initHtml;
     /** Wavesurfer itself calls this method. Do not call it manually. */
     setOptions(options: WaveSurferOptions): void;
@@ -45,6 +44,7 @@ declare class Renderer extends EventEmitter<RendererEvents> {
     setScrollPercentage(percent: number): void;
     destroy(): void;
     private createDelay;
+    private getHeight;
     private convertColorValues;
     private getPixelRatio;
     private renderBarWaveform;