yetangitu/Oinktube
1
0
Fork 0
mirror of https://github.com/DanielnetoDotCom/YouPHPTube synced 2025-10-05 02:39:46 +02:00
Code Issues Releases Wiki Activity

https://github.com/WWBN/AVideo/issues/8137

Browse source
This commit is contained in:
Daniel Neto 2023-06-30 09:56:13 -03:00
parent 37e90e3dfe
commit 214f5d9fc3
4949 changed files with 1393320 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

3
node_modules/video.js/dist/lang/en-GB.js generated vendored Normal file
View file

@ -0,0 +1,3 @@
videojs.addLanguage('en-GB', {
"Color": "Colour"
});

4
node_modules/video.js/dist/lang/en-GB.json generated vendored Normal file
View file

@ -0,0 +1,4 @@
{
"Color": "Colour"
}

27
node_modules/video.js/dist/types/big-play-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,27 @@
export default BigPlayButton;
/**
* The initial play button that shows before the video has played. The hiding of the
* `BigPlayButton` get done via CSS and `Player` states.
*
* @extends Button
*/
declare class BigPlayButton extends Button {
constructor(player: any, options: any);
mouseused_: boolean;
/**
* This gets called when a `BigPlayButton` "clicked". See {@link ClickableComponent}
* for more detailed information on what a click can be.
*
* @param {KeyboardEvent} event
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event: KeyboardEvent): void;
handleKeyDown(event: any): void;
handleMouseDown(event: any): void;
}
import Button from "./button.js";
//# sourceMappingURL=big-play-button.d.ts.map

1
node_modules/video.js/dist/types/big-play-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"big-play-button.d.ts","sourceRoot":"","sources":["../../src/js/big-play-button.js"],"names":[],"mappings":";AAOA;;;;;GAKG;AACH;IACE,uCAMC;IAHC,oBAAuB;IAezB;;;;;;;;;;OAUG;IACH,mBAPW,aAAa,QAoCvB;IAED,gCAIC;IAED,kCAEC;CACF"}

28
node_modules/video.js/dist/types/button.d.ts generated vendored Normal file
View file

@ -0,0 +1,28 @@
export default Button;
/**
* Base class for all buttons.
*
* @extends ClickableComponent
*/
declare class Button extends ClickableComponent {
/**
* Add a child `Component` inside of this `Button`.
*
* @param {string|Component} child
* The name or instance of a child to add.
*
* @param {Object} [options={}]
* The key/value store of options that will get passed to children of
* the child.
*
* @return {Component}
* The `Component` that gets added as a child. When using a string the
* `Component` will get created by this process.
*
* @deprecated since version 5
*/
addChild(child: string | Component, options?: any): Component;
}
import ClickableComponent from "./clickable-component.js";
import Component from "./component";
//# sourceMappingURL=button.d.ts.map

1
node_modules/video.js/dist/types/button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"button.d.ts","sourceRoot":"","sources":["../../src/js/button.js"],"names":[],"mappings":";AASA;;;;GAIG;AACH;IA6CE;;;;;;;;;;;;;;;OAeG;IACH,gBAbW,MAAM,GAAC,SAAS,kBAOf,SAAS,CAapB;CA4CF"}

100
node_modules/video.js/dist/types/clickable-component.d.ts generated vendored Normal file
View file

@ -0,0 +1,100 @@
export default ClickableComponent;
/**
* Component which is clickable or keyboard actionable, but is not a
* native HTML button.
*
* @extends Component
*/
declare class ClickableComponent extends Component {
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of component options.
*
* @param {function} [options.clickHandler]
* The function to call when the button is clicked / activated
*
* @param {string} [options.controlText]
* The text to set on the button
*
* @param {string} [options.className]
* A class or space separated list of classes to add the component
*
*/
constructor(player: import('./player').default, options?: {
clickHandler?: Function;
controlText?: string;
className?: string;
});
handleMouseOver_: (e: any) => any;
handleMouseOut_: (e: any) => any;
handleClick_: (e: any) => void;
handleKeyDown_: (e: any) => void;
tabIndex_: any;
dispose(): void;
controlTextEl_: Element;
/**
* Create a control text element on this `ClickableComponent`
*
* @param {Element} [el]
* Parent element for the control text.
*
* @return {Element}
* The control text element that gets created.
*/
createControlTextEl(el?: Element): Element;
/**
* Get or set the localize text to use for the controls on the `ClickableComponent`.
*
* @param {string} [text]
* Control text for element.
*
* @param {Element} [el=this.el()]
* Element to set the title on.
*
* @return {string}
* - The control text when getting
*/
controlText(text?: string, el?: Element): string;
/** @protected */
protected controlText_: string;
/**
* Enable this `ClickableComponent`
*/
enable(): void;
enabled_: boolean;
/**
* Disable this `ClickableComponent`
*/
disable(): void;
/**
* Event handler that is called when a `ClickableComponent` receives a
* `click` or `tap` event.
*
* @param {Event} event
* The `tap` or `click` event that caused this function to be called.
*
* @listens tap
* @listens click
* @abstract
*/
handleClick(event: Event, ...args: any[]): void;
/**
* Event handler that is called when a `ClickableComponent` receives a
* `keydown` event.
*
* By default, if the key is Space or Enter, it will trigger a `click` event.
*
* @param {Event} event
* The `keydown` event that caused this function to be called.
*
* @listens keydown
*/
handleKeyDown(event: Event): void;
}
import Component from "./component";
//# sourceMappingURL=clickable-component.d.ts.map

1
node_modules/video.js/dist/types/clickable-component.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"clickable-component.d.ts","sourceRoot":"","sources":["../../src/js/clickable-component.js"],"names":[],"mappings":";AAQA;;;;;GAKG;AACH;IAEE;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAhBa,OAAO,UAAU,EAAE,OAAO;QAMR,YAAY;QAGd,WAAW,GAA5B,MAAM;QAGW,SAAS,GAA1B,MAAM;OAoBjB;IARC,kCAAsD;IACtD,iCAAoD;IACpD,+BAA8C;IAC9C,iCAAkD;IAqClD,eAA+B;IAejC,gBAKC;IAHC,wBAA0B;IAK5B;;;;;;;;OAQG;IACH,yBANW,OAAO,GAGN,OAAO,CAkBlB;IAED;;;;;;;;;;;OAWG;IACH,mBATW,MAAM,OAGN,OAAO,GAGN,MAAM,CAiBjB;IAPC,iBAAiB;IACjB,+BAAwB;IAkB1B;;OAEG;IACH,eAWC;IATG,kBAAoB;IAWxB;;OAEG;IACH,gBAWC;IAWD;;;;;;;;;;OAUG;IACH,mBAPW,KAAK,wBAWf;IAED;;;;;;;;;;OAUG;IACH,qBALW,KAAK,QAmBf;CACF"}

35
node_modules/video.js/dist/types/close-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,35 @@
export default CloseButton;
/**
* The `CloseButton` is a `{@link Button}` that fires a `close` event when
* it gets clicked.
*
* @extends Button
*/
declare class CloseButton extends Button {
/**
* Creates an instance of the this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('./player').default, options?: any);
/**
* This gets called when a `CloseButton` gets clicked. See
* {@link ClickableComponent#handleClick} for more information on when
* this will be triggered
*
* @param {Event} event
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
* @fires CloseButton#close
*/
handleClick(event: Event): void;
}
import Button from "./button";
//# sourceMappingURL=close-button.d.ts.map

1
node_modules/video.js/dist/types/close-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"close-button.d.ts","sourceRoot":"","sources":["../../src/js/close-button.js"],"names":[],"mappings":";AAOA;;;;;GAKG;AACH;IAEE;;;;;;;;MAQE;IACF,oBANY,OAAO,UAAU,EAAE,OAAO,iBASrC;IAYD;;;;;;;;;;;;OAYG;IACH,mBARW,KAAK,QAqBf;CAuBF"}

866
node_modules/video.js/dist/types/component.d.ts generated vendored Normal file
View file

@ -0,0 +1,866 @@
export default Component;
/**
* Base class for all UI Components.
* Components are UI objects which represent both a javascript object and an element
* in the DOM. They can be children of other components, and can have
* children themselves.
*
* Components can also use methods from {@link EventTarget}
*/
declare class Component {
/**
* Register a `Component` with `videojs` given the name and the component.
*
* > NOTE: {@link Tech}s should not be registered as a `Component`. {@link Tech}s
* should be registered using {@link Tech.registerTech} or
* {@link videojs:videojs.registerTech}.
*
* > NOTE: This function can also be seen on videojs as
* {@link videojs:videojs.registerComponent}.
*
* @param {string} name
* The name of the `Component` to register.
*
* @param {Component} ComponentToRegister
* The `Component` class to register.
*
* @return {Component}
* The `Component` that was registered.
*/
static registerComponent(name: string, ComponentToRegister: Component): Component;
/**
* Get a `Component` based on the name it was registered with.
*
* @param {string} name
* The Name of the component to get.
*
* @return {Component}
* The `Component` that got registered under the given name.
*/
static getComponent(name: string): Component;
/**
* A callback that is called when a component is ready. Does not have any
* parameters and any callback value will be ignored.
*
* @callback ReadyCallback
* @this Component
*/
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of component options.
*
* @param {Object[]} [options.children]
* An array of children objects to initialize this component with. Children objects have
* a name property that will be used if more than one component of the same type needs to be
* added.
*
* @param {string} [options.className]
* A class or space separated list of classes to add the component
*
* @param {ReadyCallback} [ready]
* Function that gets called when the `Component` is ready.
*/
constructor(player: import('./player').default, options?: {
children?: any[];
className?: string;
}, ready?: () => any);
player_: any;
isDisposed_: boolean;
parentComponent_: any;
options_: any;
id_: any;
name_: any;
el_: any;
/**
* Handles language change for the player in components. Should be overridden by sub-components.
*
* @abstract
*/
handleLanguagechange(): void;
children_: any[];
childIndex_: {};
childNameIndex_: {};
setTimeoutIds_: Set<any>;
setIntervalIds_: Set<any>;
rafIds_: Set<any>;
namedRafs_: Map<any, any>;
clearingTimersOnDispose_: boolean;
/**
* Adds an `event listener` to an instance of an `EventTarget`. An `event listener` is a
* function that will get called when an event with a certain name gets triggered.
*
* @param {string|string[]} type
* An event name or an array of event names.
*
* @param {Function} fn
* The function to call with `EventTarget`s
*/
on(type: string | string[], fn: Function): void;
/**
* Removes an `event listener` for a specific event from an instance of `EventTarget`.
* This makes it so that the `event listener` will no longer get called when the
* named event happens.
*
* @param {string|string[]} type
* An event name or an array of event names.
*
* @param {Function} fn
* The function to remove.
*/
off(type: string | string[], fn: Function): void;
/**
* This function will add an `event listener` that gets triggered only once. After the
* first trigger it will get removed. This is like adding an `event listener`
* with {@link EventTarget#on} that calls {@link EventTarget#off} on itself.
*
* @param {string|string[]} type
* An event name or an array of event names.
*
* @param {Function} fn
* The function to be called once for each event name.
*/
one(type: string | string[], fn: Function): void;
/**
* This function will add an `event listener` that gets triggered only once and is
* removed from all events. This is like adding an array of `event listener`s
* with {@link EventTarget#on} that calls {@link EventTarget#off} on all events the
* first time it is triggered.
*
* @param {string|string[]} type
* An event name or an array of event names.
*
* @param {Function} fn
* The function to be called once for each event name.
*/
any(type: string | string[], fn: Function): void;
/**
* This function causes an event to happen. This will then cause any `event listeners`
* that are waiting for that event, to get called. If there are no `event listeners`
* for an event then nothing will happen.
*
* If the name of the `Event` that is being triggered is in `EventTarget.allowedEvents_`.
* Trigger will also call the `on` + `uppercaseEventName` function.
*
* Example:
* 'click' is in `EventTarget.allowedEvents_`, so, trigger will attempt to call
* `onClick` if it exists.
*
* @param {string|Event|Object} event
* The name of the event, an `Event`, or an object with a key of type set to
* an event name.
*/
trigger(event: string | Event | any): void;
/**
* Dispose of the `Component` and all child components.
*
* @fires Component#dispose
*
* @param {Object} options
* @param {Element} options.originalEl element with which to replace player element
*/
dispose(options?: {
originalEl: Element;
}): void;
/**
* Determine whether or not this component has been disposed.
*
* @return {boolean}
* If the component has been disposed, will be `true`. Otherwise, `false`.
*/
isDisposed(): boolean;
/**
* Return the {@link Player} that the `Component` has attached to.
*
* @return { import('./player').default }
* The player that this `Component` has attached to.
*/
player(): import('./player').default;
/**
* Deep merge of options objects with new options.
* > Note: When both `obj` and `options` contain properties whose values are objects.
* The two properties get merged using {@link module:obj.merge}
*
* @param {Object} obj
* The object that contains new options.
*
* @return {Object}
* A new object of `this.options_` and `obj` merged together.
*/
options(obj: any): any;
/**
* Get the `Component`s DOM element
*
* @return {Element}
* The DOM element for this `Component`.
*/
el(): Element;
/**
* Create the `Component`s DOM element.
*
* @param {string} [tagName]
* Element's DOM node type. e.g. 'div'
*
* @param {Object} [properties]
* An object of properties that should be set.
*
* @param {Object} [attributes]
* An object of attributes that should be set.
*
* @return {Element}
* The element that gets created.
*/
createEl(tagName?: string, properties?: any, attributes?: any): Element;
/**
* Localize a string given the string in english.
*
* If tokens are provided, it'll try and run a simple token replacement on the provided string.
* The tokens it looks for look like `{1}` with the index being 1-indexed into the tokens array.
*
* If a `defaultValue` is provided, it'll use that over `string`,
* if a value isn't found in provided language files.
* This is useful if you want to have a descriptive key for token replacement
* but have a succinct localized string and not require `en.json` to be included.
*
* Currently, it is used for the progress bar timing.
* ```js
* {
* "progress bar timing: currentTime={1} duration={2}": "{1} of {2}"
* }
* ```
* It is then used like so:
* ```js
* this.localize('progress bar timing: currentTime={1} duration{2}',
* [this.player_.currentTime(), this.player_.duration()],
* '{1} of {2}');
* ```
*
* Which outputs something like: `01:23 of 24:56`.
*
*
* @param {string} string
* The string to localize and the key to lookup in the language files.
* @param {string[]} [tokens]
* If the current item has token replacements, provide the tokens here.
* @param {string} [defaultValue]
* Defaults to `string`. Can be a default value to use for token replacement
* if the lookup key is needed to be separate.
*
* @return {string}
* The localized string or if no localization exists the english string.
*/
localize(string: string, tokens?: string[], defaultValue?: string): string;
/**
* Return the `Component`s DOM element. This is where children get inserted.
* This will usually be the the same as the element returned in {@link Component#el}.
*
* @return {Element}
* The content element for this `Component`.
*/
contentEl(): Element;
/**
* Get this `Component`s ID
*
* @return {string}
* The id of this `Component`
*/
id(): string;
/**
* Get the `Component`s name. The name gets used to reference the `Component`
* and is set during registration.
*
* @return {string}
* The name of this `Component`.
*/
name(): string;
/**
* Get an array of all child components
*
* @return {Array}
* The children
*/
children(): any[];
/**
* Returns the child `Component` with the given `id`.
*
* @param {string} id
* The id of the child `Component` to get.
*
* @return {Component|undefined}
* The child `Component` with the given `id` or undefined.
*/
getChildById(id: string): Component | undefined;
/**
* Returns the child `Component` with the given `name`.
*
* @param {string} name
* The name of the child `Component` to get.
*
* @return {Component|undefined}
* The child `Component` with the given `name` or undefined.
*/
getChild(name: string): Component | undefined;
/**
* Returns the descendant `Component` following the givent
* descendant `names`. For instance ['foo', 'bar', 'baz'] would
* try to get 'foo' on the current component, 'bar' on the 'foo'
* component and 'baz' on the 'bar' component and return undefined
* if any of those don't exist.
*
* @param {...string[]|...string} names
* The name of the child `Component` to get.
*
* @return {Component|undefined}
* The descendant `Component` following the given descendant
* `names` or undefined.
*/
getDescendant(...names: any[]): Component | undefined;
/**
* Add a child `Component` inside the current `Component`.
*
*
* @param {string|Component} child
* The name or instance of a child to add.
*
* @param {Object} [options={}]
* The key/value store of options that will get passed to children of
* the child.
*
* @param {number} [index=this.children_.length]
* The index to attempt to add a child into.
*
* @return {Component}
* The `Component` that gets added as a child. When using a string the
* `Component` will get created by this process.
*/
addChild(child: string | Component, options?: any, index?: number): Component;
/**
* Remove a child `Component` from this `Component`s list of children. Also removes
* the child `Component`s element from this `Component`s element.
*
* @param {Component} component
* The child `Component` to remove.
*/
removeChild(component: Component): void;
/**
* Add and initialize default child `Component`s based upon options.
*/
initChildren(): void;
/**
* Builds the default DOM class name. Should be overridden by sub-components.
*
* @return {string}
* The DOM class name for this object.
*
* @abstract
*/
buildCSSClass(): string;
/**
* Bind a listener to the component's ready state.
* Different from event listeners in that if the ready event has already happened
* it will trigger the function immediately.
*
* @param {ReadyCallback} fn
* Function that gets called when the `Component` is ready.
*
* @return {Component}
* Returns itself; method can be chained.
*/
ready(fn: () => any, sync?: boolean): Component;
readyQueue_: any;
/**
* Trigger all the ready listeners for this `Component`.
*
* @fires Component#ready
*/
triggerReady(): void;
isReady_: boolean;
/**
* Find a single DOM element matching a `selector`. This can be within the `Component`s
* `contentEl()` or another custom context.
*
* @param {string} selector
* A valid CSS selector, which will be passed to `querySelector`.
*
* @param {Element|string} [context=this.contentEl()]
* A DOM element within which to query. Can also be a selector string in
* which case the first matching element will get used as context. If
* missing `this.contentEl()` gets used. If `this.contentEl()` returns
* nothing it falls back to `document`.
*
* @return {Element|null}
* the dom element that was found, or null
*
* @see [Information on CSS Selectors](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Getting_Started/Selectors)
*/
$(selector: string, context?: Element | string): Element | null;
/**
* Finds all DOM element matching a `selector`. This can be within the `Component`s
* `contentEl()` or another custom context.
*
* @param {string} selector
* A valid CSS selector, which will be passed to `querySelectorAll`.
*
* @param {Element|string} [context=this.contentEl()]
* A DOM element within which to query. Can also be a selector string in
* which case the first matching element will get used as context. If
* missing `this.contentEl()` gets used. If `this.contentEl()` returns
* nothing it falls back to `document`.
*
* @return {NodeList}
* a list of dom elements that were found
*
* @see [Information on CSS Selectors](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Getting_Started/Selectors)
*/
$$(selector: string, context?: Element | string): NodeList;
/**
* Check if a component's element has a CSS class name.
*
* @param {string} classToCheck
* CSS class name to check.
*
* @return {boolean}
* - True if the `Component` has the class.
* - False if the `Component` does not have the class`
*/
hasClass(classToCheck: string): boolean;
/**
* Add a CSS class name to the `Component`s element.
*
* @param {...string} classesToAdd
* One or more CSS class name to add.
*/
addClass(...classesToAdd: string[]): void;
/**
* Remove a CSS class name from the `Component`s element.
*
* @param {...string} classesToRemove
* One or more CSS class name to remove.
*/
removeClass(...classesToRemove: string[]): void;
/**
* Add or remove a CSS class name from the component's element.
* - `classToToggle` gets added when {@link Component#hasClass} would return false.
* - `classToToggle` gets removed when {@link Component#hasClass} would return true.
*
* @param {string} classToToggle
* The class to add or remove based on (@link Component#hasClass}
*
* @param {boolean|Dom~predicate} [predicate]
* An {@link Dom~predicate} function or a boolean
*/
toggleClass(classToToggle: string, predicate: any): void;
/**
* Show the `Component`s element if it is hidden by removing the
* 'vjs-hidden' class name from it.
*/
show(): void;
/**
* Hide the `Component`s element if it is currently showing by adding the
* 'vjs-hidden` class name to it.
*/
hide(): void;
/**
* Lock a `Component`s element in its visible state by adding the 'vjs-lock-showing'
* class name to it. Used during fadeIn/fadeOut.
*
* @private
*/
private lockShowing;
/**
* Unlock a `Component`s element from its visible state by removing the 'vjs-lock-showing'
* class name from it. Used during fadeIn/fadeOut.
*
* @private
*/
private unlockShowing;
/**
* Get the value of an attribute on the `Component`s element.
*
* @param {string} attribute
* Name of the attribute to get the value from.
*
* @return {string|null}
* - The value of the attribute that was asked for.
* - Can be an empty string on some browsers if the attribute does not exist
* or has no value
* - Most browsers will return null if the attribute does not exist or has
* no value.
*
* @see [DOM API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Element/getAttribute}
*/
getAttribute(attribute: string): string | null;
/**
* Set the value of an attribute on the `Component`'s element
*
* @param {string} attribute
* Name of the attribute to set.
*
* @param {string} value
* Value to set the attribute to.
*
* @see [DOM API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Element/setAttribute}
*/
setAttribute(attribute: string, value: string): void;
/**
* Remove an attribute from the `Component`s element.
*
* @param {string} attribute
* Name of the attribute to remove.
*
* @see [DOM API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Element/removeAttribute}
*/
removeAttribute(attribute: string): void;
/**
* Get or set the width of the component based upon the CSS styles.
* See {@link Component#dimension} for more detailed information.
*
* @param {number|string} [num]
* The width that you want to set postfixed with '%', 'px' or nothing.
*
* @param {boolean} [skipListeners]
* Skip the componentresize event trigger
*
* @return {number|string}
* The width when getting, zero if there is no width. Can be a string
* postpixed with '%' or 'px'.
*/
width(num?: number | string, skipListeners?: boolean): number | string;
/**
* Get or set the height of the component based upon the CSS styles.
* See {@link Component#dimension} for more detailed information.
*
* @param {number|string} [num]
* The height that you want to set postfixed with '%', 'px' or nothing.
*
* @param {boolean} [skipListeners]
* Skip the componentresize event trigger
*
* @return {number|string}
* The width when getting, zero if there is no width. Can be a string
* postpixed with '%' or 'px'.
*/
height(num?: number | string, skipListeners?: boolean): number | string;
/**
* Set both the width and height of the `Component` element at the same time.
*
* @param {number|string} width
* Width to set the `Component`s element to.
*
* @param {number|string} height
* Height to set the `Component`s element to.
*/
dimensions(width: number | string, height: number | string): void;
/**
* Get or set width or height of the `Component` element. This is the shared code
* for the {@link Component#width} and {@link Component#height}.
*
* Things to know:
* - If the width or height in an number this will return the number postfixed with 'px'.
* - If the width/height is a percent this will return the percent postfixed with '%'
* - Hidden elements have a width of 0 with `window.getComputedStyle`. This function
* defaults to the `Component`s `style.width` and falls back to `window.getComputedStyle`.
* See [this]{@link http://www.foliotek.com/devblog/getting-the-width-of-a-hidden-element-with-jquery-using-width/}
* for more information
* - If you want the computed style of the component, use {@link Component#currentWidth}
* and {@link {Component#currentHeight}
*
* @fires Component#componentresize
*
* @param {string} widthOrHeight
8 'width' or 'height'
*
* @param {number|string} [num]
8 New dimension
*
* @param {boolean} [skipListeners]
* Skip componentresize event trigger
*
* @return {number}
* The dimension when getting or 0 if unset
*/
dimension(widthOrHeight: string, num?: number | string, skipListeners?: boolean): number;
/**
* Get the computed width or the height of the component's element.
*
* Uses `window.getComputedStyle`.
*
* @param {string} widthOrHeight
* A string containing 'width' or 'height'. Whichever one you want to get.
*
* @return {number}
* The dimension that gets asked for or 0 if nothing was set
* for that dimension.
*/
currentDimension(widthOrHeight: string): number;
/**
* An object that contains width and height values of the `Component`s
* computed style. Uses `window.getComputedStyle`.
*
* @typedef {Object} Component~DimensionObject
*
* @property {number} width
* The width of the `Component`s computed style.
*
* @property {number} height
* The height of the `Component`s computed style.
*/
/**
* Get an object that contains computed width and height values of the
* component's element.
*
* Uses `window.getComputedStyle`.
*
* @return {Component~DimensionObject}
* The computed dimensions of the component's element.
*/
currentDimensions(): Component;
/**
* Get the computed width of the component's element.
*
* Uses `window.getComputedStyle`.
*
* @return {number}
* The computed width of the component's element.
*/
currentWidth(): number;
/**
* Get the computed height of the component's element.
*
* Uses `window.getComputedStyle`.
*
* @return {number}
* The computed height of the component's element.
*/
currentHeight(): number;
/**
* Set the focus to this component
*/
focus(): void;
/**
* Remove the focus from this component
*/
blur(): void;
/**
* When this Component receives a `keydown` event which it does not process,
* it passes the event to the Player for handling.
*
* @param {KeyboardEvent} event
* The `keydown` event that caused this function to be called.
*/
handleKeyDown(event: KeyboardEvent): void;
/**
* Many components used to have a `handleKeyPress` method, which was poorly
* named because it listened to a `keydown` event. This method name now
* delegates to `handleKeyDown`. This means anyone calling `handleKeyPress`
* will not see their method calls stop working.
*
* @param {Event} event
* The event that caused this function to be called.
*/
handleKeyPress(event: Event): void;
/**
* Emit a 'tap' events when touch event support gets detected. This gets used to
* support toggling the controls through a tap on the video. They get enabled
* because every sub-component would have extra overhead otherwise.
*
* @private
* @fires Component#tap
* @listens Component#touchstart
* @listens Component#touchmove
* @listens Component#touchleave
* @listens Component#touchcancel
* @listens Component#touchend
*/
private emitTapEvents;
/**
* This function reports user activity whenever touch events happen. This can get
* turned off by any sub-components that wants touch events to act another way.
*
* Report user touch activity when touch events occur. User activity gets used to
* determine when controls should show/hide. It is simple when it comes to mouse
* events, because any mouse event should show the controls. So we capture mouse
* events that bubble up to the player and report activity when that happens.
* With touch events it isn't as easy as `touchstart` and `touchend` toggle player
* controls. So touch events can't help us at the player level either.
*
* User activity gets checked asynchronously. So what could happen is a tap event
* on the video turns the controls off. Then the `touchend` event bubbles up to
* the player. Which, if it reported user activity, would turn the controls right
* back on. We also don't want to completely block touch events from bubbling up.
* Furthermore a `touchmove` event and anything other than a tap, should not turn
* controls back on.
*
* @listens Component#touchstart
* @listens Component#touchmove
* @listens Component#touchend
* @listens Component#touchcancel
*/
enableTouchActivity(): void;
/**
* A callback that has no parameters and is bound into `Component`s context.
*
* @callback Component~GenericCallback
* @this Component
*/
/**
* Creates a function that runs after an `x` millisecond timeout. This function is a
* wrapper around `window.setTimeout`. There are a few reasons to use this one
* instead though:
* 1. It gets cleared via {@link Component#clearTimeout} when
* {@link Component#dispose} gets called.
* 2. The function callback will gets turned into a {@link Component~GenericCallback}
*
* > Note: You can't use `window.clearTimeout` on the id returned by this function. This
* will cause its dispose listener not to get cleaned up! Please use
* {@link Component#clearTimeout} or {@link Component#dispose} instead.
*
* @param {Component~GenericCallback} fn
* The function that will be run after `timeout`.
*
* @param {number} timeout
* Timeout in milliseconds to delay before executing the specified function.
*
* @return {number}
* Returns a timeout ID that gets used to identify the timeout. It can also
* get used in {@link Component#clearTimeout} to clear the timeout that
* was set.
*
* @listens Component#dispose
* @see [Similar to]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setTimeout}
*/
setTimeout(fn: any, timeout: number): number;
/**
* Clears a timeout that gets created via `window.setTimeout` or
* {@link Component#setTimeout}. If you set a timeout via {@link Component#setTimeout}
* use this function instead of `window.clearTimout`. If you don't your dispose
* listener will not get cleaned up until {@link Component#dispose}!
*
* @param {number} timeoutId
* The id of the timeout to clear. The return value of
* {@link Component#setTimeout} or `window.setTimeout`.
*
* @return {number}
* Returns the timeout id that was cleared.
*
* @see [Similar to]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/clearTimeout}
*/
clearTimeout(timeoutId: number): number;
/**
* Creates a function that gets run every `x` milliseconds. This function is a wrapper
* around `window.setInterval`. There are a few reasons to use this one instead though.
* 1. It gets cleared via {@link Component#clearInterval} when
* {@link Component#dispose} gets called.
* 2. The function callback will be a {@link Component~GenericCallback}
*
* @param {Component~GenericCallback} fn
* The function to run every `x` seconds.
*
* @param {number} interval
* Execute the specified function every `x` milliseconds.
*
* @return {number}
* Returns an id that can be used to identify the interval. It can also be be used in
* {@link Component#clearInterval} to clear the interval.
*
* @listens Component#dispose
* @see [Similar to]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setInterval}
*/
setInterval(fn: any, interval: number): number;
/**
* Clears an interval that gets created via `window.setInterval` or
* {@link Component#setInterval}. If you set an interval via {@link Component#setInterval}
* use this function instead of `window.clearInterval`. If you don't your dispose
* listener will not get cleaned up until {@link Component#dispose}!
*
* @param {number} intervalId
* The id of the interval to clear. The return value of
* {@link Component#setInterval} or `window.setInterval`.
*
* @return {number}
* Returns the interval id that was cleared.
*
* @see [Similar to]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/clearInterval}
*/
clearInterval(intervalId: number): number;
/**
* Queues up a callback to be passed to requestAnimationFrame (rAF), but
* with a few extra bonuses:
*
* - Supports browsers that do not support rAF by falling back to
* {@link Component#setTimeout}.
*
* - The callback is turned into a {@link Component~GenericCallback} (i.e.
* bound to the component).
*
* - Automatic cancellation of the rAF callback is handled if the component
* is disposed before it is called.
*
* @param {Component~GenericCallback} fn
* A function that will be bound to this component and executed just
* before the browser's next repaint.
*
* @return {number}
* Returns an rAF ID that gets used to identify the timeout. It can
* also be used in {@link Component#cancelAnimationFrame} to cancel
* the animation frame callback.
*
* @listens Component#dispose
* @see [Similar to]{@link https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame}
*/
requestAnimationFrame(fn: any): number;
/**
* Request an animation frame, but only one named animation
* frame will be queued. Another will never be added until
* the previous one finishes.
*
* @param {string} name
* The name to give this requestAnimationFrame
*
* @param {Component~GenericCallback} fn
* A function that will be bound to this component and executed just
* before the browser's next repaint.
*/
requestNamedAnimationFrame(name: string, fn: any): string;
/**
* Cancels a current named animation frame if it exists.
*
* @param {string} name
* The name of the requestAnimationFrame to cancel.
*/
cancelNamedAnimationFrame(name: string): void;
/**
* Cancels a queued callback passed to {@link Component#requestAnimationFrame}
* (rAF).
*
* If you queue an rAF callback via {@link Component#requestAnimationFrame},
* use this function instead of `window.cancelAnimationFrame`. If you don't,
* your dispose listener will not get cleaned up until {@link Component#dispose}!
*
* @param {number} id
* The rAF ID to clear. The return value of {@link Component#requestAnimationFrame}.
*
* @return {number}
* Returns the rAF ID that was cleared.
*
* @see [Similar to]{@link https://developer.mozilla.org/en-US/docs/Web/API/window/cancelAnimationFrame}
*/
cancelAnimationFrame(id: number): number;
/**
* A function to setup `requestAnimationFrame`, `setTimeout`,
* and `setInterval`, clearing on dispose.
*
* > Previously each timer added and removed dispose listeners on it's own.
* For better performance it was decided to batch them all, and use `Set`s
* to track outstanding timer ids.
*
* @private
*/
private clearTimersOnDispose_;
}
//# sourceMappingURL=component.d.ts.map

1
node_modules/video.js/dist/types/component.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/js/component.js"],"names":[],"mappings":";AAeA;;;;;;;GAOG;AACH;IA2pDE;;;;;;;;;;;;;;;;;;OAkBG;IACH,+BATW,MAAM,uBAGN,SAAS,GAGR,SAAS,CAsDpB;IAED;;;;;;;;OAQG;IACH,0BANW,MAAM,GAGL,SAAS,CASpB;IAhvDD;;;;;;OAMG;IAEH;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oBAjBY,OAAO,UAAU,EAAE,OAAO;QAMR,QAAQ,GAA3B,KAAQ;QAKU,SAAS,GAA1B,MAAM;0BAyFjB;IA/EG,aAA4B;IAK9B,qBAAwB;IAGxB,sBAA4B;IAG5B,cAAwC;IAMxC,SAAsD;IAUtD,WAAiC;IAI/B,SAAqB;IAwUzB;;;;OAIG;IACH,6BAAyB;IApTvB,iBAAmB;IACnB,gBAAqB;IACrB,oBAAyB;IAEzB,yBAA+B;IAC/B,0BAAgC;IAChC,kBAAwB;IACxB,0BAA2B;IAC3B,kCAAqC;IAoBvC;;;;;;;;;OASG;IACH,SANW,MAAM,GAAC,MAAM,EAAE,sBAMX;IAEf;;;;;;;;;;OAUG;IACH,UANW,MAAM,GAAC,MAAM,EAAE,sBAMV;IAEhB;;;;;;;;;;OAUG;IACH,UANW,MAAM,GAAC,MAAM,EAAE,sBAMV;IAEhB;;;;;;;;;;;OAWG;IACH,UANW,MAAM,GAAC,MAAM,EAAE,sBAMV;IAEhB;;;;;;;;;;;;;;;OAeG;IACH,eAJW,MAAM,GAAC,KAAK,MAAO,QAIb;IAEjB;;;;;;;OAOG;IACH;QAF4B,UAAU,EAA3B,OAAO;aA0DjB;IAED;;;;;OAKG;IACH,cAHY,OAAO,CAKlB;IAED;;;;;OAKG;IACH,UAHa,OAAO,UAAU,EAAE,OAAO,CAKtC;IAED;;;;;;;;;;OAUG;IACH,uBAOC;IAED;;;;;OAKG;IACH,MAHY,OAAO,CAKlB;IAED;;;;;;;;;;;;;;OAcG;IACH,mBAZW,MAAM,uCASL,OAAO,CAKlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,iBAXW,MAAM,WAEN,MAAM,EAAE,iBAER,MAAM,GAIL,MAAM,CAiCjB;IASD;;;;;;OAMG;IACH,aAHY,OAAO,CAKlB;IAED;;;;;OAKG;IACH,MAHY,MAAM,CAKjB;IAED;;;;;;OAMG;IACH,QAHY,MAAM,CAKjB;IAED;;;;;OAKG;IACH,kBAEC;IAED;;;;;;;;OAQG;IACH,iBANW,MAAM,GAGL,SAAS,GAAC,SAAS,CAK9B;IAED;;;;;;;;OAQG;IACH,eANW,MAAM,GAGL,SAAS,GAAC,SAAS,CAS9B;IAED;;;;;;;;;;;;;OAaG;IACH,gCAJY,SAAS,GAAC,SAAS,CAmB9B;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAdW,MAAM,GAAC,SAAS,yBAOhB,MAAM,GAGL,SAAS,CA+EpB;IAED;;;;;;OAMG;IACH,uBAHW,SAAS,QAqCnB;IAED;;OAEG;IACH,qBA6FC;IAED;;;;;;;OAOG;IACH,iBALY,MAAM,CASjB;IAED;;;;;;;;;;OAUG;IACH,sCAHY,SAAS,CAoBpB;IAXG,iBAAyC;IAa7C;;;;OAIG;IACH,qBAyBC;IAxBC,kBAAoB;IA0BtB;;;;;;;;;;;;;;;;;OAiBG;IACH,YAdW,MAAM,YAGN,OAAO,GAAC,MAAM,GAMb,OAAO,GAAC,IAAI,CAOvB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,aAdW,MAAM,YAGN,OAAO,GAAC,MAAM,GAMb,QAAQ,CAOnB;IAED;;;;;;;;;OASG;IACH,uBAPW,MAAM,GAGL,OAAO,CAMlB;IAED;;;;;OAKG;IACH,0BAHc,MAAM,UAKnB;IAED;;;;;OAKG;IACH,gCAHc,MAAM,UAKnB;IAED;;;;;;;;;;OAUG;IACH,2BANY,MAAM,wBAQjB;IAED;;;OAGG;IACH,aAEC;IAED;;;OAGG;IACH,aAEC;IAED;;;;;OAKG;IACH,oBAEC;IAED;;;;;OAKG;IACH,sBAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,wBAZW,MAAM,GAGL,MAAM,GAAC,IAAI,CAWtB;IAED;;;;;;;;;;OAUG;IACH,wBARW,MAAM,SAGN,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,2BALW,MAAM,QAOhB;IAED;;;;;;;;;;;;;OAaG;IACH,YAVW,MAAM,GAAC,MAAM,kBAGb,OAAO,GAGN,MAAM,GAAC,MAAM,CAMxB;IAED;;;;;;;;;;;;;OAaG;IACH,aAVW,MAAM,GAAC,MAAM,kBAGb,OAAO,GAGN,MAAM,GAAC,MAAM,CAMxB;IAED;;;;;;;;OAQG;IACH,kBANY,MAAM,GAAC,MAAM,UAGb,MAAM,GAAC,MAAM,QAOxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,yBAZW,MAAM,QAGL,MAAM,GAAC,MAAM,kBAGb,OAAO,GAGP,MAAM,CAoDjB;IAED;;;;;;;;;;;OAWG;IACH,gCAPW,MAAM,GAGL,MAAM,CA0BjB;IAED;;;;;;;;;;;OAWG;IAEH;;;;;;;;OAQG;IACH,qBAHY,SAAS,CAQpB;IAED;;;;;;;OAOG;IACH,gBAHY,MAAM,CAKjB;IAED;;;;;;;OAOG;IACH,iBAHY,MAAM,CAKjB;IAED;;OAEG;IACH,cAEC;IAED;;OAEG;IACH,aAEC;IAED;;;;;;OAMG;IACH,qBAHW,aAAa,QAavB;IAED;;;;;;;;OAQG;IACH,sBAHW,KAAK,QAKf;IAED;;;;;;;;;;;;;OAaG;IACH,sBAiFC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,4BA8BC;IAED;;;;;OAKG;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,6BAXW,MAAM,GAGL,MAAM,CA2BjB;IAED;;;;;;;;;;;;;;OAcG;IACH,wBATW,MAAM,GAIL,MAAM,CAYjB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,+BAVW,MAAM,GAGL,MAAM,CAiBjB;IAED;;;;;;;;;;;;;;OAcG;IACH,0BATW,MAAM,GAIL,MAAM,CAYjB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gCARY,MAAM,CAyBjB;IAED;;;;;;;;;;;OAWG;IACH,iCAPW,MAAM,mBAyBhB;IAED;;;;;OAKG;IACH,gCAHW,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBARW,MAAM,GAGL,MAAM,CAajB;IAED;;;;;;;;;OASG;IACH,8BAqBC;CA0FF"}

28
node_modules/video.js/dist/types/control-bar/audio-track-controls/audio-track-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,28 @@
export default AudioTrackButton;
/**
* The base class for buttons that toggle specific {@link AudioTrack} types.
*
* @extends TrackButton
*/
declare class AudioTrackButton extends TrackButton {
/**
* Create a menu item for each audio track
*
* @param {AudioTrackMenuItem[]} [items=[]]
* An array of existing menu items to use.
*
* @return {AudioTrackMenuItem[]}
* An array of menu items
*/
createItems(items?: AudioTrackMenuItem[]): AudioTrackMenuItem[];
/**
* The text that should display over the `AudioTrackButton`s controls. Added for localization.
*
* @type {string}
* @protected
*/
protected controlText_: string;
}
import TrackButton from "../track-button.js";
import AudioTrackMenuItem from "./audio-track-menu-item.js";
//# sourceMappingURL=audio-track-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/audio-track-controls/audio-track-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"audio-track-button.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/audio-track-controls/audio-track-button.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IA+BE;;;;;;;;OAQG;IACH,oBANW,kBAAkB,EAAE,GAGnB,kBAAkB,EAAE,CAsB/B;IAGH;;;;;OAKG;IACH,wBAHU,MAAM,CAGuB;CARtC"}

33
node_modules/video.js/dist/types/control-bar/audio-track-controls/audio-track-menu-item.d.ts generated vendored Normal file
View file

@ -0,0 +1,33 @@
export default AudioTrackMenuItem;
/**
* An {@link AudioTrack} {@link MenuItem}
*
* @extends MenuItem
*/
declare class AudioTrackMenuItem extends MenuItem {
track: any;
createEl(type: any, props: any, attrs: any): Element;
/**
* This gets called when an `AudioTrackMenuItem is "clicked". See {@link ClickableComponent}
* for more detailed information on what a click can be.
*
* @param {Event} [event]
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event?: Event): void;
/**
* Handle any {@link AudioTrack} change.
*
* @param {Event} [event]
* The {@link AudioTrackList#change} event that caused this to run.
*
* @listens AudioTrackList#change
*/
handleTracksChange(event?: Event): void;
}
import MenuItem from "../../menu/menu-item.js";
//# sourceMappingURL=audio-track-menu-item.d.ts.map

1
node_modules/video.js/dist/types/control-bar/audio-track-controls/audio-track-menu-item.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"audio-track-menu-item.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/audio-track-controls/audio-track-menu-item.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAqBI,WAAkB;IAcpB,qDAiBC;IAED;;;;;;;;;;OAUG;IACH,oBAPW,KAAK,QA6Bf;IAED;;;;;;;OAOG;IACH,2BALW,KAAK,QAOf;CACF"}

17
node_modules/video.js/dist/types/control-bar/control-bar.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
export default ControlBar;
/**
* Container of main controls.
*
* @extends Component
*/
declare class ControlBar extends Component {
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
}
import Component from "../component.js";
//# sourceMappingURL=control-bar.d.ts.map

1
node_modules/video.js/dist/types/control-bar/control-bar.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"control-bar.d.ts","sourceRoot":"","sources":["../../../src/js/control-bar/control-bar.js"],"names":[],"mappings":";AA6BA;;;;GAIG;AACH;IAEE;;;;;OAKG;IACH,YAHY,OAAO,CAQlB;CACF"}

42
node_modules/video.js/dist/types/control-bar/fullscreen-toggle.d.ts generated vendored Normal file
View file

@ -0,0 +1,42 @@
export default FullscreenToggle;
/**
* Toggle fullscreen video
*
* @extends Button
*/
declare class FullscreenToggle extends Button {
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: any, options?: any);
/**
* Handles fullscreenchange on the player and change control text accordingly.
*
* @param {Event} [event]
* The {@link Player#fullscreenchange} event that caused this function to be
* called.
*
* @listens Player#fullscreenchange
*/
handleFullscreenChange(event?: Event): void;
/**
* This gets called when an `FullscreenToggle` is "clicked". See
* {@link ClickableComponent} for more detailed information on what a click can be.
*
* @param {Event} [event]
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event?: Event): void;
}
import Button from "../button.js";
//# sourceMappingURL=fullscreen-toggle.d.ts.map

1
node_modules/video.js/dist/types/control-bar/fullscreen-toggle.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"fullscreen-toggle.d.ts","sourceRoot":"","sources":["../../../src/js/control-bar/fullscreen-toggle.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,wCAOC;IAYD;;;;;;;;OAQG;IACH,+BANW,KAAK,QAYf;IAED;;;;;;;;;;OAUG;IACH,oBAPW,KAAK,QAaf;CAEF"}

39
node_modules/video.js/dist/types/control-bar/live-display.d.ts generated vendored Normal file
View file

@ -0,0 +1,39 @@
export default LiveDisplay;
/**
* Displays the live indicator when duration is Infinity.
*
* @extends Component
*/
declare class LiveDisplay extends Component {
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: any, options?: any);
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
contentEl_: Element;
dispose(): void;
/**
* Check the duration to see if the LiveDisplay should be showing or not. Then show/hide
* it accordingly
*
* @param {Event} [event]
* The {@link Player#durationchange} event that caused this function to run.
*
* @listens Player#durationchange
*/
updateShowing(event?: Event): void;
}
import Component from "../component";
//# sourceMappingURL=live-display.d.ts.map

1
node_modules/video.js/dist/types/control-bar/live-display.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"live-display.d.ts","sourceRoot":"","sources":["../../../src/js/control-bar/live-display.js"],"names":[],"mappings":";AASA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,wCAKC;IAED;;;;;OAKG;IACH,YAHY,OAAO,CAsBlB;IAdC,oBAIE;IAYJ,gBAIC;IAED;;;;;;;;OAQG;IACH,sBALW,KAAK,QAWf;CAEF"}

64
node_modules/video.js/dist/types/control-bar/mute-toggle.d.ts generated vendored Normal file
View file

@ -0,0 +1,64 @@
export default MuteToggle;
/**
* A button component for muting the audio.
*
* @extends Button
*/
declare class MuteToggle extends Button {
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: any, options?: any);
/**
* This gets called when an `MuteToggle` is "clicked". See
* {@link ClickableComponent} for more detailed information on what a click can be.
*
* @param {Event} [event]
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event?: Event): void;
/**
* Update the `MuteToggle` button based on the state of `volume` and `muted`
* on the player.
*
* @param {Event} [event]
* The {@link Player#loadstart} event if this function was called
* through an event.
*
* @listens Player#loadstart
* @listens Player#volumechange
*/
update(event?: Event): void;
/**
* Update the appearance of the `MuteToggle` icon.
*
* Possible states (given `level` variable below):
* - 0: crossed out
* - 1: zero bars of volume
* - 2: one bar of volume
* - 3: two bars of volume
*
* @private
*/
private updateIcon_;
/**
* If `muted` has changed on the player, update the control text
* (`title` attribute on `vjs-mute-control` element and content of
* `vjs-control-text` element).
*
* @private
*/
private updateControlText_;
}
import Button from "../button";
//# sourceMappingURL=mute-toggle.d.ts.map

1
node_modules/video.js/dist/types/control-bar/mute-toggle.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"mute-toggle.d.ts","sourceRoot":"","sources":["../../../src/js/control-bar/mute-toggle.js"],"names":[],"mappings":";AASA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,wCAOC;IAYD;;;;;;;;;;OAUG;IACH,oBAPW,KAAK,QAmBf;IAED;;;;;;;;;;OAUG;IACH,eAPW,KAAK,QAUf;IAED;;;;;;;;;;OAUG;IACH,oBAqBC;IAED;;;;;;OAMG;IACH,2BAOC;CAEF"}

56
node_modules/video.js/dist/types/control-bar/picture-in-picture-toggle.d.ts generated vendored Normal file
View file

@ -0,0 +1,56 @@
export default PictureInPictureToggle;
/**
* Toggle Picture-in-Picture mode
*
* @extends Button
*/
declare class PictureInPictureToggle extends Button {
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*
* @listens Player#enterpictureinpicture
* @listens Player#leavepictureinpicture
*/
constructor(player: any, options?: any);
/**
* Enables or disables button based on availability of a Picture-In-Picture mode.
*
* Enabled if
* - `player.options().enableDocumentPictureInPicture` is true and
* window.documentPictureInPicture is available; or
* - `player.disablePictureInPicture()` is false and
* element.requestPictureInPicture is available
*/
handlePictureInPictureEnabledChange(): void;
/**
* Handles enterpictureinpicture and leavepictureinpicture on the player and change control text accordingly.
*
* @param {Event} [event]
* The {@link Player#enterpictureinpicture} or {@link Player#leavepictureinpicture} event that caused this function to be
* called.
*
* @listens Player#enterpictureinpicture
* @listens Player#leavepictureinpicture
*/
handlePictureInPictureChange(event?: Event): void;
/**
* This gets called when an `PictureInPictureToggle` is "clicked". See
* {@link ClickableComponent} for more detailed information on what a click can be.
*
* @param {Event} [event]
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event?: Event): void;
}
import Button from "../button.js";
//# sourceMappingURL=picture-in-picture-toggle.d.ts.map

1
node_modules/video.js/dist/types/control-bar/picture-in-picture-toggle.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"picture-in-picture-toggle.d.ts","sourceRoot":"","sources":["../../../src/js/control-bar/picture-in-picture-toggle.js"],"names":[],"mappings":";AAQA;;;;GAIG;AACH;IAEE;;;;;;;;;;;OAWG;IACH,wCAsBC;IAYD;;;;;;;;OAQG;IACH,4CASC;IAED;;;;;;;;;OASG;IACH,qCAPW,KAAK,QAcf;IAED;;;;;;;;;;OAUG;IACH,oBAPW,KAAK,QAaf;CAEF"}

69
node_modules/video.js/dist/types/control-bar/play-toggle.d.ts generated vendored Normal file
View file

@ -0,0 +1,69 @@
export default PlayToggle;
/**
* Button to toggle between play and pause.
*
* @extends Button
*/
declare class PlayToggle extends Button {
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options={}]
* The key/value store of player options.
*/
constructor(player: any, options?: any);
/**
* This gets called when an `PlayToggle` is "clicked". See
* {@link ClickableComponent} for more detailed information on what a click can be.
*
* @param {Event} [event]
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event?: Event): void;
/**
* This gets called once after the video has ended and the user seeks so that
* we can change the replay button back to a play button.
*
* @param {Event} [event]
* The event that caused this function to run.
*
* @listens Player#seeked
*/
handleSeeked(event?: Event): void;
/**
* Add the vjs-playing class to the element so it can change appearance.
*
* @param {Event} [event]
* The event that caused this function to run.
*
* @listens Player#play
*/
handlePlay(event?: Event): void;
/**
* Add the vjs-paused class to the element so it can change appearance.
*
* @param {Event} [event]
* The event that caused this function to run.
*
* @listens Player#pause
*/
handlePause(event?: Event): void;
/**
* Add the vjs-ended class to the element so it can change appearance
*
* @param {Event} [event]
* The event that caused this function to run.
*
* @listens Player#ended
*/
handleEnded(event?: Event): void;
}
import Button from "../button.js";
//# sourceMappingURL=play-toggle.d.ts.map

1
node_modules/video.js/dist/types/control-bar/play-toggle.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"play-toggle.d.ts","sourceRoot":"","sources":["../../../src/js/control-bar/play-toggle.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,wCAYC;IAYD;;;;;;;;;;OAUG;IACH,oBAPW,KAAK,QAaf;IAED;;;;;;;;OAQG;IACH,qBALW,KAAK,QAaf;IAED;;;;;;;OAOG;IACH,mBALW,KAAK,QAUf;IAED;;;;;;;OAOG;IACH,oBALW,KAAK,QAUf;IAED;;;;;;;OAOG;IACH,oBALW,KAAK,QAaf;CACF"}

66
node_modules/video.js/dist/types/control-bar/playback-rate-menu/playback-rate-menu-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,66 @@
export default PlaybackRateMenuButton;
/**
* The component for controlling the playback rate.
*
* @extends MenuButton
*/
declare class PlaybackRateMenuButton extends MenuButton {
labelElId_: string;
labelEl_: Element;
/**
* Create the list of menu items. Specific to each subclass.
*
*/
createItems(): PlaybackRateMenuItem[];
/**
* On playbackrateschange, update the menu to account for the new items.
*
* @listens Player#playbackrateschange
*/
handlePlaybackRateschange(event: any): void;
/**
* Get possible playback rates
*
* @return {Array}
* All possible playback rates
*/
playbackRates(): any[];
/**
* Get whether playback rates is supported by the tech
* and an array of playback rates exists
*
* @return {boolean}
* Whether changing playback rate is supported
*/
playbackRateSupported(): boolean;
/**
* Hide playback rate controls when they're no playback rate options to select
*
* @param {Event} [event]
* The event that caused this function to run.
*
* @listens Player#loadstart
*/
updateVisibility(event?: Event): void;
/**
* Update button label when rate changed
*
* @param {Event} [event]
* The event that caused this function to run.
*
* @listens Player#ratechange
*/
updateLabel(event?: Event): void;
/**
* The text that should display over the `PlaybackRateMenuButton`s controls.
*
* Added for localization.
*
* @type {string}
* @protected
*/
protected controlText_: string;
}
import MenuButton from "../../menu/menu-button.js";
import PlaybackRateMenuItem from "./playback-rate-menu-item.js";
//# sourceMappingURL=playback-rate-menu-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/playback-rate-menu/playback-rate-menu-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"playback-rate-menu-button.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/playback-rate-menu/playback-rate-menu-button.js"],"names":[],"mappings":";AAQA;;;;GAIG;AACH;IAiCI,mBAA6D;IAE7D,kBAIE;IA2BJ;;;OAGG;IACH,sCASC;IAED;;;;OAIG;IACH,4CAEC;IAED;;;;;OAKG;IACH,uBAIC;IAED;;;;;;OAMG;IACH,yBAHY,OAAO,CASlB;IAED;;;;;;;OAOG;IACH,yBALW,KAAK,QAWf;IAED;;;;;;;OAOG;IACH,oBALW,KAAK,QASf;IAIH;;;;;;;OAOG;IACH,wBAHU,MAAM,CAG6B;CAV5C"}

40
node_modules/video.js/dist/types/control-bar/playback-rate-menu/playback-rate-menu-item.d.ts generated vendored Normal file
View file

@ -0,0 +1,40 @@
export default PlaybackRateMenuItem;
/**
* The specific menu item type for selecting a playback rate.
*
* @extends MenuItem
*/
declare class PlaybackRateMenuItem extends MenuItem {
label: any;
rate: number;
/**
* This gets called when an `PlaybackRateMenuItem` is "clicked". See
* {@link ClickableComponent} for more detailed information on what a click can be.
*
* @param {Event} [event]
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event?: Event): void;
/**
* Update the PlaybackRateMenuItem when the playbackrate changes.
*
* @param {Event} [event]
* The `ratechange` event that caused this function to run.
*
* @listens Player#ratechange
*/
update(event?: Event): void;
/**
* The text that should display over the `PlaybackRateMenuItem`s controls. Added for localization.
*
* @type {string}
* @private
*/
private contentElType;
}
import MenuItem from "../../menu/menu-item.js";
//# sourceMappingURL=playback-rate-menu-item.d.ts.map

1
node_modules/video.js/dist/types/control-bar/playback-rate-menu/playback-rate-menu-item.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"playback-rate-menu-item.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/playback-rate-menu/playback-rate-menu-item.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH;IAuBI,WAAkB;IAClB,aAAgB;IAKlB;;;;;;;;;;OAUG;IACH,oBAPW,KAAK,QAUf;IAED;;;;;;;OAOG;IACH,eALW,KAAK,QAOf;IAIH;;;;;OAKG;IACH,sBAA4C;CAR3C"}

40
node_modules/video.js/dist/types/control-bar/progress-control/load-progress-bar.d.ts generated vendored Normal file
View file

@ -0,0 +1,40 @@
export default LoadProgressBar;
/**
* Shows loading progress
*
* @extends Component
*/
declare class LoadProgressBar extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
partEls_: any[];
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
percentageEl_: Element;
dispose(): void;
/**
* Update progress bar
*
* @param {Event} [event]
* The `progress` event that caused this function to run.
*
* @listens Player#progress
*/
update(event?: Event): void;
percent_: any;
}
import Component from "../../component.js";
//# sourceMappingURL=load-progress-bar.d.ts.map

1
node_modules/video.js/dist/types/control-bar/progress-control/load-progress-bar.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"load-progress-bar.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/progress-control/load-progress-bar.js"],"names":[],"mappings":";AAWA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBAUzC;IAFC,gBAAkB;IAIpB;;;;;OAKG;IACH,YAHY,OAAO,CAoBlB;IAXC,uBAGE;IAUJ,gBAKC;IAED;;;;;;;OAOG;IACH,eALW,KAAK,QAoDf;IAjCK,cAAuB;CAkC9B"}

42
node_modules/video.js/dist/types/control-bar/progress-control/mouse-time-display.d.ts generated vendored Normal file
View file

@ -0,0 +1,42 @@
export default MouseTimeDisplay;
/**
* The {@link MouseTimeDisplay} component tracks mouse movement over the
* {@link ProgressControl}. It displays an indicator and a {@link TimeTooltip}
* indicating the time which is represented by a given point in the
* {@link ProgressControl}.
*
* @extends Component
*/
declare class MouseTimeDisplay extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The {@link Player} that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Enqueues updates to its own DOM as well as the DOM of its
* {@link TimeTooltip} child.
*
* @param {Object} seekBarRect
* The `ClientRect` for the {@link SeekBar} element.
*
* @param {number} seekBarPoint
* A number from 0 to 1, representing a horizontal reference point
* from the left edge of the {@link SeekBar}
*/
update(seekBarRect: any, seekBarPoint: number): void;
/**
* Create the DOM element for this class.
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
}
import Component from "../../component.js";
//# sourceMappingURL=mouse-time-display.d.ts.map

1
node_modules/video.js/dist/types/control-bar/progress-control/mouse-time-display.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"mouse-time-display.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/progress-control/mouse-time-display.js"],"names":[],"mappings":";AAQA;;;;;;;GAOG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBASzC;IAcD;;;;;;;;;;OAUG;IACH,uCAJW,MAAM,QAUhB;IA7BD;;;;;OAKG;IACH,YAHY,OAAO,CAOlB;CAoBF"}

40
node_modules/video.js/dist/types/control-bar/progress-control/play-progress-bar.d.ts generated vendored Normal file
View file

@ -0,0 +1,40 @@
export default PlayProgressBar;
/**
* Used by {@link SeekBar} to display media playback progress as part of the
* {@link ProgressControl}.
*
* @extends Component
*/
declare class PlayProgressBar extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The {@link Player} that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Enqueues updates to its own DOM as well as the DOM of its
* {@link TimeTooltip} child.
*
* @param {Object} seekBarRect
* The `ClientRect` for the {@link SeekBar} element.
*
* @param {number} seekBarPoint
* A number from 0 to 1, representing a horizontal reference point
* from the left edge of the {@link SeekBar}
*/
update(seekBarRect: any, seekBarPoint: number): void;
/**
* Create the the DOM element for this class.
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
}
import Component from "../../component.js";
//# sourceMappingURL=play-progress-bar.d.ts.map

1
node_modules/video.js/dist/types/control-bar/progress-control/play-progress-bar.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"play-progress-bar.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/progress-control/play-progress-bar.js"],"names":[],"mappings":";AASA;;;;;GAKG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBASzC;IAgBD;;;;;;;;;;OAUG;IACH,uCAJW,MAAM,QAgBhB;IArCD;;;;;OAKG;IACH,YAHY,OAAO,CASlB;CA0BF"}

101
node_modules/video.js/dist/types/control-bar/progress-control/progress-control.d.ts generated vendored Normal file
View file

@ -0,0 +1,101 @@
export default ProgressControl;
/**
* The Progress Control component contains the seek bar, load progress,
* and play progress.
*
* @extends Component
*/
declare class ProgressControl extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* When the mouse moves over the `ProgressControl`, the pointer position
* gets passed down to the `MouseTimeDisplay` component.
*
* @param {Event} event
* The `mousemove` event that caused this function to run.
*
* @listen mousemove
*/
handleMouseMove(event: Event): void;
throttledHandleMouseSeek: Function;
handleMouseUpHandler_: (e: any) => void;
handleMouseDownHandler_: (e: any) => void;
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
/**
* A throttled version of the {@link ProgressControl#handleMouseSeek} listener.
*
* @method ProgressControl#throttledHandleMouseSeek
* @param {Event} event
* The `mousemove` event that caused this function to run.
*
* @listen mousemove
* @listen touchmove
*/
/**
* Handle `mousemove` or `touchmove` events on the `ProgressControl`.
*
* @param {Event} event
* `mousedown` or `touchstart` event that triggered this function
*
* @listens mousemove
* @listens touchmove
*/
handleMouseSeek(event: Event): void;
/**
* Are controls are currently enabled for this progress control.
*
* @return {boolean}
* true if controls are enabled, false otherwise
*/
enabled(): boolean;
/**
* Disable all controls on the progress control and its children
*/
disable(): void;
enabled_: boolean;
/**
* Enable all controls on the progress control and its children
*/
enable(): void;
/**
* Cleanup listeners after the user finishes interacting with the progress controls
*/
removeListenersAddedOnMousedownAndTouchstart(): void;
/**
* Handle `mousedown` or `touchstart` events on the `ProgressControl`.
*
* @param {Event} event
* `mousedown` or `touchstart` event that triggered this function
*
* @listens mousedown
* @listens touchstart
*/
handleMouseDown(event: Event): void;
/**
* Handle `mouseup` or `touchend` events on the `ProgressControl`.
*
* @param {Event} event
* `mouseup` or `touchend` event that triggered this function.
*
* @listens touchend
* @listens mouseup
*/
handleMouseUp(event: Event): void;
}
import Component from "../../component.js";
//# sourceMappingURL=progress-control.d.ts.map

1
node_modules/video.js/dist/types/control-bar/progress-control/progress-control.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"progress-control.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/progress-control/progress-control.js"],"names":[],"mappings":";AAWA;;;;;GAKG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBAczC;IAcD;;;;;;;;OAQG;IACH,uBALW,KAAK,QAoCf;IA3DC,mCAAoG;IACpG,wCAAyD;IACzD,0CAA6D;IAK/D;;;;;OAKG;IACH,YAHY,OAAO,CAOlB;IA4CD;;;;;;;;;OASG;IAEH;;;;;;;;OAQG;IACH,uBANW,KAAK,QAYf;IAED;;;;;OAKG;IACH,WAHY,OAAO,CAKlB;IAED;;OAEG;IACH,gBA0BC;IAZC,kBAAqB;IAcvB;;OAEG;IACH,eAYC;IAED;;OAEG;IACH,qDAOC;IAED;;;;;;;;OAQG;IACH,uBANW,KAAK,QAkBf;IAED;;;;;;;;OAQG;IACH,qBANW,KAAK,QAcf;CACF"}

100
node_modules/video.js/dist/types/control-bar/progress-control/seek-bar.d.ts generated vendored Normal file
View file

@ -0,0 +1,100 @@
export default SeekBar;
/**
* Seek bar and container for the progress bars. Uses {@link PlayProgressBar}
* as its `bar`.
*
* @extends Slider
*/
declare class SeekBar extends Slider {
/**
* Sets the event handlers
*
* @private
*/
private setEventHandlers_;
/**
* This function updates the play progress bar and accessibility
* attributes to whatever is passed in.
*
* @param {Event} [event]
* The `timeupdate` or `ended` event that caused this to run.
*
* @listens Player#timeupdate
*
* @return {number}
* The current percent at a number from 0-1
*/
update(event?: Event): number;
updateInterval: number;
enableIntervalHandler_: (e: any) => void;
disableIntervalHandler_: (e: any) => void;
toggleVisibility_(e: any): void;
enableInterval_(): void;
disableInterval_(e: any): void;
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
percent_: any;
currentTime_: any;
duration_: any;
/**
* Prevent liveThreshold from causing seeks to seem like they
* are not happening from a user perspective.
*
* @param {number} ct
* current time to seek to
*/
userSeek_(ct: number): void;
/**
* Get the value of current time but allows for smooth scrubbing,
* when player can't keep up.
*
* @return {number}
* The current time value to display
*
* @private
*/
private getCurrentTime_;
/**
* Get the percentage of media played so far.
*
* @return {number}
* The percentage of media played so far (0 to 1).
*/
getPercent(): number;
videoWasPlaying: boolean;
/**
* Handle mouse move on seek bar
*
* @param {MouseEvent} event
* The `mousemove` event that caused this to run.
* @param {boolean} mouseDown this is a flag that should be set to true if `handleMouseMove` is called directly. It allows us to skip things that should not happen if coming from mouse down but should happen on regular mouse move handler. Defaults to false
*
* @listens mousemove
*/
handleMouseMove(event: MouseEvent, mouseDown?: boolean): void;
/**
* Move more quickly fast forward for keyboard-only users
*/
stepForward(): void;
/**
* Move more quickly rewind for keyboard-only users
*/
stepBack(): void;
/**
* Toggles the playback state of the player
* This gets called when enter or space is used on the seekbar
*
* @param {KeyboardEvent} event
* The `keydown` event that caused this function to be called
*
*/
handleAction(event: KeyboardEvent): void;
dispose(): void;
}
import Slider from "../../slider/slider.js";
//# sourceMappingURL=seek-bar.d.ts.map

1
node_modules/video.js/dist/types/control-bar/progress-control/seek-bar.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"seek-bar.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/progress-control/seek-bar.js"],"names":[],"mappings":";AAuBA;;;;;GAKG;AACH;IAgBE;;;;OAIG;IACH,0BAyBC;IAoDD;;;;;;;;;;;OAWG;IACH,eARW,KAAK,GAKJ,MAAM,CAkDjB;IA7HC,uBAA0B;IAE1B,yCAA4D;IAC5D,0CAA8D;IAahE,gCAaC;IAED,wBAMC;IAED,+BAWC;IAED;;;;;OAKG;IACH,YAHY,OAAO,CASlB;IAmCK,cAAuB;IAevB,kBAA+B;IAC/B,eAAyB;IAY/B;;;;;;OAMG;IACH,cAHW,MAAM,QAShB;IAED;;;;;;;;OAQG;IACH,wBAIC;IAED;;;;;OAKG;IACH,cAHY,MAAM,CAoBjB;IAkBC,yBAA6C;IAM/C;;;;;;;;OAQG;IACH,uBANW,UAAU,cAEV,OAAO,QAwDjB;IA0DD;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,iBAEC;IAED;;;;;;;OAOG;IACH,oBAJW,aAAa,QAUvB;IA6DD,gBAkBC;CACF"}

63
node_modules/video.js/dist/types/control-bar/progress-control/time-tooltip.d.ts generated vendored Normal file
View file

@ -0,0 +1,63 @@
export default TimeTooltip;
/**
* Time tooltips display a time above the progress bar.
*
* @extends Component
*/
declare class TimeTooltip extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The {@link Player} that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Updates the position of the time tooltip relative to the `SeekBar`.
*
* @param {Object} seekBarRect
* The `ClientRect` for the {@link SeekBar} element.
*
* @param {number} seekBarPoint
* A number from 0 to 1, representing a horizontal reference point
* from the left edge of the {@link SeekBar}
*/
update(seekBarRect: any, seekBarPoint: number, content: any): void;
/**
* Create the time tooltip DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
/**
* Write the time to the tooltip DOM element.
*
* @param {string} content
* The formatted time for the tooltip.
*/
write(content: string): void;
/**
* Updates the position of the time tooltip relative to the `SeekBar`.
*
* @param {Object} seekBarRect
* The `ClientRect` for the {@link SeekBar} element.
*
* @param {number} seekBarPoint
* A number from 0 to 1, representing a horizontal reference point
* from the left edge of the {@link SeekBar}
*
* @param {number} time
* The time to update the tooltip to, not used during live playback
*
* @param {Function} cb
* A function that will be called during the request animation frame
* for tooltips that need to do additional animations from the default
*/
updateTime(seekBarRect: any, seekBarPoint: number, time: number, cb: Function): void;
}
import Component from "../../component";
//# sourceMappingURL=time-tooltip.d.ts.map

1
node_modules/video.js/dist/types/control-bar/progress-control/time-tooltip.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"time-tooltip.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/progress-control/time-tooltip.js"],"names":[],"mappings":";AAQA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBASzC;IAgBD;;;;;;;;;OASG;IACH,uCAJW,MAAM,sBAyDhB;IA7ED;;;;;OAKG;IACH,YAHY,OAAO,CASlB;IAmED;;;;;OAKG;IACH,eAHW,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,2CAXW,MAAM,QAIN,MAAM,sBA0BhB;CACF"}

51
node_modules/video.js/dist/types/control-bar/seek-to-live.d.ts generated vendored Normal file
View file

@ -0,0 +1,51 @@
export default SeekToLive;
/**
* Displays the live indicator when duration is Infinity.
*
* @extends Component
*/
declare class SeekToLive extends Component {
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: any, options?: any);
updateLiveEdgeStatusHandler_: (e: any) => void;
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
textEl_: Element;
/**
* Update the state of this button if we are at the live edge
* or not
*/
updateLiveEdgeStatus(): void;
/**
* On click bring us as near to the live point as possible.
* This requires that we wait for the next `live-seekable-change`
* event which will happen every segment length seconds.
*/
handleClick(): void;
/**
* Dispose of the element and stop tracking
*/
dispose(): void;
/**
* The text that should display over the `SeekToLive`s control. Added for localization.
*
* @type {string}
* @protected
*/
protected controlText_: string;
}
import Component from "../component";
//# sourceMappingURL=seek-to-live.d.ts.map

1
node_modules/video.js/dist/types/control-bar/seek-to-live.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"seek-to-live.d.ts","sourceRoot":"","sources":["../../../src/js/control-bar/seek-to-live.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,wCASC;IAHG,+CAAuE;IAK3E;;;;;OAKG;IACH,YAHY,OAAO,CAiBlB;IATC,iBAKE;IAMJ;;;OAGG;IACH,6BAWC;IAED;;;;OAIG;IACH,oBAEC;IAED;;OAEG;IACH,gBAOC;IAEH;;;;;OAKG;IACH,wBAHU,MAAM,CAGiB;CAPhC"}

29
node_modules/video.js/dist/types/control-bar/skip-buttons/skip-backward.d.ts generated vendored Normal file
View file

@ -0,0 +1,29 @@
export default SkipBackward;
/**
* Button to skip backward a configurable amount of time
* through a video. Renders in the control bar.
*
* * e.g. options: {controlBar: {skipButtons: backward: 5}}
*
* @extends Button
*/
declare class SkipBackward extends Button {
constructor(player: any, options: any);
validOptions: number[];
skipTime: any;
getSkipBackwardTime(): any;
/**
* On click, skips backward in the video by a configurable amount of seconds.
* If the current time in the video is less than the configured 'skip backward' time,
* skips to beginning of video or seekable range.
*
* Handle a click on a `SkipBackward` button
*
* @param {EventTarget~Event} event
* The `click` event that caused this function
* to be called
*/
handleClick(event: any): void;
}
import Button from "../../button";
//# sourceMappingURL=skip-backward.d.ts.map

1
node_modules/video.js/dist/types/control-bar/skip-buttons/skip-backward.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"skip-backward.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/skip-buttons/skip-backward.js"],"names":[],"mappings":";AAGA;;;;;;;GAOG;AACH;IACE,uCAYC;IATC,uBAA+B;IAC/B,cAA0C;IAU5C,2BAIC;IAMD;;;;;;;;;;OAUG;IACH,8BAcC;CAQF"}

29
node_modules/video.js/dist/types/control-bar/skip-buttons/skip-forward.d.ts generated vendored Normal file
View file

@ -0,0 +1,29 @@
export default SkipForward;
/**
* Button to skip forward a configurable amount of time
* through a video. Renders in the control bar.
*
* e.g. options: {controlBar: {skipButtons: forward: 5}}
*
* @extends Button
*/
declare class SkipForward extends Button {
constructor(player: any, options: any);
validOptions: number[];
skipTime: any;
getSkipForwardTime(): any;
/**
* On click, skips forward in the duration/seekable range by a configurable amount of seconds.
* If the time left in the duration/seekable range is less than the configured 'skip forward' time,
* skips to end of duration/seekable range.
*
* Handle a click on a `SkipForward` button
*
* @param {EventTarget~Event} event
* The `click` event that caused this function
* to be called
*/
handleClick(event: any): void;
}
import Button from "../../button";
//# sourceMappingURL=skip-forward.d.ts.map

1
node_modules/video.js/dist/types/control-bar/skip-buttons/skip-forward.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"skip-forward.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/skip-buttons/skip-forward.js"],"names":[],"mappings":";AAGA;;;;;;;GAOG;AACH;IACE,uCAYC;IATC,uBAA+B;IAC/B,cAAyC;IAU3C,0BAIC;IAMD;;;;;;;;;;OAUG;IACH,8BAaC;CAQF"}

17
node_modules/video.js/dist/types/control-bar/spacer-controls/custom-control-spacer.d.ts generated vendored Normal file
View file

@ -0,0 +1,17 @@
export default CustomControlSpacer;
/**
* Spacer specifically meant to be used as an insertion point for new plugins, etc.
*
* @extends Spacer
*/
declare class CustomControlSpacer extends Spacer {
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
}
import Spacer from "./spacer.js";
//# sourceMappingURL=custom-control-spacer.d.ts.map

1
node_modules/video.js/dist/types/control-bar/spacer-controls/custom-control-spacer.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"custom-control-spacer.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/spacer-controls/custom-control-spacer.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH;IAYE;;;;;OAKG;IACH,YAHY,OAAO,CAUlB;CACF"}

18
node_modules/video.js/dist/types/control-bar/spacer-controls/spacer.d.ts generated vendored Normal file
View file

@ -0,0 +1,18 @@
export default Spacer;
/**
* Just an empty spacer element that can be used as an append point for plugins, etc.
* Also can be used to create space between elements when necessary.
*
* @extends Component
*/
declare class Spacer extends Component {
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(tag?: string, props?: {}, attributes?: {}): Element;
}
import Component from "../../component.js";
//# sourceMappingURL=spacer.d.ts.map

1
node_modules/video.js/dist/types/control-bar/spacer-controls/spacer.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"spacer.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/spacer-controls/spacer.js"],"names":[],"mappings":";AAKA;;;;;GAKG;AACH;IAYE;;;;;OAKG;IACH,qDAHY,OAAO,CASlB;CACF"}

22
node_modules/video.js/dist/types/control-bar/text-track-controls/caption-settings-menu-item.d.ts generated vendored Normal file
View file

@ -0,0 +1,22 @@
export default CaptionSettingsMenuItem;
/**
* The menu item for caption track settings menu
*
* @extends TextTrackMenuItem
*/
declare class CaptionSettingsMenuItem extends TextTrackMenuItem {
/**
* This gets called when an `CaptionSettingsMenuItem` is "clicked". See
* {@link ClickableComponent} for more detailed information on what a click can be.
*
* @param {Event} [event]
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event?: Event): void;
}
import TextTrackMenuItem from "./text-track-menu-item.js";
//# sourceMappingURL=caption-settings-menu-item.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/caption-settings-menu-item.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"caption-settings-menu-item.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/caption-settings-menu-item.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH;IA+BE;;;;;;;;;;OAUG;IACH,oBAPW,KAAK,QASf;CAUF"}

53
node_modules/video.js/dist/types/control-bar/text-track-controls/captions-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,53 @@
export default CaptionsButton;
/**
* The button component for toggling and selecting captions
*
* @extends TextTrackButton
*/
declare class CaptionsButton extends TextTrackButton {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*
* @param {Function} [ready]
* The function to call when this component is ready.
*/
constructor(player: import('../../player').default, options?: any, ready?: Function);
/**
* Builds the default DOM `className`.
*
* @return {string}
* The DOM `className` for this object.
*/
buildCSSClass(): string;
buildWrapperCSSClass(): string;
/**
* Create caption menu items
*
* @return {CaptionSettingsMenuItem[]}
* The array of current menu items.
*/
createItems(): CaptionSettingsMenuItem[];
/**
* `kind` of TextTrack to look for to associate it with this menu.
*
* @type {string}
* @private
*/
private kind_;
/**
* The text that should display over the `CaptionsButton`s controls. Added for localization.
*
* @type {string}
* @protected
*/
protected controlText_: string;
}
import TextTrackButton from "./text-track-button.js";
import CaptionSettingsMenuItem from "./caption-settings-menu-item.js";
//# sourceMappingURL=captions-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/captions-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"captions-button.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/captions-button.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAEE;;;;;;;;;;;OAWG;IACH,oBATY,OAAO,cAAc,EAAE,OAAO,mCAWzC;IAED;;;;;OAKG;IACH,iBAHY,MAAM,CAKjB;IAED,+BAEC;IAED;;;;;OAKG;IACH,eAHY,uBAAuB,EAAE,CAcpC;IAIH;;;;;OAKG;IACH,cAA8B;IAE9B;;;;;OAKG;IACH,wBAHU,MAAM,CAGqB;CAhBpC"}

98
node_modules/video.js/dist/types/control-bar/text-track-controls/chapters-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,98 @@
export default ChaptersButton;
/**
* The button component for toggling and selecting chapters
* Chapters act much differently than other text tracks
* Cues are navigation vs. other tracks of alternative languages
*
* @extends TextTrackButton
*/
declare class ChaptersButton extends TextTrackButton {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*
* @param {Function} [ready]
* The function to call when this function is ready.
*/
constructor(player: import('../../player').default, options?: any, ready?: Function);
selectCurrentItem_: () => void;
/**
* Builds the default DOM `className`.
*
* @return {string}
* The DOM `className` for this object.
*/
buildCSSClass(): string;
buildWrapperCSSClass(): string;
/**
* Update the menu based on the current state of its items.
*
* @param {Event} [event]
* An event that triggered this function to run.
*
* @listens TextTrackList#addtrack
* @listens TextTrackList#removetrack
* @listens TextTrackList#change
*/
update(event?: Event): void;
/**
* Set the currently selected track for the chapters button.
*
* @param {TextTrack} track
* The new track to select. Nothing will change if this is the currently selected
* track.
*/
setTrack(track: TextTrack): void;
updateHandler_: any;
track_: any;
/**
* Find the track object that is currently in use by this ChaptersButton
*
* @return {TextTrack|undefined}
* The current track or undefined if none was found.
*/
findChaptersTrack(): TextTrack | undefined;
/**
* Get the caption for the ChaptersButton based on the track label. This will also
* use the current tracks localized kind as a fallback if a label does not exist.
*
* @return {string}
* The tracks current label or the localized track kind.
*/
getMenuCaption(): string;
/**
* Create menu from chapter track
*
* @return { import('../../menu/menu').default }
* New menu for the chapter buttons
*/
createMenu(): import('../../menu/menu').default;
/**
* Create a menu item for each text track
*
* @return { import('./text-track-menu-item').default[] }
* Array of menu items
*/
createItems(): import('./text-track-menu-item').default[];
/**
* `kind` of TextTrack to look for to associate it with this menu.
*
* @type {string}
* @private
*/
private kind_;
/**
* The text that should display over the `ChaptersButton`s controls. Added for localization.
*
* @type {string}
* @protected
*/
protected controlText_: string;
}
import TextTrackButton from "./text-track-button.js";
//# sourceMappingURL=chapters-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/chapters-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"chapters-button.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/chapters-button.js"],"names":[],"mappings":";AAQA;;;;;;GAMG;AACH;IAEE;;;;;;;;;;;OAWG;IACH,oBATY,OAAO,cAAc,EAAE,OAAO,mCAiBzC;IALC,+BAIC;IAGH;;;;;OAKG;IACH,iBAHY,MAAM,CAKjB;IAED,+BAEC;IAED;;;;;;;;;OASG;IACH,eAPW,KAAK,QAqBf;IAED;;;;;;OAMG;IACH,gBAJW,SAAS,QAwCnB;IA9BG,oBAA4C;IAa5C,YAAkB;IAmBtB;;;;;OAKG;IACH,qBAHY,SAAS,GAAC,SAAS,CAc9B;IAED;;;;;;OAMG;IACH,kBAHY,MAAM,CAQjB;IAED;;;;;OAKG;IACH,cAHa,OAAO,iBAAiB,EAAE,OAAO,CAM7C;IAED;;;;;OAKG;IACH,eAHc,OAAO,wBAAwB,EAAE,OAAO,EAAE,CAwBvD;IAIH;;;;;OAKG;IACH,cAA8B;IAE9B;;;;;OAKG;IACH,wBAHU,MAAM,CAGqB;CAhBpC"}

24
node_modules/video.js/dist/types/control-bar/text-track-controls/chapters-track-menu-item.d.ts generated vendored Normal file
View file

@ -0,0 +1,24 @@
export default ChaptersTrackMenuItem;
/**
* The chapter track menu item
*
* @extends MenuItem
*/
declare class ChaptersTrackMenuItem extends MenuItem {
track: any;
cue: any;
/**
* This gets called when an `ChaptersTrackMenuItem` is "clicked". See
* {@link ClickableComponent} for more detailed information on what a click can be.
*
* @param {Event} [event]
* The `keydown`, `tap`, or `click` event that caused this function to be
* called.
*
* @listens tap
* @listens click
*/
handleClick(event?: Event): void;
}
import MenuItem from "../../menu/menu-item.js";
//# sourceMappingURL=chapters-track-menu-item.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/chapters-track-menu-item.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"chapters-track-menu-item.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/chapters-track-menu-item.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH;IAuBI,WAAkB;IAClB,SAAc;IAGhB;;;;;;;;;;OAUG;IACH,oBAPW,KAAK,QAUf;CAEF"}

54
node_modules/video.js/dist/types/control-bar/text-track-controls/descriptions-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,54 @@
export default DescriptionsButton;
/**
* The button component for toggling and selecting descriptions
*
* @extends TextTrackButton
*/
declare class DescriptionsButton extends TextTrackButton {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*
* @param {Function} [ready]
* The function to call when this component is ready.
*/
constructor(player: import('../../player').default, options?: any, ready?: Function);
/**
* Handle text track change
*
* @param {Event} event
* The event that caused this function to run
*
* @listens TextTrackList#change
*/
handleTracksChange(event: Event): void;
/**
* Builds the default DOM `className`.
*
* @return {string}
* The DOM `className` for this object.
*/
buildCSSClass(): string;
buildWrapperCSSClass(): string;
/**
* `kind` of TextTrack to look for to associate it with this menu.
*
* @type {string}
* @private
*/
private kind_;
/**
* The text that should display over the `DescriptionsButton`s controls. Added for localization.
*
* @type {string}
* @protected
*/
protected controlText_: string;
}
import TextTrackButton from "./text-track-button.js";
//# sourceMappingURL=descriptions-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/descriptions-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"descriptions-button.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/descriptions-button.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAEE;;;;;;;;;;;OAWG;IACH,oBATY,OAAO,cAAc,EAAE,OAAO,mCAmBzC;IAED;;;;;;;OAOG;IACH,0BALW,KAAK,QAyBf;IAED;;;;;OAKG;IACH,iBAHY,MAAM,CAKjB;IAED,+BAEC;IAGH;;;;;OAKG;IACH,cAAkC;IAElC;;;;;OAKG;IACH,wBAHU,MAAM,CAGyB;CAhBxC"}

10
node_modules/video.js/dist/types/control-bar/text-track-controls/off-text-track-menu-item.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
export default OffTextTrackMenuItem;
/**
* A special menu item for turning of a specific type of text track
*
* @extends TextTrackMenuItem
*/
declare class OffTextTrackMenuItem extends TextTrackMenuItem {
}
import TextTrackMenuItem from "./text-track-menu-item.js";
//# sourceMappingURL=off-text-track-menu-item.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/off-text-track-menu-item.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"off-text-track-menu-item.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/off-text-track-menu-item.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH;CAkGC"}

35
node_modules/video.js/dist/types/control-bar/text-track-controls/subs-caps-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,35 @@
export default SubsCapsButton;
/**
* The button component for toggling and selecting captions and/or subtitles
*
* @extends TextTrackButton
*/
declare class SubsCapsButton extends TextTrackButton {
label_: string;
/**
* Builds the default DOM `className`.
*
* @return {string}
* The DOM `className` for this object.
*/
buildCSSClass(): string;
buildWrapperCSSClass(): string;
/**
* Create caption/subtitles menu items
*
* @return {CaptionSettingsMenuItem[]}
* The array of current menu items.
*/
createItems(): CaptionSettingsMenuItem[];
/**
* The text that should display over the `SubsCapsButton`s controls.
*
*
* @type {string}
* @protected
*/
protected controlText_: string;
}
import TextTrackButton from "./text-track-button.js";
import CaptionSettingsMenuItem from "./caption-settings-menu-item.js";
//# sourceMappingURL=subs-caps-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/subs-caps-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"subs-caps-button.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/subs-caps-button.js"],"names":[],"mappings":";AASA;;;;GAIG;AACH;IAmBI,eAAyB;IAO3B;;;;;OAKG;IACH,iBAHY,MAAM,CAKjB;IAED,+BAEC;IAED;;;;;OAKG;IACH,eAHY,uBAAuB,EAAE,CAepC;IAYH;;;;;;OAMG;IACH,wBAHU,MAAM,CAGqB;CAjBpC"}

12
node_modules/video.js/dist/types/control-bar/text-track-controls/subs-caps-menu-item.d.ts generated vendored Normal file
View file

@ -0,0 +1,12 @@
export default SubsCapsMenuItem;
/**
* SubsCapsMenuItem has an [cc] icon to distinguish captions from subtitles
* in the SubsCapsMenu.
*
* @extends TextTrackMenuItem
*/
declare class SubsCapsMenuItem extends TextTrackMenuItem {
createEl(type: any, props: any, attrs: any): Element;
}
import TextTrackMenuItem from "./text-track-menu-item.js";
//# sourceMappingURL=subs-caps-menu-item.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/subs-caps-menu-item.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"subs-caps-menu-item.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/subs-caps-menu-item.js"],"names":[],"mappings":";AAOA;;;;;GAKG;AACH;IAEE,qDAmBC;CACF"}

45
node_modules/video.js/dist/types/control-bar/text-track-controls/subtitles-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,45 @@
export default SubtitlesButton;
/**
* The button component for toggling and selecting subtitles
*
* @extends TextTrackButton
*/
declare class SubtitlesButton extends TextTrackButton {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*
* @param {Function} [ready]
* The function to call when this component is ready.
*/
constructor(player: import('../../player').default, options?: any, ready?: Function);
/**
* Builds the default DOM `className`.
*
* @return {string}
* The DOM `className` for this object.
*/
buildCSSClass(): string;
buildWrapperCSSClass(): string;
/**
* `kind` of TextTrack to look for to associate it with this menu.
*
* @type {string}
* @private
*/
private kind_;
/**
* The text that should display over the `SubtitlesButton`s controls. Added for localization.
*
* @type {string}
* @protected
*/
protected controlText_: string;
}
import TextTrackButton from "./text-track-button.js";
//# sourceMappingURL=subtitles-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/subtitles-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"subtitles-button.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/subtitles-button.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH;IAEE;;;;;;;;;;;OAWG;IACH,oBATY,OAAO,cAAc,EAAE,OAAO,mCAWzC;IAED;;;;;OAKG;IACH,iBAHY,MAAM,CAKjB;IAED,+BAEC;IAGH;;;;;OAKG;IACH,cAA+B;IAE/B;;;;;OAKG;IACH,wBAHU,MAAM,CAGsB;CAhBrC"}

31
node_modules/video.js/dist/types/control-bar/text-track-controls/text-track-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,31 @@
export default TextTrackButton;
/**
* The base class for buttons that toggle specific text track types (e.g. subtitles)
*
* @extends MenuButton
*/
declare class TextTrackButton {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options={}]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Create a menu item for each text track
*
* @param {TextTrackMenuItem[]} [items=[]]
* Existing array of items to use during creation
*
* @return {TextTrackMenuItem[]}
* Array of menu items that were created
*/
createItems(items?: TextTrackMenuItem[], TrackMenuItem?: typeof TextTrackMenuItem): TextTrackMenuItem[];
kinds_: any[];
}
import TextTrackMenuItem from "./text-track-menu-item.js";
//# sourceMappingURL=text-track-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/text-track-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"text-track-button.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/text-track-button.js"],"names":[],"mappings":";AAQA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBAUzC;IAED;;;;;;;;OAQG;IACH,oBANW,iBAAiB,EAAE,6CAGlB,iBAAiB,EAAE,CAiD9B;IAzBG,cAA0B;CA2B/B"}

22
node_modules/video.js/dist/types/control-bar/text-track-controls/text-track-menu-item.d.ts generated vendored Normal file
View file

@ -0,0 +1,22 @@
export default TextTrackMenuItem;
/**
* The specific menu item type for selecting a language within a text track kind
*
* @extends MenuItem
*/
declare class TextTrackMenuItem extends MenuItem {
track: any;
kinds: any;
/**
* Handle text track list change
*
* @param {Event} event
* The `change` event that caused this function to be called.
*
* @listens TextTrackList#change
*/
handleTracksChange(event: Event): void;
handleSelectedLanguageChange(event: any): void;
}
import MenuItem from "../../menu/menu-item.js";
//# sourceMappingURL=text-track-menu-item.d.ts.map

1
node_modules/video.js/dist/types/control-bar/text-track-controls/text-track-menu-item.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"text-track-menu-item.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/text-track-controls/text-track-menu-item.js"],"names":[],"mappings":";AAQA;;;;GAIG;AACH;IAqBI,WAAkB;IAGlB,WAAiF;IA+FnF;;;;;;;OAOG;IACH,0BALW,KAAK,QAaf;IAED,+CAiBC;CASF"}

35
node_modules/video.js/dist/types/control-bar/time-controls/current-time-display.d.ts generated vendored Normal file
View file

@ -0,0 +1,35 @@
export default CurrentTimeDisplay;
/**
* Displays the current time
*
* @extends Component
*/
declare class CurrentTimeDisplay extends Component {
/**
* Update current time display
*
* @param {Event} [event]
* The `timeupdate` event that caused this function to run.
*
* @listens Player#timeupdate
*/
updateContent(event?: Event): void;
/**
* The text that is added to the `CurrentTimeDisplay` for screen reader users.
*
* @type {string}
* @private
*/
private labelText_;
/**
* The text that should display over the `CurrentTimeDisplay`s controls. Added to for localization.
*
* @type {string}
* @protected
*
* @deprecated in v7; controlText_ is not used in non-active display Components
*/
protected controlText_: string;
}
import Component from "../../component.js";
//# sourceMappingURL=current-time-display.d.ts.map

1
node_modules/video.js/dist/types/control-bar/time-controls/current-time-display.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"current-time-display.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/time-controls/current-time-display.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH;IAYE;;;;;;;OAOG;IACH,sBALW,KAAK,QAgBf;IAGH;;;;;OAKG;IACH,mBAAuC;IAEvC;;;;;;;OAOG;IACH,wBALU,MAAM,CAKyB;CAlBxC"}

48
node_modules/video.js/dist/types/control-bar/time-controls/duration-display.d.ts generated vendored Normal file
View file

@ -0,0 +1,48 @@
export default DurationDisplay;
/**
* Displays the duration
*
* @extends Component
*/
declare class DurationDisplay extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Update duration time display.
*
* @param {Event} [event]
* The `durationchange`, `timeupdate`, or `loadedmetadata` event that caused
* this function to be called.
*
* @listens Player#durationchange
* @listens Player#timeupdate
* @listens Player#loadedmetadata
*/
updateContent(event?: Event): void;
/**
* The text that is added to the `DurationDisplay` for screen reader users.
*
* @type {string}
* @private
*/
private labelText_;
/**
* The text that should display over the `DurationDisplay`s controls. Added to for localization.
*
* @type {string}
* @protected
*
* @deprecated in v7; controlText_ is not used in non-active display Components
*/
protected controlText_: string;
}
import Component from "../../component.js";
//# sourceMappingURL=duration-display.d.ts.map

1
node_modules/video.js/dist/types/control-bar/time-controls/duration-display.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"duration-display.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/time-controls/duration-display.js"],"names":[],"mappings":";AAMA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBAyBzC;IAYD;;;;;;;;;;OAUG;IACH,sBARW,KAAK,QAYf;IAGH;;;;;OAKG;IACH,mBAAoC;IAEpC;;;;;;;OAOG;IACH,wBALU,MAAM,CAKsB;CAlBrC"}

53
node_modules/video.js/dist/types/control-bar/time-controls/remaining-time-display.d.ts generated vendored Normal file
View file

@ -0,0 +1,53 @@
export default RemainingTimeDisplay;
/**
* Displays the time left in the video
*
* @extends Component
*/
declare class RemainingTimeDisplay extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Create the `Component`'s DOM element with the "minus" character prepend to the time
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
/**
* Update remaining time display.
*
* @param {Event} [event]
* The `timeupdate` or `durationchange` event that caused this to run.
*
* @listens Player#timeupdate
* @listens Player#durationchange
*/
updateContent(event?: Event): void;
/**
* The text that is added to the `RemainingTimeDisplay` for screen reader users.
*
* @type {string}
* @private
*/
private labelText_;
/**
* The text that should display over the `RemainingTimeDisplay`s controls. Added to for localization.
*
* @type {string}
* @protected
*
* @deprecated in v7; controlText_ is not used in non-active display Components
*/
protected controlText_: string;
}
import Component from "../../component.js";
//# sourceMappingURL=remaining-time-display.d.ts.map

1
node_modules/video.js/dist/types/control-bar/time-controls/remaining-time-display.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"remaining-time-display.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/time-controls/remaining-time-display.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBASzC;IAYD;;;;;OAKG;IACH,YAHY,OAAO,CAUlB;IAED;;;;;;;;OAQG;IACH,sBANW,KAAK,QAwBf;IAGH;;;;;OAKG;IACH,mBAAyC;IAEzC;;;;;;;OAOG;IACH,wBALU,MAAM,CAK2B;CAlB1C"}

65
node_modules/video.js/dist/types/control-bar/time-controls/time-display.d.ts generated vendored Normal file
View file

@ -0,0 +1,65 @@
export default TimeDisplay;
/**
* Displays time information about the video
*
* @extends Component
*/
declare class TimeDisplay extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
contentEl_: Element;
dispose(): void;
textNode_: any;
/**
* Updates the time display text node with a new time
*
* @param {number} [time=0] the time to update to
*
* @private
*/
private updateTextNode_;
formattedTime_: any;
/**
* To be filled out in the child class, should update the displayed time
* in accordance with the fact that the current time has changed.
*
* @param {Event} [event]
* The `timeupdate` event that caused this to run.
*
* @listens Player#timeupdate
*/
updateContent(event?: Event): void;
/**
* The text that is added to the `TimeDisplay` for screen reader users.
*
* @type {string}
* @private
*/
private labelText_;
/**
* The text that should display over the `TimeDisplay`s controls. Added to for localization.
*
* @type {string}
* @protected
*
* @deprecated in v7; controlText_ is not used in non-active display Components
*/
protected controlText_: string;
}
import Component from "../../component.js";
//# sourceMappingURL=time-display.d.ts.map

1
node_modules/video.js/dist/types/control-bar/time-controls/time-display.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"time-display.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/time-controls/time-display.js"],"names":[],"mappings":";AASA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBAWzC;IAED;;;;;OAKG;IACH,YAHY,OAAO,CA6BlB;IAZC,oBAQE;IAMJ,gBAKC;IAHC,eAAqB;IAKvB;;;;;;OAMG;IACH,wBAkCC;IA3BC,oBAA0B;IA6B5B;;;;;;;;OAQG;IACH,sBALW,KAAK,QAKO;IAGzB;;;;;OAKG;IACH,mBAAgC;IAEhC;;;;;;;OAOG;IACH,wBALU,MAAM,CAKkB;CAlBjC"}

18
node_modules/video.js/dist/types/control-bar/time-controls/time-divider.d.ts generated vendored Normal file
View file

@ -0,0 +1,18 @@
export default TimeDivider;
/**
* The separator between the current time and duration.
* Can be hidden if it's not needed in the design.
*
* @extends Component
*/
declare class TimeDivider extends Component {
/**
* Create the component's DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
}
import Component from "../../component.js";
//# sourceMappingURL=time-divider.d.ts.map

1
node_modules/video.js/dist/types/control-bar/time-controls/time-divider.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"time-divider.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/time-controls/time-divider.js"],"names":[],"mappings":";AAKA;;;;;GAKG;AACH;IAEE;;;;;OAKG;IACH,YAHY,OAAO,CAsBlB;CAEF"}

20
node_modules/video.js/dist/types/control-bar/track-button.d.ts generated vendored Normal file
View file

@ -0,0 +1,20 @@
export default TrackButton;
/**
* The base class for buttons that toggle specific track types (e.g. subtitles).
*
* @extends MenuButton
*/
declare class TrackButton extends MenuButton {
/**
* Creates an instance of this class.
*
* @param { import('./player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: any, options?: any);
}
import MenuButton from "../menu/menu-button.js";
//# sourceMappingURL=track-button.d.ts.map

1
node_modules/video.js/dist/types/control-bar/track-button.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"track-button.d.ts","sourceRoot":"","sources":["../../../src/js/control-bar/track-button.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,wCAyBC;CAEF"}

15
node_modules/video.js/dist/types/control-bar/volume-control/check-mute-support.d.ts generated vendored Normal file
View file

@ -0,0 +1,15 @@
export default checkMuteSupport;
/**
* Check if muting volume is supported and if it isn't hide the mute toggle
* button.
*
* @param { import('../../component').default } self
* A reference to the mute toggle button
*
* @param { import('../../player').default } player
* A reference to the player
*
* @private
*/
declare function checkMuteSupport(self: import('../../component').default, player: import('../../player').default): void;
//# sourceMappingURL=check-mute-support.d.ts.map

1
node_modules/video.js/dist/types/control-bar/volume-control/check-mute-support.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"check-mute-support.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/volume-control/check-mute-support.js"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;AACH,wCARY,OAAO,iBAAiB,EAAE,OAAO,UAGjC,OAAO,cAAc,EAAE,OAAO,QAkBzC"}

15
node_modules/video.js/dist/types/control-bar/volume-control/check-volume-support.d.ts generated vendored Normal file
View file

@ -0,0 +1,15 @@
export default checkVolumeSupport;
/**
* Check if volume control is supported and if it isn't hide the
* `Component` that was passed using the `vjs-hidden` class.
*
* @param { import('../../component').default } self
* The component that should be hidden if volume is unsupported
*
* @param { import('../../player').default } player
* A reference to the player
*
* @private
*/
declare function checkVolumeSupport(self: import('../../component').default, player: import('../../player').default): void;
//# sourceMappingURL=check-volume-support.d.ts.map

1
node_modules/video.js/dist/types/control-bar/volume-control/check-volume-support.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"check-volume-support.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/volume-control/check-volume-support.js"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;AACH,0CARY,OAAO,iBAAiB,EAAE,OAAO,UAGjC,OAAO,cAAc,EAAE,OAAO,QAkBzC"}

47
node_modules/video.js/dist/types/control-bar/volume-control/mouse-volume-level-display.d.ts generated vendored Normal file
View file

@ -0,0 +1,47 @@
export default MouseVolumeLevelDisplay;
/**
* The {@link MouseVolumeLevelDisplay} component tracks mouse movement over the
* {@link VolumeControl}. It displays an indicator and a {@link VolumeLevelTooltip}
* indicating the volume level which is represented by a given point in the
* {@link VolumeBar}.
*
* @extends Component
*/
declare class MouseVolumeLevelDisplay extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The {@link Player} that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Enquires updates to its own DOM as well as the DOM of its
* {@link VolumeLevelTooltip} child.
*
* @param {Object} rangeBarRect
* The `ClientRect` for the {@link VolumeBar} element.
*
* @param {number} rangeBarPoint
* A number from 0 to 1, representing a horizontal/vertical reference point
* from the left edge of the {@link VolumeBar}
*
* @param {boolean} vertical
* Referees to the Volume control position
* in the control bar{@link VolumeControl}
*
*/
update(rangeBarRect: any, rangeBarPoint: number, vertical: boolean): void;
/**
* Create the DOM element for this class.
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
}
import Component from "../../component.js";
//# sourceMappingURL=mouse-volume-level-display.d.ts.map

1
node_modules/video.js/dist/types/control-bar/volume-control/mouse-volume-level-display.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"mouse-volume-level-display.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/volume-control/mouse-volume-level-display.js"],"names":[],"mappings":";AAQA;;;;;;;GAOG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBASzC;IAcD;;;;;;;;;;;;;;;OAeG;IACH,yCATW,MAAM,YAIN,OAAO,QAejB;IAtCD;;;;;OAKG;IACH,YAHY,OAAO,CAOlB;CA6BF"}

84
node_modules/video.js/dist/types/control-bar/volume-control/volume-bar.d.ts generated vendored Normal file
View file

@ -0,0 +1,84 @@
export default VolumeBar;
/**
* The bar that contains the volume level and can be clicked on to adjust the level
*
* @extends Slider
*/
declare class VolumeBar extends Slider {
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
/**
* Handle mouse down on volume bar
*
* @param {Event} event
* The `mousedown` event that caused this to run.
*
* @listens mousedown
*/
handleMouseDown(event: Event): void;
/**
* Handle movement events on the {@link VolumeMenuButton}.
*
* @param {Event} event
* The event that caused this function to run.
*
* @listens mousemove
*/
handleMouseMove(event: Event): void;
/**
* If the player is muted unmute it.
*/
checkMuted(): void;
/**
* Get percent of volume level
*
* @return {number}
* Volume level percent as a decimal number.
*/
getPercent(): number;
/**
* Increase volume level for keyboard users
*/
stepForward(): void;
/**
* Decrease volume level for keyboard users
*/
stepBack(): void;
/**
* Update ARIA accessibility attributes
*
* @param {Event} [event]
* The `volumechange` event that caused this function to run.
*
* @listens Player#volumechange
*/
updateARIAAttributes(event?: Event): void;
/**
* Returns the current value of the player volume as a percentage
*
* @private
*/
private volumeAsPercentage_;
/**
* When user starts dragging the VolumeBar, store the volume and listen for
* the end of the drag. When the drag ends, if the volume was set to zero,
* set lastVolume to the stored volume.
*
* @listens slideractive
* @private
*/
private updateLastVolume_;
/**
* Call the update event for this Slider when this event happens on the player.
*
* @type {string}
*/
playerEvent: string;
}
import Slider from "../../slider/slider.js";
//# sourceMappingURL=volume-bar.d.ts.map

1
node_modules/video.js/dist/types/control-bar/volume-control/volume-bar.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"volume-bar.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/volume-control/volume-bar.js"],"names":[],"mappings":";AAaA;;;;GAIG;AACH;IAkBE;;;;;OAKG;IACH,YAHY,OAAO,CAUlB;IAED;;;;;;;OAOG;IACH,uBALW,KAAK,QAWf;IAED;;;;;;;OAOG;IACH,uBALW,KAAK,QA6Bf;IAED;;OAEG;IACH,mBAIC;IAED;;;;;OAKG;IACH,cAHY,MAAM,CAQjB;IAED;;OAEG;IACH,oBAGC;IAED;;OAEG;IACH,iBAGC;IAED;;;;;;;OAOG;IACH,6BALW,KAAK,QAUf;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,0BAQC;IAsBH;;;;OAIG;IACH,aAFU,MAAM,CAEe;CAzB9B"}

59
node_modules/video.js/dist/types/control-bar/volume-control/volume-control.d.ts generated vendored Normal file
View file

@ -0,0 +1,59 @@
export default VolumeControl;
/**
* The component for controlling the volume level
*
* @extends Component
*/
declare class VolumeControl extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The `Player` that this class should be attached to.
*
* @param {Object} [options={}]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
throttledHandleMouseMove: Function;
handleMouseUpHandler_: (e: any) => void;
/**
* Create the `Component`'s DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
/**
* Handle `mousedown` or `touchstart` events on the `VolumeControl`.
*
* @param {Event} event
* `mousedown` or `touchstart` event that triggered this function
*
* @listens mousedown
* @listens touchstart
*/
handleMouseDown(event: Event): void;
/**
* Handle `mouseup` or `touchend` events on the `VolumeControl`.
*
* @param {Event} event
* `mouseup` or `touchend` event that triggered this function.
*
* @listens touchend
* @listens mouseup
*/
handleMouseUp(event: Event): void;
/**
* Handle `mousedown` or `touchstart` events on the `VolumeControl`.
*
* @param {Event} event
* `mousedown` or `touchstart` event that triggered this function
*
* @listens mousedown
* @listens touchstart
*/
handleMouseMove(event: Event): void;
}
import Component from "../../component.js";
//# sourceMappingURL=volume-control.d.ts.map

1
node_modules/video.js/dist/types/control-bar/volume-control/volume-control.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"volume-control.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/volume-control/volume-control.js"],"names":[],"mappings":";AAWA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBAyCzC;IApBC,mCAAoG;IACpG,wCAAyD;IAqB3D;;;;;OAKG;IACH,YAHY,OAAO,CAalB;IAED;;;;;;;;OAQG;IACH,uBANW,KAAK,QAaf;IAED;;;;;;;;OAQG;IACH,qBANW,KAAK,QAaf;IAED;;;;;;;;OAQG;IACH,uBANW,KAAK,QAQf;CACF"}

73
node_modules/video.js/dist/types/control-bar/volume-control/volume-level-tooltip.d.ts generated vendored Normal file
View file

@ -0,0 +1,73 @@
export default VolumeLevelTooltip;
/**
* Volume level tooltips display a volume above or side by side the volume bar.
*
* @extends Component
*/
declare class VolumeLevelTooltip extends Component {
/**
* Creates an instance of this class.
*
* @param { import('../../player').default } player
* The {@link Player} that this class should be attached to.
*
* @param {Object} [options]
* The key/value store of player options.
*/
constructor(player: import('../../player').default, options?: any);
/**
* Updates the position of the tooltip relative to the `VolumeBar` and
* its content text.
*
* @param {Object} rangeBarRect
* The `ClientRect` for the {@link VolumeBar} element.
*
* @param {number} rangeBarPoint
* A number from 0 to 1, representing a horizontal/vertical reference point
* from the left edge of the {@link VolumeBar}
*
* @param {boolean} vertical
* Referees to the Volume control position
* in the control bar{@link VolumeControl}
*
*/
update(rangeBarRect: any, rangeBarPoint: number, vertical: boolean, content: any): void;
/**
* Create the volume tooltip DOM element
*
* @return {Element}
* The element that was created.
*/
createEl(): Element;
/**
* Write the volume to the tooltip DOM element.
*
* @param {string} content
* The formatted volume for the tooltip.
*/
write(content: string): void;
/**
* Updates the position of the volume tooltip relative to the `VolumeBar`.
*
* @param {Object} rangeBarRect
* The `ClientRect` for the {@link VolumeBar} element.
*
* @param {number} rangeBarPoint
* A number from 0 to 1, representing a horizontal/vertical reference point
* from the left edge of the {@link VolumeBar}
*
* @param {boolean} vertical
* Referees to the Volume control position
* in the control bar{@link VolumeControl}
*
* @param {number} volume
* The volume level to update the tooltip to
*
* @param {Function} cb
* A function that will be called during the request animation frame
* for tooltips that need to do additional animations from the default
*/
updateVolume(rangeBarRect: any, rangeBarPoint: number, vertical: boolean, volume: number, cb: Function): void;
}
import Component from "../../component";
//# sourceMappingURL=volume-level-tooltip.d.ts.map

1
node_modules/video.js/dist/types/control-bar/volume-control/volume-level-tooltip.d.ts.map generated vendored Normal file
View file

@ -0,0 +1 @@
{"version":3,"file":"volume-level-tooltip.d.ts","sourceRoot":"","sources":["../../../../src/js/control-bar/volume-control/volume-level-tooltip.js"],"names":[],"mappings":";AAOA;;;;GAIG;AACH;IAEE;;;;;;;;OAQG;IACH,oBANY,OAAO,cAAc,EAAE,OAAO,iBASzC;IAgBD;;;;;;;;;;;;;;;OAeG;IACH,yCATW,MAAM,YAIN,OAAO,sBAmCjB;IA5DD;;;;;OAKG;IACH,YAHY,OAAO,CASlB;IAkDD;;;;;OAKG;IACH,eAHW,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,+CAfW,MAAM,YAIN,OAAO,UAIP,MAAM,sBAchB;CACF"}

Some files were not shown because too many files have changed in this diff Show more