code stringlengths 2 1.05M |
|---|
class CryptoUtil {
constructor() {
}
}
CryptoUtil.exportPublicKey = async function (key) {
return await window.crypto.subtle.exportKey('spki', key);
}
CryptoUtil.exportPrivateKey = async function (key) {
return await window.crypto.subtle.exportKey('pkcs8', key);
}
CryptoUtil.uint8ArrayToHex = function (data, sep) {
var a, h = '';
var ch = sep ? sep : '';
for (var i = 0, len = data.length; i !== len; ++i) {
a = data[i];
h += i > 0 ? ch : '';
h += a < 16 ? '0' : '';
h += a.toString(16);
}
return h;
}
CryptoUtil.hexToUint8Array = function (data) {
if (!data) {
return new Uint8Array();
}
var a = [];
for (var i = 0, len = data.length; i < len; i += 2) {
a.push(parseInt(data.substr(i, 2), 16));
}
return new Uint8Array(a);
// var a, h = '';
// var ch = sep ? sep : '';
// for (var i = 0, len = data.length; i !== len; ++i) {
// a = data[i];
// h += i > 0 ? ch : '';
// h += a < 16 ? '0' : '';
// h += a.toString(16);
// }
// return h;
}
CryptoUtil.stringToArrayBuffer = function (string) {
var encoder = new TextEncoder("utf-8");
return encoder.encode(string);
}
CryptoUtil.arrayToHexString = function (byteArray) {
var hexString = "";
var nextHexByte;
for (var i = 0; i < byteArray.byteLength; i++) {
nextHexByte = byteArray[i].toString(16); // Integer to base 16
if (nextHexByte.length < 2) {
nextHexByte = "0" + nextHexByte; // Otherwise 10 becomes just a instead of 0a
}
hexString += nextHexByte;
}
return hexString;
}
CryptoUtil.arrayBufferToHexString = function (arrayBuffer) {
var byteArray = new Uint8Array(arrayBuffer);
var hexString = "";
var nextHexByte;
for (var i = 0; i < byteArray.byteLength; i++) {
nextHexByte = byteArray[i].toString(16); // Integer to base 16
if (nextHexByte.length < 2) {
nextHexByte = "0" + nextHexByte; // Otherwise 10 becomes just a instead of 0a
}
hexString += nextHexByte;
}
return hexString;
}
CryptoUtil.convertUint8ArrayToText = function (data) {
var s = '';
for (var i = 0, len = data.length; i !== len; ++i) {
s += String.fromCharCode(data[i]);
}
return s;
}
CryptoUtil.convertUint8ArrayToBase64 = function (data) {
var s = CryptoUtil.convertUint8ArrayToText(data);
return window.btoa(s);
}
|
define(['bluebird', 'kb_lib/observed'], (Promise, Observed) => {
'use strict';
return class Menu {
constructor({config}) {
this.config = config;
this.state = new Observed();
this.state.setItem('menuItems', {
divider: {
type: 'divider'
}
});
// MAIN
this.state.setItem('menu', []);
// creates initial empty menus
this.setupMenus();
}
setupMenus() {
const hamburgerMenu = {
main: [],
developer: [],
help: []
};
this.state.setItem('menu.hamburger', hamburgerMenu);
const sidebarMenu = {
main: []
};
this.state.setItem('menu.sidebar', sidebarMenu);
}
// Adds a menu item definition
addMenuItem(id, menuDef) {
// Another quick hack - not all menu defs have the name - the name
// aka id is also the may key for plugin config menu items.
menuDef.id = id;
this.state.modifyItem('menuItems', (menuItems) => {
menuItems[id] = menuDef;
return menuItems;
});
}
/*
* Add a defined menu item to a menu, according to a menu entry definition.
*/
addToMenu(menuEntry, menuItemSpec) {
const menuItems = this.state.getItem('menuItems');
const menuItemDef = menuItems[menuItemSpec.id];
if (!menuItemDef) {
throw {
type: 'InvalidKey',
reason: 'MenuItemNotFound',
message: 'The menu item key provided, "' + menuItemSpec.id + '", is not registered'
};
}
let path;
if (menuItemDef.path) {
if (typeof menuItemDef.path === 'string') {
path = menuItemDef.path;
} else if (menuItemDef.path instanceof Array) {
path = menuItemDef.path.join('/');
} else {
throw new Error('Invalid path for menu item', menuItemDef);
}
}
const menuItem = {
// These are from the plugin's menu item definition
id: menuItemDef.id,
label: menuItemSpec.label || menuItemDef.label,
path: path,
icon: menuItemDef.icon,
uri: menuItemDef.uri,
newWindow: menuItemDef.newWindow,
beta: menuItemDef.beta || false,
// These are from the ui menu item spec
allow: menuItemSpec.allow || null,
allowRoles: menuItemSpec.allowRoles || null,
authRequired: menuItemSpec.auth ? true : false
};
const menu = menuEntry.menu;
const section = menuEntry.section;
const position = menuEntry.position || 'bottom';
this.state.modifyItem('menu.' + menu, (menus) => {
if (!menus[section]) {
console.error('ERROR: Menu section not defined', menuEntry, menu, section, menus);
throw new Error('Menu section not defined: ' + section);
}
if (position === 'top') {
menus[section].unshift(menuItem);
} else {
menus[section].push(menuItem);
}
return menus;
});
}
getCurrentMenu(menu) {
menu = menu || 'hamburger';
return this.state.getItem('menu.' + menu);
}
// Plugin interface
pluginHandler(newMenus) {
if (!newMenus) {
return;
}
return Promise.try(() => {
newMenus.forEach((menu) => {
// quick patch to the definition to add the id.
// TODO: maybe just store the whole menu from
// the plugin config?
menu.id = menu.name;
this.addMenuItem(menu.name, menu.definition || menu);
});
});
}
onChange(fun) {
this.state.listen('menu.hamburger', {
onSet: () => {
fun(this.getCurrentMenu('hamburger'));
}
});
}
// SERVICE API
start() {
// The hamburger menu.
Object.keys(this.config.menus).forEach((menu) => {
const menuDef = this.config.menus[menu];
// Skip a menu with no sections
if (!menuDef.sections) {
return;
}
Object.keys(menuDef.sections).forEach((section) => {
// Skip sections with no items.
if (!menuDef.sections[section]) {
return;
}
if (!menuDef.sections[section].items) {
return;
}
const items = menuDef.sections[section].items;
const disabled = menuDef.disabled || [];
items.forEach((menuItem) => {
if (menuItem.disabled) {
return;
}
if (disabled.indexOf(menuItem.id) >= 0) {
return;
}
this.addToMenu(
{
menu: menu,
section: section,
position: 'bottom',
allow: menuItem.allow
},
menuItem
);
});
});
});
}
stop() {}
};
});
|
module.exports = function(profileInfo, browser, asyncCallback) {
browser
.evaluate(function() {
var output = [];
// Utility functions
var get = function() {
var querySelector = (sel) => document.querySelector(sel);
var startIdx = 0;
if (typeof(arguments[0]) === 'object') {
querySelector = (sel) => arguments[0].querySelector(sel);
startIdx = 1;
}
for (var i = startIdx; i < arguments.length; i++) {
var query = arguments[i];
var targetNode = querySelector(query);
if (targetNode) {
return targetNode;
}
}
return null;
};
var getText = function() {
var targetNode = get.apply(this, arguments);
return (targetNode) ? targetNode.innerText : null;
};
var getImgSrc = function() {
var targetNode = get.apply(this, arguments);
return (targetNode) ? targetNode.src : null;
};
var getAll = function() {
var querySelectorAll = (sel) => document.querySelectorAll(sel);
var startIdx = 0;
if (typeof(arguments[0]) === 'object') {
querySelectorAll = (sel) => arguments[0].querySelectorAll(sel);
startIdx = 1;
}
for (var i = startIdx; i < arguments.length; i++) {
var query = arguments[i];
var targetNode = querySelectorAll(query);
if (targetNode && targetNode.length > 0) {
return targetNode;
}
}
return [];
};
// Add each certification node's information as a JSON
// object to output.
var certificationNodes = getAll(
'#background-certifications > div.entity-container > ' +
'div.entity > div.edit-action-area',
'#background-certifications > div'
);
certificationNodes.forEach(function(certNode) {
// Extract basic details about this certification entry.
var certInfo = {
title: getText(certNode,
'div > hgroup > h4 > a',
'div > header > h4 > div > span'),
imgUrl: getImgSrc(certNode,
'div > hgroup > h5.certification-logo > a ' +
'> span > strong > img',
'div > header > h5.section-logo > span > strong > img'),
certAuthority: getText(certNode,
'div > hgroup > h5 > span > strong > a',
'div > header > h5.sub-header-field.field > span'),
timePeriod: getText(certNode, 'div > div > span', 'div > span')
};
// Add JSON object with current certification entry's
// details to output.
output.push(certInfo);
});
// Return a list of JSON objects, where each object is
// essentially a LinkedIn education entry.
return output;
})
.then(function(certInfo) {
profileInfo.certifications = certInfo;
asyncCallback(null, profileInfo, browser);
}, function() {
profileInfo.certifications = [];
profileInfo.errors.push('Unable to access certifications section.');
asyncCallback(null, profileInfo, browser);
});
}; |
export default class Storage{
constructor(Adapter) {
this.adapter = Adapter;
}
get (key) {return this.adapter.get(key);}
set (key, value) {return this.adapter.set(key, value)}
entries () {return this.adapter.entries()}
keys () {return this.adapter.keys()}
remove (key) {return this.adapter.delete(key)}
has (key) {return this.adapter.has(key)}
} |
import { PropTypes } from 'react';
import momentPropTypes from 'react-moment-proptypes';
import OrientationShape from '../shapes/OrientationShape';
import anchorDirectionShape from '../shapes/AnchorDirectionShape';
export default {
id: PropTypes.string.isRequired,
placeholder: PropTypes.string,
date: momentPropTypes.momentObj,
focused: PropTypes.bool,
showClearDate: PropTypes.bool,
reopenPickerOnClearDates: PropTypes.bool,
keepOpenOnDateSelect: PropTypes.bool,
disabled: PropTypes.bool,
required: PropTypes.bool,
screenReaderInputMessage: PropTypes.string,
onDateChange: PropTypes.func,
onFocusChange: PropTypes.func,
isDayBlocked: PropTypes.func,
isOutsideRange: PropTypes.func,
enableOutsideDays: PropTypes.bool,
numberOfMonths: PropTypes.number,
orientation: OrientationShape,
initialVisibleMonth: PropTypes.func,
anchorDirection: anchorDirectionShape,
horizontalMargin: PropTypes.number,
navPrev: PropTypes.node,
navNext: PropTypes.node,
// portal options
withPortal: PropTypes.bool,
withFullScreenPortal: PropTypes.bool,
onPrevMonthClick: PropTypes.func,
onNextMonthClick: PropTypes.func,
// i18n
displayFormat: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
monthFormat: PropTypes.string,
phrases: PropTypes.shape({
closeDatePicker: PropTypes.node,
}),
};
|
//>>built
define(["dojo/_base/declare","dojo/_base/lang","dojo/has","dijit/form/Button","esri/dijit/editing/tools/ToolBase","esri/kernel"],function(c,d,e,a,b,f){return c([a,b],{declaredClass:"esri.dijit.editing.tools.ButtonToolBase",postCreate:function(){this.inherited(arguments);this._setShowLabelAttr&&this._setShowLabelAttr(!1)},destroy:function(){a.prototype.destroy.apply(this,arguments);b.prototype.destroy.apply(this,arguments)}})}); |
/*
Copyright (c) 2003-2014, CKSource - Frederico Knabben. All rights reserved.
For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.plugins.setLang( 'preview', 'sl', {
preview: 'Predogled'
} );
|
'use strict';
$(function () {
nodecg.listenFor('ssbmTopUpdate', updateText);
nodecg.listenFor('ssbmTopUpdateAnim', updatePanelsAnim);
nodecg.listenFor('ssbmTopMessage', showMessage);
function updatePanelsAnim(data) {
$('.panel').animate({top: "-100%"}, {duration: 1000, complete: function () { updateText(data); }});
$('.panel').animate({top: "0%"}, {duration: 1000});
}
function updateText(data) {
$('#panel1').text(data.panel1text);
$('#panel2').text(data.panel2text);
}
function showMessage(data) {
$('#panel1').animate({left: "-460px"}, {duration: 1000});
$('#panel2').animate({left: "1270px"}, {duration: 1000});
$('#message').animate({left: "0px", width: "1270px"}, {duration: 1000});
setTimeout(function() {
$('#message-text').text(data);
$('#message-text').fadeIn(500);
}, 500);
setTimeout(hideMessage, 10000);
}
function hideMessage(data) {
$('#message-text').fadeOut(500);
$('#message').animate({left: "645px", width: "0"}, {duration: 1000});
$('#panel1').animate({left: "165px"}, {duration: 1000});
$('#panel2').animate({left: "645px"}, {duration: 1000});
}
var bgInfo = nodecg.Replicant('bgInfo', 'ssbm-bg-helper');
bgInfo.on('change', function(newValue, oldValue) {
if(oldValue) {
if(oldValue.image && newValue.image) return;
else if (newValue.image) {
$('.panel').css('background', 'none');
$('.panel').css('background-image', 'url("img/top info.png")');
} else {
$('.panel').css('background-image', 'none');
$('.panel').css('background', '#' + newValue.color);
$('.panel').css('border-radius', newValue.corner + 'px')
}
}
});
}) |
// Note: This is the list of formats
// The rules that formats use are stored in data/rulesets.js
exports.Formats = [
// XY Singles
///////////////////////////////////////////////////////////////////
{
name: "Random Battle",
section: "ORAS Singles",
team: 'random',
ruleset: ['PotD', 'Pokemon', 'Sleep Clause Mod', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "Unrated Random Battle",
section: "ORAS Singles",
team: 'random',
challengeShow: false,
rated: false,
ruleset: ['PotD', 'Pokemon', 'Sleep Clause Mod', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "OU",
section: "ORAS Singles",
ruleset: ['Pokemon', 'Standard', 'Team Preview', 'Swagger Clause', 'Baton Pass Clause'],
banlist: ['Uber', 'Soul Dew', 'Gengarite', 'Kangaskhanite', 'Lucarionite', 'Mawilite', 'Salamencite']
},
{
name: "OU (no Mega)",
section: "ORAS Singles",
ruleset: ['OU'],
onBegin: function () {
for (var i = 0; i < this.p1.pokemon.length; i++) {
this.p1.pokemon[i].canMegaEvo = false;
}
for (var i = 0; i < this.p2.pokemon.length; i++) {
this.p2.pokemon[i].canMegaEvo = false;
}
}
},
{
name: "Ubers",
section: "ORAS Singles",
ruleset: ['Pokemon', 'Standard', 'Swagger Clause', 'Team Preview', 'Mega Rayquaza Clause'],
banlist: []
},
{
name: "UU",
section: "ORAS Singles",
ruleset: ['OU'],
banlist: ['OU', 'BL', 'Alakazite', 'Altarianite', 'Diancite', 'Heracronite', 'Galladite', 'Gardevoirite', 'Lopunnite', 'Medichamite',
'Metagrossite', 'Pinsirite', 'Drizzle', 'Drought', 'Shadow Tag'
]
},
{
name: "RU",
section: "ORAS Singles",
ruleset: ['UU'],
banlist: ['UU', 'BL2', 'Galladite', 'Houndoominite', 'Pidgeotite']
},
{
name: "NU",
section: "ORAS Singles",
ruleset: ['RU'],
banlist: ['RU', 'BL3', 'Cameruptite', 'Glalitite', 'Steelixite']
},
{
name: "LC",
section: "ORAS Singles",
maxLevel: 5,
ruleset: ['Pokemon', 'Standard', 'Team Preview', 'Little Cup'],
banlist: ['LC Uber', 'Gligar', 'Misdreavus', 'Scyther', 'Sneasel', 'Tangela', 'Dragon Rage', 'Sonic Boom', 'Swagger']
},
{
name: "Anything Goes",
section: "ORAS Singles",
ruleset: ['Pokemon', 'Endless Battle Clause', 'HP Percentage Mod', 'Cancel Mod', 'Team Preview'],
banlist: ['Unreleased', 'Illegal']
},
{
name: "CAP Naviathan Playtest",
section: "ORAS Singles",
ruleset: ['Pokemon', 'Standard', 'Baton Pass Clause', 'Swagger Clause', 'Team Preview'],
banlist: ['Allow CAP', 'Syclant', 'Revenankh', 'Pyroak', 'Fidgit', 'Stratagem', 'Arghonaut', 'Kitsunoh', 'Cyclohm', 'Colossoil', 'Krilowatt', 'Voodoom',
'Tomohawk', 'Necturna', 'Mollux', 'Aurumoth', 'Malaconda', 'Cawmodore', 'Volkraken', 'Plasmanta',
'Aegislash', 'Arceus', 'Blaziken', 'Darkrai', 'Deoxys', 'Deoxys-Attack', 'Deoxys-Defense', 'Deoxys-Speed', 'Dialga', 'Genesect',
'Giratina', 'Giratina-Origin', 'Greninja', 'Groudon', 'Ho-Oh', 'Kyogre', 'Kyurem-White', 'Lugia', 'Mewtwo', 'Palkia',
'Rayquaza', 'Reshiram', 'Shaymin-Sky', 'Xerneas', 'Yveltal', 'Zekrom',
'Gengarite', 'Kangaskhanite', 'Lucarionite', 'Mawilite', 'Salamencite', 'Soul Dew'
]
},
{
name: "Battle Spot Singles",
section: "ORAS Singles",
maxForcedLevel: 50,
ruleset: ['Pokemon', 'Standard GBU', 'Team Preview GBU'],
requirePentagon: true,
validateTeam: function (team, format) {
if (team.length < 3) return ['You must bring at least three Pok\u00e9mon.'];
},
onBegin: function () {
this.debug('cutting down to 3');
this.p1.pokemon = this.p1.pokemon.slice(0, 3);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 3);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "Battle Spot Special 10",
section: "ORAS Singles",
maxForcedLevel: 50,
ruleset: ['Battle Spot Singles'],
requirePentagon: true,
validateTeam: function (team, format) {
if (team.length < 3) return ['You must bring at least three Pok\u00e9mon.'];
},
onBegin: function () {
this.debug('cutting down to 3');
this.p1.pokemon = this.p1.pokemon.slice(0, 3);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 3);
this.p2.pokemonLeft = this.p2.pokemon.length;
},
onNegateImmunity: function (pokemon, type) {
if (type in this.data.TypeChart && this.runEvent('Immunity', pokemon, null, null, type)) return false;
},
onEffectiveness: function (typeMod, target, type, move) {
// The effectiveness of Freeze Dry on Water isn't reverted
if (move && move.id === 'freezedry' && type === 'Water') return;
if (move && !this.getImmunity(move, type)) return 1;
return -typeMod;
}
},
{
name: "Custom Game",
section: "ORAS Singles",
searchShow: false,
canUseRandomTeam: true,
debug: true,
maxLevel: 9999,
defaultLevel: 100,
// no restrictions, for serious (other than team preview)
ruleset: ['Team Preview', 'Cancel Mod']
},
// XY Doubles
///////////////////////////////////////////////////////////////////
{
name: "Random Doubles Battle",
section: "ORAS Doubles",
gameType: 'doubles',
team: 'randomDoubles',
ruleset: ['PotD', 'Pokemon', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "Doubles OU",
section: "ORAS Doubles",
gameType: 'doubles',
ruleset: ['Pokemon', 'Standard Doubles', 'Team Preview'],
banlist: ['Arceus', 'Dialga', 'Giratina', 'Giratina-Origin', 'Groudon', 'Ho-Oh', 'Kyogre', 'Kyurem-White', 'Lugia', 'Mewtwo',
'Palkia', 'Rayquaza', 'Reshiram', 'Xerneas', 'Yveltal', 'Zekrom', 'Salamencite', 'Soul Dew', 'Dark Void',
'Gravity ++ Grass Whistle', 'Gravity ++ Hypnosis', 'Gravity ++ Lovely Kiss', 'Gravity ++ Sing', 'Gravity ++ Sleep Powder', 'Gravity ++ Spore'
]
},
{
name: "Doubles Ubers",
section: "ORAS Doubles",
gameType: 'doubles',
ruleset: ['Pokemon', 'Species Clause', 'Moody Clause', 'OHKO Clause', 'Endless Battle Clause', 'HP Percentage Mod', 'Cancel Mod', 'Team Preview'],
banlist: ['Unreleased', 'Illegal', 'Dark Void']
},
{
name: "Doubles UU",
section: "ORAS Doubles",
gameType: 'doubles',
ruleset: ['Doubles OU'],
banlist: ['Aegislash', 'Amoonguss', 'Azumarill', 'Bisharp', 'Breloom', 'Camerupt', 'Chandelure', 'Charizard', 'Conkeldurr',
'Cresselia', 'Diancie', 'Dragonite', 'Excadrill', 'Ferrothorn', 'Garchomp', 'Gardevoir',
'Gengar', 'Greninja', 'Gyarados', 'Heatran', 'Hitmontop', 'Hydreigon', 'Kangaskhan', 'Keldeo',
'Kyurem-Black', 'Landorus', 'Landorus-Therian', 'Latios', 'Ludicolo', 'Mamoswine', 'Mawile', 'Metagross', 'Mew',
'Politoed', 'Rotom-Wash', 'Sableye', 'Scizor', 'Scrafty', 'Shaymin-Sky',
'Suicune', 'Sylveon', 'Talonflame', 'Terrakion', 'Thundurus', 'Togekiss',
'Tyranitar', 'Venusaur', 'Weavile', 'Whimsicott', 'Zapdos'
]
},
{
name: "Doubles NU",
section: "ORAS Doubles",
gameType: 'doubles',
searchShow: false,
ruleset: ['Doubles UU'],
banlist: ['Snorlax', 'Machamp', 'Lopunny', 'Galvantula', 'Mienshao', 'Infernape', 'Aromatisse',
'Clawitzer', 'Kyurem', 'Flygon', 'Lucario', 'Alakazam', 'Gastrodon', 'Bronzong', 'Chandelure',
'Dragalge', 'Mamoswine', 'Genesect', 'Arcanine', 'Volcarona', 'Aggron', 'Manectric', 'Salamence',
'Tornadus', 'Porygon2', 'Latias', 'Meowstic', 'Ninetales', 'Crobat', 'Blastoise', 'Darmanitan',
'Sceptile', 'Jirachi', 'Goodra', 'Deoxys-Attack', 'Milotic', 'Victini', 'Hariyama', 'Crawdaunt',
'Aerodactyl', 'Abomasnow', 'Krookodile', 'Cofagrigus', 'Druddigon', 'Escavalier', 'Dusclops',
'Slowbro', 'Slowking', 'Eelektross', 'Spinda', 'Cloyster', 'Raikou', 'Thundurus-Therian', 'Swampert',
'Nidoking', 'Aurorus', 'Granbull', 'Braviary'
]
},
{
name: "Battle Spot Doubles (VGC 2015)",
section: "ORAS Doubles",
gameType: 'doubles',
maxForcedLevel: 50,
ruleset: ['Pokemon', 'Standard GBU', 'Team Preview VGC'],
banlist: ['Tornadus + Defiant', 'Thundurus + Defiant', 'Landorus + Sheer Force'],
requirePentagon: true,
validateTeam: function (team, format) {
if (team.length < 4) return ['You must bring at least four Pok\u00e9mon.'];
},
onBegin: function () {
this.debug('cutting down to 4');
this.p1.pokemon = this.p1.pokemon.slice(0, 4);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 4);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "Doubles Hackmons Cup",
section: "ORAS Doubles",
gameType: 'doubles',
team: 'randomHC',
searchShow: false,
ruleset: ['Pokemon', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "Doubles Custom Game",
section: "ORAS Doubles",
gameType: 'doubles',
searchShow: false,
canUseRandomTeam: true,
maxLevel: 9999,
defaultLevel: 100,
debug: true,
// no restrictions, for serious (other than team preview)
ruleset: ['Team Preview', 'Cancel Mod']
},
// XY Triples
///////////////////////////////////////////////////////////////////
{
name: "Random Triples Battle",
section: "ORAS Triples",
gameType: 'triples',
team: 'randomDoubles',
ruleset: ['PotD', 'Pokemon', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "Smogon Triples",
section: "ORAS Triples",
gameType: 'triples',
ruleset: ['Pokemon', 'Species Clause', 'OHKO Clause', 'Moody Clause', 'Evasion Moves Clause', 'Endless Battle Clause', 'HP Percentage Mod', 'Cancel Mod', 'Team Preview'],
banlist: ['Illegal', 'Unreleased', 'Arceus', 'Dialga', 'Giratina', 'Giratina-Origin', 'Groudon', 'Ho-Oh', 'Kyogre', 'Kyurem-White',
'Lugia', 'Mewtwo', 'Palkia', 'Rayquaza', 'Reshiram', 'Xerneas', 'Yveltal', 'Zekrom',
'Soul Dew', 'Dark Void', 'Perish Song'
]
},
{
name: "Battle Spot Triples",
section: "ORAS Triples",
gameType: 'triples',
maxForcedLevel: 50,
ruleset: ['Pokemon', 'Standard GBU', 'Team Preview'],
requirePentagon: true,
validateTeam: function (team, format) {
if (team.length < 6) return ['You must have six Pokémon.'];
}
},
{
name: "Triples Hackmons Cup",
section: "ORAS Triples",
gameType: 'triples',
team: 'randomHC',
searchShow: false,
ruleset: ['Pokemon', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "Triples Custom Game",
section: "ORAS Triples",
gameType: 'triples',
searchShow: false,
canUseRandomTeam: true,
maxLevel: 9999,
defaultLevel: 100,
debug: true,
// no restrictions, for serious (other than team preview)
ruleset: ['Team Preview', 'Cancel Mod']
},
// Other Metagames
///////////////////////////////////////////////////////////////////
{
name: "Linked",
section: "OM of the Month",
column: 2,
mod: 'linked',
ruleset: ['OU'],
banlist: ["King's Rock", 'Razor Fang'],
validateTeam: function (team, format) {
var hasChoice = false;
for (var i = 0; i < team.length; i++) {
var item = toId(team[i].item);
if (!item) continue;
if (item === 'choiceband' || item === 'choicescarf' || item === 'choicespecs') {
if (hasChoice) return ["You are limited to one Choice item."];
hasChoice = true;
}
}
},
validateSet: function (set) {
if (set.moves && set.moves.length >= 2) {
var moves = [toId(set.moves[0]), toId(set.moves[1])];
if (moves.indexOf('craftyshield') >= 0 || moves.indexOf('detect') >= 0 || moves.indexOf('kingsshield') >= 0 || moves.indexOf('protect') >= 0 || moves.indexOf('spikyshield') >= 0) {
return ["Linking protect moves is banned."];
}
if (moves.indexOf('superfang') >= 0 && (moves.indexOf('nightshade') >= 0 || moves.indexOf('seismictoss') >= 0)) {
return ["Linking Super Fang with Night Shade or Seismic Toss is banned."];
}
if (this.getMove(moves[0]).flags['charge'] || this.getMove(moves[1]).flags['charge']) {
return ["Linking two turn moves is banned."];
}
}
}
},
{
name: "Averagemons",
section: "OM of the Month",
mod: 'averagemons',
ruleset: ['Pokemon', 'Standard', 'Evasion Abilities Clause', 'Baton Pass Clause', 'Swagger Clause', 'Team Preview'],
banlist: ['Sableye + Prankster', 'Shedinja', 'Smeargle', 'Venomoth',
'DeepSeaScale', 'DeepSeaTooth', 'Eviolite', 'Gengarite', 'Kangaskhanite', 'Light Ball', 'Mawilite', 'Medichamite', 'Soul Dew', 'Thick Club',
'Arena Trap', 'Huge Power', 'Pure Power', 'Shadow Tag', 'Chatter'
]
},
{
name: "[Seasonal] You are (not) prepared",
section: 'OM of the Month',
team: 'randomSeasonalMay2015',
mod: 'seasonal',
gameType: 'triples',
ruleset: ['HP Percentage Mod', 'Sleep Clause Mod', 'Cancel Mod'],
onBegin: function () {
this.add('raw|<b><font color="red">IMPORTANT!</font></b> All moves on this seasonal are custom. Use the command <b>/seasonaldata</b>, <b>/sdata</b>, or <b>/sdt</b> to know what they do.');
this.add('raw|More information can be found <a href="http://www.smogon.com/forums/threads/3491902/page-12#post-6202283">here</a>');
},
onModifyMove: function (move) {
// Shows legit name after use...
var legitNames = {
recover: "Cura", softboiled: "Curaga", reflect: "Wild Growth", acupressure: "Power Shield",
holdhands: "Rejuvenation", luckychant: "Fairy Ward", followme: "Taunt", meditate: "Sacrifice",
helpinghand: "Cooperation", spite: "Slow Down", aromaticmist: "Healing Touch", healbell: "Penance",
fakeout: "Stop", endure: "Last Stand", withdraw: "Barkskin", seismictoss: "Punishment",
flamethrower: "Flamestrike", fireblast: "Conflagration", thunderbolt: "Moonfire", thunder: "Starfire",
toxic: "Corruption", leechseed: "Soul Leech", icebeam: "Ice Lance", freezeshock: "Frostbite",
aircutter: "Hurricane", muddywater: "Storm", furyswipes: "Fury", scratch: "Garrote", slash: "Mutilate",
smog: "Poison Gas", protect: "Evasion", matblock: "Sacred Shield"
};
if (move.id in legitNames) {
move.name = legitNames[move.id];
}
},
onFaint: function (pokemon) {
var message = {
'Amy': 'French?', 'Princess Leia': 'Why, you stuck up, half-witted, scruffy-looking Nerf herder.',
'Scruffy': "Scruffy's gonna die the way he lived. [Turns page of Zero-G Juggs magazine.] Mmhm.",
'Yoda': 'Wrath leads to the dark side.', 'Bender': 'DEATH TO ALL HUMANS!', 'Gurren Lagann': 'Later, buddy.',
'Lagann': "Eh, I guess I'm no one.", 'Rei Ayanami': 'Man fears the darkness, and so he scrapes away at the edges of it with fire.',
'Slurms McKenzie': 'I will keep partying until the end.', 'C3PO': 'Oh, dear!',
'Hermes': 'I can still... limbo...', 'Professor Farnsworth': 'Bad news, everyone!', 'Kif': 'Sigh.',
'Jar Jar Binks': "Better dead here than deader in the Core. Ye gods, whatta meesa sayin'?",
'R2D2': '*beep boop*', 'Asuka Langley': 'Disgusting.', 'Chewy': 'GRARARWOOWRALWRL',
'Fry': 'Huh. Did everything just taste purple for a second?', 'Han Solo': 'I should have shot first...',
'Leela': 'Yeeee-hAW!', 'Luke Skywalker': 'I could not use the force...',
'Nibbler': 'I hereby place an order for one cheese pizza.',
'Shinji Ikari': 'It would be better if I never existed. I should just die too.', 'Zoidberg': 'Why not Zoidberg?',
'Anti-Spiral': 'If this is how it must be, protect the universe at all costs.', 'Gendo Ikari': 'Everything goes according to the plan.',
'Kaworu Nagisa': 'Dying of your own will. That is the one and only absolute freedom there is.',
'Jabba the Hut': 'Han, ma bukee.', 'Lilith': '...', 'Lrrr': "But I'm emperor of Omicron Persei 8!",
'Mommy': 'Stupid!', 'Bobba Fett': "I see now I've done terrible things.", 'Zapp Brannigan': "Oh, God, I'm pathetic. Sorry. Just go...",
'An angel': ',,,', 'Darth Vader': "I'm sorry, son.", 'Emperor Palpatine': 'What the hell is an "Aluminum Falcon"?',
'Fender': '*beeps*', 'Storm Trooper': 'But my aim is perfect!'
}[pokemon.name];
this.add('-message', pokemon.name + ': ' + message);
}
},
{
name: "CAP",
section: "Other Metagames",
column: 2,
searchShow: false,
ruleset: ['OU'],
banlist: ['Allow CAP']
},
{
name: "Battle Factory",
section: "Other Metagames",
team: 'randomFactory',
ruleset: ['Pokemon', 'Sleep Clause Mod', 'Team Preview', 'HP Percentage Mod', 'Cancel Mod', 'Mega Rayquaza Clause']
},
{
name: "Challenge Cup 1v1",
section: "Other Metagames",
team: 'randomCC',
ruleset: ['Pokemon', 'HP Percentage Mod', 'Cancel Mod', 'Team Preview 1v1'],
onBegin: function () {
this.debug('Cutting down to 1');
this.p1.pokemon = this.p1.pokemon.slice(0, 1);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 1);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "Balanced Hackmons",
section: "Other Metagames",
ruleset: ['Pokemon', 'Ability Clause', '-ate Clause', 'OHKO Clause', 'Evasion Moves Clause', 'Team Preview', 'HP Percentage Mod', 'Cancel Mod'],
banlist: ['Arena Trap', 'Huge Power', 'Parental Bond', 'Pure Power', 'Shadow Tag', 'Wonder Guard', 'Assist', 'Chatter']
},
{
name: "1v1",
section: 'Other Metagames',
ruleset: ['Pokemon', 'Moody Clause', 'OHKO Clause', 'Evasion Moves Clause', 'Swagger Clause', 'Endless Battle Clause', 'HP Percentage Mod', 'Cancel Mod', 'Team Preview 1v1'],
banlist: ['Illegal', 'Unreleased', 'Arceus', 'Blaziken', 'Darkrai', 'Deoxys', 'Deoxys-Attack', 'Dialga', 'Giratina', 'Giratina-Origin',
'Groudon', 'Ho-Oh', 'Kyogre', 'Kyurem-White', 'Lugia', 'Mewtwo', 'Palkia', 'Rayquaza', 'Reshiram', 'Shaymin-Sky',
'Xerneas', 'Yveltal', 'Zekrom', 'Focus Sash', 'Kangaskhanite', 'Soul Dew'
],
validateTeam: function (team, format) {
if (team.length > 3) return ['You may only bring up to three Pok\u00e9mon.'];
},
onBegin: function () {
this.p1.pokemon = this.p1.pokemon.slice(0, 1);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 1);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "Monotype",
section: "Other Metagames",
ruleset: ['Pokemon', 'Standard', 'Baton Pass Clause', 'Swagger Clause', 'Same Type Clause', 'Team Preview'],
banlist: ['Arceus', 'Blaziken', 'Darkrai', 'Deoxys', 'Deoxys-Attack', 'Dialga', 'Giratina', 'Giratina-Origin', 'Greninja', 'Groudon', 'Ho-Oh',
'Kyogre', 'Kyurem-White', 'Lugia', 'Mewtwo', 'Palkia', 'Rayquaza', 'Reshiram', 'Talonflame', 'Xerneas', 'Yveltal', 'Zekrom',
'Gengarite', 'Kangaskhanite', 'Lucarionite', 'Mawilite', 'Metagrossite', 'Salamencite', 'Shaymin-Sky', 'Slowbronite', 'Soul Dew'
]
},
{
name: "Tier Shift",
section: "Other Metagames",
mod: 'tiershift',
ruleset: ['OU'],
banlist: ['Shadow Tag', 'Chatter']
},
{
name: "PU",
section: "Other Metagames",
ruleset: ['NU'],
banlist: ['NU', 'BL4', 'Altarianite', 'Beedrillite', 'Lopunnite', 'Chatter', 'Shell Smash + Baton Pass']
},
{
name: "Inverse Battle",
section: "Other Metagames",
ruleset: ['Pokemon', 'Standard', 'Baton Pass Clause', 'Swagger Clause', 'Team Preview'],
banlist: ['Arceus', 'Blaziken', 'Darkrai', 'Deoxys', 'Deoxys-Attack', 'Deoxys-Defense', 'Deoxys-Speed', 'Diggersby', 'Giratina-Origin', 'Groudon',
'Ho-Oh', 'Kyogre', 'Kyurem-Black', 'Kyurem-White', 'Lugia', 'Mewtwo', 'Palkia', 'Rayquaza', 'Reshiram', 'Serperior',
'Shaymin-Sky', 'Snorlax', 'Xerneas', 'Yveltal', 'Zekrom', 'Gengarite', 'Kangaskhanite', 'Salamencite', 'Soul Dew'
],
onNegateImmunity: function (pokemon, type) {
if (type in this.data.TypeChart && this.runEvent('Immunity', pokemon, null, null, type)) return false;
},
onEffectiveness: function (typeMod, target, type, move) {
// The effectiveness of Freeze Dry on Water isn't reverted
if (move && move.id === 'freezedry' && type === 'Water') return;
if (move && !this.getImmunity(move, type)) return 1;
return -typeMod;
}
},
{
name: "Almost Any Ability",
section: "Other Metagames",
ruleset: ['Pokemon', 'Standard', 'Ability Clause', 'Baton Pass Clause', 'Swagger Clause', 'Team Preview'],
banlist: ['Ignore Illegal Abilities',
'Arceus', 'Archeops', 'Bisharp', 'Darkrai', 'Deoxys', 'Deoxys-Attack', 'Dialga', 'Giratina', 'Giratina-Origin', 'Groudon',
'Ho-Oh', 'Keldeo', 'Kyogre', 'Kyurem-Black', 'Kyurem-White', 'Lugia', 'Mamoswine', 'Mewtwo', 'Palkia', 'Rayquaza',
'Regigigas', 'Reshiram', 'Shedinja', 'Slaking', 'Smeargle', 'Terrakion', 'Weavile', 'Xerneas', 'Yveltal', 'Zekrom',
'Blazikenite', 'Gengarite', 'Kangaskhanite', 'Lucarionite', 'Mawilite', 'Salamencite', 'Soul Dew', 'Chatter'
],
validateSet: function (set) {
var bannedAbilities = {'Aerilate': 1, 'Arena Trap': 1, 'Contrary': 1, 'Fur Coat': 1, 'Huge Power': 1, 'Imposter': 1, 'Parental Bond': 1, 'Protean': 1, 'Pure Power': 1, 'Shadow Tag': 1, 'Simple':1, 'Speed Boost': 1, 'Wonder Guard': 1};
if (set.ability in bannedAbilities) {
var template = this.getTemplate(set.species || set.name);
var legalAbility = false;
for (var i in template.abilities) {
if (set.ability === template.abilities[i]) legalAbility = true;
}
if (!legalAbility) return ['The ability ' + set.ability + ' is banned on Pok\u00e9mon that do not naturally have it.'];
}
}
},
{
name: "STABmons",
section: "Other Metagames",
ruleset: ['Pokemon', 'Standard', 'Baton Pass Clause', 'Swagger Clause', 'Team Preview'],
banlist: ['Ignore STAB Moves',
'Arceus', 'Blaziken', 'Deoxys', 'Deoxys-Attack', 'Dialga', 'Diggersby', 'Genesect', 'Giratina', 'Giratina-Origin', 'Greninja',
'Groudon', 'Ho-Oh', 'Keldeo', 'Kyogre', 'Kyurem-Black', 'Kyurem-White', 'Landorus', 'Lugia', 'Mewtwo', 'Palkia',
'Porygon-Z', 'Rayquaza', 'Reshiram', 'Shaymin-Sky', 'Sylveon', 'Xerneas', 'Yveltal', 'Zekrom',
'Aerodactylite', 'Altarianite', 'Gengarite', 'Kangaskhanite', "King's Rock", 'Lopunnite', 'Lucarionite', 'Mawilite', 'Metagrossite', 'Razor Fang',
'Salamencite', 'Slowbronite', 'Soul Dew'
]
},
{
name: "LC UU",
section: "Other Metagames",
maxLevel: 5,
ruleset: ['LC'],
banlist: ['Abra', 'Aipom', 'Archen', 'Bunnelby', 'Carvanha', 'Chinchou', 'Corphish', 'Cottonee', 'Croagunk', 'Diglett',
'Drilbur', 'Dwebble', 'Elekid', 'Ferroseed', 'Fletchling', 'Foongus', 'Gastly', 'Gothita', 'Houndour', 'Larvesta',
'Magnemite', 'Mienfoo', 'Munchlax', 'Omanyte', 'Onix', 'Pawniard', 'Ponyta', 'Porygon', 'Pumpkaboo-Super', 'Scraggy',
'Shellder', 'Skrelp', 'Snivy', 'Snubbull', 'Spritzee', 'Staryu', 'Surskit', 'Timburr', 'Tirtouga', 'Vullaby',
'Vulpix', 'Zigzagoon', 'Shell Smash'
]
},
{
name: "Hackmons Cup",
section: "Other Metagames",
team: 'randomHC',
ruleset: ['Pokemon', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "2v2 Doubles",
section: "Other Metagames",
gameType: 'doubles',
searchShow: false,
ruleset: ['Doubles OU'],
banlist: ['Perish Song'],
validateTeam: function (team, format) {
if (team.length > 4) return ['You may only bring up to four Pok\u00e9mon.'];
},
onBegin: function () {
this.p1.pokemon = this.p1.pokemon.slice(0, 2);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 2);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "Hidden Type",
section: "Other Metagames",
searchShow: false,
mod: 'hiddentype',
ruleset: ['OU']
},
{
name: "OU Theorymon",
section: "Other Metagames",
mod: 'theorymon',
searchShow: false,
ruleset: ['OU']
},
{
name: "Gen-NEXT OU",
section: "Other Metagames",
mod: 'gennext',
searchShow: false,
ruleset: ['Pokemon', 'Standard NEXT', 'Team Preview'],
banlist: ['Uber']
},
{
name: "Monotype Random Battle",
section: "Other Metagames",
team: 'randomMonotype',
searchShow: false,
ruleset: ['Pokemon', 'Same Type Clause', 'Sleep Clause Mod', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "Hackmons Challenge Cup",
section: "Other Metagames",
team: 'randomHackmonsCC',
searchShow: false,
ruleset: ['HP Percentage Mod', 'Cancel Mod']
},
// Random Metagames
///////////////////////////////////////////////////////////////////
{
name: "Random Monotype",
section: "Random Metagames",
mod: 'randoms',
column: 3,
searchShow: true,
team: 'randomMonoType',
ruleset: ['PotD', 'Pokemon', 'Sleep Clause Mod', 'HP Percentage Mod']
},
{
name: "Random Inverse Battle",
section: "Random Metagames",
mod: 'inverse',
searchShow: false,
team: 'random',
ruleset: ['Pokemon', 'HP Percentage Mod', 'Sleep Clause Mod']
},
{
name: "Random Haxmons",
section: "Random Metagames",
searchShow: false,
team: 'random',
ruleset: ['Pokemon', 'HP Percentage Mod', 'Sleep Clause Mod', 'Freeze Clause'],
onModifyMovePriority: -100,
onModifyMove: function (move) {
if (move.accuracy !== true && move.accuracy < 100) move.accuracy = 0;
move.willCrit = true;
if (move.secondaries) {
for (var i = 0; i < move.secondaries.length; i++) {
move.secondaries[i].chance = 100;
}
}
}
},
{
name: "Random Sky Battle",
section: "Random Metagames",
mod: 'randoms',
searchShow: true,
team: 'randomSky',
ruleset: ['PotD', 'Pokemon', 'Sleep Clause Mod', 'HP Percentage Mod']
},
{
name: "Random Ubers",
section: "Random Metagames",
mod: 'randoms',
searchShow: true,
team: 'randomUber',
ruleset: ['PotD', 'Pokemon', 'Sleep Clause Mod', 'HP Percentage Mod']
},
{
name: "Random LC",
section: "Random Metagames",
mod: 'randoms',
searchShow: true,
team: 'randomLC',
ruleset: ['PotD', 'Pokemon', 'Sleep Clause Mod', 'HP Percentage Mod']
},
{
name: "Random CAP",
section: "Random Metagames",
mod: 'randoms',
searchShow: true,
team: 'randomCap',
ruleset: ['PotD', 'Pokemon', 'Sleep Clause Mod', 'HP Percentage Mod']
},
{
name: "Random MonoGen",
section: "Random Metagames",
mod: 'randoms',
searchShow: true,
team: 'randomMonoGen',
ruleset: ['PotD', 'Pokemon', 'Sleep Clause Mod', 'HP Percentage Mod']
},
{
name: "Challenge Cup 2-vs-2",
section: "Random Metagames",
mod: 'randoms',
gameType: 'doubles',
team: 'randomCC',
searchShow: true,
ruleset: ['Pokemon', 'Team Preview 2v2', 'HP Percentage Mod'],
onBegin: function () {
this.debug('Cutting down to 2');
this.p1.pokemon = this.p1.pokemon.slice(0, 2);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 2);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "Challenge Cup Metronome",
section: "Random Metagames",
mod: 'randoms',
searchShow: true,
team: 'randomMetro',
ruleset: ['Pokemon', 'HP Percentage Mod']
},
// Local Metagames
///////////////////////////////////////////////////////////////////
{
name: "1v1 (No Team Preview)",
section: 'Local Metagames',
column: 3,
ruleset: ['Pokemon', 'Standard', 'Swagger Clause'],
banlist: ['Arceus', 'Blaziken', 'Darkrai', 'Deoxys', 'Deoxys-Attack', 'Dialga', 'Giratina', 'Giratina-Origin', 'Groudon', 'Ho-Oh',
'Kyogre', 'Kyurem-White', 'Lugia', 'Mewtwo', 'Palkia', 'Rayquaza', 'Reshiram', 'Shaymin-Sky', 'Xerneas', 'Yveltal',
'Zekrom', 'Focus Sash', 'Kangaskhanite', 'Soul Dew'
],
onBegin: function () {
this.p1.pokemon = this.p1.pokemon.slice(0, 1);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 1);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "Mega Tier",
section: "Local Metagames",
mod: 'megatier',
ruleset: ['OU']
},
{
name: "Metagamiate",
section: "Local Metagames",
ruleset: ['Pokemon', 'Standard', 'Baton Pass Clause', 'Swagger Clause', 'Team Preview'],
banlist: ['Gengarite', 'Kangaskhanite', 'Lucarionite', 'Soul Dew',
'Arceus', 'Blaziken', 'Darkrai', 'Deoxys', 'Deoxys-Attack', 'Deoxys-Defense', 'Deoxys-Speed', 'Dialga', 'Genesect', 'Giratina',
'Giratina-Origin', 'Groudon', 'Kyogre', 'Ho-Oh', 'Kyurem-White', 'Lugia', 'Mewtwo', 'Palkia', 'Rayquaza', 'Reshiram',
'Shaymin-Sky', 'Kyurem-White', 'Xerneas', 'Yveltal', 'Zekrom'
],
onModifyMove: function(move, pokemon) {
if (move.type === 'Normal' && move.id !== 'hiddenpower' && !pokemon.hasAbility(['aerilate', 'pixilate', 'refrigerate'])) {
var types = pokemon.getTypes();
if (!types[0] || types[0] === '???') return;
move.type = types[0];
move.isMetagamiate = true;
}
},
onBasePowerPriority: 9,
onBasePower: function(basePower, attacker, defender, move) {
if (!move.isMetagamiate) return;
return this.chainModify([0x14CD, 0x1000]);
}
},
{
name: "Protean Palace",
section: "Local Metagames",
ruleset: ['Pokemon', 'Standard', 'Team Preview'],
banlist: ['Uber', 'Soul Dew', 'Gengarite', 'Kangaskhanite', 'Lucarionite', 'Mawilite'],
onPrepareHit: function (source, target, move) {
var type = move.type;
if (type && type !== '???' && source.getTypes().join() !== type) {
if (!source.setType(type)) return;
this.add('-start', source, 'typechange', type, '[from] Protean');
}
}
},
{
name: "Same Type Stealth Rock",
section: "Local Metagames",
mod: 'stsr',
ruleset: ['OU']
},
{
name: "Startermons",
section: 'Local Metagames',
ruleset: ['Pokemon', 'Standard', 'Team Preview', 'Swagger Clause', 'Baton Pass Clause'],
banlist: ['Soul Dew', 'Charizardite X', 'Charizardite Y', 'Venusaurite', 'Blastoisinite', 'Blazikenite', 'Blaziken + Speed Boost'],
validateSet: function (set) {
var validStarters = {
"Bulbasaur":1, "Ivysaur":1, "Venusaur":1, "Charmander":1, "Charmeleon":1, "Charizard":1, "Squirtle":1, "Wartortle":1, "Blastoise":1,
"Chikorita":1, "Bayleef":1, "Meganium":1, "Cyndaquil":1, "Quilava":1, "Typhlosion":1, "Totodile":1, "Croconaw":1, "Feraligatr":1,
"Treecko":1, "Grovyle":1, "Sceptile":1, "Torchic":1, "Combusken":1, "Blaziken":1, "Mudkip":1, "Marshtomp":1, "Swampert":1,
"Turtwig":1, "Grotle":1, "Torterra":1, "Chimchar":1, "Monferno":1, "Infernape":1, "Piplup":1, "Prinplup":1, "Empoleon":1,
"Snivy":1, "Servine":1, "Serperior":1, "Tepig":1, "Pignite":1, "Emboar":1, "Oshawott":1, "Dewott":1, "Samurott":1,
"Chespin":1, "Quilladin":1, "Chesnaught":1, "Fennekin":1, "Braixen":1, "Delphox":1, "Froakie":1, "Frogadier":1, "Greninja":1,
"Pikachu":1, "Raichu":1
};
if (!(set.species in validStarters)) {
return [set.species + " is not a starter."];
}
},
validateTeam: function (team) {
var problems = [];
var hasOneOfEach = true;
var gens = [0, 0, 0, 0, 0, 0];
for (var i = 0; i < team.length; i++) {
var pokemon = Tools.getTemplate(team[i].species || team[i].name);
if (pokemon.num <= 151) ++gens[0];
else if (pokemon.num <= 251) ++gens[1];
else if (pokemon.num <= 386) ++gens[2];
else if (pokemon.num <= 494) ++gens[3];
else if (pokemon.num <= 649) ++gens[4];
else if (pokemon.num <= 721) ++gens[5];
}
for (var j in gens) {
if (gens[j] > 1) hasOneOfEach = false;
}
if (!hasOneOfEach) problems.push('You must bring a Pokemon of each gen.');
return problems;
}
},
{
name: "VGC 2010",
section: "Local Metagames",
gameType: 'doubles',
searchShow: true,
mod: 'gen4',
maxForcedLevel: 50,
ruleset: ['Species Clause', 'Item Clause'],
banlist: ['Unreleased', 'Illegal', 'Soul Dew', 'Huntail + Shell Smash + Sucker Punch', 'Manaphy', 'Mew', 'Arceus', 'Shaymin', 'Darkrai', 'Celebi', 'Jirachi', 'Deoxys', 'Phione'],
onBegin: function () {
this.debug('cutting down to 4');
this.p1.pokemon = this.p1.pokemon.slice(0, 4);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 4);
this.p2.pokemonLeft = this.p2.pokemon.length;
},
validateTeam: function (team) {
if (team.length < 4) return ['You must bring at least four Pokémon.'];
var legendCount = 0;
for (var i = 0; i < 4; i++) {
var pokemon = Tools.getTemplate(team[i].species || team[i].name);
if (pokemon.species in {'Mewtwo': 1, 'Lugia': 1, 'Ho-Oh': 1, 'Rayquaza': 1, 'Kyogre': 1, 'Groudon': 1, 'Dialga': 1, 'Palkia': 1, 'Giratina': 1}) legendCount ++;
}
if (legendCount > 2) return ['You can\'t use more than two of these pokemon: Mewtwo, Lugia, Ho-Oh, Rayquaza, Kyogre, Groudon, Dialga, Palkia, Giratina.'];
}
},
{
name: "Balanced Hackmons (Doubles)",
section: "Local Metagames",
gameType: 'doubles',
ruleset: ['Pokemon', 'Ability Clause', '-ate Clause', 'OHKO Clause', 'Evasion Moves Clause', 'Team Preview', 'HP Percentage Mod', 'Cancel Mod'],
banlist: ['Arena Trap', 'Huge Power', 'Parental Bond', 'Pure Power', 'Shadow Tag', 'Wonder Guard', 'Assist', 'Chatter']
},
// BW2 Singles
///////////////////////////////////////////////////////////////////
{
name: "[Gen 5] OU",
section: "BW2 Singles",
column: 4,
mod: 'gen5',
ruleset: ['Pokemon', 'Standard', 'Evasion Abilities Clause', 'Team Preview'],
banlist: ['Uber', 'Drizzle ++ Swift Swim', 'Soul Dew']
},
{
name: "[Gen 5] Ubers",
section: "BW2 Singles",
mod: 'gen5',
ruleset: ['Pokemon', 'Team Preview', 'Standard Ubers'],
banlist: []
},
{
name: "[Gen 5] UU",
section: "BW2 Singles",
mod: 'gen5',
ruleset: ['[Gen 5] OU'],
banlist: ['OU', 'BL', 'Drought', 'Sand Stream', 'Snow Warning']
},
{
name: "[Gen 5] RU",
section: "BW2 Singles",
mod: 'gen5',
ruleset: ['[Gen 5] UU'],
banlist: ['UU', 'BL2', 'Shell Smash + Baton Pass', 'Snow Warning']
},
{
name: "[Gen 5] NU",
section: "BW2 Singles",
mod: 'gen5',
ruleset: ['[Gen 5] RU'],
banlist: ['RU', 'BL3', 'Prankster + Assist']
},
{
name: "[Gen 5] LC",
section: "BW2 Singles",
mod: 'gen5',
maxLevel: 5,
ruleset: ['Pokemon', 'Standard', 'Team Preview', 'Little Cup'],
banlist: ['Berry Juice', 'Soul Dew', 'Dragon Rage', 'Sonic Boom', 'LC Uber', 'Gligar', 'Scyther', 'Sneasel', 'Tangela']
},
{
name: "[Gen 5] GBU Singles",
section: "BW2 Singles",
mod: 'gen5',
searchShow: false,
maxForcedLevel: 50,
ruleset: ['Pokemon', 'Standard GBU', 'Team Preview GBU'],
banlist: ['Dark Void', 'Sky Drop'],
onBegin: function () {
this.debug('cutting down to 3');
this.p1.pokemon = this.p1.pokemon.slice(0, 3);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 3);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "[Gen 5] Custom Game",
section: "BW2 Singles",
mod: 'gen5',
searchShow: false,
canUseRandomTeam: true,
debug: true,
maxLevel: 9999,
defaultLevel: 100,
// no restrictions, for serious (other than team preview)
ruleset: ['Team Preview', 'Cancel Mod']
},
// BW2 Doubles
///////////////////////////////////////////////////////////////////
{
name: "[Gen 5] Doubles OU",
section: 'BW2 Doubles',
column: 4,
mod: 'gen5',
gameType: 'doubles',
ruleset: ['Pokemon', 'Standard', 'Evasion Abilities Clause', 'Team Preview'],
banlist: ['Arceus', 'Dialga', 'Giratina', 'Giratina-Origin', 'Groudon', 'Ho-Oh', 'Kyogre', 'Kyurem-White', 'Lugia', 'Mewtwo',
'Palkia', 'Rayquaza', 'Reshiram', 'Zekrom', 'Soul Dew', 'Dark Void', 'Sky Drop'
]
},
{
name: "[Gen 5] GBU Doubles",
section: 'BW2 Doubles',
mod: 'gen5',
gameType: 'doubles',
searchShow: false,
maxForcedLevel: 50,
ruleset: ['Pokemon', 'Standard GBU', 'Team Preview VGC'],
banlist: ['Dark Void', 'Sky Drop'],
onBegin: function () {
this.debug('cutting down to 4');
this.p1.pokemon = this.p1.pokemon.slice(0, 4);
this.p1.pokemonLeft = this.p1.pokemon.length;
this.p2.pokemon = this.p2.pokemon.slice(0, 4);
this.p2.pokemonLeft = this.p2.pokemon.length;
}
},
{
name: "[Gen 5] Doubles Custom Game",
section: 'BW2 Doubles',
mod: 'gen5',
gameType: 'doubles',
searchShow: false,
canUseRandomTeam: true,
debug: true,
maxLevel: 9999,
defaultLevel: 100,
// no restrictions, for serious (other than team preview)
ruleset: ['Team Preview', 'Cancel Mod']
},
// Past Generations
///////////////////////////////////////////////////////////////////
{
name: "[Gen 4] OU",
section: "Past Generations",
column: 4,
mod: 'gen4',
ruleset: ['Pokemon', 'Standard'],
banlist: ['Uber']
},
{
name: "[Gen 4] Ubers",
section: "Past Generations",
mod: 'gen4',
ruleset: ['Pokemon', 'Standard'],
banlist: ['Arceus']
},
{
name: "[Gen 4] UU",
section: "Past Generations",
mod: 'gen4',
ruleset: ['Pokemon', 'Standard'],
banlist: ['Uber', 'OU', 'BL']
},
{
name: "[Gen 4] LC",
section: "Past Generations",
mod: 'gen4',
maxLevel: 5,
ruleset: ['Pokemon', 'Standard', 'Little Cup'],
banlist: ['Berry Juice', 'DeepSeaTooth', 'Dragon Rage', 'Sonic Boom', 'Meditite', 'Misdreavus', 'Murkrow', 'Scyther', 'Sneasel', 'Tangela', 'Yanma']
},
{
name: "[Gen 4] Custom Game",
section: "Past Generations",
mod: 'gen4',
searchShow: false,
canUseRandomTeam: true,
debug: true,
maxLevel: 9999,
defaultLevel: 100,
// no restrictions
ruleset: ['Cancel Mod']
},
{
name: "[Gen 4] Doubles Custom Game",
section: 'Past Generations',
mod: 'gen4',
gameType: 'doubles',
searchShow: false,
canUseRandomTeam: true,
debug: true,
maxLevel: 9999,
defaultLevel: 100,
// no restrictions
ruleset: ['Cancel Mod']
},
{
name: "[Gen 3] OU",
section: "Past Generations",
mod: 'gen3',
ruleset: ['Pokemon', 'Standard'],
banlist: ['Uber', 'Smeargle + Ingrain']
},
{
name: "[Gen 3] Ubers",
section: "Past Generations",
mod: 'gen3',
ruleset: ['Pokemon', 'Standard'],
banlist: ['Wobbuffet + Leftovers']
},
{
name: "[Gen 3] Custom Game",
section: "Past Generations",
mod: 'gen3',
searchShow: false,
debug: true,
ruleset: ['Pokemon', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "[Gen 2] OU",
section: "Past Generations",
mod: 'gen2',
ruleset: ['Pokemon', 'Standard'],
banlist: ['Uber']
},
{
name: "[Gen 2] Random Battle",
section: "Past Generations",
mod: 'gen2',
searchShow: false,
team: 'random',
ruleset: ['Pokemon', 'Standard']
},
{
name: "[Gen 2] Custom Game",
section: "Past Generations",
mod: 'gen2',
searchShow: false,
debug: true,
ruleset: ['Pokemon', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "[Gen 1] OU",
section: "Past Generations",
mod: 'gen1',
ruleset: ['Pokemon', 'Standard'],
banlist: ['Uber']
},
{
name: "[Gen 1] Ubers",
section: "Past Generations",
mod: 'gen1',
searchShow: false,
ruleset: ['Pokemon', 'Standard'],
banlist: []
},
{
name: "[Gen 1] OU (tradeback)",
section: "Past Generations",
mod: 'gen1',
searchShow: false,
ruleset: ['Pokemon', 'Sleep Clause Mod', 'Freeze Clause Mod', 'Species Clause', 'OHKO Clause', 'Evasion Moves Clause', 'HP Percentage Mod', 'Cancel Mod'],
banlist: ['Uber', 'Unreleased', 'Illegal',
'Nidoking + Fury Attack + Thrash', 'Exeggutor + Poison Powder + Stomp', 'Exeggutor + Sleep Powder + Stomp',
'Exeggutor + Stun Spore + Stomp', 'Jolteon + Focus Energy + Thunder Shock', 'Flareon + Focus Energy + Ember'
]
},
{
name: "[Gen 1] Random Battle",
section: "Past Generations",
mod: 'gen1',
team: 'random',
ruleset: ['Pokemon', 'Sleep Clause Mod', 'Freeze Clause Mod', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "[Gen 1] Challenge Cup",
section: "Past Generations",
mod: 'gen1',
team: 'randomCC',
searchShow: false,
ruleset: ['Pokemon', 'Sleep Clause Mod', 'Freeze Clause Mod', 'HP Percentage Mod', 'Cancel Mod']
},
{
name: "[Gen 1] Stadium",
section: "Past Generations",
mod: 'stadium',
searchShow: false,
ruleset: ['Pokemon', 'Standard', 'Team Preview'],
banlist: ['Uber',
'Nidoking + Fury Attack + Thrash', 'Exeggutor + Poison Powder + Stomp', 'Exeggutor + Sleep Powder + Stomp',
'Exeggutor + Stun Spore + Stomp', 'Jolteon + Focus Energy + Thunder Shock', 'Flareon + Focus Energy + Ember'
]
},
{
name: "[Gen 1] Custom Game",
section: "Past Generations",
mod: 'gen1',
searchShow: false,
debug: true,
ruleset: ['Pokemon', 'HP Percentage Mod', 'Cancel Mod']
}
];
|
/*
* <%= _.slugify(appName) %>
* https://github.com/<%= userName %>/<%= _.slugify(appName) %>
*
* Copyright (c) 2013 <%= authorName %>
* Licensed under the MIT license.
*/
'use strict';
var chai = require('chai');
chai.expect();
chai.should();
var <%= _.slugify(appName) %> = require('../lib/<%= _.slugify(appName) %>.js');
describe('<%= _.slugify(appName) %> module', function(){
describe('#awesome()', function(){
it('should return a hello', function(){
<%= _.slugify(appName) %>.awesome('livia').should.equal("hello livia");
});
});
});
|
var collisionFinder = require('../lib/collisionFinder');
var mocha = require('mocha');
var chai = require('chai');
var assert = require('assert');
var expect = chai.expect;
var ID_1 = '65506863-548f-49e0-9dd5-0632efd953b7';
var ID_2 = '194e6127-d500-4c8f-85ba-2b3b35c40587';
var ID_3 = '194e6127-d500-4c8f-85ba-2b3b35c40587';
describe('#Collisions', function() {
it('returns SUCCESS when given valid directory', function(done) {
var data;
collisionFinder(__dirname, 'js', function(res) {
data = res;
});
setTimeout(function() {
expect(data.status).to.equal('SUCCESS');
done();
}, 100);
});
it('returns ERROR when given invalid directory', function(done) {
var data;
collisionFinder('?', 'js', function(res) {
data = res;
});
setTimeout(function() {
expect(data.status).to.equal('ERROR');
done();
}, 100);
});
it('finds collisions across multiple files', function(done) {
var data;
collisionFinder(__dirname, 'js', function(res) {
data = res;
});
setTimeout(function() {
expect(data.message).to.equal('Collisions');
done();
}, 100);
});
it('finds collisions across multiple file types', function(done) {
var data;
collisionFinder(__dirname, '.', function(res) {
data = res;
});
setTimeout(function() {
expect(data.message).to.equal('Collisions');
done();
}, 100);
});
it('returns negative when no collisions found', function(done) {
var data;
collisionFinder(__dirname + '/testData3', '.', function(res) {
data = res;
});
setTimeout(function() {
expect(data.message).to.equal('No collisions found!');
done();
}, 100);
});
});
|
/**
* Module dependencies
*/
var mongoose = require('mongoose')
, Schema = mongoose.Schema;
var CommentSchema = new Schema({
body: String,
user: {
username: String
}
});
mongoose.model('Comment', CommentSchema);
|
"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var QuadTree_1=require("../../../../Utils/QuadTree"),Attractor=function(){function t(){}return t.attract=function(t,e,r){for(var i,o=e.options,a=null!==(i=t.lineLinkedDistance)&&void 0!==i?i:e.retina.lineLinkedDistance,n=t.getPosition(),c=0,l=e.particles.quadTree.query(new QuadTree_1.Circle(n.x,n.y,a));c<l.length;c++){var s,u,v,y,d,p,x=l[c];t===x||x.particlesOptions.move.attract.enable||(s=x.getPosition(),u=n.x-s.x,v=n.y-s.y,d=u/(1e3*(y=o.particles.move.attract.rotate).x),p=v/(1e3*y.y),t.velocity.horizontal-=d,t.velocity.vertical-=p,x.velocity.horizontal+=d,x.velocity.vertical+=p)}},t}();exports.Attractor=Attractor; |
/**
* @license Highcharts JS v9.3.0 (2021-10-21)
*
* Old IE (v6, v7, v8) module for Highcharts v6+.
*
* (c) 2010-2021 Highsoft AS
* Author: Torstein Honsi
*
* License: www.highcharts.com/license
*/
'use strict';
(function (factory) {
if (typeof module === 'object' && module.exports) {
factory['default'] = factory;
module.exports = factory;
} else if (typeof define === 'function' && define.amd) {
define('highcharts/modules/oldie', ['highcharts'], function (Highcharts) {
factory(Highcharts);
factory.Highcharts = Highcharts;
return factory;
});
} else {
factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
}
}(function (Highcharts) {
var _modules = Highcharts ? Highcharts._modules : {};
function _registerModule(obj, path, args, fn) {
if (!obj.hasOwnProperty(path)) {
obj[path] = fn.apply(null, args);
}
}
_registerModule(_modules, 'Extensions/Oldie/VMLAxis3D.js', [_modules['Core/Utilities.js']], function (U) {
/* *
*
* (c) 2010-2021 Torstein Honsi
*
* Extension to the VML Renderer
*
* License: www.highcharts.com/license
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
var addEvent = U.addEvent;
/* *
*
* Class
*
* */
/* eslint-disable valid-jsdoc */
var VMLAxis3DAdditions = /** @class */ (function () {
/* *
*
* Constructors
*
* */
function VMLAxis3DAdditions(axis) {
this.axis = axis;
}
return VMLAxis3DAdditions;
}());
var VMLAxis3D = /** @class */ (function () {
function VMLAxis3D() {
}
/* *
*
* Static Properties
*
* */
VMLAxis3D.compose = function (AxisClass) {
AxisClass.keepProps.push('vml');
addEvent(AxisClass, 'destroy', VMLAxis3D.onDestroy);
addEvent(AxisClass, 'init', VMLAxis3D.onInit);
addEvent(AxisClass, 'render', VMLAxis3D.onRender);
};
/**
* @private
*/
VMLAxis3D.onDestroy = function () {
var axis = this,
vml = axis.vml;
if (vml) {
var el_1;
['backFrame', 'bottomFrame', 'sideFrame'].forEach(function (prop) {
el_1 = vml[prop];
if (el_1) {
vml[prop] = el_1.destroy();
}
}, this);
}
};
/**
* @private
*/
VMLAxis3D.onInit = function () {
var axis = this;
if (!axis.vml) {
axis.vml = new VMLAxis3DAdditions(axis);
}
};
/**
* @private
*/
VMLAxis3D.onRender = function () {
var axis = this;
var vml = axis.vml;
// VML doesn't support a negative z-index
if (vml.sideFrame) {
vml.sideFrame.css({ zIndex: 0 });
vml.sideFrame.front.attr({
fill: vml.sideFrame.color
});
}
if (vml.bottomFrame) {
vml.bottomFrame.css({ zIndex: 1 });
vml.bottomFrame.front.attr({
fill: vml.bottomFrame.color
});
}
if (vml.backFrame) {
vml.backFrame.css({ zIndex: 0 });
vml.backFrame.front.attr({
fill: vml.backFrame.color
});
}
};
return VMLAxis3D;
}());
return VMLAxis3D;
});
_registerModule(_modules, 'Extensions/Oldie/VMLRenderer3D.js', [_modules['Core/Axis/Axis.js'], _modules['Core/DefaultOptions.js'], _modules['Extensions/Oldie/VMLAxis3D.js']], function (Axis, D, VMLAxis3D) {
/* *
*
* (c) 2010-2021 Torstein Honsi
*
* Extension to the VML Renderer
*
* License: www.highcharts.com/license
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
var setOptions = D.setOptions;
var VMLRenderer3D = /** @class */ (function () {
function VMLRenderer3D() {
}
/* *
*
* Static Properties
*
* */
VMLRenderer3D.compose = function (vmlClass, svgClass) {
var svgProto = svgClass.prototype;
var vmlProto = vmlClass.prototype;
setOptions({ animate: false });
vmlProto.face3d = svgProto.face3d;
vmlProto.polyhedron = svgProto.polyhedron;
vmlProto.elements3d = svgProto.elements3d;
vmlProto.element3d = svgProto.element3d;
vmlProto.cuboid = svgProto.cuboid;
vmlProto.cuboidPath = svgProto.cuboidPath;
vmlProto.toLinePath = svgProto.toLinePath;
vmlProto.toLineSegments = svgProto.toLineSegments;
vmlProto.arc3d = function (shapeArgs) {
var result = svgProto.arc3d.call(this,
shapeArgs);
result.css({ zIndex: result.zIndex });
return result;
};
vmlProto.arc3dPath = svgProto.arc3dPath;
VMLAxis3D.compose(Axis);
};
return VMLRenderer3D;
}());
return VMLRenderer3D;
});
_registerModule(_modules, 'Extensions/Oldie/Oldie.js', [_modules['Core/Chart/Chart.js'], _modules['Core/Color/Color.js'], _modules['Core/Globals.js'], _modules['Core/DefaultOptions.js'], _modules['Core/Pointer.js'], _modules['Core/Renderer/RendererRegistry.js'], _modules['Core/Renderer/SVG/SVGElement.js'], _modules['Core/Renderer/SVG/SVGRenderer.js'], _modules['Core/Utilities.js'], _modules['Extensions/Oldie/VMLRenderer3D.js']], function (Chart, Color, H, D, Pointer, RendererRegistry, SVGElement, SVGRenderer, U, VMLRenderer3D) {
/* *
*
* (c) 2010-2021 Torstein Honsi
*
* License: www.highcharts.com/license
*
* Support for old IE browsers (6, 7 and 8) in Highcharts v6+.
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
var color = Color.parse;
var deg2rad = H.deg2rad,
doc = H.doc,
noop = H.noop,
svg = H.svg,
win = H.win;
var getOptions = D.getOptions;
var addEvent = U.addEvent,
createElement = U.createElement,
css = U.css,
defined = U.defined,
discardElement = U.discardElement,
erase = U.erase,
extend = U.extend,
extendClass = U.extendClass,
isArray = U.isArray,
isNumber = U.isNumber,
isObject = U.isObject,
pick = U.pick,
pInt = U.pInt,
uniqueKey = U.uniqueKey;
var VMLRenderer,
VMLElement;
/**
* Path to the pattern image required by VML browsers in order to
* draw radial gradients.
*
* @type {string}
* @default http://code.highcharts.com/{version}/gfx/vml-radial-gradient.png
* @since 2.3.0
* @requires modules/oldie
* @apioption global.VMLRadialGradientURL
*/
getOptions().global.VMLRadialGradientURL =
'http://code.highcharts.com/9.3.0/gfx/vml-radial-gradient.png';
// Utilites
if (doc && !doc.defaultView) {
H.getStyle = U.getStyle = function getStyle(el, prop) {
var val,
alias = {
width: 'clientWidth',
height: 'clientHeight'
}[prop];
if (el.style[prop]) {
return pInt(el.style[prop]);
}
if (prop === 'opacity') {
prop = 'filter';
}
// Getting the rendered width and height
if (alias) {
el.style.zoom = 1;
return Math.max(el[alias] - 2 * getStyle(el, 'padding'), 0);
}
val = el.currentStyle[prop.replace(/\-(\w)/g, function (a, b) {
return b.toUpperCase();
})];
if (prop === 'filter') {
val = val.replace(/alpha\(opacity=([0-9]+)\)/, function (a, b) {
return (b / 100);
});
}
return val === '' ? 1 : pInt(val);
};
}
/* eslint-disable no-invalid-this, valid-jsdoc */
if (!svg) {
// Prevent wrapping from creating false offsetWidths in export in legacy IE.
// This applies only to charts for export, where IE runs the SVGRenderer
// instead of the VMLRenderer
// (#1079, #1063)
addEvent(SVGElement, 'afterInit', function () {
if (this.element.nodeName === 'text') {
this.css({
position: 'absolute'
});
}
});
/**
* Old IE override for pointer normalize, adds chartX and chartY to event
* arguments.
*
* @ignore
* @function Highcharts.Pointer#normalize
* @param {global.PointerEvent} e
* @param {boolean} [chartPosition=false]
* @return {Highcharts.PointerEventObject}
*/
Pointer.prototype.normalize = function (e, chartPosition) {
e = e || win.event;
if (!e.target) {
e.target = e.srcElement;
}
// Get mouse position
if (!chartPosition) {
this.chartPosition = chartPosition = this.getChartPosition();
}
return extend(e, {
// #2005, #2129: the second case is for IE10 quirks mode within
// framesets
chartX: Math.round(Math.max(e.x, e.clientX - chartPosition.left)),
chartY: Math.round(e.y)
});
};
/**
* Further sanitize the mock-SVG that is generated when exporting charts in
* oldIE.
*
* @private
* @function Highcharts.Chart#ieSanitizeSVG
*/
Chart.prototype.ieSanitizeSVG = function (svg) {
svg = svg
.replace(/<IMG /g, '<image ')
.replace(/<(\/?)TITLE>/g, '<$1title>')
.replace(/height=([^" ]+)/g, 'height="$1"')
.replace(/width=([^" ]+)/g, 'width="$1"')
.replace(/hc-svg-href="([^"]+)">/g, 'xlink:href="$1"/>')
.replace(/ id=([^" >]+)/g, ' id="$1"') // #4003
.replace(/class=([^" >]+)/g, 'class="$1"')
.replace(/ transform /g, ' ')
.replace(/:(path|rect)/g, '$1')
.replace(/style="([^"]+)"/g, function (s) {
return s.toLowerCase();
});
return svg;
};
/**
* VML namespaces can't be added until after complete. Listening
* for Perini's doScroll hack is not enough.
*
* @private
* @function Highcharts.Chart#isReadyToRender
*/
Chart.prototype.isReadyToRender = function () {
var chart = this;
// Note: win == win.top is required
if (!svg &&
(win == win.top && // eslint-disable-line eqeqeq
doc.readyState !== 'complete')) {
doc.attachEvent('onreadystatechange', function () {
doc.detachEvent('onreadystatechange', chart.firstRender);
if (doc.readyState === 'complete') {
chart.firstRender();
}
});
return false;
}
return true;
};
// IE compatibility hack for generating SVG content that it doesn't really
// understand. Used by the exporting module.
if (!doc.createElementNS) {
doc.createElementNS = function (ns, tagName) {
return doc.createElement(tagName);
};
}
/**
* Old IE polyfill for addEventListener, called from inside the addEvent
* function.
*
* @private
* @function Highcharts.addEventListenerPolyfill<T>
* @param {string} type
* @param {Highcharts.EventCallbackFunction<T>} fn
* @return {void}
*/
H.addEventListenerPolyfill = function (type, fn) {
var el = this;
/**
* @private
*/
function wrappedFn(e) {
e.target = e.srcElement || win; // #2820
fn.call(el, e);
}
if (el.attachEvent) {
if (!el.hcEventsIE) {
el.hcEventsIE = {};
}
// unique function string (#6746)
if (!fn.hcKey) {
fn.hcKey = uniqueKey();
}
// Link wrapped fn with original fn, so we can get this in
// removeEvent
el.hcEventsIE[fn.hcKey] = wrappedFn;
el.attachEvent('on' + type, wrappedFn);
}
};
/**
* @private
* @function Highcharts.removeEventListenerPolyfill<T>
* @param {string} type
* @param {Highcharts.EventCallbackFunction<T>} fn
* @return {void}
*/
H.removeEventListenerPolyfill = function (type, fn) {
if (this.detachEvent) {
fn = this.hcEventsIE[fn.hcKey];
this.detachEvent('on' + type, fn);
}
};
/**
* The VML element wrapper.
*
* @private
* @class
* @name Highcharts.VMLElement
*
* @augments Highcharts.SVGElement
*/
VMLElement = {
docMode8: doc && doc.documentMode === 8,
/**
* Initialize a new VML element wrapper. It builds the markup as a
* string to minimize DOM traffic.
*
* @function Highcharts.VMLElement#init
* @param {Highcharts.VMLRenderer} renderer
* @param {string} nodeName
*/
init: function (renderer, nodeName) {
var wrapper = this, markup = ['<', nodeName, ' filled="f" stroked="f"'], style = ['position: ', 'absolute', ';'], isDiv = nodeName === 'div';
// divs and shapes need size
if (nodeName === 'shape' || isDiv) {
style.push('left:0;top:0;width:1px;height:1px;');
}
style.push('visibility: ', isDiv ? 'hidden' : 'visible');
markup.push(' style="', style.join(''), '"/>');
// create element with default attributes and style
if (nodeName) {
markup = isDiv || nodeName === 'span' || nodeName === 'img' ?
markup.join('') :
renderer.prepVML(markup);
wrapper.element = createElement(markup);
}
wrapper.renderer = renderer;
},
/**
* Add the node to the given parent
*
* @function Highcharts.VMLElement
* @param {Highcharts.VMLElement} parent
* @return {Highcharts.VMLElement}
*/
add: function (parent) {
var wrapper = this,
renderer = wrapper.renderer,
element = wrapper.element,
box = renderer.box,
inverted = parent && parent.inverted,
// get the parent node
parentNode = parent ?
parent.element || parent :
box;
if (parent) {
this.parentGroup = parent;
}
// if the parent group is inverted, apply inversion on all children
if (inverted) { // only on groups
renderer.invertChild(element, parentNode);
}
// append it
parentNode.appendChild(element);
// align text after adding to be able to read offset
wrapper.added = true;
if (wrapper.alignOnAdd && !wrapper.deferUpdateTransform) {
wrapper.updateTransform();
}
// fire an event for internal hooks
if (wrapper.onAdd) {
wrapper.onAdd();
}
// IE8 Standards can't set the class name before the element is
// appended
if (this.className) {
this.attr('class', this.className);
}
return wrapper;
},
/**
* VML always uses htmlUpdateTransform
*
* @function Highcharts.VMLElement#updateTransform
*/
updateTransform: SVGElement.prototype.htmlUpdateTransform,
/**
* Set the rotation of a span with oldIE's filter
*
* @function Highcharts.VMLElement#setSpanRotation
* @return {void}
*/
setSpanRotation: function () {
// Adjust for alignment and rotation. Rotation of useHTML content is
// not yet implemented but it can probably be implemented for
// Firefox 3.5+ on user request. FF3.5+ has support for CSS3
// transform. The getBBox method also needs to be updated to
// compensate for the rotation, like it currently does for SVG.
// Test case: https://jsfiddle.net/highcharts/Ybt44/
var rotation = this.rotation,
costheta = Math.cos(rotation * deg2rad),
sintheta = Math.sin(rotation * deg2rad);
css(this.element, {
filter: rotation ? [
'progid:DXImageTransform.Microsoft.Matrix(M11=', costheta,
', M12=', -sintheta, ', M21=', sintheta, ', M22=', costheta,
', sizingMethod=\'auto expand\')'
].join('') : 'none'
});
},
/**
* Get the positioning correction for the span after rotating.
*
* @function Highcharts.VMLElement#getSpanCorrection
*/
getSpanCorrection: function (width, baseline, alignCorrection, rotation, align) {
var costheta = rotation ? Math.cos(rotation * deg2rad) : 1,
sintheta = rotation ? Math.sin(rotation * deg2rad) : 0,
height = pick(this.elemHeight,
this.element.offsetHeight),
quad,
nonLeft = align && align !== 'left';
// correct x and y
this.xCorr = (costheta < 0 && -width);
this.yCorr = (sintheta < 0 && -height);
// correct for baseline and corners spilling out after rotation
quad = costheta * sintheta < 0;
this.xCorr += (sintheta *
baseline *
(quad ? 1 - alignCorrection : alignCorrection));
this.yCorr -= (costheta *
baseline *
(rotation ? (quad ? alignCorrection : 1 - alignCorrection) : 1));
// correct for the length/height of the text
if (nonLeft) {
this.xCorr -=
width * alignCorrection * (costheta < 0 ? -1 : 1);
if (rotation) {
this.yCorr -= (height *
alignCorrection *
(sintheta < 0 ? -1 : 1));
}
css(this.element, {
textAlign: align
});
}
},
/**
* Converts a subset of an SVG path definition to its VML counterpart.
* Takes an array as the parameter and returns a string.
*
* @function Highcharts.VMLElement#pathToVML
*/
pathToVML: function (value) {
// convert paths
var i = value.length,
path = [];
while (i--) {
// Multiply by 10 to allow subpixel precision.
// Substracting half a pixel seems to make the coordinates
// align with SVG, but this hasn't been tested thoroughly
if (isNumber(value[i])) {
path[i] = Math.round(value[i] * 10) - 5;
}
else if (value[i] === 'Z') { // close the path
path[i] = 'x';
}
else {
path[i] = value[i];
// When the start X and end X coordinates of an arc are too
// close, they are rounded to the same value above. In this
// case, substract or add 1 from the end X and Y positions.
// #186, #760, #1371, #1410.
if (value.isArc &&
(value[i] === 'wa' || value[i] === 'at')) {
// Start and end X
if (path[i + 5] === path[i + 7]) {
path[i + 7] +=
value[i + 7] > value[i + 5] ? 1 : -1;
}
// Start and end Y
if (path[i + 6] === path[i + 8]) {
path[i + 8] +=
value[i + 8] > value[i + 6] ? 1 : -1;
}
}
}
}
return path.join(' ') || 'x';
},
/**
* Set the element's clipping to a predefined rectangle
*
* @function Highcharts.VMLElement#clip
* @param {Highcharts.VMLClipRectObject} clipRect
* @return {Highcharts.VMLElement}
*/
clip: function (clipRect) {
var wrapper = this,
clipMembers,
cssRet;
if (clipRect) {
clipMembers = clipRect.members;
// Ensure unique list of elements (#1258)
erase(clipMembers, wrapper);
clipMembers.push(wrapper);
wrapper.destroyClip = function () {
erase(clipMembers, wrapper);
};
cssRet = clipRect.getCSS(wrapper);
}
else {
if (wrapper.destroyClip) {
wrapper.destroyClip();
}
cssRet = {
clip: wrapper.docMode8 ? 'inherit' : 'rect(auto)'
}; // #1214
}
return wrapper.css(cssRet);
},
/**
* Set styles for the element
*
* @function Highcharts.VMLElement#css
* @param {Highcharts.CSSObject} styles
* @return {Highcharts.VMLElement}
*/
css: SVGElement.prototype.htmlCss,
/**
* Removes a child either by removeChild or move to garbageBin.
* Issue 490; in VML removeChild results in Orphaned nodes according to
* sIEve, discardElement does not.
*
* @function Highcharts.VMLElement#safeRemoveChild
* @param {Highcharts.HTMLDOMElement} element
* @return {void}
*/
safeRemoveChild: function (element) {
// discardElement will detach the node from its parent before
// attaching it to the garbage bin. Therefore it is important that
// the node is attached and have parent.
if (element.parentNode) {
discardElement(element);
}
},
/**
* Extend element.destroy by removing it from the clip members array
*
* @function Highcharts.VMLElement#destroy
*/
destroy: function () {
if (this.destroyClip) {
this.destroyClip();
}
return SVGElement.prototype.destroy.apply(this);
},
/**
* Add an event listener. VML override for normalizing event parameters.
*
* @function Highcharts.VMLElement#on
* @param {string} eventType
* @param {Function} handler
* @return {Highcharts.VMLElement}
*/
on: function (eventType, handler) {
// simplest possible event model for internal use
this.element['on' + eventType] = function () {
var e = win.event;
e.target = e.srcElement;
handler(e);
};
return this;
},
/**
* In stacked columns, cut off the shadows so that they don't overlap
*
* @function Highcharts.VMLElement#cutOffPath
* @param {string} path
* @param {number} length
* @return {string}
*/
cutOffPath: function (path, length) {
var len;
// The extra comma tricks the trailing comma remover in
// "gulp scripts" task
path = path.split(/[ ,]/);
len = path.length;
if (len === 9 || len === 11) {
path[len - 4] = path[len - 2] =
pInt(path[len - 2]) - 10 * length;
}
return path.join(' ');
},
/**
* Apply a drop shadow by copying elements and giving them different
* strokes.
*
* @function Highcharts.VMLElement#shadow
* @param {Highcharts.ShadowOptionsObject} shadowOptions
* @param {Highcharts.VMLElement} group
* @param {boolean} cutOff
* @return {Highcharts.VMLElement}
*/
shadow: function (shadowOptions, group, cutOff) {
var shadows = [],
i,
element = this.element,
renderer = this.renderer,
shadow,
elemStyle = element.style,
markup,
path = element.path,
strokeWidth,
modifiedPath,
shadowWidth,
shadowElementOpacity;
// some times empty paths are not strings
if (path && typeof path.value !== 'string') {
path = 'x';
}
modifiedPath = path;
if (shadowOptions) {
shadowWidth = pick(shadowOptions.width, 3);
shadowElementOpacity =
(shadowOptions.opacity || 0.15) / shadowWidth;
for (i = 1; i <= 3; i++) {
strokeWidth = (shadowWidth * 2) + 1 - (2 * i);
// Cut off shadows for stacked column items
if (cutOff) {
modifiedPath = this.cutOffPath(path.value, strokeWidth + 0.5);
}
markup = [
'<shape isShadow="true" strokeweight="', strokeWidth,
'" filled="false" path="', modifiedPath,
'" coordsize="10 10" style="', element.style.cssText,
'" />'
];
shadow = createElement(renderer.prepVML(markup), null, {
left: (pInt(elemStyle.left) +
pick(shadowOptions.offsetX, 1)) + 'px',
top: (pInt(elemStyle.top) +
pick(shadowOptions.offsetY, 1)) + 'px'
});
if (cutOff) {
shadow.cutOff = strokeWidth + 1;
}
// apply the opacity
markup = [
'<stroke color="',
shadowOptions.color || "#000000" /* neutralColor100 */,
'" opacity="', shadowElementOpacity * i, '"/>'
];
createElement(renderer.prepVML(markup), null, null, shadow);
// insert it
if (group) {
group.element.appendChild(shadow);
}
else {
element.parentNode
.insertBefore(shadow, element);
}
// record it
shadows.push(shadow);
}
this.shadows = shadows;
}
return this;
},
updateShadows: noop,
setAttr: function (key, value) {
if (this.docMode8) { // IE8 setAttribute bug
this.element[key] = value;
}
else {
this.element.setAttribute(key, value);
}
},
getAttr: function (key) {
if (this.docMode8) { // IE8 setAttribute bug
return this.element[key];
}
return this.element.getAttribute(key);
},
classSetter: function (value) {
// IE8 Standards mode has problems retrieving the className unless
// set like this. IE8 Standards can't set the class name before the
// element is appended.
(this.added ? this.element : this).className = value;
},
dashstyleSetter: function (value, key, element) {
var strokeElem = element.getElementsByTagName('stroke')[0] ||
createElement(this.renderer.prepVML(['<stroke/>']),
null,
null,
element);
strokeElem[key] = value || 'solid';
// Because changing stroke-width will change the dash length and
// cause an epileptic effect
this[key] = value;
},
dSetter: function (value, key, element) {
var i,
shadows = this.shadows;
value = value || [];
// Used in getter for animation
this.d = value.join && value.join(' ');
element.path = value = this.pathToVML(value);
// update shadows
if (shadows) {
i = shadows.length;
while (i--) {
shadows[i].path = shadows[i].cutOff ?
this.cutOffPath(value, shadows[i].cutOff) :
value;
}
}
this.setAttr(key, value);
},
fillSetter: function (value, key, element) {
var nodeName = element.nodeName;
if (nodeName === 'SPAN') { // text color
element.style.color = value;
}
else if (nodeName !== 'IMG') { // #1336
element.filled = value !== 'none';
this.setAttr('fillcolor', this.renderer.color(value, element, key, this));
}
},
'fill-opacitySetter': function (value, key, element) {
createElement(this.renderer.prepVML(['<', key.split('-')[0], ' opacity="', value, '"/>']), null, null, element);
},
// Don't bother - animation is too slow and filters introduce artifacts
opacitySetter: noop,
rotationSetter: function (value, key, element) {
var style = element.style;
// style is for #1873:
this[key] = style[key] = value;
// Correction for the 1x1 size of the shape container. Used in gauge
// needles.
style.left =
-Math.round(Math.sin(value * deg2rad) + 1) + 'px';
style.top =
Math.round(Math.cos(value * deg2rad)) + 'px';
},
strokeSetter: function (value, key, element) {
this.setAttr('strokecolor', this.renderer.color(value, element, key, this));
},
'stroke-widthSetter': function (value, key, element) {
element.stroked = !!value; // VML "stroked" attribute
this[key] = value; // used in getter, issue #113
if (isNumber(value)) {
value += 'px';
}
this.setAttr('strokeweight', value);
},
titleSetter: function (value, key) {
this.setAttr(key, value);
},
visibilitySetter: function (value, key, element) {
// Handle inherited visibility
if (value === 'inherit') {
value = 'visible';
}
// Let the shadow follow the main element
if (this.shadows) {
this.shadows.forEach(function (shadow) {
shadow.style[key] = value;
});
}
// Instead of toggling the visibility CSS property, move the div out
// of the viewport. This works around #61 and #586
if (element.nodeName === 'DIV') {
value = value === 'hidden' ? '-999em' : 0;
// In order to redraw, IE7 needs the div to be visible when
// tucked away outside the viewport. So the visibility is
// actually opposite of the expected value. This applies to the
// tooltip only.
if (!this.docMode8) {
element.style[key] = value ? 'visible' : 'hidden';
}
key = 'top';
}
element.style[key] = value;
},
xSetter: function (value, key, element) {
this[key] = value; // used in getter
if (key === 'x') {
key = 'left';
}
else if (key === 'y') {
key = 'top';
}
// clipping rectangle special
if (this.updateClipping) {
// the key is now 'left' or 'top' for 'x' and 'y'
this[key] = value;
this.updateClipping();
}
else {
// normal
element.style[key] = value;
}
},
zIndexSetter: function (value, key, element) {
element.style[key] = value;
},
fillGetter: function () {
return this.getAttr('fillcolor') || '';
},
strokeGetter: function () {
return this.getAttr('strokecolor') || '';
},
// #7850
classGetter: function () {
return this.getAttr('className') || '';
}
};
VMLElement['stroke-opacitySetter'] =
VMLElement['fill-opacitySetter'];
H.VMLElement = VMLElement = extendClass(SVGElement, VMLElement);
// Some shared setters
VMLElement.prototype.ySetter =
VMLElement.prototype.widthSetter =
VMLElement.prototype.heightSetter =
VMLElement.prototype.xSetter;
/**
* The VML renderer
*
* @private
* @class
* @name Highcharts.VMLRenderer
*
* @augments Highcharts.SVGRenderer
*/
var VMLRendererExtension = {
Element: VMLElement,
isIE8: win.navigator.userAgent.indexOf('MSIE 8.0') > -1,
/**
* Initialize the VMLRenderer.
*
* @function Highcharts.VMLRenderer#init
* @param {Highcharts.HTMLDOMElement} container
* @param {number} width
* @param {number} height
* @return {void}
*/
init: function (container,
width,
height) {
var renderer = this,
boxWrapper,
box,
css;
// Extended SVGRenderer member
this.crispPolyLine = SVGRenderer.prototype.crispPolyLine;
renderer.alignedObjects = [];
boxWrapper = renderer.createElement('div')
.css({ position: 'relative' });
box = boxWrapper.element;
container.appendChild(boxWrapper.element);
// generate the containing box
renderer.isVML = true;
renderer.box = box;
renderer.boxWrapper = boxWrapper;
renderer.gradients = {};
renderer.cache = {}; // Cache for numerical bounding boxes
renderer.cacheKeys = [];
renderer.imgCount = 0;
renderer.setSize(width, height, false);
// The only way to make IE6 and IE7 print is to use a global
// namespace. However, with IE8 the only way to make the dynamic
// shapes visible in screen and print mode seems to be to add the
// xmlns attribute and the behaviour style inline.
if (!doc.namespaces.hcv) {
doc.namespaces.add('hcv', 'urn:schemas-microsoft-com:vml');
// Setup default CSS (#2153, #2368, #2384)
css = 'hcv\\:fill, hcv\\:path, hcv\\:shape, hcv\\:stroke' +
'{ behavior:url(#default#VML); display: inline-block; } ';
try {
doc.createStyleSheet().cssText = css;
}
catch (e) {
doc.styleSheets[0].cssText += css;
}
}
},
/**
* Detect whether the renderer is hidden. This happens when one of the
* parent elements has display: none
*
* @function Highcharts.VMLRenderer#isHidden
*/
isHidden: function () {
return !this.box.offsetWidth;
},
/**
* Define a clipping rectangle. In VML it is accomplished by storing the
* values for setting the CSS style to all associated members.
*
* @function Highcharts.VMLRenderer#clipRect
* @param {number|Highcharts.SizeObject} x
* @param {number} y
* @param {number} width
* @param {number} height
* @return {Highcharts.VMLElement}
*/
clipRect: function (x, y, width, height) {
// create a dummy element
var clipRect = this.createElement(),
isObj = isObject(x);
// mimic a rectangle with its style object for automatic updating in
// attr
return extend(clipRect, {
members: [],
count: 0,
left: (isObj ? x.x : x) + 1,
top: (isObj ? x.y : y) + 1,
width: (isObj ? x.width : width) - 1,
height: (isObj ? x.height : height) - 1,
getCSS: function (wrapper) {
var element = wrapper.element, nodeName = element.nodeName, isShape = nodeName === 'shape', inverted = wrapper.inverted, rect = this, top = rect.top - (isShape ? element.offsetTop : 0), left = rect.left, right = left + rect.width, bottom = top + rect.height, ret = {
clip: 'rect(' +
Math.round(inverted ? left : top) + 'px,' +
Math.round(inverted ? bottom : right) + 'px,' +
Math.round(inverted ? right : bottom) + 'px,' +
Math.round(inverted ? top : left) + 'px)'
};
// issue 74 workaround
if (!inverted && wrapper.docMode8 && nodeName === 'DIV') {
extend(ret, {
width: right + 'px',
height: bottom + 'px'
});
}
return ret;
},
// used in attr and animation to update the clipping of all
// members
updateClipping: function () {
clipRect.members.forEach(function (member) {
// Member.element is falsy on deleted series, like in
// stock/members/series-remove demo. Should be removed
// from members, but this will do.
if (member.element) {
member.css(clipRect.getCSS(member));
}
});
}
});
},
/**
* Take a color and return it if it's a string, make it a gradient if
* it's a gradient configuration object, and apply opacity.
*
* @function Highcharts.VMLRenderer#color<T>
*
* @param {T} color
* The color or config object
*
* @return {T}
*/
color: function (colorOption, elem, prop, wrapper) {
var renderer = this,
colorObject,
regexRgba = /^rgba/,
markup,
fillType,
ret = 'none';
// Check for linear or radial gradient
if (colorOption &&
colorOption.linearGradient) {
fillType = 'gradient';
}
else if (colorOption &&
colorOption.radialGradient) {
fillType = 'pattern';
}
if (fillType) {
var stopColor_1, stopOpacity_1, gradient = (colorOption.linearGradient ||
colorOption.radialGradient), x1 = void 0, y1 = void 0, x2 = void 0, y2 = void 0, opacity1_1, opacity2_1, color1_1, color2_1, fillAttr_1 = '', stops = colorOption.stops, firstStop = void 0, lastStop = void 0, colors_1 = [], addFillNode_1 = function () {
// Add the fill subnode. When colors attribute is used,
// the meanings of opacity and o:opacity2 are reversed.
markup = ['<fill colors="' + colors_1.join(',') +
'" opacity="', opacity2_1, '" o:opacity2="',
opacity1_1, '" type="', fillType, '" ', fillAttr_1,
'focus="100%" method="any" />'];
createElement(renderer.prepVML(markup), null, null, elem);
};
// Extend from 0 to 1
firstStop = stops[0];
lastStop = stops[stops.length - 1];
if (firstStop[0] > 0) {
stops.unshift([
0,
firstStop[1]
]);
}
if (lastStop[0] < 1) {
stops.push([
1,
lastStop[1]
]);
}
// Compute the stops
stops.forEach(function (stop, i) {
if (regexRgba.test(stop[1])) {
colorObject = color(stop[1]);
stopColor_1 = colorObject.get('rgb');
stopOpacity_1 = colorObject.get('a');
}
else {
stopColor_1 = stop[1];
stopOpacity_1 = 1;
}
// Build the color attribute
colors_1.push((stop[0] * 100) + '% ' + stopColor_1);
// Only start and end opacities are allowed, so we use the
// first and the last
if (!i) {
opacity1_1 = stopOpacity_1;
color2_1 = stopColor_1;
}
else {
opacity2_1 = stopOpacity_1;
color1_1 = stopColor_1;
}
});
// Apply the gradient to fills only.
if (prop === 'fill') {
// Handle linear gradient angle
if (fillType === 'gradient') {
x1 = gradient.x1 || gradient[0] || 0;
y1 = gradient.y1 || gradient[1] || 0;
x2 = gradient.x2 || gradient[2] || 0;
y2 = gradient.y2 || gradient[3] || 0;
fillAttr_1 = 'angle="' + (90 - Math.atan((y2 - y1) / // y vector
(x2 - x1) // x vector
) * 180 / Math.PI) + '"';
addFillNode_1();
// Radial (circular) gradient
}
else {
var r = gradient.r,
sizex_1 = r * 2,
sizey_1 = r * 2,
cx_1 = gradient.cx,
cy_1 = gradient.cy,
radialReference_1 = elem.radialReference,
bBox_1,
applyRadialGradient = function () {
if (radialReference_1) {
bBox_1 = wrapper.getBBox();
cx_1 += (radialReference_1[0] - bBox_1.x) /
bBox_1.width - 0.5;
cy_1 += (radialReference_1[1] - bBox_1.y) /
bBox_1.height - 0.5;
sizex_1 *= radialReference_1[2] / bBox_1.width;
sizey_1 *= radialReference_1[2] / bBox_1.height;
}
fillAttr_1 =
'src="' + getOptions().global.VMLRadialGradientURL +
'" ' +
'size="' + sizex_1 + ',' + sizey_1 + '" ' +
'origin="0.5,0.5" ' +
'position="' + cx_1 + ',' + cy_1 + '" ' +
'color2="' + color2_1 + '" ';
addFillNode_1();
};
// Apply radial gradient
if (wrapper.added) {
applyRadialGradient();
}
else {
// We need to know the bounding box to get the size
// and position right
wrapper.onAdd = applyRadialGradient;
}
// The fill element's color attribute is broken in IE8
// standards mode, so we need to set the parent shape's
// fillcolor attribute instead.
ret = color1_1;
}
// Gradients are not supported for VML stroke, return the first
// color. #722.
}
else {
ret = stopColor_1;
}
// If the color is an rgba color, split it and add a fill node
// to hold the opacity component
}
else if (regexRgba.test(colorOption) && elem.tagName !== 'IMG') {
colorObject = color(colorOption);
wrapper[prop + '-opacitySetter'](colorObject.get('a'), prop, elem);
ret = colorObject.get('rgb');
}
else {
// 'stroke' or 'fill' node
var propNodes = elem.getElementsByTagName(prop);
if (propNodes.length) {
propNodes[0].opacity = 1;
propNodes[0].type = 'solid';
}
ret = colorOption;
}
return ret;
},
/**
* Take a VML string and prepare it for either IE8 or IE6/IE7.
*
* @function Highcharts.VMLRenderer#prepVML
*
* @param {Array<(number|string)>} markup
* A string array of the VML markup to prepare
*
* @return {string}
*/
prepVML: function (markup) {
var vmlStyle = 'display:inline-block;behavior:url(#default#VML);',
isIE8 = this.isIE8;
markup = markup.join('');
if (isIE8) { // add xmlns and style inline
markup = markup.replace('/>', ' xmlns="urn:schemas-microsoft-com:vml" />');
if (markup.indexOf('style="') === -1) {
markup = markup.replace('/>', ' style="' + vmlStyle + '" />');
}
else {
markup = markup.replace('style="', 'style="' + vmlStyle);
}
}
else { // add namespace
markup = markup.replace('<', '<hcv:');
}
return markup;
},
/**
* Create rotated and aligned text
*
* @function Highcharts.VMLRenderer#text
*
* @param {string} str
*
* @param {number} x
*
* @param {number} y
*/
text: SVGRenderer.prototype.html,
/**
* Create and return a path element
*
* @function Highcharts.VMLRenderer#path
*
* @param {Highcharts.VMLAttributes|Highcharts.VMLPathArray} [path]
*/
path: function (path) {
var attr = {
// subpixel precision down to 0.1 (width and height = 1px)
coordsize: '10 10'
};
if (isArray(path)) {
attr.d = path;
}
else if (isObject(path)) { // attributes
extend(attr, path);
}
// create the shape
return this.createElement('shape').attr(attr);
},
/**
* Create and return a circle element. In VML circles are implemented as
* shapes, which is faster than v:oval
*
* @function Highcharts.VMLRenderer#circle
* @param {number|Highcharts.Dictionary<number>} x
* @param {number} [y]
* @param {number} [r]
* @return {Highcharts.VMLElement}
*/
circle: function (x, y, r) {
var circle = this.symbol('circle');
if (isObject(x)) {
r = x.r;
y = x.y;
x = x.x;
}
circle.isCircle = true; // Causes x and y to mean center (#1682)
circle.r = r;
return circle.attr({ x: x, y: y });
},
/**
* Create a group using an outer div and an inner v:group to allow
* rotating and flipping. A simple v:group would have problems with
* positioning child HTML elements and CSS clip.
*
* @function Highcharts.VMLRenderer#g
*
* @param {string} name
* The name of the group
*
* @return {Highcharts.VMLElement}
*/
g: function (name) {
var wrapper,
attribs;
// set the class name
if (name) {
attribs = {
'className': 'highcharts-' + name,
'class': 'highcharts-' + name
};
}
// the div to hold HTML and clipping
wrapper = this.createElement('div').attr(attribs);
return wrapper;
},
/**
* VML override to create a regular HTML image.
*
* @function Highcharts.VMLRenderer#image
*
* @param {string} src
*
* @param {number} x
*
* @param {number} y
*
* @param {number} width
*
* @param {number} height
* @return {Highcharts.VMLElement}
*/
image: function (src, x, y, width, height) {
var obj = this.createElement('img').attr({ src: src });
if (arguments.length > 1) {
obj.attr({
x: x,
y: y,
width: width,
height: height
});
}
return obj;
},
/**
* For rectangles, VML uses a shape for rect to overcome bugs and
* rotation problems
*
* @function Highcharts.VMLRenderer#createElement
* @param {string} nodeName
* @return {Highcharts.VMLElement}
*/
createElement: function (nodeName) {
return nodeName === 'rect' ?
this.symbol(nodeName) :
SVGRenderer.prototype.createElement.call(this, nodeName);
},
/**
* In the VML renderer, each child of an inverted div (group) is
* inverted
*
* @function Highcharts.VMLRenderer#invertChild
*
* @param {Highcharts.HTMLDOMElement} element
*
* @param {Highcharts.HTMLDOMElement} parentNode
*/
invertChild: function (element, parentNode) {
var ren = this,
parentStyle = parentNode.style,
imgStyle = element.tagName === 'IMG' && element.style; // #1111
css(element, {
flip: 'x',
left: (pInt(parentStyle.width) -
(imgStyle ? pInt(imgStyle.top) : 1)) + 'px',
top: (pInt(parentStyle.height) -
(imgStyle ? pInt(imgStyle.left) : 1)) + 'px',
rotation: -90
});
// Recursively invert child elements, needed for nested composite
// shapes like box plots and error bars. #1680, #1806.
[].forEach.call(element.childNodes, function (child) {
ren.invertChild(child, element);
});
},
/**
* Symbol definitions that override the parent SVG renderer's symbols
*
* @name Highcharts.VMLRenderer#symbols
* @type {Highcharts.Dictionary<Function>}
*/
symbols: {
// VML specific arc function
arc: function (x, y, w, h, options) {
var start = options.start,
end = options.end,
radius = options.r || w || h,
innerRadius = options.innerR,
cosStart = Math.cos(start),
sinStart = Math.sin(start),
cosEnd = Math.cos(end),
sinEnd = Math.sin(end),
ret;
if (end - start === 0) { // no angle, don't show it.
return ['x'];
}
ret = [
'wa',
x - radius,
y - radius,
x + radius,
y + radius,
x + radius * cosStart,
y + radius * sinStart,
x + radius * cosEnd,
y + radius * sinEnd // end y
];
if (options.open && !innerRadius) {
ret.push('e', 'M', x, // - innerRadius,
y // - innerRadius
);
}
ret.push('at', // anti clockwise arc to
x - innerRadius, // left
y - innerRadius, // top
x + innerRadius, // right
y + innerRadius, // bottom
x + innerRadius * cosEnd, // start x
y + innerRadius * sinEnd, // start y
x + innerRadius * cosStart, // end x
y + innerRadius * sinStart, // end y
'x', // finish path
'e' // close
);
ret.isArc = true;
return ret;
},
// Add circle symbol path. This performs significantly faster than
// v:oval.
circle: function (x, y, w, h, wrapper) {
if (wrapper && defined(wrapper.r)) {
w = h = 2 * wrapper.r;
}
// Center correction, #1682
if (wrapper && wrapper.isCircle) {
x -= w / 2;
y -= h / 2;
}
// Return the path
return [
'wa',
x,
y,
x + w,
y + h,
x + w,
y + h / 2,
x + w,
y + h / 2,
'e' // close
];
},
/**
* Add rectangle symbol path which eases rotation and omits arcsize
* problems compared to the built-in VML roundrect shape. When
* borders are not rounded, use the simpler square path, else use
* the callout path without the arrow.
*/
rect: function (x, y, w, h, options) {
return SVGRenderer.prototype.symbols[!defined(options) || !options.r ? 'square' : 'callout'].call(0, x, y, w, h, options);
}
}
};
H.VMLRenderer = VMLRenderer = function () {
this.init.apply(this, arguments);
};
extend(VMLRenderer.prototype, SVGRenderer.prototype);
extend(VMLRenderer.prototype, VMLRendererExtension);
// general renderer
RendererRegistry.registerRendererType('VMLRenderer', VMLRenderer, true);
// 3D additions
VMLRenderer3D.compose(VMLRenderer, SVGRenderer);
}
SVGRenderer.prototype.getSpanWidth = function (wrapper, tspan) {
var renderer = this,
bBox = wrapper.getBBox(true),
actualWidth = bBox.width;
// Old IE cannot measure the actualWidth for SVG elements (#2314)
if (!svg && renderer.forExport) {
actualWidth = renderer.measureSpanWidth(tspan.firstChild.data, wrapper.styles);
}
return actualWidth;
};
// This method is used with exporting in old IE, when emulating SVG (see #2314)
SVGRenderer.prototype.measureSpanWidth = function (text, styles) {
var measuringSpan = doc.createElement('span'),
offsetWidth,
textNode = doc.createTextNode(text);
measuringSpan.appendChild(textNode);
css(measuringSpan, styles);
this.box.appendChild(measuringSpan);
offsetWidth = measuringSpan.offsetWidth;
discardElement(measuringSpan); // #2463
return offsetWidth;
};
});
_registerModule(_modules, 'masters/modules/oldie.src.js', [], function () {
});
})); |
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
Object.defineProperty(exports, "createFilterOptions", {
enumerable: true,
get: function () {
return _useAutocomplete.createFilterOptions;
}
});
exports.default = void 0;
var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var React = _interopRequireWildcard(require("react"));
var _propTypes = _interopRequireDefault(require("prop-types"));
var _clsx = _interopRequireDefault(require("clsx"));
var _utils = require("@material-ui/utils");
var _unstyled = require("@material-ui/unstyled");
var _system = require("@material-ui/system");
var _Popper = _interopRequireDefault(require("../Popper"));
var _ListSubheader = _interopRequireDefault(require("../ListSubheader"));
var _Paper = _interopRequireDefault(require("../Paper"));
var _IconButton = _interopRequireDefault(require("../IconButton"));
var _Chip = _interopRequireDefault(require("../Chip"));
var _Close = _interopRequireDefault(require("../internal/svg-icons/Close"));
var _ArrowDropDown = _interopRequireDefault(require("../internal/svg-icons/ArrowDropDown"));
var _useAutocomplete = _interopRequireWildcard(require("../useAutocomplete"));
var _useThemeProps = _interopRequireDefault(require("../styles/useThemeProps"));
var _styled = _interopRequireDefault(require("../styles/styled"));
var _autocompleteClasses = _interopRequireWildcard(require("./autocompleteClasses"));
var _capitalize = _interopRequireDefault(require("../utils/capitalize"));
var _jsxRuntime = require("react/jsx-runtime");
var _ClearIcon, _ArrowDropDownIcon;
const _excluded = ["autoComplete", "autoHighlight", "autoSelect", "blurOnSelect", "ChipProps", "className", "clearIcon", "clearOnBlur", "clearOnEscape", "clearText", "closeText", "defaultValue", "disableClearable", "disableCloseOnSelect", "disabled", "disabledItemsFocusable", "disableListWrap", "disablePortal", "filterOptions", "filterSelectedOptions", "forcePopupIcon", "freeSolo", "fullWidth", "getLimitTagsText", "getOptionDisabled", "getOptionLabel", "isOptionEqualToValue", "groupBy", "handleHomeEndKeys", "id", "includeInputInList", "inputValue", "limitTags", "ListboxComponent", "ListboxProps", "loading", "loadingText", "multiple", "noOptionsText", "onChange", "onClose", "onHighlightChange", "onInputChange", "onOpen", "open", "openOnFocus", "openText", "options", "PaperComponent", "PopperComponent", "popupIcon", "renderGroup", "renderInput", "renderOption", "renderTags", "selectOnFocus", "size", "value"];
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
const useUtilityClasses = styleProps => {
const {
classes,
disablePortal,
focused,
fullWidth,
hasClearIcon,
hasPopupIcon,
inputFocused,
popupOpen,
size
} = styleProps;
const slots = {
root: ['root', focused && 'focused', fullWidth && 'fullWidth', hasClearIcon && 'hasClearIcon', hasPopupIcon && 'hasPopupIcon'],
inputRoot: ['inputRoot'],
input: ['input', inputFocused && 'inputFocused'],
tag: ['tag', `tagSize${(0, _capitalize.default)(size)}`],
endAdornment: ['endAdornment'],
clearIndicator: ['clearIndicator'],
popupIndicator: ['popupIndicator', popupOpen && 'popupIndicatorOpen'],
popper: ['popper', disablePortal && 'popperDisablePortal'],
paper: ['paper'],
listbox: ['listbox'],
loading: ['loading'],
noOptions: ['noOptions'],
option: ['option'],
groupLabel: ['groupLabel'],
groupUl: ['groupUl']
};
return (0, _unstyled.unstable_composeClasses)(slots, _autocompleteClasses.getAutocompleteUtilityClass, classes);
};
const AutocompleteRoot = (0, _styled.default)('div', {
name: 'MuiAutocomplete',
slot: 'Root',
overridesResolver: (props, styles) => {
const {
styleProps
} = props;
const {
fullWidth,
hasClearIcon,
hasPopupIcon,
inputFocused,
size
} = styleProps;
return (0, _extends2.default)({
[`& .${_autocompleteClasses.default.tag}`]: (0, _extends2.default)({}, styles.tag, styles[`tagSize${(0, _capitalize.default)(size)}`]),
[`& .${_autocompleteClasses.default.inputRoot}`]: styles.inputRoot,
[`& .${_autocompleteClasses.default.input}`]: (0, _extends2.default)({}, styles.input, inputFocused && styles.inputFocused)
}, styles.root, fullWidth && styles.fullWidth, hasPopupIcon && styles.hasPopupIcon, hasClearIcon && styles.hasClearIcon);
}
})(({
styleProps
}) => (0, _extends2.default)({
/* Styles applied to the root element. */
[`&.${_autocompleteClasses.default.focused} .${_autocompleteClasses.default.clearIndicator}`]: {
visibility: 'visible'
},
/* Avoid double tap issue on iOS */
'@media (pointer: fine)': {
[`&:hover .${_autocompleteClasses.default.clearIndicator}`]: {
visibility: 'visible'
}
}
}, styleProps.fullWidth && {
width: '100%'
}, {
/* Styles applied to the tag elements, e.g. the chips. */
[`& .${_autocompleteClasses.default.tag}`]: (0, _extends2.default)({
margin: 3,
maxWidth: 'calc(100% - 6px)'
}, styleProps.size === 'small' && {
margin: 2,
maxWidth: 'calc(100% - 4px)'
}),
/* Styles applied to the Input element. */
[`& .${_autocompleteClasses.default.inputRoot}`]: {
flexWrap: 'wrap',
[`.${_autocompleteClasses.default.hasPopupIcon}&, .${_autocompleteClasses.default.hasClearIcon}&`]: {
paddingRight: 26 + 4
},
[`.${_autocompleteClasses.default.hasPopupIcon}.${_autocompleteClasses.default.hasClearIcon}&`]: {
paddingRight: 52 + 4
},
[`& .${_autocompleteClasses.default.input}`]: {
width: 0,
minWidth: 30
}
},
'& .MuiInput-root': {
paddingBottom: 1,
'& .MuiInput-input': {
padding: '4px 4px 4px 0px'
}
},
'& .MuiInput-root.MuiInputBase-sizeSmall': {
'& .MuiInput-input': {
padding: '2px 4px 3px 0'
}
},
'& .MuiOutlinedInput-root': {
padding: 9,
[`.${_autocompleteClasses.default.hasPopupIcon}&, .${_autocompleteClasses.default.hasClearIcon}&`]: {
paddingRight: 26 + 4 + 9
},
[`.${_autocompleteClasses.default.hasPopupIcon}.${_autocompleteClasses.default.hasClearIcon}&`]: {
paddingRight: 52 + 4 + 9
},
[`& .${_autocompleteClasses.default.input}`]: {
padding: '7.5px 4px 7.5px 6px'
},
[`& .${_autocompleteClasses.default.endAdornment}`]: {
right: 9
}
},
'& .MuiOutlinedInput-root.MuiInputBase-sizeSmall': {
padding: 6,
[`& .${_autocompleteClasses.default.input}`]: {
padding: '2.5px 4px 2.5px 6px'
}
},
'& .MuiFilledInput-root': {
paddingTop: 19,
paddingLeft: 8,
[`.${_autocompleteClasses.default.hasPopupIcon}&, .${_autocompleteClasses.default.hasClearIcon}&`]: {
paddingRight: 26 + 4 + 9
},
[`.${_autocompleteClasses.default.hasPopupIcon}.${_autocompleteClasses.default.hasClearIcon}&`]: {
paddingRight: 52 + 4 + 9
},
'& .MuiFilledInput-input': {
padding: '7px 4px'
},
[`& .${_autocompleteClasses.default.endAdornment}`]: {
right: 9
}
},
'& .MuiFilledInput-root.MuiInputBase-sizeSmall': {
paddingBottom: 1,
'& .MuiFilledInput-input': {
padding: '2.5px 4px'
}
},
/* Styles applied to the input element. */
[`& .${_autocompleteClasses.default.input}`]: (0, _extends2.default)({
flexGrow: 1,
textOverflow: 'ellipsis',
opacity: 0
}, styleProps.inputFocused && {
opacity: 1
})
}));
const AutocompleteEndAdornment = (0, _styled.default)('div', {
name: 'MuiAutocomplete',
slot: 'EndAdornment',
overridesResolver: (props, styles) => styles.endAdornment
})({
/* Styles applied to the endAdornment element. */
// We use a position absolute to support wrapping tags.
position: 'absolute',
right: 0,
top: 'calc(50% - 14px)' // Center vertically
});
const AutocompleteClearIndicator = (0, _styled.default)(_IconButton.default, {
name: 'MuiAutocomplete',
slot: 'ClearIndicator',
overridesResolver: (props, styles) => styles.clearIndicator
})({
/* Styles applied to the clear indicator. */
marginRight: -2,
padding: 4,
visibility: 'hidden'
});
const AutocompletePopupIndicator = (0, _styled.default)(_IconButton.default, {
name: 'MuiAutocomplete',
slot: 'PopupIndicator',
overridesResolver: ({
styleProps
}, styles) => (0, _extends2.default)({}, styles.popupIndicator, styleProps.popupOpen && styles.popupIndicatorOpen)
})(({
styleProps
}) => (0, _extends2.default)({
/* Styles applied to the popup indicator. */
padding: 2,
marginRight: -2
}, styleProps.popupOpen && {
transform: 'rotate(180deg)'
}));
const AutocompletePopper = (0, _styled.default)(_Popper.default, {
name: 'MuiAutocomplete',
slot: 'Popper',
overridesResolver: (props, styles) => {
const {
styleProps
} = props;
return (0, _extends2.default)({
[`& .${_autocompleteClasses.default.option}`]: styles.option
}, styles.popper, styleProps.disablePortal && styles.popperDisablePortal);
}
})(({
theme,
styleProps
}) => (0, _extends2.default)({
/* Styles applied to the popper element. */
zIndex: theme.zIndex.modal
}, styleProps.disablePortal && {
position: 'absolute'
}));
const AutocompletePaper = (0, _styled.default)(_Paper.default, {
name: 'MuiAutocomplete',
slot: 'Paper',
overridesResolver: (props, styles) => styles.paper
})(({
theme
}) => (0, _extends2.default)({}, theme.typography.body1, {
overflow: 'auto'
}));
const AutocompleteLoading = (0, _styled.default)('div', {
name: 'MuiAutocomplete',
slot: 'Loading',
overridesResolver: (props, styles) => styles.loading
})(({
theme
}) => ({
/* Styles applied to the loading wrapper. */
color: theme.palette.text.secondary,
padding: '14px 16px'
}));
const AutocompleteNoOptions = (0, _styled.default)('div', {
name: 'MuiAutocomplete',
slot: 'NoOptions',
overridesResolver: (props, styles) => styles.noOptions
})(({
theme
}) => ({
/* Styles applied to the no option wrapper. */
color: theme.palette.text.secondary,
padding: '14px 16px'
}));
const AutocompleteListbox = (0, _styled.default)('div', {
name: 'MuiAutocomplete',
slot: 'Listbox',
overridesResolver: (props, styles) => styles.listbox
})(({
theme
}) => ({
/* Styles applied to the listbox component. */
listStyle: 'none',
margin: 0,
padding: '8px 0',
maxHeight: '40vh',
overflow: 'auto',
/* Styles applied to the option elements. */
[`& .${_autocompleteClasses.default.option}`]: {
minHeight: 48,
display: 'flex',
overflow: 'hidden',
justifyContent: 'flex-start',
alignItems: 'center',
cursor: 'pointer',
paddingTop: 6,
boxSizing: 'border-box',
outline: '0',
WebkitTapHighlightColor: 'transparent',
paddingBottom: 6,
paddingLeft: 16,
paddingRight: 16,
[theme.breakpoints.up('sm')]: {
minHeight: 'auto'
},
[`&.${_autocompleteClasses.default.focused}`]: {
backgroundColor: theme.palette.action.hover,
// Reset on touch devices, it doesn't add specificity
'@media (hover: none)': {
backgroundColor: 'transparent'
}
},
'&[aria-disabled="true"]': {
opacity: theme.palette.action.disabledOpacity,
pointerEvents: 'none'
},
[`&.${_autocompleteClasses.default.focusVisible}`]: {
backgroundColor: theme.palette.action.focus
},
'&[aria-selected="true"]': {
backgroundColor: (0, _system.alpha)(theme.palette.primary.main, theme.palette.action.selectedOpacity),
[`&.${_autocompleteClasses.default.focused}`]: {
backgroundColor: (0, _system.alpha)(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.hoverOpacity),
// Reset on touch devices, it doesn't add specificity
'@media (hover: none)': {
backgroundColor: theme.palette.action.selected
}
},
[`&.${_autocompleteClasses.default.focusVisible}`]: {
backgroundColor: (0, _system.alpha)(theme.palette.primary.main, theme.palette.action.selectedOpacity + theme.palette.action.focusOpacity)
}
}
}
}));
const AutocompleteGroupLabel = (0, _styled.default)(_ListSubheader.default, {
name: 'MuiAutocomplete',
slot: 'GroupLabel',
overridesResolver: (props, styles) => styles.groupLabel
})(({
theme
}) => ({
/* Styles applied to the group's label elements. */
backgroundColor: theme.palette.background.paper,
top: -8
}));
const AutocompleteGroupUl = (0, _styled.default)('ul', {
name: 'MuiAutocomplete',
slot: 'GroupUl',
overridesResolver: (props, styles) => styles.groupUl
})({
/* Styles applied to the group's ul elements. */
padding: 0,
[`& .${_autocompleteClasses.default.option}`]: {
paddingLeft: 24
}
});
const Autocomplete = /*#__PURE__*/React.forwardRef(function Autocomplete(inProps, ref) {
const props = (0, _useThemeProps.default)({
props: inProps,
name: 'MuiAutocomplete'
});
/* eslint-disable @typescript-eslint/no-unused-vars */
const {
autoComplete = false,
autoHighlight = false,
autoSelect = false,
blurOnSelect = false,
ChipProps,
className,
clearIcon = _ClearIcon || (_ClearIcon = /*#__PURE__*/(0, _jsxRuntime.jsx)(_Close.default, {
fontSize: "small"
})),
clearOnBlur = !props.freeSolo,
clearOnEscape = false,
clearText = 'Clear',
closeText = 'Close',
defaultValue = props.multiple ? [] : null,
disableClearable = false,
disableCloseOnSelect = false,
disabled = false,
disabledItemsFocusable = false,
disableListWrap = false,
disablePortal = false,
filterSelectedOptions = false,
forcePopupIcon = 'auto',
freeSolo = false,
fullWidth = false,
getLimitTagsText = more => `+${more}`,
getOptionLabel = option => {
var _option$label;
return (_option$label = option.label) !== null && _option$label !== void 0 ? _option$label : option;
},
groupBy,
handleHomeEndKeys = !props.freeSolo,
includeInputInList = false,
limitTags = -1,
ListboxComponent = 'ul',
ListboxProps,
loading = false,
loadingText = 'Loading…',
multiple = false,
noOptionsText = 'No options',
openOnFocus = false,
openText = 'Open',
PaperComponent = _Paper.default,
PopperComponent = _Popper.default,
popupIcon = _ArrowDropDownIcon || (_ArrowDropDownIcon = /*#__PURE__*/(0, _jsxRuntime.jsx)(_ArrowDropDown.default, {})),
renderGroup: renderGroupProp,
renderInput,
renderOption: renderOptionProp,
renderTags,
selectOnFocus = !props.freeSolo,
size = 'medium'
} = props,
other = (0, _objectWithoutPropertiesLoose2.default)(props, _excluded);
/* eslint-enable @typescript-eslint/no-unused-vars */
const {
getRootProps,
getInputProps,
getInputLabelProps,
getPopupIndicatorProps,
getClearProps,
getTagProps,
getListboxProps,
getOptionProps,
value,
dirty,
id,
popupOpen,
focused,
focusedTag,
anchorEl,
setAnchorEl,
inputValue,
groupedOptions
} = (0, _useAutocomplete.default)((0, _extends2.default)({}, props, {
componentName: 'Autocomplete'
}));
const hasClearIcon = !disableClearable && !disabled && dirty;
const hasPopupIcon = (!freeSolo || forcePopupIcon === true) && forcePopupIcon !== false;
const styleProps = (0, _extends2.default)({}, props, {
disablePortal,
focused,
fullWidth,
hasClearIcon,
hasPopupIcon,
inputFocused: focusedTag === -1,
popupOpen,
size
});
const classes = useUtilityClasses(styleProps);
let startAdornment;
if (multiple && value.length > 0) {
const getCustomizedTagProps = params => (0, _extends2.default)({
className: (0, _clsx.default)(classes.tag),
disabled
}, getTagProps(params));
if (renderTags) {
startAdornment = renderTags(value, getCustomizedTagProps);
} else {
startAdornment = value.map((option, index) => /*#__PURE__*/(0, _jsxRuntime.jsx)(_Chip.default, (0, _extends2.default)({
label: getOptionLabel(option),
size: size
}, getCustomizedTagProps({
index
}), ChipProps)));
}
}
if (limitTags > -1 && Array.isArray(startAdornment)) {
const more = startAdornment.length - limitTags;
if (!focused && more > 0) {
startAdornment = startAdornment.splice(0, limitTags);
startAdornment.push( /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
className: classes.tag,
children: getLimitTagsText(more)
}, startAdornment.length));
}
}
const defaultRenderGroup = params => /*#__PURE__*/(0, _jsxRuntime.jsxs)("li", {
children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompleteGroupLabel, {
className: classes.groupLabel,
styleProps: styleProps,
component: "div",
children: params.group
}), /*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompleteGroupUl, {
className: classes.groupUl,
styleProps: styleProps,
children: params.children
})]
}, params.key);
const renderGroup = renderGroupProp || defaultRenderGroup;
const defaultRenderOption = (props2, option) => /*#__PURE__*/(0, _jsxRuntime.jsx)("li", (0, _extends2.default)({}, props2, {
children: getOptionLabel(option)
}));
const renderOption = renderOptionProp || defaultRenderOption;
const renderListOption = (option, index) => {
const optionProps = getOptionProps({
option,
index
});
return renderOption((0, _extends2.default)({}, optionProps, {
className: classes.option
}), option, {
selected: optionProps['aria-selected'],
inputValue
});
};
return /*#__PURE__*/(0, _jsxRuntime.jsxs)(React.Fragment, {
children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompleteRoot, (0, _extends2.default)({
ref: ref,
className: (0, _clsx.default)(classes.root, className),
styleProps: styleProps
}, getRootProps(other), {
children: renderInput({
id,
disabled,
fullWidth: true,
size: size === 'small' ? 'small' : undefined,
InputLabelProps: getInputLabelProps(),
InputProps: {
ref: setAnchorEl,
className: classes.inputRoot,
startAdornment,
endAdornment: /*#__PURE__*/(0, _jsxRuntime.jsxs)(AutocompleteEndAdornment, {
className: classes.endAdornment,
styleProps: styleProps,
children: [hasClearIcon ? /*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompleteClearIndicator, (0, _extends2.default)({}, getClearProps(), {
"aria-label": clearText,
title: clearText,
className: classes.clearIndicator,
styleProps: styleProps,
children: clearIcon
})) : null, hasPopupIcon ? /*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompletePopupIndicator, (0, _extends2.default)({}, getPopupIndicatorProps(), {
disabled: disabled,
"aria-label": popupOpen ? closeText : openText,
title: popupOpen ? closeText : openText,
className: (0, _clsx.default)(classes.popupIndicator),
styleProps: styleProps,
children: popupIcon
})) : null]
})
},
inputProps: (0, _extends2.default)({
className: (0, _clsx.default)(classes.input),
disabled
}, getInputProps())
})
})), popupOpen && anchorEl ? /*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompletePopper, {
as: PopperComponent,
className: (0, _clsx.default)(classes.popper),
disablePortal: disablePortal,
style: {
width: anchorEl ? anchorEl.clientWidth : null
},
styleProps: styleProps,
role: "presentation",
anchorEl: anchorEl,
open: true,
children: /*#__PURE__*/(0, _jsxRuntime.jsxs)(AutocompletePaper, {
as: PaperComponent,
className: classes.paper,
styleProps: styleProps,
children: [loading && groupedOptions.length === 0 ? /*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompleteLoading, {
className: classes.loading,
styleProps: styleProps,
children: loadingText
}) : null, groupedOptions.length === 0 && !freeSolo && !loading ? /*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompleteNoOptions, {
className: classes.noOptions,
styleProps: styleProps,
role: "presentation",
onMouseDown: event => {
// Prevent input blur when interacting with the "no options" content
event.preventDefault();
},
children: noOptionsText
}) : null, groupedOptions.length > 0 ? /*#__PURE__*/(0, _jsxRuntime.jsx)(AutocompleteListbox, (0, _extends2.default)({
as: ListboxComponent,
className: classes.listbox,
styleProps: styleProps
}, getListboxProps(), ListboxProps, {
children: groupedOptions.map((option, index) => {
if (groupBy) {
return renderGroup({
key: option.key,
group: option.group,
children: option.options.map((option2, index2) => renderListOption(option2, option.index + index2))
});
}
return renderListOption(option, index);
})
})) : null]
})
}) : null]
});
});
process.env.NODE_ENV !== "production" ? Autocomplete.propTypes
/* remove-proptypes */
= {
// ----------------------------- Warning --------------------------------
// | These PropTypes are generated from the TypeScript type definitions |
// | To update them edit the d.ts file and run "yarn proptypes" |
// ----------------------------------------------------------------------
/**
* If `true`, the portion of the selected suggestion that has not been typed by the user,
* known as the completion string, appears inline after the input cursor in the textbox.
* The inline completion string is visually highlighted and has a selected state.
* @default false
*/
autoComplete: _propTypes.default.bool,
/**
* If `true`, the first option is automatically highlighted.
* @default false
*/
autoHighlight: _propTypes.default.bool,
/**
* If `true`, the selected option becomes the value of the input
* when the Autocomplete loses focus unless the user chooses
* a different option or changes the character string in the input.
* @default false
*/
autoSelect: _propTypes.default.bool,
/**
* Control if the input should be blurred when an option is selected:
*
* - `false` the input is not blurred.
* - `true` the input is always blurred.
* - `touch` the input is blurred after a touch event.
* - `mouse` the input is blurred after a mouse event.
* @default false
*/
blurOnSelect: _propTypes.default.oneOfType([_propTypes.default.oneOf(['mouse', 'touch']), _propTypes.default.bool]),
/**
* Props applied to the [`Chip`](/api/chip/) element.
*/
ChipProps: _propTypes.default.object,
/**
* Override or extend the styles applied to the component.
*/
classes: _propTypes.default.object,
/**
* @ignore
*/
className: _propTypes.default.string,
/**
* The icon to display in place of the default clear icon.
* @default <ClearIcon fontSize="small" />
*/
clearIcon: _propTypes.default.node,
/**
* If `true`, the input's text is cleared on blur if no value is selected.
*
* Set to `true` if you want to help the user enter a new value.
* Set to `false` if you want to help the user resume his search.
* @default !props.freeSolo
*/
clearOnBlur: _propTypes.default.bool,
/**
* If `true`, clear all values when the user presses escape and the popup is closed.
* @default false
*/
clearOnEscape: _propTypes.default.bool,
/**
* Override the default text for the *clear* icon button.
*
* For localization purposes, you can use the provided [translations](/guides/localization/).
* @default 'Clear'
*/
clearText: _propTypes.default.string,
/**
* Override the default text for the *close popup* icon button.
*
* For localization purposes, you can use the provided [translations](/guides/localization/).
* @default 'Close'
*/
closeText: _propTypes.default.string,
/**
* The default value. Use when the component is not controlled.
* @default props.multiple ? [] : null
*/
defaultValue: _propTypes.default.any,
/**
* If `true`, the input can't be cleared.
* @default false
*/
disableClearable: _propTypes.default.bool,
/**
* If `true`, the popup won't close when a value is selected.
* @default false
*/
disableCloseOnSelect: _propTypes.default.bool,
/**
* If `true`, the component is disabled.
* @default false
*/
disabled: _propTypes.default.bool,
/**
* If `true`, will allow focus on disabled items.
* @default false
*/
disabledItemsFocusable: _propTypes.default.bool,
/**
* If `true`, the list box in the popup will not wrap focus.
* @default false
*/
disableListWrap: _propTypes.default.bool,
/**
* If `true`, the `Popper` content will be under the DOM hierarchy of the parent component.
* @default false
*/
disablePortal: _propTypes.default.bool,
/**
* A filter function that determines the options that are eligible.
*
* @param {T[]} options The options to render.
* @param {object} state The state of the component.
* @returns {T[]}
*/
filterOptions: _propTypes.default.func,
/**
* If `true`, hide the selected options from the list box.
* @default false
*/
filterSelectedOptions: _propTypes.default.bool,
/**
* Force the visibility display of the popup icon.
* @default 'auto'
*/
forcePopupIcon: _propTypes.default.oneOfType([_propTypes.default.oneOf(['auto']), _propTypes.default.bool]),
/**
* If `true`, the Autocomplete is free solo, meaning that the user input is not bound to provided options.
* @default false
*/
freeSolo: _propTypes.default.bool,
/**
* If `true`, the input will take up the full width of its container.
* @default false
*/
fullWidth: _propTypes.default.bool,
/**
* The label to display when the tags are truncated (`limitTags`).
*
* @param {number} more The number of truncated tags.
* @returns {ReactNode}
* @default (more) => `+${more}`
*/
getLimitTagsText: _propTypes.default.func,
/**
* Used to determine the disabled state for a given option.
*
* @param {T} option The option to test.
* @returns {boolean}
*/
getOptionDisabled: _propTypes.default.func,
/**
* Used to determine the string value for a given option.
* It's used to fill the input (and the list box options if `renderOption` is not provided).
*
* @param {T} option
* @returns {string}
* @default (option) => option.label ?? option
*/
getOptionLabel: _propTypes.default.func,
/**
* If provided, the options will be grouped under the returned string.
* The groupBy value is also used as the text for group headings when `renderGroup` is not provided.
*
* @param {T} options The options to group.
* @returns {string}
*/
groupBy: _propTypes.default.func,
/**
* If `true`, the component handles the "Home" and "End" keys when the popup is open.
* It should move focus to the first option and last option, respectively.
* @default !props.freeSolo
*/
handleHomeEndKeys: _propTypes.default.bool,
/**
* This prop is used to help implement the accessibility logic.
* If you don't provide an id it will fall back to a randomly generated one.
*/
id: _propTypes.default.string,
/**
* If `true`, the highlight can move to the input.
* @default false
*/
includeInputInList: _propTypes.default.bool,
/**
* The input value.
*/
inputValue: _propTypes.default.string,
/**
* Used to determine if the option represents the given value.
* Uses strict equality by default.
* ⚠️ Both arguments need to be handled, an option can only match with one value.
*
* @param {T} option The option to test.
* @param {T} value The value to test against.
* @returns {boolean}
*/
isOptionEqualToValue: _propTypes.default.func,
/**
* The maximum number of tags that will be visible when not focused.
* Set `-1` to disable the limit.
* @default -1
*/
limitTags: _utils.integerPropType,
/**
* The component used to render the listbox.
* @default 'ul'
*/
ListboxComponent: _propTypes.default.elementType,
/**
* Props applied to the Listbox element.
*/
ListboxProps: _propTypes.default.object,
/**
* If `true`, the component is in a loading state.
* @default false
*/
loading: _propTypes.default.bool,
/**
* Text to display when in a loading state.
*
* For localization purposes, you can use the provided [translations](/guides/localization/).
* @default 'Loading…'
*/
loadingText: _propTypes.default.node,
/**
* If `true`, `value` must be an array and the menu will support multiple selections.
* @default false
*/
multiple: _propTypes.default.bool,
/**
* Text to display when there are no options.
*
* For localization purposes, you can use the provided [translations](/guides/localization/).
* @default 'No options'
*/
noOptionsText: _propTypes.default.node,
/**
* Callback fired when the value changes.
*
* @param {object} event The event source of the callback.
* @param {T|T[]} value The new value of the component.
* @param {string} reason One of "createOption", "selectOption", "removeOption", "blur" or "clear".
* @param {string} [details]
*/
onChange: _propTypes.default.func,
/**
* Callback fired when the popup requests to be closed.
* Use in controlled mode (see open).
*
* @param {object} event The event source of the callback.
* @param {string} reason Can be: `"toggleInput"`, `"escape"`, `"selectOption"`, `"removeOption"`, `"blur"`.
*/
onClose: _propTypes.default.func,
/**
* Callback fired when the highlight option changes.
*
* @param {object} event The event source of the callback.
* @param {T} option The highlighted option.
* @param {string} reason Can be: `"keyboard"`, `"auto"`, `"mouse"`.
*/
onHighlightChange: _propTypes.default.func,
/**
* Callback fired when the input value changes.
*
* @param {object} event The event source of the callback.
* @param {string} value The new value of the text input.
* @param {string} reason Can be: `"input"` (user input), `"reset"` (programmatic change), `"clear"`.
*/
onInputChange: _propTypes.default.func,
/**
* Callback fired when the popup requests to be opened.
* Use in controlled mode (see open).
*
* @param {object} event The event source of the callback.
*/
onOpen: _propTypes.default.func,
/**
* If `true`, the component is shown.
*/
open: _propTypes.default.bool,
/**
* If `true`, the popup will open on input focus.
* @default false
*/
openOnFocus: _propTypes.default.bool,
/**
* Override the default text for the *open popup* icon button.
*
* For localization purposes, you can use the provided [translations](/guides/localization/).
* @default 'Open'
*/
openText: _propTypes.default.string,
/**
* Array of options.
*/
options: _propTypes.default.array.isRequired,
/**
* The component used to render the body of the popup.
* @default Paper
*/
PaperComponent: _propTypes.default.elementType,
/**
* The component used to position the popup.
* @default Popper
*/
PopperComponent: _propTypes.default.elementType,
/**
* The icon to display in place of the default popup icon.
* @default <ArrowDropDownIcon />
*/
popupIcon: _propTypes.default.node,
/**
* Render the group.
*
* @param {any} option The group to render.
* @returns {ReactNode}
*/
renderGroup: _propTypes.default.func,
/**
* Render the input.
*
* @param {object} params
* @returns {ReactNode}
*/
renderInput: _propTypes.default.func.isRequired,
/**
* Render the option, use `getOptionLabel` by default.
*
* @param {object} props The props to apply on the li element.
* @param {T} option The option to render.
* @param {object} state The state of the component.
* @returns {ReactNode}
*/
renderOption: _propTypes.default.func,
/**
* Render the selected value.
*
* @param {T[]} value The `value` provided to the component.
* @param {function} getTagProps A tag props getter.
* @returns {ReactNode}
*/
renderTags: _propTypes.default.func,
/**
* If `true`, the input's text is selected on focus.
* It helps the user clear the selected value.
* @default !props.freeSolo
*/
selectOnFocus: _propTypes.default.bool,
/**
* The size of the component.
* @default 'medium'
*/
size: _propTypes.default
/* @typescript-to-proptypes-ignore */
.oneOfType([_propTypes.default.oneOf(['medium', 'small']), _propTypes.default.string]),
/**
* The system prop that allows defining system overrides as well as additional CSS styles.
*/
sx: _propTypes.default.object,
/**
* The value of the autocomplete.
*
* The value must have reference equality with the option in order to be selected.
* You can customize the equality behavior with the `isOptionEqualToValue` prop.
*/
value: (0, _utils.chainPropTypes)(_propTypes.default.any, props => {
if (props.multiple && props.value !== undefined && !Array.isArray(props.value)) {
return new Error(['Material-UI: The Autocomplete expects the `value` prop to be an array or undefined.', `However, ${props.value} was provided.`].join('\n'));
}
return null;
})
} : void 0;
var _default = Autocomplete;
exports.default = _default; |
typeof window !== "undefined" &&
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["Hls"] = factory();
else
root["Hls"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "/dist/";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = "./src/hls.ts");
/******/ })
/************************************************************************/
/******/ ({
/***/ "./node_modules/eventemitter3/index.js":
/*!*********************************************!*\
!*** ./node_modules/eventemitter3/index.js ***!
\*********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var has = Object.prototype.hasOwnProperty
, prefix = '~';
/**
* Constructor to create a storage for our `EE` objects.
* An `Events` instance is a plain object whose properties are event names.
*
* @constructor
* @private
*/
function Events() {}
//
// We try to not inherit from `Object.prototype`. In some engines creating an
// instance in this way is faster than calling `Object.create(null)` directly.
// If `Object.create(null)` is not supported we prefix the event names with a
// character to make sure that the built-in object properties are not
// overridden or used as an attack vector.
//
if (Object.create) {
Events.prototype = Object.create(null);
//
// This hack is needed because the `__proto__` property is still inherited in
// some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
//
if (!new Events().__proto__) prefix = false;
}
/**
* Representation of a single event listener.
*
* @param {Function} fn The listener function.
* @param {*} context The context to invoke the listener with.
* @param {Boolean} [once=false] Specify if the listener is a one-time listener.
* @constructor
* @private
*/
function EE(fn, context, once) {
this.fn = fn;
this.context = context;
this.once = once || false;
}
/**
* Add a listener for a given event.
*
* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} context The context to invoke the listener with.
* @param {Boolean} once Specify if the listener is a one-time listener.
* @returns {EventEmitter}
* @private
*/
function addListener(emitter, event, fn, context, once) {
if (typeof fn !== 'function') {
throw new TypeError('The listener must be a function');
}
var listener = new EE(fn, context || emitter, once)
, evt = prefix ? prefix + event : event;
if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
else emitter._events[evt] = [emitter._events[evt], listener];
return emitter;
}
/**
* Clear event by name.
*
* @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
* @param {(String|Symbol)} evt The Event name.
* @private
*/
function clearEvent(emitter, evt) {
if (--emitter._eventsCount === 0) emitter._events = new Events();
else delete emitter._events[evt];
}
/**
* Minimal `EventEmitter` interface that is molded against the Node.js
* `EventEmitter` interface.
*
* @constructor
* @public
*/
function EventEmitter() {
this._events = new Events();
this._eventsCount = 0;
}
/**
* Return an array listing the events for which the emitter has registered
* listeners.
*
* @returns {Array}
* @public
*/
EventEmitter.prototype.eventNames = function eventNames() {
var names = []
, events
, name;
if (this._eventsCount === 0) return names;
for (name in (events = this._events)) {
if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
}
if (Object.getOwnPropertySymbols) {
return names.concat(Object.getOwnPropertySymbols(events));
}
return names;
};
/**
* Return the listeners registered for a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Array} The registered listeners.
* @public
*/
EventEmitter.prototype.listeners = function listeners(event) {
var evt = prefix ? prefix + event : event
, handlers = this._events[evt];
if (!handlers) return [];
if (handlers.fn) return [handlers.fn];
for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
ee[i] = handlers[i].fn;
}
return ee;
};
/**
* Return the number of listeners listening to a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Number} The number of listeners.
* @public
*/
EventEmitter.prototype.listenerCount = function listenerCount(event) {
var evt = prefix ? prefix + event : event
, listeners = this._events[evt];
if (!listeners) return 0;
if (listeners.fn) return 1;
return listeners.length;
};
/**
* Calls each of the listeners registered for a given event.
*
* @param {(String|Symbol)} event The event name.
* @returns {Boolean} `true` if the event had listeners, else `false`.
* @public
*/
EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
var evt = prefix ? prefix + event : event;
if (!this._events[evt]) return false;
var listeners = this._events[evt]
, len = arguments.length
, args
, i;
if (listeners.fn) {
if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
switch (len) {
case 1: return listeners.fn.call(listeners.context), true;
case 2: return listeners.fn.call(listeners.context, a1), true;
case 3: return listeners.fn.call(listeners.context, a1, a2), true;
case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
}
for (i = 1, args = new Array(len -1); i < len; i++) {
args[i - 1] = arguments[i];
}
listeners.fn.apply(listeners.context, args);
} else {
var length = listeners.length
, j;
for (i = 0; i < length; i++) {
if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
switch (len) {
case 1: listeners[i].fn.call(listeners[i].context); break;
case 2: listeners[i].fn.call(listeners[i].context, a1); break;
case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
default:
if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
args[j - 1] = arguments[j];
}
listeners[i].fn.apply(listeners[i].context, args);
}
}
}
return true;
};
/**
* Add a listener for a given event.
*
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} [context=this] The context to invoke the listener with.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.on = function on(event, fn, context) {
return addListener(this, event, fn, context, false);
};
/**
* Add a one-time listener for a given event.
*
* @param {(String|Symbol)} event The event name.
* @param {Function} fn The listener function.
* @param {*} [context=this] The context to invoke the listener with.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.once = function once(event, fn, context) {
return addListener(this, event, fn, context, true);
};
/**
* Remove the listeners of a given event.
*
* @param {(String|Symbol)} event The event name.
* @param {Function} fn Only remove the listeners that match this function.
* @param {*} context Only remove the listeners that have this context.
* @param {Boolean} once Only remove one-time listeners.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
var evt = prefix ? prefix + event : event;
if (!this._events[evt]) return this;
if (!fn) {
clearEvent(this, evt);
return this;
}
var listeners = this._events[evt];
if (listeners.fn) {
if (
listeners.fn === fn &&
(!once || listeners.once) &&
(!context || listeners.context === context)
) {
clearEvent(this, evt);
}
} else {
for (var i = 0, events = [], length = listeners.length; i < length; i++) {
if (
listeners[i].fn !== fn ||
(once && !listeners[i].once) ||
(context && listeners[i].context !== context)
) {
events.push(listeners[i]);
}
}
//
// Reset the array, or remove it completely if we have no more listeners.
//
if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
else clearEvent(this, evt);
}
return this;
};
/**
* Remove all listeners, or those of the specified event.
*
* @param {(String|Symbol)} [event] The event name.
* @returns {EventEmitter} `this`.
* @public
*/
EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
var evt;
if (event) {
evt = prefix ? prefix + event : event;
if (this._events[evt]) clearEvent(this, evt);
} else {
this._events = new Events();
this._eventsCount = 0;
}
return this;
};
//
// Alias methods names because people roll like that.
//
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.addListener = EventEmitter.prototype.on;
//
// Expose the prefix.
//
EventEmitter.prefixed = prefix;
//
// Allow `EventEmitter` to be imported as module namespace.
//
EventEmitter.EventEmitter = EventEmitter;
//
// Expose the module.
//
if (true) {
module.exports = EventEmitter;
}
/***/ }),
/***/ "./node_modules/url-toolkit/src/url-toolkit.js":
/*!*****************************************************!*\
!*** ./node_modules/url-toolkit/src/url-toolkit.js ***!
\*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {
// see https://tools.ietf.org/html/rfc1808
(function (root) {
var URL_REGEX =
/^((?:[a-zA-Z0-9+\-.]+:)?)(\/\/[^\/?#]*)?((?:[^\/?#]*\/)*[^;?#]*)?(;[^?#]*)?(\?[^#]*)?(#[^]*)?$/;
var FIRST_SEGMENT_REGEX = /^([^\/?#]*)([^]*)$/;
var SLASH_DOT_REGEX = /(?:\/|^)\.(?=\/)/g;
var SLASH_DOT_DOT_REGEX = /(?:\/|^)\.\.\/(?!\.\.\/)[^\/]*(?=\/)/g;
var URLToolkit = {
// If opts.alwaysNormalize is true then the path will always be normalized even when it starts with / or //
// E.g
// With opts.alwaysNormalize = false (default, spec compliant)
// http://a.com/b/cd + /e/f/../g => http://a.com/e/f/../g
// With opts.alwaysNormalize = true (not spec compliant)
// http://a.com/b/cd + /e/f/../g => http://a.com/e/g
buildAbsoluteURL: function (baseURL, relativeURL, opts) {
opts = opts || {};
// remove any remaining space and CRLF
baseURL = baseURL.trim();
relativeURL = relativeURL.trim();
if (!relativeURL) {
// 2a) If the embedded URL is entirely empty, it inherits the
// entire base URL (i.e., is set equal to the base URL)
// and we are done.
if (!opts.alwaysNormalize) {
return baseURL;
}
var basePartsForNormalise = URLToolkit.parseURL(baseURL);
if (!basePartsForNormalise) {
throw new Error('Error trying to parse base URL.');
}
basePartsForNormalise.path = URLToolkit.normalizePath(
basePartsForNormalise.path
);
return URLToolkit.buildURLFromParts(basePartsForNormalise);
}
var relativeParts = URLToolkit.parseURL(relativeURL);
if (!relativeParts) {
throw new Error('Error trying to parse relative URL.');
}
if (relativeParts.scheme) {
// 2b) If the embedded URL starts with a scheme name, it is
// interpreted as an absolute URL and we are done.
if (!opts.alwaysNormalize) {
return relativeURL;
}
relativeParts.path = URLToolkit.normalizePath(relativeParts.path);
return URLToolkit.buildURLFromParts(relativeParts);
}
var baseParts = URLToolkit.parseURL(baseURL);
if (!baseParts) {
throw new Error('Error trying to parse base URL.');
}
if (!baseParts.netLoc && baseParts.path && baseParts.path[0] !== '/') {
// If netLoc missing and path doesn't start with '/', assume everthing before the first '/' is the netLoc
// This causes 'example.com/a' to be handled as '//example.com/a' instead of '/example.com/a'
var pathParts = FIRST_SEGMENT_REGEX.exec(baseParts.path);
baseParts.netLoc = pathParts[1];
baseParts.path = pathParts[2];
}
if (baseParts.netLoc && !baseParts.path) {
baseParts.path = '/';
}
var builtParts = {
// 2c) Otherwise, the embedded URL inherits the scheme of
// the base URL.
scheme: baseParts.scheme,
netLoc: relativeParts.netLoc,
path: null,
params: relativeParts.params,
query: relativeParts.query,
fragment: relativeParts.fragment,
};
if (!relativeParts.netLoc) {
// 3) If the embedded URL's <net_loc> is non-empty, we skip to
// Step 7. Otherwise, the embedded URL inherits the <net_loc>
// (if any) of the base URL.
builtParts.netLoc = baseParts.netLoc;
// 4) If the embedded URL path is preceded by a slash "/", the
// path is not relative and we skip to Step 7.
if (relativeParts.path[0] !== '/') {
if (!relativeParts.path) {
// 5) If the embedded URL path is empty (and not preceded by a
// slash), then the embedded URL inherits the base URL path
builtParts.path = baseParts.path;
// 5a) if the embedded URL's <params> is non-empty, we skip to
// step 7; otherwise, it inherits the <params> of the base
// URL (if any) and
if (!relativeParts.params) {
builtParts.params = baseParts.params;
// 5b) if the embedded URL's <query> is non-empty, we skip to
// step 7; otherwise, it inherits the <query> of the base
// URL (if any) and we skip to step 7.
if (!relativeParts.query) {
builtParts.query = baseParts.query;
}
}
} else {
// 6) The last segment of the base URL's path (anything
// following the rightmost slash "/", or the entire path if no
// slash is present) is removed and the embedded URL's path is
// appended in its place.
var baseURLPath = baseParts.path;
var newPath =
baseURLPath.substring(0, baseURLPath.lastIndexOf('/') + 1) +
relativeParts.path;
builtParts.path = URLToolkit.normalizePath(newPath);
}
}
}
if (builtParts.path === null) {
builtParts.path = opts.alwaysNormalize
? URLToolkit.normalizePath(relativeParts.path)
: relativeParts.path;
}
return URLToolkit.buildURLFromParts(builtParts);
},
parseURL: function (url) {
var parts = URL_REGEX.exec(url);
if (!parts) {
return null;
}
return {
scheme: parts[1] || '',
netLoc: parts[2] || '',
path: parts[3] || '',
params: parts[4] || '',
query: parts[5] || '',
fragment: parts[6] || '',
};
},
normalizePath: function (path) {
// The following operations are
// then applied, in order, to the new path:
// 6a) All occurrences of "./", where "." is a complete path
// segment, are removed.
// 6b) If the path ends with "." as a complete path segment,
// that "." is removed.
path = path.split('').reverse().join('').replace(SLASH_DOT_REGEX, '');
// 6c) All occurrences of "<segment>/../", where <segment> is a
// complete path segment not equal to "..", are removed.
// Removal of these path segments is performed iteratively,
// removing the leftmost matching pattern on each iteration,
// until no matching pattern remains.
// 6d) If the path ends with "<segment>/..", where <segment> is a
// complete path segment not equal to "..", that
// "<segment>/.." is removed.
while (
path.length !== (path = path.replace(SLASH_DOT_DOT_REGEX, '')).length
) {}
return path.split('').reverse().join('');
},
buildURLFromParts: function (parts) {
return (
parts.scheme +
parts.netLoc +
parts.path +
parts.params +
parts.query +
parts.fragment
);
},
};
if (true)
module.exports = URLToolkit;
else {}
})(this);
/***/ }),
/***/ "./node_modules/webworkify-webpack/index.js":
/*!**************************************************!*\
!*** ./node_modules/webworkify-webpack/index.js ***!
\**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {
function webpackBootstrapFunc (modules) {
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // identity function for calling harmony imports with the correct context
/******/ __webpack_require__.i = function(value) { return value; };
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "/";
/******/ // on error function for async loading
/******/ __webpack_require__.oe = function(err) { console.error(err); throw err; };
var f = __webpack_require__(__webpack_require__.s = ENTRY_MODULE)
return f.default || f // try to call default if defined to also support babel esmodule exports
}
var moduleNameReqExp = '[\\.|\\-|\\+|\\w|\/|@]+'
var dependencyRegExp = '\\(\\s*(\/\\*.*?\\*\/)?\\s*.*?(' + moduleNameReqExp + ').*?\\)' // additional chars when output.pathinfo is true
// http://stackoverflow.com/a/2593661/130442
function quoteRegExp (str) {
return (str + '').replace(/[.?*+^$[\]\\(){}|-]/g, '\\$&')
}
function isNumeric(n) {
return !isNaN(1 * n); // 1 * n converts integers, integers as string ("123"), 1e3 and "1e3" to integers and strings to NaN
}
function getModuleDependencies (sources, module, queueName) {
var retval = {}
retval[queueName] = []
var fnString = module.toString()
var wrapperSignature = fnString.match(/^function\s?\w*\(\w+,\s*\w+,\s*(\w+)\)/)
if (!wrapperSignature) return retval
var webpackRequireName = wrapperSignature[1]
// main bundle deps
var re = new RegExp('(\\\\n|\\W)' + quoteRegExp(webpackRequireName) + dependencyRegExp, 'g')
var match
while ((match = re.exec(fnString))) {
if (match[3] === 'dll-reference') continue
retval[queueName].push(match[3])
}
// dll deps
re = new RegExp('\\(' + quoteRegExp(webpackRequireName) + '\\("(dll-reference\\s(' + moduleNameReqExp + '))"\\)\\)' + dependencyRegExp, 'g')
while ((match = re.exec(fnString))) {
if (!sources[match[2]]) {
retval[queueName].push(match[1])
sources[match[2]] = __webpack_require__(match[1]).m
}
retval[match[2]] = retval[match[2]] || []
retval[match[2]].push(match[4])
}
// convert 1e3 back to 1000 - this can be important after uglify-js converted 1000 to 1e3
var keys = Object.keys(retval);
for (var i = 0; i < keys.length; i++) {
for (var j = 0; j < retval[keys[i]].length; j++) {
if (isNumeric(retval[keys[i]][j])) {
retval[keys[i]][j] = 1 * retval[keys[i]][j];
}
}
}
return retval
}
function hasValuesInQueues (queues) {
var keys = Object.keys(queues)
return keys.reduce(function (hasValues, key) {
return hasValues || queues[key].length > 0
}, false)
}
function getRequiredModules (sources, moduleId) {
var modulesQueue = {
main: [moduleId]
}
var requiredModules = {
main: []
}
var seenModules = {
main: {}
}
while (hasValuesInQueues(modulesQueue)) {
var queues = Object.keys(modulesQueue)
for (var i = 0; i < queues.length; i++) {
var queueName = queues[i]
var queue = modulesQueue[queueName]
var moduleToCheck = queue.pop()
seenModules[queueName] = seenModules[queueName] || {}
if (seenModules[queueName][moduleToCheck] || !sources[queueName][moduleToCheck]) continue
seenModules[queueName][moduleToCheck] = true
requiredModules[queueName] = requiredModules[queueName] || []
requiredModules[queueName].push(moduleToCheck)
var newModules = getModuleDependencies(sources, sources[queueName][moduleToCheck], queueName)
var newModulesKeys = Object.keys(newModules)
for (var j = 0; j < newModulesKeys.length; j++) {
modulesQueue[newModulesKeys[j]] = modulesQueue[newModulesKeys[j]] || []
modulesQueue[newModulesKeys[j]] = modulesQueue[newModulesKeys[j]].concat(newModules[newModulesKeys[j]])
}
}
}
return requiredModules
}
module.exports = function (moduleId, options) {
options = options || {}
var sources = {
main: __webpack_require__.m
}
var requiredModules = options.all ? { main: Object.keys(sources.main) } : getRequiredModules(sources, moduleId)
var src = ''
Object.keys(requiredModules).filter(function (m) { return m !== 'main' }).forEach(function (module) {
var entryModule = 0
while (requiredModules[module][entryModule]) {
entryModule++
}
requiredModules[module].push(entryModule)
sources[module][entryModule] = '(function(module, exports, __webpack_require__) { module.exports = __webpack_require__; })'
src = src + 'var ' + module + ' = (' + webpackBootstrapFunc.toString().replace('ENTRY_MODULE', JSON.stringify(entryModule)) + ')({' + requiredModules[module].map(function (id) { return '' + JSON.stringify(id) + ': ' + sources[module][id].toString() }).join(',') + '});\n'
})
src = src + 'new ((' + webpackBootstrapFunc.toString().replace('ENTRY_MODULE', JSON.stringify(moduleId)) + ')({' + requiredModules.main.map(function (id) { return '' + JSON.stringify(id) + ': ' + sources.main[id].toString() }).join(',') + '}))(self);'
var blob = new window.Blob([src], { type: 'text/javascript' })
if (options.bare) { return blob }
var URL = window.URL || window.webkitURL || window.mozURL || window.msURL
var workerUrl = URL.createObjectURL(blob)
var worker = new window.Worker(workerUrl)
worker.objectURL = workerUrl
return worker
}
/***/ }),
/***/ "./src/config.ts":
/*!***********************!*\
!*** ./src/config.ts ***!
\***********************/
/*! exports provided: hlsDefaultConfig, mergeConfig, enableStreamingMode */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hlsDefaultConfig", function() { return hlsDefaultConfig; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mergeConfig", function() { return mergeConfig; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "enableStreamingMode", function() { return enableStreamingMode; });
/* harmony import */ var _controller_abr_controller__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./controller/abr-controller */ "./src/controller/abr-controller.ts");
/* harmony import */ var _controller_audio_stream_controller__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./controller/audio-stream-controller */ "./src/controller/audio-stream-controller.ts");
/* harmony import */ var _controller_audio_track_controller__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./controller/audio-track-controller */ "./src/controller/audio-track-controller.ts");
/* harmony import */ var _controller_subtitle_stream_controller__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./controller/subtitle-stream-controller */ "./src/controller/subtitle-stream-controller.ts");
/* harmony import */ var _controller_subtitle_track_controller__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./controller/subtitle-track-controller */ "./src/controller/subtitle-track-controller.ts");
/* harmony import */ var _controller_buffer_controller__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./controller/buffer-controller */ "./src/controller/buffer-controller.ts");
/* harmony import */ var _controller_timeline_controller__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./controller/timeline-controller */ "./src/controller/timeline-controller.ts");
/* harmony import */ var _controller_cap_level_controller__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./controller/cap-level-controller */ "./src/controller/cap-level-controller.ts");
/* harmony import */ var _controller_fps_controller__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./controller/fps-controller */ "./src/controller/fps-controller.ts");
/* harmony import */ var _controller_eme_controller__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./controller/eme-controller */ "./src/controller/eme-controller.ts");
/* harmony import */ var _utils_xhr_loader__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./utils/xhr-loader */ "./src/utils/xhr-loader.ts");
/* harmony import */ var _utils_fetch_loader__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./utils/fetch-loader */ "./src/utils/fetch-loader.ts");
/* harmony import */ var _utils_cues__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./utils/cues */ "./src/utils/cues.ts");
/* harmony import */ var _utils_mediakeys_helper__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./utils/mediakeys-helper */ "./src/utils/mediakeys-helper.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./utils/logger */ "./src/utils/logger.ts");
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
// If possible, keep hlsDefaultConfig shallow
// It is cloned whenever a new Hls instance is created, by keeping the config
// shallow the properties are cloned, and we don't end up manipulating the default
var hlsDefaultConfig = _objectSpread(_objectSpread({
autoStartLoad: true,
// used by stream-controller
startPosition: -1,
// used by stream-controller
defaultAudioCodec: undefined,
// used by stream-controller
debug: false,
// used by logger
capLevelOnFPSDrop: false,
// used by fps-controller
capLevelToPlayerSize: false,
// used by cap-level-controller
initialLiveManifestSize: 1,
// used by stream-controller
maxBufferLength: 30,
// used by stream-controller
backBufferLength: Infinity,
// used by buffer-controller
maxBufferSize: 60 * 1000 * 1000,
// used by stream-controller
maxBufferHole: 0.1,
// used by stream-controller
highBufferWatchdogPeriod: 2,
// used by stream-controller
nudgeOffset: 0.1,
// used by stream-controller
nudgeMaxRetry: 3,
// used by stream-controller
maxFragLookUpTolerance: 0.25,
// used by stream-controller
liveSyncDurationCount: 3,
// used by latency-controller
liveMaxLatencyDurationCount: Infinity,
// used by latency-controller
liveSyncDuration: undefined,
// used by latency-controller
liveMaxLatencyDuration: undefined,
// used by latency-controller
maxLiveSyncPlaybackRate: 1,
// used by latency-controller
liveDurationInfinity: false,
// used by buffer-controller
liveBackBufferLength: null,
// used by buffer-controller
maxMaxBufferLength: 600,
// used by stream-controller
enableWorker: true,
// used by demuxer
enableSoftwareAES: true,
// used by decrypter
manifestLoadingTimeOut: 10000,
// used by playlist-loader
manifestLoadingMaxRetry: 1,
// used by playlist-loader
manifestLoadingRetryDelay: 1000,
// used by playlist-loader
manifestLoadingMaxRetryTimeout: 64000,
// used by playlist-loader
startLevel: undefined,
// used by level-controller
levelLoadingTimeOut: 10000,
// used by playlist-loader
levelLoadingMaxRetry: 4,
// used by playlist-loader
levelLoadingRetryDelay: 1000,
// used by playlist-loader
levelLoadingMaxRetryTimeout: 64000,
// used by playlist-loader
fragLoadingTimeOut: 20000,
// used by fragment-loader
fragLoadingMaxRetry: 6,
// used by fragment-loader
fragLoadingRetryDelay: 1000,
// used by fragment-loader
fragLoadingMaxRetryTimeout: 64000,
// used by fragment-loader
startFragPrefetch: false,
// used by stream-controller
fpsDroppedMonitoringPeriod: 5000,
// used by fps-controller
fpsDroppedMonitoringThreshold: 0.2,
// used by fps-controller
appendErrorMaxRetry: 3,
// used by buffer-controller
loader: _utils_xhr_loader__WEBPACK_IMPORTED_MODULE_10__["default"],
// loader: FetchLoader,
fLoader: undefined,
// used by fragment-loader
pLoader: undefined,
// used by playlist-loader
xhrSetup: undefined,
// used by xhr-loader
licenseXhrSetup: undefined,
// used by eme-controller
licenseResponseCallback: undefined,
// used by eme-controller
abrController: _controller_abr_controller__WEBPACK_IMPORTED_MODULE_0__["default"],
bufferController: _controller_buffer_controller__WEBPACK_IMPORTED_MODULE_5__["default"],
capLevelController: _controller_cap_level_controller__WEBPACK_IMPORTED_MODULE_7__["default"],
fpsController: _controller_fps_controller__WEBPACK_IMPORTED_MODULE_8__["default"],
stretchShortVideoTrack: false,
// used by mp4-remuxer
maxAudioFramesDrift: 1,
// used by mp4-remuxer
forceKeyFrameOnDiscontinuity: true,
// used by ts-demuxer
abrEwmaFastLive: 3,
// used by abr-controller
abrEwmaSlowLive: 9,
// used by abr-controller
abrEwmaFastVoD: 3,
// used by abr-controller
abrEwmaSlowVoD: 9,
// used by abr-controller
abrEwmaDefaultEstimate: 5e5,
// 500 kbps // used by abr-controller
abrBandWidthFactor: 0.95,
// used by abr-controller
abrBandWidthUpFactor: 0.7,
// used by abr-controller
abrMaxWithRealBitrate: false,
// used by abr-controller
maxStarvationDelay: 4,
// used by abr-controller
maxLoadingDelay: 4,
// used by abr-controller
minAutoBitrate: 0,
// used by hls
emeEnabled: false,
// used by eme-controller
widevineLicenseUrl: undefined,
// used by eme-controller
drmSystemOptions: {},
// used by eme-controller
requestMediaKeySystemAccessFunc: _utils_mediakeys_helper__WEBPACK_IMPORTED_MODULE_13__["requestMediaKeySystemAccess"],
// used by eme-controller
testBandwidth: true,
progressive: false,
lowLatencyMode: true
}, timelineConfig()), {}, {
subtitleStreamController: true ? _controller_subtitle_stream_controller__WEBPACK_IMPORTED_MODULE_3__["SubtitleStreamController"] : undefined,
subtitleTrackController: true ? _controller_subtitle_track_controller__WEBPACK_IMPORTED_MODULE_4__["default"] : undefined,
timelineController: true ? _controller_timeline_controller__WEBPACK_IMPORTED_MODULE_6__["TimelineController"] : undefined,
audioStreamController: true ? _controller_audio_stream_controller__WEBPACK_IMPORTED_MODULE_1__["default"] : undefined,
audioTrackController: true ? _controller_audio_track_controller__WEBPACK_IMPORTED_MODULE_2__["default"] : undefined,
emeController: true ? _controller_eme_controller__WEBPACK_IMPORTED_MODULE_9__["default"] : undefined
});
function timelineConfig() {
return {
cueHandler: _utils_cues__WEBPACK_IMPORTED_MODULE_12__["default"],
// used by timeline-controller
enableCEA708Captions: true,
// used by timeline-controller
enableWebVTT: true,
// used by timeline-controller
enableIMSC1: true,
// used by timeline-controller
captionsTextTrack1Label: 'English',
// used by timeline-controller
captionsTextTrack1LanguageCode: 'en',
// used by timeline-controller
captionsTextTrack2Label: 'Spanish',
// used by timeline-controller
captionsTextTrack2LanguageCode: 'es',
// used by timeline-controller
captionsTextTrack3Label: 'Unknown CC',
// used by timeline-controller
captionsTextTrack3LanguageCode: '',
// used by timeline-controller
captionsTextTrack4Label: 'Unknown CC',
// used by timeline-controller
captionsTextTrack4LanguageCode: '',
// used by timeline-controller
renderTextTracksNatively: true
};
}
function mergeConfig(defaultConfig, userConfig) {
if ((userConfig.liveSyncDurationCount || userConfig.liveMaxLatencyDurationCount) && (userConfig.liveSyncDuration || userConfig.liveMaxLatencyDuration)) {
throw new Error("Illegal hls.js config: don't mix up liveSyncDurationCount/liveMaxLatencyDurationCount and liveSyncDuration/liveMaxLatencyDuration");
}
if (userConfig.liveMaxLatencyDurationCount !== undefined && (userConfig.liveSyncDurationCount === undefined || userConfig.liveMaxLatencyDurationCount <= userConfig.liveSyncDurationCount)) {
throw new Error('Illegal hls.js config: "liveMaxLatencyDurationCount" must be greater than "liveSyncDurationCount"');
}
if (userConfig.liveMaxLatencyDuration !== undefined && (userConfig.liveSyncDuration === undefined || userConfig.liveMaxLatencyDuration <= userConfig.liveSyncDuration)) {
throw new Error('Illegal hls.js config: "liveMaxLatencyDuration" must be greater than "liveSyncDuration"');
}
return _extends({}, defaultConfig, userConfig);
}
function enableStreamingMode(config) {
var currentLoader = config.loader;
if (currentLoader !== _utils_fetch_loader__WEBPACK_IMPORTED_MODULE_11__["default"] && currentLoader !== _utils_xhr_loader__WEBPACK_IMPORTED_MODULE_10__["default"]) {
// If a developer has configured their own loader, respect that choice
_utils_logger__WEBPACK_IMPORTED_MODULE_14__["logger"].log('[config]: Custom loader detected, cannot enable progressive streaming');
config.progressive = false;
} else {
var canStreamProgressively = Object(_utils_fetch_loader__WEBPACK_IMPORTED_MODULE_11__["fetchSupported"])();
if (canStreamProgressively) {
config.loader = _utils_fetch_loader__WEBPACK_IMPORTED_MODULE_11__["default"];
config.progressive = true;
config.enableSoftwareAES = true;
_utils_logger__WEBPACK_IMPORTED_MODULE_14__["logger"].log('[config]: Progressive streaming enabled, using FetchLoader');
}
}
}
/***/ }),
/***/ "./src/controller/abr-controller.ts":
/*!******************************************!*\
!*** ./src/controller/abr-controller.ts ***!
\******************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _utils_ewma_bandwidth_estimator__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/ewma-bandwidth-estimator */ "./src/utils/ewma-bandwidth-estimator.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var AbrController = /*#__PURE__*/function () {
function AbrController(hls) {
this.hls = void 0;
this.lastLoadedFragLevel = 0;
this._nextAutoLevel = -1;
this.timer = void 0;
this.onCheck = this._abandonRulesCheck.bind(this);
this.fragCurrent = null;
this.partCurrent = null;
this.bitrateTestDelay = 0;
this.bwEstimator = void 0;
this.hls = hls;
var config = hls.config;
this.bwEstimator = new _utils_ewma_bandwidth_estimator__WEBPACK_IMPORTED_MODULE_1__["default"](config.abrEwmaSlowVoD, config.abrEwmaFastVoD, config.abrEwmaDefaultEstimate);
this.registerListeners();
}
var _proto = AbrController.prototype;
_proto.registerListeners = function registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_LOADING, this.onFragLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_LOADED, this.onFragLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_BUFFERED, this.onFragBuffered, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, this.onError, this);
};
_proto.unregisterListeners = function unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_LOADING, this.onFragLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_LOADED, this.onFragLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_BUFFERED, this.onFragBuffered, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, this.onError, this);
};
_proto.destroy = function destroy() {
this.unregisterListeners();
this.clearTimer(); // @ts-ignore
this.hls = this.onCheck = null;
this.fragCurrent = this.partCurrent = null;
};
_proto.onFragLoading = function onFragLoading(event, data) {
var frag = data.frag;
if (frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_5__["PlaylistLevelType"].MAIN) {
if (!this.timer) {
var _data$part;
this.fragCurrent = frag;
this.partCurrent = (_data$part = data.part) != null ? _data$part : null;
this.timer = self.setInterval(this.onCheck, 100);
}
}
};
_proto.onLevelLoaded = function onLevelLoaded(event, data) {
var config = this.hls.config;
if (data.details.live) {
this.bwEstimator.update(config.abrEwmaSlowLive, config.abrEwmaFastLive);
} else {
this.bwEstimator.update(config.abrEwmaSlowVoD, config.abrEwmaFastVoD);
}
}
/*
This method monitors the download rate of the current fragment, and will downswitch if that fragment will not load
quickly enough to prevent underbuffering
*/
;
_proto._abandonRulesCheck = function _abandonRulesCheck() {
var frag = this.fragCurrent,
part = this.partCurrent,
hls = this.hls;
var autoLevelEnabled = hls.autoLevelEnabled,
config = hls.config,
media = hls.media;
if (!frag || !media) {
return;
}
var stats = part ? part.stats : frag.stats;
var duration = part ? part.duration : frag.duration; // If loading has been aborted and not in lowLatencyMode, stop timer and return
if (stats.aborted) {
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].warn('frag loader destroy or aborted, disarm abandonRules');
this.clearTimer(); // reset forced auto level value so that next level will be selected
this._nextAutoLevel = -1;
return;
} // This check only runs if we're in ABR mode and actually playing
if (!autoLevelEnabled || media.paused || !media.playbackRate || !media.readyState) {
return;
}
var requestDelay = performance.now() - stats.loading.start;
var playbackRate = Math.abs(media.playbackRate); // In order to work with a stable bandwidth, only begin monitoring bandwidth after half of the fragment has been loaded
if (requestDelay <= 500 * duration / playbackRate) {
return;
}
var levels = hls.levels,
minAutoLevel = hls.minAutoLevel;
var level = levels[frag.level];
var expectedLen = stats.total || Math.max(stats.loaded, Math.round(duration * level.maxBitrate / 8));
var loadRate = Math.max(1, stats.bwEstimate ? stats.bwEstimate / 8 : stats.loaded * 1000 / requestDelay); // fragLoadDelay is an estimate of the time (in seconds) it will take to buffer the entire fragment
var fragLoadedDelay = (expectedLen - stats.loaded) / loadRate;
var pos = media.currentTime; // bufferStarvationDelay is an estimate of the amount time (in seconds) it will take to exhaust the buffer
var bufferStarvationDelay = (_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].bufferInfo(media, pos, config.maxBufferHole).end - pos) / playbackRate; // Attempt an emergency downswitch only if less than 2 fragment lengths are buffered, and the time to finish loading
// the current fragment is greater than the amount of buffer we have left
if (bufferStarvationDelay >= 2 * duration / playbackRate || fragLoadedDelay <= bufferStarvationDelay) {
return;
}
var fragLevelNextLoadedDelay = Number.POSITIVE_INFINITY;
var nextLoadLevel; // Iterate through lower level and try to find the largest one that avoids rebuffering
for (nextLoadLevel = frag.level - 1; nextLoadLevel > minAutoLevel; nextLoadLevel--) {
// compute time to load next fragment at lower level
// 0.8 : consider only 80% of current bw to be conservative
// 8 = bits per byte (bps/Bps)
var levelNextBitrate = levels[nextLoadLevel].maxBitrate;
fragLevelNextLoadedDelay = duration * levelNextBitrate / (8 * 0.8 * loadRate);
if (fragLevelNextLoadedDelay < bufferStarvationDelay) {
break;
}
} // Only emergency switch down if it takes less time to load a new fragment at lowest level instead of continuing
// to load the current one
if (fragLevelNextLoadedDelay >= fragLoadedDelay) {
return;
}
var bwEstimate = this.bwEstimator.getEstimate();
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].warn("Fragment " + frag.sn + (part ? ' part ' + part.index : '') + " of level " + frag.level + " is loading too slowly and will cause an underbuffer; aborting and switching to level " + nextLoadLevel + "\n Current BW estimate: " + (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(bwEstimate) ? (bwEstimate / 1024).toFixed(3) : 'Unknown') + " Kb/s\n Estimated load time for current fragment: " + fragLoadedDelay.toFixed(3) + " s\n Estimated load time for the next fragment: " + fragLevelNextLoadedDelay.toFixed(3) + " s\n Time to underbuffer: " + bufferStarvationDelay.toFixed(3) + " s");
hls.nextLoadLevel = nextLoadLevel;
this.bwEstimator.sample(requestDelay, stats.loaded);
this.clearTimer();
if (frag.loader) {
this.fragCurrent = this.partCurrent = null;
frag.loader.abort();
}
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_LOAD_EMERGENCY_ABORTED, {
frag: frag,
part: part,
stats: stats
});
};
_proto.onFragLoaded = function onFragLoaded(event, _ref) {
var frag = _ref.frag,
part = _ref.part;
if (frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_5__["PlaylistLevelType"].MAIN && Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(frag.sn)) {
var stats = part ? part.stats : frag.stats;
var duration = part ? part.duration : frag.duration; // stop monitoring bw once frag loaded
this.clearTimer(); // store level id after successful fragment load
this.lastLoadedFragLevel = frag.level; // reset forced auto level value so that next level will be selected
this._nextAutoLevel = -1; // compute level average bitrate
if (this.hls.config.abrMaxWithRealBitrate) {
var level = this.hls.levels[frag.level];
var loadedBytes = (level.loaded ? level.loaded.bytes : 0) + stats.loaded;
var loadedDuration = (level.loaded ? level.loaded.duration : 0) + duration;
level.loaded = {
bytes: loadedBytes,
duration: loadedDuration
};
level.realBitrate = Math.round(8 * loadedBytes / loadedDuration);
}
if (frag.bitrateTest) {
var fragBufferedData = {
stats: stats,
frag: frag,
part: part,
id: frag.type
};
this.onFragBuffered(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_BUFFERED, fragBufferedData);
frag.bitrateTest = false;
}
}
};
_proto.onFragBuffered = function onFragBuffered(event, data) {
var frag = data.frag,
part = data.part;
var stats = part ? part.stats : frag.stats;
if (stats.aborted) {
return;
} // Only count non-alt-audio frags which were actually buffered in our BW calculations
if (frag.type !== _types_loader__WEBPACK_IMPORTED_MODULE_5__["PlaylistLevelType"].MAIN || frag.sn === 'initSegment') {
return;
} // Use the difference between parsing and request instead of buffering and request to compute fragLoadingProcessing;
// rationale is that buffer appending only happens once media is attached. This can happen when config.startFragPrefetch
// is used. If we used buffering in that case, our BW estimate sample will be very large.
var processingMs = stats.parsing.end - stats.loading.start;
this.bwEstimator.sample(processingMs, stats.loaded);
stats.bwEstimate = this.bwEstimator.getEstimate();
if (frag.bitrateTest) {
this.bitrateTestDelay = processingMs / 1000;
} else {
this.bitrateTestDelay = 0;
}
};
_proto.onError = function onError(event, data) {
// stop timer in case of frag loading error
switch (data.details) {
case _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorDetails"].FRAG_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorDetails"].FRAG_LOAD_TIMEOUT:
this.clearTimer();
break;
default:
break;
}
};
_proto.clearTimer = function clearTimer() {
self.clearInterval(this.timer);
this.timer = undefined;
} // return next auto level
;
_proto.getNextABRAutoLevel = function getNextABRAutoLevel() {
var fragCurrent = this.fragCurrent,
partCurrent = this.partCurrent,
hls = this.hls;
var maxAutoLevel = hls.maxAutoLevel,
config = hls.config,
minAutoLevel = hls.minAutoLevel,
media = hls.media;
var currentFragDuration = partCurrent ? partCurrent.duration : fragCurrent ? fragCurrent.duration : 0;
var pos = media ? media.currentTime : 0; // playbackRate is the absolute value of the playback rate; if media.playbackRate is 0, we use 1 to load as
// if we're playing back at the normal rate.
var playbackRate = media && media.playbackRate !== 0 ? Math.abs(media.playbackRate) : 1.0;
var avgbw = this.bwEstimator ? this.bwEstimator.getEstimate() : config.abrEwmaDefaultEstimate; // bufferStarvationDelay is the wall-clock time left until the playback buffer is exhausted.
var bufferStarvationDelay = (_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].bufferInfo(media, pos, config.maxBufferHole).end - pos) / playbackRate; // First, look to see if we can find a level matching with our avg bandwidth AND that could also guarantee no rebuffering at all
var bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay, config.abrBandWidthFactor, config.abrBandWidthUpFactor);
if (bestLevel >= 0) {
return bestLevel;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].trace((bufferStarvationDelay ? 'rebuffering expected' : 'buffer is empty') + ", finding optimal quality level"); // not possible to get rid of rebuffering ... let's try to find level that will guarantee less than maxStarvationDelay of rebuffering
// if no matching level found, logic will return 0
var maxStarvationDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxStarvationDelay) : config.maxStarvationDelay;
var bwFactor = config.abrBandWidthFactor;
var bwUpFactor = config.abrBandWidthUpFactor;
if (!bufferStarvationDelay) {
// in case buffer is empty, let's check if previous fragment was loaded to perform a bitrate test
var bitrateTestDelay = this.bitrateTestDelay;
if (bitrateTestDelay) {
// if it is the case, then we need to adjust our max starvation delay using maxLoadingDelay config value
// max video loading delay used in automatic start level selection :
// in that mode ABR controller will ensure that video loading time (ie the time to fetch the first fragment at lowest quality level +
// the time to fetch the fragment at the appropriate quality level is less than ```maxLoadingDelay``` )
// cap maxLoadingDelay and ensure it is not bigger 'than bitrate test' frag duration
var maxLoadingDelay = currentFragDuration ? Math.min(currentFragDuration, config.maxLoadingDelay) : config.maxLoadingDelay;
maxStarvationDelay = maxLoadingDelay - bitrateTestDelay;
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].trace("bitrate test took " + Math.round(1000 * bitrateTestDelay) + "ms, set first fragment max fetchDuration to " + Math.round(1000 * maxStarvationDelay) + " ms"); // don't use conservative factor on bitrate test
bwFactor = bwUpFactor = 1;
}
}
bestLevel = this.findBestLevel(avgbw, minAutoLevel, maxAutoLevel, bufferStarvationDelay + maxStarvationDelay, bwFactor, bwUpFactor);
return Math.max(bestLevel, 0);
};
_proto.findBestLevel = function findBestLevel(currentBw, minAutoLevel, maxAutoLevel, maxFetchDuration, bwFactor, bwUpFactor) {
var _level$details;
var fragCurrent = this.fragCurrent,
partCurrent = this.partCurrent,
currentLevel = this.lastLoadedFragLevel;
var levels = this.hls.levels;
var level = levels[currentLevel];
var live = !!(level !== null && level !== void 0 && (_level$details = level.details) !== null && _level$details !== void 0 && _level$details.live);
var currentCodecSet = level === null || level === void 0 ? void 0 : level.codecSet;
var currentFragDuration = partCurrent ? partCurrent.duration : fragCurrent ? fragCurrent.duration : 0;
for (var i = maxAutoLevel; i >= minAutoLevel; i--) {
var levelInfo = levels[i];
if (!levelInfo || currentCodecSet && levelInfo.codecSet !== currentCodecSet) {
continue;
}
var levelDetails = levelInfo.details;
var avgDuration = (partCurrent ? levelDetails === null || levelDetails === void 0 ? void 0 : levelDetails.partTarget : levelDetails === null || levelDetails === void 0 ? void 0 : levelDetails.averagetargetduration) || currentFragDuration;
var adjustedbw = void 0; // follow algorithm captured from stagefright :
// https://android.googlesource.com/platform/frameworks/av/+/master/media/libstagefright/httplive/LiveSession.cpp
// Pick the highest bandwidth stream below or equal to estimated bandwidth.
// consider only 80% of the available bandwidth, but if we are switching up,
// be even more conservative (70%) to avoid overestimating and immediately
// switching back.
if (i <= currentLevel) {
adjustedbw = bwFactor * currentBw;
} else {
adjustedbw = bwUpFactor * currentBw;
}
var bitrate = levels[i].maxBitrate;
var fetchDuration = bitrate * avgDuration / adjustedbw;
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].trace("level/adjustedbw/bitrate/avgDuration/maxFetchDuration/fetchDuration: " + i + "/" + Math.round(adjustedbw) + "/" + bitrate + "/" + avgDuration + "/" + maxFetchDuration + "/" + fetchDuration); // if adjusted bw is greater than level bitrate AND
if (adjustedbw > bitrate && ( // fragment fetchDuration unknown OR live stream OR fragment fetchDuration less than max allowed fetch duration, then this level matches
// we don't account for max Fetch Duration for live streams, this is to avoid switching down when near the edge of live sliding window ...
// special case to support startLevel = -1 (bitrateTest) on live streams : in that case we should not exit loop so that findBestLevel will return -1
!fetchDuration || live && !this.bitrateTestDelay || fetchDuration < maxFetchDuration)) {
// as we are looping from highest to lowest, this will return the best achievable quality level
return i;
}
} // not enough time budget even with quality level 0 ... rebuffering might happen
return -1;
};
_createClass(AbrController, [{
key: "nextAutoLevel",
get: function get() {
var forcedAutoLevel = this._nextAutoLevel;
var bwEstimator = this.bwEstimator; // in case next auto level has been forced, and bw not available or not reliable, return forced value
if (forcedAutoLevel !== -1 && (!bwEstimator || !bwEstimator.canEstimate())) {
return forcedAutoLevel;
} // compute next level using ABR logic
var nextABRAutoLevel = this.getNextABRAutoLevel(); // if forced auto level has been defined, use it to cap ABR computed quality level
if (forcedAutoLevel !== -1) {
nextABRAutoLevel = Math.min(forcedAutoLevel, nextABRAutoLevel);
}
return nextABRAutoLevel;
},
set: function set(nextLevel) {
this._nextAutoLevel = nextLevel;
}
}]);
return AbrController;
}();
/* harmony default export */ __webpack_exports__["default"] = (AbrController);
/***/ }),
/***/ "./src/controller/audio-stream-controller.ts":
/*!***************************************************!*\
!*** ./src/controller/audio-stream-controller.ts ***!
\***************************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./base-stream-controller */ "./src/controller/base-stream-controller.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
/* harmony import */ var _fragment_tracker__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./fragment-tracker */ "./src/controller/fragment-tracker.ts");
/* harmony import */ var _types_level__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../types/level */ "./src/types/level.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
/* harmony import */ var _loader_fragment__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../loader/fragment */ "./src/loader/fragment.ts");
/* harmony import */ var _demux_chunk_cache__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../demux/chunk-cache */ "./src/demux/chunk-cache.ts");
/* harmony import */ var _demux_transmuxer_interface__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../demux/transmuxer-interface */ "./src/demux/transmuxer-interface.ts");
/* harmony import */ var _types_transmuxer__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../types/transmuxer */ "./src/types/transmuxer.ts");
/* harmony import */ var _fragment_finders__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./fragment-finders */ "./src/controller/fragment-finders.ts");
/* harmony import */ var _utils_discontinuities__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../utils/discontinuities */ "./src/utils/discontinuities.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var TICK_INTERVAL = 100; // how often to tick in ms
var AudioStreamController = /*#__PURE__*/function (_BaseStreamController) {
_inheritsLoose(AudioStreamController, _BaseStreamController);
function AudioStreamController(hls, fragmentTracker) {
var _this;
_this = _BaseStreamController.call(this, hls, fragmentTracker, '[audio-stream-controller]') || this;
_this.videoBuffer = null;
_this.videoTrackCC = -1;
_this.waitingVideoCC = -1;
_this.audioSwitch = false;
_this.trackId = -1;
_this.waitingData = null;
_this.mainDetails = null;
_this.bufferFlushed = false;
_this._registerListeners();
return _this;
}
var _proto = AudioStreamController.prototype;
_proto.onHandlerDestroying = function onHandlerDestroying() {
this._unregisterListeners();
this.mainDetails = null;
};
_proto._registerListeners = function _registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].AUDIO_TRACKS_UPDATED, this.onAudioTracksUpdated, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, this.onError, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_RESET, this.onBufferReset, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_CREATED, this.onBufferCreated, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_FLUSHED, this.onBufferFlushed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].INIT_PTS_FOUND, this.onInitPtsFound, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_BUFFERED, this.onFragBuffered, this);
};
_proto._unregisterListeners = function _unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].AUDIO_TRACKS_UPDATED, this.onAudioTracksUpdated, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, this.onError, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_RESET, this.onBufferReset, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_CREATED, this.onBufferCreated, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_FLUSHED, this.onBufferFlushed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].INIT_PTS_FOUND, this.onInitPtsFound, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_BUFFERED, this.onFragBuffered, this);
} // INIT_PTS_FOUND is triggered when the video track parsed in the stream-controller has a new PTS value
;
_proto.onInitPtsFound = function onInitPtsFound(event, _ref) {
var frag = _ref.frag,
id = _ref.id,
initPTS = _ref.initPTS;
// Always update the new INIT PTS
// Can change due level switch
if (id === 'main') {
var cc = frag.cc;
this.initPTS[frag.cc] = initPTS;
this.log("InitPTS for cc: " + cc + " found from main: " + initPTS);
this.videoTrackCC = cc; // If we are waiting, tick immediately to unblock audio fragment transmuxing
if (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_INIT_PTS) {
this.tick();
}
}
};
_proto.startLoad = function startLoad(startPosition) {
if (!this.levels) {
this.startPosition = startPosition;
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].STOPPED;
return;
}
var lastCurrentTime = this.lastCurrentTime;
this.stopLoad();
this.setInterval(TICK_INTERVAL);
this.fragLoadError = 0;
if (lastCurrentTime > 0 && startPosition === -1) {
this.log("Override startPosition with lastCurrentTime @" + lastCurrentTime.toFixed(3));
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
} else {
this.loadedmetadata = false;
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_TRACK;
}
this.nextLoadPosition = this.startPosition = this.lastCurrentTime = startPosition;
this.tick();
};
_proto.doTick = function doTick() {
switch (this.state) {
case _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE:
this.doTickIdle();
break;
case _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_TRACK:
{
var _levels$trackId;
var levels = this.levels,
trackId = this.trackId;
var details = levels === null || levels === void 0 ? void 0 : (_levels$trackId = levels[trackId]) === null || _levels$trackId === void 0 ? void 0 : _levels$trackId.details;
if (details) {
if (this.waitForCdnTuneIn(details)) {
break;
}
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_INIT_PTS;
}
break;
}
case _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].FRAG_LOADING_WAITING_RETRY:
{
var _this$media;
var now = performance.now();
var retryDate = this.retryDate; // if current time is gt than retryDate, or if media seeking let's switch to IDLE state to retry loading
if (!retryDate || now >= retryDate || (_this$media = this.media) !== null && _this$media !== void 0 && _this$media.seeking) {
this.log('RetryDate reached, switch back to IDLE state');
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
}
break;
}
case _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_INIT_PTS:
{
// Ensure we don't get stuck in the WAITING_INIT_PTS state if the waiting frag CC doesn't match any initPTS
var waitingData = this.waitingData;
if (waitingData) {
var frag = waitingData.frag,
part = waitingData.part,
cache = waitingData.cache,
complete = waitingData.complete;
if (this.initPTS[frag.cc] !== undefined) {
this.waitingData = null;
this.waitingVideoCC = -1;
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].FRAG_LOADING;
var payload = cache.flush();
var data = {
frag: frag,
part: part,
payload: payload,
networkDetails: null
};
this._handleFragmentLoadProgress(data);
if (complete) {
_BaseStreamController.prototype._handleFragmentLoadComplete.call(this, data);
}
} else if (this.videoTrackCC !== this.waitingVideoCC) {
// Drop waiting fragment if videoTrackCC has changed since waitingFragment was set and initPTS was not found
_utils_logger__WEBPACK_IMPORTED_MODULE_14__["logger"].log("Waiting fragment cc (" + frag.cc + ") cancelled because video is at cc " + this.videoTrackCC);
this.clearWaitingFragment();
} else {
// Drop waiting fragment if an earlier fragment is needed
var pos = this.getLoadPosition();
var bufferInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].bufferInfo(this.mediaBuffer, pos, this.config.maxBufferHole);
var waitingFragmentAtPosition = Object(_fragment_finders__WEBPACK_IMPORTED_MODULE_11__["fragmentWithinToleranceTest"])(bufferInfo.end, this.config.maxFragLookUpTolerance, frag);
if (waitingFragmentAtPosition < 0) {
_utils_logger__WEBPACK_IMPORTED_MODULE_14__["logger"].log("Waiting fragment cc (" + frag.cc + ") @ " + frag.start + " cancelled because another fragment at " + bufferInfo.end + " is needed");
this.clearWaitingFragment();
}
}
} else {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
}
}
}
this.onTickEnd();
};
_proto.clearWaitingFragment = function clearWaitingFragment() {
var waitingData = this.waitingData;
if (waitingData) {
this.fragmentTracker.removeFragment(waitingData.frag);
this.waitingData = null;
this.waitingVideoCC = -1;
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
}
};
_proto.onTickEnd = function onTickEnd() {
var media = this.media;
if (!media || !media.readyState) {
// Exit early if we don't have media or if the media hasn't buffered anything yet (readyState 0)
return;
}
var mediaBuffer = this.mediaBuffer ? this.mediaBuffer : media;
var buffered = mediaBuffer.buffered;
if (!this.loadedmetadata && buffered.length) {
this.loadedmetadata = true;
}
this.lastCurrentTime = media.currentTime;
};
_proto.doTickIdle = function doTickIdle() {
var _frag$decryptdata, _frag$decryptdata2;
var hls = this.hls,
levels = this.levels,
media = this.media,
trackId = this.trackId;
var config = hls.config;
if (!levels || !levels[trackId]) {
return;
} // if video not attached AND
// start fragment already requested OR start frag prefetch not enabled
// exit loop
// => if media not attached but start frag prefetch is enabled and start frag not requested yet, we will not exit loop
if (!media && (this.startFragRequested || !config.startFragPrefetch)) {
return;
}
var levelInfo = levels[trackId];
var trackDetails = levelInfo.details;
if (!trackDetails || trackDetails.live && this.levelLastLoaded !== trackId || this.waitForCdnTuneIn(trackDetails)) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_TRACK;
return;
}
if (this.bufferFlushed) {
this.bufferFlushed = false;
this.afterBufferFlushed(this.mediaBuffer ? this.mediaBuffer : this.media, _loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].AUDIO, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].AUDIO);
}
var bufferInfo = this.getFwdBufferInfo(this.mediaBuffer ? this.mediaBuffer : this.media, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].AUDIO);
if (bufferInfo === null) {
return;
}
var bufferLen = bufferInfo.len;
var maxBufLen = this.getMaxBufferLength();
var audioSwitch = this.audioSwitch; // if buffer length is less than maxBufLen try to load a new fragment
if (bufferLen >= maxBufLen && !audioSwitch) {
return;
}
if (!audioSwitch && this._streamEnded(bufferInfo, trackDetails)) {
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_EOS, {
type: 'audio'
});
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].ENDED;
return;
}
var fragments = trackDetails.fragments;
var start = fragments[0].start;
var targetBufferTime = bufferInfo.end;
if (audioSwitch) {
var pos = this.getLoadPosition();
targetBufferTime = pos; // if currentTime (pos) is less than alt audio playlist start time, it means that alt audio is ahead of currentTime
if (trackDetails.PTSKnown && pos < start) {
// if everything is buffered from pos to start or if audio buffer upfront, let's seek to start
if (bufferInfo.end > start || bufferInfo.nextStart) {
this.log('Alt audio track ahead of main track, seek to start of alt audio track');
media.currentTime = start + 0.05;
}
}
}
var frag = this.getNextFragment(targetBufferTime, trackDetails);
if (!frag) {
this.bufferFlushed = true;
return;
}
if (((_frag$decryptdata = frag.decryptdata) === null || _frag$decryptdata === void 0 ? void 0 : _frag$decryptdata.keyFormat) === 'identity' && !((_frag$decryptdata2 = frag.decryptdata) !== null && _frag$decryptdata2 !== void 0 && _frag$decryptdata2.key)) {
this.loadKey(frag, trackDetails);
} else {
this.loadFragment(frag, trackDetails, targetBufferTime);
}
};
_proto.getMaxBufferLength = function getMaxBufferLength() {
var maxConfigBuffer = _BaseStreamController.prototype.getMaxBufferLength.call(this);
var mainBufferInfo = this.getFwdBufferInfo(this.videoBuffer ? this.videoBuffer : this.media, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN);
if (mainBufferInfo === null) {
return maxConfigBuffer;
}
return Math.max(maxConfigBuffer, mainBufferInfo.len);
};
_proto.onMediaDetaching = function onMediaDetaching() {
this.videoBuffer = null;
_BaseStreamController.prototype.onMediaDetaching.call(this);
};
_proto.onAudioTracksUpdated = function onAudioTracksUpdated(event, _ref2) {
var audioTracks = _ref2.audioTracks;
this.resetTransmuxer();
this.levels = audioTracks.map(function (mediaPlaylist) {
return new _types_level__WEBPACK_IMPORTED_MODULE_5__["Level"](mediaPlaylist);
});
};
_proto.onAudioTrackSwitching = function onAudioTrackSwitching(event, data) {
// if any URL found on new audio track, it is an alternate audio track
var altAudio = !!data.url;
this.trackId = data.id;
var fragCurrent = this.fragCurrent;
if (fragCurrent !== null && fragCurrent !== void 0 && fragCurrent.loader) {
fragCurrent.loader.abort();
}
this.fragCurrent = null;
this.clearWaitingFragment(); // destroy useless transmuxer when switching audio to main
if (!altAudio) {
this.resetTransmuxer();
} else {
// switching to audio track, start timer if not already started
this.setInterval(TICK_INTERVAL);
} // should we switch tracks ?
if (altAudio) {
this.audioSwitch = true; // main audio track are handled by stream-controller, just do something if switching to alt audio track
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
} else {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].STOPPED;
}
this.tick();
};
_proto.onManifestLoading = function onManifestLoading() {
this.mainDetails = null;
this.fragmentTracker.removeAllFragments();
this.startPosition = this.lastCurrentTime = 0;
this.bufferFlushed = false;
};
_proto.onLevelLoaded = function onLevelLoaded(event, data) {
this.mainDetails = data.details;
};
_proto.onAudioTrackLoaded = function onAudioTrackLoaded(event, data) {
var _track$details;
var levels = this.levels;
var newDetails = data.details,
trackId = data.id;
if (!levels) {
this.warn("Audio tracks were reset while loading level " + trackId);
return;
}
this.log("Track " + trackId + " loaded [" + newDetails.startSN + "," + newDetails.endSN + "],duration:" + newDetails.totalduration);
var track = levels[trackId];
var sliding = 0;
if (newDetails.live || (_track$details = track.details) !== null && _track$details !== void 0 && _track$details.live) {
var mainDetails = this.mainDetails;
if (!newDetails.fragments[0]) {
newDetails.deltaUpdateFailed = true;
}
if (newDetails.deltaUpdateFailed || !mainDetails) {
return;
}
if (!track.details && newDetails.hasProgramDateTime && mainDetails.hasProgramDateTime) {
// Make sure our audio rendition is aligned with the "main" rendition, using
// pdt as our reference times.
Object(_utils_discontinuities__WEBPACK_IMPORTED_MODULE_12__["alignMediaPlaylistByPDT"])(newDetails, mainDetails);
sliding = newDetails.fragments[0].start;
} else {
sliding = this.alignPlaylists(newDetails, track.details);
}
}
track.details = newDetails;
this.levelLastLoaded = trackId; // compute start position if we are aligned with the main playlist
if (!this.startFragRequested && (this.mainDetails || !newDetails.live)) {
this.setStartPosition(track.details, sliding);
} // only switch back to IDLE state if we were waiting for track to start downloading a new fragment
if (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_TRACK && !this.waitForCdnTuneIn(newDetails)) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
} // trigger handler right now
this.tick();
};
_proto._handleFragmentLoadProgress = function _handleFragmentLoadProgress(data) {
var _frag$initSegment;
var frag = data.frag,
part = data.part,
payload = data.payload;
var config = this.config,
trackId = this.trackId,
levels = this.levels;
if (!levels) {
this.warn("Audio tracks were reset while fragment load was in progress. Fragment " + frag.sn + " of level " + frag.level + " will not be buffered");
return;
}
var track = levels[trackId];
console.assert(track, 'Audio track is defined on fragment load progress');
var details = track.details;
console.assert(details, 'Audio track details are defined on fragment load progress');
var audioCodec = config.defaultAudioCodec || track.audioCodec || 'mp4a.40.2';
var transmuxer = this.transmuxer;
if (!transmuxer) {
transmuxer = this.transmuxer = new _demux_transmuxer_interface__WEBPACK_IMPORTED_MODULE_9__["default"](this.hls, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].AUDIO, this._handleTransmuxComplete.bind(this), this._handleTransmuxerFlush.bind(this));
} // Check if we have video initPTS
// If not we need to wait for it
var initPTS = this.initPTS[frag.cc];
var initSegmentData = (_frag$initSegment = frag.initSegment) === null || _frag$initSegment === void 0 ? void 0 : _frag$initSegment.data;
if (initPTS !== undefined) {
// this.log(`Transmuxing ${sn} of [${details.startSN} ,${details.endSN}],track ${trackId}`);
// time Offset is accurate if level PTS is known, or if playlist is not sliding (not live)
var accurateTimeOffset = false; // details.PTSKnown || !details.live;
var partIndex = part ? part.index : -1;
var partial = partIndex !== -1;
var chunkMeta = new _types_transmuxer__WEBPACK_IMPORTED_MODULE_10__["ChunkMetadata"](frag.level, frag.sn, frag.stats.chunkCount, payload.byteLength, partIndex, partial);
transmuxer.push(payload, initSegmentData, audioCodec, '', frag, part, details.totalduration, accurateTimeOffset, chunkMeta, initPTS);
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_14__["logger"].log("Unknown video PTS for cc " + frag.cc + ", waiting for video PTS before demuxing audio frag " + frag.sn + " of [" + details.startSN + " ," + details.endSN + "],track " + trackId);
var _this$waitingData = this.waitingData = this.waitingData || {
frag: frag,
part: part,
cache: new _demux_chunk_cache__WEBPACK_IMPORTED_MODULE_8__["default"](),
complete: false
},
cache = _this$waitingData.cache;
cache.push(new Uint8Array(payload));
this.waitingVideoCC = this.videoTrackCC;
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_INIT_PTS;
}
};
_proto._handleFragmentLoadComplete = function _handleFragmentLoadComplete(fragLoadedData) {
if (this.waitingData) {
this.waitingData.complete = true;
return;
}
_BaseStreamController.prototype._handleFragmentLoadComplete.call(this, fragLoadedData);
};
_proto.onBufferReset = function onBufferReset() {
// reset reference to sourcebuffers
this.mediaBuffer = this.videoBuffer = null;
this.loadedmetadata = false;
};
_proto.onBufferCreated = function onBufferCreated(event, data) {
var audioTrack = data.tracks.audio;
if (audioTrack) {
this.mediaBuffer = audioTrack.buffer;
}
if (data.tracks.video) {
this.videoBuffer = data.tracks.video.buffer;
}
};
_proto.onFragBuffered = function onFragBuffered(event, data) {
var frag = data.frag,
part = data.part;
if (frag.type !== _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].AUDIO) {
return;
}
if (this.fragContextChanged(frag)) {
// If a level switch was requested while a fragment was buffering, it will emit the FRAG_BUFFERED event upon completion
// Avoid setting state back to IDLE or concluding the audio switch; otherwise, the switched-to track will not buffer
this.warn("Fragment " + frag.sn + (part ? ' p: ' + part.index : '') + " of level " + frag.level + " finished buffering, but was aborted. state: " + this.state + ", audioSwitch: " + this.audioSwitch);
return;
}
if (frag.sn !== 'initSegment') {
this.fragPrevious = frag;
if (this.audioSwitch) {
this.audioSwitch = false;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].AUDIO_TRACK_SWITCHED, {
id: this.trackId
});
}
}
this.fragBufferedComplete(frag, part);
};
_proto.onError = function onError(event, data) {
switch (data.details) {
case _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"].FRAG_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"].FRAG_LOAD_TIMEOUT:
case _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"].KEY_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"].KEY_LOAD_TIMEOUT:
// TODO: Skip fragments that do not belong to this.fragCurrent audio-group id
this.onFragmentOrKeyLoadError(_types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].AUDIO, data);
break;
case _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"].AUDIO_TRACK_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"].AUDIO_TRACK_LOAD_TIMEOUT:
// when in ERROR state, don't switch back to IDLE state in case a non-fatal error is received
if (this.state !== _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].ERROR && this.state !== _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].STOPPED) {
// if fatal error, stop processing, otherwise move to IDLE to retry loading
this.state = data.fatal ? _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].ERROR : _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
this.warn(data.details + " while loading frag, switching to " + this.state + " state");
}
break;
case _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"].BUFFER_FULL_ERROR:
// if in appending state
if (data.parent === 'audio' && (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSING || this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSED)) {
var flushBuffer = true;
var bufferedInfo = this.getFwdBufferInfo(this.mediaBuffer, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].AUDIO); // 0.5 : tolerance needed as some browsers stalls playback before reaching buffered end
// reduce max buf len if current position is buffered
if (bufferedInfo && bufferedInfo.len > 0.5) {
flushBuffer = !this.reduceMaxBufferLength(bufferedInfo.len);
}
if (flushBuffer) {
// current position is not buffered, but browser is still complaining about buffer full error
// this happens on IE/Edge, refer to https://github.com/video-dev/hls.js/pull/708
// in that case flush the whole audio buffer to recover
this.warn('Buffer full error also media.currentTime is not buffered, flush audio buffer');
this.fragCurrent = null;
_BaseStreamController.prototype.flushMainBuffer.call(this, 0, Number.POSITIVE_INFINITY, 'audio');
}
this.resetLoadingState();
}
break;
default:
break;
}
};
_proto.onBufferFlushed = function onBufferFlushed(event, _ref3) {
var type = _ref3.type;
if (type === _loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].AUDIO) {
this.bufferFlushed = true;
}
};
_proto._handleTransmuxComplete = function _handleTransmuxComplete(transmuxResult) {
var _id3$samples;
var id = 'audio';
var hls = this.hls;
var remuxResult = transmuxResult.remuxResult,
chunkMeta = transmuxResult.chunkMeta;
var context = this.getCurrentContext(chunkMeta);
if (!context) {
this.warn("The loading context changed while buffering fragment " + chunkMeta.sn + " of level " + chunkMeta.level + ". This chunk will not be buffered.");
this.resetLiveStartWhenNotLoaded(chunkMeta.level);
return;
}
var frag = context.frag,
part = context.part;
var audio = remuxResult.audio,
text = remuxResult.text,
id3 = remuxResult.id3,
initSegment = remuxResult.initSegment; // Check if the current fragment has been aborted. We check this by first seeing if we're still playing the current level.
// If we are, subsequently check if the currently loading fragment (fragCurrent) has changed.
if (this.fragContextChanged(frag)) {
return;
}
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSING;
if (this.audioSwitch && audio) {
this.completeAudioSwitch();
}
if (initSegment !== null && initSegment !== void 0 && initSegment.tracks) {
this._bufferInitSegment(initSegment.tracks, frag, chunkMeta);
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_PARSING_INIT_SEGMENT, {
frag: frag,
id: id,
tracks: initSegment.tracks
}); // Only flush audio from old audio tracks when PTS is known on new audio track
}
if (audio) {
var startPTS = audio.startPTS,
endPTS = audio.endPTS,
startDTS = audio.startDTS,
endDTS = audio.endDTS;
if (part) {
part.elementaryStreams[_loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].AUDIO] = {
startPTS: startPTS,
endPTS: endPTS,
startDTS: startDTS,
endDTS: endDTS
};
}
frag.setElementaryStreamInfo(_loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].AUDIO, startPTS, endPTS, startDTS, endDTS);
this.bufferFragmentData(audio, frag, part, chunkMeta);
}
if (id3 !== null && id3 !== void 0 && (_id3$samples = id3.samples) !== null && _id3$samples !== void 0 && _id3$samples.length) {
var emittedID3 = _extends({
frag: frag,
id: id
}, id3);
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_PARSING_METADATA, emittedID3);
}
if (text) {
var emittedText = _extends({
frag: frag,
id: id
}, text);
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].FRAG_PARSING_USERDATA, emittedText);
}
};
_proto._bufferInitSegment = function _bufferInitSegment(tracks, frag, chunkMeta) {
if (this.state !== _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSING) {
return;
} // delete any video track found on audio transmuxer
if (tracks.video) {
delete tracks.video;
} // include levelCodec in audio and video tracks
var track = tracks.audio;
if (!track) {
return;
}
track.levelCodec = track.codec;
track.id = 'audio';
this.log("Init audio buffer, container:" + track.container + ", codecs[parsed]=[" + track.codec + "]");
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_CODECS, tracks);
var initSegment = track.initSegment;
if (initSegment !== null && initSegment !== void 0 && initSegment.byteLength) {
var segment = {
type: 'audio',
frag: frag,
part: null,
chunkMeta: chunkMeta,
parent: frag.type,
data: initSegment
};
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].BUFFER_APPENDING, segment);
} // trigger handler right now
this.tick();
};
_proto.loadFragment = function loadFragment(frag, trackDetails, targetBufferTime) {
// only load if fragment is not loaded or if in audio switch
var fragState = this.fragmentTracker.getState(frag);
this.fragCurrent = frag; // we force a frag loading in audio switch as fragment tracker might not have evicted previous frags in case of quick audio switch
if (this.audioSwitch || fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_4__["FragmentState"].NOT_LOADED || fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_4__["FragmentState"].PARTIAL) {
if (frag.sn === 'initSegment') {
this._loadInitSegment(frag);
} else if (trackDetails.live && !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(this.initPTS[frag.cc])) {
this.log("Waiting for video PTS in continuity counter " + frag.cc + " of live stream before loading audio fragment " + frag.sn + " of level " + this.trackId);
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_INIT_PTS;
} else {
this.startFragRequested = true;
_BaseStreamController.prototype.loadFragment.call(this, frag, trackDetails, targetBufferTime);
}
}
};
_proto.completeAudioSwitch = function completeAudioSwitch() {
var hls = this.hls,
media = this.media,
trackId = this.trackId;
if (media) {
this.log('Switching audio track : flushing all audio');
_BaseStreamController.prototype.flushMainBuffer.call(this, 0, Number.POSITIVE_INFINITY, 'audio');
}
this.audioSwitch = false;
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].AUDIO_TRACK_SWITCHED, {
id: trackId
});
};
return AudioStreamController;
}(_base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["default"]);
/* harmony default export */ __webpack_exports__["default"] = (AudioStreamController);
/***/ }),
/***/ "./src/controller/audio-track-controller.ts":
/*!**************************************************!*\
!*** ./src/controller/audio-track-controller.ts ***!
\**************************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _base_playlist_controller__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./base-playlist-controller */ "./src/controller/base-playlist-controller.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var AudioTrackController = /*#__PURE__*/function (_BasePlaylistControll) {
_inheritsLoose(AudioTrackController, _BasePlaylistControll);
function AudioTrackController(hls) {
var _this;
_this = _BasePlaylistControll.call(this, hls, '[audio-track-controller]') || this;
_this.tracks = [];
_this.groupId = null;
_this.tracksInGroup = [];
_this.trackId = -1;
_this.trackName = '';
_this.selectDefaultTrack = true;
_this.registerListeners();
return _this;
}
var _proto = AudioTrackController.prototype;
_proto.registerListeners = function registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_LOADING, this.onLevelLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_SWITCHING, this.onLevelSwitching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, this.onError, this);
};
_proto.unregisterListeners = function unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_LOADING, this.onLevelLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_SWITCHING, this.onLevelSwitching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].AUDIO_TRACK_LOADED, this.onAudioTrackLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, this.onError, this);
};
_proto.destroy = function destroy() {
this.unregisterListeners();
this.tracks.length = 0;
this.tracksInGroup.length = 0;
_BasePlaylistControll.prototype.destroy.call(this);
};
_proto.onManifestLoading = function onManifestLoading() {
this.tracks = [];
this.groupId = null;
this.tracksInGroup = [];
this.trackId = -1;
this.trackName = '';
this.selectDefaultTrack = true;
};
_proto.onManifestParsed = function onManifestParsed(event, data) {
this.tracks = data.audioTracks || [];
};
_proto.onAudioTrackLoaded = function onAudioTrackLoaded(event, data) {
var id = data.id,
details = data.details;
var currentTrack = this.tracksInGroup[id];
if (!currentTrack) {
this.warn("Invalid audio track id " + id);
return;
}
var curDetails = currentTrack.details;
currentTrack.details = data.details;
this.log("audioTrack " + id + " loaded [" + details.startSN + "-" + details.endSN + "]");
if (id === this.trackId) {
this.retryCount = 0;
this.playlistLoaded(id, data, curDetails);
}
};
_proto.onLevelLoading = function onLevelLoading(event, data) {
this.switchLevel(data.level);
};
_proto.onLevelSwitching = function onLevelSwitching(event, data) {
this.switchLevel(data.level);
};
_proto.switchLevel = function switchLevel(levelIndex) {
var levelInfo = this.hls.levels[levelIndex];
if (!(levelInfo !== null && levelInfo !== void 0 && levelInfo.audioGroupIds)) {
return;
}
var audioGroupId = levelInfo.audioGroupIds[levelInfo.urlId];
if (this.groupId !== audioGroupId) {
this.groupId = audioGroupId;
var audioTracks = this.tracks.filter(function (track) {
return !audioGroupId || track.groupId === audioGroupId;
}); // Disable selectDefaultTrack if there are no default tracks
if (this.selectDefaultTrack && !audioTracks.some(function (track) {
return track.default;
})) {
this.selectDefaultTrack = false;
}
this.tracksInGroup = audioTracks;
var audioTracksUpdated = {
audioTracks: audioTracks
};
this.log("Updating audio tracks, " + audioTracks.length + " track(s) found in \"" + audioGroupId + "\" group-id");
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].AUDIO_TRACKS_UPDATED, audioTracksUpdated);
this.selectInitialTrack();
}
};
_proto.onError = function onError(event, data) {
_BasePlaylistControll.prototype.onError.call(this, event, data);
if (data.fatal || !data.context) {
return;
}
if (data.context.type === _types_loader__WEBPACK_IMPORTED_MODULE_3__["PlaylistContextType"].AUDIO_TRACK && data.context.id === this.trackId && data.context.groupId === this.groupId) {
this.retryLoadingOrFail(data);
}
};
_proto.setAudioTrack = function setAudioTrack(newId) {
var tracks = this.tracksInGroup; // check if level idx is valid
if (newId < 0 || newId >= tracks.length) {
this.warn('Invalid id passed to audio-track controller');
return;
} // stopping live reloading timer if any
this.clearTimer();
var lastTrack = tracks[this.trackId];
this.log("Now switching to audio-track index " + newId);
var track = tracks[newId];
var id = track.id,
_track$groupId = track.groupId,
groupId = _track$groupId === void 0 ? '' : _track$groupId,
name = track.name,
type = track.type,
url = track.url;
this.trackId = newId;
this.trackName = name;
this.selectDefaultTrack = false;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].AUDIO_TRACK_SWITCHING, {
id: id,
groupId: groupId,
name: name,
type: type,
url: url
}); // Do not reload track unless live
if (track.details && !track.details.live) {
return;
}
var hlsUrlParameters = this.switchParams(track.url, lastTrack === null || lastTrack === void 0 ? void 0 : lastTrack.details);
this.loadPlaylist(hlsUrlParameters);
};
_proto.selectInitialTrack = function selectInitialTrack() {
var audioTracks = this.tracksInGroup;
console.assert(audioTracks.length, 'Initial audio track should be selected when tracks are known');
var currentAudioTrackName = this.trackName;
var trackId = this.findTrackId(currentAudioTrackName) || this.findTrackId();
if (trackId !== -1) {
this.setAudioTrack(trackId);
} else {
this.warn("No track found for running audio group-ID: " + this.groupId);
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].AUDIO_TRACK_LOAD_ERROR,
fatal: true
});
}
};
_proto.findTrackId = function findTrackId(name) {
var audioTracks = this.tracksInGroup;
for (var i = 0; i < audioTracks.length; i++) {
var track = audioTracks[i];
if (!this.selectDefaultTrack || track.default) {
if (!name || name === track.name) {
return track.id;
}
}
}
return -1;
};
_proto.loadPlaylist = function loadPlaylist(hlsUrlParameters) {
var audioTrack = this.tracksInGroup[this.trackId];
if (this.shouldLoadTrack(audioTrack)) {
var id = audioTrack.id;
var groupId = audioTrack.groupId;
var url = audioTrack.url;
if (hlsUrlParameters) {
try {
url = hlsUrlParameters.addDirectives(url);
} catch (error) {
this.warn("Could not construct new URL with HLS Delivery Directives: " + error);
}
} // track not retrieved yet, or live playlist we need to (re)load it
this.log("loading audio-track playlist for id: " + id);
this.clearTimer();
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].AUDIO_TRACK_LOADING, {
url: url,
id: id,
groupId: groupId,
deliveryDirectives: hlsUrlParameters || null
});
}
};
_createClass(AudioTrackController, [{
key: "audioTracks",
get: function get() {
return this.tracksInGroup;
}
}, {
key: "audioTrack",
get: function get() {
return this.trackId;
},
set: function set(newId) {
// If audio track is selected from API then don't choose from the manifest default track
this.selectDefaultTrack = false;
this.setAudioTrack(newId);
}
}]);
return AudioTrackController;
}(_base_playlist_controller__WEBPACK_IMPORTED_MODULE_2__["default"]);
/* harmony default export */ __webpack_exports__["default"] = (AudioTrackController);
/***/ }),
/***/ "./src/controller/base-playlist-controller.ts":
/*!****************************************************!*\
!*** ./src/controller/base-playlist-controller.ts ***!
\****************************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return BasePlaylistController; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _types_level__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../types/level */ "./src/types/level.ts");
/* harmony import */ var _level_helper__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./level-helper */ "./src/controller/level-helper.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
var BasePlaylistController = /*#__PURE__*/function () {
function BasePlaylistController(hls, logPrefix) {
this.hls = void 0;
this.timer = -1;
this.canLoad = false;
this.retryCount = 0;
this.log = void 0;
this.warn = void 0;
this.log = _utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].log.bind(_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"], logPrefix + ":");
this.warn = _utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn.bind(_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"], logPrefix + ":");
this.hls = hls;
}
var _proto = BasePlaylistController.prototype;
_proto.destroy = function destroy() {
this.clearTimer(); // @ts-ignore
this.hls = this.log = this.warn = null;
};
_proto.onError = function onError(event, data) {
if (data.fatal && data.type === _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorTypes"].NETWORK_ERROR) {
this.clearTimer();
}
};
_proto.clearTimer = function clearTimer() {
clearTimeout(this.timer);
this.timer = -1;
};
_proto.startLoad = function startLoad() {
this.canLoad = true;
this.retryCount = 0;
this.loadPlaylist();
};
_proto.stopLoad = function stopLoad() {
this.canLoad = false;
this.clearTimer();
};
_proto.switchParams = function switchParams(playlistUri, previous) {
var renditionReports = previous === null || previous === void 0 ? void 0 : previous.renditionReports;
if (renditionReports) {
for (var i = 0; i < renditionReports.length; i++) {
var attr = renditionReports[i];
var uri = '' + attr.URI;
if (uri === playlistUri.substr(-uri.length)) {
var msn = parseInt(attr['LAST-MSN']);
var part = parseInt(attr['LAST-PART']);
if (previous && this.hls.config.lowLatencyMode) {
var currentGoal = Math.min(previous.age - previous.partTarget, previous.targetduration);
if (part !== undefined && currentGoal > previous.partTarget) {
part += 1;
}
}
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(msn)) {
return new _types_level__WEBPACK_IMPORTED_MODULE_1__["HlsUrlParameters"](msn, Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(part) ? part : undefined, _types_level__WEBPACK_IMPORTED_MODULE_1__["HlsSkip"].No);
}
}
}
}
};
_proto.loadPlaylist = function loadPlaylist(hlsUrlParameters) {};
_proto.shouldLoadTrack = function shouldLoadTrack(track) {
return this.canLoad && track && !!track.url && (!track.details || track.details.live);
};
_proto.playlistLoaded = function playlistLoaded(index, data, previousDetails) {
var _this = this;
var details = data.details,
stats = data.stats; // Set last updated date-time
var elapsed = stats.loading.end ? Math.max(0, self.performance.now() - stats.loading.end) : 0;
details.advancedDateTime = Date.now() - elapsed; // if current playlist is a live playlist, arm a timer to reload it
if (details.live || previousDetails !== null && previousDetails !== void 0 && previousDetails.live) {
details.reloaded(previousDetails);
if (previousDetails) {
this.log("live playlist " + index + " " + (details.advanced ? 'REFRESHED ' + details.lastPartSn + '-' + details.lastPartIndex : 'MISSED'));
} // Merge live playlists to adjust fragment starts and fill in delta playlist skipped segments
if (previousDetails && details.fragments.length > 0) {
Object(_level_helper__WEBPACK_IMPORTED_MODULE_2__["mergeDetails"])(previousDetails, details);
}
if (!this.canLoad || !details.live) {
return;
}
var deliveryDirectives;
var msn = undefined;
var part = undefined;
if (details.canBlockReload && details.endSN && details.advanced) {
// Load level with LL-HLS delivery directives
var lowLatencyMode = this.hls.config.lowLatencyMode;
var lastPartSn = details.lastPartSn;
var endSn = details.endSN;
var lastPartIndex = details.lastPartIndex;
var hasParts = lastPartIndex !== -1;
var lastPart = lastPartSn === endSn; // When low latency mode is disabled, we'll skip part requests once the last part index is found
var nextSnStartIndex = lowLatencyMode ? 0 : lastPartIndex;
if (hasParts) {
msn = lastPart ? endSn + 1 : lastPartSn;
part = lastPart ? nextSnStartIndex : lastPartIndex + 1;
} else {
msn = endSn + 1;
} // Low-Latency CDN Tune-in: "age" header and time since load indicates we're behind by more than one part
// Update directives to obtain the Playlist that has the estimated additional duration of media
var lastAdvanced = details.age;
var cdnAge = lastAdvanced + details.ageHeader;
var currentGoal = Math.min(cdnAge - details.partTarget, details.targetduration * 1.5);
if (currentGoal > 0) {
if (previousDetails && currentGoal > previousDetails.tuneInGoal) {
// If we attempted to get the next or latest playlist update, but currentGoal increased,
// then we either can't catchup, or the "age" header cannot be trusted.
this.warn("CDN Tune-in goal increased from: " + previousDetails.tuneInGoal + " to: " + currentGoal + " with playlist age: " + details.age);
currentGoal = 0;
} else {
var segments = Math.floor(currentGoal / details.targetduration);
msn += segments;
if (part !== undefined) {
var parts = Math.round(currentGoal % details.targetduration / details.partTarget);
part += parts;
}
this.log("CDN Tune-in age: " + details.ageHeader + "s last advanced " + lastAdvanced.toFixed(2) + "s goal: " + currentGoal + " skip sn " + segments + " to part " + part);
}
details.tuneInGoal = currentGoal;
}
deliveryDirectives = this.getDeliveryDirectives(details, data.deliveryDirectives, msn, part);
if (lowLatencyMode || !lastPart) {
this.loadPlaylist(deliveryDirectives);
return;
}
} else {
deliveryDirectives = this.getDeliveryDirectives(details, data.deliveryDirectives, msn, part);
}
var reloadInterval = Object(_level_helper__WEBPACK_IMPORTED_MODULE_2__["computeReloadInterval"])(details, stats);
if (msn !== undefined && details.canBlockReload) {
reloadInterval -= details.partTarget || 1;
}
this.log("reload live playlist " + index + " in " + Math.round(reloadInterval) + " ms");
this.timer = self.setTimeout(function () {
return _this.loadPlaylist(deliveryDirectives);
}, reloadInterval);
} else {
this.clearTimer();
}
};
_proto.getDeliveryDirectives = function getDeliveryDirectives(details, previousDeliveryDirectives, msn, part) {
var skip = Object(_types_level__WEBPACK_IMPORTED_MODULE_1__["getSkipValue"])(details, msn);
if (previousDeliveryDirectives !== null && previousDeliveryDirectives !== void 0 && previousDeliveryDirectives.skip && details.deltaUpdateFailed) {
msn = previousDeliveryDirectives.msn;
part = previousDeliveryDirectives.part;
skip = _types_level__WEBPACK_IMPORTED_MODULE_1__["HlsSkip"].No;
}
return new _types_level__WEBPACK_IMPORTED_MODULE_1__["HlsUrlParameters"](msn, part, skip);
};
_proto.retryLoadingOrFail = function retryLoadingOrFail(errorEvent) {
var _this2 = this;
var config = this.hls.config;
var retry = this.retryCount < config.levelLoadingMaxRetry;
if (retry) {
var _errorEvent$context;
this.retryCount++;
if (errorEvent.details.indexOf('LoadTimeOut') > -1 && (_errorEvent$context = errorEvent.context) !== null && _errorEvent$context !== void 0 && _errorEvent$context.deliveryDirectives) {
// The LL-HLS request already timed out so retry immediately
this.warn("retry playlist loading #" + this.retryCount + " after \"" + errorEvent.details + "\"");
this.loadPlaylist();
} else {
// exponential backoff capped to max retry timeout
var delay = Math.min(Math.pow(2, this.retryCount) * config.levelLoadingRetryDelay, config.levelLoadingMaxRetryTimeout); // Schedule level/track reload
this.timer = self.setTimeout(function () {
return _this2.loadPlaylist();
}, delay);
this.warn("retry playlist loading #" + this.retryCount + " in " + delay + " ms after \"" + errorEvent.details + "\"");
}
} else {
this.warn("cannot recover from error \"" + errorEvent.details + "\""); // stopping live reloading timer if any
this.clearTimer(); // switch error to fatal
errorEvent.fatal = true;
}
return retry;
};
return BasePlaylistController;
}();
/***/ }),
/***/ "./src/controller/base-stream-controller.ts":
/*!**************************************************!*\
!*** ./src/controller/base-stream-controller.ts ***!
\**************************************************/
/*! exports provided: State, default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "State", function() { return State; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return BaseStreamController; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _task_loop__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../task-loop */ "./src/task-loop.ts");
/* harmony import */ var _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./fragment-tracker */ "./src/controller/fragment-tracker.ts");
/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _types_transmuxer__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../types/transmuxer */ "./src/types/transmuxer.ts");
/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _utils_discontinuities__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../utils/discontinuities */ "./src/utils/discontinuities.ts");
/* harmony import */ var _fragment_finders__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./fragment-finders */ "./src/controller/fragment-finders.ts");
/* harmony import */ var _level_helper__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./level-helper */ "./src/controller/level-helper.ts");
/* harmony import */ var _loader_fragment_loader__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../loader/fragment-loader */ "./src/loader/fragment-loader.ts");
/* harmony import */ var _crypt_decrypter__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../crypt/decrypter */ "./src/crypt/decrypter.ts");
/* harmony import */ var _utils_time_ranges__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../utils/time-ranges */ "./src/utils/time-ranges.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var State = {
STOPPED: 'STOPPED',
IDLE: 'IDLE',
KEY_LOADING: 'KEY_LOADING',
FRAG_LOADING: 'FRAG_LOADING',
FRAG_LOADING_WAITING_RETRY: 'FRAG_LOADING_WAITING_RETRY',
WAITING_TRACK: 'WAITING_TRACK',
PARSING: 'PARSING',
PARSED: 'PARSED',
BACKTRACKING: 'BACKTRACKING',
ENDED: 'ENDED',
ERROR: 'ERROR',
WAITING_INIT_PTS: 'WAITING_INIT_PTS',
WAITING_LEVEL: 'WAITING_LEVEL'
};
var BaseStreamController = /*#__PURE__*/function (_TaskLoop) {
_inheritsLoose(BaseStreamController, _TaskLoop);
function BaseStreamController(hls, fragmentTracker, logPrefix) {
var _this;
_this = _TaskLoop.call(this) || this;
_this.hls = void 0;
_this.fragPrevious = null;
_this.fragCurrent = null;
_this.fragmentTracker = void 0;
_this.transmuxer = null;
_this._state = State.STOPPED;
_this.media = void 0;
_this.mediaBuffer = void 0;
_this.config = void 0;
_this.bitrateTest = false;
_this.lastCurrentTime = 0;
_this.nextLoadPosition = 0;
_this.startPosition = 0;
_this.loadedmetadata = false;
_this.fragLoadError = 0;
_this.retryDate = 0;
_this.levels = null;
_this.fragmentLoader = void 0;
_this.levelLastLoaded = null;
_this.startFragRequested = false;
_this.decrypter = void 0;
_this.initPTS = [];
_this.onvseeking = null;
_this.onvended = null;
_this.logPrefix = '';
_this.log = void 0;
_this.warn = void 0;
_this.logPrefix = logPrefix;
_this.log = _utils_logger__WEBPACK_IMPORTED_MODULE_4__["logger"].log.bind(_utils_logger__WEBPACK_IMPORTED_MODULE_4__["logger"], logPrefix + ":");
_this.warn = _utils_logger__WEBPACK_IMPORTED_MODULE_4__["logger"].warn.bind(_utils_logger__WEBPACK_IMPORTED_MODULE_4__["logger"], logPrefix + ":");
_this.hls = hls;
_this.fragmentLoader = new _loader_fragment_loader__WEBPACK_IMPORTED_MODULE_12__["default"](hls.config);
_this.fragmentTracker = fragmentTracker;
_this.config = hls.config;
_this.decrypter = new _crypt_decrypter__WEBPACK_IMPORTED_MODULE_13__["default"](hls, hls.config);
hls.on(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].KEY_LOADED, _this.onKeyLoaded, _assertThisInitialized(_this));
return _this;
}
var _proto = BaseStreamController.prototype;
_proto.doTick = function doTick() {
this.onTickEnd();
};
_proto.onTickEnd = function onTickEnd() {} // eslint-disable-next-line @typescript-eslint/no-unused-vars
;
_proto.startLoad = function startLoad(startPosition) {};
_proto.stopLoad = function stopLoad() {
this.fragmentLoader.abort();
var frag = this.fragCurrent;
if (frag) {
this.fragmentTracker.removeFragment(frag);
}
this.resetTransmuxer();
this.fragCurrent = null;
this.fragPrevious = null;
this.clearInterval();
this.clearNextTick();
this.state = State.STOPPED;
};
_proto._streamEnded = function _streamEnded(bufferInfo, levelDetails) {
var fragCurrent = this.fragCurrent,
fragmentTracker = this.fragmentTracker; // we just got done loading the final fragment and there is no other buffered range after ...
// rationale is that in case there are any buffered ranges after, it means that there are unbuffered portion in between
// so we should not switch to ENDED in that case, to be able to buffer them
if (!levelDetails.live && fragCurrent && fragCurrent.sn === levelDetails.endSN && !bufferInfo.nextStart) {
var fragState = fragmentTracker.getState(fragCurrent);
return fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__["FragmentState"].PARTIAL || fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__["FragmentState"].OK;
}
return false;
};
_proto.onMediaAttached = function onMediaAttached(event, data) {
var media = this.media = this.mediaBuffer = data.media;
this.onvseeking = this.onMediaSeeking.bind(this);
this.onvended = this.onMediaEnded.bind(this);
media.addEventListener('seeking', this.onvseeking);
media.addEventListener('ended', this.onvended);
var config = this.config;
if (this.levels && config.autoStartLoad && this.state === State.STOPPED) {
this.startLoad(config.startPosition);
}
};
_proto.onMediaDetaching = function onMediaDetaching() {
var media = this.media;
if (media !== null && media !== void 0 && media.ended) {
this.log('MSE detaching and video ended, reset startPosition');
this.startPosition = this.lastCurrentTime = 0;
} // remove video listeners
if (media) {
media.removeEventListener('seeking', this.onvseeking);
media.removeEventListener('ended', this.onvended);
this.onvseeking = this.onvended = null;
}
this.media = this.mediaBuffer = null;
this.loadedmetadata = false;
this.fragmentTracker.removeAllFragments();
this.stopLoad();
};
_proto.onMediaSeeking = function onMediaSeeking() {
var config = this.config,
fragCurrent = this.fragCurrent,
media = this.media,
mediaBuffer = this.mediaBuffer,
state = this.state;
var currentTime = media ? media.currentTime : 0;
var bufferInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].bufferInfo(mediaBuffer || media, currentTime, config.maxBufferHole);
this.log("media seeking to " + (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(currentTime) ? currentTime.toFixed(3) : currentTime) + ", state: " + state);
if (state === State.ENDED) {
this.resetLoadingState();
} else if (fragCurrent && !bufferInfo.len) {
// check if we are seeking to a unbuffered area AND if frag loading is in progress
var tolerance = config.maxFragLookUpTolerance;
var fragStartOffset = fragCurrent.start - tolerance;
var fragEndOffset = fragCurrent.start + fragCurrent.duration + tolerance;
var pastFragment = currentTime > fragEndOffset; // check if the seek position is past current fragment, and if so abort loading
if (currentTime < fragStartOffset || pastFragment) {
if (pastFragment && fragCurrent.loader) {
this.log('seeking outside of buffer while fragment load in progress, cancel fragment load');
fragCurrent.loader.abort();
}
this.resetLoadingState();
}
}
if (media) {
this.lastCurrentTime = currentTime;
} // in case seeking occurs although no media buffered, adjust startPosition and nextLoadPosition to seek target
if (!this.loadedmetadata && !bufferInfo.len) {
this.nextLoadPosition = this.startPosition = currentTime;
} // Async tick to speed up processing
this.tickImmediate();
};
_proto.onMediaEnded = function onMediaEnded() {
// reset startPosition and lastCurrentTime to restart playback @ stream beginning
this.startPosition = this.lastCurrentTime = 0;
};
_proto.onKeyLoaded = function onKeyLoaded(event, data) {
if (this.state !== State.KEY_LOADING || data.frag !== this.fragCurrent || !this.levels) {
return;
}
this.state = State.IDLE;
var levelDetails = this.levels[data.frag.level].details;
if (levelDetails) {
this.loadFragment(data.frag, levelDetails, data.frag.start);
}
};
_proto.onHandlerDestroying = function onHandlerDestroying() {
this.stopLoad();
_TaskLoop.prototype.onHandlerDestroying.call(this);
};
_proto.onHandlerDestroyed = function onHandlerDestroyed() {
this.state = State.STOPPED;
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].KEY_LOADED, this.onKeyLoaded, this);
if (this.fragmentLoader) {
this.fragmentLoader.destroy();
}
if (this.decrypter) {
this.decrypter.destroy();
}
this.hls = this.log = this.warn = this.decrypter = this.fragmentLoader = this.fragmentTracker = null;
_TaskLoop.prototype.onHandlerDestroyed.call(this);
};
_proto.loadKey = function loadKey(frag, details) {
this.log("Loading key for " + frag.sn + " of [" + details.startSN + "-" + details.endSN + "], " + (this.logPrefix === '[stream-controller]' ? 'level' : 'track') + " " + frag.level);
this.state = State.KEY_LOADING;
this.fragCurrent = frag;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].KEY_LOADING, {
frag: frag
});
};
_proto.loadFragment = function loadFragment(frag, levelDetails, targetBufferTime) {
this._loadFragForPlayback(frag, levelDetails, targetBufferTime);
};
_proto._loadFragForPlayback = function _loadFragForPlayback(frag, levelDetails, targetBufferTime) {
var _this2 = this;
var progressCallback = function progressCallback(data) {
if (_this2.fragContextChanged(frag)) {
_this2.warn("Fragment " + frag.sn + (data.part ? ' p: ' + data.part.index : '') + " of level " + frag.level + " was dropped during download.");
_this2.fragmentTracker.removeFragment(frag);
return;
}
frag.stats.chunkCount++;
_this2._handleFragmentLoadProgress(data);
};
this._doFragLoad(frag, levelDetails, targetBufferTime, progressCallback).then(function (data) {
if (!data) {
// if we're here we probably needed to backtrack or are waiting for more parts
return;
}
_this2.fragLoadError = 0;
var state = _this2.state;
if (_this2.fragContextChanged(frag)) {
if (state === State.FRAG_LOADING || state === State.BACKTRACKING || !_this2.fragCurrent && state === State.PARSING) {
_this2.fragmentTracker.removeFragment(frag);
_this2.state = State.IDLE;
}
return;
}
if ('payload' in data) {
_this2.log("Loaded fragment " + frag.sn + " of level " + frag.level);
_this2.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].FRAG_LOADED, data); // Tracker backtrack must be called after onFragLoaded to update the fragment entity state to BACKTRACKED
// This happens after handleTransmuxComplete when the worker or progressive is disabled
if (_this2.state === State.BACKTRACKING) {
_this2.fragmentTracker.backtrack(frag, data);
_this2.resetFragmentLoading(frag);
return;
}
} // Pass through the whole payload; controllers not implementing progressive loading receive data from this callback
_this2._handleFragmentLoadComplete(data);
}).catch(function (reason) {
_this2.warn(reason);
_this2.resetFragmentLoading(frag);
});
};
_proto.flushMainBuffer = function flushMainBuffer(startOffset, endOffset, type) {
if (type === void 0) {
type = null;
}
if (!(startOffset - endOffset)) {
return;
} // When alternate audio is playing, the audio-stream-controller is responsible for the audio buffer. Otherwise,
// passing a null type flushes both buffers
var flushScope = {
startOffset: startOffset,
endOffset: endOffset,
type: type
}; // Reset load errors on flush
this.fragLoadError = 0;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].BUFFER_FLUSHING, flushScope);
};
_proto._loadInitSegment = function _loadInitSegment(frag) {
var _this3 = this;
this._doFragLoad(frag).then(function (data) {
if (!data || _this3.fragContextChanged(frag) || !_this3.levels) {
throw new Error('init load aborted');
}
return data;
}).then(function (data) {
var hls = _this3.hls;
var payload = data.payload;
var decryptData = frag.decryptdata; // check to see if the payload needs to be decrypted
if (payload && payload.byteLength > 0 && decryptData && decryptData.key && decryptData.iv && decryptData.method === 'AES-128') {
var startTime = self.performance.now(); // decrypt the subtitles
return _this3.decrypter.webCryptoDecrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).then(function (decryptedData) {
var endTime = self.performance.now();
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].FRAG_DECRYPTED, {
frag: frag,
payload: decryptedData,
stats: {
tstart: startTime,
tdecrypt: endTime
}
});
data.payload = decryptedData;
return data;
});
}
return data;
}).then(function (data) {
var fragCurrent = _this3.fragCurrent,
hls = _this3.hls,
levels = _this3.levels;
if (!levels) {
throw new Error('init load aborted, missing levels');
}
var details = levels[frag.level].details;
console.assert(details, 'Level details are defined when init segment is loaded');
var stats = frag.stats;
_this3.state = State.IDLE;
_this3.fragLoadError = 0;
frag.data = new Uint8Array(data.payload);
stats.parsing.start = stats.buffering.start = self.performance.now();
stats.parsing.end = stats.buffering.end = self.performance.now(); // Silence FRAG_BUFFERED event if fragCurrent is null
if (data.frag === fragCurrent) {
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].FRAG_BUFFERED, {
stats: stats,
frag: fragCurrent,
part: null,
id: frag.type
});
}
_this3.tick();
}).catch(function (reason) {
_this3.warn(reason);
_this3.resetFragmentLoading(frag);
});
};
_proto.fragContextChanged = function fragContextChanged(frag) {
var fragCurrent = this.fragCurrent;
return !frag || !fragCurrent || frag.level !== fragCurrent.level || frag.sn !== fragCurrent.sn || frag.urlId !== fragCurrent.urlId;
};
_proto.fragBufferedComplete = function fragBufferedComplete(frag, part) {
var media = this.mediaBuffer ? this.mediaBuffer : this.media;
this.log("Buffered " + frag.type + " sn: " + frag.sn + (part ? ' part: ' + part.index : '') + " of " + (this.logPrefix === '[stream-controller]' ? 'level' : 'track') + " " + frag.level + " " + _utils_time_ranges__WEBPACK_IMPORTED_MODULE_14__["default"].toString(_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].getBuffered(media)));
this.state = State.IDLE;
this.tick();
};
_proto._handleFragmentLoadComplete = function _handleFragmentLoadComplete(fragLoadedEndData) {
var transmuxer = this.transmuxer;
if (!transmuxer) {
return;
}
var frag = fragLoadedEndData.frag,
part = fragLoadedEndData.part,
partsLoaded = fragLoadedEndData.partsLoaded; // If we did not load parts, or loaded all parts, we have complete (not partial) fragment data
var complete = !partsLoaded || partsLoaded.length === 0 || partsLoaded.some(function (fragLoaded) {
return !fragLoaded;
});
var chunkMeta = new _types_transmuxer__WEBPACK_IMPORTED_MODULE_7__["ChunkMetadata"](frag.level, frag.sn, frag.stats.chunkCount + 1, 0, part ? part.index : -1, !complete);
transmuxer.flush(chunkMeta);
} // eslint-disable-next-line @typescript-eslint/no-unused-vars
;
_proto._handleFragmentLoadProgress = function _handleFragmentLoadProgress(frag) {};
_proto._doFragLoad = function _doFragLoad(frag, details, targetBufferTime, progressCallback) {
var _this4 = this;
if (targetBufferTime === void 0) {
targetBufferTime = null;
}
if (!this.levels) {
throw new Error('frag load aborted, missing levels');
}
targetBufferTime = Math.max(frag.start, targetBufferTime || 0);
if (this.config.lowLatencyMode && details) {
var partList = details.partList;
if (partList && progressCallback) {
if (targetBufferTime > frag.end && details.fragmentHint) {
frag = details.fragmentHint;
}
var partIndex = this.getNextPart(partList, frag, targetBufferTime);
if (partIndex > -1) {
var part = partList[partIndex];
this.log("Loading part sn: " + frag.sn + " p: " + part.index + " cc: " + frag.cc + " of playlist [" + details.startSN + "-" + details.endSN + "] parts [0-" + partIndex + "-" + (partList.length - 1) + "] " + (this.logPrefix === '[stream-controller]' ? 'level' : 'track') + ": " + frag.level + ", target: " + parseFloat(targetBufferTime.toFixed(3)));
this.nextLoadPosition = part.start + part.duration;
this.state = State.FRAG_LOADING;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].FRAG_LOADING, {
frag: frag,
part: partList[partIndex],
targetBufferTime: targetBufferTime
});
return this.doFragPartsLoad(frag, partList, partIndex, progressCallback).catch(function (error) {
return _this4.handleFragLoadError(error);
});
} else if (!frag.url || this.loadedEndOfParts(partList, targetBufferTime)) {
// Fragment hint has no parts
return Promise.resolve(null);
}
}
}
this.log("Loading fragment " + frag.sn + " cc: " + frag.cc + " " + (details ? 'of [' + details.startSN + '-' + details.endSN + '] ' : '') + (this.logPrefix === '[stream-controller]' ? 'level' : 'track') + ": " + frag.level + ", target: " + parseFloat(targetBufferTime.toFixed(3))); // Don't update nextLoadPosition for fragments which are not buffered
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(frag.sn) && !this.bitrateTest) {
this.nextLoadPosition = frag.start + frag.duration;
}
this.state = State.FRAG_LOADING;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].FRAG_LOADING, {
frag: frag,
targetBufferTime: targetBufferTime
});
return this.fragmentLoader.load(frag, progressCallback).catch(function (error) {
return _this4.handleFragLoadError(error);
});
};
_proto.doFragPartsLoad = function doFragPartsLoad(frag, partList, partIndex, progressCallback) {
var _this5 = this;
return new Promise(function (resolve, reject) {
var partsLoaded = [];
var loadPartIndex = function loadPartIndex(index) {
var part = partList[index];
_this5.fragmentLoader.loadPart(frag, part, progressCallback).then(function (partLoadedData) {
partsLoaded[part.index] = partLoadedData;
var loadedPart = partLoadedData.part;
_this5.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].FRAG_LOADED, partLoadedData);
var nextPart = partList[index + 1];
if (nextPart && nextPart.fragment === frag) {
loadPartIndex(index + 1);
} else {
return resolve({
frag: frag,
part: loadedPart,
partsLoaded: partsLoaded
});
}
}).catch(reject);
};
loadPartIndex(partIndex);
});
};
_proto.handleFragLoadError = function handleFragLoadError(_ref) {
var data = _ref.data;
if (data && data.details === _errors__WEBPACK_IMPORTED_MODULE_6__["ErrorDetails"].INTERNAL_ABORTED) {
this.handleFragLoadAborted(data.frag, data.part);
} else {
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].ERROR, data);
}
return null;
};
_proto._handleTransmuxerFlush = function _handleTransmuxerFlush(chunkMeta) {
var context = this.getCurrentContext(chunkMeta);
if (!context || this.state !== State.PARSING) {
if (!this.fragCurrent) {
this.state = State.IDLE;
}
return;
}
var frag = context.frag,
part = context.part,
level = context.level;
var now = self.performance.now();
frag.stats.parsing.end = now;
if (part) {
part.stats.parsing.end = now;
}
this.updateLevelTiming(frag, part, level, chunkMeta.partial);
};
_proto.getCurrentContext = function getCurrentContext(chunkMeta) {
var levels = this.levels;
var levelIndex = chunkMeta.level,
sn = chunkMeta.sn,
partIndex = chunkMeta.part;
if (!levels || !levels[levelIndex]) {
this.warn("Levels object was unset while buffering fragment " + sn + " of level " + levelIndex + ". The current chunk will not be buffered.");
return null;
}
var level = levels[levelIndex];
var part = partIndex > -1 ? Object(_level_helper__WEBPACK_IMPORTED_MODULE_11__["getPartWith"])(level, sn, partIndex) : null;
var frag = part ? part.fragment : Object(_level_helper__WEBPACK_IMPORTED_MODULE_11__["getFragmentWithSN"])(level, sn, this.fragCurrent);
if (!frag) {
return null;
}
return {
frag: frag,
part: part,
level: level
};
};
_proto.bufferFragmentData = function bufferFragmentData(data, frag, part, chunkMeta) {
if (!data || this.state !== State.PARSING) {
return;
}
var data1 = data.data1,
data2 = data.data2;
var buffer = data1;
if (data1 && data2) {
// Combine the moof + mdat so that we buffer with a single append
buffer = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_8__["appendUint8Array"])(data1, data2);
}
if (!buffer || !buffer.length) {
return;
}
var segment = {
type: data.type,
frag: frag,
part: part,
chunkMeta: chunkMeta,
parent: frag.type,
data: buffer
};
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].BUFFER_APPENDING, segment);
if (data.dropped && data.independent && !part) {
// Clear buffer so that we reload previous segments sequentially if required
this.flushBufferGap(frag);
}
};
_proto.flushBufferGap = function flushBufferGap(frag) {
var media = this.media;
if (!media) {
return;
} // If currentTime is not buffered, clear the back buffer so that we can backtrack as much as needed
if (!_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].isBuffered(media, media.currentTime)) {
this.flushMainBuffer(0, frag.start);
return;
} // Remove back-buffer without interrupting playback to allow back tracking
var currentTime = media.currentTime;
var bufferInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].bufferInfo(media, currentTime, 0);
var fragDuration = frag.duration;
var segmentFraction = Math.min(this.config.maxFragLookUpTolerance * 2, fragDuration * 0.25);
var start = Math.max(Math.min(frag.start - segmentFraction, bufferInfo.end - segmentFraction), currentTime + segmentFraction);
if (frag.start - start > segmentFraction) {
this.flushMainBuffer(start, frag.start);
}
};
_proto.getFwdBufferInfo = function getFwdBufferInfo(bufferable, type) {
var config = this.config;
var pos = this.getLoadPosition();
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(pos)) {
return null;
}
var bufferInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].bufferInfo(bufferable, pos, config.maxBufferHole); // Workaround flaw in getting forward buffer when maxBufferHole is smaller than gap at current pos
if (bufferInfo.len === 0 && bufferInfo.nextStart !== undefined) {
var bufferedFragAtPos = this.fragmentTracker.getBufferedFrag(pos, type);
if (bufferedFragAtPos && bufferInfo.nextStart < bufferedFragAtPos.end) {
return _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].bufferInfo(bufferable, pos, Math.max(bufferInfo.nextStart, config.maxBufferHole));
}
}
return bufferInfo;
};
_proto.getMaxBufferLength = function getMaxBufferLength(levelBitrate) {
var config = this.config;
var maxBufLen;
if (levelBitrate) {
maxBufLen = Math.max(8 * config.maxBufferSize / levelBitrate, config.maxBufferLength);
} else {
maxBufLen = config.maxBufferLength;
}
return Math.min(maxBufLen, config.maxMaxBufferLength);
};
_proto.reduceMaxBufferLength = function reduceMaxBufferLength(threshold) {
var config = this.config;
var minLength = threshold || config.maxBufferLength;
if (config.maxMaxBufferLength >= minLength) {
// reduce max buffer length as it might be too high. we do this to avoid loop flushing ...
config.maxMaxBufferLength /= 2;
this.warn("Reduce max buffer length to " + config.maxMaxBufferLength + "s");
return true;
}
return false;
};
_proto.getNextFragment = function getNextFragment(pos, levelDetails) {
var _frag, _frag2;
var fragments = levelDetails.fragments;
var fragLen = fragments.length;
if (!fragLen) {
return null;
} // find fragment index, contiguous with end of buffer position
var config = this.config;
var start = fragments[0].start;
var frag;
if (levelDetails.live) {
var initialLiveManifestSize = config.initialLiveManifestSize;
if (fragLen < initialLiveManifestSize) {
this.warn("Not enough fragments to start playback (have: " + fragLen + ", need: " + initialLiveManifestSize + ")");
return null;
} // The real fragment start times for a live stream are only known after the PTS range for that level is known.
// In order to discover the range, we load the best matching fragment for that level and demux it.
// Do not load using live logic if the starting frag is requested - we want to use getFragmentAtPosition() so that
// we get the fragment matching that start time
if (!levelDetails.PTSKnown && !this.startFragRequested && this.startPosition === -1) {
frag = this.getInitialLiveFragment(levelDetails, fragments);
this.startPosition = frag ? this.hls.liveSyncPosition || frag.start : pos;
}
} else if (pos <= start) {
// VoD playlist: if loadPosition before start of playlist, load first fragment
frag = fragments[0];
} // If we haven't run into any special cases already, just load the fragment most closely matching the requested position
if (!frag) {
var end = config.lowLatencyMode ? levelDetails.partEnd : levelDetails.fragmentEnd;
frag = this.getFragmentAtPosition(pos, end, levelDetails);
} // If an initSegment is present, it must be buffered first
if ((_frag = frag) !== null && _frag !== void 0 && _frag.initSegment && !((_frag2 = frag) !== null && _frag2 !== void 0 && _frag2.initSegment.data) && !this.bitrateTest) {
frag = frag.initSegment;
}
return frag;
};
_proto.getNextPart = function getNextPart(partList, frag, targetBufferTime) {
var nextPart = -1;
var contiguous = false;
var independentAttrOmitted = true;
for (var i = 0, len = partList.length; i < len; i++) {
var part = partList[i];
independentAttrOmitted = independentAttrOmitted && !part.independent;
if (nextPart > -1 && targetBufferTime < part.start) {
break;
}
var loaded = part.loaded;
if (!loaded && (contiguous || part.independent || independentAttrOmitted) && part.fragment === frag) {
nextPart = i;
}
contiguous = loaded;
}
return nextPart;
};
_proto.loadedEndOfParts = function loadedEndOfParts(partList, targetBufferTime) {
var lastPart = partList[partList.length - 1];
return lastPart && targetBufferTime > lastPart.start && lastPart.loaded;
}
/*
This method is used find the best matching first fragment for a live playlist. This fragment is used to calculate the
"sliding" of the playlist, which is its offset from the start of playback. After sliding we can compute the real
start and end times for each fragment in the playlist (after which this method will not need to be called).
*/
;
_proto.getInitialLiveFragment = function getInitialLiveFragment(levelDetails, fragments) {
var fragPrevious = this.fragPrevious;
var frag = null;
if (fragPrevious) {
if (levelDetails.hasProgramDateTime) {
// Prefer using PDT, because it can be accurate enough to choose the correct fragment without knowing the level sliding
this.log("Live playlist, switching playlist, load frag with same PDT: " + fragPrevious.programDateTime);
frag = Object(_fragment_finders__WEBPACK_IMPORTED_MODULE_10__["findFragmentByPDT"])(fragments, fragPrevious.endProgramDateTime, this.config.maxFragLookUpTolerance);
}
if (!frag) {
// SN does not need to be accurate between renditions, but depending on the packaging it may be so.
var targetSN = fragPrevious.sn + 1;
if (targetSN >= levelDetails.startSN && targetSN <= levelDetails.endSN) {
var fragNext = fragments[targetSN - levelDetails.startSN]; // Ensure that we're staying within the continuity range, since PTS resets upon a new range
if (fragPrevious.cc === fragNext.cc) {
frag = fragNext;
this.log("Live playlist, switching playlist, load frag with next SN: " + frag.sn);
}
} // It's important to stay within the continuity range if available; otherwise the fragments in the playlist
// will have the wrong start times
if (!frag) {
frag = Object(_fragment_finders__WEBPACK_IMPORTED_MODULE_10__["findFragWithCC"])(fragments, fragPrevious.cc);
if (frag) {
this.log("Live playlist, switching playlist, load frag with same CC: " + frag.sn);
}
}
}
} else {
// Find a new start fragment when fragPrevious is null
var liveStart = this.hls.liveSyncPosition;
if (liveStart !== null) {
frag = this.getFragmentAtPosition(liveStart, this.bitrateTest ? levelDetails.fragmentEnd : levelDetails.edge, levelDetails);
}
}
return frag;
}
/*
This method finds the best matching fragment given the provided position.
*/
;
_proto.getFragmentAtPosition = function getFragmentAtPosition(bufferEnd, end, levelDetails) {
var config = this.config,
fragPrevious = this.fragPrevious;
var fragments = levelDetails.fragments,
endSN = levelDetails.endSN;
var fragmentHint = levelDetails.fragmentHint;
var tolerance = config.maxFragLookUpTolerance;
var loadingParts = !!(config.lowLatencyMode && levelDetails.partList && fragmentHint);
if (loadingParts && fragmentHint && !this.bitrateTest) {
// Include incomplete fragment with parts at end
fragments = fragments.concat(fragmentHint);
endSN = fragmentHint.sn;
}
var frag;
if (bufferEnd < end) {
var lookupTolerance = bufferEnd > end - tolerance ? 0 : tolerance; // Remove the tolerance if it would put the bufferEnd past the actual end of stream
// Uses buffer and sequence number to calculate switch segment (required if using EXT-X-DISCONTINUITY-SEQUENCE)
frag = Object(_fragment_finders__WEBPACK_IMPORTED_MODULE_10__["findFragmentByPTS"])(fragPrevious, fragments, bufferEnd, lookupTolerance);
} else {
// reach end of playlist
frag = fragments[fragments.length - 1];
}
if (frag) {
var curSNIdx = frag.sn - levelDetails.startSN;
var sameLevel = fragPrevious && frag.level === fragPrevious.level;
var nextFrag = fragments[curSNIdx + 1];
var fragState = this.fragmentTracker.getState(frag);
if (fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__["FragmentState"].BACKTRACKED) {
frag = null;
var i = curSNIdx;
while (fragments[i] && this.fragmentTracker.getState(fragments[i]) === _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__["FragmentState"].BACKTRACKED) {
// When fragPrevious is null, backtrack to first the first fragment is not BACKTRACKED for loading
// When fragPrevious is set, we want the first BACKTRACKED fragment for parsing and buffering
if (!fragPrevious) {
frag = fragments[--i];
} else {
frag = fragments[i--];
}
}
if (!frag) {
frag = nextFrag;
}
} else if (fragPrevious && frag.sn === fragPrevious.sn && !loadingParts) {
// Force the next fragment to load if the previous one was already selected. This can occasionally happen with
// non-uniform fragment durations
if (sameLevel) {
if (frag.sn < endSN && this.fragmentTracker.getState(nextFrag) !== _fragment_tracker__WEBPACK_IMPORTED_MODULE_2__["FragmentState"].OK) {
this.log("SN " + frag.sn + " just loaded, load next one: " + nextFrag.sn);
frag = nextFrag;
} else {
frag = null;
}
}
}
}
return frag;
};
_proto.synchronizeToLiveEdge = function synchronizeToLiveEdge(levelDetails) {
var config = this.config,
media = this.media;
if (!media) {
return;
}
var liveSyncPosition = this.hls.liveSyncPosition;
var currentTime = media.currentTime;
var start = levelDetails.fragments[0].start;
var end = levelDetails.edge;
var withinSlidingWindow = currentTime >= start - config.maxFragLookUpTolerance && currentTime <= end; // Continue if we can seek forward to sync position or if current time is outside of sliding window
if (liveSyncPosition !== null && media.duration > liveSyncPosition && (currentTime < liveSyncPosition || !withinSlidingWindow)) {
// Continue if buffer is starving or if current time is behind max latency
var maxLatency = config.liveMaxLatencyDuration !== undefined ? config.liveMaxLatencyDuration : config.liveMaxLatencyDurationCount * levelDetails.targetduration;
if (!withinSlidingWindow && media.readyState < 4 || currentTime < end - maxLatency) {
if (!this.loadedmetadata) {
this.nextLoadPosition = liveSyncPosition;
} // Only seek if ready and there is not a significant forward buffer available for playback
if (media.readyState) {
this.warn("Playback: " + currentTime.toFixed(3) + " is located too far from the end of live sliding playlist: " + end + ", reset currentTime to : " + liveSyncPosition.toFixed(3));
media.currentTime = liveSyncPosition;
}
}
}
};
_proto.alignPlaylists = function alignPlaylists(details, previousDetails) {
var levels = this.levels,
levelLastLoaded = this.levelLastLoaded,
fragPrevious = this.fragPrevious;
var lastLevel = levelLastLoaded !== null ? levels[levelLastLoaded] : null; // FIXME: If not for `shouldAlignOnDiscontinuities` requiring fragPrevious.cc,
// this could all go in level-helper mergeDetails()
var length = details.fragments.length;
if (!length) {
this.warn("No fragments in live playlist");
return 0;
}
var slidingStart = details.fragments[0].start;
var firstLevelLoad = !previousDetails;
var aligned = details.alignedSliding && Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(slidingStart);
if (firstLevelLoad || !aligned && !slidingStart) {
Object(_utils_discontinuities__WEBPACK_IMPORTED_MODULE_9__["alignStream"])(fragPrevious, lastLevel, details);
var alignedSlidingStart = details.fragments[0].start;
this.log("Live playlist sliding: " + alignedSlidingStart.toFixed(2) + " start-sn: " + (previousDetails ? previousDetails.startSN : 'na') + "->" + details.startSN + " prev-sn: " + (fragPrevious ? fragPrevious.sn : 'na') + " fragments: " + length);
return alignedSlidingStart;
}
return slidingStart;
};
_proto.waitForCdnTuneIn = function waitForCdnTuneIn(details) {
// Wait for Low-Latency CDN Tune-in to get an updated playlist
var advancePartLimit = 3;
return details.live && details.canBlockReload && details.tuneInGoal > Math.max(details.partHoldBack, details.partTarget * advancePartLimit);
};
_proto.setStartPosition = function setStartPosition(details, sliding) {
// compute start position if set to -1. use it straight away if value is defined
var startPosition = this.startPosition;
if (startPosition < sliding) {
startPosition = -1;
}
if (startPosition === -1 || this.lastCurrentTime === -1) {
// first, check if start time offset has been set in playlist, if yes, use this value
var startTimeOffset = details.startTimeOffset;
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(startTimeOffset)) {
startPosition = sliding + startTimeOffset;
if (startTimeOffset < 0) {
startPosition += details.totalduration;
}
startPosition = Math.min(Math.max(sliding, startPosition), sliding + details.totalduration);
this.log("Start time offset " + startTimeOffset + " found in playlist, adjust startPosition to " + startPosition);
this.startPosition = startPosition;
} else if (details.live) {
// Leave this.startPosition at -1, so that we can use `getInitialLiveFragment` logic when startPosition has
// not been specified via the config or an as an argument to startLoad (#3736).
startPosition = this.hls.liveSyncPosition || sliding;
} else {
this.startPosition = startPosition = 0;
}
this.lastCurrentTime = startPosition;
}
this.nextLoadPosition = startPosition;
};
_proto.getLoadPosition = function getLoadPosition() {
var media = this.media; // if we have not yet loaded any fragment, start loading from start position
var pos = 0;
if (this.loadedmetadata && media) {
pos = media.currentTime;
} else if (this.nextLoadPosition) {
pos = this.nextLoadPosition;
}
return pos;
};
_proto.handleFragLoadAborted = function handleFragLoadAborted(frag, part) {
if (this.transmuxer && frag.sn !== 'initSegment' && frag.stats.aborted) {
this.warn("Fragment " + frag.sn + (part ? ' part' + part.index : '') + " of level " + frag.level + " was aborted");
this.resetFragmentLoading(frag);
}
};
_proto.resetFragmentLoading = function resetFragmentLoading(frag) {
if (!this.fragCurrent || !this.fragContextChanged(frag)) {
this.state = State.IDLE;
}
};
_proto.onFragmentOrKeyLoadError = function onFragmentOrKeyLoadError(filterType, data) {
if (data.fatal) {
return;
}
var frag = data.frag; // Handle frag error related to caller's filterType
if (!frag || frag.type !== filterType) {
return;
}
var fragCurrent = this.fragCurrent;
console.assert(fragCurrent && frag.sn === fragCurrent.sn && frag.level === fragCurrent.level && frag.urlId === fragCurrent.urlId, 'Frag load error must match current frag to retry');
var config = this.config; // keep retrying until the limit will be reached
if (this.fragLoadError + 1 <= config.fragLoadingMaxRetry) {
if (this.resetLiveStartWhenNotLoaded(frag.level)) {
return;
} // exponential backoff capped to config.fragLoadingMaxRetryTimeout
var delay = Math.min(Math.pow(2, this.fragLoadError) * config.fragLoadingRetryDelay, config.fragLoadingMaxRetryTimeout);
this.warn("Fragment " + frag.sn + " of " + filterType + " " + frag.level + " failed to load, retrying in " + delay + "ms");
this.retryDate = self.performance.now() + delay;
this.fragLoadError++;
this.state = State.FRAG_LOADING_WAITING_RETRY;
} else if (data.levelRetry) {
if (filterType === _types_loader__WEBPACK_IMPORTED_MODULE_15__["PlaylistLevelType"].AUDIO) {
// Reset current fragment since audio track audio is essential and may not have a fail-over track
this.fragCurrent = null;
} // Fragment errors that result in a level switch or redundant fail-over
// should reset the stream controller state to idle
this.fragLoadError = 0;
this.state = State.IDLE;
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_4__["logger"].error(data.details + " reaches max retry, redispatch as fatal ..."); // switch error to fatal
data.fatal = true;
this.hls.stopLoad();
this.state = State.ERROR;
}
};
_proto.afterBufferFlushed = function afterBufferFlushed(media, bufferType, playlistType) {
if (!media) {
return;
} // After successful buffer flushing, filter flushed fragments from bufferedFrags use mediaBuffered instead of media
// (so that we will check against video.buffered ranges in case of alt audio track)
var bufferedTimeRanges = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_3__["BufferHelper"].getBuffered(media);
this.fragmentTracker.detectEvictedFragments(bufferType, bufferedTimeRanges, playlistType);
if (this.state === State.ENDED) {
this.resetLoadingState();
}
};
_proto.resetLoadingState = function resetLoadingState() {
this.fragCurrent = null;
this.fragPrevious = null;
this.state = State.IDLE;
};
_proto.resetLiveStartWhenNotLoaded = function resetLiveStartWhenNotLoaded(level) {
// if loadedmetadata is not set, it means that we are emergency switch down on first frag
// in that case, reset startFragRequested flag
if (!this.loadedmetadata) {
this.startFragRequested = false;
var details = this.levels ? this.levels[level].details : null;
if (details !== null && details !== void 0 && details.live) {
// We can't afford to retry after a delay in a live scenario. Update the start position and return to IDLE.
this.startPosition = -1;
this.setStartPosition(details, 0);
this.resetLoadingState();
return true;
}
this.nextLoadPosition = this.startPosition;
}
return false;
};
_proto.updateLevelTiming = function updateLevelTiming(frag, part, level, partial) {
var _this6 = this;
var details = level.details;
console.assert(!!details, 'level.details must be defined');
var parsed = Object.keys(frag.elementaryStreams).reduce(function (result, type) {
var info = frag.elementaryStreams[type];
if (info) {
var parsedDuration = info.endPTS - info.startPTS;
if (parsedDuration <= 0) {
// Destroy the transmuxer after it's next time offset failed to advance because duration was <= 0.
// The new transmuxer will be configured with a time offset matching the next fragment start,
// preventing the timeline from shifting.
_this6.warn("Could not parse fragment " + frag.sn + " " + type + " duration reliably (" + parsedDuration + ") resetting transmuxer to fallback to playlist timing");
_this6.resetTransmuxer();
return result || false;
}
var drift = partial ? 0 : Object(_level_helper__WEBPACK_IMPORTED_MODULE_11__["updateFragPTSDTS"])(details, frag, info.startPTS, info.endPTS, info.startDTS, info.endDTS);
_this6.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].LEVEL_PTS_UPDATED, {
details: details,
level: level,
drift: drift,
type: type,
frag: frag,
start: info.startPTS,
end: info.endPTS
});
return true;
}
return result;
}, false);
if (parsed) {
this.state = State.PARSED;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].FRAG_PARSED, {
frag: frag,
part: part
});
} else {
this.resetLoadingState();
}
};
_proto.resetTransmuxer = function resetTransmuxer() {
if (this.transmuxer) {
this.transmuxer.destroy();
this.transmuxer = null;
}
};
_createClass(BaseStreamController, [{
key: "state",
get: function get() {
return this._state;
},
set: function set(nextState) {
var previousState = this._state;
if (previousState !== nextState) {
this._state = nextState;
this.log(previousState + "->" + nextState);
}
}
}]);
return BaseStreamController;
}(_task_loop__WEBPACK_IMPORTED_MODULE_1__["default"]);
/***/ }),
/***/ "./src/controller/buffer-controller.ts":
/*!*********************************************!*\
!*** ./src/controller/buffer-controller.ts ***!
\*********************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return BufferController; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
/* harmony import */ var _utils_mediasource_helper__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/mediasource-helper */ "./src/utils/mediasource-helper.ts");
/* harmony import */ var _loader_fragment__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../loader/fragment */ "./src/loader/fragment.ts");
/* harmony import */ var _buffer_operation_queue__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./buffer-operation-queue */ "./src/controller/buffer-operation-queue.ts");
var MediaSource = Object(_utils_mediasource_helper__WEBPACK_IMPORTED_MODULE_5__["getMediaSource"])();
var VIDEO_CODEC_PROFILE_REPACE = /([ha]vc.)(?:\.[^.,]+)+/;
var BufferController = /*#__PURE__*/function () {
// The level details used to determine duration, target-duration and live
// cache the self generated object url to detect hijack of video tag
// A queue of buffer operations which require the SourceBuffer to not be updating upon execution
// References to event listeners for each SourceBuffer, so that they can be referenced for event removal
// The number of BUFFER_CODEC events received before any sourceBuffers are created
// The total number of BUFFER_CODEC events received
// A reference to the attached media element
// A reference to the active media source
// counters
function BufferController(_hls) {
var _this = this;
this.details = null;
this._objectUrl = null;
this.operationQueue = void 0;
this.listeners = void 0;
this.hls = void 0;
this.bufferCodecEventsExpected = 0;
this._bufferCodecEventsTotal = 0;
this.media = null;
this.mediaSource = null;
this.appendError = 0;
this.tracks = {};
this.pendingTracks = {};
this.sourceBuffer = void 0;
this._onMediaSourceOpen = function () {
var hls = _this.hls,
media = _this.media,
mediaSource = _this.mediaSource;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('[buffer-controller]: Media source opened');
if (media) {
_this.updateMediaElementDuration();
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_ATTACHED, {
media: media
});
}
if (mediaSource) {
// once received, don't listen anymore to sourceopen event
mediaSource.removeEventListener('sourceopen', _this._onMediaSourceOpen);
}
_this.checkPendingTracks();
};
this._onMediaSourceClose = function () {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('[buffer-controller]: Media source closed');
};
this._onMediaSourceEnded = function () {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('[buffer-controller]: Media source ended');
};
this.hls = _hls;
this._initSourceBuffer();
this.registerListeners();
}
var _proto = BufferController.prototype;
_proto.hasSourceTypes = function hasSourceTypes() {
return this.getSourceBufferTypes().length > 0 || Object.keys(this.pendingTracks).length > 0;
};
_proto.destroy = function destroy() {
this.unregisterListeners();
this.details = null;
};
_proto.registerListeners = function registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_ATTACHING, this.onMediaAttaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_RESET, this.onBufferReset, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_APPENDING, this.onBufferAppending, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_CODECS, this.onBufferCodecs, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_EOS, this.onBufferEos, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_FLUSHING, this.onBufferFlushing, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_UPDATED, this.onLevelUpdated, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_PARSED, this.onFragParsed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_CHANGED, this.onFragChanged, this);
};
_proto.unregisterListeners = function unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_ATTACHING, this.onMediaAttaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_RESET, this.onBufferReset, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_APPENDING, this.onBufferAppending, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_CODECS, this.onBufferCodecs, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_EOS, this.onBufferEos, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_FLUSHING, this.onBufferFlushing, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_UPDATED, this.onLevelUpdated, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_PARSED, this.onFragParsed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_CHANGED, this.onFragChanged, this);
};
_proto._initSourceBuffer = function _initSourceBuffer() {
this.sourceBuffer = {};
this.operationQueue = new _buffer_operation_queue__WEBPACK_IMPORTED_MODULE_7__["default"](this.sourceBuffer);
this.listeners = {
audio: [],
video: [],
audiovideo: []
};
};
_proto.onManifestParsed = function onManifestParsed(event, data) {
// in case of alt audio 2 BUFFER_CODECS events will be triggered, one per stream controller
// sourcebuffers will be created all at once when the expected nb of tracks will be reached
// in case alt audio is not used, only one BUFFER_CODEC event will be fired from main stream controller
// it will contain the expected nb of source buffers, no need to compute it
var codecEvents = 2;
if (data.audio && !data.video || !data.altAudio) {
codecEvents = 1;
}
this.bufferCodecEventsExpected = this._bufferCodecEventsTotal = codecEvents;
this.details = null;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log(this.bufferCodecEventsExpected + " bufferCodec event(s) expected");
};
_proto.onMediaAttaching = function onMediaAttaching(event, data) {
var media = this.media = data.media;
if (media && MediaSource) {
var ms = this.mediaSource = new MediaSource(); // MediaSource listeners are arrow functions with a lexical scope, and do not need to be bound
ms.addEventListener('sourceopen', this._onMediaSourceOpen);
ms.addEventListener('sourceended', this._onMediaSourceEnded);
ms.addEventListener('sourceclose', this._onMediaSourceClose); // link video and media Source
media.src = self.URL.createObjectURL(ms); // cache the locally generated object url
this._objectUrl = media.src;
}
};
_proto.onMediaDetaching = function onMediaDetaching() {
var media = this.media,
mediaSource = this.mediaSource,
_objectUrl = this._objectUrl;
if (mediaSource) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('[buffer-controller]: media source detaching');
if (mediaSource.readyState === 'open') {
try {
// endOfStream could trigger exception if any sourcebuffer is in updating state
// we don't really care about checking sourcebuffer state here,
// as we are anyway detaching the MediaSource
// let's just avoid this exception to propagate
mediaSource.endOfStream();
} catch (err) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("[buffer-controller]: onMediaDetaching: " + err.message + " while calling endOfStream");
}
} // Clean up the SourceBuffers by invoking onBufferReset
this.onBufferReset();
mediaSource.removeEventListener('sourceopen', this._onMediaSourceOpen);
mediaSource.removeEventListener('sourceended', this._onMediaSourceEnded);
mediaSource.removeEventListener('sourceclose', this._onMediaSourceClose); // Detach properly the MediaSource from the HTMLMediaElement as
// suggested in https://github.com/w3c/media-source/issues/53.
if (media) {
if (_objectUrl) {
self.URL.revokeObjectURL(_objectUrl);
} // clean up video tag src only if it's our own url. some external libraries might
// hijack the video tag and change its 'src' without destroying the Hls instance first
if (media.src === _objectUrl) {
media.removeAttribute('src');
media.load();
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn('[buffer-controller]: media.src was changed by a third party - skip cleanup');
}
}
this.mediaSource = null;
this.media = null;
this._objectUrl = null;
this.bufferCodecEventsExpected = this._bufferCodecEventsTotal;
this.pendingTracks = {};
this.tracks = {};
}
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_DETACHED, undefined);
};
_proto.onBufferReset = function onBufferReset() {
var _this2 = this;
this.getSourceBufferTypes().forEach(function (type) {
var sb = _this2.sourceBuffer[type];
try {
if (sb) {
_this2.removeBufferListeners(type);
if (_this2.mediaSource) {
_this2.mediaSource.removeSourceBuffer(sb);
} // Synchronously remove the SB from the map before the next call in order to prevent an async function from
// accessing it
_this2.sourceBuffer[type] = undefined;
}
} catch (err) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("[buffer-controller]: Failed to reset the " + type + " buffer", err);
}
});
this._initSourceBuffer();
};
_proto.onBufferCodecs = function onBufferCodecs(event, data) {
var _this3 = this;
var sourceBufferCount = this.getSourceBufferTypes().length;
Object.keys(data).forEach(function (trackName) {
if (sourceBufferCount) {
// check if SourceBuffer codec needs to change
var track = _this3.tracks[trackName];
if (track && typeof track.buffer.changeType === 'function') {
var _data$trackName = data[trackName],
codec = _data$trackName.codec,
levelCodec = _data$trackName.levelCodec,
container = _data$trackName.container;
var currentCodec = (track.levelCodec || track.codec).replace(VIDEO_CODEC_PROFILE_REPACE, '$1');
var nextCodec = (levelCodec || codec).replace(VIDEO_CODEC_PROFILE_REPACE, '$1');
if (currentCodec !== nextCodec) {
var mimeType = container + ";codecs=" + (levelCodec || codec);
_this3.appendChangeType(trackName, mimeType);
}
}
} else {
// if source buffer(s) not created yet, appended buffer tracks in this.pendingTracks
_this3.pendingTracks[trackName] = data[trackName];
}
}); // if sourcebuffers already created, do nothing ...
if (sourceBufferCount) {
return;
}
this.bufferCodecEventsExpected = Math.max(this.bufferCodecEventsExpected - 1, 0);
if (this.mediaSource && this.mediaSource.readyState === 'open') {
this.checkPendingTracks();
}
};
_proto.appendChangeType = function appendChangeType(type, mimeType) {
var _this4 = this;
var operationQueue = this.operationQueue;
var operation = {
execute: function execute() {
var sb = _this4.sourceBuffer[type];
if (sb) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("[buffer-controller]: changing " + type + " sourceBuffer type to " + mimeType);
sb.changeType(mimeType);
}
operationQueue.shiftAndExecuteNext(type);
},
onStart: function onStart() {},
onComplete: function onComplete() {},
onError: function onError(e) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("[buffer-controller]: Failed to change " + type + " SourceBuffer type", e);
}
};
operationQueue.append(operation, type);
};
_proto.onBufferAppending = function onBufferAppending(event, eventData) {
var _this5 = this;
var hls = this.hls,
operationQueue = this.operationQueue,
tracks = this.tracks;
var data = eventData.data,
type = eventData.type,
frag = eventData.frag,
part = eventData.part,
chunkMeta = eventData.chunkMeta;
var chunkStats = chunkMeta.buffering[type];
var bufferAppendingStart = self.performance.now();
chunkStats.start = bufferAppendingStart;
var fragBuffering = frag.stats.buffering;
var partBuffering = part ? part.stats.buffering : null;
if (fragBuffering.start === 0) {
fragBuffering.start = bufferAppendingStart;
}
if (partBuffering && partBuffering.start === 0) {
partBuffering.start = bufferAppendingStart;
} // TODO: Only update timestampOffset when audio/mpeg fragment or part is not contiguous with previously appended
// Adjusting `SourceBuffer.timestampOffset` (desired point in the timeline where the next frames should be appended)
// in Chrome browser when we detect MPEG audio container and time delta between level PTS and `SourceBuffer.timestampOffset`
// is greater than 100ms (this is enough to handle seek for VOD or level change for LIVE videos).
// More info here: https://github.com/video-dev/hls.js/issues/332#issuecomment-257986486
var audioTrack = tracks.audio;
var checkTimestampOffset = type === 'audio' && chunkMeta.id === 1 && (audioTrack === null || audioTrack === void 0 ? void 0 : audioTrack.container) === 'audio/mpeg';
var operation = {
execute: function execute() {
chunkStats.executeStart = self.performance.now();
if (checkTimestampOffset) {
var sb = _this5.sourceBuffer[type];
if (sb) {
var delta = frag.start - sb.timestampOffset;
if (Math.abs(delta) >= 0.1) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("[buffer-controller]: Updating audio SourceBuffer timestampOffset to " + frag.start + " (delta: " + delta + ") sn: " + frag.sn + ")");
sb.timestampOffset = frag.start;
}
}
}
_this5.appendExecutor(data, type);
},
onStart: function onStart() {// logger.debug(`[buffer-controller]: ${type} SourceBuffer updatestart`);
},
onComplete: function onComplete() {
// logger.debug(`[buffer-controller]: ${type} SourceBuffer updateend`);
var end = self.performance.now();
chunkStats.executeEnd = chunkStats.end = end;
if (fragBuffering.first === 0) {
fragBuffering.first = end;
}
if (partBuffering && partBuffering.first === 0) {
partBuffering.first = end;
}
var sourceBuffer = _this5.sourceBuffer;
var timeRanges = {};
for (var _type in sourceBuffer) {
timeRanges[_type] = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__["BufferHelper"].getBuffered(sourceBuffer[_type]);
}
_this5.appendError = 0;
_this5.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_APPENDED, {
type: type,
frag: frag,
part: part,
chunkMeta: chunkMeta,
parent: frag.type,
timeRanges: timeRanges
});
},
onError: function onError(err) {
// in case any error occured while appending, put back segment in segments table
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error("[buffer-controller]: Error encountered while trying to append to the " + type + " SourceBuffer", err);
var event = {
type: _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorTypes"].MEDIA_ERROR,
parent: frag.type,
details: _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorDetails"].BUFFER_APPEND_ERROR,
err: err,
fatal: false
};
if (err.code === DOMException.QUOTA_EXCEEDED_ERR) {
// QuotaExceededError: http://www.w3.org/TR/html5/infrastructure.html#quotaexceedederror
// let's stop appending any segments, and report BUFFER_FULL_ERROR error
event.details = _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorDetails"].BUFFER_FULL_ERROR;
} else {
_this5.appendError++;
event.details = _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorDetails"].BUFFER_APPEND_ERROR;
/* with UHD content, we could get loop of quota exceeded error until
browser is able to evict some data from sourcebuffer. Retrying can help recover.
*/
if (_this5.appendError > hls.config.appendErrorMaxRetry) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error("[buffer-controller]: Failed " + hls.config.appendErrorMaxRetry + " times to append segment in sourceBuffer");
event.fatal = true;
}
}
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, event);
}
};
operationQueue.append(operation, type);
};
_proto.onBufferFlushing = function onBufferFlushing(event, data) {
var _this6 = this;
var operationQueue = this.operationQueue;
var flushOperation = function flushOperation(type) {
return {
execute: _this6.removeExecutor.bind(_this6, type, data.startOffset, data.endOffset),
onStart: function onStart() {// logger.debug(`[buffer-controller]: Started flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
},
onComplete: function onComplete() {
// logger.debug(`[buffer-controller]: Finished flushing ${data.startOffset} -> ${data.endOffset} for ${type} Source Buffer`);
_this6.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_FLUSHED, {
type: type
});
},
onError: function onError(e) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("[buffer-controller]: Failed to remove from " + type + " SourceBuffer", e);
}
};
};
if (data.type) {
operationQueue.append(flushOperation(data.type), data.type);
} else {
this.getSourceBufferTypes().forEach(function (type) {
operationQueue.append(flushOperation(type), type);
});
}
};
_proto.onFragParsed = function onFragParsed(event, data) {
var _this7 = this;
var frag = data.frag,
part = data.part;
var buffersAppendedTo = [];
var elementaryStreams = part ? part.elementaryStreams : frag.elementaryStreams;
if (elementaryStreams[_loader_fragment__WEBPACK_IMPORTED_MODULE_6__["ElementaryStreamTypes"].AUDIOVIDEO]) {
buffersAppendedTo.push('audiovideo');
} else {
if (elementaryStreams[_loader_fragment__WEBPACK_IMPORTED_MODULE_6__["ElementaryStreamTypes"].AUDIO]) {
buffersAppendedTo.push('audio');
}
if (elementaryStreams[_loader_fragment__WEBPACK_IMPORTED_MODULE_6__["ElementaryStreamTypes"].VIDEO]) {
buffersAppendedTo.push('video');
}
}
var onUnblocked = function onUnblocked() {
var now = self.performance.now();
frag.stats.buffering.end = now;
if (part) {
part.stats.buffering.end = now;
}
var stats = part ? part.stats : frag.stats;
_this7.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_BUFFERED, {
frag: frag,
part: part,
stats: stats,
id: frag.type
});
};
if (buffersAppendedTo.length === 0) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("Fragments must have at least one ElementaryStreamType set. type: " + frag.type + " level: " + frag.level + " sn: " + frag.sn);
}
this.blockBuffers(onUnblocked, buffersAppendedTo);
};
_proto.onFragChanged = function onFragChanged(event, data) {
this.flushBackBuffer();
} // on BUFFER_EOS mark matching sourcebuffer(s) as ended and trigger checkEos()
// an undefined data.type will mark all buffers as EOS.
;
_proto.onBufferEos = function onBufferEos(event, data) {
var _this8 = this;
var ended = this.getSourceBufferTypes().reduce(function (acc, type) {
var sb = _this8.sourceBuffer[type];
if (!data.type || data.type === type) {
if (sb && !sb.ended) {
sb.ended = true;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("[buffer-controller]: " + type + " sourceBuffer now EOS");
}
}
return acc && !!(!sb || sb.ended);
}, true);
if (ended) {
this.blockBuffers(function () {
var mediaSource = _this8.mediaSource;
if (!mediaSource || mediaSource.readyState !== 'open') {
return;
} // Allow this to throw and be caught by the enqueueing function
mediaSource.endOfStream();
});
}
};
_proto.onLevelUpdated = function onLevelUpdated(event, _ref) {
var details = _ref.details;
if (!details.fragments.length) {
return;
}
this.details = details;
if (this.getSourceBufferTypes().length) {
this.blockBuffers(this.updateMediaElementDuration.bind(this));
} else {
this.updateMediaElementDuration();
}
};
_proto.flushBackBuffer = function flushBackBuffer() {
var hls = this.hls,
details = this.details,
media = this.media,
sourceBuffer = this.sourceBuffer;
if (!media || details === null) {
return;
}
var sourceBufferTypes = this.getSourceBufferTypes();
if (!sourceBufferTypes.length) {
return;
} // Support for deprecated liveBackBufferLength
var backBufferLength = details.live && hls.config.liveBackBufferLength !== null ? hls.config.liveBackBufferLength : hls.config.backBufferLength;
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(backBufferLength) || backBufferLength < 0) {
return;
}
var currentTime = media.currentTime;
var targetDuration = details.levelTargetDuration;
var maxBackBufferLength = Math.max(backBufferLength, targetDuration);
var targetBackBufferPosition = Math.floor(currentTime / targetDuration) * targetDuration - maxBackBufferLength;
sourceBufferTypes.forEach(function (type) {
var sb = sourceBuffer[type];
if (sb) {
var buffered = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__["BufferHelper"].getBuffered(sb); // when target buffer start exceeds actual buffer start
if (buffered.length > 0 && targetBackBufferPosition > buffered.start(0)) {
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BACK_BUFFER_REACHED, {
bufferEnd: targetBackBufferPosition
}); // Support for deprecated event:
if (details.live) {
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LIVE_BACK_BUFFER_REACHED, {
bufferEnd: targetBackBufferPosition
});
}
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_FLUSHING, {
startOffset: 0,
endOffset: targetBackBufferPosition,
type: type
});
}
}
});
}
/**
* Update Media Source duration to current level duration or override to Infinity if configuration parameter
* 'liveDurationInfinity` is set to `true`
* More details: https://github.com/video-dev/hls.js/issues/355
*/
;
_proto.updateMediaElementDuration = function updateMediaElementDuration() {
if (!this.details || !this.media || !this.mediaSource || this.mediaSource.readyState !== 'open') {
return;
}
var details = this.details,
hls = this.hls,
media = this.media,
mediaSource = this.mediaSource;
var levelDuration = details.fragments[0].start + details.totalduration;
var mediaDuration = media.duration;
var msDuration = Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(mediaSource.duration) ? mediaSource.duration : 0;
if (details.live && hls.config.liveDurationInfinity) {
// Override duration to Infinity
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('[buffer-controller]: Media Source duration is set to Infinity');
mediaSource.duration = Infinity;
this.updateSeekableRange(details);
} else if (levelDuration > msDuration && levelDuration > mediaDuration || !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(mediaDuration)) {
// levelDuration was the last value we set.
// not using mediaSource.duration as the browser may tweak this value
// only update Media Source duration if its value increase, this is to avoid
// flushing already buffered portion when switching between quality level
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("[buffer-controller]: Updating Media Source duration to " + levelDuration.toFixed(3));
mediaSource.duration = levelDuration;
}
};
_proto.updateSeekableRange = function updateSeekableRange(levelDetails) {
var mediaSource = this.mediaSource;
var fragments = levelDetails.fragments;
var len = fragments.length;
if (len && levelDetails.live && mediaSource !== null && mediaSource !== void 0 && mediaSource.setLiveSeekableRange) {
var start = Math.max(0, fragments[0].start);
var end = Math.max(start, start + levelDetails.totalduration);
mediaSource.setLiveSeekableRange(start, end);
}
};
_proto.checkPendingTracks = function checkPendingTracks() {
var bufferCodecEventsExpected = this.bufferCodecEventsExpected,
operationQueue = this.operationQueue,
pendingTracks = this.pendingTracks; // Check if we've received all of the expected bufferCodec events. When none remain, create all the sourceBuffers at once.
// This is important because the MSE spec allows implementations to throw QuotaExceededErrors if creating new sourceBuffers after
// data has been appended to existing ones.
// 2 tracks is the max (one for audio, one for video). If we've reach this max go ahead and create the buffers.
var pendingTracksCount = Object.keys(pendingTracks).length;
if (pendingTracksCount && !bufferCodecEventsExpected || pendingTracksCount === 2) {
// ok, let's create them now !
this.createSourceBuffers(pendingTracks);
this.pendingTracks = {}; // append any pending segments now !
var buffers = this.getSourceBufferTypes();
if (buffers.length === 0) {
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorDetails"].BUFFER_INCOMPATIBLE_CODECS_ERROR,
fatal: true,
reason: 'could not create source buffer for media codec(s)'
});
return;
}
buffers.forEach(function (type) {
operationQueue.executeNext(type);
});
}
};
_proto.createSourceBuffers = function createSourceBuffers(tracks) {
var sourceBuffer = this.sourceBuffer,
mediaSource = this.mediaSource;
if (!mediaSource) {
throw Error('createSourceBuffers called when mediaSource was null');
}
var tracksCreated = 0;
for (var trackName in tracks) {
if (!sourceBuffer[trackName]) {
var track = tracks[trackName];
if (!track) {
throw Error("source buffer exists for track " + trackName + ", however track does not");
} // use levelCodec as first priority
var codec = track.levelCodec || track.codec;
var mimeType = track.container + ";codecs=" + codec;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("[buffer-controller]: creating sourceBuffer(" + mimeType + ")");
try {
var sb = sourceBuffer[trackName] = mediaSource.addSourceBuffer(mimeType);
var sbName = trackName;
this.addBufferListener(sbName, 'updatestart', this._onSBUpdateStart);
this.addBufferListener(sbName, 'updateend', this._onSBUpdateEnd);
this.addBufferListener(sbName, 'error', this._onSBUpdateError);
this.tracks[trackName] = {
buffer: sb,
codec: codec,
container: track.container,
levelCodec: track.levelCodec,
id: track.id
};
tracksCreated++;
} catch (err) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error("[buffer-controller]: error while trying to add sourceBuffer: " + err.message);
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorDetails"].BUFFER_ADD_CODEC_ERROR,
fatal: false,
error: err,
mimeType: mimeType
});
}
}
}
if (tracksCreated) {
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_CREATED, {
tracks: this.tracks
});
}
} // Keep as arrow functions so that we can directly reference these functions directly as event listeners
;
_proto._onSBUpdateStart = function _onSBUpdateStart(type) {
var operationQueue = this.operationQueue;
var operation = operationQueue.current(type);
operation.onStart();
};
_proto._onSBUpdateEnd = function _onSBUpdateEnd(type) {
var operationQueue = this.operationQueue;
var operation = operationQueue.current(type);
operation.onComplete();
operationQueue.shiftAndExecuteNext(type);
};
_proto._onSBUpdateError = function _onSBUpdateError(type, event) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error("[buffer-controller]: " + type + " SourceBuffer error", event); // according to http://www.w3.org/TR/media-source/#sourcebuffer-append-error
// SourceBuffer errors are not necessarily fatal; if so, the HTMLMediaElement will fire an error event
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_3__["ErrorDetails"].BUFFER_APPENDING_ERROR,
fatal: false
}); // updateend is always fired after error, so we'll allow that to shift the current operation off of the queue
var operation = this.operationQueue.current(type);
if (operation) {
operation.onError(event);
}
} // This method must result in an updateend event; if remove is not called, _onSBUpdateEnd must be called manually
;
_proto.removeExecutor = function removeExecutor(type, startOffset, endOffset) {
var media = this.media,
mediaSource = this.mediaSource,
operationQueue = this.operationQueue,
sourceBuffer = this.sourceBuffer;
var sb = sourceBuffer[type];
if (!media || !mediaSource || !sb) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("[buffer-controller]: Attempting to remove from the " + type + " SourceBuffer, but it does not exist");
operationQueue.shiftAndExecuteNext(type);
return;
}
var mediaDuration = Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(media.duration) ? media.duration : Infinity;
var msDuration = Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(mediaSource.duration) ? mediaSource.duration : Infinity;
var removeStart = Math.max(0, startOffset);
var removeEnd = Math.min(endOffset, mediaDuration, msDuration);
if (removeEnd > removeStart) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("[buffer-controller]: Removing [" + removeStart + "," + removeEnd + "] from the " + type + " SourceBuffer");
console.assert(!sb.updating, type + " sourceBuffer must not be updating");
sb.remove(removeStart, removeEnd);
} else {
// Cycle the queue
operationQueue.shiftAndExecuteNext(type);
}
} // This method must result in an updateend event; if append is not called, _onSBUpdateEnd must be called manually
;
_proto.appendExecutor = function appendExecutor(data, type) {
var operationQueue = this.operationQueue,
sourceBuffer = this.sourceBuffer;
var sb = sourceBuffer[type];
if (!sb) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("[buffer-controller]: Attempting to append to the " + type + " SourceBuffer, but it does not exist");
operationQueue.shiftAndExecuteNext(type);
return;
}
sb.ended = false;
console.assert(!sb.updating, type + " sourceBuffer must not be updating");
sb.appendBuffer(data);
} // Enqueues an operation to each SourceBuffer queue which, upon execution, resolves a promise. When all promises
// resolve, the onUnblocked function is executed. Functions calling this method do not need to unblock the queue
// upon completion, since we already do it here
;
_proto.blockBuffers = function blockBuffers(onUnblocked, buffers) {
var _this9 = this;
if (buffers === void 0) {
buffers = this.getSourceBufferTypes();
}
if (!buffers.length) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('[buffer-controller]: Blocking operation requested, but no SourceBuffers exist');
Promise.resolve(onUnblocked);
return;
}
var operationQueue = this.operationQueue; // logger.debug(`[buffer-controller]: Blocking ${buffers} SourceBuffer`);
var blockingOperations = buffers.map(function (type) {
return operationQueue.appendBlocker(type);
});
Promise.all(blockingOperations).then(function () {
// logger.debug(`[buffer-controller]: Blocking operation resolved; unblocking ${buffers} SourceBuffer`);
onUnblocked();
buffers.forEach(function (type) {
var sb = _this9.sourceBuffer[type]; // Only cycle the queue if the SB is not updating. There's a bug in Chrome which sets the SB updating flag to
// true when changing the MediaSource duration (https://bugs.chromium.org/p/chromium/issues/detail?id=959359&can=2&q=mediasource%20duration)
// While this is a workaround, it's probably useful to have around
if (!sb || !sb.updating) {
operationQueue.shiftAndExecuteNext(type);
}
});
});
};
_proto.getSourceBufferTypes = function getSourceBufferTypes() {
return Object.keys(this.sourceBuffer);
};
_proto.addBufferListener = function addBufferListener(type, event, fn) {
var buffer = this.sourceBuffer[type];
if (!buffer) {
return;
}
var listener = fn.bind(this, type);
this.listeners[type].push({
event: event,
listener: listener
});
buffer.addEventListener(event, listener);
};
_proto.removeBufferListeners = function removeBufferListeners(type) {
var buffer = this.sourceBuffer[type];
if (!buffer) {
return;
}
this.listeners[type].forEach(function (l) {
buffer.removeEventListener(l.event, l.listener);
});
};
return BufferController;
}();
/***/ }),
/***/ "./src/controller/buffer-operation-queue.ts":
/*!**************************************************!*\
!*** ./src/controller/buffer-operation-queue.ts ***!
\**************************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return BufferOperationQueue; });
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
var BufferOperationQueue = /*#__PURE__*/function () {
function BufferOperationQueue(sourceBufferReference) {
this.buffers = void 0;
this.queues = {
video: [],
audio: [],
audiovideo: []
};
this.buffers = sourceBufferReference;
}
var _proto = BufferOperationQueue.prototype;
_proto.append = function append(operation, type) {
var queue = this.queues[type];
queue.push(operation);
if (queue.length === 1 && this.buffers[type]) {
this.executeNext(type);
}
};
_proto.insertAbort = function insertAbort(operation, type) {
var queue = this.queues[type];
queue.unshift(operation);
this.executeNext(type);
};
_proto.appendBlocker = function appendBlocker(type) {
var execute;
var promise = new Promise(function (resolve) {
execute = resolve;
});
var operation = {
execute: execute,
onStart: function onStart() {},
onComplete: function onComplete() {},
onError: function onError() {}
};
this.append(operation, type);
return promise;
};
_proto.executeNext = function executeNext(type) {
var buffers = this.buffers,
queues = this.queues;
var sb = buffers[type];
var queue = queues[type];
if (queue.length) {
var operation = queue[0];
try {
// Operations are expected to result in an 'updateend' event being fired. If not, the queue will lock. Operations
// which do not end with this event must call _onSBUpdateEnd manually
operation.execute();
} catch (e) {
_utils_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].warn('[buffer-operation-queue]: Unhandled exception executing the current operation');
operation.onError(e); // Only shift the current operation off, otherwise the updateend handler will do this for us
if (!sb || !sb.updating) {
queue.shift();
this.executeNext(type);
}
}
}
};
_proto.shiftAndExecuteNext = function shiftAndExecuteNext(type) {
this.queues[type].shift();
this.executeNext(type);
};
_proto.current = function current(type) {
return this.queues[type][0];
};
return BufferOperationQueue;
}();
/***/ }),
/***/ "./src/controller/cap-level-controller.ts":
/*!************************************************!*\
!*** ./src/controller/cap-level-controller.ts ***!
\************************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
/*
* cap stream level to media size dimension controller
*/
var CapLevelController = /*#__PURE__*/function () {
function CapLevelController(hls) {
this.autoLevelCapping = void 0;
this.firstLevel = void 0;
this.media = void 0;
this.restrictedLevels = void 0;
this.timer = void 0;
this.hls = void 0;
this.streamController = void 0;
this.clientRect = void 0;
this.hls = hls;
this.autoLevelCapping = Number.POSITIVE_INFINITY;
this.firstLevel = -1;
this.media = null;
this.restrictedLevels = [];
this.timer = undefined;
this.clientRect = null;
this.registerListeners();
}
var _proto = CapLevelController.prototype;
_proto.setStreamController = function setStreamController(streamController) {
this.streamController = streamController;
};
_proto.destroy = function destroy() {
this.unregisterListener();
if (this.hls.config.capLevelToPlayerSize) {
this.stopCapping();
}
this.media = null;
this.clientRect = null; // @ts-ignore
this.hls = this.streamController = null;
};
_proto.registerListeners = function registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FPS_DROP_LEVEL_CAPPING, this.onFpsDropLevelCapping, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHING, this.onMediaAttaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].BUFFER_CODECS, this.onBufferCodecs, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
};
_proto.unregisterListener = function unregisterListener() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FPS_DROP_LEVEL_CAPPING, this.onFpsDropLevelCapping, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHING, this.onMediaAttaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].BUFFER_CODECS, this.onBufferCodecs, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
};
_proto.onFpsDropLevelCapping = function onFpsDropLevelCapping(event, data) {
// Don't add a restricted level more than once
if (CapLevelController.isLevelAllowed(data.droppedLevel, this.restrictedLevels)) {
this.restrictedLevels.push(data.droppedLevel);
}
};
_proto.onMediaAttaching = function onMediaAttaching(event, data) {
this.media = data.media instanceof HTMLVideoElement ? data.media : null;
};
_proto.onManifestParsed = function onManifestParsed(event, data) {
var hls = this.hls;
this.restrictedLevels = [];
this.firstLevel = data.firstLevel;
if (hls.config.capLevelToPlayerSize && data.video) {
// Start capping immediately if the manifest has signaled video codecs
this.startCapping();
}
} // Only activate capping when playing a video stream; otherwise, multi-bitrate audio-only streams will be restricted
// to the first level
;
_proto.onBufferCodecs = function onBufferCodecs(event, data) {
var hls = this.hls;
if (hls.config.capLevelToPlayerSize && data.video) {
// If the manifest did not signal a video codec capping has been deferred until we're certain video is present
this.startCapping();
}
};
_proto.onMediaDetaching = function onMediaDetaching() {
this.stopCapping();
};
_proto.detectPlayerSize = function detectPlayerSize() {
if (this.media && this.mediaHeight > 0 && this.mediaWidth > 0) {
var levels = this.hls.levels;
if (levels.length) {
var hls = this.hls;
hls.autoLevelCapping = this.getMaxLevel(levels.length - 1);
if (hls.autoLevelCapping > this.autoLevelCapping && this.streamController) {
// if auto level capping has a higher value for the previous one, flush the buffer using nextLevelSwitch
// usually happen when the user go to the fullscreen mode.
this.streamController.nextLevelSwitch();
}
this.autoLevelCapping = hls.autoLevelCapping;
}
}
}
/*
* returns level should be the one with the dimensions equal or greater than the media (player) dimensions (so the video will be downscaled)
*/
;
_proto.getMaxLevel = function getMaxLevel(capLevelIndex) {
var _this = this;
var levels = this.hls.levels;
if (!levels.length) {
return -1;
}
var validLevels = levels.filter(function (level, index) {
return CapLevelController.isLevelAllowed(index, _this.restrictedLevels) && index <= capLevelIndex;
});
this.clientRect = null;
return CapLevelController.getMaxLevelByMediaSize(validLevels, this.mediaWidth, this.mediaHeight);
};
_proto.startCapping = function startCapping() {
if (this.timer) {
// Don't reset capping if started twice; this can happen if the manifest signals a video codec
return;
}
this.autoLevelCapping = Number.POSITIVE_INFINITY;
this.hls.firstLevel = this.getMaxLevel(this.firstLevel);
self.clearInterval(this.timer);
this.timer = self.setInterval(this.detectPlayerSize.bind(this), 1000);
this.detectPlayerSize();
};
_proto.stopCapping = function stopCapping() {
this.restrictedLevels = [];
this.firstLevel = -1;
this.autoLevelCapping = Number.POSITIVE_INFINITY;
if (this.timer) {
self.clearInterval(this.timer);
this.timer = undefined;
}
};
_proto.getDimensions = function getDimensions() {
if (this.clientRect) {
return this.clientRect;
}
var media = this.media;
var boundsRect = {
width: 0,
height: 0
};
if (media) {
var clientRect = media.getBoundingClientRect();
boundsRect.width = clientRect.width;
boundsRect.height = clientRect.height;
if (!boundsRect.width && !boundsRect.height) {
// When the media element has no width or height (equivalent to not being in the DOM),
// then use its width and height attributes (media.width, media.height)
boundsRect.width = clientRect.right - clientRect.left || media.width || 0;
boundsRect.height = clientRect.bottom - clientRect.top || media.height || 0;
}
}
this.clientRect = boundsRect;
return boundsRect;
};
CapLevelController.isLevelAllowed = function isLevelAllowed(level, restrictedLevels) {
if (restrictedLevels === void 0) {
restrictedLevels = [];
}
return restrictedLevels.indexOf(level) === -1;
};
CapLevelController.getMaxLevelByMediaSize = function getMaxLevelByMediaSize(levels, width, height) {
if (!levels || !levels.length) {
return -1;
} // Levels can have the same dimensions but differing bandwidths - since levels are ordered, we can look to the next
// to determine whether we've chosen the greatest bandwidth for the media's dimensions
var atGreatestBandiwdth = function atGreatestBandiwdth(curLevel, nextLevel) {
if (!nextLevel) {
return true;
}
return curLevel.width !== nextLevel.width || curLevel.height !== nextLevel.height;
}; // If we run through the loop without breaking, the media's dimensions are greater than every level, so default to
// the max level
var maxLevelIndex = levels.length - 1;
for (var i = 0; i < levels.length; i += 1) {
var level = levels[i];
if ((level.width >= width || level.height >= height) && atGreatestBandiwdth(level, levels[i + 1])) {
maxLevelIndex = i;
break;
}
}
return maxLevelIndex;
};
_createClass(CapLevelController, [{
key: "mediaWidth",
get: function get() {
return this.getDimensions().width * CapLevelController.contentScaleFactor;
}
}, {
key: "mediaHeight",
get: function get() {
return this.getDimensions().height * CapLevelController.contentScaleFactor;
}
}], [{
key: "contentScaleFactor",
get: function get() {
var pixelRatio = 1;
try {
pixelRatio = self.devicePixelRatio;
} catch (e) {
/* no-op */
}
return pixelRatio;
}
}]);
return CapLevelController;
}();
/* harmony default export */ __webpack_exports__["default"] = (CapLevelController);
/***/ }),
/***/ "./src/controller/eme-controller.ts":
/*!******************************************!*\
!*** ./src/controller/eme-controller.ts ***!
\******************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _utils_mediakeys_helper__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/mediakeys-helper */ "./src/utils/mediakeys-helper.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
/**
* @author Stephan Hesse <disparat@gmail.com> | <tchakabam@gmail.com>
*
* DRM support for Hls.js
*/
var MAX_LICENSE_REQUEST_FAILURES = 3;
/**
* @see https://developer.mozilla.org/en-US/docs/Web/API/MediaKeySystemConfiguration
* @param {Array<string>} audioCodecs List of required audio codecs to support
* @param {Array<string>} videoCodecs List of required video codecs to support
* @param {object} drmSystemOptions Optional parameters/requirements for the key-system
* @returns {Array<MediaSystemConfiguration>} An array of supported configurations
*/
var createWidevineMediaKeySystemConfigurations = function createWidevineMediaKeySystemConfigurations(audioCodecs, videoCodecs, drmSystemOptions) {
/* jshint ignore:line */
var baseConfig = {
// initDataTypes: ['keyids', 'mp4'],
// label: "",
// persistentState: "not-allowed", // or "required" ?
// distinctiveIdentifier: "not-allowed", // or "required" ?
// sessionTypes: ['temporary'],
audioCapabilities: [],
// { contentType: 'audio/mp4; codecs="mp4a.40.2"' }
videoCapabilities: [] // { contentType: 'video/mp4; codecs="avc1.42E01E"' }
};
audioCodecs.forEach(function (codec) {
baseConfig.audioCapabilities.push({
contentType: "audio/mp4; codecs=\"" + codec + "\"",
robustness: drmSystemOptions.audioRobustness || ''
});
});
videoCodecs.forEach(function (codec) {
baseConfig.videoCapabilities.push({
contentType: "video/mp4; codecs=\"" + codec + "\"",
robustness: drmSystemOptions.videoRobustness || ''
});
});
return [baseConfig];
};
/**
* The idea here is to handle key-system (and their respective platforms) specific configuration differences
* in order to work with the local requestMediaKeySystemAccess method.
*
* We can also rule-out platform-related key-system support at this point by throwing an error.
*
* @param {string} keySystem Identifier for the key-system, see `KeySystems` enum
* @param {Array<string>} audioCodecs List of required audio codecs to support
* @param {Array<string>} videoCodecs List of required video codecs to support
* @throws will throw an error if a unknown key system is passed
* @returns {Array<MediaSystemConfiguration>} A non-empty Array of MediaKeySystemConfiguration objects
*/
var getSupportedMediaKeySystemConfigurations = function getSupportedMediaKeySystemConfigurations(keySystem, audioCodecs, videoCodecs, drmSystemOptions) {
switch (keySystem) {
case _utils_mediakeys_helper__WEBPACK_IMPORTED_MODULE_3__["KeySystems"].WIDEVINE:
return createWidevineMediaKeySystemConfigurations(audioCodecs, videoCodecs, drmSystemOptions);
default:
throw new Error("Unknown key-system: " + keySystem);
}
};
/**
* Controller to deal with encrypted media extensions (EME)
* @see https://developer.mozilla.org/en-US/docs/Web/API/Encrypted_Media_Extensions_API
*
* @class
* @constructor
*/
var EMEController = /*#__PURE__*/function () {
/**
* @constructs
* @param {Hls} hls Our Hls.js instance
*/
function EMEController(hls) {
this.hls = void 0;
this._widevineLicenseUrl = void 0;
this._licenseXhrSetup = void 0;
this._licenseResponseCallback = void 0;
this._emeEnabled = void 0;
this._requestMediaKeySystemAccess = void 0;
this._drmSystemOptions = void 0;
this._config = void 0;
this._mediaKeysList = [];
this._media = null;
this._hasSetMediaKeys = false;
this._requestLicenseFailureCount = 0;
this.mediaKeysPromise = null;
this._onMediaEncrypted = this.onMediaEncrypted.bind(this);
this.hls = hls;
this._config = hls.config;
this._widevineLicenseUrl = this._config.widevineLicenseUrl;
this._licenseXhrSetup = this._config.licenseXhrSetup;
this._licenseResponseCallback = this._config.licenseResponseCallback;
this._emeEnabled = this._config.emeEnabled;
this._requestMediaKeySystemAccess = this._config.requestMediaKeySystemAccessFunc;
this._drmSystemOptions = this._config.drmSystemOptions;
this._registerListeners();
}
var _proto = EMEController.prototype;
_proto.destroy = function destroy() {
this._unregisterListeners(); // @ts-ignore
this.hls = this._onMediaEncrypted = null;
this._requestMediaKeySystemAccess = null;
};
_proto._registerListeners = function _registerListeners() {
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHED, this.onMediaDetached, this);
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
};
_proto._unregisterListeners = function _unregisterListeners() {
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHED, this.onMediaDetached, this);
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
}
/**
* @param {string} keySystem Identifier for the key-system, see `KeySystems` enum
* @returns {string} License server URL for key-system (if any configured, otherwise causes error)
* @throws if a unsupported keysystem is passed
*/
;
_proto.getLicenseServerUrl = function getLicenseServerUrl(keySystem) {
switch (keySystem) {
case _utils_mediakeys_helper__WEBPACK_IMPORTED_MODULE_3__["KeySystems"].WIDEVINE:
if (!this._widevineLicenseUrl) {
break;
}
return this._widevineLicenseUrl;
}
throw new Error("no license server URL configured for key-system \"" + keySystem + "\"");
}
/**
* Requests access object and adds it to our list upon success
* @private
* @param {string} keySystem System ID (see `KeySystems`)
* @param {Array<string>} audioCodecs List of required audio codecs to support
* @param {Array<string>} videoCodecs List of required video codecs to support
* @throws When a unsupported KeySystem is passed
*/
;
_proto._attemptKeySystemAccess = function _attemptKeySystemAccess(keySystem, audioCodecs, videoCodecs) {
var _this = this;
// This can throw, but is caught in event handler callpath
var mediaKeySystemConfigs = getSupportedMediaKeySystemConfigurations(keySystem, audioCodecs, videoCodecs, this._drmSystemOptions);
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('Requesting encrypted media key-system access'); // expecting interface like window.navigator.requestMediaKeySystemAccess
var keySystemAccessPromise = this.requestMediaKeySystemAccess(keySystem, mediaKeySystemConfigs);
this.mediaKeysPromise = keySystemAccessPromise.then(function (mediaKeySystemAccess) {
return _this._onMediaKeySystemAccessObtained(keySystem, mediaKeySystemAccess);
});
keySystemAccessPromise.catch(function (err) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error("Failed to obtain key-system \"" + keySystem + "\" access:", err);
});
};
/**
* Handles obtaining access to a key-system
* @private
* @param {string} keySystem
* @param {MediaKeySystemAccess} mediaKeySystemAccess https://developer.mozilla.org/en-US/docs/Web/API/MediaKeySystemAccess
*/
_proto._onMediaKeySystemAccessObtained = function _onMediaKeySystemAccessObtained(keySystem, mediaKeySystemAccess) {
var _this2 = this;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("Access for key-system \"" + keySystem + "\" obtained");
var mediaKeysListItem = {
mediaKeysSessionInitialized: false,
mediaKeySystemAccess: mediaKeySystemAccess,
mediaKeySystemDomain: keySystem
};
this._mediaKeysList.push(mediaKeysListItem);
var mediaKeysPromise = Promise.resolve().then(function () {
return mediaKeySystemAccess.createMediaKeys();
}).then(function (mediaKeys) {
mediaKeysListItem.mediaKeys = mediaKeys;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("Media-keys created for key-system \"" + keySystem + "\"");
_this2._onMediaKeysCreated();
return mediaKeys;
});
mediaKeysPromise.catch(function (err) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error('Failed to create media-keys:', err);
});
return mediaKeysPromise;
}
/**
* Handles key-creation (represents access to CDM). We are going to create key-sessions upon this
* for all existing keys where no session exists yet.
*
* @private
*/
;
_proto._onMediaKeysCreated = function _onMediaKeysCreated() {
var _this3 = this;
// check for all key-list items if a session exists, otherwise, create one
this._mediaKeysList.forEach(function (mediaKeysListItem) {
if (!mediaKeysListItem.mediaKeysSession) {
// mediaKeys is definitely initialized here
mediaKeysListItem.mediaKeysSession = mediaKeysListItem.mediaKeys.createSession();
_this3._onNewMediaKeySession(mediaKeysListItem.mediaKeysSession);
}
});
}
/**
* @private
* @param {*} keySession
*/
;
_proto._onNewMediaKeySession = function _onNewMediaKeySession(keySession) {
var _this4 = this;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("New key-system session " + keySession.sessionId);
keySession.addEventListener('message', function (event) {
_this4._onKeySessionMessage(keySession, event.message);
}, false);
}
/**
* @private
* @param {MediaKeySession} keySession
* @param {ArrayBuffer} message
*/
;
_proto._onKeySessionMessage = function _onKeySessionMessage(keySession, message) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('Got EME message event, creating license request');
this._requestLicense(message, function (data) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("Received license data (length: " + (data ? data.byteLength : data) + "), updating key-session");
keySession.update(data);
});
}
/**
* @private
* @param e {MediaEncryptedEvent}
*/
;
_proto.onMediaEncrypted = function onMediaEncrypted(e) {
var _this5 = this;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("Media is encrypted using \"" + e.initDataType + "\" init data type");
if (!this.mediaKeysPromise) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error('Fatal: Media is encrypted but no CDM access or no keys have been requested');
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_NO_KEYS,
fatal: true
});
return;
}
var finallySetKeyAndStartSession = function finallySetKeyAndStartSession(mediaKeys) {
if (!_this5._media) {
return;
}
_this5._attemptSetMediaKeys(mediaKeys);
_this5._generateRequestWithPreferredKeySession(e.initDataType, e.initData);
}; // Could use `Promise.finally` but some Promise polyfills are missing it
this.mediaKeysPromise.then(finallySetKeyAndStartSession).catch(finallySetKeyAndStartSession);
}
/**
* @private
*/
;
_proto._attemptSetMediaKeys = function _attemptSetMediaKeys(mediaKeys) {
if (!this._media) {
throw new Error('Attempted to set mediaKeys without first attaching a media element');
}
if (!this._hasSetMediaKeys) {
// FIXME: see if we can/want/need-to really to deal with several potential key-sessions?
var keysListItem = this._mediaKeysList[0];
if (!keysListItem || !keysListItem.mediaKeys) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error('Fatal: Media is encrypted but no CDM access or no keys have been obtained yet');
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_NO_KEYS,
fatal: true
});
return;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('Setting keys for encrypted media');
this._media.setMediaKeys(keysListItem.mediaKeys);
this._hasSetMediaKeys = true;
}
}
/**
* @private
*/
;
_proto._generateRequestWithPreferredKeySession = function _generateRequestWithPreferredKeySession(initDataType, initData) {
var _this6 = this;
// FIXME: see if we can/want/need-to really to deal with several potential key-sessions?
var keysListItem = this._mediaKeysList[0];
if (!keysListItem) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error('Fatal: Media is encrypted but not any key-system access has been obtained yet');
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_NO_ACCESS,
fatal: true
});
return;
}
if (keysListItem.mediaKeysSessionInitialized) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn('Key-Session already initialized but requested again');
return;
}
var keySession = keysListItem.mediaKeysSession;
if (!keySession) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error('Fatal: Media is encrypted but no key-session existing');
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_NO_SESSION,
fatal: true
});
return;
} // initData is null if the media is not CORS-same-origin
if (!initData) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn('Fatal: initData required for generating a key session is null');
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_NO_INIT_DATA,
fatal: true
});
return;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("Generating key-session request for \"" + initDataType + "\" init data type");
keysListItem.mediaKeysSessionInitialized = true;
keySession.generateRequest(initDataType, initData).then(function () {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].debug('Key-session generation succeeded');
}).catch(function (err) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error('Error generating key-session request:', err);
_this6.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_NO_SESSION,
fatal: false
});
});
}
/**
* @private
* @param {string} url License server URL
* @param {ArrayBuffer} keyMessage Message data issued by key-system
* @param {function} callback Called when XHR has succeeded
* @returns {XMLHttpRequest} Unsent (but opened state) XHR object
* @throws if XMLHttpRequest construction failed
*/
;
_proto._createLicenseXhr = function _createLicenseXhr(url, keyMessage, callback) {
var xhr = new XMLHttpRequest();
xhr.responseType = 'arraybuffer';
xhr.onreadystatechange = this._onLicenseRequestReadyStageChange.bind(this, xhr, url, keyMessage, callback);
var licenseXhrSetup = this._licenseXhrSetup;
if (licenseXhrSetup) {
try {
licenseXhrSetup.call(this.hls, xhr, url);
licenseXhrSetup = undefined;
} catch (e) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error(e);
}
}
try {
// if licenseXhrSetup did not yet call open, let's do it now
if (!xhr.readyState) {
xhr.open('POST', url, true);
}
if (licenseXhrSetup) {
licenseXhrSetup.call(this.hls, xhr, url);
}
} catch (e) {
// IE11 throws an exception on xhr.open if attempting to access an HTTP resource over HTTPS
throw new Error("issue setting up KeySystem license XHR " + e);
}
return xhr;
}
/**
* @private
* @param {XMLHttpRequest} xhr
* @param {string} url License server URL
* @param {ArrayBuffer} keyMessage Message data issued by key-system
* @param {function} callback Called when XHR has succeeded
*/
;
_proto._onLicenseRequestReadyStageChange = function _onLicenseRequestReadyStageChange(xhr, url, keyMessage, callback) {
switch (xhr.readyState) {
case 4:
if (xhr.status === 200) {
this._requestLicenseFailureCount = 0;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('License request succeeded');
var _data = xhr.response;
var licenseResponseCallback = this._licenseResponseCallback;
if (licenseResponseCallback) {
try {
_data = licenseResponseCallback.call(this.hls, xhr, url);
} catch (e) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error(e);
}
}
callback(_data);
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error("License Request XHR failed (" + url + "). Status: " + xhr.status + " (" + xhr.statusText + ")");
this._requestLicenseFailureCount++;
if (this._requestLicenseFailureCount > MAX_LICENSE_REQUEST_FAILURES) {
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_LICENSE_REQUEST_FAILED,
fatal: true
});
return;
}
var attemptsLeft = MAX_LICENSE_REQUEST_FAILURES - this._requestLicenseFailureCount + 1;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("Retrying license request, " + attemptsLeft + " attempts left");
this._requestLicense(keyMessage, callback);
}
break;
}
}
/**
* @private
* @param {MediaKeysListItem} keysListItem
* @param {ArrayBuffer} keyMessage
* @returns {ArrayBuffer} Challenge data posted to license server
* @throws if KeySystem is unsupported
*/
;
_proto._generateLicenseRequestChallenge = function _generateLicenseRequestChallenge(keysListItem, keyMessage) {
switch (keysListItem.mediaKeySystemDomain) {
// case KeySystems.PLAYREADY:
// from https://github.com/MicrosoftEdge/Demos/blob/master/eme/scripts/demo.js
/*
if (this.licenseType !== this.LICENSE_TYPE_WIDEVINE) {
// For PlayReady CDMs, we need to dig the Challenge out of the XML.
var keyMessageXml = new DOMParser().parseFromString(String.fromCharCode.apply(null, new Uint16Array(keyMessage)), 'application/xml');
if (keyMessageXml.getElementsByTagName('Challenge')[0]) {
challenge = atob(keyMessageXml.getElementsByTagName('Challenge')[0].childNodes[0].nodeValue);
} else {
throw 'Cannot find <Challenge> in key message';
}
var headerNames = keyMessageXml.getElementsByTagName('name');
var headerValues = keyMessageXml.getElementsByTagName('value');
if (headerNames.length !== headerValues.length) {
throw 'Mismatched header <name>/<value> pair in key message';
}
for (var i = 0; i < headerNames.length; i++) {
xhr.setRequestHeader(headerNames[i].childNodes[0].nodeValue, headerValues[i].childNodes[0].nodeValue);
}
}
break;
*/
case _utils_mediakeys_helper__WEBPACK_IMPORTED_MODULE_3__["KeySystems"].WIDEVINE:
// For Widevine CDMs, the challenge is the keyMessage.
return keyMessage;
}
throw new Error("unsupported key-system: " + keysListItem.mediaKeySystemDomain);
}
/**
* @private
* @param keyMessage
* @param callback
*/
;
_proto._requestLicense = function _requestLicense(keyMessage, callback) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('Requesting content license for key-system');
var keysListItem = this._mediaKeysList[0];
if (!keysListItem) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error('Fatal error: Media is encrypted but no key-system access has been obtained yet');
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_NO_ACCESS,
fatal: true
});
return;
}
try {
var _url = this.getLicenseServerUrl(keysListItem.mediaKeySystemDomain);
var _xhr = this._createLicenseXhr(_url, keyMessage, callback);
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log("Sending license request to URL: " + _url);
var challenge = this._generateLicenseRequestChallenge(keysListItem, keyMessage);
_xhr.send(challenge);
} catch (e) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error("Failure requesting DRM license: " + e);
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].KEY_SYSTEM_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_SYSTEM_LICENSE_REQUEST_FAILED,
fatal: true
});
}
};
_proto.onMediaAttached = function onMediaAttached(event, data) {
if (!this._emeEnabled) {
return;
}
var media = data.media; // keep reference of media
this._media = media;
media.addEventListener('encrypted', this._onMediaEncrypted);
};
_proto.onMediaDetached = function onMediaDetached() {
var media = this._media;
var mediaKeysList = this._mediaKeysList;
if (!media) {
return;
}
media.removeEventListener('encrypted', this._onMediaEncrypted);
this._media = null;
this._mediaKeysList = []; // Close all sessions and remove media keys from the video element.
Promise.all(mediaKeysList.map(function (mediaKeysListItem) {
if (mediaKeysListItem.mediaKeysSession) {
return mediaKeysListItem.mediaKeysSession.close().catch(function () {// Ignore errors when closing the sessions. Closing a session that
// generated no key requests will throw an error.
});
}
})).then(function () {
return media.setMediaKeys(null);
}).catch(function () {// Ignore any failures while removing media keys from the video element.
});
};
_proto.onManifestParsed = function onManifestParsed(event, data) {
if (!this._emeEnabled) {
return;
}
var audioCodecs = data.levels.map(function (level) {
return level.audioCodec;
}).filter(function (audioCodec) {
return !!audioCodec;
});
var videoCodecs = data.levels.map(function (level) {
return level.videoCodec;
}).filter(function (videoCodec) {
return !!videoCodec;
});
this._attemptKeySystemAccess(_utils_mediakeys_helper__WEBPACK_IMPORTED_MODULE_3__["KeySystems"].WIDEVINE, audioCodecs, videoCodecs);
};
_createClass(EMEController, [{
key: "requestMediaKeySystemAccess",
get: function get() {
if (!this._requestMediaKeySystemAccess) {
throw new Error('No requestMediaKeySystemAccess function configured');
}
return this._requestMediaKeySystemAccess;
}
}]);
return EMEController;
}();
/* harmony default export */ __webpack_exports__["default"] = (EMEController);
/***/ }),
/***/ "./src/controller/fps-controller.ts":
/*!******************************************!*\
!*** ./src/controller/fps-controller.ts ***!
\******************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
var FPSController = /*#__PURE__*/function () {
// stream controller must be provided as a dependency!
function FPSController(hls) {
this.hls = void 0;
this.isVideoPlaybackQualityAvailable = false;
this.timer = void 0;
this.media = null;
this.lastTime = void 0;
this.lastDroppedFrames = 0;
this.lastDecodedFrames = 0;
this.streamController = void 0;
this.hls = hls;
this.registerListeners();
}
var _proto = FPSController.prototype;
_proto.setStreamController = function setStreamController(streamController) {
this.streamController = streamController;
};
_proto.registerListeners = function registerListeners() {
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHING, this.onMediaAttaching, this);
};
_proto.unregisterListeners = function unregisterListeners() {
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHING, this.onMediaAttaching);
};
_proto.destroy = function destroy() {
if (this.timer) {
clearInterval(this.timer);
}
this.unregisterListeners();
this.isVideoPlaybackQualityAvailable = false;
this.media = null;
};
_proto.onMediaAttaching = function onMediaAttaching(event, data) {
var config = this.hls.config;
if (config.capLevelOnFPSDrop) {
var media = data.media instanceof self.HTMLVideoElement ? data.media : null;
this.media = media;
if (media && typeof media.getVideoPlaybackQuality === 'function') {
this.isVideoPlaybackQualityAvailable = true;
}
self.clearInterval(this.timer);
this.timer = self.setInterval(this.checkFPSInterval.bind(this), config.fpsDroppedMonitoringPeriod);
}
};
_proto.checkFPS = function checkFPS(video, decodedFrames, droppedFrames) {
var currentTime = performance.now();
if (decodedFrames) {
if (this.lastTime) {
var currentPeriod = currentTime - this.lastTime;
var currentDropped = droppedFrames - this.lastDroppedFrames;
var currentDecoded = decodedFrames - this.lastDecodedFrames;
var droppedFPS = 1000 * currentDropped / currentPeriod;
var hls = this.hls;
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FPS_DROP, {
currentDropped: currentDropped,
currentDecoded: currentDecoded,
totalDroppedFrames: droppedFrames
});
if (droppedFPS > 0) {
// logger.log('checkFPS : droppedFPS/decodedFPS:' + droppedFPS/(1000 * currentDecoded / currentPeriod));
if (currentDropped > hls.config.fpsDroppedMonitoringThreshold * currentDecoded) {
var currentLevel = hls.currentLevel;
_utils_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].warn('drop FPS ratio greater than max allowed value for currentLevel: ' + currentLevel);
if (currentLevel > 0 && (hls.autoLevelCapping === -1 || hls.autoLevelCapping >= currentLevel)) {
currentLevel = currentLevel - 1;
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FPS_DROP_LEVEL_CAPPING, {
level: currentLevel,
droppedLevel: hls.currentLevel
});
hls.autoLevelCapping = currentLevel;
this.streamController.nextLevelSwitch();
}
}
}
}
this.lastTime = currentTime;
this.lastDroppedFrames = droppedFrames;
this.lastDecodedFrames = decodedFrames;
}
};
_proto.checkFPSInterval = function checkFPSInterval() {
var video = this.media;
if (video) {
if (this.isVideoPlaybackQualityAvailable) {
var videoPlaybackQuality = video.getVideoPlaybackQuality();
this.checkFPS(video, videoPlaybackQuality.totalVideoFrames, videoPlaybackQuality.droppedVideoFrames);
} else {
// HTMLVideoElement doesn't include the webkit types
this.checkFPS(video, video.webkitDecodedFrameCount, video.webkitDroppedFrameCount);
}
}
};
return FPSController;
}();
/* harmony default export */ __webpack_exports__["default"] = (FPSController);
/***/ }),
/***/ "./src/controller/fragment-finders.ts":
/*!********************************************!*\
!*** ./src/controller/fragment-finders.ts ***!
\********************************************/
/*! exports provided: findFragmentByPDT, findFragmentByPTS, fragmentWithinToleranceTest, pdtWithinToleranceTest, findFragWithCC */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findFragmentByPDT", function() { return findFragmentByPDT; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findFragmentByPTS", function() { return findFragmentByPTS; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fragmentWithinToleranceTest", function() { return fragmentWithinToleranceTest; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pdtWithinToleranceTest", function() { return pdtWithinToleranceTest; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findFragWithCC", function() { return findFragWithCC; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _utils_binary_search__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/binary-search */ "./src/utils/binary-search.ts");
/**
* Returns first fragment whose endPdt value exceeds the given PDT.
* @param {Array<Fragment>} fragments - The array of candidate fragments
* @param {number|null} [PDTValue = null] - The PDT value which must be exceeded
* @param {number} [maxFragLookUpTolerance = 0] - The amount of time that a fragment's start/end can be within in order to be considered contiguous
* @returns {*|null} fragment - The best matching fragment
*/
function findFragmentByPDT(fragments, PDTValue, maxFragLookUpTolerance) {
if (PDTValue === null || !Array.isArray(fragments) || !fragments.length || !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(PDTValue)) {
return null;
} // if less than start
var startPDT = fragments[0].programDateTime;
if (PDTValue < (startPDT || 0)) {
return null;
}
var endPDT = fragments[fragments.length - 1].endProgramDateTime;
if (PDTValue >= (endPDT || 0)) {
return null;
}
maxFragLookUpTolerance = maxFragLookUpTolerance || 0;
for (var seg = 0; seg < fragments.length; ++seg) {
var frag = fragments[seg];
if (pdtWithinToleranceTest(PDTValue, maxFragLookUpTolerance, frag)) {
return frag;
}
}
return null;
}
/**
* Finds a fragment based on the SN of the previous fragment; or based on the needs of the current buffer.
* This method compensates for small buffer gaps by applying a tolerance to the start of any candidate fragment, thus
* breaking any traps which would cause the same fragment to be continuously selected within a small range.
* @param {*} fragPrevious - The last frag successfully appended
* @param {Array} fragments - The array of candidate fragments
* @param {number} [bufferEnd = 0] - The end of the contiguous buffered range the playhead is currently within
* @param {number} maxFragLookUpTolerance - The amount of time that a fragment's start/end can be within in order to be considered contiguous
* @returns {*} foundFrag - The best matching fragment
*/
function findFragmentByPTS(fragPrevious, fragments, bufferEnd, maxFragLookUpTolerance) {
if (bufferEnd === void 0) {
bufferEnd = 0;
}
if (maxFragLookUpTolerance === void 0) {
maxFragLookUpTolerance = 0;
}
var fragNext = null;
if (fragPrevious) {
fragNext = fragments[fragPrevious.sn - fragments[0].sn + 1] || null;
} else if (bufferEnd === 0 && fragments[0].start === 0) {
fragNext = fragments[0];
} // Prefer the next fragment if it's within tolerance
if (fragNext && fragmentWithinToleranceTest(bufferEnd, maxFragLookUpTolerance, fragNext) === 0) {
return fragNext;
} // We might be seeking past the tolerance so find the best match
var foundFragment = _utils_binary_search__WEBPACK_IMPORTED_MODULE_1__["default"].search(fragments, fragmentWithinToleranceTest.bind(null, bufferEnd, maxFragLookUpTolerance));
if (foundFragment) {
return foundFragment;
} // If no match was found return the next fragment after fragPrevious, or null
return fragNext;
}
/**
* The test function used by the findFragmentBySn's BinarySearch to look for the best match to the current buffer conditions.
* @param {*} candidate - The fragment to test
* @param {number} [bufferEnd = 0] - The end of the current buffered range the playhead is currently within
* @param {number} [maxFragLookUpTolerance = 0] - The amount of time that a fragment's start can be within in order to be considered contiguous
* @returns {number} - 0 if it matches, 1 if too low, -1 if too high
*/
function fragmentWithinToleranceTest(bufferEnd, maxFragLookUpTolerance, candidate) {
if (bufferEnd === void 0) {
bufferEnd = 0;
}
if (maxFragLookUpTolerance === void 0) {
maxFragLookUpTolerance = 0;
}
// offset should be within fragment boundary - config.maxFragLookUpTolerance
// this is to cope with situations like
// bufferEnd = 9.991
// frag[Ø] : [0,10]
// frag[1] : [10,20]
// bufferEnd is within frag[0] range ... although what we are expecting is to return frag[1] here
// frag start frag start+duration
// |-----------------------------|
// <---> <--->
// ...--------><-----------------------------><---------....
// previous frag matching fragment next frag
// return -1 return 0 return 1
// logger.log(`level/sn/start/end/bufEnd:${level}/${candidate.sn}/${candidate.start}/${(candidate.start+candidate.duration)}/${bufferEnd}`);
// Set the lookup tolerance to be small enough to detect the current segment - ensures we don't skip over very small segments
var candidateLookupTolerance = Math.min(maxFragLookUpTolerance, candidate.duration + (candidate.deltaPTS ? candidate.deltaPTS : 0));
if (candidate.start + candidate.duration - candidateLookupTolerance <= bufferEnd) {
return 1;
} else if (candidate.start - candidateLookupTolerance > bufferEnd && candidate.start) {
// if maxFragLookUpTolerance will have negative value then don't return -1 for first element
return -1;
}
return 0;
}
/**
* The test function used by the findFragmentByPdt's BinarySearch to look for the best match to the current buffer conditions.
* This function tests the candidate's program date time values, as represented in Unix time
* @param {*} candidate - The fragment to test
* @param {number} [pdtBufferEnd = 0] - The Unix time representing the end of the current buffered range
* @param {number} [maxFragLookUpTolerance = 0] - The amount of time that a fragment's start can be within in order to be considered contiguous
* @returns {boolean} True if contiguous, false otherwise
*/
function pdtWithinToleranceTest(pdtBufferEnd, maxFragLookUpTolerance, candidate) {
var candidateLookupTolerance = Math.min(maxFragLookUpTolerance, candidate.duration + (candidate.deltaPTS ? candidate.deltaPTS : 0)) * 1000; // endProgramDateTime can be null, default to zero
var endProgramDateTime = candidate.endProgramDateTime || 0;
return endProgramDateTime - candidateLookupTolerance > pdtBufferEnd;
}
function findFragWithCC(fragments, cc) {
return _utils_binary_search__WEBPACK_IMPORTED_MODULE_1__["default"].search(fragments, function (candidate) {
if (candidate.cc < cc) {
return 1;
} else if (candidate.cc > cc) {
return -1;
} else {
return 0;
}
});
}
/***/ }),
/***/ "./src/controller/fragment-tracker.ts":
/*!********************************************!*\
!*** ./src/controller/fragment-tracker.ts ***!
\********************************************/
/*! exports provided: FragmentState, FragmentTracker */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FragmentState", function() { return FragmentState; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FragmentTracker", function() { return FragmentTracker; });
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
var FragmentState;
(function (FragmentState) {
FragmentState["NOT_LOADED"] = "NOT_LOADED";
FragmentState["BACKTRACKED"] = "BACKTRACKED";
FragmentState["APPENDING"] = "APPENDING";
FragmentState["PARTIAL"] = "PARTIAL";
FragmentState["OK"] = "OK";
})(FragmentState || (FragmentState = {}));
var FragmentTracker = /*#__PURE__*/function () {
function FragmentTracker(hls) {
this.activeFragment = null;
this.activeParts = null;
this.fragments = Object.create(null);
this.timeRanges = Object.create(null);
this.bufferPadding = 0.2;
this.hls = void 0;
this.hls = hls;
this._registerListeners();
}
var _proto = FragmentTracker.prototype;
_proto._registerListeners = function _registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].BUFFER_APPENDED, this.onBufferAppended, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FRAG_BUFFERED, this.onFragBuffered, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FRAG_LOADED, this.onFragLoaded, this);
};
_proto._unregisterListeners = function _unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].BUFFER_APPENDED, this.onBufferAppended, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FRAG_BUFFERED, this.onFragBuffered, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FRAG_LOADED, this.onFragLoaded, this);
};
_proto.destroy = function destroy() {
this._unregisterListeners(); // @ts-ignore
this.fragments = this.timeRanges = null;
}
/**
* Return a Fragment with an appended range that matches the position and levelType.
* If not found any Fragment, return null
*/
;
_proto.getAppendedFrag = function getAppendedFrag(position, levelType) {
if (levelType === _types_loader__WEBPACK_IMPORTED_MODULE_1__["PlaylistLevelType"].MAIN) {
var activeFragment = this.activeFragment,
activeParts = this.activeParts;
if (!activeFragment) {
return null;
}
if (activeParts) {
for (var i = activeParts.length; i--;) {
var activePart = activeParts[i];
var appendedPTS = activePart ? activePart.end : activeFragment.appendedPTS;
if (activePart.start <= position && appendedPTS !== undefined && position <= appendedPTS) {
// 9 is a magic number. remove parts from lookup after a match but keep some short seeks back.
if (i > 9) {
this.activeParts = activeParts.slice(i - 9);
}
return activePart;
}
}
} else if (activeFragment.start <= position && activeFragment.appendedPTS !== undefined && position <= activeFragment.appendedPTS) {
return activeFragment;
}
}
return this.getBufferedFrag(position, levelType);
}
/**
* Return a buffered Fragment that matches the position and levelType.
* A buffered Fragment is one whose loading, parsing and appending is done (completed or "partial" meaning aborted).
* If not found any Fragment, return null
*/
;
_proto.getBufferedFrag = function getBufferedFrag(position, levelType) {
var fragments = this.fragments;
var keys = Object.keys(fragments);
for (var i = keys.length; i--;) {
var fragmentEntity = fragments[keys[i]];
if ((fragmentEntity === null || fragmentEntity === void 0 ? void 0 : fragmentEntity.body.type) === levelType && fragmentEntity.buffered) {
var frag = fragmentEntity.body;
if (frag.start <= position && position <= frag.end) {
return frag;
}
}
}
return null;
}
/**
* Partial fragments effected by coded frame eviction will be removed
* The browser will unload parts of the buffer to free up memory for new buffer data
* Fragments will need to be reloaded when the buffer is freed up, removing partial fragments will allow them to reload(since there might be parts that are still playable)
*/
;
_proto.detectEvictedFragments = function detectEvictedFragments(elementaryStream, timeRange, playlistType) {
var _this = this;
// Check if any flagged fragments have been unloaded
Object.keys(this.fragments).forEach(function (key) {
var fragmentEntity = _this.fragments[key];
if (!fragmentEntity) {
return;
}
if (!fragmentEntity.buffered) {
if (fragmentEntity.body.type === playlistType) {
_this.removeFragment(fragmentEntity.body);
}
return;
}
var esData = fragmentEntity.range[elementaryStream];
if (!esData) {
return;
}
esData.time.some(function (time) {
var isNotBuffered = !_this.isTimeBuffered(time.startPTS, time.endPTS, timeRange);
if (isNotBuffered) {
// Unregister partial fragment as it needs to load again to be reused
_this.removeFragment(fragmentEntity.body);
}
return isNotBuffered;
});
});
}
/**
* Checks if the fragment passed in is loaded in the buffer properly
* Partially loaded fragments will be registered as a partial fragment
*/
;
_proto.detectPartialFragments = function detectPartialFragments(data) {
var _this2 = this;
var timeRanges = this.timeRanges;
var frag = data.frag,
part = data.part;
if (!timeRanges || frag.sn === 'initSegment') {
return;
}
var fragKey = getFragmentKey(frag);
var fragmentEntity = this.fragments[fragKey];
if (!fragmentEntity) {
return;
}
Object.keys(timeRanges).forEach(function (elementaryStream) {
var streamInfo = frag.elementaryStreams[elementaryStream];
if (!streamInfo) {
return;
}
var timeRange = timeRanges[elementaryStream];
var partial = part !== null || streamInfo.partial === true;
fragmentEntity.range[elementaryStream] = _this2.getBufferedTimes(frag, part, partial, timeRange);
});
fragmentEntity.backtrack = fragmentEntity.loaded = null;
if (Object.keys(fragmentEntity.range).length) {
fragmentEntity.buffered = true;
} else {
// remove fragment if nothing was appended
this.removeFragment(fragmentEntity.body);
}
};
_proto.fragBuffered = function fragBuffered(frag) {
var fragKey = getFragmentKey(frag);
var fragmentEntity = this.fragments[fragKey];
if (fragmentEntity) {
fragmentEntity.backtrack = fragmentEntity.loaded = null;
fragmentEntity.buffered = true;
}
};
_proto.getBufferedTimes = function getBufferedTimes(fragment, part, partial, timeRange) {
var buffered = {
time: [],
partial: partial
};
var startPTS = part ? part.start : fragment.start;
var endPTS = part ? part.end : fragment.end;
var minEndPTS = fragment.minEndPTS || endPTS;
var maxStartPTS = fragment.maxStartPTS || startPTS;
for (var i = 0; i < timeRange.length; i++) {
var startTime = timeRange.start(i) - this.bufferPadding;
var endTime = timeRange.end(i) + this.bufferPadding;
if (maxStartPTS >= startTime && minEndPTS <= endTime) {
// Fragment is entirely contained in buffer
// No need to check the other timeRange times since it's completely playable
buffered.time.push({
startPTS: Math.max(startPTS, timeRange.start(i)),
endPTS: Math.min(endPTS, timeRange.end(i))
});
break;
} else if (startPTS < endTime && endPTS > startTime) {
buffered.partial = true; // Check for intersection with buffer
// Get playable sections of the fragment
buffered.time.push({
startPTS: Math.max(startPTS, timeRange.start(i)),
endPTS: Math.min(endPTS, timeRange.end(i))
});
} else if (endPTS <= startTime) {
// No need to check the rest of the timeRange as it is in order
break;
}
}
return buffered;
}
/**
* Gets the partial fragment for a certain time
*/
;
_proto.getPartialFragment = function getPartialFragment(time) {
var bestFragment = null;
var timePadding;
var startTime;
var endTime;
var bestOverlap = 0;
var bufferPadding = this.bufferPadding,
fragments = this.fragments;
Object.keys(fragments).forEach(function (key) {
var fragmentEntity = fragments[key];
if (!fragmentEntity) {
return;
}
if (isPartial(fragmentEntity)) {
startTime = fragmentEntity.body.start - bufferPadding;
endTime = fragmentEntity.body.end + bufferPadding;
if (time >= startTime && time <= endTime) {
// Use the fragment that has the most padding from start and end time
timePadding = Math.min(time - startTime, endTime - time);
if (bestOverlap <= timePadding) {
bestFragment = fragmentEntity.body;
bestOverlap = timePadding;
}
}
}
});
return bestFragment;
};
_proto.getState = function getState(fragment) {
var fragKey = getFragmentKey(fragment);
var fragmentEntity = this.fragments[fragKey];
if (fragmentEntity) {
if (!fragmentEntity.buffered) {
if (fragmentEntity.backtrack) {
return FragmentState.BACKTRACKED;
}
return FragmentState.APPENDING;
} else if (isPartial(fragmentEntity)) {
return FragmentState.PARTIAL;
} else {
return FragmentState.OK;
}
}
return FragmentState.NOT_LOADED;
};
_proto.backtrack = function backtrack(frag, data) {
var fragKey = getFragmentKey(frag);
var fragmentEntity = this.fragments[fragKey];
if (!fragmentEntity || fragmentEntity.backtrack) {
return null;
}
var backtrack = fragmentEntity.backtrack = data ? data : fragmentEntity.loaded;
fragmentEntity.loaded = null;
return backtrack;
};
_proto.getBacktrackData = function getBacktrackData(fragment) {
var fragKey = getFragmentKey(fragment);
var fragmentEntity = this.fragments[fragKey];
if (fragmentEntity) {
var _backtrack$payload;
var backtrack = fragmentEntity.backtrack; // If data was already sent to Worker it is detached no longer available
if (backtrack !== null && backtrack !== void 0 && (_backtrack$payload = backtrack.payload) !== null && _backtrack$payload !== void 0 && _backtrack$payload.byteLength) {
return backtrack;
} else {
this.removeFragment(fragment);
}
}
return null;
};
_proto.isTimeBuffered = function isTimeBuffered(startPTS, endPTS, timeRange) {
var startTime;
var endTime;
for (var i = 0; i < timeRange.length; i++) {
startTime = timeRange.start(i) - this.bufferPadding;
endTime = timeRange.end(i) + this.bufferPadding;
if (startPTS >= startTime && endPTS <= endTime) {
return true;
}
if (endPTS <= startTime) {
// No need to check the rest of the timeRange as it is in order
return false;
}
}
return false;
};
_proto.onFragLoaded = function onFragLoaded(event, data) {
var frag = data.frag,
part = data.part; // don't track initsegment (for which sn is not a number)
// don't track frags used for bitrateTest, they're irrelevant.
// don't track parts for memory efficiency
if (frag.sn === 'initSegment' || frag.bitrateTest || part) {
return;
}
var fragKey = getFragmentKey(frag);
this.fragments[fragKey] = {
body: frag,
loaded: data,
backtrack: null,
buffered: false,
range: Object.create(null)
};
};
_proto.onBufferAppended = function onBufferAppended(event, data) {
var _this3 = this;
var frag = data.frag,
part = data.part,
timeRanges = data.timeRanges;
if (frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_1__["PlaylistLevelType"].MAIN) {
this.activeFragment = frag;
if (part) {
var activeParts = this.activeParts;
if (!activeParts) {
this.activeParts = activeParts = [];
}
activeParts.push(part);
} else {
this.activeParts = null;
}
} // Store the latest timeRanges loaded in the buffer
this.timeRanges = timeRanges;
Object.keys(timeRanges).forEach(function (elementaryStream) {
var timeRange = timeRanges[elementaryStream];
_this3.detectEvictedFragments(elementaryStream, timeRange);
if (!part) {
for (var i = 0; i < timeRange.length; i++) {
frag.appendedPTS = Math.max(timeRange.end(i), frag.appendedPTS || 0);
}
}
});
};
_proto.onFragBuffered = function onFragBuffered(event, data) {
this.detectPartialFragments(data);
};
_proto.hasFragment = function hasFragment(fragment) {
var fragKey = getFragmentKey(fragment);
return !!this.fragments[fragKey];
};
_proto.removeFragmentsInRange = function removeFragmentsInRange(start, end, playlistType) {
var _this4 = this;
Object.keys(this.fragments).forEach(function (key) {
var fragmentEntity = _this4.fragments[key];
if (!fragmentEntity) {
return;
}
if (fragmentEntity.buffered) {
var frag = fragmentEntity.body;
if (frag.type === playlistType && frag.start < end && frag.end > start) {
_this4.removeFragment(frag);
}
}
});
};
_proto.removeFragment = function removeFragment(fragment) {
var fragKey = getFragmentKey(fragment);
fragment.stats.loaded = 0;
fragment.clearElementaryStreamInfo();
delete this.fragments[fragKey];
};
_proto.removeAllFragments = function removeAllFragments() {
this.fragments = Object.create(null);
this.activeFragment = null;
this.activeParts = null;
};
return FragmentTracker;
}();
function isPartial(fragmentEntity) {
var _fragmentEntity$range, _fragmentEntity$range2;
return fragmentEntity.buffered && (((_fragmentEntity$range = fragmentEntity.range.video) === null || _fragmentEntity$range === void 0 ? void 0 : _fragmentEntity$range.partial) || ((_fragmentEntity$range2 = fragmentEntity.range.audio) === null || _fragmentEntity$range2 === void 0 ? void 0 : _fragmentEntity$range2.partial));
}
function getFragmentKey(fragment) {
return fragment.type + "_" + fragment.level + "_" + fragment.urlId + "_" + fragment.sn;
}
/***/ }),
/***/ "./src/controller/gap-controller.ts":
/*!******************************************!*\
!*** ./src/controller/gap-controller.ts ***!
\******************************************/
/*! exports provided: STALL_MINIMUM_DURATION_MS, MAX_START_GAP_JUMP, SKIP_BUFFER_HOLE_STEP_SECONDS, SKIP_BUFFER_RANGE_START, default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "STALL_MINIMUM_DURATION_MS", function() { return STALL_MINIMUM_DURATION_MS; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MAX_START_GAP_JUMP", function() { return MAX_START_GAP_JUMP; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SKIP_BUFFER_HOLE_STEP_SECONDS", function() { return SKIP_BUFFER_HOLE_STEP_SECONDS; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SKIP_BUFFER_RANGE_START", function() { return SKIP_BUFFER_RANGE_START; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return GapController; });
/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
var STALL_MINIMUM_DURATION_MS = 250;
var MAX_START_GAP_JUMP = 2.0;
var SKIP_BUFFER_HOLE_STEP_SECONDS = 0.1;
var SKIP_BUFFER_RANGE_START = 0.05;
var GapController = /*#__PURE__*/function () {
function GapController(config, media, fragmentTracker, hls) {
this.config = void 0;
this.media = void 0;
this.fragmentTracker = void 0;
this.hls = void 0;
this.nudgeRetry = 0;
this.stallReported = false;
this.stalled = null;
this.moved = false;
this.seeking = false;
this.config = config;
this.media = media;
this.fragmentTracker = fragmentTracker;
this.hls = hls;
}
var _proto = GapController.prototype;
_proto.destroy = function destroy() {
// @ts-ignore
this.hls = this.fragmentTracker = this.media = null;
}
/**
* Checks if the playhead is stuck within a gap, and if so, attempts to free it.
* A gap is an unbuffered range between two buffered ranges (or the start and the first buffered range).
*
* @param {number} lastCurrentTime Previously read playhead position
*/
;
_proto.poll = function poll(lastCurrentTime) {
var config = this.config,
media = this.media,
stalled = this.stalled;
var currentTime = media.currentTime,
seeking = media.seeking;
var seeked = this.seeking && !seeking;
var beginSeek = !this.seeking && seeking;
this.seeking = seeking; // The playhead is moving, no-op
if (currentTime !== lastCurrentTime) {
this.moved = true;
if (stalled !== null) {
// The playhead is now moving, but was previously stalled
if (this.stallReported) {
var _stalledDuration = self.performance.now() - stalled;
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn("playback not stuck anymore @" + currentTime + ", after " + Math.round(_stalledDuration) + "ms");
this.stallReported = false;
}
this.stalled = null;
this.nudgeRetry = 0;
}
return;
} // Clear stalled state when beginning or finishing seeking so that we don't report stalls coming out of a seek
if (beginSeek || seeked) {
this.stalled = null;
} // The playhead should not be moving
if (media.paused || media.ended || media.playbackRate === 0 || !_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_0__["BufferHelper"].getBuffered(media).length) {
return;
}
var bufferInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_0__["BufferHelper"].bufferInfo(media, currentTime, 0);
var isBuffered = bufferInfo.len > 0;
var nextStart = bufferInfo.nextStart || 0; // There is no playable buffer (seeked, waiting for buffer)
if (!isBuffered && !nextStart) {
return;
}
if (seeking) {
// Waiting for seeking in a buffered range to complete
var hasEnoughBuffer = bufferInfo.len > MAX_START_GAP_JUMP; // Next buffered range is too far ahead to jump to while still seeking
var noBufferGap = !nextStart || nextStart - currentTime > MAX_START_GAP_JUMP && !this.fragmentTracker.getPartialFragment(currentTime);
if (hasEnoughBuffer || noBufferGap) {
return;
} // Reset moved state when seeking to a point in or before a gap
this.moved = false;
} // Skip start gaps if we haven't played, but the last poll detected the start of a stall
// The addition poll gives the browser a chance to jump the gap for us
if (!this.moved && this.stalled !== null) {
var _level$details;
// Jump start gaps within jump threshold
var startJump = Math.max(nextStart, bufferInfo.start || 0) - currentTime; // When joining a live stream with audio tracks, account for live playlist window sliding by allowing
// a larger jump over start gaps caused by the audio-stream-controller buffering a start fragment
// that begins over 1 target duration after the video start position.
var level = this.hls.levels ? this.hls.levels[this.hls.currentLevel] : null;
var isLive = level === null || level === void 0 ? void 0 : (_level$details = level.details) === null || _level$details === void 0 ? void 0 : _level$details.live;
var maxStartGapJump = isLive ? level.details.targetduration * 2 : MAX_START_GAP_JUMP;
if (startJump > 0 && startJump <= maxStartGapJump) {
this._trySkipBufferHole(null);
return;
}
} // Start tracking stall time
var tnow = self.performance.now();
if (stalled === null) {
this.stalled = tnow;
return;
}
var stalledDuration = tnow - stalled;
if (!seeking && stalledDuration >= STALL_MINIMUM_DURATION_MS) {
// Report stalling after trying to fix
this._reportStall(bufferInfo.len);
}
var bufferedWithHoles = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_0__["BufferHelper"].bufferInfo(media, currentTime, config.maxBufferHole);
this._tryFixBufferStall(bufferedWithHoles, stalledDuration);
}
/**
* Detects and attempts to fix known buffer stalling issues.
* @param bufferInfo - The properties of the current buffer.
* @param stalledDurationMs - The amount of time Hls.js has been stalling for.
* @private
*/
;
_proto._tryFixBufferStall = function _tryFixBufferStall(bufferInfo, stalledDurationMs) {
var config = this.config,
fragmentTracker = this.fragmentTracker,
media = this.media;
var currentTime = media.currentTime;
var partial = fragmentTracker.getPartialFragment(currentTime);
if (partial) {
// Try to skip over the buffer hole caused by a partial fragment
// This method isn't limited by the size of the gap between buffered ranges
var targetTime = this._trySkipBufferHole(partial); // we return here in this case, meaning
// the branch below only executes when we don't handle a partial fragment
if (targetTime) {
return;
}
} // if we haven't had to skip over a buffer hole of a partial fragment
// we may just have to "nudge" the playlist as the browser decoding/rendering engine
// needs to cross some sort of threshold covering all source-buffers content
// to start playing properly.
if (bufferInfo.len > config.maxBufferHole && stalledDurationMs > config.highBufferWatchdogPeriod * 1000) {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn('Trying to nudge playhead over buffer-hole'); // Try to nudge currentTime over a buffer hole if we've been stalling for the configured amount of seconds
// We only try to jump the hole if it's under the configured size
// Reset stalled so to rearm watchdog timer
this.stalled = null;
this._tryNudgeBuffer();
}
}
/**
* Triggers a BUFFER_STALLED_ERROR event, but only once per stall period.
* @param bufferLen - The playhead distance from the end of the current buffer segment.
* @private
*/
;
_proto._reportStall = function _reportStall(bufferLen) {
var hls = this.hls,
media = this.media,
stallReported = this.stallReported;
if (!stallReported) {
// Report stalled error once
this.stallReported = true;
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn("Playback stalling at @" + media.currentTime + " due to low buffer (buffer=" + bufferLen + ")");
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].BUFFER_STALLED_ERROR,
fatal: false,
buffer: bufferLen
});
}
}
/**
* Attempts to fix buffer stalls by jumping over known gaps caused by partial fragments
* @param partial - The partial fragment found at the current time (where playback is stalling).
* @private
*/
;
_proto._trySkipBufferHole = function _trySkipBufferHole(partial) {
var config = this.config,
hls = this.hls,
media = this.media;
var currentTime = media.currentTime;
var lastEndTime = 0; // Check if currentTime is between unbuffered regions of partial fragments
var buffered = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_0__["BufferHelper"].getBuffered(media);
for (var i = 0; i < buffered.length; i++) {
var startTime = buffered.start(i);
if (currentTime + config.maxBufferHole >= lastEndTime && currentTime < startTime) {
var targetTime = Math.max(startTime + SKIP_BUFFER_RANGE_START, media.currentTime + SKIP_BUFFER_HOLE_STEP_SECONDS);
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn("skipping hole, adjusting currentTime from " + currentTime + " to " + targetTime);
this.moved = true;
this.stalled = null;
media.currentTime = targetTime;
if (partial) {
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].BUFFER_SEEK_OVER_HOLE,
fatal: false,
reason: "fragment loaded with buffer holes, seeking from " + currentTime + " to " + targetTime,
frag: partial
});
}
return targetTime;
}
lastEndTime = buffered.end(i);
}
return 0;
}
/**
* Attempts to fix buffer stalls by advancing the mediaElement's current time by a small amount.
* @private
*/
;
_proto._tryNudgeBuffer = function _tryNudgeBuffer() {
var config = this.config,
hls = this.hls,
media = this.media;
var currentTime = media.currentTime;
var nudgeRetry = (this.nudgeRetry || 0) + 1;
this.nudgeRetry = nudgeRetry;
if (nudgeRetry < config.nudgeMaxRetry) {
var targetTime = currentTime + nudgeRetry * config.nudgeOffset; // playback stalled in buffered area ... let's nudge currentTime to try to overcome this
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn("Nudging 'currentTime' from " + currentTime + " to " + targetTime);
media.currentTime = targetTime;
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].BUFFER_NUDGE_ON_STALL,
fatal: false
});
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].error("Playhead still not moving while enough data buffered @" + currentTime + " after " + config.nudgeMaxRetry + " nudges");
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].BUFFER_STALLED_ERROR,
fatal: true
});
}
};
return GapController;
}();
/***/ }),
/***/ "./src/controller/id3-track-controller.ts":
/*!************************************************!*\
!*** ./src/controller/id3-track-controller.ts ***!
\************************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/texttrack-utils */ "./src/utils/texttrack-utils.ts");
/* harmony import */ var _demux_id3__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../demux/id3 */ "./src/demux/id3.ts");
var MIN_CUE_DURATION = 0.25;
var ID3TrackController = /*#__PURE__*/function () {
function ID3TrackController(hls) {
this.hls = void 0;
this.id3Track = null;
this.media = null;
this.hls = hls;
this._registerListeners();
}
var _proto = ID3TrackController.prototype;
_proto.destroy = function destroy() {
this._unregisterListeners();
};
_proto._registerListeners = function _registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].BUFFER_FLUSHING, this.onBufferFlushing, this);
};
_proto._unregisterListeners = function _unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FRAG_PARSING_METADATA, this.onFragParsingMetadata, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].BUFFER_FLUSHING, this.onBufferFlushing, this);
} // Add ID3 metatadata text track.
;
_proto.onMediaAttached = function onMediaAttached(event, data) {
this.media = data.media;
};
_proto.onMediaDetaching = function onMediaDetaching() {
if (!this.id3Track) {
return;
}
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_1__["clearCurrentCues"])(this.id3Track);
this.id3Track = null;
this.media = null;
};
_proto.getID3Track = function getID3Track(textTracks) {
if (!this.media) {
return;
}
for (var i = 0; i < textTracks.length; i++) {
var textTrack = textTracks[i];
if (textTrack.kind === 'metadata' && textTrack.label === 'id3') {
// send 'addtrack' when reusing the textTrack for metadata,
// same as what we do for captions
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_1__["sendAddTrackEvent"])(textTrack, this.media);
return textTrack;
}
}
return this.media.addTextTrack('metadata', 'id3');
};
_proto.onFragParsingMetadata = function onFragParsingMetadata(event, data) {
if (!this.media) {
return;
}
var fragment = data.frag;
var samples = data.samples; // create track dynamically
if (!this.id3Track) {
this.id3Track = this.getID3Track(this.media.textTracks);
this.id3Track.mode = 'hidden';
} // Attempt to recreate Safari functionality by creating
// WebKitDataCue objects when available and store the decoded
// ID3 data in the value property of the cue
var Cue = self.WebKitDataCue || self.VTTCue || self.TextTrackCue;
for (var i = 0; i < samples.length; i++) {
var frames = _demux_id3__WEBPACK_IMPORTED_MODULE_2__["getID3Frames"](samples[i].data);
if (frames) {
var startTime = samples[i].pts;
var endTime = i < samples.length - 1 ? samples[i + 1].pts : fragment.end;
var timeDiff = endTime - startTime;
if (timeDiff <= 0) {
endTime = startTime + MIN_CUE_DURATION;
}
for (var j = 0; j < frames.length; j++) {
var frame = frames[j]; // Safari doesn't put the timestamp frame in the TextTrack
if (!_demux_id3__WEBPACK_IMPORTED_MODULE_2__["isTimeStampFrame"](frame)) {
var cue = new Cue(startTime, endTime, '');
cue.value = frame;
this.id3Track.addCue(cue);
}
}
}
}
};
_proto.onBufferFlushing = function onBufferFlushing(event, _ref) {
var startOffset = _ref.startOffset,
endOffset = _ref.endOffset,
type = _ref.type;
if (!type || type === 'audio') {
// id3 cues come from parsed audio only remove cues when audio buffer is cleared
var id3Track = this.id3Track;
if (id3Track) {
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_1__["removeCuesInRange"])(id3Track, startOffset, endOffset);
}
}
};
return ID3TrackController;
}();
/* harmony default export */ __webpack_exports__["default"] = (ID3TrackController);
/***/ }),
/***/ "./src/controller/latency-controller.ts":
/*!**********************************************!*\
!*** ./src/controller/latency-controller.ts ***!
\**********************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return LatencyController; });
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var LatencyController = /*#__PURE__*/function () {
function LatencyController(hls) {
var _this = this;
this.hls = void 0;
this.config = void 0;
this.media = null;
this.levelDetails = null;
this.currentTime = 0;
this.stallCount = 0;
this._latency = null;
this.timeupdateHandler = function () {
return _this.timeupdate();
};
this.hls = hls;
this.config = hls.config;
this.registerListeners();
}
var _proto = LatencyController.prototype;
_proto.destroy = function destroy() {
this.unregisterListeners();
this.onMediaDetaching();
this.levelDetails = null; // @ts-ignore
this.hls = this.timeupdateHandler = null;
};
_proto.registerListeners = function registerListeners() {
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_UPDATED, this.onLevelUpdated, this);
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, this.onError, this);
};
_proto.unregisterListeners = function unregisterListeners() {
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_ATTACHED, this.onMediaAttached);
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_DETACHING, this.onMediaDetaching);
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADING, this.onManifestLoading);
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_UPDATED, this.onLevelUpdated);
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, this.onError);
};
_proto.onMediaAttached = function onMediaAttached(event, data) {
this.media = data.media;
this.media.addEventListener('timeupdate', this.timeupdateHandler);
};
_proto.onMediaDetaching = function onMediaDetaching() {
if (this.media) {
this.media.removeEventListener('timeupdate', this.timeupdateHandler);
this.media = null;
}
};
_proto.onManifestLoading = function onManifestLoading() {
this.levelDetails = null;
this._latency = null;
this.stallCount = 0;
};
_proto.onLevelUpdated = function onLevelUpdated(event, _ref) {
var details = _ref.details;
this.levelDetails = details;
if (details.advanced) {
this.timeupdate();
}
if (!details.live && this.media) {
this.media.removeEventListener('timeupdate', this.timeupdateHandler);
}
};
_proto.onError = function onError(event, data) {
if (data.details !== _errors__WEBPACK_IMPORTED_MODULE_0__["ErrorDetails"].BUFFER_STALLED_ERROR) {
return;
}
this.stallCount++;
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn('[playback-rate-controller]: Stall detected, adjusting target latency');
};
_proto.timeupdate = function timeupdate() {
var media = this.media,
levelDetails = this.levelDetails;
if (!media || !levelDetails) {
return;
}
this.currentTime = media.currentTime;
var latency = this.computeLatency();
if (latency === null) {
return;
}
this._latency = latency; // Adapt playbackRate to meet target latency in low-latency mode
var _this$config = this.config,
lowLatencyMode = _this$config.lowLatencyMode,
maxLiveSyncPlaybackRate = _this$config.maxLiveSyncPlaybackRate;
if (!lowLatencyMode || maxLiveSyncPlaybackRate === 1) {
return;
}
var targetLatency = this.targetLatency;
if (targetLatency === null) {
return;
}
var distanceFromTarget = latency - targetLatency; // Only adjust playbackRate when within one target duration of targetLatency
// and more than one second from under-buffering.
// Playback further than one target duration from target can be considered DVR playback.
var liveMinLatencyDuration = Math.min(this.maxLatency, targetLatency + levelDetails.targetduration);
var inLiveRange = distanceFromTarget < liveMinLatencyDuration;
if (levelDetails.live && inLiveRange && distanceFromTarget > 0.05 && this.forwardBufferLength > 1) {
var max = Math.min(2, Math.max(1.0, maxLiveSyncPlaybackRate));
var rate = Math.round(2 / (1 + Math.exp(-0.75 * distanceFromTarget - this.edgeStalled)) * 20) / 20;
media.playbackRate = Math.min(max, Math.max(1, rate));
} else if (media.playbackRate !== 1 && media.playbackRate !== 0) {
media.playbackRate = 1;
}
};
_proto.estimateLiveEdge = function estimateLiveEdge() {
var levelDetails = this.levelDetails;
if (levelDetails === null) {
return null;
}
return levelDetails.edge + levelDetails.age;
};
_proto.computeLatency = function computeLatency() {
var liveEdge = this.estimateLiveEdge();
if (liveEdge === null) {
return null;
}
return liveEdge - this.currentTime;
};
_createClass(LatencyController, [{
key: "latency",
get: function get() {
return this._latency || 0;
}
}, {
key: "maxLatency",
get: function get() {
var config = this.config,
levelDetails = this.levelDetails;
if (config.liveMaxLatencyDuration !== undefined) {
return config.liveMaxLatencyDuration;
}
return levelDetails ? config.liveMaxLatencyDurationCount * levelDetails.targetduration : 0;
}
}, {
key: "targetLatency",
get: function get() {
var levelDetails = this.levelDetails;
if (levelDetails === null) {
return null;
}
var holdBack = levelDetails.holdBack,
partHoldBack = levelDetails.partHoldBack,
targetduration = levelDetails.targetduration;
var _this$config2 = this.config,
liveSyncDuration = _this$config2.liveSyncDuration,
liveSyncDurationCount = _this$config2.liveSyncDurationCount,
lowLatencyMode = _this$config2.lowLatencyMode;
var userConfig = this.hls.userConfig;
var targetLatency = lowLatencyMode ? partHoldBack || holdBack : holdBack;
if (userConfig.liveSyncDuration || userConfig.liveSyncDurationCount || targetLatency === 0) {
targetLatency = liveSyncDuration !== undefined ? liveSyncDuration : liveSyncDurationCount * targetduration;
}
var maxLiveSyncOnStallIncrease = targetduration;
var liveSyncOnStallIncrease = 1.0;
return targetLatency + Math.min(this.stallCount * liveSyncOnStallIncrease, maxLiveSyncOnStallIncrease);
}
}, {
key: "liveSyncPosition",
get: function get() {
var liveEdge = this.estimateLiveEdge();
var targetLatency = this.targetLatency;
var levelDetails = this.levelDetails;
if (liveEdge === null || targetLatency === null || levelDetails === null) {
return null;
}
var edge = levelDetails.edge;
var syncPosition = liveEdge - targetLatency - this.edgeStalled;
var min = edge - levelDetails.totalduration;
var max = edge - (this.config.lowLatencyMode && levelDetails.partTarget || levelDetails.targetduration);
return Math.min(Math.max(min, syncPosition), max);
}
}, {
key: "drift",
get: function get() {
var levelDetails = this.levelDetails;
if (levelDetails === null) {
return 1;
}
return levelDetails.drift;
}
}, {
key: "edgeStalled",
get: function get() {
var levelDetails = this.levelDetails;
if (levelDetails === null) {
return 0;
}
var maxLevelUpdateAge = (this.config.lowLatencyMode && levelDetails.partTarget || levelDetails.targetduration) * 3;
return Math.max(levelDetails.age - maxLevelUpdateAge, 0);
}
}, {
key: "forwardBufferLength",
get: function get() {
var media = this.media,
levelDetails = this.levelDetails;
if (!media || !levelDetails) {
return 0;
}
var bufferedRanges = media.buffered.length;
return bufferedRanges ? media.buffered.end(bufferedRanges - 1) : levelDetails.edge - this.currentTime;
}
}]);
return LatencyController;
}();
/***/ }),
/***/ "./src/controller/level-controller.ts":
/*!********************************************!*\
!*** ./src/controller/level-controller.ts ***!
\********************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return LevelController; });
/* harmony import */ var _types_level__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../types/level */ "./src/types/level.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_codecs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/codecs */ "./src/utils/codecs.ts");
/* harmony import */ var _level_helper__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./level-helper */ "./src/controller/level-helper.ts");
/* harmony import */ var _base_playlist_controller__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./base-playlist-controller */ "./src/controller/base-playlist-controller.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
/*
* Level Controller
*/
var chromeOrFirefox = /chrome|firefox/.test(navigator.userAgent.toLowerCase());
var LevelController = /*#__PURE__*/function (_BasePlaylistControll) {
_inheritsLoose(LevelController, _BasePlaylistControll);
function LevelController(hls) {
var _this;
_this = _BasePlaylistControll.call(this, hls, '[level-controller]') || this;
_this._levels = [];
_this._firstLevel = -1;
_this._startLevel = void 0;
_this.currentLevelIndex = -1;
_this.manualLevelIndex = -1;
_this.onParsedComplete = void 0;
_this._registerListeners();
return _this;
}
var _proto = LevelController.prototype;
_proto._registerListeners = function _registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADED, this.onManifestLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_LOADED, this.onFragLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, this.onError, this);
};
_proto._unregisterListeners = function _unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADED, this.onManifestLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_LOADED, this.onFragLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, this.onError, this);
};
_proto.destroy = function destroy() {
this._unregisterListeners();
this.manualLevelIndex = -1;
this._levels.length = 0;
_BasePlaylistControll.prototype.destroy.call(this);
};
_proto.startLoad = function startLoad() {
var levels = this._levels; // clean up live level details to force reload them, and reset load errors
levels.forEach(function (level) {
level.loadError = 0;
});
_BasePlaylistControll.prototype.startLoad.call(this);
};
_proto.onManifestLoaded = function onManifestLoaded(event, data) {
var levels = [];
var audioTracks = [];
var subtitleTracks = [];
var bitrateStart;
var levelSet = {};
var levelFromSet;
var resolutionFound = false;
var videoCodecFound = false;
var audioCodecFound = false; // regroup redundant levels together
data.levels.forEach(function (levelParsed) {
var attributes = levelParsed.attrs;
resolutionFound = resolutionFound || !!(levelParsed.width && levelParsed.height);
videoCodecFound = videoCodecFound || !!levelParsed.videoCodec;
audioCodecFound = audioCodecFound || !!levelParsed.audioCodec; // erase audio codec info if browser does not support mp4a.40.34.
// demuxer will autodetect codec and fallback to mpeg/audio
if (chromeOrFirefox && levelParsed.audioCodec && levelParsed.audioCodec.indexOf('mp4a.40.34') !== -1) {
levelParsed.audioCodec = undefined;
}
var levelKey = levelParsed.bitrate + "-" + levelParsed.attrs.RESOLUTION + "-" + levelParsed.attrs.CODECS;
levelFromSet = levelSet[levelKey];
if (!levelFromSet) {
levelFromSet = new _types_level__WEBPACK_IMPORTED_MODULE_0__["Level"](levelParsed);
levelSet[levelKey] = levelFromSet;
levels.push(levelFromSet);
} else {
levelFromSet.url.push(levelParsed.url);
}
if (attributes) {
if (attributes.AUDIO) {
Object(_level_helper__WEBPACK_IMPORTED_MODULE_4__["addGroupId"])(levelFromSet, 'audio', attributes.AUDIO);
}
if (attributes.SUBTITLES) {
Object(_level_helper__WEBPACK_IMPORTED_MODULE_4__["addGroupId"])(levelFromSet, 'text', attributes.SUBTITLES);
}
}
}); // remove audio-only level if we also have levels with video codecs or RESOLUTION signalled
if ((resolutionFound || videoCodecFound) && audioCodecFound) {
levels = levels.filter(function (_ref) {
var videoCodec = _ref.videoCodec,
width = _ref.width,
height = _ref.height;
return !!videoCodec || !!(width && height);
});
} // only keep levels with supported audio/video codecs
levels = levels.filter(function (_ref2) {
var audioCodec = _ref2.audioCodec,
videoCodec = _ref2.videoCodec;
return (!audioCodec || Object(_utils_codecs__WEBPACK_IMPORTED_MODULE_3__["isCodecSupportedInMp4"])(audioCodec, 'audio')) && (!videoCodec || Object(_utils_codecs__WEBPACK_IMPORTED_MODULE_3__["isCodecSupportedInMp4"])(videoCodec, 'video'));
});
if (data.audioTracks) {
audioTracks = data.audioTracks.filter(function (track) {
return !track.audioCodec || Object(_utils_codecs__WEBPACK_IMPORTED_MODULE_3__["isCodecSupportedInMp4"])(track.audioCodec, 'audio');
}); // Assign ids after filtering as array indices by group-id
Object(_level_helper__WEBPACK_IMPORTED_MODULE_4__["assignTrackIdsByGroup"])(audioTracks);
}
if (data.subtitles) {
subtitleTracks = data.subtitles;
Object(_level_helper__WEBPACK_IMPORTED_MODULE_4__["assignTrackIdsByGroup"])(subtitleTracks);
}
if (levels.length > 0) {
// start bitrate is the first bitrate of the manifest
bitrateStart = levels[0].bitrate; // sort level on bitrate
levels.sort(function (a, b) {
return a.bitrate - b.bitrate;
});
this._levels = levels; // find index of first level in sorted levels
for (var i = 0; i < levels.length; i++) {
if (levels[i].bitrate === bitrateStart) {
this._firstLevel = i;
this.log("manifest loaded, " + levels.length + " level(s) found, first bitrate: " + bitrateStart);
break;
}
} // Audio is only alternate if manifest include a URI along with the audio group tag,
// and this is not an audio-only stream where levels contain audio-only
var audioOnly = audioCodecFound && !videoCodecFound;
var edata = {
levels: levels,
audioTracks: audioTracks,
subtitleTracks: subtitleTracks,
firstLevel: this._firstLevel,
stats: data.stats,
audio: audioCodecFound,
video: videoCodecFound,
altAudio: !audioOnly && audioTracks.some(function (t) {
return !!t.url;
})
};
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_PARSED, edata); // Initiate loading after all controllers have received MANIFEST_PARSED
if (this.hls.config.autoStartLoad || this.hls.forceStartLoad) {
this.hls.startLoad(this.hls.config.startPosition);
}
} else {
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].MANIFEST_INCOMPATIBLE_CODECS_ERROR,
fatal: true,
url: data.url,
reason: 'no level with compatible codecs found in manifest'
});
}
};
_proto.onError = function onError(event, data) {
_BasePlaylistControll.prototype.onError.call(this, event, data);
if (data.fatal) {
return;
} // Switch to redundant level when track fails to load
var context = data.context;
var level = this._levels[this.currentLevelIndex];
if (context && (context.type === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].AUDIO_TRACK && level.audioGroupIds && context.groupId === level.audioGroupIds[level.urlId] || context.type === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].SUBTITLE_TRACK && level.textGroupIds && context.groupId === level.textGroupIds[level.urlId])) {
this.redundantFailover(this.currentLevelIndex);
return;
}
var levelError = false;
var levelSwitch = true;
var levelIndex; // try to recover not fatal errors
switch (data.details) {
case _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].FRAG_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].FRAG_LOAD_TIMEOUT:
case _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].KEY_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].KEY_LOAD_TIMEOUT:
if (data.frag) {
var _level = this._levels[data.frag.level]; // Set levelIndex when we're out of fragment retries
if (_level) {
_level.fragmentError++;
if (_level.fragmentError > this.hls.config.fragLoadingMaxRetry) {
levelIndex = data.frag.level;
}
} else {
levelIndex = data.frag.level;
}
}
break;
case _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].LEVEL_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].LEVEL_LOAD_TIMEOUT:
// Do not perform level switch if an error occurred using delivery directives
// Attempt to reload level without directives first
if (context) {
if (context.deliveryDirectives) {
levelSwitch = false;
}
levelIndex = context.level;
}
levelError = true;
break;
case _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].REMUX_ALLOC_ERROR:
levelIndex = data.level;
levelError = true;
break;
}
if (levelIndex !== undefined) {
this.recoverLevel(data, levelIndex, levelError, levelSwitch);
}
}
/**
* Switch to a redundant stream if any available.
* If redundant stream is not available, emergency switch down if ABR mode is enabled.
*/
;
_proto.recoverLevel = function recoverLevel(errorEvent, levelIndex, levelError, levelSwitch) {
var errorDetails = errorEvent.details;
var level = this._levels[levelIndex];
level.loadError++;
if (levelError) {
var retrying = this.retryLoadingOrFail(errorEvent);
if (retrying) {
// boolean used to inform stream controller not to switch back to IDLE on non fatal error
errorEvent.levelRetry = true;
} else {
this.currentLevelIndex = -1;
return;
}
}
if (levelSwitch) {
var redundantLevels = level.url.length; // Try redundant fail-over until level.loadError reaches redundantLevels
if (redundantLevels > 1 && level.loadError < redundantLevels) {
errorEvent.levelRetry = true;
this.redundantFailover(levelIndex);
} else if (this.manualLevelIndex === -1) {
// Search for available level in auto level selection mode, cycling from highest to lowest bitrate
var nextLevel = levelIndex === 0 ? this._levels.length - 1 : levelIndex - 1;
if (this.currentLevelIndex !== nextLevel && this._levels[nextLevel].loadError === 0) {
this.warn(errorDetails + ": switch to " + nextLevel);
errorEvent.levelRetry = true;
this.hls.nextAutoLevel = nextLevel;
}
}
}
};
_proto.redundantFailover = function redundantFailover(levelIndex) {
var level = this._levels[levelIndex];
var redundantLevels = level.url.length;
if (redundantLevels > 1) {
// Update the url id of all levels so that we stay on the same set of variants when level switching
var newUrlId = (level.urlId + 1) % redundantLevels;
this.warn("Switching to redundant URL-id " + newUrlId);
this._levels.forEach(function (level) {
level.urlId = newUrlId;
});
this.level = levelIndex;
}
} // reset errors on the successful load of a fragment
;
_proto.onFragLoaded = function onFragLoaded(event, _ref3) {
var frag = _ref3.frag;
if (frag !== undefined && frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN) {
var level = this._levels[frag.level];
if (level !== undefined) {
level.fragmentError = 0;
level.loadError = 0;
}
}
};
_proto.onLevelLoaded = function onLevelLoaded(event, data) {
var _data$deliveryDirecti2;
var level = data.level,
details = data.details;
var curLevel = this._levels[level];
if (!curLevel) {
var _data$deliveryDirecti;
this.warn("Invalid level index " + level);
if ((_data$deliveryDirecti = data.deliveryDirectives) !== null && _data$deliveryDirecti !== void 0 && _data$deliveryDirecti.skip) {
details.deltaUpdateFailed = true;
}
return;
} // only process level loaded events matching with expected level
if (level === this.currentLevelIndex) {
// reset level load error counter on successful level loaded only if there is no issues with fragments
if (curLevel.fragmentError === 0) {
curLevel.loadError = 0;
this.retryCount = 0;
}
this.playlistLoaded(level, data, curLevel.details);
} else if ((_data$deliveryDirecti2 = data.deliveryDirectives) !== null && _data$deliveryDirecti2 !== void 0 && _data$deliveryDirecti2.skip) {
// received a delta playlist update that cannot be merged
details.deltaUpdateFailed = true;
}
};
_proto.onAudioTrackSwitched = function onAudioTrackSwitched(event, data) {
var currentLevel = this.hls.levels[this.currentLevelIndex];
if (!currentLevel) {
return;
}
if (currentLevel.audioGroupIds) {
var urlId = -1;
var audioGroupId = this.hls.audioTracks[data.id].groupId;
for (var i = 0; i < currentLevel.audioGroupIds.length; i++) {
if (currentLevel.audioGroupIds[i] === audioGroupId) {
urlId = i;
break;
}
}
if (urlId !== currentLevel.urlId) {
currentLevel.urlId = urlId;
this.startLoad();
}
}
};
_proto.loadPlaylist = function loadPlaylist(hlsUrlParameters) {
var level = this.currentLevelIndex;
var currentLevel = this._levels[level];
if (this.canLoad && currentLevel && currentLevel.url.length > 0) {
var id = currentLevel.urlId;
var url = currentLevel.url[id];
if (hlsUrlParameters) {
try {
url = hlsUrlParameters.addDirectives(url);
} catch (error) {
this.warn("Could not construct new URL with HLS Delivery Directives: " + error);
}
}
this.log("Attempt loading level index " + level + (hlsUrlParameters ? ' at sn ' + hlsUrlParameters.msn + ' part ' + hlsUrlParameters.part : '') + " with URL-id " + id + " " + url); // console.log('Current audio track group ID:', this.hls.audioTracks[this.hls.audioTrack].groupId);
// console.log('New video quality level audio group id:', levelObject.attrs.AUDIO, level);
this.clearTimer();
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_LOADING, {
url: url,
level: level,
id: id,
deliveryDirectives: hlsUrlParameters || null
});
}
};
_proto.removeLevel = function removeLevel(levelIndex, urlId) {
var filterLevelAndGroupByIdIndex = function filterLevelAndGroupByIdIndex(url, id) {
return id !== urlId;
};
var levels = this._levels.filter(function (level, index) {
if (index !== levelIndex) {
return true;
}
if (level.url.length > 1 && urlId !== undefined) {
level.url = level.url.filter(filterLevelAndGroupByIdIndex);
if (level.audioGroupIds) {
level.audioGroupIds = level.audioGroupIds.filter(filterLevelAndGroupByIdIndex);
}
if (level.textGroupIds) {
level.textGroupIds = level.textGroupIds.filter(filterLevelAndGroupByIdIndex);
}
level.urlId = 0;
return true;
}
return false;
}).map(function (level, index) {
var details = level.details;
if (details !== null && details !== void 0 && details.fragments) {
details.fragments.forEach(function (fragment) {
fragment.level = index;
});
}
return level;
});
this._levels = levels;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVELS_UPDATED, {
levels: levels
});
};
_createClass(LevelController, [{
key: "levels",
get: function get() {
if (this._levels.length === 0) {
return null;
}
return this._levels;
}
}, {
key: "level",
get: function get() {
return this.currentLevelIndex;
},
set: function set(newLevel) {
var _levels$newLevel;
var levels = this._levels;
if (levels.length === 0) {
return;
}
if (this.currentLevelIndex === newLevel && (_levels$newLevel = levels[newLevel]) !== null && _levels$newLevel !== void 0 && _levels$newLevel.details) {
return;
} // check if level idx is valid
if (newLevel < 0 || newLevel >= levels.length) {
// invalid level id given, trigger error
var fatal = newLevel < 0;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorTypes"].OTHER_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].LEVEL_SWITCH_ERROR,
level: newLevel,
fatal: fatal,
reason: 'invalid level idx'
});
if (fatal) {
return;
}
newLevel = Math.min(newLevel, levels.length - 1);
} // stopping live reloading timer if any
this.clearTimer();
var lastLevelIndex = this.currentLevelIndex;
var lastLevel = levels[lastLevelIndex];
var level = levels[newLevel];
this.log("switching to level " + newLevel + " from " + lastLevelIndex);
this.currentLevelIndex = newLevel;
var levelSwitchingData = _extends({}, level, {
level: newLevel,
maxBitrate: level.maxBitrate,
uri: level.uri,
urlId: level.urlId
}); // @ts-ignore
delete levelSwitchingData._urlId;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_SWITCHING, levelSwitchingData); // check if we need to load playlist for this level
var levelDetails = level.details;
if (!levelDetails || levelDetails.live) {
// level not retrieved yet, or live playlist we need to (re)load it
var hlsUrlParameters = this.switchParams(level.uri, lastLevel === null || lastLevel === void 0 ? void 0 : lastLevel.details);
this.loadPlaylist(hlsUrlParameters);
}
}
}, {
key: "manualLevel",
get: function get() {
return this.manualLevelIndex;
},
set: function set(newLevel) {
this.manualLevelIndex = newLevel;
if (this._startLevel === undefined) {
this._startLevel = newLevel;
}
if (newLevel !== -1) {
this.level = newLevel;
}
}
}, {
key: "firstLevel",
get: function get() {
return this._firstLevel;
},
set: function set(newLevel) {
this._firstLevel = newLevel;
}
}, {
key: "startLevel",
get: function get() {
// hls.startLevel takes precedence over config.startLevel
// if none of these values are defined, fallback on this._firstLevel (first quality level appearing in variant manifest)
if (this._startLevel === undefined) {
var configStartLevel = this.hls.config.startLevel;
if (configStartLevel !== undefined) {
return configStartLevel;
} else {
return this._firstLevel;
}
} else {
return this._startLevel;
}
},
set: function set(newLevel) {
this._startLevel = newLevel;
}
}, {
key: "nextLoadLevel",
get: function get() {
if (this.manualLevelIndex !== -1) {
return this.manualLevelIndex;
} else {
return this.hls.nextAutoLevel;
}
},
set: function set(nextLevel) {
this.level = nextLevel;
if (this.manualLevelIndex === -1) {
this.hls.nextAutoLevel = nextLevel;
}
}
}]);
return LevelController;
}(_base_playlist_controller__WEBPACK_IMPORTED_MODULE_5__["default"]);
/***/ }),
/***/ "./src/controller/level-helper.ts":
/*!****************************************!*\
!*** ./src/controller/level-helper.ts ***!
\****************************************/
/*! exports provided: addGroupId, assignTrackIdsByGroup, updatePTS, updateFragPTSDTS, mergeDetails, mapPartIntersection, mapFragmentIntersection, adjustSliding, addSliding, computeReloadInterval, getFragmentWithSN, getPartWith */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addGroupId", function() { return addGroupId; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assignTrackIdsByGroup", function() { return assignTrackIdsByGroup; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "updatePTS", function() { return updatePTS; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "updateFragPTSDTS", function() { return updateFragPTSDTS; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mergeDetails", function() { return mergeDetails; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mapPartIntersection", function() { return mapPartIntersection; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mapFragmentIntersection", function() { return mapFragmentIntersection; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "adjustSliding", function() { return adjustSliding; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addSliding", function() { return addSliding; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computeReloadInterval", function() { return computeReloadInterval; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getFragmentWithSN", function() { return getFragmentWithSN; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getPartWith", function() { return getPartWith; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/**
* @module LevelHelper
* Providing methods dealing with playlist sliding and drift
* */
function addGroupId(level, type, id) {
switch (type) {
case 'audio':
if (!level.audioGroupIds) {
level.audioGroupIds = [];
}
level.audioGroupIds.push(id);
break;
case 'text':
if (!level.textGroupIds) {
level.textGroupIds = [];
}
level.textGroupIds.push(id);
break;
}
}
function assignTrackIdsByGroup(tracks) {
var groups = {};
tracks.forEach(function (track) {
var groupId = track.groupId || '';
track.id = groups[groupId] = groups[groupId] || 0;
groups[groupId]++;
});
}
function updatePTS(fragments, fromIdx, toIdx) {
var fragFrom = fragments[fromIdx];
var fragTo = fragments[toIdx];
updateFromToPTS(fragFrom, fragTo);
}
function updateFromToPTS(fragFrom, fragTo) {
var fragToPTS = fragTo.startPTS; // if we know startPTS[toIdx]
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(fragToPTS)) {
// update fragment duration.
// it helps to fix drifts between playlist reported duration and fragment real duration
var duration = 0;
var frag;
if (fragTo.sn > fragFrom.sn) {
duration = fragToPTS - fragFrom.start;
frag = fragFrom;
} else {
duration = fragFrom.start - fragToPTS;
frag = fragTo;
} // TODO? Drift can go either way, or the playlist could be completely accurate
// console.assert(duration > 0,
// `duration of ${duration} computed for frag ${frag.sn}, level ${frag.level}, there should be some duration drift between playlist and fragment!`);
if (frag.duration !== duration) {
frag.duration = duration;
} // we dont know startPTS[toIdx]
} else if (fragTo.sn > fragFrom.sn) {
var contiguous = fragFrom.cc === fragTo.cc; // TODO: With part-loading end/durations we need to confirm the whole fragment is loaded before using (or setting) minEndPTS
if (contiguous && fragFrom.minEndPTS) {
fragTo.start = fragFrom.start + (fragFrom.minEndPTS - fragFrom.start);
} else {
fragTo.start = fragFrom.start + fragFrom.duration;
}
} else {
fragTo.start = Math.max(fragFrom.start - fragTo.duration, 0);
}
}
function updateFragPTSDTS(details, frag, startPTS, endPTS, startDTS, endDTS) {
var parsedMediaDuration = endPTS - startPTS;
if (parsedMediaDuration <= 0) {
_utils_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].warn('Fragment should have a positive duration', frag);
endPTS = startPTS + frag.duration;
endDTS = startDTS + frag.duration;
}
var maxStartPTS = startPTS;
var minEndPTS = endPTS;
var fragStartPts = frag.startPTS;
var fragEndPts = frag.endPTS;
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(fragStartPts)) {
// delta PTS between audio and video
var deltaPTS = Math.abs(fragStartPts - startPTS);
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(frag.deltaPTS)) {
frag.deltaPTS = deltaPTS;
} else {
frag.deltaPTS = Math.max(deltaPTS, frag.deltaPTS);
}
maxStartPTS = Math.max(startPTS, fragStartPts);
startPTS = Math.min(startPTS, fragStartPts);
startDTS = Math.min(startDTS, frag.startDTS);
minEndPTS = Math.min(endPTS, fragEndPts);
endPTS = Math.max(endPTS, fragEndPts);
endDTS = Math.max(endDTS, frag.endDTS);
}
frag.duration = endPTS - startPTS;
var drift = startPTS - frag.start;
frag.appendedPTS = endPTS;
frag.start = frag.startPTS = startPTS;
frag.maxStartPTS = maxStartPTS;
frag.startDTS = startDTS;
frag.endPTS = endPTS;
frag.minEndPTS = minEndPTS;
frag.endDTS = endDTS;
var sn = frag.sn; // 'initSegment'
// exit if sn out of range
if (!details || sn < details.startSN || sn > details.endSN) {
return 0;
}
var i;
var fragIdx = sn - details.startSN;
var fragments = details.fragments; // update frag reference in fragments array
// rationale is that fragments array might not contain this frag object.
// this will happen if playlist has been refreshed between frag loading and call to updateFragPTSDTS()
// if we don't update frag, we won't be able to propagate PTS info on the playlist
// resulting in invalid sliding computation
fragments[fragIdx] = frag; // adjust fragment PTS/duration from seqnum-1 to frag 0
for (i = fragIdx; i > 0; i--) {
updateFromToPTS(fragments[i], fragments[i - 1]);
} // adjust fragment PTS/duration from seqnum to last frag
for (i = fragIdx; i < fragments.length - 1; i++) {
updateFromToPTS(fragments[i], fragments[i + 1]);
}
if (details.fragmentHint) {
updateFromToPTS(fragments[fragments.length - 1], details.fragmentHint);
}
details.PTSKnown = details.alignedSliding = true;
return drift;
}
function mergeDetails(oldDetails, newDetails) {
// Track the last initSegment processed. Initialize it to the last one on the timeline.
var currentInitSegment = null;
var oldFragments = oldDetails.fragments;
for (var i = oldFragments.length - 1; i >= 0; i--) {
var oldInit = oldFragments[i].initSegment;
if (oldInit) {
currentInitSegment = oldInit;
break;
}
}
if (oldDetails.fragmentHint) {
// prevent PTS and duration from being adjusted on the next hint
delete oldDetails.fragmentHint.endPTS;
} // check if old/new playlists have fragments in common
// loop through overlapping SN and update startPTS , cc, and duration if any found
var ccOffset = 0;
var PTSFrag;
mapFragmentIntersection(oldDetails, newDetails, function (oldFrag, newFrag) {
var _currentInitSegment;
if (oldFrag.relurl) {
// Do not compare CC if the old fragment has no url. This is a level.fragmentHint used by LL-HLS parts.
// It maybe be off by 1 if it was created before any parts or discontinuity tags were appended to the end
// of the playlist.
ccOffset = oldFrag.cc - newFrag.cc;
}
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(oldFrag.startPTS) && Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(oldFrag.endPTS)) {
newFrag.start = newFrag.startPTS = oldFrag.startPTS;
newFrag.startDTS = oldFrag.startDTS;
newFrag.appendedPTS = oldFrag.appendedPTS;
newFrag.maxStartPTS = oldFrag.maxStartPTS;
newFrag.endPTS = oldFrag.endPTS;
newFrag.endDTS = oldFrag.endDTS;
newFrag.minEndPTS = oldFrag.minEndPTS;
newFrag.duration = oldFrag.endPTS - oldFrag.startPTS;
if (newFrag.duration) {
PTSFrag = newFrag;
} // PTS is known when any segment has startPTS and endPTS
newDetails.PTSKnown = newDetails.alignedSliding = true;
}
newFrag.elementaryStreams = oldFrag.elementaryStreams;
newFrag.loader = oldFrag.loader;
newFrag.stats = oldFrag.stats;
newFrag.urlId = oldFrag.urlId;
if (oldFrag.initSegment) {
newFrag.initSegment = oldFrag.initSegment;
currentInitSegment = oldFrag.initSegment;
} else if (!newFrag.initSegment || newFrag.initSegment.relurl == ((_currentInitSegment = currentInitSegment) === null || _currentInitSegment === void 0 ? void 0 : _currentInitSegment.relurl)) {
newFrag.initSegment = currentInitSegment;
}
});
if (newDetails.skippedSegments) {
newDetails.deltaUpdateFailed = newDetails.fragments.some(function (frag) {
return !frag;
});
if (newDetails.deltaUpdateFailed) {
_utils_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].warn('[level-helper] Previous playlist missing segments skipped in delta playlist');
for (var _i = newDetails.skippedSegments; _i--;) {
newDetails.fragments.shift();
}
newDetails.startSN = newDetails.fragments[0].sn;
newDetails.startCC = newDetails.fragments[0].cc;
}
}
var newFragments = newDetails.fragments;
if (ccOffset) {
_utils_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].warn('discontinuity sliding from playlist, take drift into account');
for (var _i2 = 0; _i2 < newFragments.length; _i2++) {
newFragments[_i2].cc += ccOffset;
}
}
if (newDetails.skippedSegments) {
newDetails.startCC = newDetails.fragments[0].cc;
} // Merge parts
mapPartIntersection(oldDetails.partList, newDetails.partList, function (oldPart, newPart) {
newPart.elementaryStreams = oldPart.elementaryStreams;
newPart.stats = oldPart.stats;
}); // if at least one fragment contains PTS info, recompute PTS information for all fragments
if (PTSFrag) {
updateFragPTSDTS(newDetails, PTSFrag, PTSFrag.startPTS, PTSFrag.endPTS, PTSFrag.startDTS, PTSFrag.endDTS);
} else {
// ensure that delta is within oldFragments range
// also adjust sliding in case delta is 0 (we could have old=[50-60] and new=old=[50-61])
// in that case we also need to adjust start offset of all fragments
adjustSliding(oldDetails, newDetails);
}
if (newFragments.length) {
newDetails.totalduration = newDetails.edge - newFragments[0].start;
}
newDetails.driftStartTime = oldDetails.driftStartTime;
newDetails.driftStart = oldDetails.driftStart;
var advancedDateTime = newDetails.advancedDateTime;
if (newDetails.advanced && advancedDateTime) {
var edge = newDetails.edge;
if (!newDetails.driftStart) {
newDetails.driftStartTime = advancedDateTime;
newDetails.driftStart = edge;
}
newDetails.driftEndTime = advancedDateTime;
newDetails.driftEnd = edge;
} else {
newDetails.driftEndTime = oldDetails.driftEndTime;
newDetails.driftEnd = oldDetails.driftEnd;
newDetails.advancedDateTime = oldDetails.advancedDateTime;
}
}
function mapPartIntersection(oldParts, newParts, intersectionFn) {
if (oldParts && newParts) {
var delta = 0;
for (var i = 0, len = oldParts.length; i <= len; i++) {
var _oldPart = oldParts[i];
var _newPart = newParts[i + delta];
if (_oldPart && _newPart && _oldPart.index === _newPart.index && _oldPart.fragment.sn === _newPart.fragment.sn) {
intersectionFn(_oldPart, _newPart);
} else {
delta--;
}
}
}
}
function mapFragmentIntersection(oldDetails, newDetails, intersectionFn) {
var skippedSegments = newDetails.skippedSegments;
var start = Math.max(oldDetails.startSN, newDetails.startSN) - newDetails.startSN;
var end = (oldDetails.fragmentHint ? 1 : 0) + (skippedSegments ? newDetails.endSN : Math.min(oldDetails.endSN, newDetails.endSN)) - newDetails.startSN;
var delta = newDetails.startSN - oldDetails.startSN;
var newFrags = newDetails.fragmentHint ? newDetails.fragments.concat(newDetails.fragmentHint) : newDetails.fragments;
var oldFrags = oldDetails.fragmentHint ? oldDetails.fragments.concat(oldDetails.fragmentHint) : oldDetails.fragments;
for (var i = start; i <= end; i++) {
var _oldFrag = oldFrags[delta + i];
var _newFrag = newFrags[i];
if (skippedSegments && !_newFrag && i < skippedSegments) {
// Fill in skipped segments in delta playlist
_newFrag = newDetails.fragments[i] = _oldFrag;
}
if (_oldFrag && _newFrag) {
intersectionFn(_oldFrag, _newFrag);
}
}
}
function adjustSliding(oldDetails, newDetails) {
var delta = newDetails.startSN + newDetails.skippedSegments - oldDetails.startSN;
var oldFragments = oldDetails.fragments;
if (delta < 0 || delta >= oldFragments.length) {
return;
}
addSliding(newDetails, oldFragments[delta].start);
}
function addSliding(details, start) {
if (start) {
var fragments = details.fragments;
for (var i = details.skippedSegments; i < fragments.length; i++) {
fragments[i].start += start;
}
if (details.fragmentHint) {
details.fragmentHint.start += start;
}
}
}
function computeReloadInterval(newDetails, stats) {
var reloadInterval = 1000 * newDetails.levelTargetDuration;
var reloadIntervalAfterMiss = reloadInterval / 2;
var timeSinceLastModified = newDetails.age;
var useLastModified = timeSinceLastModified > 0 && timeSinceLastModified < reloadInterval * 3;
var roundTrip = stats.loading.end - stats.loading.start;
var estimatedTimeUntilUpdate;
var availabilityDelay = newDetails.availabilityDelay; // let estimate = 'average';
if (newDetails.updated === false) {
if (useLastModified) {
// estimate = 'miss round trip';
// We should have had a hit so try again in the time it takes to get a response,
// but no less than 1/3 second.
var minRetry = 333 * newDetails.misses;
estimatedTimeUntilUpdate = Math.max(Math.min(reloadIntervalAfterMiss, roundTrip * 2), minRetry);
newDetails.availabilityDelay = (newDetails.availabilityDelay || 0) + estimatedTimeUntilUpdate;
} else {
// estimate = 'miss half average';
// follow HLS Spec, If the client reloads a Playlist file and finds that it has not
// changed then it MUST wait for a period of one-half the target
// duration before retrying.
estimatedTimeUntilUpdate = reloadIntervalAfterMiss;
}
} else if (useLastModified) {
// estimate = 'next modified date';
// Get the closest we've been to timeSinceLastModified on update
availabilityDelay = Math.min(availabilityDelay || reloadInterval / 2, timeSinceLastModified);
newDetails.availabilityDelay = availabilityDelay;
estimatedTimeUntilUpdate = availabilityDelay + reloadInterval - timeSinceLastModified;
} else {
estimatedTimeUntilUpdate = reloadInterval - roundTrip;
} // console.log(`[computeReloadInterval] live reload ${newDetails.updated ? 'REFRESHED' : 'MISSED'}`,
// '\n method', estimate,
// '\n estimated time until update =>', estimatedTimeUntilUpdate,
// '\n average target duration', reloadInterval,
// '\n time since modified', timeSinceLastModified,
// '\n time round trip', roundTrip,
// '\n availability delay', availabilityDelay);
return Math.round(estimatedTimeUntilUpdate);
}
function getFragmentWithSN(level, sn, fragCurrent) {
if (!level || !level.details) {
return null;
}
var levelDetails = level.details;
var fragment = levelDetails.fragments[sn - levelDetails.startSN];
if (fragment) {
return fragment;
}
fragment = levelDetails.fragmentHint;
if (fragment && fragment.sn === sn) {
return fragment;
}
if (sn < levelDetails.startSN && fragCurrent && fragCurrent.sn === sn) {
return fragCurrent;
}
return null;
}
function getPartWith(level, sn, partIndex) {
if (!level || !level.details) {
return null;
}
var partList = level.details.partList;
if (partList) {
for (var i = partList.length; i--;) {
var part = partList[i];
if (part.index === partIndex && part.fragment.sn === sn) {
return part;
}
}
}
return null;
}
/***/ }),
/***/ "./src/controller/stream-controller.ts":
/*!*********************************************!*\
!*** ./src/controller/stream-controller.ts ***!
\*********************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return StreamController; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./base-stream-controller */ "./src/controller/base-stream-controller.ts");
/* harmony import */ var _is_supported__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../is-supported */ "./src/is-supported.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
/* harmony import */ var _fragment_tracker__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./fragment-tracker */ "./src/controller/fragment-tracker.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
/* harmony import */ var _loader_fragment__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../loader/fragment */ "./src/loader/fragment.ts");
/* harmony import */ var _demux_transmuxer_interface__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../demux/transmuxer-interface */ "./src/demux/transmuxer-interface.ts");
/* harmony import */ var _types_transmuxer__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../types/transmuxer */ "./src/types/transmuxer.ts");
/* harmony import */ var _gap_controller__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./gap-controller */ "./src/controller/gap-controller.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var TICK_INTERVAL = 100; // how often to tick in ms
var StreamController = /*#__PURE__*/function (_BaseStreamController) {
_inheritsLoose(StreamController, _BaseStreamController);
function StreamController(hls, fragmentTracker) {
var _this;
_this = _BaseStreamController.call(this, hls, fragmentTracker, '[stream-controller]') || this;
_this.audioCodecSwap = false;
_this.gapController = null;
_this.level = -1;
_this._forceStartLoad = false;
_this.altAudio = false;
_this.audioOnly = false;
_this.fragPlaying = null;
_this.onvplaying = null;
_this.onvseeked = null;
_this.fragLastKbps = 0;
_this.stalled = false;
_this.couldBacktrack = false;
_this.audioCodecSwitch = false;
_this.videoBuffer = null;
_this._registerListeners();
return _this;
}
var _proto = StreamController.prototype;
_proto._registerListeners = function _registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].LEVEL_LOADING, this.onLevelLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].ERROR, this.onError, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_CREATED, this.onBufferCreated, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_FLUSHED, this.onBufferFlushed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].LEVELS_UPDATED, this.onLevelsUpdated, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_BUFFERED, this.onFragBuffered, this);
};
_proto._unregisterListeners = function _unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_LOAD_EMERGENCY_ABORTED, this.onFragLoadEmergencyAborted, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].ERROR, this.onError, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].AUDIO_TRACK_SWITCHING, this.onAudioTrackSwitching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].AUDIO_TRACK_SWITCHED, this.onAudioTrackSwitched, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_CREATED, this.onBufferCreated, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_FLUSHED, this.onBufferFlushed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].LEVELS_UPDATED, this.onLevelsUpdated, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_BUFFERED, this.onFragBuffered, this);
};
_proto.onHandlerDestroying = function onHandlerDestroying() {
this._unregisterListeners();
this.onMediaDetaching();
};
_proto.startLoad = function startLoad(startPosition) {
if (this.levels) {
var lastCurrentTime = this.lastCurrentTime,
hls = this.hls;
this.stopLoad();
this.setInterval(TICK_INTERVAL);
this.level = -1;
this.fragLoadError = 0;
if (!this.startFragRequested) {
// determine load level
var startLevel = hls.startLevel;
if (startLevel === -1) {
if (hls.config.testBandwidth) {
// -1 : guess start Level by doing a bitrate test by loading first fragment of lowest quality level
startLevel = 0;
this.bitrateTest = true;
} else {
startLevel = hls.nextAutoLevel;
}
} // set new level to playlist loader : this will trigger start level load
// hls.nextLoadLevel remains until it is set to a new value or until a new frag is successfully loaded
this.level = hls.nextLoadLevel = startLevel;
this.loadedmetadata = false;
} // if startPosition undefined but lastCurrentTime set, set startPosition to last currentTime
if (lastCurrentTime > 0 && startPosition === -1) {
this.log("Override startPosition with lastCurrentTime @" + lastCurrentTime.toFixed(3));
startPosition = lastCurrentTime;
}
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
this.nextLoadPosition = this.startPosition = this.lastCurrentTime = startPosition;
this.tick();
} else {
this._forceStartLoad = true;
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].STOPPED;
}
};
_proto.stopLoad = function stopLoad() {
this._forceStartLoad = false;
_BaseStreamController.prototype.stopLoad.call(this);
};
_proto.doTick = function doTick() {
switch (this.state) {
case _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE:
this.doTickIdle();
break;
case _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_LEVEL:
{
var _levels$level;
var levels = this.levels,
level = this.level;
var details = levels === null || levels === void 0 ? void 0 : (_levels$level = levels[level]) === null || _levels$level === void 0 ? void 0 : _levels$level.details;
if (details && (!details.live || this.levelLastLoaded === this.level)) {
if (this.waitForCdnTuneIn(details)) {
break;
}
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
break;
}
break;
}
case _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].FRAG_LOADING_WAITING_RETRY:
{
var _this$media;
var now = self.performance.now();
var retryDate = this.retryDate; // if current time is gt than retryDate, or if media seeking let's switch to IDLE state to retry loading
if (!retryDate || now >= retryDate || (_this$media = this.media) !== null && _this$media !== void 0 && _this$media.seeking) {
this.log('retryDate reached, switch back to IDLE state');
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
}
}
break;
default:
break;
} // check buffer
// check/update current fragment
this.onTickEnd();
};
_proto.onTickEnd = function onTickEnd() {
_BaseStreamController.prototype.onTickEnd.call(this);
this.checkBuffer();
this.checkFragmentChanged();
};
_proto.doTickIdle = function doTickIdle() {
var _frag$decryptdata, _frag$decryptdata2;
var hls = this.hls,
levelLastLoaded = this.levelLastLoaded,
levels = this.levels,
media = this.media;
var config = hls.config,
level = hls.nextLoadLevel; // if start level not parsed yet OR
// if video not attached AND start fragment already requested OR start frag prefetch not enabled
// exit loop, as we either need more info (level not parsed) or we need media to be attached to load new fragment
if (levelLastLoaded === null || !media && (this.startFragRequested || !config.startFragPrefetch)) {
return;
} // If the "main" level is audio-only but we are loading an alternate track in the same group, do not load anything
if (this.altAudio && this.audioOnly) {
return;
}
if (!levels || !levels[level]) {
return;
}
var levelInfo = levels[level]; // if buffer length is less than maxBufLen try to load a new fragment
// set next load level : this will trigger a playlist load if needed
this.level = hls.nextLoadLevel = level;
var levelDetails = levelInfo.details; // if level info not retrieved yet, switch state and wait for level retrieval
// if live playlist, ensure that new playlist has been refreshed to avoid loading/try to load
// a useless and outdated fragment (that might even introduce load error if it is already out of the live playlist)
if (!levelDetails || this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_LEVEL || levelDetails.live && this.levelLastLoaded !== level) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_LEVEL;
return;
}
var bufferInfo = this.getFwdBufferInfo(this.mediaBuffer ? this.mediaBuffer : media, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN);
if (bufferInfo === null) {
return;
}
var bufferLen = bufferInfo.len; // compute max Buffer Length that we could get from this load level, based on level bitrate. don't buffer more than 60 MB and more than 30s
var maxBufLen = this.getMaxBufferLength(levelInfo.maxBitrate); // Stay idle if we are still with buffer margins
if (bufferLen >= maxBufLen) {
return;
}
if (this._streamEnded(bufferInfo, levelDetails)) {
var data = {};
if (this.altAudio) {
data.type = 'video';
}
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_EOS, data);
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].ENDED;
return;
}
var targetBufferTime = bufferInfo.end;
var frag = this.getNextFragment(targetBufferTime, levelDetails); // Avoid backtracking after seeking or switching by loading an earlier segment in streams that could backtrack
if (this.couldBacktrack && !this.fragPrevious && frag && frag.sn !== 'initSegment') {
var fragIdx = frag.sn - levelDetails.startSN;
if (fragIdx > 1) {
frag = levelDetails.fragments[fragIdx - 1];
this.fragmentTracker.removeFragment(frag);
}
} // Avoid loop loading by using nextLoadPosition set for backtracking
if (frag && this.fragmentTracker.getState(frag) === _fragment_tracker__WEBPACK_IMPORTED_MODULE_5__["FragmentState"].OK && this.nextLoadPosition > targetBufferTime) {
// Cleanup the fragment tracker before trying to find the next unbuffered fragment
var type = this.audioOnly && !this.altAudio ? _loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].AUDIO : _loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].VIDEO;
this.afterBufferFlushed(media, type, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN);
frag = this.getNextFragment(this.nextLoadPosition, levelDetails);
}
if (!frag) {
return;
}
if (frag.initSegment && !frag.initSegment.data && !this.bitrateTest) {
frag = frag.initSegment;
} // We want to load the key if we're dealing with an identity key, because we will decrypt
// this content using the key we fetch. Other keys will be handled by the DRM CDM via EME.
if (((_frag$decryptdata = frag.decryptdata) === null || _frag$decryptdata === void 0 ? void 0 : _frag$decryptdata.keyFormat) === 'identity' && !((_frag$decryptdata2 = frag.decryptdata) !== null && _frag$decryptdata2 !== void 0 && _frag$decryptdata2.key)) {
this.loadKey(frag, levelDetails);
} else {
this.loadFragment(frag, levelDetails, targetBufferTime);
}
};
_proto.loadFragment = function loadFragment(frag, levelDetails, targetBufferTime) {
var _this$media2;
// Check if fragment is not loaded
var fragState = this.fragmentTracker.getState(frag);
this.fragCurrent = frag; // Use data from loaded backtracked fragment if available
if (fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_5__["FragmentState"].BACKTRACKED) {
var data = this.fragmentTracker.getBacktrackData(frag);
if (data) {
this._handleFragmentLoadProgress(data);
this._handleFragmentLoadComplete(data);
return;
} else {
fragState = _fragment_tracker__WEBPACK_IMPORTED_MODULE_5__["FragmentState"].NOT_LOADED;
}
}
if (fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_5__["FragmentState"].NOT_LOADED || fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_5__["FragmentState"].PARTIAL) {
if (frag.sn === 'initSegment') {
this._loadInitSegment(frag);
} else if (this.bitrateTest) {
frag.bitrateTest = true;
this.log("Fragment " + frag.sn + " of level " + frag.level + " is being downloaded to test bitrate and will not be buffered");
this._loadBitrateTestFrag(frag);
} else {
this.startFragRequested = true;
_BaseStreamController.prototype.loadFragment.call(this, frag, levelDetails, targetBufferTime);
}
} else if (fragState === _fragment_tracker__WEBPACK_IMPORTED_MODULE_5__["FragmentState"].APPENDING) {
// Lower the buffer size and try again
if (this.reduceMaxBufferLength(frag.duration)) {
this.fragmentTracker.removeFragment(frag);
}
} else if (((_this$media2 = this.media) === null || _this$media2 === void 0 ? void 0 : _this$media2.buffered.length) === 0) {
// Stop gap for bad tracker / buffer flush behavior
this.fragmentTracker.removeAllFragments();
}
};
_proto.getAppendedFrag = function getAppendedFrag(position) {
var fragOrPart = this.fragmentTracker.getAppendedFrag(position, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN);
if (fragOrPart && 'fragment' in fragOrPart) {
return fragOrPart.fragment;
}
return fragOrPart;
};
_proto.getBufferedFrag = function getBufferedFrag(position) {
return this.fragmentTracker.getBufferedFrag(position, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN);
};
_proto.followingBufferedFrag = function followingBufferedFrag(frag) {
if (frag) {
// try to get range of next fragment (500ms after this range)
return this.getBufferedFrag(frag.end + 0.5);
}
return null;
}
/*
on immediate level switch :
- pause playback if playing
- cancel any pending load request
- and trigger a buffer flush
*/
;
_proto.immediateLevelSwitch = function immediateLevelSwitch() {
this.abortCurrentFrag();
this.flushMainBuffer(0, Number.POSITIVE_INFINITY);
}
/**
* try to switch ASAP without breaking video playback:
* in order to ensure smooth but quick level switching,
* we need to find the next flushable buffer range
* we should take into account new segment fetch time
*/
;
_proto.nextLevelSwitch = function nextLevelSwitch() {
var levels = this.levels,
media = this.media; // ensure that media is defined and that metadata are available (to retrieve currentTime)
if (media !== null && media !== void 0 && media.readyState) {
var fetchdelay;
var fragPlayingCurrent = this.getAppendedFrag(media.currentTime);
if (fragPlayingCurrent && fragPlayingCurrent.start > 1) {
// flush buffer preceding current fragment (flush until current fragment start offset)
// minus 1s to avoid video freezing, that could happen if we flush keyframe of current video ...
this.flushMainBuffer(0, fragPlayingCurrent.start - 1);
}
if (!media.paused && levels) {
// add a safety delay of 1s
var nextLevelId = this.hls.nextLoadLevel;
var nextLevel = levels[nextLevelId];
var fragLastKbps = this.fragLastKbps;
if (fragLastKbps && this.fragCurrent) {
fetchdelay = this.fragCurrent.duration * nextLevel.maxBitrate / (1000 * fragLastKbps) + 1;
} else {
fetchdelay = 0;
}
} else {
fetchdelay = 0;
} // this.log('fetchdelay:'+fetchdelay);
// find buffer range that will be reached once new fragment will be fetched
var bufferedFrag = this.getBufferedFrag(media.currentTime + fetchdelay);
if (bufferedFrag) {
// we can flush buffer range following this one without stalling playback
var nextBufferedFrag = this.followingBufferedFrag(bufferedFrag);
if (nextBufferedFrag) {
// if we are here, we can also cancel any loading/demuxing in progress, as they are useless
this.abortCurrentFrag(); // start flush position is in next buffered frag. Leave some padding for non-independent segments and smoother playback.
var maxStart = nextBufferedFrag.maxStartPTS ? nextBufferedFrag.maxStartPTS : nextBufferedFrag.start;
var fragDuration = nextBufferedFrag.duration;
var startPts = Math.max(bufferedFrag.end, maxStart + Math.min(Math.max(fragDuration - this.config.maxFragLookUpTolerance, fragDuration * 0.5), fragDuration * 0.75));
this.flushMainBuffer(startPts, Number.POSITIVE_INFINITY);
}
}
}
};
_proto.abortCurrentFrag = function abortCurrentFrag() {
var fragCurrent = this.fragCurrent;
this.fragCurrent = null;
if (fragCurrent !== null && fragCurrent !== void 0 && fragCurrent.loader) {
fragCurrent.loader.abort();
}
if (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].KEY_LOADING) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
}
this.nextLoadPosition = this.getLoadPosition();
};
_proto.flushMainBuffer = function flushMainBuffer(startOffset, endOffset) {
_BaseStreamController.prototype.flushMainBuffer.call(this, startOffset, endOffset, this.altAudio ? 'video' : null);
};
_proto.onMediaAttached = function onMediaAttached(event, data) {
_BaseStreamController.prototype.onMediaAttached.call(this, event, data);
var media = data.media;
this.onvplaying = this.onMediaPlaying.bind(this);
this.onvseeked = this.onMediaSeeked.bind(this);
media.addEventListener('playing', this.onvplaying);
media.addEventListener('seeked', this.onvseeked);
this.gapController = new _gap_controller__WEBPACK_IMPORTED_MODULE_10__["default"](this.config, media, this.fragmentTracker, this.hls);
};
_proto.onMediaDetaching = function onMediaDetaching() {
var media = this.media;
if (media) {
media.removeEventListener('playing', this.onvplaying);
media.removeEventListener('seeked', this.onvseeked);
this.onvplaying = this.onvseeked = null;
this.videoBuffer = null;
}
this.fragPlaying = null;
if (this.gapController) {
this.gapController.destroy();
this.gapController = null;
}
_BaseStreamController.prototype.onMediaDetaching.call(this);
};
_proto.onMediaPlaying = function onMediaPlaying() {
// tick to speed up FRAG_CHANGED triggering
this.tick();
};
_proto.onMediaSeeked = function onMediaSeeked() {
var media = this.media;
var currentTime = media ? media.currentTime : null;
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(currentTime)) {
this.log("Media seeked to " + currentTime.toFixed(3));
} // tick to speed up FRAG_CHANGED triggering
this.tick();
};
_proto.onManifestLoading = function onManifestLoading() {
// reset buffer on manifest loading
this.log('Trigger BUFFER_RESET');
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_RESET, undefined);
this.fragmentTracker.removeAllFragments();
this.couldBacktrack = this.stalled = false;
this.startPosition = this.lastCurrentTime = 0;
this.fragPlaying = null;
};
_proto.onManifestParsed = function onManifestParsed(event, data) {
var aac = false;
var heaac = false;
var codec;
data.levels.forEach(function (level) {
// detect if we have different kind of audio codecs used amongst playlists
codec = level.audioCodec;
if (codec) {
if (codec.indexOf('mp4a.40.2') !== -1) {
aac = true;
}
if (codec.indexOf('mp4a.40.5') !== -1) {
heaac = true;
}
}
});
this.audioCodecSwitch = aac && heaac && !Object(_is_supported__WEBPACK_IMPORTED_MODULE_2__["changeTypeSupported"])();
if (this.audioCodecSwitch) {
this.log('Both AAC/HE-AAC audio found in levels; declaring level codec as HE-AAC');
}
this.levels = data.levels;
this.startFragRequested = false;
};
_proto.onLevelLoading = function onLevelLoading(event, data) {
var levels = this.levels;
if (!levels || this.state !== _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE) {
return;
}
var level = levels[data.level];
if (!level.details || level.details.live && this.levelLastLoaded !== data.level || this.waitForCdnTuneIn(level.details)) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_LEVEL;
}
};
_proto.onLevelLoaded = function onLevelLoaded(event, data) {
var _curLevel$details;
var levels = this.levels;
var newLevelId = data.level;
var newDetails = data.details;
var duration = newDetails.totalduration;
if (!levels) {
this.warn("Levels were reset while loading level " + newLevelId);
return;
}
this.log("Level " + newLevelId + " loaded [" + newDetails.startSN + "," + newDetails.endSN + "], cc [" + newDetails.startCC + ", " + newDetails.endCC + "] duration:" + duration);
var fragCurrent = this.fragCurrent;
if (fragCurrent && (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].FRAG_LOADING || this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].FRAG_LOADING_WAITING_RETRY)) {
if (fragCurrent.level !== data.level && fragCurrent.loader) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
fragCurrent.loader.abort();
}
}
var curLevel = levels[newLevelId];
var sliding = 0;
if (newDetails.live || (_curLevel$details = curLevel.details) !== null && _curLevel$details !== void 0 && _curLevel$details.live) {
if (!newDetails.fragments[0]) {
newDetails.deltaUpdateFailed = true;
}
if (newDetails.deltaUpdateFailed) {
return;
}
sliding = this.alignPlaylists(newDetails, curLevel.details);
} // override level info
curLevel.details = newDetails;
this.levelLastLoaded = newLevelId;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].LEVEL_UPDATED, {
details: newDetails,
level: newLevelId
}); // only switch back to IDLE state if we were waiting for level to start downloading a new fragment
if (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_LEVEL) {
if (this.waitForCdnTuneIn(newDetails)) {
// Wait for Low-Latency CDN Tune-in
return;
}
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
}
if (!this.startFragRequested) {
this.setStartPosition(newDetails, sliding);
} else if (newDetails.live) {
this.synchronizeToLiveEdge(newDetails);
} // trigger handler right now
this.tick();
};
_proto._handleFragmentLoadProgress = function _handleFragmentLoadProgress(data) {
var _frag$initSegment;
var frag = data.frag,
part = data.part,
payload = data.payload;
var levels = this.levels;
if (!levels) {
this.warn("Levels were reset while fragment load was in progress. Fragment " + frag.sn + " of level " + frag.level + " will not be buffered");
return;
}
var currentLevel = levels[frag.level];
var details = currentLevel.details;
if (!details) {
this.warn("Dropping fragment " + frag.sn + " of level " + frag.level + " after level details were reset");
return;
}
var videoCodec = currentLevel.videoCodec; // time Offset is accurate if level PTS is known, or if playlist is not sliding (not live)
var accurateTimeOffset = details.PTSKnown || !details.live;
var initSegmentData = (_frag$initSegment = frag.initSegment) === null || _frag$initSegment === void 0 ? void 0 : _frag$initSegment.data;
var audioCodec = this._getAudioCodec(currentLevel); // transmux the MPEG-TS data to ISO-BMFF segments
// this.log(`Transmuxing ${frag.sn} of [${details.startSN} ,${details.endSN}],level ${frag.level}, cc ${frag.cc}`);
var transmuxer = this.transmuxer = this.transmuxer || new _demux_transmuxer_interface__WEBPACK_IMPORTED_MODULE_8__["default"](this.hls, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN, this._handleTransmuxComplete.bind(this), this._handleTransmuxerFlush.bind(this));
var partIndex = part ? part.index : -1;
var partial = partIndex !== -1;
var chunkMeta = new _types_transmuxer__WEBPACK_IMPORTED_MODULE_9__["ChunkMetadata"](frag.level, frag.sn, frag.stats.chunkCount, payload.byteLength, partIndex, partial);
var initPTS = this.initPTS[frag.cc];
transmuxer.push(payload, initSegmentData, audioCodec, videoCodec, frag, part, details.totalduration, accurateTimeOffset, chunkMeta, initPTS);
};
_proto.onAudioTrackSwitching = function onAudioTrackSwitching(event, data) {
// if any URL found on new audio track, it is an alternate audio track
var fromAltAudio = this.altAudio;
var altAudio = !!data.url;
var trackId = data.id; // if we switch on main audio, ensure that main fragment scheduling is synced with media.buffered
// don't do anything if we switch to alt audio: audio stream controller is handling it.
// we will just have to change buffer scheduling on audioTrackSwitched
if (!altAudio) {
if (this.mediaBuffer !== this.media) {
this.log('Switching on main audio, use media.buffered to schedule main fragment loading');
this.mediaBuffer = this.media;
var fragCurrent = this.fragCurrent; // we need to refill audio buffer from main: cancel any frag loading to speed up audio switch
if (fragCurrent !== null && fragCurrent !== void 0 && fragCurrent.loader) {
this.log('Switching to main audio track, cancel main fragment load');
fragCurrent.loader.abort();
} // destroy transmuxer to force init segment generation (following audio switch)
this.resetTransmuxer(); // switch to IDLE state to load new fragment
this.resetLoadingState();
} else if (this.audioOnly) {
// Reset audio transmuxer so when switching back to main audio we're not still appending where we left off
this.resetTransmuxer();
}
var hls = this.hls; // If switching from alt to main audio, flush all audio and trigger track switched
if (fromAltAudio) {
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_FLUSHING, {
startOffset: 0,
endOffset: Number.POSITIVE_INFINITY,
type: 'audio'
});
}
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].AUDIO_TRACK_SWITCHED, {
id: trackId
});
}
};
_proto.onAudioTrackSwitched = function onAudioTrackSwitched(event, data) {
var trackId = data.id;
var altAudio = !!this.hls.audioTracks[trackId].url;
if (altAudio) {
var videoBuffer = this.videoBuffer; // if we switched on alternate audio, ensure that main fragment scheduling is synced with video sourcebuffer buffered
if (videoBuffer && this.mediaBuffer !== videoBuffer) {
this.log('Switching on alternate audio, use video.buffered to schedule main fragment loading');
this.mediaBuffer = videoBuffer;
}
}
this.altAudio = altAudio;
this.tick();
};
_proto.onBufferCreated = function onBufferCreated(event, data) {
var tracks = data.tracks;
var mediaTrack;
var name;
var alternate = false;
for (var type in tracks) {
var track = tracks[type];
if (track.id === 'main') {
name = type;
mediaTrack = track; // keep video source buffer reference
if (type === 'video') {
var videoTrack = tracks[type];
if (videoTrack) {
this.videoBuffer = videoTrack.buffer;
}
}
} else {
alternate = true;
}
}
if (alternate && mediaTrack) {
this.log("Alternate track found, use " + name + ".buffered to schedule main fragment loading");
this.mediaBuffer = mediaTrack.buffer;
} else {
this.mediaBuffer = this.media;
}
};
_proto.onFragBuffered = function onFragBuffered(event, data) {
var frag = data.frag,
part = data.part;
if (frag && frag.type !== _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN) {
return;
}
if (this.fragContextChanged(frag)) {
// If a level switch was requested while a fragment was buffering, it will emit the FRAG_BUFFERED event upon completion
// Avoid setting state back to IDLE, since that will interfere with a level switch
this.warn("Fragment " + frag.sn + (part ? ' p: ' + part.index : '') + " of level " + frag.level + " finished buffering, but was aborted. state: " + this.state);
if (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSED) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
}
return;
}
var stats = part ? part.stats : frag.stats;
this.fragLastKbps = Math.round(8 * stats.total / (stats.buffering.end - stats.loading.first));
if (frag.sn !== 'initSegment') {
this.fragPrevious = frag;
}
this.fragBufferedComplete(frag, part);
};
_proto.onError = function onError(event, data) {
switch (data.details) {
case _errors__WEBPACK_IMPORTED_MODULE_11__["ErrorDetails"].FRAG_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_11__["ErrorDetails"].FRAG_LOAD_TIMEOUT:
case _errors__WEBPACK_IMPORTED_MODULE_11__["ErrorDetails"].KEY_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_11__["ErrorDetails"].KEY_LOAD_TIMEOUT:
this.onFragmentOrKeyLoadError(_types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN, data);
break;
case _errors__WEBPACK_IMPORTED_MODULE_11__["ErrorDetails"].LEVEL_LOAD_ERROR:
case _errors__WEBPACK_IMPORTED_MODULE_11__["ErrorDetails"].LEVEL_LOAD_TIMEOUT:
if (this.state !== _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].ERROR) {
if (data.fatal) {
// if fatal error, stop processing
this.warn("" + data.details);
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].ERROR;
} else {
// in case of non fatal error while loading level, if level controller is not retrying to load level , switch back to IDLE
if (!data.levelRetry && this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].WAITING_LEVEL) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
}
}
}
break;
case _errors__WEBPACK_IMPORTED_MODULE_11__["ErrorDetails"].BUFFER_FULL_ERROR:
// if in appending state
if (data.parent === 'main' && (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSING || this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSED)) {
var flushBuffer = true;
var bufferedInfo = this.getFwdBufferInfo(this.media, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN); // 0.5 : tolerance needed as some browsers stalls playback before reaching buffered end
// reduce max buf len if current position is buffered
if (bufferedInfo && bufferedInfo.len > 0.5) {
flushBuffer = !this.reduceMaxBufferLength(bufferedInfo.len);
}
if (flushBuffer) {
// current position is not buffered, but browser is still complaining about buffer full error
// this happens on IE/Edge, refer to https://github.com/video-dev/hls.js/pull/708
// in that case flush the whole buffer to recover
this.warn('buffer full error also media.currentTime is not buffered, flush main'); // flush main buffer
this.immediateLevelSwitch();
}
this.resetLoadingState();
}
break;
default:
break;
}
} // Checks the health of the buffer and attempts to resolve playback stalls.
;
_proto.checkBuffer = function checkBuffer() {
var media = this.media,
gapController = this.gapController;
if (!media || !gapController || !media.readyState) {
// Exit early if we don't have media or if the media hasn't buffered anything yet (readyState 0)
return;
} // Check combined buffer
var buffered = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__["BufferHelper"].getBuffered(media);
if (!this.loadedmetadata && buffered.length) {
this.loadedmetadata = true;
this.seekToStartPos();
} else {
// Resolve gaps using the main buffer, whose ranges are the intersections of the A/V sourcebuffers
gapController.poll(this.lastCurrentTime);
}
this.lastCurrentTime = media.currentTime;
};
_proto.onFragLoadEmergencyAborted = function onFragLoadEmergencyAborted() {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE; // if loadedmetadata is not set, it means that we are emergency switch down on first frag
// in that case, reset startFragRequested flag
if (!this.loadedmetadata) {
this.startFragRequested = false;
this.nextLoadPosition = this.startPosition;
}
this.tickImmediate();
};
_proto.onBufferFlushed = function onBufferFlushed(event, _ref) {
var type = _ref.type;
if (type !== _loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].AUDIO || this.audioOnly && !this.altAudio) {
var media = (type === _loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].VIDEO ? this.videoBuffer : this.mediaBuffer) || this.media;
this.afterBufferFlushed(media, type, _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN);
}
};
_proto.onLevelsUpdated = function onLevelsUpdated(event, data) {
this.levels = data.levels;
};
_proto.swapAudioCodec = function swapAudioCodec() {
this.audioCodecSwap = !this.audioCodecSwap;
}
/**
* Seeks to the set startPosition if not equal to the mediaElement's current time.
* @private
*/
;
_proto.seekToStartPos = function seekToStartPos() {
var media = this.media;
var currentTime = media.currentTime;
var startPosition = this.startPosition; // only adjust currentTime if different from startPosition or if startPosition not buffered
// at that stage, there should be only one buffered range, as we reach that code after first fragment has been buffered
if (startPosition >= 0 && currentTime < startPosition) {
if (media.seeking) {
_utils_logger__WEBPACK_IMPORTED_MODULE_12__["logger"].log("could not seek to " + startPosition + ", already seeking at " + currentTime);
return;
}
var buffered = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__["BufferHelper"].getBuffered(media);
var bufferStart = buffered.length ? buffered.start(0) : 0;
var delta = bufferStart - startPosition;
if (delta > 0 && (delta < this.config.maxBufferHole || delta < this.config.maxFragLookUpTolerance)) {
_utils_logger__WEBPACK_IMPORTED_MODULE_12__["logger"].log("adjusting start position by " + delta + " to match buffer start");
startPosition += delta;
this.startPosition = startPosition;
}
this.log("seek to target start position " + startPosition + " from current time " + currentTime);
media.currentTime = startPosition;
}
};
_proto._getAudioCodec = function _getAudioCodec(currentLevel) {
var audioCodec = this.config.defaultAudioCodec || currentLevel.audioCodec;
if (this.audioCodecSwap && audioCodec) {
this.log('Swapping audio codec');
if (audioCodec.indexOf('mp4a.40.5') !== -1) {
audioCodec = 'mp4a.40.2';
} else {
audioCodec = 'mp4a.40.5';
}
}
return audioCodec;
};
_proto._loadBitrateTestFrag = function _loadBitrateTestFrag(frag) {
var _this2 = this;
this._doFragLoad(frag).then(function (data) {
var hls = _this2.hls;
if (!data || hls.nextLoadLevel || _this2.fragContextChanged(frag)) {
return;
}
_this2.fragLoadError = 0;
_this2.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].IDLE;
_this2.startFragRequested = false;
_this2.bitrateTest = false;
var stats = frag.stats; // Bitrate tests fragments are neither parsed nor buffered
stats.parsing.start = stats.parsing.end = stats.buffering.start = stats.buffering.end = self.performance.now();
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_LOADED, data);
});
};
_proto._handleTransmuxComplete = function _handleTransmuxComplete(transmuxResult) {
var _id3$samples;
var id = 'main';
var hls = this.hls;
var remuxResult = transmuxResult.remuxResult,
chunkMeta = transmuxResult.chunkMeta;
var context = this.getCurrentContext(chunkMeta);
if (!context) {
this.warn("The loading context changed while buffering fragment " + chunkMeta.sn + " of level " + chunkMeta.level + ". This chunk will not be buffered.");
this.resetLiveStartWhenNotLoaded(chunkMeta.level);
return;
}
var frag = context.frag,
part = context.part,
level = context.level;
var video = remuxResult.video,
text = remuxResult.text,
id3 = remuxResult.id3,
initSegment = remuxResult.initSegment; // The audio-stream-controller handles audio buffering if Hls.js is playing an alternate audio track
var audio = this.altAudio ? undefined : remuxResult.audio; // Check if the current fragment has been aborted. We check this by first seeing if we're still playing the current level.
// If we are, subsequently check if the currently loading fragment (fragCurrent) has changed.
if (this.fragContextChanged(frag)) {
return;
}
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSING;
if (initSegment) {
if (initSegment.tracks) {
this._bufferInitSegment(level, initSegment.tracks, frag, chunkMeta);
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_PARSING_INIT_SEGMENT, {
frag: frag,
id: id,
tracks: initSegment.tracks
});
} // This would be nice if Number.isFinite acted as a typeguard, but it doesn't. See: https://github.com/Microsoft/TypeScript/issues/10038
var initPTS = initSegment.initPTS;
var timescale = initSegment.timescale;
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(initPTS)) {
this.initPTS[frag.cc] = initPTS;
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].INIT_PTS_FOUND, {
frag: frag,
id: id,
initPTS: initPTS,
timescale: timescale
});
}
} // Avoid buffering if backtracking this fragment
if (video && remuxResult.independent !== false) {
if (level.details) {
var startPTS = video.startPTS,
endPTS = video.endPTS,
startDTS = video.startDTS,
endDTS = video.endDTS;
if (part) {
part.elementaryStreams[video.type] = {
startPTS: startPTS,
endPTS: endPTS,
startDTS: startDTS,
endDTS: endDTS
};
} else {
if (video.firstKeyFrame && video.independent) {
this.couldBacktrack = true;
}
if (video.dropped && video.independent) {
// Backtrack if dropped frames create a gap after currentTime
var pos = this.getLoadPosition() + this.config.maxBufferHole;
if (pos < startPTS) {
this.backtrack(frag);
return;
} // Set video stream start to fragment start so that truncated samples do not distort the timeline, and mark it partial
frag.setElementaryStreamInfo(video.type, frag.start, endPTS, frag.start, endDTS, true);
}
}
frag.setElementaryStreamInfo(video.type, startPTS, endPTS, startDTS, endDTS);
this.bufferFragmentData(video, frag, part, chunkMeta);
}
} else if (remuxResult.independent === false) {
this.backtrack(frag);
return;
}
if (audio) {
var _startPTS = audio.startPTS,
_endPTS = audio.endPTS,
_startDTS = audio.startDTS,
_endDTS = audio.endDTS;
if (part) {
part.elementaryStreams[_loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].AUDIO] = {
startPTS: _startPTS,
endPTS: _endPTS,
startDTS: _startDTS,
endDTS: _endDTS
};
}
frag.setElementaryStreamInfo(_loader_fragment__WEBPACK_IMPORTED_MODULE_7__["ElementaryStreamTypes"].AUDIO, _startPTS, _endPTS, _startDTS, _endDTS);
this.bufferFragmentData(audio, frag, part, chunkMeta);
}
if (id3 !== null && id3 !== void 0 && (_id3$samples = id3.samples) !== null && _id3$samples !== void 0 && _id3$samples.length) {
var emittedID3 = {
frag: frag,
id: id,
samples: id3.samples
};
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_PARSING_METADATA, emittedID3);
}
if (text) {
var emittedText = {
frag: frag,
id: id,
samples: text.samples
};
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_PARSING_USERDATA, emittedText);
}
};
_proto._bufferInitSegment = function _bufferInitSegment(currentLevel, tracks, frag, chunkMeta) {
var _this3 = this;
if (this.state !== _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].PARSING) {
return;
}
this.audioOnly = !!tracks.audio && !tracks.video; // if audio track is expected to come from audio stream controller, discard any coming from main
if (this.altAudio && !this.audioOnly) {
delete tracks.audio;
} // include levelCodec in audio and video tracks
var audio = tracks.audio,
video = tracks.video,
audiovideo = tracks.audiovideo;
if (audio) {
var audioCodec = currentLevel.audioCodec;
var ua = navigator.userAgent.toLowerCase();
if (this.audioCodecSwitch) {
if (audioCodec) {
if (audioCodec.indexOf('mp4a.40.5') !== -1) {
audioCodec = 'mp4a.40.2';
} else {
audioCodec = 'mp4a.40.5';
}
} // In the case that AAC and HE-AAC audio codecs are signalled in manifest,
// force HE-AAC, as it seems that most browsers prefers it.
// don't force HE-AAC if mono stream, or in Firefox
if (audio.metadata.channelCount !== 1 && ua.indexOf('firefox') === -1) {
audioCodec = 'mp4a.40.5';
}
} // HE-AAC is broken on Android, always signal audio codec as AAC even if variant manifest states otherwise
if (ua.indexOf('android') !== -1 && audio.container !== 'audio/mpeg') {
// Exclude mpeg audio
audioCodec = 'mp4a.40.2';
this.log("Android: force audio codec to " + audioCodec);
}
if (currentLevel.audioCodec && currentLevel.audioCodec !== audioCodec) {
this.log("Swapping manifest audio codec \"" + currentLevel.audioCodec + "\" for \"" + audioCodec + "\"");
}
audio.levelCodec = audioCodec;
audio.id = 'main';
this.log("Init audio buffer, container:" + audio.container + ", codecs[selected/level/parsed]=[" + (audioCodec || '') + "/" + (currentLevel.audioCodec || '') + "/" + audio.codec + "]");
}
if (video) {
video.levelCodec = currentLevel.videoCodec;
video.id = 'main';
this.log("Init video buffer, container:" + video.container + ", codecs[level/parsed]=[" + (currentLevel.videoCodec || '') + "/" + video.codec + "]");
}
if (audiovideo) {
this.log("Init audiovideo buffer, container:" + audiovideo.container + ", codecs[level/parsed]=[" + (currentLevel.attrs.CODECS || '') + "/" + audiovideo.codec + "]");
}
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_CODECS, tracks); // loop through tracks that are going to be provided to bufferController
Object.keys(tracks).forEach(function (trackName) {
var track = tracks[trackName];
var initSegment = track.initSegment;
if (initSegment !== null && initSegment !== void 0 && initSegment.byteLength) {
_this3.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].BUFFER_APPENDING, {
type: trackName,
data: initSegment,
frag: frag,
part: null,
chunkMeta: chunkMeta,
parent: frag.type
});
}
}); // trigger handler right now
this.tick();
};
_proto.backtrack = function backtrack(frag) {
this.couldBacktrack = true; // Causes findFragments to backtrack through fragments to find the keyframe
this.resetTransmuxer();
this.flushBufferGap(frag);
var data = this.fragmentTracker.backtrack(frag);
this.fragPrevious = null;
this.nextLoadPosition = frag.start;
if (data) {
this.resetFragmentLoading(frag);
} else {
// Change state to BACKTRACKING so that fragmentEntity.backtrack data can be added after _doFragLoad
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["State"].BACKTRACKING;
}
};
_proto.checkFragmentChanged = function checkFragmentChanged() {
var video = this.media;
var fragPlayingCurrent = null;
if (video && video.readyState > 1 && video.seeking === false) {
var currentTime = video.currentTime;
/* if video element is in seeked state, currentTime can only increase.
(assuming that playback rate is positive ...)
As sometimes currentTime jumps back to zero after a
media decode error, check this, to avoid seeking back to
wrong position after a media decode error
*/
if (_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__["BufferHelper"].isBuffered(video, currentTime)) {
fragPlayingCurrent = this.getAppendedFrag(currentTime);
} else if (_utils_buffer_helper__WEBPACK_IMPORTED_MODULE_4__["BufferHelper"].isBuffered(video, currentTime + 0.1)) {
/* ensure that FRAG_CHANGED event is triggered at startup,
when first video frame is displayed and playback is paused.
add a tolerance of 100ms, in case current position is not buffered,
check if current pos+100ms is buffered and use that buffer range
for FRAG_CHANGED event reporting */
fragPlayingCurrent = this.getAppendedFrag(currentTime + 0.1);
}
if (fragPlayingCurrent) {
var fragPlaying = this.fragPlaying;
var fragCurrentLevel = fragPlayingCurrent.level;
if (!fragPlaying || fragPlayingCurrent.sn !== fragPlaying.sn || fragPlaying.level !== fragCurrentLevel || fragPlayingCurrent.urlId !== fragPlaying.urlId) {
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].FRAG_CHANGED, {
frag: fragPlayingCurrent
});
if (!fragPlaying || fragPlaying.level !== fragCurrentLevel) {
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].LEVEL_SWITCHED, {
level: fragCurrentLevel
});
}
this.fragPlaying = fragPlayingCurrent;
}
}
}
};
_createClass(StreamController, [{
key: "nextLevel",
get: function get() {
var frag = this.nextBufferedFrag;
if (frag) {
return frag.level;
} else {
return -1;
}
}
}, {
key: "currentLevel",
get: function get() {
var media = this.media;
if (media) {
var fragPlayingCurrent = this.getAppendedFrag(media.currentTime);
if (fragPlayingCurrent) {
return fragPlayingCurrent.level;
}
}
return -1;
}
}, {
key: "nextBufferedFrag",
get: function get() {
var media = this.media;
if (media) {
// first get end range of current fragment
var fragPlayingCurrent = this.getAppendedFrag(media.currentTime);
return this.followingBufferedFrag(fragPlayingCurrent);
} else {
return null;
}
}
}, {
key: "forceStartLoad",
get: function get() {
return this._forceStartLoad;
}
}]);
return StreamController;
}(_base_stream_controller__WEBPACK_IMPORTED_MODULE_1__["default"]);
/***/ }),
/***/ "./src/controller/subtitle-stream-controller.ts":
/*!******************************************************!*\
!*** ./src/controller/subtitle-stream-controller.ts ***!
\******************************************************/
/*! exports provided: SubtitleStreamController */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "SubtitleStreamController", function() { return SubtitleStreamController; });
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/buffer-helper */ "./src/utils/buffer-helper.ts");
/* harmony import */ var _fragment_finders__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./fragment-finders */ "./src/controller/fragment-finders.ts");
/* harmony import */ var _utils_discontinuities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/discontinuities */ "./src/utils/discontinuities.ts");
/* harmony import */ var _level_helper__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./level-helper */ "./src/controller/level-helper.ts");
/* harmony import */ var _fragment_tracker__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./fragment-tracker */ "./src/controller/fragment-tracker.ts");
/* harmony import */ var _base_stream_controller__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./base-stream-controller */ "./src/controller/base-stream-controller.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
/* harmony import */ var _types_level__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../types/level */ "./src/types/level.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var TICK_INTERVAL = 500; // how often to tick in ms
var SubtitleStreamController = /*#__PURE__*/function (_BaseStreamController) {
_inheritsLoose(SubtitleStreamController, _BaseStreamController);
function SubtitleStreamController(hls, fragmentTracker) {
var _this;
_this = _BaseStreamController.call(this, hls, fragmentTracker, '[subtitle-stream-controller]') || this;
_this.levels = [];
_this.currentTrackId = -1;
_this.tracksBuffered = [];
_this.mainDetails = null;
_this._registerListeners();
return _this;
}
var _proto = SubtitleStreamController.prototype;
_proto.onHandlerDestroying = function onHandlerDestroying() {
this._unregisterListeners();
this.mainDetails = null;
};
_proto._registerListeners = function _registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, this.onError, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_FRAG_PROCESSED, this.onSubtitleFragProcessed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].BUFFER_FLUSHING, this.onBufferFlushing, this);
};
_proto._unregisterListeners = function _unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_LOADED, this.onLevelLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, this.onError, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_FRAG_PROCESSED, this.onSubtitleFragProcessed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].BUFFER_FLUSHING, this.onBufferFlushing, this);
};
_proto.startLoad = function startLoad() {
this.stopLoad();
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_7__["State"].IDLE;
this.setInterval(TICK_INTERVAL);
this.tick();
};
_proto.onManifestLoading = function onManifestLoading() {
this.mainDetails = null;
this.fragmentTracker.removeAllFragments();
};
_proto.onLevelLoaded = function onLevelLoaded(event, data) {
this.mainDetails = data.details;
};
_proto.onSubtitleFragProcessed = function onSubtitleFragProcessed(event, data) {
var frag = data.frag,
success = data.success;
this.fragPrevious = frag;
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_7__["State"].IDLE;
if (!success) {
return;
}
var buffered = this.tracksBuffered[this.currentTrackId];
if (!buffered) {
return;
} // Create/update a buffered array matching the interface used by BufferHelper.bufferedInfo
// so we can re-use the logic used to detect how much has been buffered
var timeRange;
var fragStart = frag.start;
for (var i = 0; i < buffered.length; i++) {
if (fragStart >= buffered[i].start && fragStart <= buffered[i].end) {
timeRange = buffered[i];
break;
}
}
var fragEnd = frag.start + frag.duration;
if (timeRange) {
timeRange.end = fragEnd;
} else {
timeRange = {
start: fragStart,
end: fragEnd
};
buffered.push(timeRange);
}
this.fragmentTracker.fragBuffered(frag);
};
_proto.onBufferFlushing = function onBufferFlushing(event, data) {
var startOffset = data.startOffset,
endOffset = data.endOffset;
if (startOffset === 0 && endOffset !== Number.POSITIVE_INFINITY) {
var currentTrackId = this.currentTrackId,
levels = this.levels;
if (!levels.length || !levels[currentTrackId] || !levels[currentTrackId].details) {
return;
}
var trackDetails = levels[currentTrackId].details;
var targetDuration = trackDetails.targetduration;
var endOffsetSubtitles = endOffset - targetDuration;
if (endOffsetSubtitles <= 0) {
return;
}
data.endOffsetSubtitles = Math.max(0, endOffsetSubtitles);
this.tracksBuffered.forEach(function (buffered) {
for (var i = 0; i < buffered.length;) {
if (buffered[i].end <= endOffsetSubtitles) {
buffered.shift();
continue;
} else if (buffered[i].start < endOffsetSubtitles) {
buffered[i].start = endOffsetSubtitles;
} else {
break;
}
i++;
}
});
this.fragmentTracker.removeFragmentsInRange(startOffset, endOffsetSubtitles, _types_loader__WEBPACK_IMPORTED_MODULE_8__["PlaylistLevelType"].SUBTITLE);
}
} // If something goes wrong, proceed to next frag, if we were processing one.
;
_proto.onError = function onError(event, data) {
var _this$fragCurrent;
var frag = data.frag; // don't handle error not related to subtitle fragment
if (!frag || frag.type !== _types_loader__WEBPACK_IMPORTED_MODULE_8__["PlaylistLevelType"].SUBTITLE) {
return;
}
if ((_this$fragCurrent = this.fragCurrent) !== null && _this$fragCurrent !== void 0 && _this$fragCurrent.loader) {
this.fragCurrent.loader.abort();
}
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_7__["State"].IDLE;
} // Got all new subtitle levels.
;
_proto.onSubtitleTracksUpdated = function onSubtitleTracksUpdated(event, _ref) {
var _this2 = this;
var subtitleTracks = _ref.subtitleTracks;
this.tracksBuffered = [];
this.levels = subtitleTracks.map(function (mediaPlaylist) {
return new _types_level__WEBPACK_IMPORTED_MODULE_9__["Level"](mediaPlaylist);
});
this.fragmentTracker.removeAllFragments();
this.fragPrevious = null;
this.levels.forEach(function (level) {
_this2.tracksBuffered[level.id] = [];
});
this.mediaBuffer = null;
};
_proto.onSubtitleTrackSwitch = function onSubtitleTrackSwitch(event, data) {
this.currentTrackId = data.id;
if (!this.levels.length || this.currentTrackId === -1) {
this.clearInterval();
return;
} // Check if track has the necessary details to load fragments
var currentTrack = this.levels[this.currentTrackId];
if (currentTrack !== null && currentTrack !== void 0 && currentTrack.details) {
this.mediaBuffer = this.mediaBufferTimeRanges;
this.setInterval(TICK_INTERVAL);
} else {
this.mediaBuffer = null;
}
} // Got a new set of subtitle fragments.
;
_proto.onSubtitleTrackLoaded = function onSubtitleTrackLoaded(event, data) {
var _track$details;
var newDetails = data.details,
trackId = data.id;
var currentTrackId = this.currentTrackId,
levels = this.levels;
if (!levels.length) {
return;
}
var track = levels[currentTrackId];
if (trackId >= levels.length || trackId !== currentTrackId || !track) {
return;
}
this.mediaBuffer = this.mediaBufferTimeRanges;
if (newDetails.live || (_track$details = track.details) !== null && _track$details !== void 0 && _track$details.live) {
var mainDetails = this.mainDetails;
if (newDetails.deltaUpdateFailed || !mainDetails) {
return;
}
var mainSlidingStartFragment = mainDetails.fragments[0];
if (!track.details) {
if (newDetails.hasProgramDateTime && mainDetails.hasProgramDateTime) {
Object(_utils_discontinuities__WEBPACK_IMPORTED_MODULE_4__["alignMediaPlaylistByPDT"])(newDetails, mainDetails);
} else if (mainSlidingStartFragment) {
// line up live playlist with main so that fragments in range are loaded
Object(_level_helper__WEBPACK_IMPORTED_MODULE_5__["addSliding"])(newDetails, mainSlidingStartFragment.start);
}
} else {
var sliding = this.alignPlaylists(newDetails, track.details);
if (sliding === 0 && mainSlidingStartFragment) {
// realign with main when there is no overlap with last refresh
Object(_level_helper__WEBPACK_IMPORTED_MODULE_5__["addSliding"])(newDetails, mainSlidingStartFragment.start);
}
}
}
track.details = newDetails;
this.levelLastLoaded = trackId; // trigger handler right now
this.tick(); // If playlist is misaligned because of bad PDT or drift, delete details to resync with main on reload
if (newDetails.live && !this.fragCurrent && this.media && this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_7__["State"].IDLE) {
var foundFrag = Object(_fragment_finders__WEBPACK_IMPORTED_MODULE_3__["findFragmentByPTS"])(null, newDetails.fragments, this.media.currentTime, 0);
if (!foundFrag) {
this.warn('Subtitle playlist not aligned with playback');
track.details = undefined;
}
}
};
_proto._handleFragmentLoadComplete = function _handleFragmentLoadComplete(fragLoadedData) {
var frag = fragLoadedData.frag,
payload = fragLoadedData.payload;
var decryptData = frag.decryptdata;
var hls = this.hls;
if (this.fragContextChanged(frag)) {
return;
} // check to see if the payload needs to be decrypted
if (payload && payload.byteLength > 0 && decryptData && decryptData.key && decryptData.iv && decryptData.method === 'AES-128') {
var startTime = performance.now(); // decrypt the subtitles
this.decrypter.webCryptoDecrypt(new Uint8Array(payload), decryptData.key.buffer, decryptData.iv.buffer).then(function (decryptedData) {
var endTime = performance.now();
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].FRAG_DECRYPTED, {
frag: frag,
payload: decryptedData,
stats: {
tstart: startTime,
tdecrypt: endTime
}
});
});
}
};
_proto.doTick = function doTick() {
if (!this.media) {
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_7__["State"].IDLE;
return;
}
if (this.state === _base_stream_controller__WEBPACK_IMPORTED_MODULE_7__["State"].IDLE) {
var _foundFrag;
var currentTrackId = this.currentTrackId,
levels = this.levels;
if (!levels.length || !levels[currentTrackId] || !levels[currentTrackId].details) {
return;
} // Expand range of subs loaded by one target-duration in either direction to make up for misaligned playlists
var trackDetails = levels[currentTrackId].details;
var targetDuration = trackDetails.targetduration;
var config = this.config,
media = this.media;
var bufferedInfo = _utils_buffer_helper__WEBPACK_IMPORTED_MODULE_2__["BufferHelper"].bufferedInfo(this.mediaBufferTimeRanges, media.currentTime - targetDuration, config.maxBufferHole);
var targetBufferTime = bufferedInfo.end,
bufferLen = bufferedInfo.len;
var maxBufLen = this.getMaxBufferLength() + targetDuration;
if (bufferLen > maxBufLen) {
return;
}
console.assert(trackDetails, 'Subtitle track details are defined on idle subtitle stream controller tick');
var fragments = trackDetails.fragments;
var fragLen = fragments.length;
var end = trackDetails.edge;
var foundFrag;
var fragPrevious = this.fragPrevious;
if (targetBufferTime < end) {
var maxFragLookUpTolerance = config.maxFragLookUpTolerance;
if (fragPrevious && trackDetails.hasProgramDateTime) {
foundFrag = Object(_fragment_finders__WEBPACK_IMPORTED_MODULE_3__["findFragmentByPDT"])(fragments, fragPrevious.endProgramDateTime, maxFragLookUpTolerance);
}
if (!foundFrag) {
foundFrag = Object(_fragment_finders__WEBPACK_IMPORTED_MODULE_3__["findFragmentByPTS"])(fragPrevious, fragments, targetBufferTime, maxFragLookUpTolerance);
if (!foundFrag && fragPrevious && fragPrevious.start < fragments[0].start) {
foundFrag = fragments[0];
}
}
} else {
foundFrag = fragments[fragLen - 1];
}
if ((_foundFrag = foundFrag) !== null && _foundFrag !== void 0 && _foundFrag.encrypted) {
_utils_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].log("Loading key for " + foundFrag.sn);
this.state = _base_stream_controller__WEBPACK_IMPORTED_MODULE_7__["State"].KEY_LOADING;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].KEY_LOADING, {
frag: foundFrag
});
} else if (foundFrag && this.fragmentTracker.getState(foundFrag) === _fragment_tracker__WEBPACK_IMPORTED_MODULE_6__["FragmentState"].NOT_LOADED) {
// only load if fragment is not loaded
this.loadFragment(foundFrag, trackDetails, targetBufferTime);
}
}
};
_proto.loadFragment = function loadFragment(frag, levelDetails, targetBufferTime) {
this.fragCurrent = frag;
_BaseStreamController.prototype.loadFragment.call(this, frag, levelDetails, targetBufferTime);
};
_createClass(SubtitleStreamController, [{
key: "mediaBufferTimeRanges",
get: function get() {
return this.tracksBuffered[this.currentTrackId] || [];
}
}]);
return SubtitleStreamController;
}(_base_stream_controller__WEBPACK_IMPORTED_MODULE_7__["default"]);
/***/ }),
/***/ "./src/controller/subtitle-track-controller.ts":
/*!*****************************************************!*\
!*** ./src/controller/subtitle-track-controller.ts ***!
\*****************************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/texttrack-utils */ "./src/utils/texttrack-utils.ts");
/* harmony import */ var _base_playlist_controller__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./base-playlist-controller */ "./src/controller/base-playlist-controller.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
var SubtitleTrackController = /*#__PURE__*/function (_BasePlaylistControll) {
_inheritsLoose(SubtitleTrackController, _BasePlaylistControll);
// Enable/disable subtitle display rendering
function SubtitleTrackController(hls) {
var _this;
_this = _BasePlaylistControll.call(this, hls, '[subtitle-track-controller]') || this;
_this.media = null;
_this.tracks = [];
_this.groupId = null;
_this.tracksInGroup = [];
_this.trackId = -1;
_this.selectDefaultTrack = true;
_this.queuedDefaultTrack = -1;
_this.trackChangeListener = function () {
return _this.onTextTracksChanged();
};
_this.asyncPollTrackChange = function () {
return _this.pollTrackChange(0);
};
_this.useTextTrackPolling = false;
_this.subtitlePollingInterval = -1;
_this.subtitleDisplay = true;
_this.registerListeners();
return _this;
}
var _proto = SubtitleTrackController.prototype;
_proto.destroy = function destroy() {
this.unregisterListeners();
this.tracks.length = 0;
this.tracksInGroup.length = 0;
this.trackChangeListener = this.asyncPollTrackChange = null;
_BasePlaylistControll.prototype.destroy.call(this);
};
_proto.registerListeners = function registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_LOADING, this.onLevelLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_SWITCHING, this.onLevelSwitching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, this.onError, this);
};
_proto.unregisterListeners = function unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_ATTACHED, this.onMediaAttached, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].MANIFEST_PARSED, this.onManifestParsed, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_LOADING, this.onLevelLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].LEVEL_SWITCHING, this.onLevelSwitching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, this.onError, this);
} // Listen for subtitle track change, then extract the current track ID.
;
_proto.onMediaAttached = function onMediaAttached(event, data) {
this.media = data.media;
if (!this.media) {
return;
}
if (this.queuedDefaultTrack > -1) {
this.subtitleTrack = this.queuedDefaultTrack;
this.queuedDefaultTrack = -1;
}
this.useTextTrackPolling = !(this.media.textTracks && 'onchange' in this.media.textTracks);
if (this.useTextTrackPolling) {
this.pollTrackChange(500);
} else {
this.media.textTracks.addEventListener('change', this.asyncPollTrackChange);
}
};
_proto.pollTrackChange = function pollTrackChange(timeout) {
self.clearInterval(this.subtitlePollingInterval);
this.subtitlePollingInterval = self.setInterval(this.trackChangeListener, timeout);
};
_proto.onMediaDetaching = function onMediaDetaching() {
if (!this.media) {
return;
}
self.clearInterval(this.subtitlePollingInterval);
if (!this.useTextTrackPolling) {
this.media.textTracks.removeEventListener('change', this.asyncPollTrackChange);
}
if (this.trackId > -1) {
this.queuedDefaultTrack = this.trackId;
}
var textTracks = filterSubtitleTracks(this.media.textTracks); // Clear loaded cues on media detachment from tracks
textTracks.forEach(function (track) {
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_1__["clearCurrentCues"])(track);
}); // Disable all subtitle tracks before detachment so when reattached only tracks in that content are enabled.
this.subtitleTrack = -1;
this.media = null;
};
_proto.onManifestLoading = function onManifestLoading() {
this.tracks = [];
this.groupId = null;
this.tracksInGroup = [];
this.trackId = -1;
this.selectDefaultTrack = true;
} // Fired whenever a new manifest is loaded.
;
_proto.onManifestParsed = function onManifestParsed(event, data) {
this.tracks = data.subtitleTracks;
};
_proto.onSubtitleTrackLoaded = function onSubtitleTrackLoaded(event, data) {
var id = data.id,
details = data.details;
var trackId = this.trackId;
var currentTrack = this.tracksInGroup[trackId];
if (!currentTrack) {
this.warn("Invalid subtitle track id " + id);
return;
}
var curDetails = currentTrack.details;
currentTrack.details = data.details;
this.log("subtitle track " + id + " loaded [" + details.startSN + "-" + details.endSN + "]");
if (id === this.trackId) {
this.retryCount = 0;
this.playlistLoaded(id, data, curDetails);
}
};
_proto.onLevelLoading = function onLevelLoading(event, data) {
this.switchLevel(data.level);
};
_proto.onLevelSwitching = function onLevelSwitching(event, data) {
this.switchLevel(data.level);
};
_proto.switchLevel = function switchLevel(levelIndex) {
var levelInfo = this.hls.levels[levelIndex];
if (!(levelInfo !== null && levelInfo !== void 0 && levelInfo.textGroupIds)) {
return;
}
var textGroupId = levelInfo.textGroupIds[levelInfo.urlId];
if (this.groupId !== textGroupId) {
var lastTrack = this.tracksInGroup ? this.tracksInGroup[this.trackId] : undefined;
var subtitleTracks = this.tracks.filter(function (track) {
return !textGroupId || track.groupId === textGroupId;
});
this.tracksInGroup = subtitleTracks;
var initialTrackId = this.findTrackId(lastTrack === null || lastTrack === void 0 ? void 0 : lastTrack.name) || this.findTrackId();
this.groupId = textGroupId;
var subtitleTracksUpdated = {
subtitleTracks: subtitleTracks
};
this.log("Updating subtitle tracks, " + subtitleTracks.length + " track(s) found in \"" + textGroupId + "\" group-id");
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACKS_UPDATED, subtitleTracksUpdated);
if (initialTrackId !== -1) {
this.setSubtitleTrack(initialTrackId, lastTrack);
}
}
};
_proto.findTrackId = function findTrackId(name) {
var textTracks = this.tracksInGroup;
for (var i = 0; i < textTracks.length; i++) {
var track = textTracks[i];
if (!this.selectDefaultTrack || track.default) {
if (!name || name === track.name) {
return track.id;
}
}
}
return -1;
};
_proto.onError = function onError(event, data) {
_BasePlaylistControll.prototype.onError.call(this, event, data);
if (data.fatal || !data.context) {
return;
}
if (data.context.type === _types_loader__WEBPACK_IMPORTED_MODULE_3__["PlaylistContextType"].SUBTITLE_TRACK && data.context.id === this.trackId && data.context.groupId === this.groupId) {
this.retryLoadingOrFail(data);
}
}
/** get alternate subtitle tracks list from playlist **/
;
_proto.loadPlaylist = function loadPlaylist(hlsUrlParameters) {
var currentTrack = this.tracksInGroup[this.trackId];
if (this.shouldLoadTrack(currentTrack)) {
var id = currentTrack.id;
var groupId = currentTrack.groupId;
var url = currentTrack.url;
if (hlsUrlParameters) {
try {
url = hlsUrlParameters.addDirectives(url);
} catch (error) {
this.warn("Could not construct new URL with HLS Delivery Directives: " + error);
}
}
this.log("Loading subtitle playlist for id " + id);
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_LOADING, {
url: url,
id: id,
groupId: groupId,
deliveryDirectives: hlsUrlParameters || null
});
}
}
/**
* Disables the old subtitleTrack and sets current mode on the next subtitleTrack.
* This operates on the DOM textTracks.
* A value of -1 will disable all subtitle tracks.
*/
;
_proto.toggleTrackModes = function toggleTrackModes(newId) {
var _this2 = this;
var media = this.media,
subtitleDisplay = this.subtitleDisplay,
trackId = this.trackId;
if (!media) {
return;
}
var textTracks = filterSubtitleTracks(media.textTracks);
var groupTracks = textTracks.filter(function (track) {
return track.groupId === _this2.groupId;
});
if (newId === -1) {
[].slice.call(textTracks).forEach(function (track) {
track.mode = 'disabled';
});
} else {
var oldTrack = groupTracks[trackId];
if (oldTrack) {
oldTrack.mode = 'disabled';
}
}
var nextTrack = groupTracks[newId];
if (nextTrack) {
nextTrack.mode = subtitleDisplay ? 'showing' : 'hidden';
}
}
/**
* This method is responsible for validating the subtitle index and periodically reloading if live.
* Dispatches the SUBTITLE_TRACK_SWITCH event, which instructs the subtitle-stream-controller to load the selected track.
*/
;
_proto.setSubtitleTrack = function setSubtitleTrack(newId, lastTrack) {
var _tracks$newId;
var tracks = this.tracksInGroup; // setting this.subtitleTrack will trigger internal logic
// if media has not been attached yet, it will fail
// we keep a reference to the default track id
// and we'll set subtitleTrack when onMediaAttached is triggered
if (!this.media) {
this.queuedDefaultTrack = newId;
return;
}
if (this.trackId !== newId) {
this.toggleTrackModes(newId);
} // exit if track id as already set or invalid
if (this.trackId === newId && (newId === -1 || (_tracks$newId = tracks[newId]) !== null && _tracks$newId !== void 0 && _tracks$newId.details) || newId < -1 || newId >= tracks.length) {
return;
} // stopping live reloading timer if any
this.clearTimer();
var track = tracks[newId];
this.log("Switching to subtitle track " + newId);
this.trackId = newId;
if (track) {
var id = track.id,
_track$groupId = track.groupId,
groupId = _track$groupId === void 0 ? '' : _track$groupId,
name = track.name,
type = track.type,
url = track.url;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_SWITCH, {
id: id,
groupId: groupId,
name: name,
type: type,
url: url
});
var hlsUrlParameters = this.switchParams(track.url, lastTrack === null || lastTrack === void 0 ? void 0 : lastTrack.details);
this.loadPlaylist(hlsUrlParameters);
} else {
// switch to -1
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].SUBTITLE_TRACK_SWITCH, {
id: newId
});
}
};
_proto.onTextTracksChanged = function onTextTracksChanged() {
if (!this.useTextTrackPolling) {
self.clearInterval(this.subtitlePollingInterval);
} // Media is undefined when switching streams via loadSource()
if (!this.media || !this.hls.config.renderTextTracksNatively) {
return;
}
var trackId = -1;
var tracks = filterSubtitleTracks(this.media.textTracks);
for (var id = 0; id < tracks.length; id++) {
if (tracks[id].mode === 'hidden') {
// Do not break in case there is a following track with showing.
trackId = id;
} else if (tracks[id].mode === 'showing') {
trackId = id;
break;
}
} // Setting current subtitleTrack will invoke code.
if (this.subtitleTrack !== trackId) {
this.subtitleTrack = trackId;
}
};
_createClass(SubtitleTrackController, [{
key: "subtitleTracks",
get: function get() {
return this.tracksInGroup;
}
/** get/set index of the selected subtitle track (based on index in subtitle track lists) **/
}, {
key: "subtitleTrack",
get: function get() {
return this.trackId;
},
set: function set(newId) {
this.selectDefaultTrack = false;
var lastTrack = this.tracksInGroup ? this.tracksInGroup[this.trackId] : undefined;
this.setSubtitleTrack(newId, lastTrack);
}
}]);
return SubtitleTrackController;
}(_base_playlist_controller__WEBPACK_IMPORTED_MODULE_2__["default"]);
function filterSubtitleTracks(textTrackList) {
var tracks = [];
for (var i = 0; i < textTrackList.length; i++) {
var track = textTrackList[i]; // Edge adds a track without a label; we don't want to use it
if (track.kind === 'subtitles' && track.label) {
tracks.push(textTrackList[i]);
}
}
return tracks;
}
/* harmony default export */ __webpack_exports__["default"] = (SubtitleTrackController);
/***/ }),
/***/ "./src/controller/timeline-controller.ts":
/*!***********************************************!*\
!*** ./src/controller/timeline-controller.ts ***!
\***********************************************/
/*! exports provided: TimelineController */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TimelineController", function() { return TimelineController; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_cea_608_parser__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/cea-608-parser */ "./src/utils/cea-608-parser.ts");
/* harmony import */ var _utils_output_filter__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/output-filter */ "./src/utils/output-filter.ts");
/* harmony import */ var _utils_webvtt_parser__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/webvtt-parser */ "./src/utils/webvtt-parser.ts");
/* harmony import */ var _utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/texttrack-utils */ "./src/utils/texttrack-utils.ts");
/* harmony import */ var _utils_imsc1_ttml_parser__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../utils/imsc1-ttml-parser */ "./src/utils/imsc1-ttml-parser.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
var TimelineController = /*#__PURE__*/function () {
function TimelineController(hls) {
this.hls = void 0;
this.media = null;
this.config = void 0;
this.enabled = true;
this.Cues = void 0;
this.textTracks = [];
this.tracks = [];
this.initPTS = [];
this.timescale = [];
this.unparsedVttFrags = [];
this.captionsTracks = {};
this.nonNativeCaptionsTracks = {};
this.cea608Parser1 = void 0;
this.cea608Parser2 = void 0;
this.lastSn = -1;
this.prevCC = -1;
this.vttCCs = newVTTCCs();
this.captionsProperties = void 0;
this.hls = hls;
this.config = hls.config;
this.Cues = hls.config.cueHandler;
this.captionsProperties = {
textTrack1: {
label: this.config.captionsTextTrack1Label,
languageCode: this.config.captionsTextTrack1LanguageCode
},
textTrack2: {
label: this.config.captionsTextTrack2Label,
languageCode: this.config.captionsTextTrack2LanguageCode
},
textTrack3: {
label: this.config.captionsTextTrack3Label,
languageCode: this.config.captionsTextTrack3LanguageCode
},
textTrack4: {
label: this.config.captionsTextTrack4Label,
languageCode: this.config.captionsTextTrack4LanguageCode
}
};
if (this.config.enableCEA708Captions) {
var channel1 = new _utils_output_filter__WEBPACK_IMPORTED_MODULE_3__["default"](this, 'textTrack1');
var channel2 = new _utils_output_filter__WEBPACK_IMPORTED_MODULE_3__["default"](this, 'textTrack2');
var channel3 = new _utils_output_filter__WEBPACK_IMPORTED_MODULE_3__["default"](this, 'textTrack3');
var channel4 = new _utils_output_filter__WEBPACK_IMPORTED_MODULE_3__["default"](this, 'textTrack4');
this.cea608Parser1 = new _utils_cea_608_parser__WEBPACK_IMPORTED_MODULE_2__["default"](1, channel1, channel2);
this.cea608Parser2 = new _utils_cea_608_parser__WEBPACK_IMPORTED_MODULE_2__["default"](3, channel3, channel4);
}
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_ATTACHING, this.onMediaAttaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADED, this.onManifestLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_LOADING, this.onFragLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_LOADED, this.onFragLoaded, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_PARSING_USERDATA, this.onFragParsingUserdata, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_DECRYPTED, this.onFragDecrypted, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].INIT_PTS_FOUND, this.onInitPtsFound, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_TRACKS_CLEARED, this.onSubtitleTracksCleared, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_FLUSHING, this.onBufferFlushing, this);
}
var _proto = TimelineController.prototype;
_proto.destroy = function destroy() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_ATTACHING, this.onMediaAttaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MEDIA_DETACHING, this.onMediaDetaching, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADED, this.onManifestLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_LOADING, this.onFragLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_LOADED, this.onFragLoaded, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_PARSING_USERDATA, this.onFragParsingUserdata, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_DECRYPTED, this.onFragDecrypted, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].INIT_PTS_FOUND, this.onInitPtsFound, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_TRACKS_CLEARED, this.onSubtitleTracksCleared, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].BUFFER_FLUSHING, this.onBufferFlushing, this); // @ts-ignore
this.hls = this.config = this.cea608Parser1 = this.cea608Parser2 = null;
};
_proto.addCues = function addCues(trackName, startTime, endTime, screen, cueRanges) {
// skip cues which overlap more than 50% with previously parsed time ranges
var merged = false;
for (var i = cueRanges.length; i--;) {
var cueRange = cueRanges[i];
var overlap = intersection(cueRange[0], cueRange[1], startTime, endTime);
if (overlap >= 0) {
cueRange[0] = Math.min(cueRange[0], startTime);
cueRange[1] = Math.max(cueRange[1], endTime);
merged = true;
if (overlap / (endTime - startTime) > 0.5) {
return;
}
}
}
if (!merged) {
cueRanges.push([startTime, endTime]);
}
if (this.config.renderTextTracksNatively) {
var track = this.captionsTracks[trackName];
this.Cues.newCue(track, startTime, endTime, screen);
} else {
var cues = this.Cues.newCue(null, startTime, endTime, screen);
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].CUES_PARSED, {
type: 'captions',
cues: cues,
track: trackName
});
}
} // Triggered when an initial PTS is found; used for synchronisation of WebVTT.
;
_proto.onInitPtsFound = function onInitPtsFound(event, _ref) {
var _this = this;
var frag = _ref.frag,
id = _ref.id,
initPTS = _ref.initPTS,
timescale = _ref.timescale;
var unparsedVttFrags = this.unparsedVttFrags;
if (id === 'main') {
this.initPTS[frag.cc] = initPTS;
this.timescale[frag.cc] = timescale;
} // Due to asynchronous processing, initial PTS may arrive later than the first VTT fragments are loaded.
// Parse any unparsed fragments upon receiving the initial PTS.
if (unparsedVttFrags.length) {
this.unparsedVttFrags = [];
unparsedVttFrags.forEach(function (frag) {
_this.onFragLoaded(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_LOADED, frag);
});
}
};
_proto.getExistingTrack = function getExistingTrack(trackName) {
var media = this.media;
if (media) {
for (var i = 0; i < media.textTracks.length; i++) {
var textTrack = media.textTracks[i];
if (textTrack[trackName]) {
return textTrack;
}
}
}
return null;
};
_proto.createCaptionsTrack = function createCaptionsTrack(trackName) {
if (this.config.renderTextTracksNatively) {
this.createNativeTrack(trackName);
} else {
this.createNonNativeTrack(trackName);
}
};
_proto.createNativeTrack = function createNativeTrack(trackName) {
if (this.captionsTracks[trackName]) {
return;
}
var captionsProperties = this.captionsProperties,
captionsTracks = this.captionsTracks,
media = this.media;
var _captionsProperties$t = captionsProperties[trackName],
label = _captionsProperties$t.label,
languageCode = _captionsProperties$t.languageCode; // Enable reuse of existing text track.
var existingTrack = this.getExistingTrack(trackName);
if (!existingTrack) {
var textTrack = this.createTextTrack('captions', label, languageCode);
if (textTrack) {
// Set a special property on the track so we know it's managed by Hls.js
textTrack[trackName] = true;
captionsTracks[trackName] = textTrack;
}
} else {
captionsTracks[trackName] = existingTrack;
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__["clearCurrentCues"])(captionsTracks[trackName]);
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__["sendAddTrackEvent"])(captionsTracks[trackName], media);
}
};
_proto.createNonNativeTrack = function createNonNativeTrack(trackName) {
if (this.nonNativeCaptionsTracks[trackName]) {
return;
} // Create a list of a single track for the provider to consume
var trackProperties = this.captionsProperties[trackName];
if (!trackProperties) {
return;
}
var label = trackProperties.label;
var track = {
_id: trackName,
label: label,
kind: 'captions',
default: trackProperties.media ? !!trackProperties.media.default : false,
closedCaptions: trackProperties.media
};
this.nonNativeCaptionsTracks[trackName] = track;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].NON_NATIVE_TEXT_TRACKS_FOUND, {
tracks: [track]
});
};
_proto.createTextTrack = function createTextTrack(kind, label, lang) {
var media = this.media;
if (!media) {
return;
}
return media.addTextTrack(kind, label, lang);
};
_proto.onMediaAttaching = function onMediaAttaching(event, data) {
this.media = data.media;
this._cleanTracks();
};
_proto.onMediaDetaching = function onMediaDetaching() {
var captionsTracks = this.captionsTracks;
Object.keys(captionsTracks).forEach(function (trackName) {
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__["clearCurrentCues"])(captionsTracks[trackName]);
delete captionsTracks[trackName];
});
this.nonNativeCaptionsTracks = {};
};
_proto.onManifestLoading = function onManifestLoading() {
this.lastSn = -1; // Detect discontinuity in fragment parsing
this.prevCC = -1;
this.vttCCs = newVTTCCs(); // Detect discontinuity in subtitle manifests
this._cleanTracks();
this.tracks = [];
this.captionsTracks = {};
this.nonNativeCaptionsTracks = {};
this.textTracks = [];
this.unparsedVttFrags = this.unparsedVttFrags || [];
this.initPTS = [];
this.timescale = [];
if (this.cea608Parser1 && this.cea608Parser2) {
this.cea608Parser1.reset();
this.cea608Parser2.reset();
}
};
_proto._cleanTracks = function _cleanTracks() {
// clear outdated subtitles
var media = this.media;
if (!media) {
return;
}
var textTracks = media.textTracks;
if (textTracks) {
for (var i = 0; i < textTracks.length; i++) {
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__["clearCurrentCues"])(textTracks[i]);
}
}
};
_proto.onSubtitleTracksUpdated = function onSubtitleTracksUpdated(event, data) {
var _this2 = this;
this.textTracks = [];
var tracks = data.subtitleTracks || [];
var hasIMSC1 = tracks.some(function (track) {
return track.textCodec === _utils_imsc1_ttml_parser__WEBPACK_IMPORTED_MODULE_6__["IMSC1_CODEC"];
});
if (this.config.enableWebVTT || hasIMSC1 && this.config.enableIMSC1) {
var sameTracks = this.tracks && tracks && this.tracks.length === tracks.length;
this.tracks = tracks || [];
if (this.config.renderTextTracksNatively) {
var inUseTracks = this.media ? this.media.textTracks : [];
this.tracks.forEach(function (track, index) {
var textTrack;
if (index < inUseTracks.length) {
var inUseTrack = null;
for (var i = 0; i < inUseTracks.length; i++) {
if (canReuseVttTextTrack(inUseTracks[i], track)) {
inUseTrack = inUseTracks[i];
break;
}
} // Reuse tracks with the same label, but do not reuse 608/708 tracks
if (inUseTrack) {
textTrack = inUseTrack;
}
}
if (textTrack) {
Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__["clearCurrentCues"])(textTrack);
} else {
textTrack = _this2.createTextTrack('subtitles', track.name, track.lang);
if (textTrack) {
textTrack.mode = 'disabled';
}
}
if (textTrack) {
textTrack.groupId = track.groupId;
_this2.textTracks.push(textTrack);
}
});
} else if (!sameTracks && this.tracks && this.tracks.length) {
// Create a list of tracks for the provider to consume
var tracksList = this.tracks.map(function (track) {
return {
label: track.name,
kind: track.type.toLowerCase(),
default: track.default,
subtitleTrack: track
};
});
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].NON_NATIVE_TEXT_TRACKS_FOUND, {
tracks: tracksList
});
}
}
};
_proto.onManifestLoaded = function onManifestLoaded(event, data) {
var _this3 = this;
if (this.config.enableCEA708Captions && data.captions) {
data.captions.forEach(function (captionsTrack) {
var instreamIdMatch = /(?:CC|SERVICE)([1-4])/.exec(captionsTrack.instreamId);
if (!instreamIdMatch) {
return;
}
var trackName = "textTrack" + instreamIdMatch[1];
var trackProperties = _this3.captionsProperties[trackName];
if (!trackProperties) {
return;
}
trackProperties.label = captionsTrack.name;
if (captionsTrack.lang) {
// optional attribute
trackProperties.languageCode = captionsTrack.lang;
}
trackProperties.media = captionsTrack;
});
}
};
_proto.onFragLoading = function onFragLoading(event, data) {
var cea608Parser1 = this.cea608Parser1,
cea608Parser2 = this.cea608Parser2,
lastSn = this.lastSn;
if (!this.enabled || !(cea608Parser1 && cea608Parser2)) {
return;
} // if this frag isn't contiguous, clear the parser so cues with bad start/end times aren't added to the textTrack
if (data.frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_7__["PlaylistLevelType"].MAIN) {
var sn = data.frag.sn;
if (sn !== lastSn + 1) {
cea608Parser1.reset();
cea608Parser2.reset();
}
this.lastSn = sn;
}
};
_proto.onFragLoaded = function onFragLoaded(event, data) {
var frag = data.frag,
payload = data.payload;
var initPTS = this.initPTS,
unparsedVttFrags = this.unparsedVttFrags;
if (frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_7__["PlaylistLevelType"].SUBTITLE) {
// If fragment is subtitle type, parse as WebVTT.
if (payload.byteLength) {
// We need an initial synchronisation PTS. Store fragments as long as none has arrived.
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(initPTS[frag.cc])) {
unparsedVttFrags.push(data);
if (initPTS.length) {
// finish unsuccessfully, otherwise the subtitle-stream-controller could be blocked from loading new frags.
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_FRAG_PROCESSED, {
success: false,
frag: frag,
error: new Error('Missing initial subtitle PTS')
});
}
return;
}
var decryptData = frag.decryptdata; // If the subtitles are not encrypted, parse VTTs now. Otherwise, we need to wait.
if (decryptData == null || decryptData.key == null || decryptData.method !== 'AES-128') {
var trackPlaylistMedia = this.tracks[frag.level];
var vttCCs = this.vttCCs;
if (!vttCCs[frag.cc]) {
vttCCs[frag.cc] = {
start: frag.start,
prevCC: this.prevCC,
new: true
};
this.prevCC = frag.cc;
}
if (trackPlaylistMedia && trackPlaylistMedia.textCodec === _utils_imsc1_ttml_parser__WEBPACK_IMPORTED_MODULE_6__["IMSC1_CODEC"]) {
this._parseIMSC1(frag, payload);
} else {
this._parseVTTs(frag, payload, vttCCs);
}
}
} else {
// In case there is no payload, finish unsuccessfully.
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_FRAG_PROCESSED, {
success: false,
frag: frag,
error: new Error('Empty subtitle payload')
});
}
}
};
_proto._parseIMSC1 = function _parseIMSC1(frag, payload) {
var _this4 = this;
var hls = this.hls;
Object(_utils_imsc1_ttml_parser__WEBPACK_IMPORTED_MODULE_6__["parseIMSC1"])(payload, this.initPTS[frag.cc], this.timescale[frag.cc], function (cues) {
_this4._appendCues(cues, frag.level);
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_FRAG_PROCESSED, {
success: true,
frag: frag
});
}, function (error) {
_utils_logger__WEBPACK_IMPORTED_MODULE_8__["logger"].log("Failed to parse IMSC1: " + error);
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_FRAG_PROCESSED, {
success: false,
frag: frag,
error: error
});
});
};
_proto._parseVTTs = function _parseVTTs(frag, payload, vttCCs) {
var _this5 = this;
var hls = this.hls; // Parse the WebVTT file contents.
Object(_utils_webvtt_parser__WEBPACK_IMPORTED_MODULE_4__["parseWebVTT"])(payload, this.initPTS[frag.cc], this.timescale[frag.cc], vttCCs, frag.cc, frag.start, function (cues) {
_this5._appendCues(cues, frag.level);
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_FRAG_PROCESSED, {
success: true,
frag: frag
});
}, function (error) {
_this5._fallbackToIMSC1(frag, payload); // Something went wrong while parsing. Trigger event with success false.
_utils_logger__WEBPACK_IMPORTED_MODULE_8__["logger"].log("Failed to parse VTT cue: " + error);
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_FRAG_PROCESSED, {
success: false,
frag: frag,
error: error
});
});
};
_proto._fallbackToIMSC1 = function _fallbackToIMSC1(frag, payload) {
var _this6 = this;
// If textCodec is unknown, try parsing as IMSC1. Set textCodec based on the result
var trackPlaylistMedia = this.tracks[frag.level];
if (!trackPlaylistMedia.textCodec) {
Object(_utils_imsc1_ttml_parser__WEBPACK_IMPORTED_MODULE_6__["parseIMSC1"])(payload, this.initPTS[frag.cc], this.timescale[frag.cc], function () {
trackPlaylistMedia.textCodec = _utils_imsc1_ttml_parser__WEBPACK_IMPORTED_MODULE_6__["IMSC1_CODEC"];
_this6._parseIMSC1(frag, payload);
}, function () {
trackPlaylistMedia.textCodec = 'wvtt';
});
}
};
_proto._appendCues = function _appendCues(cues, fragLevel) {
var hls = this.hls;
if (this.config.renderTextTracksNatively) {
var textTrack = this.textTracks[fragLevel]; // WebVTTParser.parse is an async method and if the currently selected text track mode is set to "disabled"
// before parsing is done then don't try to access currentTrack.cues.getCueById as cues will be null
// and trying to access getCueById method of cues will throw an exception
// Because we check if the mode is disabled, we can force check `cues` below. They can't be null.
if (textTrack.mode === 'disabled') {
return;
}
cues.forEach(function (cue) {
return Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__["addCueToTrack"])(textTrack, cue);
});
} else {
var currentTrack = this.tracks[fragLevel];
var track = currentTrack.default ? 'default' : 'subtitles' + fragLevel;
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].CUES_PARSED, {
type: 'subtitles',
cues: cues,
track: track
});
}
};
_proto.onFragDecrypted = function onFragDecrypted(event, data) {
var frag = data.frag;
if (frag.type === _types_loader__WEBPACK_IMPORTED_MODULE_7__["PlaylistLevelType"].SUBTITLE) {
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(this.initPTS[frag.cc])) {
this.unparsedVttFrags.push(data);
return;
}
this.onFragLoaded(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_LOADED, data);
}
};
_proto.onSubtitleTracksCleared = function onSubtitleTracksCleared() {
this.tracks = [];
this.captionsTracks = {};
};
_proto.onFragParsingUserdata = function onFragParsingUserdata(event, data) {
var cea608Parser1 = this.cea608Parser1,
cea608Parser2 = this.cea608Parser2;
if (!this.enabled || !(cea608Parser1 && cea608Parser2)) {
return;
} // If the event contains captions (found in the bytes property), push all bytes into the parser immediately
// It will create the proper timestamps based on the PTS value
for (var i = 0; i < data.samples.length; i++) {
var ccBytes = data.samples[i].bytes;
if (ccBytes) {
var ccdatas = this.extractCea608Data(ccBytes);
cea608Parser1.addData(data.samples[i].pts, ccdatas[0]);
cea608Parser2.addData(data.samples[i].pts, ccdatas[1]);
}
}
};
_proto.onBufferFlushing = function onBufferFlushing(event, _ref2) {
var startOffset = _ref2.startOffset,
endOffset = _ref2.endOffset,
endOffsetSubtitles = _ref2.endOffsetSubtitles,
type = _ref2.type;
var media = this.media;
if (!media || media.currentTime < endOffset) {
return;
} // Clear 608 caption cues from the captions TextTracks when the video back buffer is flushed
// Forward cues are never removed because we can loose streamed 608 content from recent fragments
if (!type || type === 'video') {
var captionsTracks = this.captionsTracks;
Object.keys(captionsTracks).forEach(function (trackName) {
return Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__["removeCuesInRange"])(captionsTracks[trackName], startOffset, endOffset);
});
}
if (this.config.renderTextTracksNatively) {
// Clear VTT/IMSC1 subtitle cues from the subtitle TextTracks when the back buffer is flushed
if (startOffset === 0 && endOffsetSubtitles !== undefined) {
var textTracks = this.textTracks;
Object.keys(textTracks).forEach(function (trackName) {
return Object(_utils_texttrack_utils__WEBPACK_IMPORTED_MODULE_5__["removeCuesInRange"])(textTracks[trackName], startOffset, endOffsetSubtitles);
});
}
}
};
_proto.extractCea608Data = function extractCea608Data(byteArray) {
var count = byteArray[0] & 31;
var position = 2;
var actualCCBytes = [[], []];
for (var j = 0; j < count; j++) {
var tmpByte = byteArray[position++];
var ccbyte1 = 0x7f & byteArray[position++];
var ccbyte2 = 0x7f & byteArray[position++];
var ccValid = (4 & tmpByte) !== 0;
var ccType = 3 & tmpByte;
if (ccbyte1 === 0 && ccbyte2 === 0) {
continue;
}
if (ccValid) {
if (ccType === 0 || ccType === 1) {
actualCCBytes[ccType].push(ccbyte1);
actualCCBytes[ccType].push(ccbyte2);
}
}
}
return actualCCBytes;
};
return TimelineController;
}();
function canReuseVttTextTrack(inUseTrack, manifestTrack) {
return inUseTrack && inUseTrack.label === manifestTrack.name && !(inUseTrack.textTrack1 || inUseTrack.textTrack2);
}
function intersection(x1, x2, y1, y2) {
return Math.min(x2, y2) - Math.max(x1, y1);
}
function newVTTCCs() {
return {
ccOffset: 0,
presentationOffset: 0,
0: {
start: 0,
prevCC: -1,
new: false
}
};
}
/***/ }),
/***/ "./src/crypt/aes-crypto.ts":
/*!*********************************!*\
!*** ./src/crypt/aes-crypto.ts ***!
\*********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return AESCrypto; });
var AESCrypto = /*#__PURE__*/function () {
function AESCrypto(subtle, iv) {
this.subtle = void 0;
this.aesIV = void 0;
this.subtle = subtle;
this.aesIV = iv;
}
var _proto = AESCrypto.prototype;
_proto.decrypt = function decrypt(data, key) {
return this.subtle.decrypt({
name: 'AES-CBC',
iv: this.aesIV
}, key, data);
};
return AESCrypto;
}();
/***/ }),
/***/ "./src/crypt/aes-decryptor.ts":
/*!************************************!*\
!*** ./src/crypt/aes-decryptor.ts ***!
\************************************/
/*! exports provided: removePadding, default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removePadding", function() { return removePadding; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return AESDecryptor; });
/* harmony import */ var _utils_typed_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/typed-array */ "./src/utils/typed-array.ts");
// PKCS7
function removePadding(array) {
var outputBytes = array.byteLength;
var paddingBytes = outputBytes && new DataView(array.buffer).getUint8(outputBytes - 1);
if (paddingBytes) {
return Object(_utils_typed_array__WEBPACK_IMPORTED_MODULE_0__["sliceUint8"])(array, 0, outputBytes - paddingBytes);
}
return array;
}
var AESDecryptor = /*#__PURE__*/function () {
function AESDecryptor() {
this.rcon = [0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
this.subMix = [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)];
this.invSubMix = [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)];
this.sBox = new Uint32Array(256);
this.invSBox = new Uint32Array(256);
this.key = new Uint32Array(0);
this.ksRows = 0;
this.keySize = 0;
this.keySchedule = void 0;
this.invKeySchedule = void 0;
this.initTable();
} // Using view.getUint32() also swaps the byte order.
var _proto = AESDecryptor.prototype;
_proto.uint8ArrayToUint32Array_ = function uint8ArrayToUint32Array_(arrayBuffer) {
var view = new DataView(arrayBuffer);
var newArray = new Uint32Array(4);
for (var i = 0; i < 4; i++) {
newArray[i] = view.getUint32(i * 4);
}
return newArray;
};
_proto.initTable = function initTable() {
var sBox = this.sBox;
var invSBox = this.invSBox;
var subMix = this.subMix;
var subMix0 = subMix[0];
var subMix1 = subMix[1];
var subMix2 = subMix[2];
var subMix3 = subMix[3];
var invSubMix = this.invSubMix;
var invSubMix0 = invSubMix[0];
var invSubMix1 = invSubMix[1];
var invSubMix2 = invSubMix[2];
var invSubMix3 = invSubMix[3];
var d = new Uint32Array(256);
var x = 0;
var xi = 0;
var i = 0;
for (i = 0; i < 256; i++) {
if (i < 128) {
d[i] = i << 1;
} else {
d[i] = i << 1 ^ 0x11b;
}
}
for (i = 0; i < 256; i++) {
var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
sx = sx >>> 8 ^ sx & 0xff ^ 0x63;
sBox[x] = sx;
invSBox[sx] = x; // Compute multiplication
var x2 = d[x];
var x4 = d[x2];
var x8 = d[x4]; // Compute sub/invSub bytes, mix columns tables
var t = d[sx] * 0x101 ^ sx * 0x1010100;
subMix0[x] = t << 24 | t >>> 8;
subMix1[x] = t << 16 | t >>> 16;
subMix2[x] = t << 8 | t >>> 24;
subMix3[x] = t; // Compute inv sub bytes, inv mix columns tables
t = x8 * 0x1010101 ^ x4 * 0x10001 ^ x2 * 0x101 ^ x * 0x1010100;
invSubMix0[sx] = t << 24 | t >>> 8;
invSubMix1[sx] = t << 16 | t >>> 16;
invSubMix2[sx] = t << 8 | t >>> 24;
invSubMix3[sx] = t; // Compute next counter
if (!x) {
x = xi = 1;
} else {
x = x2 ^ d[d[d[x8 ^ x2]]];
xi ^= d[d[xi]];
}
}
};
_proto.expandKey = function expandKey(keyBuffer) {
// convert keyBuffer to Uint32Array
var key = this.uint8ArrayToUint32Array_(keyBuffer);
var sameKey = true;
var offset = 0;
while (offset < key.length && sameKey) {
sameKey = key[offset] === this.key[offset];
offset++;
}
if (sameKey) {
return;
}
this.key = key;
var keySize = this.keySize = key.length;
if (keySize !== 4 && keySize !== 6 && keySize !== 8) {
throw new Error('Invalid aes key size=' + keySize);
}
var ksRows = this.ksRows = (keySize + 6 + 1) * 4;
var ksRow;
var invKsRow;
var keySchedule = this.keySchedule = new Uint32Array(ksRows);
var invKeySchedule = this.invKeySchedule = new Uint32Array(ksRows);
var sbox = this.sBox;
var rcon = this.rcon;
var invSubMix = this.invSubMix;
var invSubMix0 = invSubMix[0];
var invSubMix1 = invSubMix[1];
var invSubMix2 = invSubMix[2];
var invSubMix3 = invSubMix[3];
var prev;
var t;
for (ksRow = 0; ksRow < ksRows; ksRow++) {
if (ksRow < keySize) {
prev = keySchedule[ksRow] = key[ksRow];
continue;
}
t = prev;
if (ksRow % keySize === 0) {
// Rot word
t = t << 8 | t >>> 24; // Sub word
t = sbox[t >>> 24] << 24 | sbox[t >>> 16 & 0xff] << 16 | sbox[t >>> 8 & 0xff] << 8 | sbox[t & 0xff]; // Mix Rcon
t ^= rcon[ksRow / keySize | 0] << 24;
} else if (keySize > 6 && ksRow % keySize === 4) {
// Sub word
t = sbox[t >>> 24] << 24 | sbox[t >>> 16 & 0xff] << 16 | sbox[t >>> 8 & 0xff] << 8 | sbox[t & 0xff];
}
keySchedule[ksRow] = prev = (keySchedule[ksRow - keySize] ^ t) >>> 0;
}
for (invKsRow = 0; invKsRow < ksRows; invKsRow++) {
ksRow = ksRows - invKsRow;
if (invKsRow & 3) {
t = keySchedule[ksRow];
} else {
t = keySchedule[ksRow - 4];
}
if (invKsRow < 4 || ksRow <= 4) {
invKeySchedule[invKsRow] = t;
} else {
invKeySchedule[invKsRow] = invSubMix0[sbox[t >>> 24]] ^ invSubMix1[sbox[t >>> 16 & 0xff]] ^ invSubMix2[sbox[t >>> 8 & 0xff]] ^ invSubMix3[sbox[t & 0xff]];
}
invKeySchedule[invKsRow] = invKeySchedule[invKsRow] >>> 0;
}
} // Adding this as a method greatly improves performance.
;
_proto.networkToHostOrderSwap = function networkToHostOrderSwap(word) {
return word << 24 | (word & 0xff00) << 8 | (word & 0xff0000) >> 8 | word >>> 24;
};
_proto.decrypt = function decrypt(inputArrayBuffer, offset, aesIV) {
var nRounds = this.keySize + 6;
var invKeySchedule = this.invKeySchedule;
var invSBOX = this.invSBox;
var invSubMix = this.invSubMix;
var invSubMix0 = invSubMix[0];
var invSubMix1 = invSubMix[1];
var invSubMix2 = invSubMix[2];
var invSubMix3 = invSubMix[3];
var initVector = this.uint8ArrayToUint32Array_(aesIV);
var initVector0 = initVector[0];
var initVector1 = initVector[1];
var initVector2 = initVector[2];
var initVector3 = initVector[3];
var inputInt32 = new Int32Array(inputArrayBuffer);
var outputInt32 = new Int32Array(inputInt32.length);
var t0, t1, t2, t3;
var s0, s1, s2, s3;
var inputWords0, inputWords1, inputWords2, inputWords3;
var ksRow, i;
var swapWord = this.networkToHostOrderSwap;
while (offset < inputInt32.length) {
inputWords0 = swapWord(inputInt32[offset]);
inputWords1 = swapWord(inputInt32[offset + 1]);
inputWords2 = swapWord(inputInt32[offset + 2]);
inputWords3 = swapWord(inputInt32[offset + 3]);
s0 = inputWords0 ^ invKeySchedule[0];
s1 = inputWords3 ^ invKeySchedule[1];
s2 = inputWords2 ^ invKeySchedule[2];
s3 = inputWords1 ^ invKeySchedule[3];
ksRow = 4; // Iterate through the rounds of decryption
for (i = 1; i < nRounds; i++) {
t0 = invSubMix0[s0 >>> 24] ^ invSubMix1[s1 >> 16 & 0xff] ^ invSubMix2[s2 >> 8 & 0xff] ^ invSubMix3[s3 & 0xff] ^ invKeySchedule[ksRow];
t1 = invSubMix0[s1 >>> 24] ^ invSubMix1[s2 >> 16 & 0xff] ^ invSubMix2[s3 >> 8 & 0xff] ^ invSubMix3[s0 & 0xff] ^ invKeySchedule[ksRow + 1];
t2 = invSubMix0[s2 >>> 24] ^ invSubMix1[s3 >> 16 & 0xff] ^ invSubMix2[s0 >> 8 & 0xff] ^ invSubMix3[s1 & 0xff] ^ invKeySchedule[ksRow + 2];
t3 = invSubMix0[s3 >>> 24] ^ invSubMix1[s0 >> 16 & 0xff] ^ invSubMix2[s1 >> 8 & 0xff] ^ invSubMix3[s2 & 0xff] ^ invKeySchedule[ksRow + 3]; // Update state
s0 = t0;
s1 = t1;
s2 = t2;
s3 = t3;
ksRow = ksRow + 4;
} // Shift rows, sub bytes, add round key
t0 = invSBOX[s0 >>> 24] << 24 ^ invSBOX[s1 >> 16 & 0xff] << 16 ^ invSBOX[s2 >> 8 & 0xff] << 8 ^ invSBOX[s3 & 0xff] ^ invKeySchedule[ksRow];
t1 = invSBOX[s1 >>> 24] << 24 ^ invSBOX[s2 >> 16 & 0xff] << 16 ^ invSBOX[s3 >> 8 & 0xff] << 8 ^ invSBOX[s0 & 0xff] ^ invKeySchedule[ksRow + 1];
t2 = invSBOX[s2 >>> 24] << 24 ^ invSBOX[s3 >> 16 & 0xff] << 16 ^ invSBOX[s0 >> 8 & 0xff] << 8 ^ invSBOX[s1 & 0xff] ^ invKeySchedule[ksRow + 2];
t3 = invSBOX[s3 >>> 24] << 24 ^ invSBOX[s0 >> 16 & 0xff] << 16 ^ invSBOX[s1 >> 8 & 0xff] << 8 ^ invSBOX[s2 & 0xff] ^ invKeySchedule[ksRow + 3]; // Write
outputInt32[offset] = swapWord(t0 ^ initVector0);
outputInt32[offset + 1] = swapWord(t3 ^ initVector1);
outputInt32[offset + 2] = swapWord(t2 ^ initVector2);
outputInt32[offset + 3] = swapWord(t1 ^ initVector3); // reset initVector to last 4 unsigned int
initVector0 = inputWords0;
initVector1 = inputWords1;
initVector2 = inputWords2;
initVector3 = inputWords3;
offset = offset + 4;
}
return outputInt32.buffer;
};
return AESDecryptor;
}();
/***/ }),
/***/ "./src/crypt/decrypter.ts":
/*!********************************!*\
!*** ./src/crypt/decrypter.ts ***!
\********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Decrypter; });
/* harmony import */ var _aes_crypto__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./aes-crypto */ "./src/crypt/aes-crypto.ts");
/* harmony import */ var _fast_aes_key__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./fast-aes-key */ "./src/crypt/fast-aes-key.ts");
/* harmony import */ var _aes_decryptor__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./aes-decryptor */ "./src/crypt/aes-decryptor.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _utils_typed_array__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/typed-array */ "./src/utils/typed-array.ts");
var CHUNK_SIZE = 16; // 16 bytes, 128 bits
var Decrypter = /*#__PURE__*/function () {
function Decrypter(observer, config, _temp) {
var _ref = _temp === void 0 ? {} : _temp,
_ref$removePKCS7Paddi = _ref.removePKCS7Padding,
removePKCS7Padding = _ref$removePKCS7Paddi === void 0 ? true : _ref$removePKCS7Paddi;
this.logEnabled = true;
this.observer = void 0;
this.config = void 0;
this.removePKCS7Padding = void 0;
this.subtle = null;
this.softwareDecrypter = null;
this.key = null;
this.fastAesKey = null;
this.remainderData = null;
this.currentIV = null;
this.currentResult = null;
this.observer = observer;
this.config = config;
this.removePKCS7Padding = removePKCS7Padding; // built in decryptor expects PKCS7 padding
if (removePKCS7Padding) {
try {
var browserCrypto = self.crypto;
if (browserCrypto) {
this.subtle = browserCrypto.subtle || browserCrypto.webkitSubtle;
}
} catch (e) {
/* no-op */
}
}
if (this.subtle === null) {
this.config.enableSoftwareAES = true;
}
}
var _proto = Decrypter.prototype;
_proto.destroy = function destroy() {
// @ts-ignore
this.observer = null;
};
_proto.isSync = function isSync() {
return this.config.enableSoftwareAES;
};
_proto.flush = function flush() {
var currentResult = this.currentResult;
if (!currentResult) {
this.reset();
return;
}
var data = new Uint8Array(currentResult);
this.reset();
if (this.removePKCS7Padding) {
return Object(_aes_decryptor__WEBPACK_IMPORTED_MODULE_2__["removePadding"])(data);
}
return data;
};
_proto.reset = function reset() {
this.currentResult = null;
this.currentIV = null;
this.remainderData = null;
if (this.softwareDecrypter) {
this.softwareDecrypter = null;
}
};
_proto.decrypt = function decrypt(data, key, iv, callback) {
if (this.config.enableSoftwareAES) {
this.softwareDecrypt(new Uint8Array(data), key, iv);
var decryptResult = this.flush();
if (decryptResult) {
callback(decryptResult.buffer);
}
} else {
this.webCryptoDecrypt(new Uint8Array(data), key, iv).then(callback);
}
};
_proto.softwareDecrypt = function softwareDecrypt(data, key, iv) {
var currentIV = this.currentIV,
currentResult = this.currentResult,
remainderData = this.remainderData;
this.logOnce('JS AES decrypt'); // The output is staggered during progressive parsing - the current result is cached, and emitted on the next call
// This is done in order to strip PKCS7 padding, which is found at the end of each segment. We only know we've reached
// the end on flush(), but by that time we have already received all bytes for the segment.
// Progressive decryption does not work with WebCrypto
if (remainderData) {
data = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_4__["appendUint8Array"])(remainderData, data);
this.remainderData = null;
} // Byte length must be a multiple of 16 (AES-128 = 128 bit blocks = 16 bytes)
var currentChunk = this.getValidChunk(data);
if (!currentChunk.length) {
return null;
}
if (currentIV) {
iv = currentIV;
}
var softwareDecrypter = this.softwareDecrypter;
if (!softwareDecrypter) {
softwareDecrypter = this.softwareDecrypter = new _aes_decryptor__WEBPACK_IMPORTED_MODULE_2__["default"]();
}
softwareDecrypter.expandKey(key);
var result = currentResult;
this.currentResult = softwareDecrypter.decrypt(currentChunk.buffer, 0, iv);
this.currentIV = Object(_utils_typed_array__WEBPACK_IMPORTED_MODULE_5__["sliceUint8"])(currentChunk, -16).buffer;
if (!result) {
return null;
}
return result;
};
_proto.webCryptoDecrypt = function webCryptoDecrypt(data, key, iv) {
var _this = this;
var subtle = this.subtle;
if (this.key !== key || !this.fastAesKey) {
this.key = key;
this.fastAesKey = new _fast_aes_key__WEBPACK_IMPORTED_MODULE_1__["default"](subtle, key);
}
return this.fastAesKey.expandKey().then(function (aesKey) {
// decrypt using web crypto
if (!subtle) {
return Promise.reject(new Error('web crypto not initialized'));
}
var crypto = new _aes_crypto__WEBPACK_IMPORTED_MODULE_0__["default"](subtle, iv);
return crypto.decrypt(data.buffer, aesKey);
}).catch(function (err) {
return _this.onWebCryptoError(err, data, key, iv);
});
};
_proto.onWebCryptoError = function onWebCryptoError(err, data, key, iv) {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn('[decrypter.ts]: WebCrypto Error, disable WebCrypto API:', err);
this.config.enableSoftwareAES = true;
this.logEnabled = true;
return this.softwareDecrypt(data, key, iv);
};
_proto.getValidChunk = function getValidChunk(data) {
var currentChunk = data;
var splitPoint = data.length - data.length % CHUNK_SIZE;
if (splitPoint !== data.length) {
currentChunk = Object(_utils_typed_array__WEBPACK_IMPORTED_MODULE_5__["sliceUint8"])(data, 0, splitPoint);
this.remainderData = Object(_utils_typed_array__WEBPACK_IMPORTED_MODULE_5__["sliceUint8"])(data, splitPoint);
}
return currentChunk;
};
_proto.logOnce = function logOnce(msg) {
if (!this.logEnabled) {
return;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].log("[decrypter.ts]: " + msg);
this.logEnabled = false;
};
return Decrypter;
}();
/***/ }),
/***/ "./src/crypt/fast-aes-key.ts":
/*!***********************************!*\
!*** ./src/crypt/fast-aes-key.ts ***!
\***********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return FastAESKey; });
var FastAESKey = /*#__PURE__*/function () {
function FastAESKey(subtle, key) {
this.subtle = void 0;
this.key = void 0;
this.subtle = subtle;
this.key = key;
}
var _proto = FastAESKey.prototype;
_proto.expandKey = function expandKey() {
return this.subtle.importKey('raw', this.key, {
name: 'AES-CBC'
}, false, ['encrypt', 'decrypt']);
};
return FastAESKey;
}();
/***/ }),
/***/ "./src/demux/aacdemuxer.ts":
/*!*********************************!*\
!*** ./src/demux/aacdemuxer.ts ***!
\*********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _base_audio_demuxer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./base-audio-demuxer */ "./src/demux/base-audio-demuxer.ts");
/* harmony import */ var _adts__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./adts */ "./src/demux/adts.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _demux_id3__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../demux/id3 */ "./src/demux/id3.ts");
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
/**
* AAC demuxer
*/
var AACDemuxer = /*#__PURE__*/function (_BaseAudioDemuxer) {
_inheritsLoose(AACDemuxer, _BaseAudioDemuxer);
function AACDemuxer(observer, config) {
var _this;
_this = _BaseAudioDemuxer.call(this) || this;
_this.observer = void 0;
_this.config = void 0;
_this.observer = observer;
_this.config = config;
return _this;
}
var _proto = AACDemuxer.prototype;
_proto.resetInitSegment = function resetInitSegment(audioCodec, videoCodec, duration) {
_BaseAudioDemuxer.prototype.resetInitSegment.call(this, audioCodec, videoCodec, duration);
this._audioTrack = {
container: 'audio/adts',
type: 'audio',
id: 0,
pid: -1,
sequenceNumber: 0,
isAAC: true,
samples: [],
manifestCodec: audioCodec,
duration: duration,
inputTimeScale: 90000,
dropped: 0
};
} // Source for probe info - https://wiki.multimedia.cx/index.php?title=ADTS
;
AACDemuxer.probe = function probe(data) {
if (!data) {
return false;
} // Check for the ADTS sync word
// Look for ADTS header | 1111 1111 | 1111 X00X | where X can be either 0 or 1
// Layer bits (position 14 and 15) in header should be always 0 for ADTS
// More info https://wiki.multimedia.cx/index.php?title=ADTS
var id3Data = _demux_id3__WEBPACK_IMPORTED_MODULE_3__["getID3Data"](data, 0) || [];
var offset = id3Data.length;
for (var length = data.length; offset < length; offset++) {
if (_adts__WEBPACK_IMPORTED_MODULE_1__["probe"](data, offset)) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('ADTS sync word found !');
return true;
}
}
return false;
};
_proto.canParse = function canParse(data, offset) {
return _adts__WEBPACK_IMPORTED_MODULE_1__["canParse"](data, offset);
};
_proto.appendFrame = function appendFrame(track, data, offset) {
_adts__WEBPACK_IMPORTED_MODULE_1__["initTrackConfig"](track, this.observer, data, offset, track.manifestCodec);
var frame = _adts__WEBPACK_IMPORTED_MODULE_1__["appendFrame"](track, data, offset, this.initPTS, this.frameIndex);
if (frame && frame.missing === 0) {
return frame;
}
};
return AACDemuxer;
}(_base_audio_demuxer__WEBPACK_IMPORTED_MODULE_0__["default"]);
AACDemuxer.minProbeByteLength = 9;
/* harmony default export */ __webpack_exports__["default"] = (AACDemuxer);
/***/ }),
/***/ "./src/demux/adts.ts":
/*!***************************!*\
!*** ./src/demux/adts.ts ***!
\***************************/
/*! exports provided: getAudioConfig, isHeaderPattern, getHeaderLength, getFullFrameLength, canGetFrameLength, isHeader, canParse, probe, initTrackConfig, getFrameDuration, parseFrameHeader, appendFrame */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getAudioConfig", function() { return getAudioConfig; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isHeaderPattern", function() { return isHeaderPattern; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getHeaderLength", function() { return getHeaderLength; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getFullFrameLength", function() { return getFullFrameLength; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "canGetFrameLength", function() { return canGetFrameLength; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isHeader", function() { return isHeader; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "canParse", function() { return canParse; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "probe", function() { return probe; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "initTrackConfig", function() { return initTrackConfig; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getFrameDuration", function() { return getFrameDuration; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseFrameHeader", function() { return parseFrameHeader; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "appendFrame", function() { return appendFrame; });
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/**
* ADTS parser helper
* @link https://wiki.multimedia.cx/index.php?title=ADTS
*/
function getAudioConfig(observer, data, offset, audioCodec) {
var adtsObjectType;
var adtsExtensionSamplingIndex;
var adtsChanelConfig;
var config;
var userAgent = navigator.userAgent.toLowerCase();
var manifestCodec = audioCodec;
var adtsSampleingRates = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350]; // byte 2
adtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
var adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
if (adtsSamplingIndex > adtsSampleingRates.length - 1) {
observer.trigger(_events__WEBPACK_IMPORTED_MODULE_2__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].FRAG_PARSING_ERROR,
fatal: true,
reason: "invalid ADTS sampling index:" + adtsSamplingIndex
});
return;
}
adtsChanelConfig = (data[offset + 2] & 0x01) << 2; // byte 3
adtsChanelConfig |= (data[offset + 3] & 0xc0) >>> 6;
_utils_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].log("manifest codec:" + audioCodec + ", ADTS type:" + adtsObjectType + ", samplingIndex:" + adtsSamplingIndex); // firefox: freq less than 24kHz = AAC SBR (HE-AAC)
if (/firefox/i.test(userAgent)) {
if (adtsSamplingIndex >= 6) {
adtsObjectType = 5;
config = new Array(4); // HE-AAC uses SBR (Spectral Band Replication) , high frequencies are constructed from low frequencies
// there is a factor 2 between frame sample rate and output sample rate
// multiply frequency by 2 (see table below, equivalent to substract 3)
adtsExtensionSamplingIndex = adtsSamplingIndex - 3;
} else {
adtsObjectType = 2;
config = new Array(2);
adtsExtensionSamplingIndex = adtsSamplingIndex;
} // Android : always use AAC
} else if (userAgent.indexOf('android') !== -1) {
adtsObjectType = 2;
config = new Array(2);
adtsExtensionSamplingIndex = adtsSamplingIndex;
} else {
/* for other browsers (Chrome/Vivaldi/Opera ...)
always force audio type to be HE-AAC SBR, as some browsers do not support audio codec switch properly (like Chrome ...)
*/
adtsObjectType = 5;
config = new Array(4); // if (manifest codec is HE-AAC or HE-AACv2) OR (manifest codec not specified AND frequency less than 24kHz)
if (audioCodec && (audioCodec.indexOf('mp4a.40.29') !== -1 || audioCodec.indexOf('mp4a.40.5') !== -1) || !audioCodec && adtsSamplingIndex >= 6) {
// HE-AAC uses SBR (Spectral Band Replication) , high frequencies are constructed from low frequencies
// there is a factor 2 between frame sample rate and output sample rate
// multiply frequency by 2 (see table below, equivalent to substract 3)
adtsExtensionSamplingIndex = adtsSamplingIndex - 3;
} else {
// if (manifest codec is AAC) AND (frequency less than 24kHz AND nb channel is 1) OR (manifest codec not specified and mono audio)
// Chrome fails to play back with low frequency AAC LC mono when initialized with HE-AAC. This is not a problem with stereo.
if (audioCodec && audioCodec.indexOf('mp4a.40.2') !== -1 && (adtsSamplingIndex >= 6 && adtsChanelConfig === 1 || /vivaldi/i.test(userAgent)) || !audioCodec && adtsChanelConfig === 1) {
adtsObjectType = 2;
config = new Array(2);
}
adtsExtensionSamplingIndex = adtsSamplingIndex;
}
}
/* refer to http://wiki.multimedia.cx/index.php?title=MPEG-4_Audio#Audio_Specific_Config
ISO 14496-3 (AAC).pdf - Table 1.13 — Syntax of AudioSpecificConfig()
Audio Profile / Audio Object Type
0: Null
1: AAC Main
2: AAC LC (Low Complexity)
3: AAC SSR (Scalable Sample Rate)
4: AAC LTP (Long Term Prediction)
5: SBR (Spectral Band Replication)
6: AAC Scalable
sampling freq
0: 96000 Hz
1: 88200 Hz
2: 64000 Hz
3: 48000 Hz
4: 44100 Hz
5: 32000 Hz
6: 24000 Hz
7: 22050 Hz
8: 16000 Hz
9: 12000 Hz
10: 11025 Hz
11: 8000 Hz
12: 7350 Hz
13: Reserved
14: Reserved
15: frequency is written explictly
Channel Configurations
These are the channel configurations:
0: Defined in AOT Specifc Config
1: 1 channel: front-center
2: 2 channels: front-left, front-right
*/
// audioObjectType = profile => profile, the MPEG-4 Audio Object Type minus 1
config[0] = adtsObjectType << 3; // samplingFrequencyIndex
config[0] |= (adtsSamplingIndex & 0x0e) >> 1;
config[1] |= (adtsSamplingIndex & 0x01) << 7; // channelConfiguration
config[1] |= adtsChanelConfig << 3;
if (adtsObjectType === 5) {
// adtsExtensionSampleingIndex
config[1] |= (adtsExtensionSamplingIndex & 0x0e) >> 1;
config[2] = (adtsExtensionSamplingIndex & 0x01) << 7; // adtsObjectType (force to 2, chrome is checking that object type is less than 5 ???
// https://chromium.googlesource.com/chromium/src.git/+/master/media/formats/mp4/aac.cc
config[2] |= 2 << 2;
config[3] = 0;
}
return {
config: config,
samplerate: adtsSampleingRates[adtsSamplingIndex],
channelCount: adtsChanelConfig,
codec: 'mp4a.40.' + adtsObjectType,
manifestCodec: manifestCodec
};
}
function isHeaderPattern(data, offset) {
return data[offset] === 0xff && (data[offset + 1] & 0xf6) === 0xf0;
}
function getHeaderLength(data, offset) {
return data[offset + 1] & 0x01 ? 7 : 9;
}
function getFullFrameLength(data, offset) {
return (data[offset + 3] & 0x03) << 11 | data[offset + 4] << 3 | (data[offset + 5] & 0xe0) >>> 5;
}
function canGetFrameLength(data, offset) {
return offset + 5 < data.length;
}
function isHeader(data, offset) {
// Look for ADTS header | 1111 1111 | 1111 X00X | where X can be either 0 or 1
// Layer bits (position 14 and 15) in header should be always 0 for ADTS
// More info https://wiki.multimedia.cx/index.php?title=ADTS
return offset + 1 < data.length && isHeaderPattern(data, offset);
}
function canParse(data, offset) {
return canGetFrameLength(data, offset) && isHeaderPattern(data, offset) && getFullFrameLength(data, offset) <= data.length - offset;
}
function probe(data, offset) {
// same as isHeader but we also check that ADTS frame follows last ADTS frame
// or end of data is reached
if (isHeader(data, offset)) {
// ADTS header Length
var headerLength = getHeaderLength(data, offset);
if (offset + headerLength >= data.length) {
return false;
} // ADTS frame Length
var frameLength = getFullFrameLength(data, offset);
if (frameLength <= headerLength) {
return false;
}
var newOffset = offset + frameLength;
return newOffset === data.length || isHeader(data, newOffset);
}
return false;
}
function initTrackConfig(track, observer, data, offset, audioCodec) {
if (!track.samplerate) {
var config = getAudioConfig(observer, data, offset, audioCodec);
if (!config) {
return;
}
track.config = config.config;
track.samplerate = config.samplerate;
track.channelCount = config.channelCount;
track.codec = config.codec;
track.manifestCodec = config.manifestCodec;
_utils_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].log("parsed codec:" + track.codec + ", rate:" + config.samplerate + ", channels:" + config.channelCount);
}
}
function getFrameDuration(samplerate) {
return 1024 * 90000 / samplerate;
}
function parseFrameHeader(data, offset, pts, frameIndex, frameDuration) {
// The protection skip bit tells us if we have 2 bytes of CRC data at the end of the ADTS header
var headerLength = getHeaderLength(data, offset); // retrieve frame size
var frameLength = getFullFrameLength(data, offset);
frameLength -= headerLength;
if (frameLength > 0) {
var stamp = pts + frameIndex * frameDuration; // logger.log(`AAC frame, offset/length/total/pts:${offset+headerLength}/${frameLength}/${data.byteLength}/${(stamp/90).toFixed(0)}`);
return {
headerLength: headerLength,
frameLength: frameLength,
stamp: stamp
};
}
}
function appendFrame(track, data, offset, pts, frameIndex) {
var frameDuration = getFrameDuration(track.samplerate);
var header = parseFrameHeader(data, offset, pts, frameIndex, frameDuration);
if (header) {
var frameLength = header.frameLength,
headerLength = header.headerLength,
stamp = header.stamp;
var length = headerLength + frameLength;
var missing = Math.max(0, offset + length - data.length); // logger.log(`AAC frame ${frameIndex}, pts:${stamp} length@offset/total: ${frameLength}@${offset+headerLength}/${data.byteLength} missing: ${missing}`);
var unit;
if (missing) {
unit = new Uint8Array(length - headerLength);
unit.set(data.subarray(offset + headerLength, data.length), 0);
} else {
unit = data.subarray(offset + headerLength, offset + length);
}
var sample = {
unit: unit,
pts: stamp
};
if (!missing) {
track.samples.push(sample);
}
return {
sample: sample,
length: length,
missing: missing
};
}
}
/***/ }),
/***/ "./src/demux/base-audio-demuxer.ts":
/*!*****************************************!*\
!*** ./src/demux/base-audio-demuxer.ts ***!
\*****************************************/
/*! exports provided: initPTSFn, default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "initPTSFn", function() { return initPTSFn; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _demux_id3__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../demux/id3 */ "./src/demux/id3.ts");
/* harmony import */ var _dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./dummy-demuxed-track */ "./src/demux/dummy-demuxed-track.ts");
/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _utils_typed_array__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/typed-array */ "./src/utils/typed-array.ts");
var BaseAudioDemuxer = /*#__PURE__*/function () {
function BaseAudioDemuxer() {
this._audioTrack = void 0;
this._id3Track = void 0;
this.frameIndex = 0;
this.cachedData = null;
this.initPTS = null;
}
var _proto = BaseAudioDemuxer.prototype;
_proto.resetInitSegment = function resetInitSegment(audioCodec, videoCodec, duration) {
this._id3Track = {
type: 'id3',
id: 0,
pid: -1,
inputTimeScale: 90000,
sequenceNumber: 0,
samples: [],
dropped: 0
};
};
_proto.resetTimeStamp = function resetTimeStamp() {};
_proto.resetContiguity = function resetContiguity() {};
_proto.canParse = function canParse(data, offset) {
return false;
};
_proto.appendFrame = function appendFrame(track, data, offset) {} // feed incoming data to the front of the parsing pipeline
;
_proto.demux = function demux(data, timeOffset) {
if (this.cachedData) {
data = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_3__["appendUint8Array"])(this.cachedData, data);
this.cachedData = null;
}
var id3Data = _demux_id3__WEBPACK_IMPORTED_MODULE_1__["getID3Data"](data, 0);
var offset = id3Data ? id3Data.length : 0;
var lastDataIndex;
var pts;
var track = this._audioTrack;
var id3Track = this._id3Track;
var timestamp = id3Data ? _demux_id3__WEBPACK_IMPORTED_MODULE_1__["getTimeStamp"](id3Data) : undefined;
var length = data.length;
if (this.frameIndex === 0 || this.initPTS === null) {
this.initPTS = initPTSFn(timestamp, timeOffset);
} // more expressive than alternative: id3Data?.length
if (id3Data && id3Data.length > 0) {
id3Track.samples.push({
pts: this.initPTS,
dts: this.initPTS,
data: id3Data
});
}
pts = this.initPTS;
while (offset < length) {
if (this.canParse(data, offset)) {
var frame = this.appendFrame(track, data, offset);
if (frame) {
this.frameIndex++;
pts = frame.sample.pts;
offset += frame.length;
lastDataIndex = offset;
} else {
offset = length;
}
} else if (_demux_id3__WEBPACK_IMPORTED_MODULE_1__["canParse"](data, offset)) {
// after a ID3.canParse, a call to ID3.getID3Data *should* always returns some data
id3Data = _demux_id3__WEBPACK_IMPORTED_MODULE_1__["getID3Data"](data, offset);
id3Track.samples.push({
pts: pts,
dts: pts,
data: id3Data
});
offset += id3Data.length;
lastDataIndex = offset;
} else {
offset++;
}
if (offset === length && lastDataIndex !== length) {
var partialData = Object(_utils_typed_array__WEBPACK_IMPORTED_MODULE_4__["sliceUint8"])(data, lastDataIndex);
if (this.cachedData) {
this.cachedData = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_3__["appendUint8Array"])(this.cachedData, partialData);
} else {
this.cachedData = partialData;
}
}
}
return {
audioTrack: track,
avcTrack: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_2__["dummyTrack"])(),
id3Track: id3Track,
textTrack: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_2__["dummyTrack"])()
};
};
_proto.demuxSampleAes = function demuxSampleAes(data, keyData, timeOffset) {
return Promise.reject(new Error("[" + this + "] This demuxer does not support Sample-AES decryption"));
};
_proto.flush = function flush(timeOffset) {
// Parse cache in case of remaining frames.
var cachedData = this.cachedData;
if (cachedData) {
this.cachedData = null;
this.demux(cachedData, 0);
}
this.frameIndex = 0;
return {
audioTrack: this._audioTrack,
avcTrack: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_2__["dummyTrack"])(),
id3Track: this._id3Track,
textTrack: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_2__["dummyTrack"])()
};
};
_proto.destroy = function destroy() {};
return BaseAudioDemuxer;
}();
/**
* Initialize PTS
* <p>
* use timestamp unless it is undefined, NaN or Infinity
* </p>
*/
var initPTSFn = function initPTSFn(timestamp, timeOffset) {
return Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(timestamp) ? timestamp * 90 : timeOffset * 90000;
};
/* harmony default export */ __webpack_exports__["default"] = (BaseAudioDemuxer);
/***/ }),
/***/ "./src/demux/chunk-cache.ts":
/*!**********************************!*\
!*** ./src/demux/chunk-cache.ts ***!
\**********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ChunkCache; });
var ChunkCache = /*#__PURE__*/function () {
function ChunkCache() {
this.chunks = [];
this.dataLength = 0;
}
var _proto = ChunkCache.prototype;
_proto.push = function push(chunk) {
this.chunks.push(chunk);
this.dataLength += chunk.length;
};
_proto.flush = function flush() {
var chunks = this.chunks,
dataLength = this.dataLength;
var result;
if (!chunks.length) {
return new Uint8Array(0);
} else if (chunks.length === 1) {
result = chunks[0];
} else {
result = concatUint8Arrays(chunks, dataLength);
}
this.reset();
return result;
};
_proto.reset = function reset() {
this.chunks.length = 0;
this.dataLength = 0;
};
return ChunkCache;
}();
function concatUint8Arrays(chunks, dataLength) {
var result = new Uint8Array(dataLength);
var offset = 0;
for (var i = 0; i < chunks.length; i++) {
var chunk = chunks[i];
result.set(chunk, offset);
offset += chunk.length;
}
return result;
}
/***/ }),
/***/ "./src/demux/dummy-demuxed-track.ts":
/*!******************************************!*\
!*** ./src/demux/dummy-demuxed-track.ts ***!
\******************************************/
/*! exports provided: dummyTrack */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dummyTrack", function() { return dummyTrack; });
function dummyTrack() {
return {
type: '',
id: -1,
pid: -1,
inputTimeScale: 90000,
sequenceNumber: -1,
samples: [],
dropped: 0
};
}
/***/ }),
/***/ "./src/demux/exp-golomb.ts":
/*!*********************************!*\
!*** ./src/demux/exp-golomb.ts ***!
\*********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/**
* Parser for exponential Golomb codes, a variable-bitwidth number encoding scheme used by h264.
*/
var ExpGolomb = /*#__PURE__*/function () {
function ExpGolomb(data) {
this.data = void 0;
this.bytesAvailable = void 0;
this.word = void 0;
this.bitsAvailable = void 0;
this.data = data; // the number of bytes left to examine in this.data
this.bytesAvailable = data.byteLength; // the current word being examined
this.word = 0; // :uint
// the number of bits left to examine in the current word
this.bitsAvailable = 0; // :uint
} // ():void
var _proto = ExpGolomb.prototype;
_proto.loadWord = function loadWord() {
var data = this.data;
var bytesAvailable = this.bytesAvailable;
var position = data.byteLength - bytesAvailable;
var workingBytes = new Uint8Array(4);
var availableBytes = Math.min(4, bytesAvailable);
if (availableBytes === 0) {
throw new Error('no bytes available');
}
workingBytes.set(data.subarray(position, position + availableBytes));
this.word = new DataView(workingBytes.buffer).getUint32(0); // track the amount of this.data that has been processed
this.bitsAvailable = availableBytes * 8;
this.bytesAvailable -= availableBytes;
} // (count:int):void
;
_proto.skipBits = function skipBits(count) {
var skipBytes; // :int
if (this.bitsAvailable > count) {
this.word <<= count;
this.bitsAvailable -= count;
} else {
count -= this.bitsAvailable;
skipBytes = count >> 3;
count -= skipBytes >> 3;
this.bytesAvailable -= skipBytes;
this.loadWord();
this.word <<= count;
this.bitsAvailable -= count;
}
} // (size:int):uint
;
_proto.readBits = function readBits(size) {
var bits = Math.min(this.bitsAvailable, size); // :uint
var valu = this.word >>> 32 - bits; // :uint
if (size > 32) {
_utils_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].error('Cannot read more than 32 bits at a time');
}
this.bitsAvailable -= bits;
if (this.bitsAvailable > 0) {
this.word <<= bits;
} else if (this.bytesAvailable > 0) {
this.loadWord();
}
bits = size - bits;
if (bits > 0 && this.bitsAvailable) {
return valu << bits | this.readBits(bits);
} else {
return valu;
}
} // ():uint
;
_proto.skipLZ = function skipLZ() {
var leadingZeroCount; // :uint
for (leadingZeroCount = 0; leadingZeroCount < this.bitsAvailable; ++leadingZeroCount) {
if ((this.word & 0x80000000 >>> leadingZeroCount) !== 0) {
// the first bit of working word is 1
this.word <<= leadingZeroCount;
this.bitsAvailable -= leadingZeroCount;
return leadingZeroCount;
}
} // we exhausted word and still have not found a 1
this.loadWord();
return leadingZeroCount + this.skipLZ();
} // ():void
;
_proto.skipUEG = function skipUEG() {
this.skipBits(1 + this.skipLZ());
} // ():void
;
_proto.skipEG = function skipEG() {
this.skipBits(1 + this.skipLZ());
} // ():uint
;
_proto.readUEG = function readUEG() {
var clz = this.skipLZ(); // :uint
return this.readBits(clz + 1) - 1;
} // ():int
;
_proto.readEG = function readEG() {
var valu = this.readUEG(); // :int
if (0x01 & valu) {
// the number is odd if the low order bit is set
return 1 + valu >>> 1; // add 1 to make it even, and divide by 2
} else {
return -1 * (valu >>> 1); // divide by two then make it negative
}
} // Some convenience functions
// :Boolean
;
_proto.readBoolean = function readBoolean() {
return this.readBits(1) === 1;
} // ():int
;
_proto.readUByte = function readUByte() {
return this.readBits(8);
} // ():int
;
_proto.readUShort = function readUShort() {
return this.readBits(16);
} // ():int
;
_proto.readUInt = function readUInt() {
return this.readBits(32);
}
/**
* Advance the ExpGolomb decoder past a scaling list. The scaling
* list is optionally transmitted as part of a sequence parameter
* set and is not relevant to transmuxing.
* @param count the number of entries in this scaling list
* @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1
*/
;
_proto.skipScalingList = function skipScalingList(count) {
var lastScale = 8;
var nextScale = 8;
var deltaScale;
for (var j = 0; j < count; j++) {
if (nextScale !== 0) {
deltaScale = this.readEG();
nextScale = (lastScale + deltaScale + 256) % 256;
}
lastScale = nextScale === 0 ? lastScale : nextScale;
}
}
/**
* Read a sequence parameter set and return some interesting video
* properties. A sequence parameter set is the H264 metadata that
* describes the properties of upcoming video frames.
* @param data {Uint8Array} the bytes of a sequence parameter set
* @return {object} an object with configuration parsed from the
* sequence parameter set, including the dimensions of the
* associated video frames.
*/
;
_proto.readSPS = function readSPS() {
var frameCropLeftOffset = 0;
var frameCropRightOffset = 0;
var frameCropTopOffset = 0;
var frameCropBottomOffset = 0;
var numRefFramesInPicOrderCntCycle;
var scalingListCount;
var i;
var readUByte = this.readUByte.bind(this);
var readBits = this.readBits.bind(this);
var readUEG = this.readUEG.bind(this);
var readBoolean = this.readBoolean.bind(this);
var skipBits = this.skipBits.bind(this);
var skipEG = this.skipEG.bind(this);
var skipUEG = this.skipUEG.bind(this);
var skipScalingList = this.skipScalingList.bind(this);
readUByte();
var profileIdc = readUByte(); // profile_idc
readBits(5); // profileCompat constraint_set[0-4]_flag, u(5)
skipBits(3); // reserved_zero_3bits u(3),
readUByte(); // level_idc u(8)
skipUEG(); // seq_parameter_set_id
// some profiles have more optional data we don't need
if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128) {
var chromaFormatIdc = readUEG();
if (chromaFormatIdc === 3) {
skipBits(1);
} // separate_colour_plane_flag
skipUEG(); // bit_depth_luma_minus8
skipUEG(); // bit_depth_chroma_minus8
skipBits(1); // qpprime_y_zero_transform_bypass_flag
if (readBoolean()) {
// seq_scaling_matrix_present_flag
scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;
for (i = 0; i < scalingListCount; i++) {
if (readBoolean()) {
// seq_scaling_list_present_flag[ i ]
if (i < 6) {
skipScalingList(16);
} else {
skipScalingList(64);
}
}
}
}
}
skipUEG(); // log2_max_frame_num_minus4
var picOrderCntType = readUEG();
if (picOrderCntType === 0) {
readUEG(); // log2_max_pic_order_cnt_lsb_minus4
} else if (picOrderCntType === 1) {
skipBits(1); // delta_pic_order_always_zero_flag
skipEG(); // offset_for_non_ref_pic
skipEG(); // offset_for_top_to_bottom_field
numRefFramesInPicOrderCntCycle = readUEG();
for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {
skipEG();
} // offset_for_ref_frame[ i ]
}
skipUEG(); // max_num_ref_frames
skipBits(1); // gaps_in_frame_num_value_allowed_flag
var picWidthInMbsMinus1 = readUEG();
var picHeightInMapUnitsMinus1 = readUEG();
var frameMbsOnlyFlag = readBits(1);
if (frameMbsOnlyFlag === 0) {
skipBits(1);
} // mb_adaptive_frame_field_flag
skipBits(1); // direct_8x8_inference_flag
if (readBoolean()) {
// frame_cropping_flag
frameCropLeftOffset = readUEG();
frameCropRightOffset = readUEG();
frameCropTopOffset = readUEG();
frameCropBottomOffset = readUEG();
}
var pixelRatio = [1, 1];
if (readBoolean()) {
// vui_parameters_present_flag
if (readBoolean()) {
// aspect_ratio_info_present_flag
var aspectRatioIdc = readUByte();
switch (aspectRatioIdc) {
case 1:
pixelRatio = [1, 1];
break;
case 2:
pixelRatio = [12, 11];
break;
case 3:
pixelRatio = [10, 11];
break;
case 4:
pixelRatio = [16, 11];
break;
case 5:
pixelRatio = [40, 33];
break;
case 6:
pixelRatio = [24, 11];
break;
case 7:
pixelRatio = [20, 11];
break;
case 8:
pixelRatio = [32, 11];
break;
case 9:
pixelRatio = [80, 33];
break;
case 10:
pixelRatio = [18, 11];
break;
case 11:
pixelRatio = [15, 11];
break;
case 12:
pixelRatio = [64, 33];
break;
case 13:
pixelRatio = [160, 99];
break;
case 14:
pixelRatio = [4, 3];
break;
case 15:
pixelRatio = [3, 2];
break;
case 16:
pixelRatio = [2, 1];
break;
case 255:
{
pixelRatio = [readUByte() << 8 | readUByte(), readUByte() << 8 | readUByte()];
break;
}
}
}
}
return {
width: Math.ceil((picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2),
height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - (frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset),
pixelRatio: pixelRatio
};
};
_proto.readSliceType = function readSliceType() {
// skip NALu type
this.readUByte(); // discard first_mb_in_slice
this.readUEG(); // return slice_type
return this.readUEG();
};
return ExpGolomb;
}();
/* harmony default export */ __webpack_exports__["default"] = (ExpGolomb);
/***/ }),
/***/ "./src/demux/id3.ts":
/*!**************************!*\
!*** ./src/demux/id3.ts ***!
\**************************/
/*! exports provided: isHeader, isFooter, getID3Data, canParse, getTimeStamp, isTimeStampFrame, getID3Frames, decodeFrame, utf8ArrayToStr, testables */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isHeader", function() { return isHeader; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isFooter", function() { return isFooter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getID3Data", function() { return getID3Data; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "canParse", function() { return canParse; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getTimeStamp", function() { return getTimeStamp; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isTimeStampFrame", function() { return isTimeStampFrame; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getID3Frames", function() { return getID3Frames; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "decodeFrame", function() { return decodeFrame; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "utf8ArrayToStr", function() { return utf8ArrayToStr; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "testables", function() { return testables; });
// breaking up those two types in order to clarify what is happening in the decoding path.
/**
* Returns true if an ID3 header can be found at offset in data
* @param {Uint8Array} data - The data to search in
* @param {number} offset - The offset at which to start searching
* @return {boolean} - True if an ID3 header is found
*/
var isHeader = function isHeader(data, offset) {
/*
* http://id3.org/id3v2.3.0
* [0] = 'I'
* [1] = 'D'
* [2] = '3'
* [3,4] = {Version}
* [5] = {Flags}
* [6-9] = {ID3 Size}
*
* An ID3v2 tag can be detected with the following pattern:
* $49 44 33 yy yy xx zz zz zz zz
* Where yy is less than $FF, xx is the 'flags' byte and zz is less than $80
*/
if (offset + 10 <= data.length) {
// look for 'ID3' identifier
if (data[offset] === 0x49 && data[offset + 1] === 0x44 && data[offset + 2] === 0x33) {
// check version is within range
if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
// check size is within range
if (data[offset + 6] < 0x80 && data[offset + 7] < 0x80 && data[offset + 8] < 0x80 && data[offset + 9] < 0x80) {
return true;
}
}
}
}
return false;
};
/**
* Returns true if an ID3 footer can be found at offset in data
* @param {Uint8Array} data - The data to search in
* @param {number} offset - The offset at which to start searching
* @return {boolean} - True if an ID3 footer is found
*/
var isFooter = function isFooter(data, offset) {
/*
* The footer is a copy of the header, but with a different identifier
*/
if (offset + 10 <= data.length) {
// look for '3DI' identifier
if (data[offset] === 0x33 && data[offset + 1] === 0x44 && data[offset + 2] === 0x49) {
// check version is within range
if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
// check size is within range
if (data[offset + 6] < 0x80 && data[offset + 7] < 0x80 && data[offset + 8] < 0x80 && data[offset + 9] < 0x80) {
return true;
}
}
}
}
return false;
};
/**
* Returns any adjacent ID3 tags found in data starting at offset, as one block of data
* @param {Uint8Array} data - The data to search in
* @param {number} offset - The offset at which to start searching
* @return {Uint8Array | undefined} - The block of data containing any ID3 tags found
* or *undefined* if no header is found at the starting offset
*/
var getID3Data = function getID3Data(data, offset) {
var front = offset;
var length = 0;
while (isHeader(data, offset)) {
// ID3 header is 10 bytes
length += 10;
var size = readSize(data, offset + 6);
length += size;
if (isFooter(data, offset + 10)) {
// ID3 footer is 10 bytes
length += 10;
}
offset += length;
}
if (length > 0) {
return data.subarray(front, front + length);
}
return undefined;
};
var readSize = function readSize(data, offset) {
var size = 0;
size = (data[offset] & 0x7f) << 21;
size |= (data[offset + 1] & 0x7f) << 14;
size |= (data[offset + 2] & 0x7f) << 7;
size |= data[offset + 3] & 0x7f;
return size;
};
var canParse = function canParse(data, offset) {
return isHeader(data, offset) && readSize(data, offset + 6) + 10 <= data.length - offset;
};
/**
* Searches for the Elementary Stream timestamp found in the ID3 data chunk
* @param {Uint8Array} data - Block of data containing one or more ID3 tags
* @return {number | undefined} - The timestamp
*/
var getTimeStamp = function getTimeStamp(data) {
var frames = getID3Frames(data);
for (var i = 0; i < frames.length; i++) {
var frame = frames[i];
if (isTimeStampFrame(frame)) {
return readTimeStamp(frame);
}
}
return undefined;
};
/**
* Returns true if the ID3 frame is an Elementary Stream timestamp frame
* @param {ID3 frame} frame
*/
var isTimeStampFrame = function isTimeStampFrame(frame) {
return frame && frame.key === 'PRIV' && frame.info === 'com.apple.streaming.transportStreamTimestamp';
};
var getFrameData = function getFrameData(data) {
/*
Frame ID $xx xx xx xx (four characters)
Size $xx xx xx xx
Flags $xx xx
*/
var type = String.fromCharCode(data[0], data[1], data[2], data[3]);
var size = readSize(data, 4); // skip frame id, size, and flags
var offset = 10;
return {
type: type,
size: size,
data: data.subarray(offset, offset + size)
};
};
/**
* Returns an array of ID3 frames found in all the ID3 tags in the id3Data
* @param {Uint8Array} id3Data - The ID3 data containing one or more ID3 tags
* @return {ID3.Frame[]} - Array of ID3 frame objects
*/
var getID3Frames = function getID3Frames(id3Data) {
var offset = 0;
var frames = [];
while (isHeader(id3Data, offset)) {
var size = readSize(id3Data, offset + 6); // skip past ID3 header
offset += 10;
var end = offset + size; // loop through frames in the ID3 tag
while (offset + 8 < end) {
var frameData = getFrameData(id3Data.subarray(offset));
var frame = decodeFrame(frameData);
if (frame) {
frames.push(frame);
} // skip frame header and frame data
offset += frameData.size + 10;
}
if (isFooter(id3Data, offset)) {
offset += 10;
}
}
return frames;
};
var decodeFrame = function decodeFrame(frame) {
if (frame.type === 'PRIV') {
return decodePrivFrame(frame);
} else if (frame.type[0] === 'W') {
return decodeURLFrame(frame);
}
return decodeTextFrame(frame);
};
var decodePrivFrame = function decodePrivFrame(frame) {
/*
Format: <text string>\0<binary data>
*/
if (frame.size < 2) {
return undefined;
}
var owner = utf8ArrayToStr(frame.data, true);
var privateData = new Uint8Array(frame.data.subarray(owner.length + 1));
return {
key: frame.type,
info: owner,
data: privateData.buffer
};
};
var decodeTextFrame = function decodeTextFrame(frame) {
if (frame.size < 2) {
return undefined;
}
if (frame.type === 'TXXX') {
/*
Format:
[0] = {Text Encoding}
[1-?] = {Description}\0{Value}
*/
var index = 1;
var description = utf8ArrayToStr(frame.data.subarray(index), true);
index += description.length + 1;
var value = utf8ArrayToStr(frame.data.subarray(index));
return {
key: frame.type,
info: description,
data: value
};
}
/*
Format:
[0] = {Text Encoding}
[1-?] = {Value}
*/
var text = utf8ArrayToStr(frame.data.subarray(1));
return {
key: frame.type,
data: text
};
};
var decodeURLFrame = function decodeURLFrame(frame) {
if (frame.type === 'WXXX') {
/*
Format:
[0] = {Text Encoding}
[1-?] = {Description}\0{URL}
*/
if (frame.size < 2) {
return undefined;
}
var index = 1;
var description = utf8ArrayToStr(frame.data.subarray(index), true);
index += description.length + 1;
var value = utf8ArrayToStr(frame.data.subarray(index));
return {
key: frame.type,
info: description,
data: value
};
}
/*
Format:
[0-?] = {URL}
*/
var url = utf8ArrayToStr(frame.data);
return {
key: frame.type,
data: url
};
};
var readTimeStamp = function readTimeStamp(timeStampFrame) {
if (timeStampFrame.data.byteLength === 8) {
var data = new Uint8Array(timeStampFrame.data); // timestamp is 33 bit expressed as a big-endian eight-octet number,
// with the upper 31 bits set to zero.
var pts33Bit = data[3] & 0x1;
var timestamp = (data[4] << 23) + (data[5] << 15) + (data[6] << 7) + data[7];
timestamp /= 45;
if (pts33Bit) {
timestamp += 47721858.84;
} // 2^32 / 90
return Math.round(timestamp);
}
return undefined;
}; // http://stackoverflow.com/questions/8936984/uint8array-to-string-in-javascript/22373197
// http://www.onicos.com/staff/iz/amuse/javascript/expert/utf.txt
/* utf.js - UTF-8 <=> UTF-16 convertion
*
* Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
* Version: 1.0
* LastModified: Dec 25 1999
* This library is free. You can redistribute it and/or modify it.
*/
var utf8ArrayToStr = function utf8ArrayToStr(array, exitOnNull) {
if (exitOnNull === void 0) {
exitOnNull = false;
}
var decoder = getTextDecoder();
if (decoder) {
var decoded = decoder.decode(array);
if (exitOnNull) {
// grab up to the first null
var idx = decoded.indexOf('\0');
return idx !== -1 ? decoded.substring(0, idx) : decoded;
} // remove any null characters
return decoded.replace(/\0/g, '');
}
var len = array.length;
var c;
var char2;
var char3;
var out = '';
var i = 0;
while (i < len) {
c = array[i++];
if (c === 0x00 && exitOnNull) {
return out;
} else if (c === 0x00 || c === 0x03) {
// If the character is 3 (END_OF_TEXT) or 0 (NULL) then skip it
continue;
}
switch (c >> 4) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
// 0xxxxxxx
out += String.fromCharCode(c);
break;
case 12:
case 13:
// 110x xxxx 10xx xxxx
char2 = array[i++];
out += String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
break;
case 14:
// 1110 xxxx 10xx xxxx 10xx xxxx
char2 = array[i++];
char3 = array[i++];
out += String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
break;
default:
}
}
return out;
};
var testables = {
decodeTextFrame: decodeTextFrame
};
var decoder;
function getTextDecoder() {
if (!decoder && typeof self.TextDecoder !== 'undefined') {
decoder = new self.TextDecoder('utf-8');
}
return decoder;
}
/***/ }),
/***/ "./src/demux/mp3demuxer.ts":
/*!*********************************!*\
!*** ./src/demux/mp3demuxer.ts ***!
\*********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _base_audio_demuxer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./base-audio-demuxer */ "./src/demux/base-audio-demuxer.ts");
/* harmony import */ var _demux_id3__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../demux/id3 */ "./src/demux/id3.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _mpegaudio__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./mpegaudio */ "./src/demux/mpegaudio.ts");
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
/**
* MP3 demuxer
*/
var MP3Demuxer = /*#__PURE__*/function (_BaseAudioDemuxer) {
_inheritsLoose(MP3Demuxer, _BaseAudioDemuxer);
function MP3Demuxer() {
return _BaseAudioDemuxer.apply(this, arguments) || this;
}
var _proto = MP3Demuxer.prototype;
_proto.resetInitSegment = function resetInitSegment(audioCodec, videoCodec, duration) {
_BaseAudioDemuxer.prototype.resetInitSegment.call(this, audioCodec, videoCodec, duration);
this._audioTrack = {
container: 'audio/mpeg',
type: 'audio',
id: 0,
pid: -1,
sequenceNumber: 0,
isAAC: false,
samples: [],
manifestCodec: audioCodec,
duration: duration,
inputTimeScale: 90000,
dropped: 0
};
};
MP3Demuxer.probe = function probe(data) {
if (!data) {
return false;
} // check if data contains ID3 timestamp and MPEG sync word
// Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either 0 or 1 and Y or Z should be 1
// Layer bits (position 14 and 15) in header should be always different from 0 (Layer I or Layer II or Layer III)
// More info http://www.mp3-tech.org/programmer/frame_header.html
var id3Data = _demux_id3__WEBPACK_IMPORTED_MODULE_1__["getID3Data"](data, 0) || [];
var offset = id3Data.length;
for (var length = data.length; offset < length; offset++) {
if (_mpegaudio__WEBPACK_IMPORTED_MODULE_3__["probe"](data, offset)) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].log('MPEG Audio sync word found !');
return true;
}
}
return false;
};
_proto.canParse = function canParse(data, offset) {
return _mpegaudio__WEBPACK_IMPORTED_MODULE_3__["canParse"](data, offset);
};
_proto.appendFrame = function appendFrame(track, data, offset) {
if (this.initPTS === null) {
return;
}
return _mpegaudio__WEBPACK_IMPORTED_MODULE_3__["appendFrame"](track, data, offset, this.initPTS, this.frameIndex);
};
return MP3Demuxer;
}(_base_audio_demuxer__WEBPACK_IMPORTED_MODULE_0__["default"]);
MP3Demuxer.minProbeByteLength = 4;
/* harmony default export */ __webpack_exports__["default"] = (MP3Demuxer);
/***/ }),
/***/ "./src/demux/mp4demuxer.ts":
/*!*********************************!*\
!*** ./src/demux/mp4demuxer.ts ***!
\*********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./dummy-demuxed-track */ "./src/demux/dummy-demuxed-track.ts");
/**
* MP4 demuxer
*/
var MP4Demuxer = /*#__PURE__*/function () {
function MP4Demuxer(observer, config) {
this.remainderData = null;
this.config = void 0;
this.config = config;
}
var _proto = MP4Demuxer.prototype;
_proto.resetTimeStamp = function resetTimeStamp() {};
_proto.resetInitSegment = function resetInitSegment() {};
_proto.resetContiguity = function resetContiguity() {};
MP4Demuxer.probe = function probe(data) {
// ensure we find a moof box in the first 16 kB
return Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_0__["findBox"])({
data: data,
start: 0,
end: Math.min(data.length, 16384)
}, ['moof']).length > 0;
};
_proto.demux = function demux(data) {
// Load all data into the avc track. The CMAF remuxer will look for the data in the samples object; the rest of the fields do not matter
var avcSamples = data;
var avcTrack = Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__["dummyTrack"])();
if (this.config.progressive) {
// Split the bytestream into two ranges: one encompassing all data up until the start of the last moof, and everything else.
// This is done to guarantee that we're sending valid data to MSE - when demuxing progressively, we have no guarantee
// that the fetch loader gives us flush moof+mdat pairs. If we push jagged data to MSE, it will throw an exception.
if (this.remainderData) {
avcSamples = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_0__["appendUint8Array"])(this.remainderData, data);
}
var segmentedData = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_0__["segmentValidRange"])(avcSamples);
this.remainderData = segmentedData.remainder;
avcTrack.samples = segmentedData.valid || new Uint8Array();
} else {
avcTrack.samples = avcSamples;
}
return {
audioTrack: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__["dummyTrack"])(),
avcTrack: avcTrack,
id3Track: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__["dummyTrack"])(),
textTrack: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__["dummyTrack"])()
};
};
_proto.flush = function flush() {
var avcTrack = Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__["dummyTrack"])();
avcTrack.samples = this.remainderData || new Uint8Array();
this.remainderData = null;
return {
audioTrack: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__["dummyTrack"])(),
avcTrack: avcTrack,
id3Track: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__["dummyTrack"])(),
textTrack: Object(_dummy_demuxed_track__WEBPACK_IMPORTED_MODULE_1__["dummyTrack"])()
};
};
_proto.demuxSampleAes = function demuxSampleAes(data, keyData, timeOffset) {
return Promise.reject(new Error('The MP4 demuxer does not support SAMPLE-AES decryption'));
};
_proto.destroy = function destroy() {};
return MP4Demuxer;
}();
MP4Demuxer.minProbeByteLength = 1024;
/* harmony default export */ __webpack_exports__["default"] = (MP4Demuxer);
/***/ }),
/***/ "./src/demux/mpegaudio.ts":
/*!********************************!*\
!*** ./src/demux/mpegaudio.ts ***!
\********************************/
/*! exports provided: appendFrame, parseHeader, isHeaderPattern, isHeader, canParse, probe */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "appendFrame", function() { return appendFrame; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseHeader", function() { return parseHeader; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isHeaderPattern", function() { return isHeaderPattern; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isHeader", function() { return isHeader; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "canParse", function() { return canParse; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "probe", function() { return probe; });
/**
* MPEG parser helper
*/
var chromeVersion = null;
var BitratesMap = [32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160];
var SamplingRateMap = [44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000];
var SamplesCoefficients = [// MPEG 2.5
[0, // Reserved
72, // Layer3
144, // Layer2
12 // Layer1
], // Reserved
[0, // Reserved
0, // Layer3
0, // Layer2
0 // Layer1
], // MPEG 2
[0, // Reserved
72, // Layer3
144, // Layer2
12 // Layer1
], // MPEG 1
[0, // Reserved
144, // Layer3
144, // Layer2
12 // Layer1
]];
var BytesInSlot = [0, // Reserved
1, // Layer3
1, // Layer2
4 // Layer1
];
function appendFrame(track, data, offset, pts, frameIndex) {
// Using http://www.datavoyage.com/mpgscript/mpeghdr.htm as a reference
if (offset + 24 > data.length) {
return;
}
var header = parseHeader(data, offset);
if (header && offset + header.frameLength <= data.length) {
var frameDuration = header.samplesPerFrame * 90000 / header.sampleRate;
var stamp = pts + frameIndex * frameDuration;
var sample = {
unit: data.subarray(offset, offset + header.frameLength),
pts: stamp,
dts: stamp
};
track.config = [];
track.channelCount = header.channelCount;
track.samplerate = header.sampleRate;
track.samples.push(sample);
return {
sample: sample,
length: header.frameLength,
missing: 0
};
}
}
function parseHeader(data, offset) {
var mpegVersion = data[offset + 1] >> 3 & 3;
var mpegLayer = data[offset + 1] >> 1 & 3;
var bitRateIndex = data[offset + 2] >> 4 & 15;
var sampleRateIndex = data[offset + 2] >> 2 & 3;
if (mpegVersion !== 1 && bitRateIndex !== 0 && bitRateIndex !== 15 && sampleRateIndex !== 3) {
var paddingBit = data[offset + 2] >> 1 & 1;
var channelMode = data[offset + 3] >> 6;
var columnInBitrates = mpegVersion === 3 ? 3 - mpegLayer : mpegLayer === 3 ? 3 : 4;
var bitRate = BitratesMap[columnInBitrates * 14 + bitRateIndex - 1] * 1000;
var columnInSampleRates = mpegVersion === 3 ? 0 : mpegVersion === 2 ? 1 : 2;
var sampleRate = SamplingRateMap[columnInSampleRates * 3 + sampleRateIndex];
var channelCount = channelMode === 3 ? 1 : 2; // If bits of channel mode are `11` then it is a single channel (Mono)
var sampleCoefficient = SamplesCoefficients[mpegVersion][mpegLayer];
var bytesInSlot = BytesInSlot[mpegLayer];
var samplesPerFrame = sampleCoefficient * 8 * bytesInSlot;
var frameLength = Math.floor(sampleCoefficient * bitRate / sampleRate + paddingBit) * bytesInSlot;
if (chromeVersion === null) {
var userAgent = navigator.userAgent || '';
var result = userAgent.match(/Chrome\/(\d+)/i);
chromeVersion = result ? parseInt(result[1]) : 0;
}
var needChromeFix = !!chromeVersion && chromeVersion <= 87;
if (needChromeFix && mpegLayer === 2 && bitRate >= 224000 && channelMode === 0) {
// Work around bug in Chromium by setting channelMode to dual-channel (01) instead of stereo (00)
data[offset + 3] = data[offset + 3] | 0x80;
}
return {
sampleRate: sampleRate,
channelCount: channelCount,
frameLength: frameLength,
samplesPerFrame: samplesPerFrame
};
}
}
function isHeaderPattern(data, offset) {
return data[offset] === 0xff && (data[offset + 1] & 0xe0) === 0xe0 && (data[offset + 1] & 0x06) !== 0x00;
}
function isHeader(data, offset) {
// Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either 0 or 1 and Y or Z should be 1
// Layer bits (position 14 and 15) in header should be always different from 0 (Layer I or Layer II or Layer III)
// More info http://www.mp3-tech.org/programmer/frame_header.html
return offset + 1 < data.length && isHeaderPattern(data, offset);
}
function canParse(data, offset) {
var headerSize = 4;
return isHeaderPattern(data, offset) && headerSize <= data.length - offset;
}
function probe(data, offset) {
// same as isHeader but we also check that MPEG frame follows last MPEG frame
// or end of data is reached
if (offset + 1 < data.length && isHeaderPattern(data, offset)) {
// MPEG header Length
var headerLength = 4; // MPEG frame Length
var header = parseHeader(data, offset);
var frameLength = headerLength;
if (header !== null && header !== void 0 && header.frameLength) {
frameLength = header.frameLength;
}
var newOffset = offset + frameLength;
return newOffset === data.length || isHeader(data, newOffset);
}
return false;
}
/***/ }),
/***/ "./src/demux/sample-aes.ts":
/*!*********************************!*\
!*** ./src/demux/sample-aes.ts ***!
\*********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _crypt_decrypter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../crypt/decrypter */ "./src/crypt/decrypter.ts");
/* harmony import */ var _tsdemuxer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./tsdemuxer */ "./src/demux/tsdemuxer.ts");
/**
* SAMPLE-AES decrypter
*/
var SampleAesDecrypter = /*#__PURE__*/function () {
function SampleAesDecrypter(observer, config, keyData) {
this.keyData = void 0;
this.decrypter = void 0;
this.keyData = keyData;
this.decrypter = new _crypt_decrypter__WEBPACK_IMPORTED_MODULE_0__["default"](observer, config, {
removePKCS7Padding: false
});
}
var _proto = SampleAesDecrypter.prototype;
_proto.decryptBuffer = function decryptBuffer(encryptedData, callback) {
this.decrypter.decrypt(encryptedData, this.keyData.key.buffer, this.keyData.iv.buffer, callback);
} // AAC - encrypt all full 16 bytes blocks starting from offset 16
;
_proto.decryptAacSample = function decryptAacSample(samples, sampleIndex, callback, sync) {
var curUnit = samples[sampleIndex].unit;
var encryptedData = curUnit.subarray(16, curUnit.length - curUnit.length % 16);
var encryptedBuffer = encryptedData.buffer.slice(encryptedData.byteOffset, encryptedData.byteOffset + encryptedData.length);
var localthis = this;
this.decryptBuffer(encryptedBuffer, function (decryptedBuffer) {
var decryptedData = new Uint8Array(decryptedBuffer);
curUnit.set(decryptedData, 16);
if (!sync) {
localthis.decryptAacSamples(samples, sampleIndex + 1, callback);
}
});
};
_proto.decryptAacSamples = function decryptAacSamples(samples, sampleIndex, callback) {
for (;; sampleIndex++) {
if (sampleIndex >= samples.length) {
callback();
return;
}
if (samples[sampleIndex].unit.length < 32) {
continue;
}
var sync = this.decrypter.isSync();
this.decryptAacSample(samples, sampleIndex, callback, sync);
if (!sync) {
return;
}
}
} // AVC - encrypt one 16 bytes block out of ten, starting from offset 32
;
_proto.getAvcEncryptedData = function getAvcEncryptedData(decodedData) {
var encryptedDataLen = Math.floor((decodedData.length - 48) / 160) * 16 + 16;
var encryptedData = new Int8Array(encryptedDataLen);
var outputPos = 0;
for (var inputPos = 32; inputPos <= decodedData.length - 16; inputPos += 160, outputPos += 16) {
encryptedData.set(decodedData.subarray(inputPos, inputPos + 16), outputPos);
}
return encryptedData;
};
_proto.getAvcDecryptedUnit = function getAvcDecryptedUnit(decodedData, decryptedData) {
var uint8DecryptedData = new Uint8Array(decryptedData);
var inputPos = 0;
for (var outputPos = 32; outputPos <= decodedData.length - 16; outputPos += 160, inputPos += 16) {
decodedData.set(uint8DecryptedData.subarray(inputPos, inputPos + 16), outputPos);
}
return decodedData;
};
_proto.decryptAvcSample = function decryptAvcSample(samples, sampleIndex, unitIndex, callback, curUnit, sync) {
var decodedData = Object(_tsdemuxer__WEBPACK_IMPORTED_MODULE_1__["discardEPB"])(curUnit.data);
var encryptedData = this.getAvcEncryptedData(decodedData);
var localthis = this;
this.decryptBuffer(encryptedData.buffer, function (decryptedBuffer) {
curUnit.data = localthis.getAvcDecryptedUnit(decodedData, decryptedBuffer);
if (!sync) {
localthis.decryptAvcSamples(samples, sampleIndex, unitIndex + 1, callback);
}
});
};
_proto.decryptAvcSamples = function decryptAvcSamples(samples, sampleIndex, unitIndex, callback) {
if (samples instanceof Uint8Array) {
throw new Error('Cannot decrypt samples of type Uint8Array');
}
for (;; sampleIndex++, unitIndex = 0) {
if (sampleIndex >= samples.length) {
callback();
return;
}
var curUnits = samples[sampleIndex].units;
for (;; unitIndex++) {
if (unitIndex >= curUnits.length) {
break;
}
var curUnit = curUnits[unitIndex];
if (curUnit.data.length <= 48 || curUnit.type !== 1 && curUnit.type !== 5) {
continue;
}
var sync = this.decrypter.isSync();
this.decryptAvcSample(samples, sampleIndex, unitIndex, callback, curUnit, sync);
if (!sync) {
return;
}
}
}
};
return SampleAesDecrypter;
}();
/* harmony default export */ __webpack_exports__["default"] = (SampleAesDecrypter);
/***/ }),
/***/ "./src/demux/transmuxer-interface.ts":
/*!*******************************************!*\
!*** ./src/demux/transmuxer-interface.ts ***!
\*******************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TransmuxerInterface; });
/* harmony import */ var webworkify_webpack__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! webworkify-webpack */ "./node_modules/webworkify-webpack/index.js");
/* harmony import */ var webworkify_webpack__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(webworkify_webpack__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _demux_transmuxer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../demux/transmuxer */ "./src/demux/transmuxer.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_mediasource_helper__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/mediasource-helper */ "./src/utils/mediasource-helper.ts");
/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! eventemitter3 */ "./node_modules/eventemitter3/index.js");
/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(eventemitter3__WEBPACK_IMPORTED_MODULE_6__);
var MediaSource = Object(_utils_mediasource_helper__WEBPACK_IMPORTED_MODULE_5__["getMediaSource"])() || {
isTypeSupported: function isTypeSupported() {
return false;
}
};
var TransmuxerInterface = /*#__PURE__*/function () {
function TransmuxerInterface(hls, id, onTransmuxComplete, onFlush) {
var _this = this;
this.hls = void 0;
this.id = void 0;
this.observer = void 0;
this.frag = null;
this.part = null;
this.worker = void 0;
this.onwmsg = void 0;
this.transmuxer = null;
this.onTransmuxComplete = void 0;
this.onFlush = void 0;
this.hls = hls;
this.id = id;
this.onTransmuxComplete = onTransmuxComplete;
this.onFlush = onFlush;
var config = hls.config;
var forwardMessage = function forwardMessage(ev, data) {
data = data || {};
data.frag = _this.frag;
data.id = _this.id;
hls.trigger(ev, data);
}; // forward events to main thread
this.observer = new eventemitter3__WEBPACK_IMPORTED_MODULE_6__["EventEmitter"]();
this.observer.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_DECRYPTED, forwardMessage);
this.observer.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, forwardMessage);
var typeSupported = {
mp4: MediaSource.isTypeSupported('video/mp4'),
mpeg: MediaSource.isTypeSupported('audio/mpeg'),
mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"')
}; // navigator.vendor is not always available in Web Worker
// refer to https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/navigator
var vendor = navigator.vendor;
if (config.enableWorker && typeof Worker !== 'undefined') {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].log('demuxing in webworker');
var worker;
try {
worker = this.worker = webworkify_webpack__WEBPACK_IMPORTED_MODULE_0__(/*require.resolve*/(/*! ../demux/transmuxer-worker.ts */ "./src/demux/transmuxer-worker.ts"));
this.onwmsg = this.onWorkerMessage.bind(this);
worker.addEventListener('message', this.onwmsg);
worker.onerror = function (event) {
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorTypes"].OTHER_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorDetails"].INTERNAL_EXCEPTION,
fatal: true,
event: 'demuxerWorker',
error: new Error(event.message + " (" + event.filename + ":" + event.lineno + ")")
});
};
worker.postMessage({
cmd: 'init',
typeSupported: typeSupported,
vendor: vendor,
id: id,
config: JSON.stringify(config)
});
} catch (err) {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn('Error in worker:', err);
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].error('Error while initializing DemuxerWorker, fallback to inline');
if (worker) {
// revoke the Object URL that was used to create transmuxer worker, so as not to leak it
self.URL.revokeObjectURL(worker.objectURL);
}
this.transmuxer = new _demux_transmuxer__WEBPACK_IMPORTED_MODULE_2__["default"](this.observer, typeSupported, config, vendor, id);
this.worker = null;
}
} else {
this.transmuxer = new _demux_transmuxer__WEBPACK_IMPORTED_MODULE_2__["default"](this.observer, typeSupported, config, vendor, id);
}
}
var _proto = TransmuxerInterface.prototype;
_proto.destroy = function destroy() {
var w = this.worker;
if (w) {
w.removeEventListener('message', this.onwmsg);
w.terminate();
this.worker = null;
} else {
var transmuxer = this.transmuxer;
if (transmuxer) {
transmuxer.destroy();
this.transmuxer = null;
}
}
var observer = this.observer;
if (observer) {
observer.removeAllListeners();
} // @ts-ignore
this.observer = null;
};
_proto.push = function push(data, initSegmentData, audioCodec, videoCodec, frag, part, duration, accurateTimeOffset, chunkMeta, defaultInitPTS) {
var _this2 = this;
chunkMeta.transmuxing.start = self.performance.now();
var transmuxer = this.transmuxer,
worker = this.worker;
var timeOffset = part ? part.start : frag.start;
var decryptdata = frag.decryptdata;
var lastFrag = this.frag;
var discontinuity = !(lastFrag && frag.cc === lastFrag.cc);
var trackSwitch = !(lastFrag && chunkMeta.level === lastFrag.level);
var snDiff = lastFrag ? chunkMeta.sn - lastFrag.sn : -1;
var partDiff = this.part ? chunkMeta.part - this.part.index : 1;
var contiguous = !trackSwitch && (snDiff === 1 || snDiff === 0 && partDiff === 1);
var now = self.performance.now();
if (trackSwitch || snDiff || frag.stats.parsing.start === 0) {
frag.stats.parsing.start = now;
}
if (part && (partDiff || !contiguous)) {
part.stats.parsing.start = now;
}
var state = new _demux_transmuxer__WEBPACK_IMPORTED_MODULE_2__["TransmuxState"](discontinuity, contiguous, accurateTimeOffset, trackSwitch, timeOffset);
if (!contiguous || discontinuity) {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].log("[transmuxer-interface, " + frag.type + "]: Starting new transmux session for sn: " + chunkMeta.sn + " p: " + chunkMeta.part + " level: " + chunkMeta.level + " id: " + chunkMeta.id + "\n discontinuity: " + discontinuity + "\n trackSwitch: " + trackSwitch + "\n contiguous: " + contiguous + "\n accurateTimeOffset: " + accurateTimeOffset + "\n timeOffset: " + timeOffset);
var config = new _demux_transmuxer__WEBPACK_IMPORTED_MODULE_2__["TransmuxConfig"](audioCodec, videoCodec, initSegmentData, duration, defaultInitPTS);
this.configureTransmuxer(config);
}
this.frag = frag;
this.part = part; // Frags with sn of 'initSegment' are not transmuxed
if (worker) {
// post fragment payload as transferable objects for ArrayBuffer (no copy)
worker.postMessage({
cmd: 'demux',
data: data,
decryptdata: decryptdata,
chunkMeta: chunkMeta,
state: state
}, data instanceof ArrayBuffer ? [data] : []);
} else if (transmuxer) {
var _transmuxResult = transmuxer.push(data, decryptdata, chunkMeta, state);
if (Object(_demux_transmuxer__WEBPACK_IMPORTED_MODULE_2__["isPromise"])(_transmuxResult)) {
_transmuxResult.then(function (data) {
_this2.handleTransmuxComplete(data);
});
} else {
this.handleTransmuxComplete(_transmuxResult);
}
}
};
_proto.flush = function flush(chunkMeta) {
var _this3 = this;
chunkMeta.transmuxing.start = self.performance.now();
var transmuxer = this.transmuxer,
worker = this.worker;
if (worker) {
worker.postMessage({
cmd: 'flush',
chunkMeta: chunkMeta
});
} else if (transmuxer) {
var _transmuxResult2 = transmuxer.flush(chunkMeta);
if (Object(_demux_transmuxer__WEBPACK_IMPORTED_MODULE_2__["isPromise"])(_transmuxResult2)) {
_transmuxResult2.then(function (data) {
_this3.handleFlushResult(data, chunkMeta);
});
} else {
this.handleFlushResult(_transmuxResult2, chunkMeta);
}
}
};
_proto.handleFlushResult = function handleFlushResult(results, chunkMeta) {
var _this4 = this;
results.forEach(function (result) {
_this4.handleTransmuxComplete(result);
});
this.onFlush(chunkMeta);
};
_proto.onWorkerMessage = function onWorkerMessage(ev) {
var data = ev.data;
var hls = this.hls;
switch (data.event) {
case 'init':
{
// revoke the Object URL that was used to create transmuxer worker, so as not to leak it
self.URL.revokeObjectURL(this.worker.objectURL);
break;
}
case 'transmuxComplete':
{
this.handleTransmuxComplete(data.data);
break;
}
case 'flush':
{
this.onFlush(data.data);
break;
}
/* falls through */
default:
{
data.data = data.data || {};
data.data.frag = this.frag;
data.data.id = this.id;
hls.trigger(data.event, data.data);
break;
}
}
};
_proto.configureTransmuxer = function configureTransmuxer(config) {
var worker = this.worker,
transmuxer = this.transmuxer;
if (worker) {
worker.postMessage({
cmd: 'configure',
config: config
});
} else if (transmuxer) {
transmuxer.configure(config);
}
};
_proto.handleTransmuxComplete = function handleTransmuxComplete(result) {
result.chunkMeta.transmuxing.end = self.performance.now();
this.onTransmuxComplete(result);
};
return TransmuxerInterface;
}();
/***/ }),
/***/ "./src/demux/transmuxer-worker.ts":
/*!****************************************!*\
!*** ./src/demux/transmuxer-worker.ts ***!
\****************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TransmuxerWorker; });
/* harmony import */ var _demux_transmuxer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../demux/transmuxer */ "./src/demux/transmuxer.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! eventemitter3 */ "./node_modules/eventemitter3/index.js");
/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(eventemitter3__WEBPACK_IMPORTED_MODULE_3__);
function TransmuxerWorker(self) {
var observer = new eventemitter3__WEBPACK_IMPORTED_MODULE_3__["EventEmitter"]();
var forwardMessage = function forwardMessage(ev, data) {
self.postMessage({
event: ev,
data: data
});
}; // forward events to main thread
observer.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].FRAG_DECRYPTED, forwardMessage);
observer.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, forwardMessage);
self.addEventListener('message', function (ev) {
var data = ev.data;
switch (data.cmd) {
case 'init':
{
var config = JSON.parse(data.config);
self.transmuxer = new _demux_transmuxer__WEBPACK_IMPORTED_MODULE_0__["default"](observer, data.typeSupported, config, data.vendor, data.id);
Object(_utils_logger__WEBPACK_IMPORTED_MODULE_2__["enableLogs"])(config.debug);
forwardMessage('init', null);
break;
}
case 'configure':
{
self.transmuxer.configure(data.config);
break;
}
case 'demux':
{
var transmuxResult = self.transmuxer.push(data.data, data.decryptdata, data.chunkMeta, data.state);
if (Object(_demux_transmuxer__WEBPACK_IMPORTED_MODULE_0__["isPromise"])(transmuxResult)) {
transmuxResult.then(function (data) {
emitTransmuxComplete(self, data);
});
} else {
emitTransmuxComplete(self, transmuxResult);
}
break;
}
case 'flush':
{
var id = data.chunkMeta;
var _transmuxResult = self.transmuxer.flush(id);
if (Object(_demux_transmuxer__WEBPACK_IMPORTED_MODULE_0__["isPromise"])(_transmuxResult)) {
_transmuxResult.then(function (results) {
handleFlushResult(self, results, id);
});
} else {
handleFlushResult(self, _transmuxResult, id);
}
break;
}
default:
break;
}
});
}
function emitTransmuxComplete(self, transmuxResult) {
if (isEmptyResult(transmuxResult.remuxResult)) {
return;
}
var transferable = [];
var _transmuxResult$remux = transmuxResult.remuxResult,
audio = _transmuxResult$remux.audio,
video = _transmuxResult$remux.video;
if (audio) {
addToTransferable(transferable, audio);
}
if (video) {
addToTransferable(transferable, video);
}
self.postMessage({
event: 'transmuxComplete',
data: transmuxResult
}, transferable);
} // Converts data to a transferable object https://developers.google.com/web/updates/2011/12/Transferable-Objects-Lightning-Fast)
// in order to minimize message passing overhead
function addToTransferable(transferable, track) {
if (track.data1) {
transferable.push(track.data1.buffer);
}
if (track.data2) {
transferable.push(track.data2.buffer);
}
}
function handleFlushResult(self, results, chunkMeta) {
results.forEach(function (result) {
emitTransmuxComplete(self, result);
});
self.postMessage({
event: 'flush',
data: chunkMeta
});
}
function isEmptyResult(remuxResult) {
return !remuxResult.audio && !remuxResult.video && !remuxResult.text && !remuxResult.id3 && !remuxResult.initSegment;
}
/***/ }),
/***/ "./src/demux/transmuxer.ts":
/*!*********************************!*\
!*** ./src/demux/transmuxer.ts ***!
\*********************************/
/*! exports provided: default, isPromise, TransmuxConfig, TransmuxState */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Transmuxer; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isPromise", function() { return isPromise; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TransmuxConfig", function() { return TransmuxConfig; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "TransmuxState", function() { return TransmuxState; });
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _crypt_decrypter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../crypt/decrypter */ "./src/crypt/decrypter.ts");
/* harmony import */ var _demux_aacdemuxer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../demux/aacdemuxer */ "./src/demux/aacdemuxer.ts");
/* harmony import */ var _demux_mp4demuxer__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../demux/mp4demuxer */ "./src/demux/mp4demuxer.ts");
/* harmony import */ var _demux_tsdemuxer__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../demux/tsdemuxer */ "./src/demux/tsdemuxer.ts");
/* harmony import */ var _demux_mp3demuxer__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../demux/mp3demuxer */ "./src/demux/mp3demuxer.ts");
/* harmony import */ var _remux_mp4_remuxer__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../remux/mp4-remuxer */ "./src/remux/mp4-remuxer.ts");
/* harmony import */ var _remux_passthrough_remuxer__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../remux/passthrough-remuxer */ "./src/remux/passthrough-remuxer.ts");
/* harmony import */ var _chunk_cache__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./chunk-cache */ "./src/demux/chunk-cache.ts");
/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
var now; // performance.now() not available on WebWorker, at least on Safari Desktop
try {
now = self.performance.now.bind(self.performance);
} catch (err) {
_utils_logger__WEBPACK_IMPORTED_MODULE_11__["logger"].debug('Unable to use Performance API on this environment');
now = self.Date.now;
}
var muxConfig = [{
demux: _demux_tsdemuxer__WEBPACK_IMPORTED_MODULE_5__["default"],
remux: _remux_mp4_remuxer__WEBPACK_IMPORTED_MODULE_7__["default"]
}, {
demux: _demux_mp4demuxer__WEBPACK_IMPORTED_MODULE_4__["default"],
remux: _remux_passthrough_remuxer__WEBPACK_IMPORTED_MODULE_8__["default"]
}, {
demux: _demux_aacdemuxer__WEBPACK_IMPORTED_MODULE_3__["default"],
remux: _remux_mp4_remuxer__WEBPACK_IMPORTED_MODULE_7__["default"]
}, {
demux: _demux_mp3demuxer__WEBPACK_IMPORTED_MODULE_6__["default"],
remux: _remux_mp4_remuxer__WEBPACK_IMPORTED_MODULE_7__["default"]
}];
var minProbeByteLength = 1024;
muxConfig.forEach(function (_ref) {
var demux = _ref.demux;
minProbeByteLength = Math.max(minProbeByteLength, demux.minProbeByteLength);
});
var Transmuxer = /*#__PURE__*/function () {
function Transmuxer(observer, typeSupported, config, vendor, id) {
this.observer = void 0;
this.typeSupported = void 0;
this.config = void 0;
this.vendor = void 0;
this.id = void 0;
this.demuxer = void 0;
this.remuxer = void 0;
this.decrypter = void 0;
this.probe = void 0;
this.decryptionPromise = null;
this.transmuxConfig = void 0;
this.currentTransmuxState = void 0;
this.cache = new _chunk_cache__WEBPACK_IMPORTED_MODULE_9__["default"]();
this.observer = observer;
this.typeSupported = typeSupported;
this.config = config;
this.vendor = vendor;
this.id = id;
}
var _proto = Transmuxer.prototype;
_proto.configure = function configure(transmuxConfig) {
this.transmuxConfig = transmuxConfig;
if (this.decrypter) {
this.decrypter.reset();
}
};
_proto.push = function push(data, decryptdata, chunkMeta, state) {
var _this = this;
var stats = chunkMeta.transmuxing;
stats.executeStart = now();
var uintData = new Uint8Array(data);
var cache = this.cache,
config = this.config,
currentTransmuxState = this.currentTransmuxState,
transmuxConfig = this.transmuxConfig;
if (state) {
this.currentTransmuxState = state;
}
var keyData = getEncryptionType(uintData, decryptdata);
if (keyData && keyData.method === 'AES-128') {
var decrypter = this.getDecrypter(); // Software decryption is synchronous; webCrypto is not
if (config.enableSoftwareAES) {
// Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
// data is handled in the flush() call
var decryptedData = decrypter.softwareDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer);
if (!decryptedData) {
stats.executeEnd = now();
return emptyResult(chunkMeta);
}
uintData = new Uint8Array(decryptedData);
} else {
this.decryptionPromise = decrypter.webCryptoDecrypt(uintData, keyData.key.buffer, keyData.iv.buffer).then(function (decryptedData) {
// Calling push here is important; if flush() is called while this is still resolving, this ensures that
// the decrypted data has been transmuxed
var result = _this.push(decryptedData, null, chunkMeta);
_this.decryptionPromise = null;
return result;
});
return this.decryptionPromise;
}
}
var _ref2 = state || currentTransmuxState,
contiguous = _ref2.contiguous,
discontinuity = _ref2.discontinuity,
trackSwitch = _ref2.trackSwitch,
accurateTimeOffset = _ref2.accurateTimeOffset,
timeOffset = _ref2.timeOffset;
var audioCodec = transmuxConfig.audioCodec,
videoCodec = transmuxConfig.videoCodec,
defaultInitPts = transmuxConfig.defaultInitPts,
duration = transmuxConfig.duration,
initSegmentData = transmuxConfig.initSegmentData; // Reset muxers before probing to ensure that their state is clean, even if flushing occurs before a successful probe
if (discontinuity || trackSwitch) {
this.resetInitSegment(initSegmentData, audioCodec, videoCodec, duration);
}
if (discontinuity) {
this.resetInitialTimestamp(defaultInitPts);
}
if (!contiguous) {
this.resetContiguity();
}
if (this.needsProbing(uintData, discontinuity, trackSwitch)) {
if (cache.dataLength) {
var cachedData = cache.flush();
uintData = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_10__["appendUint8Array"])(cachedData, uintData);
}
this.configureTransmuxer(uintData, transmuxConfig);
}
var result = this.transmux(uintData, keyData, timeOffset, accurateTimeOffset, chunkMeta);
var currentState = this.currentTransmuxState;
currentState.contiguous = true;
currentState.discontinuity = false;
currentState.trackSwitch = false;
stats.executeEnd = now();
return result;
} // Due to data caching, flush calls can produce more than one TransmuxerResult (hence the Array type)
;
_proto.flush = function flush(chunkMeta) {
var _this2 = this;
var stats = chunkMeta.transmuxing;
stats.executeStart = now();
var decrypter = this.decrypter,
cache = this.cache,
currentTransmuxState = this.currentTransmuxState,
decryptionPromise = this.decryptionPromise;
if (decryptionPromise) {
// Upon resolution, the decryption promise calls push() and returns its TransmuxerResult up the stack. Therefore
// only flushing is required for async decryption
return decryptionPromise.then(function () {
return _this2.flush(chunkMeta);
});
}
var transmuxResults = [];
var timeOffset = currentTransmuxState.timeOffset;
if (decrypter) {
// The decrypter may have data cached, which needs to be demuxed. In this case we'll have two TransmuxResults
// This happens in the case that we receive only 1 push call for a segment (either for non-progressive downloads,
// or for progressive downloads with small segments)
var decryptedData = decrypter.flush();
if (decryptedData) {
// Push always returns a TransmuxerResult if decryptdata is null
transmuxResults.push(this.push(decryptedData, null, chunkMeta));
}
}
var bytesSeen = cache.dataLength;
cache.reset();
var demuxer = this.demuxer,
remuxer = this.remuxer;
if (!demuxer || !remuxer) {
// If probing failed, and each demuxer saw enough bytes to be able to probe, then Hls.js has been given content its not able to handle
if (bytesSeen >= minProbeByteLength) {
this.observer.emit(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, _events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].FRAG_PARSING_ERROR,
fatal: true,
reason: 'no demux matching with content found'
});
}
stats.executeEnd = now();
return [emptyResult(chunkMeta)];
}
var demuxResultOrPromise = demuxer.flush(timeOffset);
if (isPromise(demuxResultOrPromise)) {
// Decrypt final SAMPLE-AES samples
return demuxResultOrPromise.then(function (demuxResult) {
_this2.flushRemux(transmuxResults, demuxResult, chunkMeta);
return transmuxResults;
});
}
this.flushRemux(transmuxResults, demuxResultOrPromise, chunkMeta);
return transmuxResults;
};
_proto.flushRemux = function flushRemux(transmuxResults, demuxResult, chunkMeta) {
var audioTrack = demuxResult.audioTrack,
avcTrack = demuxResult.avcTrack,
id3Track = demuxResult.id3Track,
textTrack = demuxResult.textTrack;
var _this$currentTransmux = this.currentTransmuxState,
accurateTimeOffset = _this$currentTransmux.accurateTimeOffset,
timeOffset = _this$currentTransmux.timeOffset;
_utils_logger__WEBPACK_IMPORTED_MODULE_11__["logger"].log("[transmuxer.ts]: Flushed fragment " + chunkMeta.sn + (chunkMeta.part > -1 ? ' p: ' + chunkMeta.part : '') + " of level " + chunkMeta.level);
var remuxResult = this.remuxer.remux(audioTrack, avcTrack, id3Track, textTrack, timeOffset, accurateTimeOffset, true, this.id);
transmuxResults.push({
remuxResult: remuxResult,
chunkMeta: chunkMeta
});
chunkMeta.transmuxing.executeEnd = now();
};
_proto.resetInitialTimestamp = function resetInitialTimestamp(defaultInitPts) {
var demuxer = this.demuxer,
remuxer = this.remuxer;
if (!demuxer || !remuxer) {
return;
}
demuxer.resetTimeStamp(defaultInitPts);
remuxer.resetTimeStamp(defaultInitPts);
};
_proto.resetContiguity = function resetContiguity() {
var demuxer = this.demuxer,
remuxer = this.remuxer;
if (!demuxer || !remuxer) {
return;
}
demuxer.resetContiguity();
remuxer.resetNextTimestamp();
};
_proto.resetInitSegment = function resetInitSegment(initSegmentData, audioCodec, videoCodec, duration) {
var demuxer = this.demuxer,
remuxer = this.remuxer;
if (!demuxer || !remuxer) {
return;
}
demuxer.resetInitSegment(audioCodec, videoCodec, duration);
remuxer.resetInitSegment(initSegmentData, audioCodec, videoCodec);
};
_proto.destroy = function destroy() {
if (this.demuxer) {
this.demuxer.destroy();
this.demuxer = undefined;
}
if (this.remuxer) {
this.remuxer.destroy();
this.remuxer = undefined;
}
};
_proto.transmux = function transmux(data, keyData, timeOffset, accurateTimeOffset, chunkMeta) {
var result;
if (keyData && keyData.method === 'SAMPLE-AES') {
result = this.transmuxSampleAes(data, keyData, timeOffset, accurateTimeOffset, chunkMeta);
} else {
result = this.transmuxUnencrypted(data, timeOffset, accurateTimeOffset, chunkMeta);
}
return result;
};
_proto.transmuxUnencrypted = function transmuxUnencrypted(data, timeOffset, accurateTimeOffset, chunkMeta) {
var _demux = this.demuxer.demux(data, timeOffset, false, !this.config.progressive),
audioTrack = _demux.audioTrack,
avcTrack = _demux.avcTrack,
id3Track = _demux.id3Track,
textTrack = _demux.textTrack;
var remuxResult = this.remuxer.remux(audioTrack, avcTrack, id3Track, textTrack, timeOffset, accurateTimeOffset, false, this.id);
return {
remuxResult: remuxResult,
chunkMeta: chunkMeta
};
};
_proto.transmuxSampleAes = function transmuxSampleAes(data, decryptData, timeOffset, accurateTimeOffset, chunkMeta) {
var _this3 = this;
return this.demuxer.demuxSampleAes(data, decryptData, timeOffset).then(function (demuxResult) {
var remuxResult = _this3.remuxer.remux(demuxResult.audioTrack, demuxResult.avcTrack, demuxResult.id3Track, demuxResult.textTrack, timeOffset, accurateTimeOffset, false, _this3.id);
return {
remuxResult: remuxResult,
chunkMeta: chunkMeta
};
});
};
_proto.configureTransmuxer = function configureTransmuxer(data, transmuxConfig) {
var config = this.config,
observer = this.observer,
typeSupported = this.typeSupported,
vendor = this.vendor;
var audioCodec = transmuxConfig.audioCodec,
defaultInitPts = transmuxConfig.defaultInitPts,
duration = transmuxConfig.duration,
initSegmentData = transmuxConfig.initSegmentData,
videoCodec = transmuxConfig.videoCodec; // probe for content type
var mux;
for (var i = 0, len = muxConfig.length; i < len; i++) {
if (muxConfig[i].demux.probe(data)) {
mux = muxConfig[i];
break;
}
}
if (!mux) {
// If probing previous configs fail, use mp4 passthrough
_utils_logger__WEBPACK_IMPORTED_MODULE_11__["logger"].warn('Failed to find demuxer by probing frag, treating as mp4 passthrough');
mux = {
demux: _demux_mp4demuxer__WEBPACK_IMPORTED_MODULE_4__["default"],
remux: _remux_passthrough_remuxer__WEBPACK_IMPORTED_MODULE_8__["default"]
};
} // so let's check that current remuxer and demuxer are still valid
var demuxer = this.demuxer;
var remuxer = this.remuxer;
var Remuxer = mux.remux;
var Demuxer = mux.demux;
if (!remuxer || !(remuxer instanceof Remuxer)) {
this.remuxer = new Remuxer(observer, config, typeSupported, vendor);
}
if (!demuxer || !(demuxer instanceof Demuxer)) {
this.demuxer = new Demuxer(observer, config, typeSupported);
this.probe = Demuxer.probe;
} // Ensure that muxers are always initialized with an initSegment
this.resetInitSegment(initSegmentData, audioCodec, videoCodec, duration);
this.resetInitialTimestamp(defaultInitPts);
};
_proto.needsProbing = function needsProbing(data, discontinuity, trackSwitch) {
// in case of continuity change, or track switch
// we might switch from content type (AAC container to TS container, or TS to fmp4 for example)
return !this.demuxer || !this.remuxer || discontinuity || trackSwitch;
};
_proto.getDecrypter = function getDecrypter() {
var decrypter = this.decrypter;
if (!decrypter) {
decrypter = this.decrypter = new _crypt_decrypter__WEBPACK_IMPORTED_MODULE_2__["default"](this.observer, this.config);
}
return decrypter;
};
return Transmuxer;
}();
function getEncryptionType(data, decryptData) {
var encryptionType = null;
if (data.byteLength > 0 && decryptData != null && decryptData.key != null && decryptData.iv !== null && decryptData.method != null) {
encryptionType = decryptData;
}
return encryptionType;
}
var emptyResult = function emptyResult(chunkMeta) {
return {
remuxResult: {},
chunkMeta: chunkMeta
};
};
function isPromise(p) {
return 'then' in p && p.then instanceof Function;
}
var TransmuxConfig = function TransmuxConfig(audioCodec, videoCodec, initSegmentData, duration, defaultInitPts) {
this.audioCodec = void 0;
this.videoCodec = void 0;
this.initSegmentData = void 0;
this.duration = void 0;
this.defaultInitPts = void 0;
this.audioCodec = audioCodec;
this.videoCodec = videoCodec;
this.initSegmentData = initSegmentData;
this.duration = duration;
this.defaultInitPts = defaultInitPts;
};
var TransmuxState = function TransmuxState(discontinuity, contiguous, accurateTimeOffset, trackSwitch, timeOffset) {
this.discontinuity = void 0;
this.contiguous = void 0;
this.accurateTimeOffset = void 0;
this.trackSwitch = void 0;
this.timeOffset = void 0;
this.discontinuity = discontinuity;
this.contiguous = contiguous;
this.accurateTimeOffset = accurateTimeOffset;
this.trackSwitch = trackSwitch;
this.timeOffset = timeOffset;
};
/***/ }),
/***/ "./src/demux/tsdemuxer.ts":
/*!********************************!*\
!*** ./src/demux/tsdemuxer.ts ***!
\********************************/
/*! exports provided: discardEPB, default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "discardEPB", function() { return discardEPB; });
/* harmony import */ var _adts__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./adts */ "./src/demux/adts.ts");
/* harmony import */ var _mpegaudio__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./mpegaudio */ "./src/demux/mpegaudio.ts");
/* harmony import */ var _exp_golomb__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./exp-golomb */ "./src/demux/exp-golomb.ts");
/* harmony import */ var _id3__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./id3 */ "./src/demux/id3.ts");
/* harmony import */ var _sample_aes__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./sample-aes */ "./src/demux/sample-aes.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/**
* highly optimized TS demuxer:
* parse PAT, PMT
* extract PES packet from audio and video PIDs
* extract AVC/H264 NAL units and AAC/ADTS samples from PES packet
* trigger the remuxer upon parsing completion
* it also tries to workaround as best as it can audio codec switch (HE-AAC to AAC and vice versa), without having to restart the MediaSource.
* it also controls the remuxing process :
* upon discontinuity or level switch detection, it will also notifies the remuxer so that it can reset its state.
*/
// We are using fixed track IDs for driving the MP4 remuxer
// instead of following the TS PIDs.
// There is no reason not to do this and some browsers/SourceBuffer-demuxers
// may not like if there are TrackID "switches"
// See https://github.com/video-dev/hls.js/issues/1331
// Here we are mapping our internal track types to constant MP4 track IDs
// With MSE currently one can only have one track of each, and we are muxing
// whatever video/audio rendition in them.
var RemuxerTrackIdConfig = {
video: 1,
audio: 2,
id3: 3,
text: 4
};
var TSDemuxer = /*#__PURE__*/function () {
function TSDemuxer(observer, config, typeSupported) {
this.observer = void 0;
this.config = void 0;
this.typeSupported = void 0;
this.sampleAes = null;
this.pmtParsed = false;
this.audioCodec = void 0;
this.videoCodec = void 0;
this._duration = 0;
this.aacLastPTS = null;
this._initPTS = null;
this._initDTS = null;
this._pmtId = -1;
this._avcTrack = void 0;
this._audioTrack = void 0;
this._id3Track = void 0;
this._txtTrack = void 0;
this.aacOverFlow = null;
this.avcSample = null;
this.remainderData = null;
this.observer = observer;
this.config = config;
this.typeSupported = typeSupported;
}
TSDemuxer.probe = function probe(data) {
var syncOffset = TSDemuxer.syncOffset(data);
if (syncOffset < 0) {
return false;
} else {
if (syncOffset) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].warn("MPEG2-TS detected but first sync word found @ offset " + syncOffset + ", junk ahead ?");
}
return true;
}
};
TSDemuxer.syncOffset = function syncOffset(data) {
// scan 1000 first bytes
var scanwindow = Math.min(1000, data.length - 3 * 188);
var i = 0;
while (i < scanwindow) {
// a TS fragment should contain at least 3 TS packets, a PAT, a PMT, and one PID, each starting with 0x47
if (data[i] === 0x47 && data[i + 188] === 0x47 && data[i + 2 * 188] === 0x47) {
return i;
} else {
i++;
}
}
return -1;
}
/**
* Creates a track model internal to demuxer used to drive remuxing input
*
* @param type 'audio' | 'video' | 'id3' | 'text'
* @param duration
* @return TSDemuxer's internal track model
*/
;
TSDemuxer.createTrack = function createTrack(type, duration) {
return {
container: type === 'video' || type === 'audio' ? 'video/mp2t' : undefined,
type: type,
id: RemuxerTrackIdConfig[type],
pid: -1,
inputTimeScale: 90000,
sequenceNumber: 0,
samples: [],
dropped: 0,
duration: type === 'audio' ? duration : undefined
};
}
/**
* Initializes a new init segment on the demuxer/remuxer interface. Needed for discontinuities/track-switches (or at stream start)
* Resets all internal track instances of the demuxer.
*/
;
var _proto = TSDemuxer.prototype;
_proto.resetInitSegment = function resetInitSegment(audioCodec, videoCodec, duration) {
this.pmtParsed = false;
this._pmtId = -1;
this._avcTrack = TSDemuxer.createTrack('video', duration);
this._audioTrack = TSDemuxer.createTrack('audio', duration);
this._id3Track = TSDemuxer.createTrack('id3', duration);
this._txtTrack = TSDemuxer.createTrack('text', duration);
this._audioTrack.isAAC = true; // flush any partial content
this.aacOverFlow = null;
this.aacLastPTS = null;
this.avcSample = null;
this.audioCodec = audioCodec;
this.videoCodec = videoCodec;
this._duration = duration;
};
_proto.resetTimeStamp = function resetTimeStamp() {};
_proto.resetContiguity = function resetContiguity() {
var _audioTrack = this._audioTrack,
_avcTrack = this._avcTrack,
_id3Track = this._id3Track;
if (_audioTrack) {
_audioTrack.pesData = null;
}
if (_avcTrack) {
_avcTrack.pesData = null;
}
if (_id3Track) {
_id3Track.pesData = null;
}
this.aacOverFlow = null;
this.aacLastPTS = null;
};
_proto.demux = function demux(data, timeOffset, isSampleAes, flush) {
if (isSampleAes === void 0) {
isSampleAes = false;
}
if (flush === void 0) {
flush = false;
}
if (!isSampleAes) {
this.sampleAes = null;
}
var pes;
var avcTrack = this._avcTrack;
var audioTrack = this._audioTrack;
var id3Track = this._id3Track;
var avcId = avcTrack.pid;
var avcData = avcTrack.pesData;
var audioId = audioTrack.pid;
var id3Id = id3Track.pid;
var audioData = audioTrack.pesData;
var id3Data = id3Track.pesData;
var unknownPIDs = false;
var pmtParsed = this.pmtParsed;
var pmtId = this._pmtId;
var len = data.length;
if (this.remainderData) {
data = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_6__["appendUint8Array"])(this.remainderData, data);
len = data.length;
this.remainderData = null;
}
if (len < 188 && !flush) {
this.remainderData = data;
return {
audioTrack: audioTrack,
avcTrack: avcTrack,
id3Track: id3Track,
textTrack: this._txtTrack
};
}
var syncOffset = Math.max(0, TSDemuxer.syncOffset(data));
len -= (len + syncOffset) % 188;
if (len < data.byteLength && !flush) {
this.remainderData = new Uint8Array(data.buffer, len, data.buffer.byteLength - len);
} // loop through TS packets
for (var start = syncOffset; start < len; start += 188) {
if (data[start] === 0x47) {
var stt = !!(data[start + 1] & 0x40); // pid is a 13-bit field starting at the last bit of TS[1]
var pid = ((data[start + 1] & 0x1f) << 8) + data[start + 2];
var atf = (data[start + 3] & 0x30) >> 4; // if an adaption field is present, its length is specified by the fifth byte of the TS packet header.
var offset = void 0;
if (atf > 1) {
offset = start + 5 + data[start + 4]; // continue if there is only adaptation field
if (offset === start + 188) {
continue;
}
} else {
offset = start + 4;
}
switch (pid) {
case avcId:
if (stt) {
if (avcData && (pes = parsePES(avcData))) {
this.parseAVCPES(pes, false);
}
avcData = {
data: [],
size: 0
};
}
if (avcData) {
avcData.data.push(data.subarray(offset, start + 188));
avcData.size += start + 188 - offset;
}
break;
case audioId:
if (stt) {
if (audioData && (pes = parsePES(audioData))) {
if (audioTrack.isAAC) {
this.parseAACPES(pes);
} else {
this.parseMPEGPES(pes);
}
}
audioData = {
data: [],
size: 0
};
}
if (audioData) {
audioData.data.push(data.subarray(offset, start + 188));
audioData.size += start + 188 - offset;
}
break;
case id3Id:
if (stt) {
if (id3Data && (pes = parsePES(id3Data))) {
this.parseID3PES(pes);
}
id3Data = {
data: [],
size: 0
};
}
if (id3Data) {
id3Data.data.push(data.subarray(offset, start + 188));
id3Data.size += start + 188 - offset;
}
break;
case 0:
if (stt) {
offset += data[offset] + 1;
}
pmtId = this._pmtId = parsePAT(data, offset);
break;
case pmtId:
{
if (stt) {
offset += data[offset] + 1;
}
var parsedPIDs = parsePMT(data, offset, this.typeSupported.mpeg === true || this.typeSupported.mp3 === true, isSampleAes); // only update track id if track PID found while parsing PMT
// this is to avoid resetting the PID to -1 in case
// track PID transiently disappears from the stream
// this could happen in case of transient missing audio samples for example
// NOTE this is only the PID of the track as found in TS,
// but we are not using this for MP4 track IDs.
avcId = parsedPIDs.avc;
if (avcId > 0) {
avcTrack.pid = avcId;
}
audioId = parsedPIDs.audio;
if (audioId > 0) {
audioTrack.pid = audioId;
audioTrack.isAAC = parsedPIDs.isAAC;
}
id3Id = parsedPIDs.id3;
if (id3Id > 0) {
id3Track.pid = id3Id;
}
if (unknownPIDs && !pmtParsed) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].log('reparse from beginning');
unknownPIDs = false; // we set it to -188, the += 188 in the for loop will reset start to 0
start = syncOffset - 188;
}
pmtParsed = this.pmtParsed = true;
break;
}
case 17:
case 0x1fff:
break;
default:
unknownPIDs = true;
break;
}
} else {
this.observer.emit(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].ERROR, _events__WEBPACK_IMPORTED_MODULE_5__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_8__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_8__["ErrorDetails"].FRAG_PARSING_ERROR,
fatal: false,
reason: 'TS packet did not start with 0x47'
});
}
}
avcTrack.pesData = avcData;
audioTrack.pesData = audioData;
id3Track.pesData = id3Data;
var demuxResult = {
audioTrack: audioTrack,
avcTrack: avcTrack,
id3Track: id3Track,
textTrack: this._txtTrack
};
if (flush) {
this.extractRemainingSamples(demuxResult);
}
return demuxResult;
};
_proto.flush = function flush() {
var remainderData = this.remainderData;
this.remainderData = null;
var result;
if (remainderData) {
result = this.demux(remainderData, -1, false, true);
} else {
result = {
audioTrack: this._audioTrack,
avcTrack: this._avcTrack,
textTrack: this._txtTrack,
id3Track: this._id3Track
};
}
this.extractRemainingSamples(result);
if (this.sampleAes) {
return this.decrypt(result, this.sampleAes);
}
return result;
};
_proto.extractRemainingSamples = function extractRemainingSamples(demuxResult) {
var audioTrack = demuxResult.audioTrack,
avcTrack = demuxResult.avcTrack,
id3Track = demuxResult.id3Track;
var avcData = avcTrack.pesData;
var audioData = audioTrack.pesData;
var id3Data = id3Track.pesData; // try to parse last PES packets
var pes;
if (avcData && (pes = parsePES(avcData))) {
this.parseAVCPES(pes, true);
avcTrack.pesData = null;
} else {
// either avcData null or PES truncated, keep it for next frag parsing
avcTrack.pesData = avcData;
}
if (audioData && (pes = parsePES(audioData))) {
if (audioTrack.isAAC) {
this.parseAACPES(pes);
} else {
this.parseMPEGPES(pes);
}
audioTrack.pesData = null;
} else {
if (audioData !== null && audioData !== void 0 && audioData.size) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].log('last AAC PES packet truncated,might overlap between fragments');
} // either audioData null or PES truncated, keep it for next frag parsing
audioTrack.pesData = audioData;
}
if (id3Data && (pes = parsePES(id3Data))) {
this.parseID3PES(pes);
id3Track.pesData = null;
} else {
// either id3Data null or PES truncated, keep it for next frag parsing
id3Track.pesData = id3Data;
}
};
_proto.demuxSampleAes = function demuxSampleAes(data, keyData, timeOffset) {
var demuxResult = this.demux(data, timeOffset, true, !this.config.progressive);
var sampleAes = this.sampleAes = new _sample_aes__WEBPACK_IMPORTED_MODULE_4__["default"](this.observer, this.config, keyData);
return this.decrypt(demuxResult, sampleAes);
};
_proto.decrypt = function decrypt(demuxResult, sampleAes) {
return new Promise(function (resolve) {
var audioTrack = demuxResult.audioTrack,
avcTrack = demuxResult.avcTrack;
if (audioTrack.samples && audioTrack.isAAC) {
sampleAes.decryptAacSamples(audioTrack.samples, 0, function () {
if (avcTrack.samples) {
sampleAes.decryptAvcSamples(avcTrack.samples, 0, 0, function () {
resolve(demuxResult);
});
} else {
resolve(demuxResult);
}
});
} else if (avcTrack.samples) {
sampleAes.decryptAvcSamples(avcTrack.samples, 0, 0, function () {
resolve(demuxResult);
});
}
});
};
_proto.destroy = function destroy() {
this._initPTS = this._initDTS = null;
this._duration = 0;
};
_proto.parseAVCPES = function parseAVCPES(pes, last) {
var _this = this;
var track = this._avcTrack;
var units = this.parseAVCNALu(pes.data);
var debug = false;
var avcSample = this.avcSample;
var push;
var spsfound = false; // free pes.data to save up some memory
pes.data = null; // if new NAL units found and last sample still there, let's push ...
// this helps parsing streams with missing AUD (only do this if AUD never found)
if (avcSample && units.length && !track.audFound) {
pushAccessUnit(avcSample, track);
avcSample = this.avcSample = createAVCSample(false, pes.pts, pes.dts, '');
}
units.forEach(function (unit) {
switch (unit.type) {
// NDR
case 1:
{
push = true;
if (!avcSample) {
avcSample = _this.avcSample = createAVCSample(true, pes.pts, pes.dts, '');
}
if (debug) {
avcSample.debug += 'NDR ';
}
avcSample.frame = true;
var data = unit.data; // only check slice type to detect KF in case SPS found in same packet (any keyframe is preceded by SPS ...)
if (spsfound && data.length > 4) {
// retrieve slice type by parsing beginning of NAL unit (follow H264 spec, slice_header definition) to detect keyframe embedded in NDR
var sliceType = new _exp_golomb__WEBPACK_IMPORTED_MODULE_2__["default"](data).readSliceType(); // 2 : I slice, 4 : SI slice, 7 : I slice, 9: SI slice
// SI slice : A slice that is coded using intra prediction only and using quantisation of the prediction samples.
// An SI slice can be coded such that its decoded samples can be constructed identically to an SP slice.
// I slice: A slice that is not an SI slice that is decoded using intra prediction only.
// if (sliceType === 2 || sliceType === 7) {
if (sliceType === 2 || sliceType === 4 || sliceType === 7 || sliceType === 9) {
avcSample.key = true;
}
}
break; // IDR
}
case 5:
push = true; // handle PES not starting with AUD
if (!avcSample) {
avcSample = _this.avcSample = createAVCSample(true, pes.pts, pes.dts, '');
}
if (debug) {
avcSample.debug += 'IDR ';
}
avcSample.key = true;
avcSample.frame = true;
break;
// SEI
case 6:
{
push = true;
if (debug && avcSample) {
avcSample.debug += 'SEI ';
}
var expGolombDecoder = new _exp_golomb__WEBPACK_IMPORTED_MODULE_2__["default"](discardEPB(unit.data)); // skip frameType
expGolombDecoder.readUByte();
var payloadType = 0;
var payloadSize = 0;
var endOfCaptions = false;
var b = 0;
while (!endOfCaptions && expGolombDecoder.bytesAvailable > 1) {
payloadType = 0;
do {
b = expGolombDecoder.readUByte();
payloadType += b;
} while (b === 0xff); // Parse payload size.
payloadSize = 0;
do {
b = expGolombDecoder.readUByte();
payloadSize += b;
} while (b === 0xff); // TODO: there can be more than one payload in an SEI packet...
// TODO: need to read type and size in a while loop to get them all
if (payloadType === 4 && expGolombDecoder.bytesAvailable !== 0) {
endOfCaptions = true;
var countryCode = expGolombDecoder.readUByte();
if (countryCode === 181) {
var providerCode = expGolombDecoder.readUShort();
if (providerCode === 49) {
var userStructure = expGolombDecoder.readUInt();
if (userStructure === 0x47413934) {
var userDataType = expGolombDecoder.readUByte(); // Raw CEA-608 bytes wrapped in CEA-708 packet
if (userDataType === 3) {
var firstByte = expGolombDecoder.readUByte();
var secondByte = expGolombDecoder.readUByte();
var totalCCs = 31 & firstByte;
var byteArray = [firstByte, secondByte];
for (var i = 0; i < totalCCs; i++) {
// 3 bytes per CC
byteArray.push(expGolombDecoder.readUByte());
byteArray.push(expGolombDecoder.readUByte());
byteArray.push(expGolombDecoder.readUByte());
}
insertSampleInOrder(_this._txtTrack.samples, {
type: 3,
pts: pes.pts,
bytes: byteArray
});
}
}
}
}
} else if (payloadType === 5 && expGolombDecoder.bytesAvailable !== 0) {
endOfCaptions = true;
if (payloadSize > 16) {
var uuidStrArray = [];
for (var _i = 0; _i < 16; _i++) {
uuidStrArray.push(expGolombDecoder.readUByte().toString(16));
if (_i === 3 || _i === 5 || _i === 7 || _i === 9) {
uuidStrArray.push('-');
}
}
var length = payloadSize - 16;
var userDataPayloadBytes = new Uint8Array(length);
for (var _i2 = 0; _i2 < length; _i2++) {
userDataPayloadBytes[_i2] = expGolombDecoder.readUByte();
}
insertSampleInOrder(_this._txtTrack.samples, {
pts: pes.pts,
payloadType: payloadType,
uuid: uuidStrArray.join(''),
userData: Object(_id3__WEBPACK_IMPORTED_MODULE_3__["utf8ArrayToStr"])(userDataPayloadBytes),
userDataBytes: userDataPayloadBytes
});
}
} else if (payloadSize < expGolombDecoder.bytesAvailable) {
for (var _i3 = 0; _i3 < payloadSize; _i3++) {
expGolombDecoder.readUByte();
}
}
}
break; // SPS
}
case 7:
push = true;
spsfound = true;
if (debug && avcSample) {
avcSample.debug += 'SPS ';
}
if (!track.sps) {
var _expGolombDecoder = new _exp_golomb__WEBPACK_IMPORTED_MODULE_2__["default"](unit.data);
var config = _expGolombDecoder.readSPS();
track.width = config.width;
track.height = config.height;
track.pixelRatio = config.pixelRatio; // TODO: `track.sps` is defined as a `number[]`, but we're setting it to a `Uint8Array[]`.
track.sps = [unit.data];
track.duration = _this._duration;
var codecarray = unit.data.subarray(1, 4);
var codecstring = 'avc1.';
for (var _i4 = 0; _i4 < 3; _i4++) {
var h = codecarray[_i4].toString(16);
if (h.length < 2) {
h = '0' + h;
}
codecstring += h;
}
track.codec = codecstring;
}
break;
// PPS
case 8:
push = true;
if (debug && avcSample) {
avcSample.debug += 'PPS ';
}
if (!track.pps) {
// TODO: `track.pss` is defined as a `number[]`, but we're setting it to a `Uint8Array[]`.
track.pps = [unit.data];
}
break;
// AUD
case 9:
push = false;
track.audFound = true;
if (avcSample) {
pushAccessUnit(avcSample, track);
}
avcSample = _this.avcSample = createAVCSample(false, pes.pts, pes.dts, debug ? 'AUD ' : '');
break;
// Filler Data
case 12:
push = false;
break;
default:
push = false;
if (avcSample) {
avcSample.debug += 'unknown NAL ' + unit.type + ' ';
}
break;
}
if (avcSample && push) {
var _units = avcSample.units;
_units.push(unit);
}
}); // if last PES packet, push samples
if (last && avcSample) {
pushAccessUnit(avcSample, track);
this.avcSample = null;
}
};
_proto.getLastNalUnit = function getLastNalUnit() {
var _avcSample;
var avcSample = this.avcSample;
var lastUnit; // try to fallback to previous sample if current one is empty
if (!avcSample || avcSample.units.length === 0) {
var samples = this._avcTrack.samples;
avcSample = samples[samples.length - 1];
}
if ((_avcSample = avcSample) !== null && _avcSample !== void 0 && _avcSample.units) {
var units = avcSample.units;
lastUnit = units[units.length - 1];
}
return lastUnit;
};
_proto.parseAVCNALu = function parseAVCNALu(array) {
var len = array.byteLength;
var track = this._avcTrack;
var state = track.naluState || 0;
var lastState = state;
var units = [];
var i = 0;
var value;
var overflow;
var unitType;
var lastUnitStart = -1;
var lastUnitType = 0; // logger.log('PES:' + Hex.hexDump(array));
if (state === -1) {
// special use case where we found 3 or 4-byte start codes exactly at the end of previous PES packet
lastUnitStart = 0; // NALu type is value read from offset 0
lastUnitType = array[0] & 0x1f;
state = 0;
i = 1;
}
while (i < len) {
value = array[i++]; // optimization. state 0 and 1 are the predominant case. let's handle them outside of the switch/case
if (!state) {
state = value ? 0 : 1;
continue;
}
if (state === 1) {
state = value ? 0 : 2;
continue;
} // here we have state either equal to 2 or 3
if (!value) {
state = 3;
} else if (value === 1) {
if (lastUnitStart >= 0) {
var unit = {
data: array.subarray(lastUnitStart, i - state - 1),
type: lastUnitType
}; // logger.log('pushing NALU, type/size:' + unit.type + '/' + unit.data.byteLength);
units.push(unit);
} else {
// lastUnitStart is undefined => this is the first start code found in this PES packet
// first check if start code delimiter is overlapping between 2 PES packets,
// ie it started in last packet (lastState not zero)
// and ended at the beginning of this PES packet (i <= 4 - lastState)
var lastUnit = this.getLastNalUnit();
if (lastUnit) {
if (lastState && i <= 4 - lastState) {
// start delimiter overlapping between PES packets
// strip start delimiter bytes from the end of last NAL unit
// check if lastUnit had a state different from zero
if (lastUnit.state) {
// strip last bytes
lastUnit.data = lastUnit.data.subarray(0, lastUnit.data.byteLength - lastState);
}
} // If NAL units are not starting right at the beginning of the PES packet, push preceding data into previous NAL unit.
overflow = i - state - 1;
if (overflow > 0) {
// logger.log('first NALU found with overflow:' + overflow);
var tmp = new Uint8Array(lastUnit.data.byteLength + overflow);
tmp.set(lastUnit.data, 0);
tmp.set(array.subarray(0, overflow), lastUnit.data.byteLength);
lastUnit.data = tmp;
}
}
} // check if we can read unit type
if (i < len) {
unitType = array[i] & 0x1f; // logger.log('find NALU @ offset:' + i + ',type:' + unitType);
lastUnitStart = i;
lastUnitType = unitType;
state = 0;
} else {
// not enough byte to read unit type. let's read it on next PES parsing
state = -1;
}
} else {
state = 0;
}
}
if (lastUnitStart >= 0 && state >= 0) {
var _unit = {
data: array.subarray(lastUnitStart, len),
type: lastUnitType,
state: state
};
units.push(_unit); // logger.log('pushing NALU, type/size/state:' + unit.type + '/' + unit.data.byteLength + '/' + state);
} // no NALu found
if (units.length === 0) {
// append pes.data to previous NAL unit
var _lastUnit = this.getLastNalUnit();
if (_lastUnit) {
var _tmp = new Uint8Array(_lastUnit.data.byteLength + array.byteLength);
_tmp.set(_lastUnit.data, 0);
_tmp.set(array, _lastUnit.data.byteLength);
_lastUnit.data = _tmp;
}
}
track.naluState = state;
return units;
};
_proto.parseAACPES = function parseAACPES(pes) {
var startOffset = 0;
var track = this._audioTrack;
var aacOverFlow = this.aacOverFlow;
var data = pes.data;
if (aacOverFlow) {
this.aacOverFlow = null;
var sampleLength = aacOverFlow.sample.unit.byteLength;
var frameMissingBytes = Math.min(aacOverFlow.missing, sampleLength);
var frameOverflowBytes = sampleLength - frameMissingBytes;
aacOverFlow.sample.unit.set(data.subarray(0, frameMissingBytes), frameOverflowBytes);
track.samples.push(aacOverFlow.sample); // logger.log(`AAC: append overflowing ${frameOverflowBytes} bytes to beginning of new PES`);
startOffset = aacOverFlow.missing;
} // look for ADTS header (0xFFFx)
var offset;
var len;
for (offset = startOffset, len = data.length; offset < len - 1; offset++) {
if (_adts__WEBPACK_IMPORTED_MODULE_0__["isHeader"](data, offset)) {
break;
}
} // if ADTS header does not start straight from the beginning of the PES payload, raise an error
if (offset !== startOffset) {
var reason;
var fatal;
if (offset < len - 1) {
reason = "AAC PES did not start with ADTS header,offset:" + offset;
fatal = false;
} else {
reason = 'no ADTS header found in AAC PES';
fatal = true;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].warn("parsing error:" + reason);
this.observer.emit(_events__WEBPACK_IMPORTED_MODULE_5__["Events"].ERROR, _events__WEBPACK_IMPORTED_MODULE_5__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_8__["ErrorTypes"].MEDIA_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_8__["ErrorDetails"].FRAG_PARSING_ERROR,
fatal: fatal,
reason: reason
});
if (fatal) {
return;
}
}
_adts__WEBPACK_IMPORTED_MODULE_0__["initTrackConfig"](track, this.observer, data, offset, this.audioCodec);
var pts;
if (pes.pts !== undefined) {
pts = pes.pts;
} else if (aacOverFlow) {
// if last AAC frame is overflowing, we should ensure timestamps are contiguous:
// first sample PTS should be equal to last sample PTS + frameDuration
var frameDuration = _adts__WEBPACK_IMPORTED_MODULE_0__["getFrameDuration"](track.samplerate);
pts = aacOverFlow.sample.pts + frameDuration;
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].warn('[tsdemuxer]: AAC PES unknown PTS');
return;
} // scan for aac samples
var frameIndex = 0;
while (offset < len) {
if (_adts__WEBPACK_IMPORTED_MODULE_0__["isHeader"](data, offset)) {
if (offset + 5 < len) {
var frame = _adts__WEBPACK_IMPORTED_MODULE_0__["appendFrame"](track, data, offset, pts, frameIndex);
if (frame) {
if (frame.missing) {
this.aacOverFlow = frame;
} else {
offset += frame.length;
frameIndex++;
continue;
}
}
} // We are at an ADTS header, but do not have enough data for a frame
// Remaining data will be added to aacOverFlow
break;
} else {
// nothing found, keep looking
offset++;
}
}
};
_proto.parseMPEGPES = function parseMPEGPES(pes) {
var data = pes.data;
var length = data.length;
var frameIndex = 0;
var offset = 0;
var pts = pes.pts;
if (pts === undefined) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].warn('[tsdemuxer]: MPEG PES unknown PTS');
return;
}
while (offset < length) {
if (_mpegaudio__WEBPACK_IMPORTED_MODULE_1__["isHeader"](data, offset)) {
var frame = _mpegaudio__WEBPACK_IMPORTED_MODULE_1__["appendFrame"](this._audioTrack, data, offset, pts, frameIndex);
if (frame) {
offset += frame.length;
frameIndex++;
} else {
// logger.log('Unable to parse Mpeg audio frame');
break;
}
} else {
// nothing found, keep looking
offset++;
}
}
};
_proto.parseID3PES = function parseID3PES(pes) {
if (pes.pts === undefined) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].warn('[tsdemuxer]: ID3 PES unknown PTS');
return;
}
this._id3Track.samples.push(pes);
};
return TSDemuxer;
}();
TSDemuxer.minProbeByteLength = 188;
function createAVCSample(key, pts, dts, debug) {
return {
key: key,
frame: false,
pts: pts,
dts: dts,
units: [],
debug: debug,
length: 0
};
}
function parsePAT(data, offset) {
// skip the PSI header and parse the first PMT entry
return (data[offset + 10] & 0x1f) << 8 | data[offset + 11]; // logger.log('PMT PID:' + this._pmtId);
}
function parsePMT(data, offset, mpegSupported, isSampleAes) {
var result = {
audio: -1,
avc: -1,
id3: -1,
isAAC: true
};
var sectionLength = (data[offset + 1] & 0x0f) << 8 | data[offset + 2];
var tableEnd = offset + 3 + sectionLength - 4; // to determine where the table is, we have to figure out how
// long the program info descriptors are
var programInfoLength = (data[offset + 10] & 0x0f) << 8 | data[offset + 11]; // advance the offset to the first entry in the mapping table
offset += 12 + programInfoLength;
while (offset < tableEnd) {
var pid = (data[offset + 1] & 0x1f) << 8 | data[offset + 2];
switch (data[offset]) {
case 0xcf:
// SAMPLE-AES AAC
if (!isSampleAes) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].log('ADTS AAC with AES-128-CBC frame encryption found in unencrypted stream');
break;
}
/* falls through */
case 0x0f:
// ISO/IEC 13818-7 ADTS AAC (MPEG-2 lower bit-rate audio)
// logger.log('AAC PID:' + pid);
if (result.audio === -1) {
result.audio = pid;
}
break;
// Packetized metadata (ID3)
case 0x15:
// logger.log('ID3 PID:' + pid);
if (result.id3 === -1) {
result.id3 = pid;
}
break;
case 0xdb:
// SAMPLE-AES AVC
if (!isSampleAes) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].log('H.264 with AES-128-CBC slice encryption found in unencrypted stream');
break;
}
/* falls through */
case 0x1b:
// ITU-T Rec. H.264 and ISO/IEC 14496-10 (lower bit-rate video)
// logger.log('AVC PID:' + pid);
if (result.avc === -1) {
result.avc = pid;
}
break;
// ISO/IEC 11172-3 (MPEG-1 audio)
// or ISO/IEC 13818-3 (MPEG-2 halved sample rate audio)
case 0x03:
case 0x04:
// logger.log('MPEG PID:' + pid);
if (!mpegSupported) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].log('MPEG audio found, not supported in this browser');
} else if (result.audio === -1) {
result.audio = pid;
result.isAAC = false;
}
break;
case 0x24:
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].warn('Unsupported HEVC stream type found');
break;
default:
// logger.log('unknown stream type:' + data[offset]);
break;
} // move to the next table entry
// skip past the elementary stream descriptors, if present
offset += ((data[offset + 3] & 0x0f) << 8 | data[offset + 4]) + 5;
}
return result;
}
function parsePES(stream) {
var i = 0;
var frag;
var pesLen;
var pesHdrLen;
var pesPts;
var pesDts;
var data = stream.data; // safety check
if (!stream || stream.size === 0) {
return null;
} // we might need up to 19 bytes to read PES header
// if first chunk of data is less than 19 bytes, let's merge it with following ones until we get 19 bytes
// usually only one merge is needed (and this is rare ...)
while (data[0].length < 19 && data.length > 1) {
var newData = new Uint8Array(data[0].length + data[1].length);
newData.set(data[0]);
newData.set(data[1], data[0].length);
data[0] = newData;
data.splice(1, 1);
} // retrieve PTS/DTS from first fragment
frag = data[0];
var pesPrefix = (frag[0] << 16) + (frag[1] << 8) + frag[2];
if (pesPrefix === 1) {
pesLen = (frag[4] << 8) + frag[5]; // if PES parsed length is not zero and greater than total received length, stop parsing. PES might be truncated
// minus 6 : PES header size
if (pesLen && pesLen > stream.size - 6) {
return null;
}
var pesFlags = frag[7];
if (pesFlags & 0xc0) {
/* PES header described here : http://dvd.sourceforge.net/dvdinfo/pes-hdr.html
as PTS / DTS is 33 bit we cannot use bitwise operator in JS,
as Bitwise operators treat their operands as a sequence of 32 bits */
pesPts = (frag[9] & 0x0e) * 536870912 + // 1 << 29
(frag[10] & 0xff) * 4194304 + // 1 << 22
(frag[11] & 0xfe) * 16384 + // 1 << 14
(frag[12] & 0xff) * 128 + // 1 << 7
(frag[13] & 0xfe) / 2;
if (pesFlags & 0x40) {
pesDts = (frag[14] & 0x0e) * 536870912 + // 1 << 29
(frag[15] & 0xff) * 4194304 + // 1 << 22
(frag[16] & 0xfe) * 16384 + // 1 << 14
(frag[17] & 0xff) * 128 + // 1 << 7
(frag[18] & 0xfe) / 2;
if (pesPts - pesDts > 60 * 90000) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].warn(Math.round((pesPts - pesDts) / 90000) + "s delta between PTS and DTS, align them");
pesPts = pesDts;
}
} else {
pesDts = pesPts;
}
}
pesHdrLen = frag[8]; // 9 bytes : 6 bytes for PES header + 3 bytes for PES extension
var payloadStartOffset = pesHdrLen + 9;
if (stream.size <= payloadStartOffset) {
return null;
}
stream.size -= payloadStartOffset; // reassemble PES packet
var pesData = new Uint8Array(stream.size);
for (var j = 0, dataLen = data.length; j < dataLen; j++) {
frag = data[j];
var len = frag.byteLength;
if (payloadStartOffset) {
if (payloadStartOffset > len) {
// trim full frag if PES header bigger than frag
payloadStartOffset -= len;
continue;
} else {
// trim partial frag if PES header smaller than frag
frag = frag.subarray(payloadStartOffset);
len -= payloadStartOffset;
payloadStartOffset = 0;
}
}
pesData.set(frag, i);
i += len;
}
if (pesLen) {
// payload size : remove PES header + PES extension
pesLen -= pesHdrLen + 3;
}
return {
data: pesData,
pts: pesPts,
dts: pesDts,
len: pesLen
};
}
return null;
}
function pushAccessUnit(avcSample, avcTrack) {
if (avcSample.units.length && avcSample.frame) {
// if sample does not have PTS/DTS, patch with last sample PTS/DTS
if (avcSample.pts === undefined) {
var samples = avcTrack.samples;
var nbSamples = samples.length;
if (nbSamples) {
var lastSample = samples[nbSamples - 1];
avcSample.pts = lastSample.pts;
avcSample.dts = lastSample.dts;
} else {
// dropping samples, no timestamp found
avcTrack.dropped++;
return;
}
}
avcTrack.samples.push(avcSample);
}
if (avcSample.debug.length) {
_utils_logger__WEBPACK_IMPORTED_MODULE_7__["logger"].log(avcSample.pts + '/' + avcSample.dts + ':' + avcSample.debug);
}
}
function insertSampleInOrder(arr, data) {
var len = arr.length;
if (len > 0) {
if (data.pts >= arr[len - 1].pts) {
arr.push(data);
} else {
for (var pos = len - 1; pos >= 0; pos--) {
if (data.pts < arr[pos].pts) {
arr.splice(pos, 0, data);
break;
}
}
}
} else {
arr.push(data);
}
}
/**
* remove Emulation Prevention bytes from a RBSP
*/
function discardEPB(data) {
var length = data.byteLength;
var EPBPositions = [];
var i = 1; // Find all `Emulation Prevention Bytes`
while (i < length - 2) {
if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {
EPBPositions.push(i + 2);
i += 2;
} else {
i++;
}
} // If no Emulation Prevention Bytes were found just return the original
// array
if (EPBPositions.length === 0) {
return data;
} // Create a new array to hold the NAL unit data
var newLength = length - EPBPositions.length;
var newData = new Uint8Array(newLength);
var sourceIndex = 0;
for (i = 0; i < newLength; sourceIndex++, i++) {
if (sourceIndex === EPBPositions[0]) {
// Skip this byte
sourceIndex++; // Remove this position index
EPBPositions.shift();
}
newData[i] = data[sourceIndex];
}
return newData;
}
/* harmony default export */ __webpack_exports__["default"] = (TSDemuxer);
/***/ }),
/***/ "./src/errors.ts":
/*!***********************!*\
!*** ./src/errors.ts ***!
\***********************/
/*! exports provided: ErrorTypes, ErrorDetails */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ErrorTypes", function() { return ErrorTypes; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ErrorDetails", function() { return ErrorDetails; });
var ErrorTypes;
/**
* @enum {ErrorDetails}
* @typedef {string} ErrorDetail
*/
(function (ErrorTypes) {
ErrorTypes["NETWORK_ERROR"] = "networkError";
ErrorTypes["MEDIA_ERROR"] = "mediaError";
ErrorTypes["KEY_SYSTEM_ERROR"] = "keySystemError";
ErrorTypes["MUX_ERROR"] = "muxError";
ErrorTypes["OTHER_ERROR"] = "otherError";
})(ErrorTypes || (ErrorTypes = {}));
var ErrorDetails;
(function (ErrorDetails) {
ErrorDetails["KEY_SYSTEM_NO_KEYS"] = "keySystemNoKeys";
ErrorDetails["KEY_SYSTEM_NO_ACCESS"] = "keySystemNoAccess";
ErrorDetails["KEY_SYSTEM_NO_SESSION"] = "keySystemNoSession";
ErrorDetails["KEY_SYSTEM_LICENSE_REQUEST_FAILED"] = "keySystemLicenseRequestFailed";
ErrorDetails["KEY_SYSTEM_NO_INIT_DATA"] = "keySystemNoInitData";
ErrorDetails["MANIFEST_LOAD_ERROR"] = "manifestLoadError";
ErrorDetails["MANIFEST_LOAD_TIMEOUT"] = "manifestLoadTimeOut";
ErrorDetails["MANIFEST_PARSING_ERROR"] = "manifestParsingError";
ErrorDetails["MANIFEST_INCOMPATIBLE_CODECS_ERROR"] = "manifestIncompatibleCodecsError";
ErrorDetails["LEVEL_EMPTY_ERROR"] = "levelEmptyError";
ErrorDetails["LEVEL_LOAD_ERROR"] = "levelLoadError";
ErrorDetails["LEVEL_LOAD_TIMEOUT"] = "levelLoadTimeOut";
ErrorDetails["LEVEL_SWITCH_ERROR"] = "levelSwitchError";
ErrorDetails["AUDIO_TRACK_LOAD_ERROR"] = "audioTrackLoadError";
ErrorDetails["AUDIO_TRACK_LOAD_TIMEOUT"] = "audioTrackLoadTimeOut";
ErrorDetails["SUBTITLE_LOAD_ERROR"] = "subtitleTrackLoadError";
ErrorDetails["SUBTITLE_TRACK_LOAD_TIMEOUT"] = "subtitleTrackLoadTimeOut";
ErrorDetails["FRAG_LOAD_ERROR"] = "fragLoadError";
ErrorDetails["FRAG_LOAD_TIMEOUT"] = "fragLoadTimeOut";
ErrorDetails["FRAG_DECRYPT_ERROR"] = "fragDecryptError";
ErrorDetails["FRAG_PARSING_ERROR"] = "fragParsingError";
ErrorDetails["REMUX_ALLOC_ERROR"] = "remuxAllocError";
ErrorDetails["KEY_LOAD_ERROR"] = "keyLoadError";
ErrorDetails["KEY_LOAD_TIMEOUT"] = "keyLoadTimeOut";
ErrorDetails["BUFFER_ADD_CODEC_ERROR"] = "bufferAddCodecError";
ErrorDetails["BUFFER_INCOMPATIBLE_CODECS_ERROR"] = "bufferIncompatibleCodecsError";
ErrorDetails["BUFFER_APPEND_ERROR"] = "bufferAppendError";
ErrorDetails["BUFFER_APPENDING_ERROR"] = "bufferAppendingError";
ErrorDetails["BUFFER_STALLED_ERROR"] = "bufferStalledError";
ErrorDetails["BUFFER_FULL_ERROR"] = "bufferFullError";
ErrorDetails["BUFFER_SEEK_OVER_HOLE"] = "bufferSeekOverHole";
ErrorDetails["BUFFER_NUDGE_ON_STALL"] = "bufferNudgeOnStall";
ErrorDetails["INTERNAL_EXCEPTION"] = "internalException";
ErrorDetails["INTERNAL_ABORTED"] = "aborted";
ErrorDetails["UNKNOWN"] = "unknown";
})(ErrorDetails || (ErrorDetails = {}));
/***/ }),
/***/ "./src/events.ts":
/*!***********************!*\
!*** ./src/events.ts ***!
\***********************/
/*! exports provided: Events */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Events", function() { return Events; });
/**
* @readonly
* @enum {string}
*/
var Events;
(function (Events) {
Events["MEDIA_ATTACHING"] = "hlsMediaAttaching";
Events["MEDIA_ATTACHED"] = "hlsMediaAttached";
Events["MEDIA_DETACHING"] = "hlsMediaDetaching";
Events["MEDIA_DETACHED"] = "hlsMediaDetached";
Events["BUFFER_RESET"] = "hlsBufferReset";
Events["BUFFER_CODECS"] = "hlsBufferCodecs";
Events["BUFFER_CREATED"] = "hlsBufferCreated";
Events["BUFFER_APPENDING"] = "hlsBufferAppending";
Events["BUFFER_APPENDED"] = "hlsBufferAppended";
Events["BUFFER_EOS"] = "hlsBufferEos";
Events["BUFFER_FLUSHING"] = "hlsBufferFlushing";
Events["BUFFER_FLUSHED"] = "hlsBufferFlushed";
Events["MANIFEST_LOADING"] = "hlsManifestLoading";
Events["MANIFEST_LOADED"] = "hlsManifestLoaded";
Events["MANIFEST_PARSED"] = "hlsManifestParsed";
Events["LEVEL_SWITCHING"] = "hlsLevelSwitching";
Events["LEVEL_SWITCHED"] = "hlsLevelSwitched";
Events["LEVEL_LOADING"] = "hlsLevelLoading";
Events["LEVEL_LOADED"] = "hlsLevelLoaded";
Events["LEVEL_UPDATED"] = "hlsLevelUpdated";
Events["LEVEL_PTS_UPDATED"] = "hlsLevelPtsUpdated";
Events["LEVELS_UPDATED"] = "hlsLevelsUpdated";
Events["AUDIO_TRACKS_UPDATED"] = "hlsAudioTracksUpdated";
Events["AUDIO_TRACK_SWITCHING"] = "hlsAudioTrackSwitching";
Events["AUDIO_TRACK_SWITCHED"] = "hlsAudioTrackSwitched";
Events["AUDIO_TRACK_LOADING"] = "hlsAudioTrackLoading";
Events["AUDIO_TRACK_LOADED"] = "hlsAudioTrackLoaded";
Events["SUBTITLE_TRACKS_UPDATED"] = "hlsSubtitleTracksUpdated";
Events["SUBTITLE_TRACKS_CLEARED"] = "hlsSubtitleTracksCleared";
Events["SUBTITLE_TRACK_SWITCH"] = "hlsSubtitleTrackSwitch";
Events["SUBTITLE_TRACK_LOADING"] = "hlsSubtitleTrackLoading";
Events["SUBTITLE_TRACK_LOADED"] = "hlsSubtitleTrackLoaded";
Events["SUBTITLE_FRAG_PROCESSED"] = "hlsSubtitleFragProcessed";
Events["CUES_PARSED"] = "hlsCuesParsed";
Events["NON_NATIVE_TEXT_TRACKS_FOUND"] = "hlsNonNativeTextTracksFound";
Events["INIT_PTS_FOUND"] = "hlsInitPtsFound";
Events["FRAG_LOADING"] = "hlsFragLoading";
Events["FRAG_LOAD_EMERGENCY_ABORTED"] = "hlsFragLoadEmergencyAborted";
Events["FRAG_LOADED"] = "hlsFragLoaded";
Events["FRAG_DECRYPTED"] = "hlsFragDecrypted";
Events["FRAG_PARSING_INIT_SEGMENT"] = "hlsFragParsingInitSegment";
Events["FRAG_PARSING_USERDATA"] = "hlsFragParsingUserdata";
Events["FRAG_PARSING_METADATA"] = "hlsFragParsingMetadata";
Events["FRAG_PARSED"] = "hlsFragParsed";
Events["FRAG_BUFFERED"] = "hlsFragBuffered";
Events["FRAG_CHANGED"] = "hlsFragChanged";
Events["FPS_DROP"] = "hlsFpsDrop";
Events["FPS_DROP_LEVEL_CAPPING"] = "hlsFpsDropLevelCapping";
Events["ERROR"] = "hlsError";
Events["DESTROYING"] = "hlsDestroying";
Events["KEY_LOADING"] = "hlsKeyLoading";
Events["KEY_LOADED"] = "hlsKeyLoaded";
Events["LIVE_BACK_BUFFER_REACHED"] = "hlsLiveBackBufferReached";
Events["BACK_BUFFER_REACHED"] = "hlsBackBufferReached";
})(Events || (Events = {}));
/***/ }),
/***/ "./src/hls.ts":
/*!********************!*\
!*** ./src/hls.ts ***!
\********************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Hls; });
/* harmony import */ var url_toolkit__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! url-toolkit */ "./node_modules/url-toolkit/src/url-toolkit.js");
/* harmony import */ var url_toolkit__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(url_toolkit__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _loader_playlist_loader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./loader/playlist-loader */ "./src/loader/playlist-loader.ts");
/* harmony import */ var _loader_key_loader__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./loader/key-loader */ "./src/loader/key-loader.ts");
/* harmony import */ var _controller_id3_track_controller__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./controller/id3-track-controller */ "./src/controller/id3-track-controller.ts");
/* harmony import */ var _controller_latency_controller__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./controller/latency-controller */ "./src/controller/latency-controller.ts");
/* harmony import */ var _controller_level_controller__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./controller/level-controller */ "./src/controller/level-controller.ts");
/* harmony import */ var _controller_fragment_tracker__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./controller/fragment-tracker */ "./src/controller/fragment-tracker.ts");
/* harmony import */ var _controller_stream_controller__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./controller/stream-controller */ "./src/controller/stream-controller.ts");
/* harmony import */ var _is_supported__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./is-supported */ "./src/is-supported.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _config__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./config */ "./src/config.ts");
/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! eventemitter3 */ "./node_modules/eventemitter3/index.js");
/* harmony import */ var eventemitter3__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(eventemitter3__WEBPACK_IMPORTED_MODULE_11__);
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./errors */ "./src/errors.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
/**
* @module Hls
* @class
* @constructor
*/
var Hls = /*#__PURE__*/function () {
Hls.isSupported = function isSupported() {
return Object(_is_supported__WEBPACK_IMPORTED_MODULE_8__["isSupported"])();
};
/**
* Creates an instance of an HLS client that can attach to exactly one `HTMLMediaElement`.
*
* @constructs Hls
* @param {HlsConfig} config
*/
function Hls(userConfig) {
if (userConfig === void 0) {
userConfig = {};
}
this.config = void 0;
this.userConfig = void 0;
this.coreComponents = void 0;
this.networkControllers = void 0;
this._emitter = new eventemitter3__WEBPACK_IMPORTED_MODULE_11__["EventEmitter"]();
this._autoLevelCapping = void 0;
this.abrController = void 0;
this.bufferController = void 0;
this.capLevelController = void 0;
this.latencyController = void 0;
this.levelController = void 0;
this.streamController = void 0;
this.audioTrackController = void 0;
this.subtitleTrackController = void 0;
this.emeController = void 0;
this._media = null;
this.url = null;
var config = this.config = Object(_config__WEBPACK_IMPORTED_MODULE_10__["mergeConfig"])(Hls.DefaultConfig, userConfig);
this.userConfig = userConfig;
Object(_utils_logger__WEBPACK_IMPORTED_MODULE_9__["enableLogs"])(config.debug);
this._autoLevelCapping = -1;
if (config.progressive) {
Object(_config__WEBPACK_IMPORTED_MODULE_10__["enableStreamingMode"])(config);
} // core controllers and network loaders
var ConfigAbrController = config.abrController,
ConfigBufferController = config.bufferController,
ConfigCapLevelController = config.capLevelController,
ConfigFpsController = config.fpsController;
var abrController = this.abrController = new ConfigAbrController(this);
var bufferController = this.bufferController = new ConfigBufferController(this);
var capLevelController = this.capLevelController = new ConfigCapLevelController(this);
var fpsController = new ConfigFpsController(this);
var playListLoader = new _loader_playlist_loader__WEBPACK_IMPORTED_MODULE_1__["default"](this);
var keyLoader = new _loader_key_loader__WEBPACK_IMPORTED_MODULE_2__["default"](this);
var id3TrackController = new _controller_id3_track_controller__WEBPACK_IMPORTED_MODULE_3__["default"](this); // network controllers
var levelController = this.levelController = new _controller_level_controller__WEBPACK_IMPORTED_MODULE_5__["default"](this); // FragmentTracker must be defined before StreamController because the order of event handling is important
var fragmentTracker = new _controller_fragment_tracker__WEBPACK_IMPORTED_MODULE_6__["FragmentTracker"](this);
var streamController = this.streamController = new _controller_stream_controller__WEBPACK_IMPORTED_MODULE_7__["default"](this, fragmentTracker); // Cap level controller uses streamController to flush the buffer
capLevelController.setStreamController(streamController); // fpsController uses streamController to switch when frames are being dropped
fpsController.setStreamController(streamController);
var networkControllers = [levelController, streamController];
this.networkControllers = networkControllers;
var coreComponents = [playListLoader, keyLoader, abrController, bufferController, capLevelController, fpsController, id3TrackController, fragmentTracker];
this.audioTrackController = this.createController(config.audioTrackController, null, networkControllers);
this.createController(config.audioStreamController, fragmentTracker, networkControllers); // subtitleTrackController must be defined before because the order of event handling is important
this.subtitleTrackController = this.createController(config.subtitleTrackController, null, networkControllers);
this.createController(config.subtitleStreamController, fragmentTracker, networkControllers);
this.createController(config.timelineController, null, coreComponents);
this.emeController = this.createController(config.emeController, null, coreComponents);
this.latencyController = this.createController(_controller_latency_controller__WEBPACK_IMPORTED_MODULE_4__["default"], null, coreComponents);
this.coreComponents = coreComponents;
}
var _proto = Hls.prototype;
_proto.createController = function createController(ControllerClass, fragmentTracker, components) {
if (ControllerClass) {
var controllerInstance = fragmentTracker ? new ControllerClass(this, fragmentTracker) : new ControllerClass(this);
if (components) {
components.push(controllerInstance);
}
return controllerInstance;
}
return null;
} // Delegate the EventEmitter through the public API of Hls.js
;
_proto.on = function on(event, listener, context) {
if (context === void 0) {
context = this;
}
this._emitter.on(event, listener, context);
};
_proto.once = function once(event, listener, context) {
if (context === void 0) {
context = this;
}
this._emitter.once(event, listener, context);
};
_proto.removeAllListeners = function removeAllListeners(event) {
this._emitter.removeAllListeners(event);
};
_proto.off = function off(event, listener, context, once) {
if (context === void 0) {
context = this;
}
this._emitter.off(event, listener, context, once);
};
_proto.listeners = function listeners(event) {
return this._emitter.listeners(event);
};
_proto.emit = function emit(event, name, eventObject) {
return this._emitter.emit(event, name, eventObject);
};
_proto.trigger = function trigger(event, eventObject) {
if (this.config.debug) {
return this.emit(event, event, eventObject);
} else {
try {
return this.emit(event, event, eventObject);
} catch (e) {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].error('An internal error happened while handling event ' + event + '. Error message: "' + e.message + '". Here is a stacktrace:', e);
this.trigger(_events__WEBPACK_IMPORTED_MODULE_12__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorTypes"].OTHER_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"].INTERNAL_EXCEPTION,
fatal: false,
event: event,
error: e
});
}
}
return false;
};
_proto.listenerCount = function listenerCount(event) {
return this._emitter.listenerCount(event);
}
/**
* Dispose of the instance
*/
;
_proto.destroy = function destroy() {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log('destroy');
this.trigger(_events__WEBPACK_IMPORTED_MODULE_12__["Events"].DESTROYING, undefined);
this.detachMedia();
this.removeAllListeners();
this._autoLevelCapping = -1;
this.url = null;
this.networkControllers.forEach(function (component) {
return component.destroy();
});
this.networkControllers.length = 0;
this.coreComponents.forEach(function (component) {
return component.destroy();
});
this.coreComponents.length = 0;
}
/**
* Attaches Hls.js to a media element
* @param {HTMLMediaElement} media
*/
;
_proto.attachMedia = function attachMedia(media) {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log('attachMedia');
this._media = media;
this.trigger(_events__WEBPACK_IMPORTED_MODULE_12__["Events"].MEDIA_ATTACHING, {
media: media
});
}
/**
* Detach Hls.js from the media
*/
;
_proto.detachMedia = function detachMedia() {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log('detachMedia');
this.trigger(_events__WEBPACK_IMPORTED_MODULE_12__["Events"].MEDIA_DETACHING, undefined);
this._media = null;
}
/**
* Set the source URL. Can be relative or absolute.
* @param {string} url
*/
;
_proto.loadSource = function loadSource(url) {
this.stopLoad();
var media = this.media;
var loadedSource = this.url;
var loadingSource = this.url = url_toolkit__WEBPACK_IMPORTED_MODULE_0__["buildAbsoluteURL"](self.location.href, url, {
alwaysNormalize: true
});
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log("loadSource:" + loadingSource);
if (media && loadedSource && loadedSource !== loadingSource && this.bufferController.hasSourceTypes()) {
this.detachMedia();
this.attachMedia(media);
} // when attaching to a source URL, trigger a playlist load
this.trigger(_events__WEBPACK_IMPORTED_MODULE_12__["Events"].MANIFEST_LOADING, {
url: url
});
}
/**
* Start loading data from the stream source.
* Depending on default config, client starts loading automatically when a source is set.
*
* @param {number} startPosition Set the start position to stream from
* @default -1 None (from earliest point)
*/
;
_proto.startLoad = function startLoad(startPosition) {
if (startPosition === void 0) {
startPosition = -1;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log("startLoad(" + startPosition + ")");
this.networkControllers.forEach(function (controller) {
controller.startLoad(startPosition);
});
}
/**
* Stop loading of any stream data.
*/
;
_proto.stopLoad = function stopLoad() {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log('stopLoad');
this.networkControllers.forEach(function (controller) {
controller.stopLoad();
});
}
/**
* Swap through possible audio codecs in the stream (for example to switch from stereo to 5.1)
*/
;
_proto.swapAudioCodec = function swapAudioCodec() {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log('swapAudioCodec');
this.streamController.swapAudioCodec();
}
/**
* When the media-element fails, this allows to detach and then re-attach it
* as one call (convenience method).
*
* Automatic recovery of media-errors by this process is configurable.
*/
;
_proto.recoverMediaError = function recoverMediaError() {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log('recoverMediaError');
var media = this._media;
this.detachMedia();
if (media) {
this.attachMedia(media);
}
};
_proto.removeLevel = function removeLevel(levelIndex, urlId) {
if (urlId === void 0) {
urlId = 0;
}
this.levelController.removeLevel(levelIndex, urlId);
}
/**
* @type {Level[]}
*/
;
_createClass(Hls, [{
key: "levels",
get: function get() {
var levels = this.levelController.levels;
return levels ? levels : [];
}
/**
* Index of quality level currently played
* @type {number}
*/
}, {
key: "currentLevel",
get: function get() {
return this.streamController.currentLevel;
}
/**
* Set quality level index immediately .
* This will flush the current buffer to replace the quality asap.
* That means playback will interrupt at least shortly to re-buffer and re-sync eventually.
* @type {number} -1 for automatic level selection
*/
,
set: function set(newLevel) {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log("set currentLevel:" + newLevel);
this.loadLevel = newLevel;
this.abrController.clearTimer();
this.streamController.immediateLevelSwitch();
}
/**
* Index of next quality level loaded as scheduled by stream controller.
* @type {number}
*/
}, {
key: "nextLevel",
get: function get() {
return this.streamController.nextLevel;
}
/**
* Set quality level index for next loaded data.
* This will switch the video quality asap, without interrupting playback.
* May abort current loading of data, and flush parts of buffer (outside currently played fragment region).
* @type {number} -1 for automatic level selection
*/
,
set: function set(newLevel) {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log("set nextLevel:" + newLevel);
this.levelController.manualLevel = newLevel;
this.streamController.nextLevelSwitch();
}
/**
* Return the quality level of the currently or last (of none is loaded currently) segment
* @type {number}
*/
}, {
key: "loadLevel",
get: function get() {
return this.levelController.level;
}
/**
* Set quality level index for next loaded data in a conservative way.
* This will switch the quality without flushing, but interrupt current loading.
* Thus the moment when the quality switch will appear in effect will only be after the already existing buffer.
* @type {number} newLevel -1 for automatic level selection
*/
,
set: function set(newLevel) {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log("set loadLevel:" + newLevel);
this.levelController.manualLevel = newLevel;
}
/**
* get next quality level loaded
* @type {number}
*/
}, {
key: "nextLoadLevel",
get: function get() {
return this.levelController.nextLoadLevel;
}
/**
* Set quality level of next loaded segment in a fully "non-destructive" way.
* Same as `loadLevel` but will wait for next switch (until current loading is done).
* @type {number} level
*/
,
set: function set(level) {
this.levelController.nextLoadLevel = level;
}
/**
* Return "first level": like a default level, if not set,
* falls back to index of first level referenced in manifest
* @type {number}
*/
}, {
key: "firstLevel",
get: function get() {
return Math.max(this.levelController.firstLevel, this.minAutoLevel);
}
/**
* Sets "first-level", see getter.
* @type {number}
*/
,
set: function set(newLevel) {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log("set firstLevel:" + newLevel);
this.levelController.firstLevel = newLevel;
}
/**
* Return start level (level of first fragment that will be played back)
* if not overrided by user, first level appearing in manifest will be used as start level
* if -1 : automatic start level selection, playback will start from level matching download bandwidth
* (determined from download of first segment)
* @type {number}
*/
}, {
key: "startLevel",
get: function get() {
return this.levelController.startLevel;
}
/**
* set start level (level of first fragment that will be played back)
* if not overrided by user, first level appearing in manifest will be used as start level
* if -1 : automatic start level selection, playback will start from level matching download bandwidth
* (determined from download of first segment)
* @type {number} newLevel
*/
,
set: function set(newLevel) {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log("set startLevel:" + newLevel); // if not in automatic start level detection, ensure startLevel is greater than minAutoLevel
if (newLevel !== -1) {
newLevel = Math.max(newLevel, this.minAutoLevel);
}
this.levelController.startLevel = newLevel;
}
/**
* Get the current setting for capLevelToPlayerSize
*
* @type {boolean}
*/
}, {
key: "capLevelToPlayerSize",
get: function get() {
return this.config.capLevelToPlayerSize;
}
/**
* set dynamically set capLevelToPlayerSize against (`CapLevelController`)
*
* @type {boolean}
*/
,
set: function set(shouldStartCapping) {
var newCapLevelToPlayerSize = !!shouldStartCapping;
if (newCapLevelToPlayerSize !== this.config.capLevelToPlayerSize) {
if (newCapLevelToPlayerSize) {
this.capLevelController.startCapping(); // If capping occurs, nextLevelSwitch will happen based on size.
} else {
this.capLevelController.stopCapping();
this.autoLevelCapping = -1;
this.streamController.nextLevelSwitch(); // Now we're uncapped, get the next level asap.
}
this.config.capLevelToPlayerSize = newCapLevelToPlayerSize;
}
}
/**
* Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
* @type {number}
*/
}, {
key: "autoLevelCapping",
get: function get() {
return this._autoLevelCapping;
}
/**
* get bandwidth estimate
* @type {number}
*/
,
set:
/**
* Capping/max level value that should be used by automatic level selection algorithm (`ABRController`)
* @type {number}
*/
function set(newLevel) {
if (this._autoLevelCapping !== newLevel) {
_utils_logger__WEBPACK_IMPORTED_MODULE_9__["logger"].log("set autoLevelCapping:" + newLevel);
this._autoLevelCapping = newLevel;
}
}
/**
* True when automatic level selection enabled
* @type {boolean}
*/
}, {
key: "bandwidthEstimate",
get: function get() {
var bwEstimator = this.abrController.bwEstimator;
if (!bwEstimator) {
return NaN;
}
return bwEstimator.getEstimate();
}
}, {
key: "autoLevelEnabled",
get: function get() {
return this.levelController.manualLevel === -1;
}
/**
* Level set manually (if any)
* @type {number}
*/
}, {
key: "manualLevel",
get: function get() {
return this.levelController.manualLevel;
}
/**
* min level selectable in auto mode according to config.minAutoBitrate
* @type {number}
*/
}, {
key: "minAutoLevel",
get: function get() {
var levels = this.levels,
minAutoBitrate = this.config.minAutoBitrate;
if (!levels) return 0;
var len = levels.length;
for (var i = 0; i < len; i++) {
if (levels[i].maxBitrate > minAutoBitrate) {
return i;
}
}
return 0;
}
/**
* max level selectable in auto mode according to autoLevelCapping
* @type {number}
*/
}, {
key: "maxAutoLevel",
get: function get() {
var levels = this.levels,
autoLevelCapping = this.autoLevelCapping;
var maxAutoLevel;
if (autoLevelCapping === -1 && levels && levels.length) {
maxAutoLevel = levels.length - 1;
} else {
maxAutoLevel = autoLevelCapping;
}
return maxAutoLevel;
}
/**
* next automatically selected quality level
* @type {number}
*/
}, {
key: "nextAutoLevel",
get: function get() {
// ensure next auto level is between min and max auto level
return Math.min(Math.max(this.abrController.nextAutoLevel, this.minAutoLevel), this.maxAutoLevel);
}
/**
* this setter is used to force next auto level.
* this is useful to force a switch down in auto mode:
* in case of load error on level N, hls.js can set nextAutoLevel to N-1 for example)
* forced value is valid for one fragment. upon succesful frag loading at forced level,
* this value will be resetted to -1 by ABR controller.
* @type {number}
*/
,
set: function set(nextLevel) {
this.abrController.nextAutoLevel = Math.max(this.minAutoLevel, nextLevel);
}
/**
* @type {AudioTrack[]}
*/
}, {
key: "audioTracks",
get: function get() {
var audioTrackController = this.audioTrackController;
return audioTrackController ? audioTrackController.audioTracks : [];
}
/**
* index of the selected audio track (index in audio track lists)
* @type {number}
*/
}, {
key: "audioTrack",
get: function get() {
var audioTrackController = this.audioTrackController;
return audioTrackController ? audioTrackController.audioTrack : -1;
}
/**
* selects an audio track, based on its index in audio track lists
* @type {number}
*/
,
set: function set(audioTrackId) {
var audioTrackController = this.audioTrackController;
if (audioTrackController) {
audioTrackController.audioTrack = audioTrackId;
}
}
/**
* get alternate subtitle tracks list from playlist
* @type {MediaPlaylist[]}
*/
}, {
key: "subtitleTracks",
get: function get() {
var subtitleTrackController = this.subtitleTrackController;
return subtitleTrackController ? subtitleTrackController.subtitleTracks : [];
}
/**
* index of the selected subtitle track (index in subtitle track lists)
* @type {number}
*/
}, {
key: "subtitleTrack",
get: function get() {
var subtitleTrackController = this.subtitleTrackController;
return subtitleTrackController ? subtitleTrackController.subtitleTrack : -1;
},
set:
/**
* select an subtitle track, based on its index in subtitle track lists
* @type {number}
*/
function set(subtitleTrackId) {
var subtitleTrackController = this.subtitleTrackController;
if (subtitleTrackController) {
subtitleTrackController.subtitleTrack = subtitleTrackId;
}
}
/**
* @type {boolean}
*/
}, {
key: "media",
get: function get() {
return this._media;
}
}, {
key: "subtitleDisplay",
get: function get() {
var subtitleTrackController = this.subtitleTrackController;
return subtitleTrackController ? subtitleTrackController.subtitleDisplay : false;
}
/**
* Enable/disable subtitle display rendering
* @type {boolean}
*/
,
set: function set(value) {
var subtitleTrackController = this.subtitleTrackController;
if (subtitleTrackController) {
subtitleTrackController.subtitleDisplay = value;
}
}
/**
* get mode for Low-Latency HLS loading
* @type {boolean}
*/
}, {
key: "lowLatencyMode",
get: function get() {
return this.config.lowLatencyMode;
}
/**
* Enable/disable Low-Latency HLS part playlist and segment loading, and start live streams at playlist PART-HOLD-BACK rather than HOLD-BACK.
* @type {boolean}
*/
,
set: function set(mode) {
this.config.lowLatencyMode = mode;
}
/**
* position (in seconds) of live sync point (ie edge of live position minus safety delay defined by ```hls.config.liveSyncDuration```)
* @type {number}
*/
}, {
key: "liveSyncPosition",
get: function get() {
return this.latencyController.liveSyncPosition;
}
/**
* estimated position (in seconds) of live edge (ie edge of live playlist plus time sync playlist advanced)
* returns 0 before first playlist is loaded
* @type {number}
*/
}, {
key: "latency",
get: function get() {
return this.latencyController.latency;
}
/**
* maximum distance from the edge before the player seeks forward to ```hls.liveSyncPosition```
* configured using ```liveMaxLatencyDurationCount``` (multiple of target duration) or ```liveMaxLatencyDuration```
* returns 0 before first playlist is loaded
* @type {number}
*/
}, {
key: "maxLatency",
get: function get() {
return this.latencyController.maxLatency;
}
/**
* target distance from the edge as calculated by the latency controller
* @type {number}
*/
}, {
key: "targetLatency",
get: function get() {
return this.latencyController.targetLatency;
}
/**
* the rate at which the edge of the current live playlist is advancing or 1 if there is none
* @type {number}
*/
}, {
key: "drift",
get: function get() {
return this.latencyController.drift;
}
/**
* set to true when startLoad is called before MANIFEST_PARSED event
* @type {boolean}
*/
}, {
key: "forceStartLoad",
get: function get() {
return this.streamController.forceStartLoad;
}
}], [{
key: "version",
get: function get() {
return "1.0.12-0.canary.8011";
}
}, {
key: "Events",
get: function get() {
return _events__WEBPACK_IMPORTED_MODULE_12__["Events"];
}
}, {
key: "ErrorTypes",
get: function get() {
return _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorTypes"];
}
}, {
key: "ErrorDetails",
get: function get() {
return _errors__WEBPACK_IMPORTED_MODULE_13__["ErrorDetails"];
}
}, {
key: "DefaultConfig",
get: function get() {
if (!Hls.defaultConfig) {
return _config__WEBPACK_IMPORTED_MODULE_10__["hlsDefaultConfig"];
}
return Hls.defaultConfig;
}
/**
* @type {HlsConfig}
*/
,
set: function set(defaultConfig) {
Hls.defaultConfig = defaultConfig;
}
}]);
return Hls;
}();
Hls.defaultConfig = void 0;
/***/ }),
/***/ "./src/is-supported.ts":
/*!*****************************!*\
!*** ./src/is-supported.ts ***!
\*****************************/
/*! exports provided: isSupported, changeTypeSupported */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isSupported", function() { return isSupported; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "changeTypeSupported", function() { return changeTypeSupported; });
/* harmony import */ var _utils_mediasource_helper__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils/mediasource-helper */ "./src/utils/mediasource-helper.ts");
function getSourceBuffer() {
return self.SourceBuffer || self.WebKitSourceBuffer;
}
function isSupported() {
var mediaSource = Object(_utils_mediasource_helper__WEBPACK_IMPORTED_MODULE_0__["getMediaSource"])();
if (!mediaSource) {
return false;
}
var sourceBuffer = getSourceBuffer();
var isTypeSupported = mediaSource && typeof mediaSource.isTypeSupported === 'function' && mediaSource.isTypeSupported('video/mp4; codecs="avc1.42E01E,mp4a.40.2"'); // if SourceBuffer is exposed ensure its API is valid
// safari and old version of Chrome doe not expose SourceBuffer globally so checking SourceBuffer.prototype is impossible
var sourceBufferValidAPI = !sourceBuffer || sourceBuffer.prototype && typeof sourceBuffer.prototype.appendBuffer === 'function' && typeof sourceBuffer.prototype.remove === 'function';
return !!isTypeSupported && !!sourceBufferValidAPI;
}
function changeTypeSupported() {
var _sourceBuffer$prototy;
var sourceBuffer = getSourceBuffer();
return typeof (sourceBuffer === null || sourceBuffer === void 0 ? void 0 : (_sourceBuffer$prototy = sourceBuffer.prototype) === null || _sourceBuffer$prototy === void 0 ? void 0 : _sourceBuffer$prototy.changeType) === 'function';
}
/***/ }),
/***/ "./src/loader/fragment-loader.ts":
/*!***************************************!*\
!*** ./src/loader/fragment-loader.ts ***!
\***************************************/
/*! exports provided: default, LoadError */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return FragmentLoader; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LoadError", function() { return LoadError; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
var MIN_CHUNK_SIZE = Math.pow(2, 17); // 128kb
var FragmentLoader = /*#__PURE__*/function () {
function FragmentLoader(config) {
this.config = void 0;
this.loader = null;
this.partLoadTimeout = -1;
this.config = config;
}
var _proto = FragmentLoader.prototype;
_proto.destroy = function destroy() {
if (this.loader) {
this.loader.destroy();
this.loader = null;
}
};
_proto.abort = function abort() {
if (this.loader) {
// Abort the loader for current fragment. Only one may load at any given time
this.loader.abort();
}
};
_proto.load = function load(frag, _onProgress) {
var _this = this;
var url = frag.url;
if (!url) {
return Promise.reject(new LoadError({
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].FRAG_LOAD_ERROR,
fatal: false,
frag: frag,
networkDetails: null
}, "Fragment does not have a " + (url ? 'part list' : 'url')));
}
this.abort();
var config = this.config;
var FragmentILoader = config.fLoader;
var DefaultILoader = config.loader;
return new Promise(function (resolve, reject) {
if (_this.loader) {
_this.loader.destroy();
}
var loader = _this.loader = frag.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
var loaderContext = createLoaderContext(frag);
var loaderConfig = {
timeout: config.fragLoadingTimeOut,
maxRetry: 0,
retryDelay: 0,
maxRetryDelay: config.fragLoadingMaxRetryTimeout,
highWaterMark: MIN_CHUNK_SIZE
}; // Assign frag stats to the loader's stats reference
frag.stats = loader.stats;
loader.load(loaderContext, loaderConfig, {
onSuccess: function onSuccess(response, stats, context, networkDetails) {
_this.resetLoader(frag, loader);
resolve({
frag: frag,
part: null,
payload: response.data,
networkDetails: networkDetails
});
},
onError: function onError(response, context, networkDetails) {
_this.resetLoader(frag, loader);
reject(new LoadError({
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].FRAG_LOAD_ERROR,
fatal: false,
frag: frag,
response: response,
networkDetails: networkDetails
}));
},
onAbort: function onAbort(stats, context, networkDetails) {
_this.resetLoader(frag, loader);
reject(new LoadError({
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].INTERNAL_ABORTED,
fatal: false,
frag: frag,
networkDetails: networkDetails
}));
},
onTimeout: function onTimeout(response, context, networkDetails) {
_this.resetLoader(frag, loader);
reject(new LoadError({
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].FRAG_LOAD_TIMEOUT,
fatal: false,
frag: frag,
networkDetails: networkDetails
}));
},
onProgress: function onProgress(stats, context, data, networkDetails) {
if (_onProgress) {
_onProgress({
frag: frag,
part: null,
payload: data,
networkDetails: networkDetails
});
}
}
});
});
};
_proto.loadPart = function loadPart(frag, part, onProgress) {
var _this2 = this;
this.abort();
var config = this.config;
var FragmentILoader = config.fLoader;
var DefaultILoader = config.loader;
return new Promise(function (resolve, reject) {
if (_this2.loader) {
_this2.loader.destroy();
}
var loader = _this2.loader = frag.loader = FragmentILoader ? new FragmentILoader(config) : new DefaultILoader(config);
var loaderContext = createLoaderContext(frag, part);
var loaderConfig = {
timeout: config.fragLoadingTimeOut,
maxRetry: 0,
retryDelay: 0,
maxRetryDelay: config.fragLoadingMaxRetryTimeout,
highWaterMark: MIN_CHUNK_SIZE
}; // Assign part stats to the loader's stats reference
part.stats = loader.stats;
loader.load(loaderContext, loaderConfig, {
onSuccess: function onSuccess(response, stats, context, networkDetails) {
_this2.resetLoader(frag, loader);
_this2.updateStatsFromPart(frag, part);
var partLoadedData = {
frag: frag,
part: part,
payload: response.data,
networkDetails: networkDetails
};
onProgress(partLoadedData);
resolve(partLoadedData);
},
onError: function onError(response, context, networkDetails) {
_this2.resetLoader(frag, loader);
reject(new LoadError({
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].FRAG_LOAD_ERROR,
fatal: false,
frag: frag,
part: part,
response: response,
networkDetails: networkDetails
}));
},
onAbort: function onAbort(stats, context, networkDetails) {
frag.stats.aborted = part.stats.aborted;
_this2.resetLoader(frag, loader);
reject(new LoadError({
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].INTERNAL_ABORTED,
fatal: false,
frag: frag,
part: part,
networkDetails: networkDetails
}));
},
onTimeout: function onTimeout(response, context, networkDetails) {
_this2.resetLoader(frag, loader);
reject(new LoadError({
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].FRAG_LOAD_TIMEOUT,
fatal: false,
frag: frag,
part: part,
networkDetails: networkDetails
}));
}
});
});
};
_proto.updateStatsFromPart = function updateStatsFromPart(frag, part) {
var fragStats = frag.stats;
var partStats = part.stats;
var partTotal = partStats.total;
fragStats.loaded += partStats.loaded;
if (partTotal) {
var estTotalParts = Math.round(frag.duration / part.duration);
var estLoadedParts = Math.min(Math.round(fragStats.loaded / partTotal), estTotalParts);
var estRemainingParts = estTotalParts - estLoadedParts;
var estRemainingBytes = estRemainingParts * Math.round(fragStats.loaded / estLoadedParts);
fragStats.total = fragStats.loaded + estRemainingBytes;
} else {
fragStats.total = Math.max(fragStats.loaded, fragStats.total);
}
var fragLoading = fragStats.loading;
var partLoading = partStats.loading;
if (fragLoading.start) {
// add to fragment loader latency
fragLoading.first += partLoading.first - partLoading.start;
} else {
fragLoading.start = partLoading.start;
fragLoading.first = partLoading.first;
}
fragLoading.end = partLoading.end;
};
_proto.resetLoader = function resetLoader(frag, loader) {
frag.loader = null;
if (this.loader === loader) {
self.clearTimeout(this.partLoadTimeout);
this.loader = null;
}
loader.destroy();
};
return FragmentLoader;
}();
function createLoaderContext(frag, part) {
if (part === void 0) {
part = null;
}
var segment = part || frag;
var loaderContext = {
frag: frag,
part: part,
responseType: 'arraybuffer',
url: segment.url,
rangeStart: 0,
rangeEnd: 0
};
var start = segment.byteRangeStartOffset;
var end = segment.byteRangeEndOffset;
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(start) && Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(end)) {
loaderContext.rangeStart = start;
loaderContext.rangeEnd = end;
}
return loaderContext;
}
var LoadError = /*#__PURE__*/function (_Error) {
_inheritsLoose(LoadError, _Error);
function LoadError(data) {
var _this3;
for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
params[_key - 1] = arguments[_key];
}
_this3 = _Error.call.apply(_Error, [this].concat(params)) || this;
_this3.data = void 0;
_this3.data = data;
return _this3;
}
return LoadError;
}( /*#__PURE__*/_wrapNativeSuper(Error));
/***/ }),
/***/ "./src/loader/fragment.ts":
/*!********************************!*\
!*** ./src/loader/fragment.ts ***!
\********************************/
/*! exports provided: ElementaryStreamTypes, BaseSegment, Fragment, Part */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ElementaryStreamTypes", function() { return ElementaryStreamTypes; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BaseSegment", function() { return BaseSegment; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Fragment", function() { return Fragment; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Part", function() { return Part; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var url_toolkit__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! url-toolkit */ "./node_modules/url-toolkit/src/url-toolkit.js");
/* harmony import */ var url_toolkit__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(url_toolkit__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _level_key__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./level-key */ "./src/loader/level-key.ts");
/* harmony import */ var _load_stats__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./load-stats */ "./src/loader/load-stats.ts");
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var ElementaryStreamTypes;
(function (ElementaryStreamTypes) {
ElementaryStreamTypes["AUDIO"] = "audio";
ElementaryStreamTypes["VIDEO"] = "video";
ElementaryStreamTypes["AUDIOVIDEO"] = "audiovideo";
})(ElementaryStreamTypes || (ElementaryStreamTypes = {}));
var BaseSegment = /*#__PURE__*/function () {
// baseurl is the URL to the playlist
// relurl is the portion of the URL that comes from inside the playlist.
// Holds the types of data this fragment supports
function BaseSegment(baseurl) {
var _this$elementaryStrea;
this._byteRange = null;
this._url = null;
this.baseurl = void 0;
this.relurl = void 0;
this.elementaryStreams = (_this$elementaryStrea = {}, _this$elementaryStrea[ElementaryStreamTypes.AUDIO] = null, _this$elementaryStrea[ElementaryStreamTypes.VIDEO] = null, _this$elementaryStrea[ElementaryStreamTypes.AUDIOVIDEO] = null, _this$elementaryStrea);
this.baseurl = baseurl;
} // setByteRange converts a EXT-X-BYTERANGE attribute into a two element array
var _proto = BaseSegment.prototype;
_proto.setByteRange = function setByteRange(value, previous) {
var params = value.split('@', 2);
var byteRange = [];
if (params.length === 1) {
byteRange[0] = previous ? previous.byteRangeEndOffset : 0;
} else {
byteRange[0] = parseInt(params[1]);
}
byteRange[1] = parseInt(params[0]) + byteRange[0];
this._byteRange = byteRange;
};
_createClass(BaseSegment, [{
key: "byteRange",
get: function get() {
if (!this._byteRange) {
return [];
}
return this._byteRange;
}
}, {
key: "byteRangeStartOffset",
get: function get() {
return this.byteRange[0];
}
}, {
key: "byteRangeEndOffset",
get: function get() {
return this.byteRange[1];
}
}, {
key: "url",
get: function get() {
if (!this._url && this.baseurl && this.relurl) {
this._url = Object(url_toolkit__WEBPACK_IMPORTED_MODULE_1__["buildAbsoluteURL"])(this.baseurl, this.relurl, {
alwaysNormalize: true
});
}
return this._url || '';
},
set: function set(value) {
this._url = value;
}
}]);
return BaseSegment;
}();
var Fragment = /*#__PURE__*/function (_BaseSegment) {
_inheritsLoose(Fragment, _BaseSegment);
// EXTINF has to be present for a m38 to be considered valid
// sn notates the sequence number for a segment, and if set to a string can be 'initSegment'
// levelkey is the EXT-X-KEY that applies to this segment for decryption
// core difference from the private field _decryptdata is the lack of the initialized IV
// _decryptdata will set the IV for this segment based on the segment number in the fragment
// A string representing the fragment type
// A reference to the loader. Set while the fragment is loading, and removed afterwards. Used to abort fragment loading
// The level/track index to which the fragment belongs
// The continuity counter of the fragment
// The starting Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
// The ending Presentation Time Stamp (PTS) of the fragment. Set after transmux complete.
// The latest Presentation Time Stamp (PTS) appended to the buffer.
// The starting Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
// The ending Decode Time Stamp (DTS) of the fragment. Set after transmux complete.
// The start time of the fragment, as listed in the manifest. Updated after transmux complete.
// Set by `updateFragPTSDTS` in level-helper
// The maximum starting Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
// The minimum ending Presentation Time Stamp (audio/video PTS) of the fragment. Set after transmux complete.
// Load/parse timing information
// A flag indicating whether the segment was downloaded in order to test bitrate, and was not buffered
// #EXTINF segment title
// The Media Initialization Section for this segment
function Fragment(type, baseurl) {
var _this;
_this = _BaseSegment.call(this, baseurl) || this;
_this._decryptdata = null;
_this.rawProgramDateTime = null;
_this.programDateTime = null;
_this.tagList = [];
_this.duration = 0;
_this.sn = 0;
_this.levelkey = void 0;
_this.type = void 0;
_this.loader = null;
_this.level = -1;
_this.cc = 0;
_this.startPTS = void 0;
_this.endPTS = void 0;
_this.appendedPTS = void 0;
_this.startDTS = void 0;
_this.endDTS = void 0;
_this.start = 0;
_this.deltaPTS = void 0;
_this.maxStartPTS = void 0;
_this.minEndPTS = void 0;
_this.stats = new _load_stats__WEBPACK_IMPORTED_MODULE_4__["LoadStats"]();
_this.urlId = 0;
_this.data = void 0;
_this.bitrateTest = false;
_this.title = null;
_this.initSegment = null;
_this.type = type;
return _this;
}
var _proto2 = Fragment.prototype;
/**
* Utility method for parseLevelPlaylist to create an initialization vector for a given segment
* @param {number} segmentNumber - segment number to generate IV with
* @returns {Uint8Array}
*/
_proto2.createInitializationVector = function createInitializationVector(segmentNumber) {
var uint8View = new Uint8Array(16);
for (var i = 12; i < 16; i++) {
uint8View[i] = segmentNumber >> 8 * (15 - i) & 0xff;
}
return uint8View;
}
/**
* Utility method for parseLevelPlaylist to get a fragment's decryption data from the currently parsed encryption key data
* @param levelkey - a playlist's encryption info
* @param segmentNumber - the fragment's segment number
* @returns {LevelKey} - an object to be applied as a fragment's decryptdata
*/
;
_proto2.setDecryptDataFromLevelKey = function setDecryptDataFromLevelKey(levelkey, segmentNumber) {
var decryptdata = levelkey;
if ((levelkey === null || levelkey === void 0 ? void 0 : levelkey.method) === 'AES-128' && levelkey.uri && !levelkey.iv) {
decryptdata = _level_key__WEBPACK_IMPORTED_MODULE_3__["LevelKey"].fromURI(levelkey.uri);
decryptdata.method = levelkey.method;
decryptdata.iv = this.createInitializationVector(segmentNumber);
decryptdata.keyFormat = 'identity';
}
return decryptdata;
};
_proto2.setElementaryStreamInfo = function setElementaryStreamInfo(type, startPTS, endPTS, startDTS, endDTS, partial) {
if (partial === void 0) {
partial = false;
}
var elementaryStreams = this.elementaryStreams;
var info = elementaryStreams[type];
if (!info) {
elementaryStreams[type] = {
startPTS: startPTS,
endPTS: endPTS,
startDTS: startDTS,
endDTS: endDTS,
partial: partial
};
return;
}
info.startPTS = Math.min(info.startPTS, startPTS);
info.endPTS = Math.max(info.endPTS, endPTS);
info.startDTS = Math.min(info.startDTS, startDTS);
info.endDTS = Math.max(info.endDTS, endDTS);
};
_proto2.clearElementaryStreamInfo = function clearElementaryStreamInfo() {
var elementaryStreams = this.elementaryStreams;
elementaryStreams[ElementaryStreamTypes.AUDIO] = null;
elementaryStreams[ElementaryStreamTypes.VIDEO] = null;
elementaryStreams[ElementaryStreamTypes.AUDIOVIDEO] = null;
};
_createClass(Fragment, [{
key: "decryptdata",
get: function get() {
if (!this.levelkey && !this._decryptdata) {
return null;
}
if (!this._decryptdata && this.levelkey) {
var sn = this.sn;
if (typeof sn !== 'number') {
// We are fetching decryption data for a initialization segment
// If the segment was encrypted with AES-128
// It must have an IV defined. We cannot substitute the Segment Number in.
if (this.levelkey && this.levelkey.method === 'AES-128' && !this.levelkey.iv) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("missing IV for initialization segment with method=\"" + this.levelkey.method + "\" - compliance issue");
}
/*
Be converted to a Number.
'initSegment' will become NaN.
NaN, which when converted through ToInt32() -> +0.
---
Explicitly set sn to resulting value from implicit conversions 'initSegment' values for IV generation.
*/
sn = 0;
}
this._decryptdata = this.setDecryptDataFromLevelKey(this.levelkey, sn);
}
return this._decryptdata;
}
}, {
key: "end",
get: function get() {
return this.start + this.duration;
}
}, {
key: "endProgramDateTime",
get: function get() {
if (this.programDateTime === null) {
return null;
}
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(this.programDateTime)) {
return null;
}
var duration = !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(this.duration) ? 0 : this.duration;
return this.programDateTime + duration * 1000;
}
}, {
key: "encrypted",
get: function get() {
var _this$decryptdata;
// At the m3u8-parser level we need to add support for manifest signalled keyformats
// when we want the fragment to start reporting that it is encrypted.
// Currently, keyFormat will only be set for identity keys
if ((_this$decryptdata = this.decryptdata) !== null && _this$decryptdata !== void 0 && _this$decryptdata.keyFormat && this.decryptdata.uri) {
return true;
}
return false;
}
}]);
return Fragment;
}(BaseSegment);
var Part = /*#__PURE__*/function (_BaseSegment2) {
_inheritsLoose(Part, _BaseSegment2);
function Part(partAttrs, frag, baseurl, index, previous) {
var _this2;
_this2 = _BaseSegment2.call(this, baseurl) || this;
_this2.fragOffset = 0;
_this2.duration = 0;
_this2.gap = false;
_this2.independent = false;
_this2.relurl = void 0;
_this2.fragment = void 0;
_this2.index = void 0;
_this2.stats = new _load_stats__WEBPACK_IMPORTED_MODULE_4__["LoadStats"]();
_this2.duration = partAttrs.decimalFloatingPoint('DURATION');
_this2.gap = partAttrs.bool('GAP');
_this2.independent = partAttrs.bool('INDEPENDENT');
_this2.relurl = partAttrs.enumeratedString('URI');
_this2.fragment = frag;
_this2.index = index;
var byteRange = partAttrs.enumeratedString('BYTERANGE');
if (byteRange) {
_this2.setByteRange(byteRange, previous);
}
if (previous) {
_this2.fragOffset = previous.fragOffset + previous.duration;
}
return _this2;
}
_createClass(Part, [{
key: "start",
get: function get() {
return this.fragment.start + this.fragOffset;
}
}, {
key: "end",
get: function get() {
return this.start + this.duration;
}
}, {
key: "loaded",
get: function get() {
var elementaryStreams = this.elementaryStreams;
return !!(elementaryStreams.audio || elementaryStreams.video || elementaryStreams.audiovideo);
}
}]);
return Part;
}(BaseSegment);
/***/ }),
/***/ "./src/loader/key-loader.ts":
/*!**********************************!*\
!*** ./src/loader/key-loader.ts ***!
\**********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return KeyLoader; });
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/*
* Decrypt key Loader
*/
var KeyLoader = /*#__PURE__*/function () {
function KeyLoader(hls) {
this.hls = void 0;
this.loaders = {};
this.decryptkey = null;
this.decrypturl = null;
this.hls = hls;
this._registerListeners();
}
var _proto = KeyLoader.prototype;
_proto._registerListeners = function _registerListeners() {
this.hls.on(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].KEY_LOADING, this.onKeyLoading, this);
};
_proto._unregisterListeners = function _unregisterListeners() {
this.hls.off(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].KEY_LOADING, this.onKeyLoading);
};
_proto.destroy = function destroy() {
this._unregisterListeners();
for (var loaderName in this.loaders) {
var loader = this.loaders[loaderName];
if (loader) {
loader.destroy();
}
}
this.loaders = {};
};
_proto.onKeyLoading = function onKeyLoading(event, data) {
var frag = data.frag;
var type = frag.type;
var loader = this.loaders[type];
if (!frag.decryptdata) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn('Missing decryption data on fragment in onKeyLoading');
return;
} // Load the key if the uri is different from previous one, or if the decrypt key has not yet been retrieved
var uri = frag.decryptdata.uri;
if (uri !== this.decrypturl || this.decryptkey === null) {
var config = this.hls.config;
if (loader) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn("abort previous key loader for type:" + type);
loader.abort();
}
if (!uri) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].warn('key uri is falsy');
return;
}
var Loader = config.loader;
var fragLoader = frag.loader = this.loaders[type] = new Loader(config);
this.decrypturl = uri;
this.decryptkey = null;
var loaderContext = {
url: uri,
frag: frag,
responseType: 'arraybuffer'
}; // maxRetry is 0 so that instead of retrying the same key on the same variant multiple times,
// key-loader will trigger an error and rely on stream-controller to handle retry logic.
// this will also align retry logic with fragment-loader
var loaderConfig = {
timeout: config.fragLoadingTimeOut,
maxRetry: 0,
retryDelay: config.fragLoadingRetryDelay,
maxRetryDelay: config.fragLoadingMaxRetryTimeout,
highWaterMark: 0
};
var loaderCallbacks = {
onSuccess: this.loadsuccess.bind(this),
onError: this.loaderror.bind(this),
onTimeout: this.loadtimeout.bind(this)
};
fragLoader.load(loaderContext, loaderConfig, loaderCallbacks);
} else if (this.decryptkey) {
// Return the key if it's already been loaded
frag.decryptdata.key = this.decryptkey;
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].KEY_LOADED, {
frag: frag
});
}
};
_proto.loadsuccess = function loadsuccess(response, stats, context) {
var frag = context.frag;
if (!frag.decryptdata) {
_utils_logger__WEBPACK_IMPORTED_MODULE_2__["logger"].error('after key load, decryptdata unset');
return;
}
this.decryptkey = frag.decryptdata.key = new Uint8Array(response.data); // detach fragment loader on load success
frag.loader = null;
delete this.loaders[frag.type];
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].KEY_LOADED, {
frag: frag
});
};
_proto.loaderror = function loaderror(response, context) {
var frag = context.frag;
var loader = frag.loader;
if (loader) {
loader.abort();
}
delete this.loaders[frag.type];
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_LOAD_ERROR,
fatal: false,
frag: frag,
response: response
});
};
_proto.loadtimeout = function loadtimeout(stats, context) {
var frag = context.frag;
var loader = frag.loader;
if (loader) {
loader.abort();
}
delete this.loaders[frag.type];
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_0__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_1__["ErrorDetails"].KEY_LOAD_TIMEOUT,
fatal: false,
frag: frag
});
};
return KeyLoader;
}();
/***/ }),
/***/ "./src/loader/level-details.ts":
/*!*************************************!*\
!*** ./src/loader/level-details.ts ***!
\*************************************/
/*! exports provided: LevelDetails */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LevelDetails", function() { return LevelDetails; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var DEFAULT_TARGET_DURATION = 10;
var LevelDetails = /*#__PURE__*/function () {
// Manifest reload synchronization
function LevelDetails(baseUrl) {
this.PTSKnown = false;
this.alignedSliding = false;
this.averagetargetduration = void 0;
this.endCC = 0;
this.endSN = 0;
this.fragments = void 0;
this.fragmentHint = void 0;
this.partList = null;
this.live = true;
this.ageHeader = 0;
this.advancedDateTime = void 0;
this.updated = true;
this.advanced = true;
this.availabilityDelay = void 0;
this.misses = 0;
this.needSidxRanges = false;
this.startCC = 0;
this.startSN = 0;
this.startTimeOffset = null;
this.targetduration = 0;
this.totalduration = 0;
this.type = null;
this.url = void 0;
this.m3u8 = '';
this.version = null;
this.canBlockReload = false;
this.canSkipUntil = 0;
this.canSkipDateRanges = false;
this.skippedSegments = 0;
this.recentlyRemovedDateranges = void 0;
this.partHoldBack = 0;
this.holdBack = 0;
this.partTarget = 0;
this.preloadHint = void 0;
this.renditionReports = void 0;
this.tuneInGoal = 0;
this.deltaUpdateFailed = void 0;
this.driftStartTime = 0;
this.driftEndTime = 0;
this.driftStart = 0;
this.driftEnd = 0;
this.fragments = [];
this.url = baseUrl;
}
var _proto = LevelDetails.prototype;
_proto.reloaded = function reloaded(previous) {
if (!previous) {
this.advanced = true;
this.updated = true;
return;
}
var partSnDiff = this.lastPartSn - previous.lastPartSn;
var partIndexDiff = this.lastPartIndex - previous.lastPartIndex;
this.updated = this.endSN !== previous.endSN || !!partIndexDiff || !!partSnDiff;
this.advanced = this.endSN > previous.endSN || partSnDiff > 0 || partSnDiff === 0 && partIndexDiff > 0;
if (this.updated || this.advanced) {
this.misses = Math.floor(previous.misses * 0.6);
} else {
this.misses = previous.misses + 1;
}
this.availabilityDelay = previous.availabilityDelay;
};
_createClass(LevelDetails, [{
key: "hasProgramDateTime",
get: function get() {
if (this.fragments.length) {
return Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(this.fragments[this.fragments.length - 1].programDateTime);
}
return false;
}
}, {
key: "levelTargetDuration",
get: function get() {
return this.averagetargetduration || this.targetduration || DEFAULT_TARGET_DURATION;
}
}, {
key: "drift",
get: function get() {
var runTime = this.driftEndTime - this.driftStartTime;
if (runTime > 0) {
var runDuration = this.driftEnd - this.driftStart;
return runDuration * 1000 / runTime;
}
return 1;
}
}, {
key: "edge",
get: function get() {
return this.partEnd || this.fragmentEnd;
}
}, {
key: "partEnd",
get: function get() {
var _this$partList;
if ((_this$partList = this.partList) !== null && _this$partList !== void 0 && _this$partList.length) {
return this.partList[this.partList.length - 1].end;
}
return this.fragmentEnd;
}
}, {
key: "fragmentEnd",
get: function get() {
var _this$fragments;
if ((_this$fragments = this.fragments) !== null && _this$fragments !== void 0 && _this$fragments.length) {
return this.fragments[this.fragments.length - 1].end;
}
return 0;
}
}, {
key: "age",
get: function get() {
if (this.advancedDateTime) {
return Math.max(Date.now() - this.advancedDateTime, 0) / 1000;
}
return 0;
}
}, {
key: "lastPartIndex",
get: function get() {
var _this$partList2;
if ((_this$partList2 = this.partList) !== null && _this$partList2 !== void 0 && _this$partList2.length) {
return this.partList[this.partList.length - 1].index;
}
return -1;
}
}, {
key: "lastPartSn",
get: function get() {
var _this$partList3;
if ((_this$partList3 = this.partList) !== null && _this$partList3 !== void 0 && _this$partList3.length) {
return this.partList[this.partList.length - 1].fragment.sn;
}
return this.endSN;
}
}]);
return LevelDetails;
}();
/***/ }),
/***/ "./src/loader/level-key.ts":
/*!*********************************!*\
!*** ./src/loader/level-key.ts ***!
\*********************************/
/*! exports provided: LevelKey */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LevelKey", function() { return LevelKey; });
/* harmony import */ var url_toolkit__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! url-toolkit */ "./node_modules/url-toolkit/src/url-toolkit.js");
/* harmony import */ var url_toolkit__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(url_toolkit__WEBPACK_IMPORTED_MODULE_0__);
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var LevelKey = /*#__PURE__*/function () {
LevelKey.fromURL = function fromURL(baseUrl, relativeUrl) {
return new LevelKey(baseUrl, relativeUrl);
};
LevelKey.fromURI = function fromURI(uri) {
return new LevelKey(uri);
};
function LevelKey(absoluteOrBaseURI, relativeURL) {
this._uri = null;
this.method = null;
this.keyFormat = null;
this.keyFormatVersions = null;
this.keyID = null;
this.key = null;
this.iv = null;
if (relativeURL) {
this._uri = Object(url_toolkit__WEBPACK_IMPORTED_MODULE_0__["buildAbsoluteURL"])(absoluteOrBaseURI, relativeURL, {
alwaysNormalize: true
});
} else {
this._uri = absoluteOrBaseURI;
}
}
_createClass(LevelKey, [{
key: "uri",
get: function get() {
return this._uri;
}
}]);
return LevelKey;
}();
/***/ }),
/***/ "./src/loader/load-stats.ts":
/*!**********************************!*\
!*** ./src/loader/load-stats.ts ***!
\**********************************/
/*! exports provided: LoadStats */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LoadStats", function() { return LoadStats; });
var LoadStats = function LoadStats() {
this.aborted = false;
this.loaded = 0;
this.retry = 0;
this.total = 0;
this.chunkCount = 0;
this.bwEstimate = 0;
this.loading = {
start: 0,
first: 0,
end: 0
};
this.parsing = {
start: 0,
end: 0
};
this.buffering = {
start: 0,
first: 0,
end: 0
};
};
/***/ }),
/***/ "./src/loader/m3u8-parser.ts":
/*!***********************************!*\
!*** ./src/loader/m3u8-parser.ts ***!
\***********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return M3U8Parser; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var url_toolkit__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! url-toolkit */ "./node_modules/url-toolkit/src/url-toolkit.js");
/* harmony import */ var url_toolkit__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(url_toolkit__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _fragment__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./fragment */ "./src/loader/fragment.ts");
/* harmony import */ var _level_details__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./level-details */ "./src/loader/level-details.ts");
/* harmony import */ var _level_key__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./level-key */ "./src/loader/level-key.ts");
/* harmony import */ var _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/attr-list */ "./src/utils/attr-list.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _utils_codecs__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../utils/codecs */ "./src/utils/codecs.ts");
// https://regex101.com is your friend
var MASTER_PLAYLIST_REGEX = /#EXT-X-STREAM-INF:([^\r\n]*)(?:[\r\n](?:#[^\r\n]*)?)*([^\r\n]+)|#EXT-X-SESSION-DATA:([^\r\n]*)[\r\n]+/g;
var MASTER_PLAYLIST_MEDIA_REGEX = /#EXT-X-MEDIA:(.*)/g;
var LEVEL_PLAYLIST_REGEX_FAST = new RegExp([/#EXTINF:\s*(\d*(?:\.\d+)?)(?:,(.*)\s+)?/.source, // duration (#EXTINF:<duration>,<title>), group 1 => duration, group 2 => title
/(?!#) *(\S[\S ]*)/.source, // segment URI, group 3 => the URI (note newline is not eaten)
/#EXT-X-BYTERANGE:*(.+)/.source, // next segment's byterange, group 4 => range spec (x@y)
/#EXT-X-PROGRAM-DATE-TIME:(.+)/.source, // next segment's program date/time group 5 => the datetime spec
/#.*/.source // All other non-segment oriented tags will match with all groups empty
].join('|'), 'g');
var LEVEL_PLAYLIST_REGEX_SLOW = new RegExp([/#(EXTM3U)/.source, /#EXT-X-(PLAYLIST-TYPE):(.+)/.source, /#EXT-X-(MEDIA-SEQUENCE): *(\d+)/.source, /#EXT-X-(SKIP):(.+)/.source, /#EXT-X-(TARGETDURATION): *(\d+)/.source, /#EXT-X-(KEY):(.+)/.source, /#EXT-X-(START):(.+)/.source, /#EXT-X-(ENDLIST)/.source, /#EXT-X-(DISCONTINUITY-SEQ)UENCE: *(\d+)/.source, /#EXT-X-(DIS)CONTINUITY/.source, /#EXT-X-(VERSION):(\d+)/.source, /#EXT-X-(MAP):(.+)/.source, /#EXT-X-(SERVER-CONTROL):(.+)/.source, /#EXT-X-(PART-INF):(.+)/.source, /#EXT-X-(GAP)/.source, /#EXT-X-(BITRATE):\s*(\d+)/.source, /#EXT-X-(PART):(.+)/.source, /#EXT-X-(PRELOAD-HINT):(.+)/.source, /#EXT-X-(RENDITION-REPORT):(.+)/.source, /(#)([^:]*):(.*)/.source, /(#)(.*)(?:.*)\r?\n?/.source].join('|'));
var MP4_REGEX_SUFFIX = /\.(mp4|m4s|m4v|m4a)$/i;
function isMP4Url(url) {
var _URLToolkit$parseURL$, _URLToolkit$parseURL;
return MP4_REGEX_SUFFIX.test((_URLToolkit$parseURL$ = (_URLToolkit$parseURL = url_toolkit__WEBPACK_IMPORTED_MODULE_1__["parseURL"](url)) === null || _URLToolkit$parseURL === void 0 ? void 0 : _URLToolkit$parseURL.path) != null ? _URLToolkit$parseURL$ : '');
}
var M3U8Parser = /*#__PURE__*/function () {
function M3U8Parser() {}
M3U8Parser.findGroup = function findGroup(groups, mediaGroupId) {
for (var i = 0; i < groups.length; i++) {
var group = groups[i];
if (group.id === mediaGroupId) {
return group;
}
}
};
M3U8Parser.convertAVC1ToAVCOTI = function convertAVC1ToAVCOTI(codec) {
// Convert avc1 codec string from RFC-4281 to RFC-6381 for MediaSource.isTypeSupported
var avcdata = codec.split('.');
if (avcdata.length > 2) {
var result = avcdata.shift() + '.';
result += parseInt(avcdata.shift()).toString(16);
result += ('000' + parseInt(avcdata.shift()).toString(16)).substr(-4);
return result;
}
return codec;
};
M3U8Parser.resolve = function resolve(url, baseUrl) {
return url_toolkit__WEBPACK_IMPORTED_MODULE_1__["buildAbsoluteURL"](baseUrl, url, {
alwaysNormalize: true
});
};
M3U8Parser.parseMasterPlaylist = function parseMasterPlaylist(string, baseurl) {
var levels = [];
var sessionData = {};
var hasSessionData = false;
MASTER_PLAYLIST_REGEX.lastIndex = 0;
var result;
while ((result = MASTER_PLAYLIST_REGEX.exec(string)) != null) {
if (result[1]) {
// '#EXT-X-STREAM-INF' is found, parse level tag in group 1
var attrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](result[1]);
var level = {
attrs: attrs,
bitrate: attrs.decimalInteger('AVERAGE-BANDWIDTH') || attrs.decimalInteger('BANDWIDTH'),
name: attrs.NAME,
url: M3U8Parser.resolve(result[2], baseurl)
};
var resolution = attrs.decimalResolution('RESOLUTION');
if (resolution) {
level.width = resolution.width;
level.height = resolution.height;
}
setCodecs((attrs.CODECS || '').split(/[ ,]+/).filter(function (c) {
return c;
}), level);
if (level.videoCodec && level.videoCodec.indexOf('avc1') !== -1) {
level.videoCodec = M3U8Parser.convertAVC1ToAVCOTI(level.videoCodec);
}
levels.push(level);
} else if (result[3]) {
// '#EXT-X-SESSION-DATA' is found, parse session data in group 3
var sessionAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](result[3]);
if (sessionAttrs['DATA-ID']) {
hasSessionData = true;
sessionData[sessionAttrs['DATA-ID']] = sessionAttrs;
}
}
}
return {
levels: levels,
sessionData: hasSessionData ? sessionData : null
};
};
M3U8Parser.parseMasterPlaylistMedia = function parseMasterPlaylistMedia(string, baseurl, type, groups) {
if (groups === void 0) {
groups = [];
}
var result;
var medias = [];
var id = 0;
MASTER_PLAYLIST_MEDIA_REGEX.lastIndex = 0;
while ((result = MASTER_PLAYLIST_MEDIA_REGEX.exec(string)) !== null) {
var attrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](result[1]);
if (attrs.TYPE === type) {
var media = {
attrs: attrs,
bitrate: 0,
id: id++,
groupId: attrs['GROUP-ID'],
instreamId: attrs['INSTREAM-ID'],
name: attrs.NAME || attrs.LANGUAGE || '',
type: type,
default: attrs.bool('DEFAULT'),
autoselect: attrs.bool('AUTOSELECT'),
forced: attrs.bool('FORCED'),
lang: attrs.LANGUAGE,
url: attrs.URI ? M3U8Parser.resolve(attrs.URI, baseurl) : ''
};
if (groups.length) {
// If there are audio or text groups signalled in the manifest, let's look for a matching codec string for this track
// If we don't find the track signalled, lets use the first audio groups codec we have
// Acting as a best guess
var groupCodec = M3U8Parser.findGroup(groups, media.groupId) || groups[0];
assignCodec(media, groupCodec, 'audioCodec');
assignCodec(media, groupCodec, 'textCodec');
}
medias.push(media);
}
}
return medias;
};
M3U8Parser.parseLevelPlaylist = function parseLevelPlaylist(string, baseurl, id, type, levelUrlId) {
var level = new _level_details__WEBPACK_IMPORTED_MODULE_3__["LevelDetails"](baseurl);
var fragments = level.fragments; // The most recent init segment seen (applies to all subsequent segments)
var currentInitSegment = null;
var currentSN = 0;
var currentPart = 0;
var totalduration = 0;
var discontinuityCounter = 0;
var prevFrag = null;
var frag = new _fragment__WEBPACK_IMPORTED_MODULE_2__["Fragment"](type, baseurl);
var result;
var i;
var levelkey;
var firstPdtIndex = -1;
var createNextFrag = false;
LEVEL_PLAYLIST_REGEX_FAST.lastIndex = 0;
level.m3u8 = string;
while ((result = LEVEL_PLAYLIST_REGEX_FAST.exec(string)) !== null) {
if (createNextFrag) {
createNextFrag = false;
frag = new _fragment__WEBPACK_IMPORTED_MODULE_2__["Fragment"](type, baseurl); // setup the next fragment for part loading
frag.start = totalduration;
frag.sn = currentSN;
frag.cc = discontinuityCounter;
frag.level = id;
if (currentInitSegment) {
frag.initSegment = currentInitSegment;
frag.rawProgramDateTime = currentInitSegment.rawProgramDateTime;
}
}
var duration = result[1];
if (duration) {
// INF
frag.duration = parseFloat(duration); // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
var title = (' ' + result[2]).slice(1);
frag.title = title || null;
frag.tagList.push(title ? ['INF', duration, title] : ['INF', duration]);
} else if (result[3]) {
// url
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(frag.duration)) {
frag.start = totalduration;
if (levelkey) {
frag.levelkey = levelkey;
}
frag.sn = currentSN;
frag.level = id;
frag.cc = discontinuityCounter;
frag.urlId = levelUrlId;
fragments.push(frag); // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
frag.relurl = (' ' + result[3]).slice(1);
assignProgramDateTime(frag, prevFrag);
prevFrag = frag;
totalduration += frag.duration;
currentSN++;
currentPart = 0;
createNextFrag = true;
}
} else if (result[4]) {
// X-BYTERANGE
var data = (' ' + result[4]).slice(1);
if (prevFrag) {
frag.setByteRange(data, prevFrag);
} else {
frag.setByteRange(data);
}
} else if (result[5]) {
// PROGRAM-DATE-TIME
// avoid sliced strings https://github.com/video-dev/hls.js/issues/939
frag.rawProgramDateTime = (' ' + result[5]).slice(1);
frag.tagList.push(['PROGRAM-DATE-TIME', frag.rawProgramDateTime]);
if (firstPdtIndex === -1) {
firstPdtIndex = fragments.length;
}
} else {
result = result[0].match(LEVEL_PLAYLIST_REGEX_SLOW);
if (!result) {
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].warn('No matches on slow regex match for level playlist!');
continue;
}
for (i = 1; i < result.length; i++) {
if (typeof result[i] !== 'undefined') {
break;
}
} // avoid sliced strings https://github.com/video-dev/hls.js/issues/939
var tag = (' ' + result[i]).slice(1);
var value1 = (' ' + result[i + 1]).slice(1);
var value2 = result[i + 2] ? (' ' + result[i + 2]).slice(1) : '';
switch (tag) {
case 'PLAYLIST-TYPE':
level.type = value1.toUpperCase();
break;
case 'MEDIA-SEQUENCE':
currentSN = level.startSN = parseInt(value1);
break;
case 'SKIP':
{
var skipAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1);
var skippedSegments = skipAttrs.decimalInteger('SKIPPED-SEGMENTS');
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(skippedSegments)) {
level.skippedSegments = skippedSegments; // This will result in fragments[] containing undefined values, which we will fill in with `mergeDetails`
for (var _i = skippedSegments; _i--;) {
fragments.unshift(null);
}
currentSN += skippedSegments;
}
var recentlyRemovedDateranges = skipAttrs.enumeratedString('RECENTLY-REMOVED-DATERANGES');
if (recentlyRemovedDateranges) {
level.recentlyRemovedDateranges = recentlyRemovedDateranges.split('\t');
}
break;
}
case 'TARGETDURATION':
level.targetduration = parseFloat(value1);
break;
case 'VERSION':
level.version = parseInt(value1);
break;
case 'EXTM3U':
break;
case 'ENDLIST':
level.live = false;
break;
case '#':
if (value1 || value2) {
frag.tagList.push(value2 ? [value1, value2] : [value1]);
}
break;
case 'DIS':
discontinuityCounter++;
/* falls through */
case 'GAP':
frag.tagList.push([tag]);
break;
case 'BITRATE':
frag.tagList.push([tag, value1]);
break;
case 'DISCONTINUITY-SEQ':
discontinuityCounter = parseInt(value1);
break;
case 'KEY':
{
var _keyAttrs$enumeratedS;
// https://tools.ietf.org/html/rfc8216#section-4.3.2.4
var keyAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1);
var decryptmethod = keyAttrs.enumeratedString('METHOD');
var decrypturi = keyAttrs.URI;
var decryptiv = keyAttrs.hexadecimalInteger('IV');
var decryptkeyformatversions = keyAttrs.enumeratedString('KEYFORMATVERSIONS');
var decryptkeyid = keyAttrs.enumeratedString('KEYID'); // From RFC: This attribute is OPTIONAL; its absence indicates an implicit value of "identity".
var decryptkeyformat = (_keyAttrs$enumeratedS = keyAttrs.enumeratedString('KEYFORMAT')) != null ? _keyAttrs$enumeratedS : 'identity';
var unsupportedKnownKeyformatsInManifest = ['com.apple.streamingkeydelivery', 'com.microsoft.playready', 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed', // widevine (v2)
'com.widevine' // earlier widevine (v1)
];
if (unsupportedKnownKeyformatsInManifest.indexOf(decryptkeyformat) > -1) {
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].warn("Keyformat " + decryptkeyformat + " is not supported from the manifest");
continue;
} else if (decryptkeyformat !== 'identity') {
// We are supposed to skip keys we don't understand.
// As we currently only officially support identity keys
// from the manifest we shouldn't save any other key.
continue;
} // TODO: multiple keys can be defined on a fragment, and we need to support this
// for clients that support both playready and widevine
if (decryptmethod) {
// TODO: need to determine if the level key is actually a relative URL
// if it isn't, then we should instead construct the LevelKey using fromURI.
levelkey = _level_key__WEBPACK_IMPORTED_MODULE_4__["LevelKey"].fromURL(baseurl, decrypturi);
if (decrypturi && ['AES-128', 'SAMPLE-AES', 'SAMPLE-AES-CENC'].indexOf(decryptmethod) >= 0) {
levelkey.method = decryptmethod;
levelkey.keyFormat = decryptkeyformat;
if (decryptkeyid) {
levelkey.keyID = decryptkeyid;
}
if (decryptkeyformatversions) {
levelkey.keyFormatVersions = decryptkeyformatversions;
} // Initialization Vector (IV)
levelkey.iv = decryptiv;
}
}
break;
}
case 'START':
{
var startAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1);
var startTimeOffset = startAttrs.decimalFloatingPoint('TIME-OFFSET'); // TIME-OFFSET can be 0
if (Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(startTimeOffset)) {
level.startTimeOffset = startTimeOffset;
}
break;
}
case 'MAP':
{
var mapAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1);
frag.relurl = mapAttrs.URI;
if (mapAttrs.BYTERANGE) {
frag.setByteRange(mapAttrs.BYTERANGE);
}
frag.level = id;
frag.sn = 'initSegment';
if (levelkey) {
frag.levelkey = levelkey;
}
frag.initSegment = null;
currentInitSegment = frag;
createNextFrag = true;
break;
}
case 'SERVER-CONTROL':
{
var serverControlAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1);
level.canBlockReload = serverControlAttrs.bool('CAN-BLOCK-RELOAD');
level.canSkipUntil = serverControlAttrs.optionalFloat('CAN-SKIP-UNTIL', 0);
level.canSkipDateRanges = level.canSkipUntil > 0 && serverControlAttrs.bool('CAN-SKIP-DATERANGES');
level.partHoldBack = serverControlAttrs.optionalFloat('PART-HOLD-BACK', 0);
level.holdBack = serverControlAttrs.optionalFloat('HOLD-BACK', 0);
break;
}
case 'PART-INF':
{
var partInfAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1);
level.partTarget = partInfAttrs.decimalFloatingPoint('PART-TARGET');
break;
}
case 'PART':
{
var partList = level.partList;
if (!partList) {
partList = level.partList = [];
}
var previousFragmentPart = currentPart > 0 ? partList[partList.length - 1] : undefined;
var index = currentPart++;
var part = new _fragment__WEBPACK_IMPORTED_MODULE_2__["Part"](new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1), frag, baseurl, index, previousFragmentPart);
partList.push(part);
frag.duration += part.duration;
break;
}
case 'PRELOAD-HINT':
{
var preloadHintAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1);
level.preloadHint = preloadHintAttrs;
break;
}
case 'RENDITION-REPORT':
{
var renditionReportAttrs = new _utils_attr_list__WEBPACK_IMPORTED_MODULE_5__["AttrList"](value1);
level.renditionReports = level.renditionReports || [];
level.renditionReports.push(renditionReportAttrs);
break;
}
default:
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].warn("line parsed but not handled: " + result);
break;
}
}
}
if (prevFrag && !prevFrag.relurl) {
fragments.pop();
totalduration -= prevFrag.duration;
if (level.partList) {
level.fragmentHint = prevFrag;
}
} else if (level.partList) {
assignProgramDateTime(frag, prevFrag);
frag.cc = discontinuityCounter;
level.fragmentHint = frag;
}
var fragmentLength = fragments.length;
var firstFragment = fragments[0];
var lastFragment = fragments[fragmentLength - 1];
totalduration += level.skippedSegments * level.targetduration;
if (totalduration > 0 && fragmentLength && lastFragment) {
level.averagetargetduration = totalduration / fragmentLength;
var lastSn = lastFragment.sn;
level.endSN = lastSn !== 'initSegment' ? lastSn : 0;
if (firstFragment) {
level.startCC = firstFragment.cc;
if (!firstFragment.initSegment) {
// this is a bit lurky but HLS really has no other way to tell us
// if the fragments are TS or MP4, except if we download them :/
// but this is to be able to handle SIDX.
if (level.fragments.every(function (frag) {
return frag.relurl && isMP4Url(frag.relurl);
})) {
_utils_logger__WEBPACK_IMPORTED_MODULE_6__["logger"].warn('MP4 fragments found but no init segment (probably no MAP, incomplete M3U8), trying to fetch SIDX');
frag = new _fragment__WEBPACK_IMPORTED_MODULE_2__["Fragment"](type, baseurl);
frag.relurl = lastFragment.relurl;
frag.level = id;
frag.sn = 'initSegment';
firstFragment.initSegment = frag;
level.needSidxRanges = true;
}
}
}
} else {
level.endSN = 0;
level.startCC = 0;
}
if (level.fragmentHint) {
totalduration += level.fragmentHint.duration;
}
level.totalduration = totalduration;
level.endCC = discontinuityCounter;
/**
* Backfill any missing PDT values
* "If the first EXT-X-PROGRAM-DATE-TIME tag in a Playlist appears after
* one or more Media Segment URIs, the client SHOULD extrapolate
* backward from that tag (using EXTINF durations and/or media
* timestamps) to associate dates with those segments."
* We have already extrapolated forward, but all fragments up to the first instance of PDT do not have their PDTs
* computed.
*/
if (firstPdtIndex > 0) {
backfillProgramDateTimes(fragments, firstPdtIndex);
}
return level;
};
return M3U8Parser;
}();
function setCodecs(codecs, level) {
['video', 'audio', 'text'].forEach(function (type) {
var filtered = codecs.filter(function (codec) {
return Object(_utils_codecs__WEBPACK_IMPORTED_MODULE_7__["isCodecType"])(codec, type);
});
if (filtered.length) {
var preferred = filtered.filter(function (codec) {
return codec.lastIndexOf('avc1', 0) === 0 || codec.lastIndexOf('mp4a', 0) === 0;
});
level[type + "Codec"] = preferred.length > 0 ? preferred[0] : filtered[0]; // remove from list
codecs = codecs.filter(function (codec) {
return filtered.indexOf(codec) === -1;
});
}
});
level.unknownCodecs = codecs;
}
function assignCodec(media, groupItem, codecProperty) {
var codecValue = groupItem[codecProperty];
if (codecValue) {
media[codecProperty] = codecValue;
}
}
function backfillProgramDateTimes(fragments, firstPdtIndex) {
var fragPrev = fragments[firstPdtIndex];
for (var i = firstPdtIndex; i--;) {
var frag = fragments[i]; // Exit on delta-playlist skipped segments
if (!frag) {
return;
}
frag.programDateTime = fragPrev.programDateTime - frag.duration * 1000;
fragPrev = frag;
}
}
function assignProgramDateTime(frag, prevFrag) {
if (frag.rawProgramDateTime) {
frag.programDateTime = Date.parse(frag.rawProgramDateTime);
} else if (prevFrag !== null && prevFrag !== void 0 && prevFrag.programDateTime) {
frag.programDateTime = prevFrag.endProgramDateTime;
}
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(frag.programDateTime)) {
frag.programDateTime = null;
frag.rawProgramDateTime = null;
}
}
/***/ }),
/***/ "./src/loader/playlist-loader.ts":
/*!***************************************!*\
!*** ./src/loader/playlist-loader.ts ***!
\***************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _m3u8_parser__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./m3u8-parser */ "./src/loader/m3u8-parser.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
/* harmony import */ var _utils_attr_list__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../utils/attr-list */ "./src/utils/attr-list.ts");
/**
* PlaylistLoader - delegate for media manifest/playlist loading tasks. Takes care of parsing media to internal data-models.
*
* Once loaded, dispatches events with parsed data-models of manifest/levels/audio/subtitle tracks.
*
* Uses loader(s) set in config to do actual internal loading of resource tasks.
*
* @module
*
*/
function mapContextToLevelType(context) {
var type = context.type;
switch (type) {
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].AUDIO_TRACK:
return _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].AUDIO;
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].SUBTITLE_TRACK:
return _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].SUBTITLE;
default:
return _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].MAIN;
}
}
function getResponseUrl(response, context) {
var url = response.url; // responseURL not supported on some browsers (it is used to detect URL redirection)
// data-uri mode also not supported (but no need to detect redirection)
if (url === undefined || url.indexOf('data:') === 0) {
// fallback to initial URL
url = context.url;
}
return url;
}
var PlaylistLoader = /*#__PURE__*/function () {
function PlaylistLoader(hls) {
this.hls = void 0;
this.loaders = Object.create(null);
this.hls = hls;
this.registerListeners();
}
var _proto = PlaylistLoader.prototype;
_proto.registerListeners = function registerListeners() {
var hls = this.hls;
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_LOADING, this.onLevelLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].AUDIO_TRACK_LOADING, this.onAudioTrackLoading, this);
hls.on(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_TRACK_LOADING, this.onSubtitleTrackLoading, this);
};
_proto.unregisterListeners = function unregisterListeners() {
var hls = this.hls;
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADING, this.onManifestLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_LOADING, this.onLevelLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].AUDIO_TRACK_LOADING, this.onAudioTrackLoading, this);
hls.off(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_TRACK_LOADING, this.onSubtitleTrackLoading, this);
}
/**
* Returns defaults or configured loader-type overloads (pLoader and loader config params)
*/
;
_proto.createInternalLoader = function createInternalLoader(context) {
var config = this.hls.config;
var PLoader = config.pLoader;
var Loader = config.loader;
var InternalLoader = PLoader || Loader;
var loader = new InternalLoader(config);
context.loader = loader;
this.loaders[context.type] = loader;
return loader;
};
_proto.getInternalLoader = function getInternalLoader(context) {
return this.loaders[context.type];
};
_proto.resetInternalLoader = function resetInternalLoader(contextType) {
if (this.loaders[contextType]) {
delete this.loaders[contextType];
}
}
/**
* Call `destroy` on all internal loader instances mapped (one per context type)
*/
;
_proto.destroyInternalLoaders = function destroyInternalLoaders() {
for (var contextType in this.loaders) {
var loader = this.loaders[contextType];
if (loader) {
loader.destroy();
}
this.resetInternalLoader(contextType);
}
};
_proto.destroy = function destroy() {
this.unregisterListeners();
this.destroyInternalLoaders();
};
_proto.onManifestLoading = function onManifestLoading(event, data) {
var url = data.url;
this.load({
id: null,
groupId: null,
level: 0,
responseType: 'text',
type: _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].MANIFEST,
url: url,
deliveryDirectives: null
});
};
_proto.onLevelLoading = function onLevelLoading(event, data) {
var id = data.id,
level = data.level,
url = data.url,
deliveryDirectives = data.deliveryDirectives;
this.load({
id: id,
groupId: null,
level: level,
responseType: 'text',
type: _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].LEVEL,
url: url,
deliveryDirectives: deliveryDirectives
});
};
_proto.onAudioTrackLoading = function onAudioTrackLoading(event, data) {
var id = data.id,
groupId = data.groupId,
url = data.url,
deliveryDirectives = data.deliveryDirectives;
this.load({
id: id,
groupId: groupId,
level: null,
responseType: 'text',
type: _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].AUDIO_TRACK,
url: url,
deliveryDirectives: deliveryDirectives
});
};
_proto.onSubtitleTrackLoading = function onSubtitleTrackLoading(event, data) {
var id = data.id,
groupId = data.groupId,
url = data.url,
deliveryDirectives = data.deliveryDirectives;
this.load({
id: id,
groupId: groupId,
level: null,
responseType: 'text',
type: _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].SUBTITLE_TRACK,
url: url,
deliveryDirectives: deliveryDirectives
});
};
_proto.load = function load(context) {
var _context$deliveryDire;
var config = this.hls.config; // logger.debug(`[playlist-loader]: Loading playlist of type ${context.type}, level: ${context.level}, id: ${context.id}`);
// Check if a loader for this context already exists
var loader = this.getInternalLoader(context);
if (loader) {
var loaderContext = loader.context;
if (loaderContext && loaderContext.url === context.url) {
// same URL can't overlap
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].trace('[playlist-loader]: playlist request ongoing');
return;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].log("[playlist-loader]: aborting previous loader for type: " + context.type);
loader.abort();
}
var maxRetry;
var timeout;
var retryDelay;
var maxRetryDelay; // apply different configs for retries depending on
// context (manifest, level, audio/subs playlist)
switch (context.type) {
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].MANIFEST:
maxRetry = config.manifestLoadingMaxRetry;
timeout = config.manifestLoadingTimeOut;
retryDelay = config.manifestLoadingRetryDelay;
maxRetryDelay = config.manifestLoadingMaxRetryTimeout;
break;
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].LEVEL:
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].AUDIO_TRACK:
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].SUBTITLE_TRACK:
// Manage retries in Level/Track Controller
maxRetry = 0;
timeout = config.levelLoadingTimeOut;
break;
default:
maxRetry = config.levelLoadingMaxRetry;
timeout = config.levelLoadingTimeOut;
retryDelay = config.levelLoadingRetryDelay;
maxRetryDelay = config.levelLoadingMaxRetryTimeout;
break;
}
loader = this.createInternalLoader(context); // Override level/track timeout for LL-HLS requests
// (the default of 10000ms is counter productive to blocking playlist reload requests)
if ((_context$deliveryDire = context.deliveryDirectives) !== null && _context$deliveryDire !== void 0 && _context$deliveryDire.part) {
var levelDetails;
if (context.type === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].LEVEL && context.level !== null) {
levelDetails = this.hls.levels[context.level].details;
} else if (context.type === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].AUDIO_TRACK && context.id !== null) {
levelDetails = this.hls.audioTracks[context.id].details;
} else if (context.type === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].SUBTITLE_TRACK && context.id !== null) {
levelDetails = this.hls.subtitleTracks[context.id].details;
}
if (levelDetails) {
var partTarget = levelDetails.partTarget;
var targetDuration = levelDetails.targetduration;
if (partTarget && targetDuration) {
timeout = Math.min(Math.max(partTarget * 3, targetDuration * 0.8) * 1000, timeout);
}
}
}
var loaderConfig = {
timeout: timeout,
maxRetry: maxRetry,
retryDelay: retryDelay,
maxRetryDelay: maxRetryDelay,
highWaterMark: 0
};
var loaderCallbacks = {
onSuccess: this.loadsuccess.bind(this),
onError: this.loaderror.bind(this),
onTimeout: this.loadtimeout.bind(this)
}; // logger.debug(`[playlist-loader]: Calling internal loader delegate for URL: ${context.url}`);
loader.load(context, loaderConfig, loaderCallbacks);
};
_proto.loadsuccess = function loadsuccess(response, stats, context, networkDetails) {
if (networkDetails === void 0) {
networkDetails = null;
}
if (context.isSidxRequest) {
this.handleSidxRequest(response, context);
this.handlePlaylistLoaded(response, stats, context, networkDetails);
return;
}
this.resetInternalLoader(context.type);
var string = response.data; // Validate if it is an M3U8 at all
if (string.indexOf('#EXTM3U') !== 0) {
this.handleManifestParsingError(response, context, 'no EXTM3U delimiter', networkDetails);
return;
}
stats.parsing.start = performance.now(); // Check if chunk-list or master. handle empty chunk list case (first EXTINF not signaled, but TARGETDURATION present)
if (string.indexOf('#EXTINF:') > 0 || string.indexOf('#EXT-X-TARGETDURATION:') > 0) {
this.handleTrackOrLevelPlaylist(response, stats, context, networkDetails);
} else {
this.handleMasterPlaylist(response, stats, context, networkDetails);
}
};
_proto.loaderror = function loaderror(response, context, networkDetails) {
if (networkDetails === void 0) {
networkDetails = null;
}
this.handleNetworkError(context, networkDetails, false, response);
};
_proto.loadtimeout = function loadtimeout(stats, context, networkDetails) {
if (networkDetails === void 0) {
networkDetails = null;
}
this.handleNetworkError(context, networkDetails, true);
};
_proto.handleMasterPlaylist = function handleMasterPlaylist(response, stats, context, networkDetails) {
var hls = this.hls;
var string = response.data;
var url = getResponseUrl(response, context);
var _M3U8Parser$parseMast = _m3u8_parser__WEBPACK_IMPORTED_MODULE_5__["default"].parseMasterPlaylist(string, url),
levels = _M3U8Parser$parseMast.levels,
sessionData = _M3U8Parser$parseMast.sessionData;
if (!levels.length) {
this.handleManifestParsingError(response, context, 'no level found in manifest', networkDetails);
return;
} // multi level playlist, parse level info
var audioGroups = levels.map(function (level) {
return {
id: level.attrs.AUDIO,
audioCodec: level.audioCodec
};
});
var subtitleGroups = levels.map(function (level) {
return {
id: level.attrs.SUBTITLES,
textCodec: level.textCodec
};
});
var audioTracks = _m3u8_parser__WEBPACK_IMPORTED_MODULE_5__["default"].parseMasterPlaylistMedia(string, url, 'AUDIO', audioGroups);
var subtitles = _m3u8_parser__WEBPACK_IMPORTED_MODULE_5__["default"].parseMasterPlaylistMedia(string, url, 'SUBTITLES', subtitleGroups);
var captions = _m3u8_parser__WEBPACK_IMPORTED_MODULE_5__["default"].parseMasterPlaylistMedia(string, url, 'CLOSED-CAPTIONS');
if (audioTracks.length) {
// check if we have found an audio track embedded in main playlist (audio track without URI attribute)
var embeddedAudioFound = audioTracks.some(function (audioTrack) {
return !audioTrack.url;
}); // if no embedded audio track defined, but audio codec signaled in quality level,
// we need to signal this main audio track this could happen with playlists with
// alt audio rendition in which quality levels (main)
// contains both audio+video. but with mixed audio track not signaled
if (!embeddedAudioFound && levels[0].audioCodec && !levels[0].attrs.AUDIO) {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].log('[playlist-loader]: audio codec signaled in quality level, but no embedded audio track signaled, create one');
audioTracks.unshift({
type: 'main',
name: 'main',
default: false,
autoselect: false,
forced: false,
id: -1,
attrs: new _utils_attr_list__WEBPACK_IMPORTED_MODULE_7__["AttrList"]({}),
bitrate: 0,
url: ''
});
}
}
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADED, {
levels: levels,
audioTracks: audioTracks,
subtitles: subtitles,
captions: captions,
url: url,
stats: stats,
networkDetails: networkDetails,
sessionData: sessionData
});
};
_proto.handleTrackOrLevelPlaylist = function handleTrackOrLevelPlaylist(response, stats, context, networkDetails) {
var hls = this.hls;
var id = context.id,
level = context.level,
type = context.type;
var url = getResponseUrl(response, context);
var levelUrlId = Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(id) ? id : 0;
var levelId = Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(level) ? level : levelUrlId;
var levelType = mapContextToLevelType(context);
var levelDetails = _m3u8_parser__WEBPACK_IMPORTED_MODULE_5__["default"].parseLevelPlaylist(response.data, url, levelId, levelType, levelUrlId);
if (!levelDetails.fragments.length) {
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].LEVEL_EMPTY_ERROR,
fatal: false,
url: url,
reason: 'no fragments found in level',
level: typeof context.level === 'number' ? context.level : undefined
});
return;
} // We have done our first request (Manifest-type) and receive
// not a master playlist but a chunk-list (track/level)
// We fire the manifest-loaded event anyway with the parsed level-details
// by creating a single-level structure for it.
if (type === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].MANIFEST) {
var singleLevel = {
attrs: new _utils_attr_list__WEBPACK_IMPORTED_MODULE_7__["AttrList"]({}),
bitrate: 0,
details: levelDetails,
name: '',
url: url
};
hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].MANIFEST_LOADED, {
levels: [singleLevel],
audioTracks: [],
url: url,
stats: stats,
networkDetails: networkDetails,
sessionData: null
});
} // save parsing time
stats.parsing.end = performance.now(); // in case we need SIDX ranges
// return early after calling load for
// the SIDX box.
if (levelDetails.needSidxRanges) {
var _levelDetails$fragmen;
var sidxUrl = (_levelDetails$fragmen = levelDetails.fragments[0].initSegment) === null || _levelDetails$fragmen === void 0 ? void 0 : _levelDetails$fragmen.url;
this.load({
url: sidxUrl,
isSidxRequest: true,
type: type,
level: level,
levelDetails: levelDetails,
id: id,
groupId: null,
rangeStart: 0,
rangeEnd: 2048,
responseType: 'arraybuffer',
deliveryDirectives: null
});
return;
} // extend the context with the new levelDetails property
context.levelDetails = levelDetails;
this.handlePlaylistLoaded(response, stats, context, networkDetails);
};
_proto.handleSidxRequest = function handleSidxRequest(response, context) {
var sidxInfo = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_4__["parseSegmentIndex"])(new Uint8Array(response.data)); // if provided fragment does not contain sidx, early return
if (!sidxInfo) {
return;
}
var sidxReferences = sidxInfo.references;
var levelDetails = context.levelDetails;
sidxReferences.forEach(function (segmentRef, index) {
var segRefInfo = segmentRef.info;
var frag = levelDetails.fragments[index];
if (frag.byteRange.length === 0) {
frag.setByteRange(String(1 + segRefInfo.end - segRefInfo.start) + '@' + String(segRefInfo.start));
}
if (frag.initSegment) {
frag.initSegment.setByteRange(String(sidxInfo.moovEndOffset) + '@0');
}
});
};
_proto.handleManifestParsingError = function handleManifestParsingError(response, context, reason, networkDetails) {
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorTypes"].NETWORK_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].MANIFEST_PARSING_ERROR,
fatal: context.type === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].MANIFEST,
url: response.url,
reason: reason,
response: response,
context: context,
networkDetails: networkDetails
});
};
_proto.handleNetworkError = function handleNetworkError(context, networkDetails, timeout, response) {
if (timeout === void 0) {
timeout = false;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn("[playlist-loader]: A network " + (timeout ? 'timeout' : 'error') + " occurred while loading " + context.type + " level: " + context.level + " id: " + context.id + " group-id: \"" + context.groupId + "\"");
var details = _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].UNKNOWN;
var fatal = false;
var loader = this.getInternalLoader(context);
switch (context.type) {
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].MANIFEST:
details = timeout ? _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].MANIFEST_LOAD_TIMEOUT : _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].MANIFEST_LOAD_ERROR;
fatal = true;
break;
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].LEVEL:
details = timeout ? _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].LEVEL_LOAD_TIMEOUT : _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].LEVEL_LOAD_ERROR;
fatal = false;
break;
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].AUDIO_TRACK:
details = timeout ? _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].AUDIO_TRACK_LOAD_TIMEOUT : _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].AUDIO_TRACK_LOAD_ERROR;
fatal = false;
break;
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].SUBTITLE_TRACK:
details = timeout ? _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].SUBTITLE_TRACK_LOAD_TIMEOUT : _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorDetails"].SUBTITLE_LOAD_ERROR;
fatal = false;
break;
}
if (loader) {
this.resetInternalLoader(context.type);
}
var errorData = {
type: _errors__WEBPACK_IMPORTED_MODULE_2__["ErrorTypes"].NETWORK_ERROR,
details: details,
fatal: fatal,
url: context.url,
loader: loader,
context: context,
networkDetails: networkDetails
};
if (response) {
errorData.response = response;
}
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].ERROR, errorData);
};
_proto.handlePlaylistLoaded = function handlePlaylistLoaded(response, stats, context, networkDetails) {
var type = context.type,
level = context.level,
id = context.id,
groupId = context.groupId,
loader = context.loader,
levelDetails = context.levelDetails,
deliveryDirectives = context.deliveryDirectives;
if (!(levelDetails !== null && levelDetails !== void 0 && levelDetails.targetduration)) {
this.handleManifestParsingError(response, context, 'invalid target duration', networkDetails);
return;
}
if (!loader) {
return;
}
if (levelDetails.live) {
if (loader.getCacheAge) {
levelDetails.ageHeader = loader.getCacheAge() || 0;
}
if (!loader.getCacheAge || isNaN(levelDetails.ageHeader)) {
levelDetails.ageHeader = 0;
}
}
switch (type) {
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].MANIFEST:
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].LEVEL:
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].LEVEL_LOADED, {
details: levelDetails,
level: level || 0,
id: id || 0,
stats: stats,
networkDetails: networkDetails,
deliveryDirectives: deliveryDirectives
});
break;
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].AUDIO_TRACK:
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].AUDIO_TRACK_LOADED, {
details: levelDetails,
id: id || 0,
groupId: groupId || '',
stats: stats,
networkDetails: networkDetails,
deliveryDirectives: deliveryDirectives
});
break;
case _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistContextType"].SUBTITLE_TRACK:
this.hls.trigger(_events__WEBPACK_IMPORTED_MODULE_1__["Events"].SUBTITLE_TRACK_LOADED, {
details: levelDetails,
id: id || 0,
groupId: groupId || '',
stats: stats,
networkDetails: networkDetails,
deliveryDirectives: deliveryDirectives
});
break;
}
};
return PlaylistLoader;
}();
/* harmony default export */ __webpack_exports__["default"] = (PlaylistLoader);
/***/ }),
/***/ "./src/polyfills/number.ts":
/*!*********************************!*\
!*** ./src/polyfills/number.ts ***!
\*********************************/
/*! exports provided: isFiniteNumber, MAX_SAFE_INTEGER */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isFiniteNumber", function() { return isFiniteNumber; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "MAX_SAFE_INTEGER", function() { return MAX_SAFE_INTEGER; });
var isFiniteNumber = Number.isFinite || function (value) {
return typeof value === 'number' && isFinite(value);
};
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
/***/ }),
/***/ "./src/remux/aac-helper.ts":
/*!*********************************!*\
!*** ./src/remux/aac-helper.ts ***!
\*********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/**
* AAC helper
*/
var AAC = /*#__PURE__*/function () {
function AAC() {}
AAC.getSilentFrame = function getSilentFrame(codec, channelCount) {
switch (codec) {
case 'mp4a.40.2':
if (channelCount === 1) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x23, 0x80]);
} else if (channelCount === 2) {
return new Uint8Array([0x21, 0x00, 0x49, 0x90, 0x02, 0x19, 0x00, 0x23, 0x80]);
} else if (channelCount === 3) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x8e]);
} else if (channelCount === 4) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x80, 0x2c, 0x80, 0x08, 0x02, 0x38]);
} else if (channelCount === 5) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x38]);
} else if (channelCount === 6) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x00, 0xb2, 0x00, 0x20, 0x08, 0xe0]);
}
break;
// handle HE-AAC below (mp4a.40.5 / mp4a.40.29)
default:
if (channelCount === 1) {
// ffmpeg -y -f lavfi -i "aevalsrc=0:d=0.05" -c:a libfdk_aac -profile:a aac_he -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x4e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x1c, 0x6, 0xf1, 0xc1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
} else if (channelCount === 2) {
// ffmpeg -y -f lavfi -i "aevalsrc=0|0:d=0.05" -c:a libfdk_aac -profile:a aac_he_v2 -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
} else if (channelCount === 3) {
// ffmpeg -y -f lavfi -i "aevalsrc=0|0|0:d=0.05" -c:a libfdk_aac -profile:a aac_he_v2 -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
}
break;
}
return undefined;
};
return AAC;
}();
/* harmony default export */ __webpack_exports__["default"] = (AAC);
/***/ }),
/***/ "./src/remux/mp4-generator.ts":
/*!************************************!*\
!*** ./src/remux/mp4-generator.ts ***!
\************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/**
* Generate MP4 Box
*/
var UINT32_MAX = Math.pow(2, 32) - 1;
var MP4 = /*#__PURE__*/function () {
function MP4() {}
MP4.init = function init() {
MP4.types = {
avc1: [],
// codingname
avcC: [],
btrt: [],
dinf: [],
dref: [],
esds: [],
ftyp: [],
hdlr: [],
mdat: [],
mdhd: [],
mdia: [],
mfhd: [],
minf: [],
moof: [],
moov: [],
mp4a: [],
'.mp3': [],
mvex: [],
mvhd: [],
pasp: [],
sdtp: [],
stbl: [],
stco: [],
stsc: [],
stsd: [],
stsz: [],
stts: [],
tfdt: [],
tfhd: [],
traf: [],
trak: [],
trun: [],
trex: [],
tkhd: [],
vmhd: [],
smhd: []
};
var i;
for (i in MP4.types) {
if (MP4.types.hasOwnProperty(i)) {
MP4.types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];
}
}
var videoHdlr = new Uint8Array([0x00, // version 0
0x00, 0x00, 0x00, // flags
0x00, 0x00, 0x00, 0x00, // pre_defined
0x76, 0x69, 0x64, 0x65, // handler_type: 'vide'
0x00, 0x00, 0x00, 0x00, // reserved
0x00, 0x00, 0x00, 0x00, // reserved
0x00, 0x00, 0x00, 0x00, // reserved
0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'
]);
var audioHdlr = new Uint8Array([0x00, // version 0
0x00, 0x00, 0x00, // flags
0x00, 0x00, 0x00, 0x00, // pre_defined
0x73, 0x6f, 0x75, 0x6e, // handler_type: 'soun'
0x00, 0x00, 0x00, 0x00, // reserved
0x00, 0x00, 0x00, 0x00, // reserved
0x00, 0x00, 0x00, 0x00, // reserved
0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'
]);
MP4.HDLR_TYPES = {
video: videoHdlr,
audio: audioHdlr
};
var dref = new Uint8Array([0x00, // version 0
0x00, 0x00, 0x00, // flags
0x00, 0x00, 0x00, 0x01, // entry_count
0x00, 0x00, 0x00, 0x0c, // entry_size
0x75, 0x72, 0x6c, 0x20, // 'url' type
0x00, // version 0
0x00, 0x00, 0x01 // entry_flags
]);
var stco = new Uint8Array([0x00, // version
0x00, 0x00, 0x00, // flags
0x00, 0x00, 0x00, 0x00 // entry_count
]);
MP4.STTS = MP4.STSC = MP4.STCO = stco;
MP4.STSZ = new Uint8Array([0x00, // version
0x00, 0x00, 0x00, // flags
0x00, 0x00, 0x00, 0x00, // sample_size
0x00, 0x00, 0x00, 0x00 // sample_count
]);
MP4.VMHD = new Uint8Array([0x00, // version
0x00, 0x00, 0x01, // flags
0x00, 0x00, // graphicsmode
0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor
]);
MP4.SMHD = new Uint8Array([0x00, // version
0x00, 0x00, 0x00, // flags
0x00, 0x00, // balance
0x00, 0x00 // reserved
]);
MP4.STSD = new Uint8Array([0x00, // version 0
0x00, 0x00, 0x00, // flags
0x00, 0x00, 0x00, 0x01]); // entry_count
var majorBrand = new Uint8Array([105, 115, 111, 109]); // isom
var avc1Brand = new Uint8Array([97, 118, 99, 49]); // avc1
var minorVersion = new Uint8Array([0, 0, 0, 1]);
MP4.FTYP = MP4.box(MP4.types.ftyp, majorBrand, minorVersion, majorBrand, avc1Brand);
MP4.DINF = MP4.box(MP4.types.dinf, MP4.box(MP4.types.dref, dref));
};
MP4.box = function box(type) {
var size = 8;
for (var _len = arguments.length, payload = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
payload[_key - 1] = arguments[_key];
}
var i = payload.length;
var len = i; // calculate the total size we need to allocate
while (i--) {
size += payload[i].byteLength;
}
var result = new Uint8Array(size);
result[0] = size >> 24 & 0xff;
result[1] = size >> 16 & 0xff;
result[2] = size >> 8 & 0xff;
result[3] = size & 0xff;
result.set(type, 4); // copy the payload into the result
for (i = 0, size = 8; i < len; i++) {
// copy payload[i] array @ offset size
result.set(payload[i], size);
size += payload[i].byteLength;
}
return result;
};
MP4.hdlr = function hdlr(type) {
return MP4.box(MP4.types.hdlr, MP4.HDLR_TYPES[type]);
};
MP4.mdat = function mdat(data) {
return MP4.box(MP4.types.mdat, data);
};
MP4.mdhd = function mdhd(timescale, duration) {
duration *= timescale;
var upperWordDuration = Math.floor(duration / (UINT32_MAX + 1));
var lowerWordDuration = Math.floor(duration % (UINT32_MAX + 1));
return MP4.box(MP4.types.mdhd, new Uint8Array([0x01, // version 1
0x00, 0x00, 0x00, // flags
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, // creation_time
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, // modification_time
timescale >> 24 & 0xff, timescale >> 16 & 0xff, timescale >> 8 & 0xff, timescale & 0xff, // timescale
upperWordDuration >> 24, upperWordDuration >> 16 & 0xff, upperWordDuration >> 8 & 0xff, upperWordDuration & 0xff, lowerWordDuration >> 24, lowerWordDuration >> 16 & 0xff, lowerWordDuration >> 8 & 0xff, lowerWordDuration & 0xff, 0x55, 0xc4, // 'und' language (undetermined)
0x00, 0x00]));
};
MP4.mdia = function mdia(track) {
return MP4.box(MP4.types.mdia, MP4.mdhd(track.timescale, track.duration), MP4.hdlr(track.type), MP4.minf(track));
};
MP4.mfhd = function mfhd(sequenceNumber) {
return MP4.box(MP4.types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00, // flags
sequenceNumber >> 24, sequenceNumber >> 16 & 0xff, sequenceNumber >> 8 & 0xff, sequenceNumber & 0xff // sequence_number
]));
};
MP4.minf = function minf(track) {
if (track.type === 'audio') {
return MP4.box(MP4.types.minf, MP4.box(MP4.types.smhd, MP4.SMHD), MP4.DINF, MP4.stbl(track));
} else {
return MP4.box(MP4.types.minf, MP4.box(MP4.types.vmhd, MP4.VMHD), MP4.DINF, MP4.stbl(track));
}
};
MP4.moof = function moof(sn, baseMediaDecodeTime, track) {
return MP4.box(MP4.types.moof, MP4.mfhd(sn), MP4.traf(track, baseMediaDecodeTime));
}
/**
* @param tracks... (optional) {array} the tracks associated with this movie
*/
;
MP4.moov = function moov(tracks) {
var i = tracks.length;
var boxes = [];
while (i--) {
boxes[i] = MP4.trak(tracks[i]);
}
return MP4.box.apply(null, [MP4.types.moov, MP4.mvhd(tracks[0].timescale, tracks[0].duration)].concat(boxes).concat(MP4.mvex(tracks)));
};
MP4.mvex = function mvex(tracks) {
var i = tracks.length;
var boxes = [];
while (i--) {
boxes[i] = MP4.trex(tracks[i]);
}
return MP4.box.apply(null, [MP4.types.mvex].concat(boxes));
};
MP4.mvhd = function mvhd(timescale, duration) {
duration *= timescale;
var upperWordDuration = Math.floor(duration / (UINT32_MAX + 1));
var lowerWordDuration = Math.floor(duration % (UINT32_MAX + 1));
var bytes = new Uint8Array([0x01, // version 1
0x00, 0x00, 0x00, // flags
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, // creation_time
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, // modification_time
timescale >> 24 & 0xff, timescale >> 16 & 0xff, timescale >> 8 & 0xff, timescale & 0xff, // timescale
upperWordDuration >> 24, upperWordDuration >> 16 & 0xff, upperWordDuration >> 8 & 0xff, upperWordDuration & 0xff, lowerWordDuration >> 24, lowerWordDuration >> 16 & 0xff, lowerWordDuration >> 8 & 0xff, lowerWordDuration & 0xff, 0x00, 0x01, 0x00, 0x00, // 1.0 rate
0x01, 0x00, // 1.0 volume
0x00, 0x00, // reserved
0x00, 0x00, 0x00, 0x00, // reserved
0x00, 0x00, 0x00, 0x00, // reserved
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // transformation: unity matrix
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined
0xff, 0xff, 0xff, 0xff // next_track_ID
]);
return MP4.box(MP4.types.mvhd, bytes);
};
MP4.sdtp = function sdtp(track) {
var samples = track.samples || [];
var bytes = new Uint8Array(4 + samples.length);
var i;
var flags; // leave the full box header (4 bytes) all zero
// write the sample table
for (i = 0; i < samples.length; i++) {
flags = samples[i].flags;
bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;
}
return MP4.box(MP4.types.sdtp, bytes);
};
MP4.stbl = function stbl(track) {
return MP4.box(MP4.types.stbl, MP4.stsd(track), MP4.box(MP4.types.stts, MP4.STTS), MP4.box(MP4.types.stsc, MP4.STSC), MP4.box(MP4.types.stsz, MP4.STSZ), MP4.box(MP4.types.stco, MP4.STCO));
};
MP4.avc1 = function avc1(track) {
var sps = [];
var pps = [];
var i;
var data;
var len; // assemble the SPSs
for (i = 0; i < track.sps.length; i++) {
data = track.sps[i];
len = data.byteLength;
sps.push(len >>> 8 & 0xff);
sps.push(len & 0xff); // SPS
sps = sps.concat(Array.prototype.slice.call(data));
} // assemble the PPSs
for (i = 0; i < track.pps.length; i++) {
data = track.pps[i];
len = data.byteLength;
pps.push(len >>> 8 & 0xff);
pps.push(len & 0xff);
pps = pps.concat(Array.prototype.slice.call(data));
}
var avcc = MP4.box(MP4.types.avcC, new Uint8Array([0x01, // version
sps[3], // profile
sps[4], // profile compat
sps[5], // level
0xfc | 3, // lengthSizeMinusOne, hard-coded to 4 bytes
0xe0 | track.sps.length // 3bit reserved (111) + numOfSequenceParameterSets
].concat(sps).concat([track.pps.length // numOfPictureParameterSets
]).concat(pps))); // "PPS"
var width = track.width;
var height = track.height;
var hSpacing = track.pixelRatio[0];
var vSpacing = track.pixelRatio[1];
return MP4.box(MP4.types.avc1, new Uint8Array([0x00, 0x00, 0x00, // reserved
0x00, 0x00, 0x00, // reserved
0x00, 0x01, // data_reference_index
0x00, 0x00, // pre_defined
0x00, 0x00, // reserved
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined
width >> 8 & 0xff, width & 0xff, // width
height >> 8 & 0xff, height & 0xff, // height
0x00, 0x48, 0x00, 0x00, // horizresolution
0x00, 0x48, 0x00, 0x00, // vertresolution
0x00, 0x00, 0x00, 0x00, // reserved
0x00, 0x01, // frame_count
0x12, 0x64, 0x61, 0x69, 0x6c, // dailymotion/hls.js
0x79, 0x6d, 0x6f, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x68, 0x6c, 0x73, 0x2e, 0x6a, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // compressorname
0x00, 0x18, // depth = 24
0x11, 0x11]), // pre_defined = -1
avcc, MP4.box(MP4.types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80, // bufferSizeDB
0x00, 0x2d, 0xc6, 0xc0, // maxBitrate
0x00, 0x2d, 0xc6, 0xc0])), // avgBitrate
MP4.box(MP4.types.pasp, new Uint8Array([hSpacing >> 24, // hSpacing
hSpacing >> 16 & 0xff, hSpacing >> 8 & 0xff, hSpacing & 0xff, vSpacing >> 24, // vSpacing
vSpacing >> 16 & 0xff, vSpacing >> 8 & 0xff, vSpacing & 0xff])));
};
MP4.esds = function esds(track) {
var configlen = track.config.length;
return new Uint8Array([0x00, // version 0
0x00, 0x00, 0x00, // flags
0x03, // descriptor_type
0x17 + configlen, // length
0x00, 0x01, // es_id
0x00, // stream_priority
0x04, // descriptor_type
0x0f + configlen, // length
0x40, // codec : mpeg4_audio
0x15, // stream_type
0x00, 0x00, 0x00, // buffer_size
0x00, 0x00, 0x00, 0x00, // maxBitrate
0x00, 0x00, 0x00, 0x00, // avgBitrate
0x05 // descriptor_type
].concat([configlen]).concat(track.config).concat([0x06, 0x01, 0x02])); // GASpecificConfig)); // length + audio config descriptor
};
MP4.mp4a = function mp4a(track) {
var samplerate = track.samplerate;
return MP4.box(MP4.types.mp4a, new Uint8Array([0x00, 0x00, 0x00, // reserved
0x00, 0x00, 0x00, // reserved
0x00, 0x01, // data_reference_index
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved
0x00, track.channelCount, // channelcount
0x00, 0x10, // sampleSize:16bits
0x00, 0x00, 0x00, 0x00, // reserved2
samplerate >> 8 & 0xff, samplerate & 0xff, //
0x00, 0x00]), MP4.box(MP4.types.esds, MP4.esds(track)));
};
MP4.mp3 = function mp3(track) {
var samplerate = track.samplerate;
return MP4.box(MP4.types['.mp3'], new Uint8Array([0x00, 0x00, 0x00, // reserved
0x00, 0x00, 0x00, // reserved
0x00, 0x01, // data_reference_index
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved
0x00, track.channelCount, // channelcount
0x00, 0x10, // sampleSize:16bits
0x00, 0x00, 0x00, 0x00, // reserved2
samplerate >> 8 & 0xff, samplerate & 0xff, //
0x00, 0x00]));
};
MP4.stsd = function stsd(track) {
if (track.type === 'audio') {
if (!track.isAAC && track.codec === 'mp3') {
return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp3(track));
}
return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp4a(track));
} else {
return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
}
};
MP4.tkhd = function tkhd(track) {
var id = track.id;
var duration = track.duration * track.timescale;
var width = track.width;
var height = track.height;
var upperWordDuration = Math.floor(duration / (UINT32_MAX + 1));
var lowerWordDuration = Math.floor(duration % (UINT32_MAX + 1));
return MP4.box(MP4.types.tkhd, new Uint8Array([0x01, // version 1
0x00, 0x00, 0x07, // flags
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, // creation_time
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, // modification_time
id >> 24 & 0xff, id >> 16 & 0xff, id >> 8 & 0xff, id & 0xff, // track_ID
0x00, 0x00, 0x00, 0x00, // reserved
upperWordDuration >> 24, upperWordDuration >> 16 & 0xff, upperWordDuration >> 8 & 0xff, upperWordDuration & 0xff, lowerWordDuration >> 24, lowerWordDuration >> 16 & 0xff, lowerWordDuration >> 8 & 0xff, lowerWordDuration & 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved
0x00, 0x00, // layer
0x00, 0x00, // alternate_group
0x00, 0x00, // non-audio track volume
0x00, 0x00, // reserved
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // transformation: unity matrix
width >> 8 & 0xff, width & 0xff, 0x00, 0x00, // width
height >> 8 & 0xff, height & 0xff, 0x00, 0x00 // height
]));
};
MP4.traf = function traf(track, baseMediaDecodeTime) {
var sampleDependencyTable = MP4.sdtp(track);
var id = track.id;
var upperWordBaseMediaDecodeTime = Math.floor(baseMediaDecodeTime / (UINT32_MAX + 1));
var lowerWordBaseMediaDecodeTime = Math.floor(baseMediaDecodeTime % (UINT32_MAX + 1));
return MP4.box(MP4.types.traf, MP4.box(MP4.types.tfhd, new Uint8Array([0x00, // version 0
0x00, 0x00, 0x00, // flags
id >> 24, id >> 16 & 0xff, id >> 8 & 0xff, id & 0xff // track_ID
])), MP4.box(MP4.types.tfdt, new Uint8Array([0x01, // version 1
0x00, 0x00, 0x00, // flags
upperWordBaseMediaDecodeTime >> 24, upperWordBaseMediaDecodeTime >> 16 & 0xff, upperWordBaseMediaDecodeTime >> 8 & 0xff, upperWordBaseMediaDecodeTime & 0xff, lowerWordBaseMediaDecodeTime >> 24, lowerWordBaseMediaDecodeTime >> 16 & 0xff, lowerWordBaseMediaDecodeTime >> 8 & 0xff, lowerWordBaseMediaDecodeTime & 0xff])), MP4.trun(track, sampleDependencyTable.length + 16 + // tfhd
20 + // tfdt
8 + // traf header
16 + // mfhd
8 + // moof header
8), // mdat header
sampleDependencyTable);
}
/**
* Generate a track box.
* @param track {object} a track definition
* @return {Uint8Array} the track box
*/
;
MP4.trak = function trak(track) {
track.duration = track.duration || 0xffffffff;
return MP4.box(MP4.types.trak, MP4.tkhd(track), MP4.mdia(track));
};
MP4.trex = function trex(track) {
var id = track.id;
return MP4.box(MP4.types.trex, new Uint8Array([0x00, // version 0
0x00, 0x00, 0x00, // flags
id >> 24, id >> 16 & 0xff, id >> 8 & 0xff, id & 0xff, // track_ID
0x00, 0x00, 0x00, 0x01, // default_sample_description_index
0x00, 0x00, 0x00, 0x00, // default_sample_duration
0x00, 0x00, 0x00, 0x00, // default_sample_size
0x00, 0x01, 0x00, 0x01 // default_sample_flags
]));
};
MP4.trun = function trun(track, offset) {
var samples = track.samples || [];
var len = samples.length;
var arraylen = 12 + 16 * len;
var array = new Uint8Array(arraylen);
var i;
var sample;
var duration;
var size;
var flags;
var cts;
offset += 8 + arraylen;
array.set([0x00, // version 0
0x00, 0x0f, 0x01, // flags
len >>> 24 & 0xff, len >>> 16 & 0xff, len >>> 8 & 0xff, len & 0xff, // sample_count
offset >>> 24 & 0xff, offset >>> 16 & 0xff, offset >>> 8 & 0xff, offset & 0xff // data_offset
], 0);
for (i = 0; i < len; i++) {
sample = samples[i];
duration = sample.duration;
size = sample.size;
flags = sample.flags;
cts = sample.cts;
array.set([duration >>> 24 & 0xff, duration >>> 16 & 0xff, duration >>> 8 & 0xff, duration & 0xff, // sample_duration
size >>> 24 & 0xff, size >>> 16 & 0xff, size >>> 8 & 0xff, size & 0xff, // sample_size
flags.isLeading << 2 | flags.dependsOn, flags.isDependedOn << 6 | flags.hasRedundancy << 4 | flags.paddingValue << 1 | flags.isNonSync, flags.degradPrio & 0xf0 << 8, flags.degradPrio & 0x0f, // sample_flags
cts >>> 24 & 0xff, cts >>> 16 & 0xff, cts >>> 8 & 0xff, cts & 0xff // sample_composition_time_offset
], 12 + 16 * i);
}
return MP4.box(MP4.types.trun, array);
};
MP4.initSegment = function initSegment(tracks) {
if (!MP4.types) {
MP4.init();
}
var movie = MP4.moov(tracks);
var result = new Uint8Array(MP4.FTYP.byteLength + movie.byteLength);
result.set(MP4.FTYP);
result.set(movie, MP4.FTYP.byteLength);
return result;
};
return MP4;
}();
MP4.types = void 0;
MP4.HDLR_TYPES = void 0;
MP4.STTS = void 0;
MP4.STSC = void 0;
MP4.STCO = void 0;
MP4.STSZ = void 0;
MP4.VMHD = void 0;
MP4.SMHD = void 0;
MP4.STSD = void 0;
MP4.FTYP = void 0;
MP4.DINF = void 0;
/* harmony default export */ __webpack_exports__["default"] = (MP4);
/***/ }),
/***/ "./src/remux/mp4-remuxer.ts":
/*!**********************************!*\
!*** ./src/remux/mp4-remuxer.ts ***!
\**********************************/
/*! exports provided: default, normalizePts */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return MP4Remuxer; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "normalizePts", function() { return normalizePts; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _aac_helper__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./aac-helper */ "./src/remux/aac-helper.ts");
/* harmony import */ var _mp4_generator__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./mp4-generator */ "./src/remux/mp4-generator.ts");
/* harmony import */ var _events__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../events */ "./src/events.ts");
/* harmony import */ var _errors__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../errors */ "./src/errors.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _types_loader__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../types/loader */ "./src/types/loader.ts");
/* harmony import */ var _utils_timescale_conversion__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../utils/timescale-conversion */ "./src/utils/timescale-conversion.ts");
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
var MAX_SILENT_FRAME_DURATION = 10 * 1000; // 10 seconds
var AAC_SAMPLES_PER_FRAME = 1024;
var MPEG_AUDIO_SAMPLE_PER_FRAME = 1152;
var chromeVersion = null;
var safariWebkitVersion = null;
var requiresPositiveDts = false;
var MP4Remuxer = /*#__PURE__*/function () {
function MP4Remuxer(observer, config, typeSupported, vendor) {
if (vendor === void 0) {
vendor = '';
}
this.observer = void 0;
this.config = void 0;
this.typeSupported = void 0;
this.ISGenerated = false;
this._initPTS = void 0;
this._initDTS = void 0;
this.nextAvcDts = null;
this.nextAudioPts = null;
this.isAudioContiguous = false;
this.isVideoContiguous = false;
this.observer = observer;
this.config = config;
this.typeSupported = typeSupported;
this.ISGenerated = false;
if (chromeVersion === null) {
var userAgent = navigator.userAgent || '';
var result = userAgent.match(/Chrome\/(\d+)/i);
chromeVersion = result ? parseInt(result[1]) : 0;
}
if (safariWebkitVersion === null) {
var _result = navigator.userAgent.match(/Safari\/(\d+)/i);
safariWebkitVersion = _result ? parseInt(_result[1]) : 0;
}
requiresPositiveDts = !!chromeVersion && chromeVersion < 75 || !!safariWebkitVersion && safariWebkitVersion < 600;
}
var _proto = MP4Remuxer.prototype;
_proto.destroy = function destroy() {};
_proto.resetTimeStamp = function resetTimeStamp(defaultTimeStamp) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].log('[mp4-remuxer]: initPTS & initDTS reset');
this._initPTS = this._initDTS = defaultTimeStamp;
};
_proto.resetNextTimestamp = function resetNextTimestamp() {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].log('[mp4-remuxer]: reset next timestamp');
this.isVideoContiguous = false;
this.isAudioContiguous = false;
};
_proto.resetInitSegment = function resetInitSegment() {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].log('[mp4-remuxer]: ISGenerated flag reset');
this.ISGenerated = false;
};
_proto.getVideoStartPts = function getVideoStartPts(videoSamples) {
var rolloverDetected = false;
var startPTS = videoSamples.reduce(function (minPTS, sample) {
var delta = sample.pts - minPTS;
if (delta < -4294967296) {
// 2^32, see PTSNormalize for reasoning, but we're hitting a rollover here, and we don't want that to impact the timeOffset calculation
rolloverDetected = true;
return normalizePts(minPTS, sample.pts);
} else if (delta > 0) {
return minPTS;
} else {
return sample.pts;
}
}, videoSamples[0].pts);
if (rolloverDetected) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].debug('PTS rollover detected');
}
return startPTS;
};
_proto.remux = function remux(audioTrack, videoTrack, id3Track, textTrack, timeOffset, accurateTimeOffset, flush, playlistType) {
var video;
var audio;
var initSegment;
var text;
var id3;
var independent;
var audioTimeOffset = timeOffset;
var videoTimeOffset = timeOffset; // If we're remuxing audio and video progressively, wait until we've received enough samples for each track before proceeding.
// This is done to synchronize the audio and video streams. We know if the current segment will have samples if the "pid"
// parameter is greater than -1. The pid is set when the PMT is parsed, which contains the tracks list.
// However, if the initSegment has already been generated, or we've reached the end of a segment (flush),
// then we can remux one track without waiting for the other.
var hasAudio = audioTrack.pid > -1;
var hasVideo = videoTrack.pid > -1;
var length = videoTrack.samples.length;
var enoughAudioSamples = audioTrack.samples.length > 0;
var enoughVideoSamples = length > 1;
var canRemuxAvc = (!hasAudio || enoughAudioSamples) && (!hasVideo || enoughVideoSamples) || this.ISGenerated || flush;
if (canRemuxAvc) {
if (!this.ISGenerated) {
initSegment = this.generateIS(audioTrack, videoTrack, timeOffset);
}
var isVideoContiguous = this.isVideoContiguous;
var firstKeyFrameIndex = -1;
if (enoughVideoSamples) {
firstKeyFrameIndex = findKeyframeIndex(videoTrack.samples);
if (!isVideoContiguous && this.config.forceKeyFrameOnDiscontinuity) {
independent = true;
if (firstKeyFrameIndex > 0) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn("[mp4-remuxer]: Dropped " + firstKeyFrameIndex + " out of " + length + " video samples due to a missing keyframe");
var startPTS = this.getVideoStartPts(videoTrack.samples);
videoTrack.samples = videoTrack.samples.slice(firstKeyFrameIndex);
videoTrack.dropped += firstKeyFrameIndex;
videoTimeOffset += (videoTrack.samples[0].pts - startPTS) / (videoTrack.timescale || 90000);
} else if (firstKeyFrameIndex === -1) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn("[mp4-remuxer]: No keyframe found out of " + length + " video samples");
independent = false;
}
}
}
if (this.ISGenerated) {
if (enoughAudioSamples && enoughVideoSamples) {
// timeOffset is expected to be the offset of the first timestamp of this fragment (first DTS)
// if first audio DTS is not aligned with first video DTS then we need to take that into account
// when providing timeOffset to remuxAudio / remuxVideo. if we don't do that, there might be a permanent / small
// drift between audio and video streams
var _startPTS = this.getVideoStartPts(videoTrack.samples);
var tsDelta = normalizePts(audioTrack.samples[0].pts, _startPTS) - _startPTS;
var audiovideoTimestampDelta = tsDelta / videoTrack.inputTimeScale;
audioTimeOffset += Math.max(0, audiovideoTimestampDelta);
videoTimeOffset += Math.max(0, -audiovideoTimestampDelta);
} // Purposefully remuxing audio before video, so that remuxVideo can use nextAudioPts, which is calculated in remuxAudio.
if (enoughAudioSamples) {
// if initSegment was generated without audio samples, regenerate it again
if (!audioTrack.samplerate) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn('[mp4-remuxer]: regenerate InitSegment as audio detected');
initSegment = this.generateIS(audioTrack, videoTrack, timeOffset);
}
audio = this.remuxAudio(audioTrack, audioTimeOffset, this.isAudioContiguous, accurateTimeOffset, hasVideo || enoughVideoSamples || playlistType === _types_loader__WEBPACK_IMPORTED_MODULE_6__["PlaylistLevelType"].AUDIO ? videoTimeOffset : undefined);
if (enoughVideoSamples) {
var audioTrackLength = audio ? audio.endPTS - audio.startPTS : 0; // if initSegment was generated without video samples, regenerate it again
if (!videoTrack.inputTimeScale) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn('[mp4-remuxer]: regenerate InitSegment as video detected');
initSegment = this.generateIS(audioTrack, videoTrack, timeOffset);
}
video = this.remuxVideo(videoTrack, videoTimeOffset, isVideoContiguous, audioTrackLength);
}
} else if (enoughVideoSamples) {
video = this.remuxVideo(videoTrack, videoTimeOffset, isVideoContiguous, 0);
}
if (video) {
video.firstKeyFrame = firstKeyFrameIndex;
video.independent = firstKeyFrameIndex !== -1;
}
}
} // Allow ID3 and text to remux, even if more audio/video samples are required
if (this.ISGenerated) {
if (id3Track.samples.length) {
id3 = this.remuxID3(id3Track, timeOffset);
}
if (textTrack.samples.length) {
text = this.remuxText(textTrack, timeOffset);
}
}
return {
audio: audio,
video: video,
initSegment: initSegment,
independent: independent,
text: text,
id3: id3
};
};
_proto.generateIS = function generateIS(audioTrack, videoTrack, timeOffset) {
var audioSamples = audioTrack.samples;
var videoSamples = videoTrack.samples;
var typeSupported = this.typeSupported;
var tracks = {};
var computePTSDTS = !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(this._initPTS);
var container = 'audio/mp4';
var initPTS;
var initDTS;
var timescale;
if (computePTSDTS) {
initPTS = initDTS = Infinity;
}
if (audioTrack.config && audioSamples.length) {
// let's use audio sampling rate as MP4 time scale.
// rationale is that there is a integer nb of audio frames per audio sample (1024 for AAC)
// using audio sampling rate here helps having an integer MP4 frame duration
// this avoids potential rounding issue and AV sync issue
audioTrack.timescale = audioTrack.samplerate;
if (!audioTrack.isAAC) {
if (typeSupported.mpeg) {
// Chrome and Safari
container = 'audio/mpeg';
audioTrack.codec = '';
} else if (typeSupported.mp3) {
// Firefox
audioTrack.codec = 'mp3';
}
}
tracks.audio = {
id: 'audio',
container: container,
codec: audioTrack.codec,
initSegment: !audioTrack.isAAC && typeSupported.mpeg ? new Uint8Array(0) : _mp4_generator__WEBPACK_IMPORTED_MODULE_2__["default"].initSegment([audioTrack]),
metadata: {
channelCount: audioTrack.channelCount
}
};
if (computePTSDTS) {
timescale = audioTrack.inputTimeScale; // remember first PTS of this demuxing context. for audio, PTS = DTS
initPTS = initDTS = audioSamples[0].pts - Math.round(timescale * timeOffset);
}
}
if (videoTrack.sps && videoTrack.pps && videoSamples.length) {
// let's use input time scale as MP4 video timescale
// we use input time scale straight away to avoid rounding issues on frame duration / cts computation
videoTrack.timescale = videoTrack.inputTimeScale;
tracks.video = {
id: 'main',
container: 'video/mp4',
codec: videoTrack.codec,
initSegment: _mp4_generator__WEBPACK_IMPORTED_MODULE_2__["default"].initSegment([videoTrack]),
metadata: {
width: videoTrack.width,
height: videoTrack.height
}
};
if (computePTSDTS) {
timescale = videoTrack.inputTimeScale;
var startPTS = this.getVideoStartPts(videoSamples);
var startOffset = Math.round(timescale * timeOffset);
initDTS = Math.min(initDTS, normalizePts(videoSamples[0].dts, startPTS) - startOffset);
initPTS = Math.min(initPTS, startPTS - startOffset);
}
}
if (Object.keys(tracks).length) {
this.ISGenerated = true;
if (computePTSDTS) {
this._initPTS = initPTS;
this._initDTS = initDTS;
}
return {
tracks: tracks,
initPTS: initPTS,
timescale: timescale
};
}
};
_proto.remuxVideo = function remuxVideo(track, timeOffset, contiguous, audioTrackLength) {
var timeScale = track.inputTimeScale;
var inputSamples = track.samples;
var outputSamples = [];
var nbSamples = inputSamples.length;
var initPTS = this._initPTS;
var nextAvcDts = this.nextAvcDts;
var offset = 8;
var mp4SampleDuration;
var firstDTS;
var lastDTS;
var minPTS = Number.POSITIVE_INFINITY;
var maxPTS = Number.NEGATIVE_INFINITY;
var ptsDtsShift = 0;
var sortSamples = false; // if parsed fragment is contiguous with last one, let's use last DTS value as reference
if (!contiguous || nextAvcDts === null) {
var pts = timeOffset * timeScale;
var cts = inputSamples[0].pts - normalizePts(inputSamples[0].dts, inputSamples[0].pts); // if not contiguous, let's use target timeOffset
nextAvcDts = pts - cts;
} // PTS is coded on 33bits, and can loop from -2^32 to 2^32
// PTSNormalize will make PTS/DTS value monotonic, we use last known DTS value as reference value
for (var i = 0; i < nbSamples; i++) {
var sample = inputSamples[i];
sample.pts = normalizePts(sample.pts - initPTS, nextAvcDts);
sample.dts = normalizePts(sample.dts - initPTS, nextAvcDts);
if (sample.dts > sample.pts) {
var PTS_DTS_SHIFT_TOLERANCE_90KHZ = 90000 * 0.2;
ptsDtsShift = Math.max(Math.min(ptsDtsShift, sample.pts - sample.dts), -1 * PTS_DTS_SHIFT_TOLERANCE_90KHZ);
}
if (sample.dts < inputSamples[i > 0 ? i - 1 : i].dts) {
sortSamples = true;
}
} // sort video samples by DTS then PTS then demux id order
if (sortSamples) {
inputSamples.sort(function (a, b) {
var deltadts = a.dts - b.dts;
var deltapts = a.pts - b.pts;
return deltadts || deltapts;
});
} // Get first/last DTS
firstDTS = inputSamples[0].dts;
lastDTS = inputSamples[inputSamples.length - 1].dts; // on Safari let's signal the same sample duration for all samples
// sample duration (as expected by trun MP4 boxes), should be the delta between sample DTS
// set this constant duration as being the avg delta between consecutive DTS.
var averageSampleDuration = Math.round((lastDTS - firstDTS) / (nbSamples - 1)); // handle broken streams with PTS < DTS, tolerance up 0.2 seconds
if (ptsDtsShift < 0) {
if (ptsDtsShift < averageSampleDuration * -2) {
// Fix for "CNN special report, with CC" in test-streams (including Safari browser)
// With large PTS < DTS errors such as this, we want to correct CTS while maintaining increasing DTS values
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn("PTS < DTS detected in video samples, offsetting DTS from PTS by " + Object(_utils_timescale_conversion__WEBPACK_IMPORTED_MODULE_7__["toMsFromMpegTsClock"])(-averageSampleDuration, true) + " ms");
var lastDts = ptsDtsShift;
for (var _i = 0; _i < nbSamples; _i++) {
inputSamples[_i].dts = lastDts = Math.max(lastDts, inputSamples[_i].pts - averageSampleDuration);
inputSamples[_i].pts = Math.max(lastDts, inputSamples[_i].pts);
}
} else {
// Fix for "Custom IV with bad PTS DTS" in test-streams
// With smaller PTS < DTS errors we can simply move all DTS back. This increases CTS without causing buffer gaps or decode errors in Safari
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn("PTS < DTS detected in video samples, shifting DTS by " + Object(_utils_timescale_conversion__WEBPACK_IMPORTED_MODULE_7__["toMsFromMpegTsClock"])(ptsDtsShift, true) + " ms to overcome this issue");
for (var _i2 = 0; _i2 < nbSamples; _i2++) {
inputSamples[_i2].dts = inputSamples[_i2].dts + ptsDtsShift;
}
}
firstDTS = inputSamples[0].dts;
} // if fragment are contiguous, detect hole/overlapping between fragments
if (contiguous) {
// check timestamp continuity across consecutive fragments (this is to remove inter-fragment gap/hole)
var delta = firstDTS - nextAvcDts;
var foundHole = delta > averageSampleDuration;
var foundOverlap = delta < -1;
if (foundHole || foundOverlap) {
if (foundHole) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn("AVC: " + Object(_utils_timescale_conversion__WEBPACK_IMPORTED_MODULE_7__["toMsFromMpegTsClock"])(delta, true) + " ms (" + delta + "dts) hole between fragments detected, filling it");
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn("AVC: " + Object(_utils_timescale_conversion__WEBPACK_IMPORTED_MODULE_7__["toMsFromMpegTsClock"])(-delta, true) + " ms (" + delta + "dts) overlapping between fragments detected");
}
firstDTS = nextAvcDts;
var firstPTS = inputSamples[0].pts - delta;
inputSamples[0].dts = firstDTS;
inputSamples[0].pts = firstPTS;
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].log("Video: First PTS/DTS adjusted: " + Object(_utils_timescale_conversion__WEBPACK_IMPORTED_MODULE_7__["toMsFromMpegTsClock"])(firstPTS, true) + "/" + Object(_utils_timescale_conversion__WEBPACK_IMPORTED_MODULE_7__["toMsFromMpegTsClock"])(firstDTS, true) + ", delta: " + Object(_utils_timescale_conversion__WEBPACK_IMPORTED_MODULE_7__["toMsFromMpegTsClock"])(delta, true) + " ms");
}
}
if (requiresPositiveDts) {
firstDTS = Math.max(0, firstDTS);
}
var nbNalu = 0;
var naluLen = 0;
for (var _i3 = 0; _i3 < nbSamples; _i3++) {
// compute total/avc sample length and nb of NAL units
var _sample = inputSamples[_i3];
var units = _sample.units;
var nbUnits = units.length;
var sampleLen = 0;
for (var j = 0; j < nbUnits; j++) {
sampleLen += units[j].data.length;
}
naluLen += sampleLen;
nbNalu += nbUnits;
_sample.length = sampleLen; // normalize PTS/DTS
// ensure sample monotonic DTS
_sample.dts = Math.max(_sample.dts, firstDTS); // ensure that computed value is greater or equal than sample DTS
_sample.pts = Math.max(_sample.pts, _sample.dts, 0);
minPTS = Math.min(_sample.pts, minPTS);
maxPTS = Math.max(_sample.pts, maxPTS);
}
lastDTS = inputSamples[nbSamples - 1].dts;
/* concatenate the video data and construct the mdat in place
(need 8 more bytes to fill length and mpdat type) */
var mdatSize = naluLen + 4 * nbNalu + 8;
var mdat;
try {
mdat = new Uint8Array(mdatSize);
} catch (err) {
this.observer.emit(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].ERROR, _events__WEBPACK_IMPORTED_MODULE_3__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorTypes"].MUX_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorDetails"].REMUX_ALLOC_ERROR,
fatal: false,
bytes: mdatSize,
reason: "fail allocating video mdat " + mdatSize
});
return;
}
var view = new DataView(mdat.buffer);
view.setUint32(0, mdatSize);
mdat.set(_mp4_generator__WEBPACK_IMPORTED_MODULE_2__["default"].types.mdat, 4);
for (var _i4 = 0; _i4 < nbSamples; _i4++) {
var avcSample = inputSamples[_i4];
var avcSampleUnits = avcSample.units;
var mp4SampleLength = 0; // convert NALU bitstream to MP4 format (prepend NALU with size field)
for (var _j = 0, _nbUnits = avcSampleUnits.length; _j < _nbUnits; _j++) {
var unit = avcSampleUnits[_j];
var unitData = unit.data;
var unitDataLen = unit.data.byteLength;
view.setUint32(offset, unitDataLen);
offset += 4;
mdat.set(unitData, offset);
offset += unitDataLen;
mp4SampleLength += 4 + unitDataLen;
} // expected sample duration is the Decoding Timestamp diff of consecutive samples
if (_i4 < nbSamples - 1) {
mp4SampleDuration = inputSamples[_i4 + 1].dts - avcSample.dts;
} else {
var config = this.config;
var lastFrameDuration = avcSample.dts - inputSamples[_i4 > 0 ? _i4 - 1 : _i4].dts;
if (config.stretchShortVideoTrack && this.nextAudioPts !== null) {
// In some cases, a segment's audio track duration may exceed the video track duration.
// Since we've already remuxed audio, and we know how long the audio track is, we look to
// see if the delta to the next segment is longer than maxBufferHole.
// If so, playback would potentially get stuck, so we artificially inflate
// the duration of the last frame to minimize any potential gap between segments.
var gapTolerance = Math.floor(config.maxBufferHole * timeScale);
var deltaToFrameEnd = (audioTrackLength ? minPTS + audioTrackLength * timeScale : this.nextAudioPts) - avcSample.pts;
if (deltaToFrameEnd > gapTolerance) {
// We subtract lastFrameDuration from deltaToFrameEnd to try to prevent any video
// frame overlap. maxBufferHole should be >> lastFrameDuration anyway.
mp4SampleDuration = deltaToFrameEnd - lastFrameDuration;
if (mp4SampleDuration < 0) {
mp4SampleDuration = lastFrameDuration;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].log("[mp4-remuxer]: It is approximately " + deltaToFrameEnd / 90 + " ms to the next segment; using duration " + mp4SampleDuration / 90 + " ms for the last video frame.");
} else {
mp4SampleDuration = lastFrameDuration;
}
} else {
mp4SampleDuration = lastFrameDuration;
}
}
var compositionTimeOffset = Math.round(avcSample.pts - avcSample.dts);
outputSamples.push(new Mp4Sample(avcSample.key, mp4SampleDuration, mp4SampleLength, compositionTimeOffset));
}
if (outputSamples.length && chromeVersion && chromeVersion < 70) {
// Chrome workaround, mark first sample as being a Random Access Point (keyframe) to avoid sourcebuffer append issue
// https://code.google.com/p/chromium/issues/detail?id=229412
var flags = outputSamples[0].flags;
flags.dependsOn = 2;
flags.isNonSync = 0;
}
console.assert(mp4SampleDuration !== undefined, 'mp4SampleDuration must be computed'); // next AVC sample DTS should be equal to last sample DTS + last sample duration (in PES timescale)
this.nextAvcDts = nextAvcDts = lastDTS + mp4SampleDuration;
this.isVideoContiguous = true;
var moof = _mp4_generator__WEBPACK_IMPORTED_MODULE_2__["default"].moof(track.sequenceNumber++, firstDTS, _extends({}, track, {
samples: outputSamples
}));
var type = 'video';
var data = {
data1: moof,
data2: mdat,
startPTS: minPTS / timeScale,
endPTS: (maxPTS + mp4SampleDuration) / timeScale,
startDTS: firstDTS / timeScale,
endDTS: nextAvcDts / timeScale,
type: type,
hasAudio: false,
hasVideo: true,
nb: outputSamples.length,
dropped: track.dropped
};
track.samples = [];
track.dropped = 0;
console.assert(mdat.length, 'MDAT length must not be zero');
return data;
};
_proto.remuxAudio = function remuxAudio(track, timeOffset, contiguous, accurateTimeOffset, videoTimeOffset) {
var inputTimeScale = track.inputTimeScale;
var mp4timeScale = track.samplerate ? track.samplerate : inputTimeScale;
var scaleFactor = inputTimeScale / mp4timeScale;
var mp4SampleDuration = track.isAAC ? AAC_SAMPLES_PER_FRAME : MPEG_AUDIO_SAMPLE_PER_FRAME;
var inputSampleDuration = mp4SampleDuration * scaleFactor;
var initPTS = this._initPTS;
var rawMPEG = !track.isAAC && this.typeSupported.mpeg;
var outputSamples = [];
var inputSamples = track.samples;
var offset = rawMPEG ? 0 : 8;
var nextAudioPts = this.nextAudioPts || -1; // window.audioSamples ? window.audioSamples.push(inputSamples.map(s => s.pts)) : (window.audioSamples = [inputSamples.map(s => s.pts)]);
// for audio samples, also consider consecutive fragments as being contiguous (even if a level switch occurs),
// for sake of clarity:
// consecutive fragments are frags with
// - less than 100ms gaps between new time offset (if accurate) and next expected PTS OR
// - less than 20 audio frames distance
// contiguous fragments are consecutive fragments from same quality level (same level, new SN = old SN + 1)
// this helps ensuring audio continuity
// and this also avoids audio glitches/cut when switching quality, or reporting wrong duration on first audio frame
var timeOffsetMpegTS = timeOffset * inputTimeScale;
this.isAudioContiguous = contiguous = contiguous || inputSamples.length && nextAudioPts > 0 && (accurateTimeOffset && Math.abs(timeOffsetMpegTS - nextAudioPts) < 9000 || Math.abs(normalizePts(inputSamples[0].pts - initPTS, timeOffsetMpegTS) - nextAudioPts) < 20 * inputSampleDuration); // compute normalized PTS
inputSamples.forEach(function (sample) {
sample.pts = normalizePts(sample.pts - initPTS, timeOffsetMpegTS);
});
if (!contiguous || nextAudioPts < 0) {
// filter out sample with negative PTS that are not playable anyway
// if we don't remove these negative samples, they will shift all audio samples forward.
// leading to audio overlap between current / next fragment
inputSamples = inputSamples.filter(function (sample) {
return sample.pts >= 0;
}); // in case all samples have negative PTS, and have been filtered out, return now
if (!inputSamples.length) {
return;
}
if (videoTimeOffset === 0) {
// Set the start to 0 to match video so that start gaps larger than inputSampleDuration are filled with silence
nextAudioPts = 0;
} else if (accurateTimeOffset) {
// When not seeking, not live, and LevelDetails.PTSKnown, use fragment start as predicted next audio PTS
nextAudioPts = Math.max(0, timeOffsetMpegTS);
} else {
// if frags are not contiguous and if we cant trust time offset, let's use first sample PTS as next audio PTS
nextAudioPts = inputSamples[0].pts;
}
} // If the audio track is missing samples, the frames seem to get "left-shifted" within the
// resulting mp4 segment, causing sync issues and leaving gaps at the end of the audio segment.
// In an effort to prevent this from happening, we inject frames here where there are gaps.
// When possible, we inject a silent frame; when that's not possible, we duplicate the last
// frame.
if (track.isAAC) {
var alignedWithVideo = videoTimeOffset !== undefined;
var maxAudioFramesDrift = this.config.maxAudioFramesDrift;
for (var i = 0, nextPts = nextAudioPts; i < inputSamples.length; i++) {
// First, let's see how far off this frame is from where we expect it to be
var sample = inputSamples[i];
var pts = sample.pts;
var delta = pts - nextPts;
var duration = Math.abs(1000 * delta / inputTimeScale); // When remuxing with video, if we're overlapping by more than a duration, drop this sample to stay in sync
if (delta <= -maxAudioFramesDrift * inputSampleDuration && alignedWithVideo) {
if (i === 0) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn("Audio frame @ " + (pts / inputTimeScale).toFixed(3) + "s overlaps nextAudioPts by " + Math.round(1000 * delta / inputTimeScale) + " ms.");
this.nextAudioPts = nextAudioPts = nextPts = pts;
}
} // eslint-disable-line brace-style
// Insert missing frames if:
// 1: We're more than maxAudioFramesDrift frame away
// 2: Not more than MAX_SILENT_FRAME_DURATION away
// 3: currentTime (aka nextPtsNorm) is not 0
// 4: remuxing with video (videoTimeOffset !== undefined)
else if (delta >= maxAudioFramesDrift * inputSampleDuration && duration < MAX_SILENT_FRAME_DURATION && alignedWithVideo) {
var missing = Math.round(delta / inputSampleDuration); // Adjust nextPts so that silent samples are aligned with media pts. This will prevent media samples from
// later being shifted if nextPts is based on timeOffset and delta is not a multiple of inputSampleDuration.
nextPts = pts - missing * inputSampleDuration;
if (nextPts < 0) {
missing--;
nextPts += inputSampleDuration;
}
if (i === 0) {
this.nextAudioPts = nextAudioPts = nextPts;
}
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn("[mp4-remuxer]: Injecting " + missing + " audio frame @ " + (nextPts / inputTimeScale).toFixed(3) + "s due to " + Math.round(1000 * delta / inputTimeScale) + " ms gap.");
for (var j = 0; j < missing; j++) {
var newStamp = Math.max(nextPts, 0);
var fillFrame = _aac_helper__WEBPACK_IMPORTED_MODULE_1__["default"].getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
if (!fillFrame) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].log('[mp4-remuxer]: Unable to get silent frame for given audio codec; duplicating last frame instead.');
fillFrame = sample.unit.subarray();
}
inputSamples.splice(i, 0, {
unit: fillFrame,
pts: newStamp
});
nextPts += inputSampleDuration;
i++;
}
}
sample.pts = nextPts;
nextPts += inputSampleDuration;
}
}
var firstPTS = null;
var lastPTS = null;
var mdat;
var mdatSize = 0;
var sampleLength = inputSamples.length;
while (sampleLength--) {
mdatSize += inputSamples[sampleLength].unit.byteLength;
}
for (var _j2 = 0, _nbSamples = inputSamples.length; _j2 < _nbSamples; _j2++) {
var audioSample = inputSamples[_j2];
var unit = audioSample.unit;
var _pts = audioSample.pts;
if (lastPTS !== null) {
// If we have more than one sample, set the duration of the sample to the "real" duration; the PTS diff with
// the previous sample
var prevSample = outputSamples[_j2 - 1];
prevSample.duration = Math.round((_pts - lastPTS) / scaleFactor);
} else {
if (contiguous && track.isAAC) {
// set PTS/DTS to expected PTS/DTS
_pts = nextAudioPts;
} // remember first PTS of our audioSamples
firstPTS = _pts;
if (mdatSize > 0) {
/* concatenate the audio data and construct the mdat in place
(need 8 more bytes to fill length and mdat type) */
mdatSize += offset;
try {
mdat = new Uint8Array(mdatSize);
} catch (err) {
this.observer.emit(_events__WEBPACK_IMPORTED_MODULE_3__["Events"].ERROR, _events__WEBPACK_IMPORTED_MODULE_3__["Events"].ERROR, {
type: _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorTypes"].MUX_ERROR,
details: _errors__WEBPACK_IMPORTED_MODULE_4__["ErrorDetails"].REMUX_ALLOC_ERROR,
fatal: false,
bytes: mdatSize,
reason: "fail allocating audio mdat " + mdatSize
});
return;
}
if (!rawMPEG) {
var view = new DataView(mdat.buffer);
view.setUint32(0, mdatSize);
mdat.set(_mp4_generator__WEBPACK_IMPORTED_MODULE_2__["default"].types.mdat, 4);
}
} else {
// no audio samples
return;
}
}
mdat.set(unit, offset);
var unitLen = unit.byteLength;
offset += unitLen; // Default the sample's duration to the computed mp4SampleDuration, which will either be 1024 for AAC or 1152 for MPEG
// In the case that we have 1 sample, this will be the duration. If we have more than one sample, the duration
// becomes the PTS diff with the previous sample
outputSamples.push(new Mp4Sample(true, mp4SampleDuration, unitLen, 0));
lastPTS = _pts;
} // We could end up with no audio samples if all input samples were overlapping with the previously remuxed ones
var nbSamples = outputSamples.length;
if (!nbSamples) {
return;
} // The next audio sample PTS should be equal to last sample PTS + duration
var lastSample = outputSamples[outputSamples.length - 1];
this.nextAudioPts = nextAudioPts = lastPTS + scaleFactor * lastSample.duration; // Set the track samples from inputSamples to outputSamples before remuxing
var moof = rawMPEG ? new Uint8Array(0) : _mp4_generator__WEBPACK_IMPORTED_MODULE_2__["default"].moof(track.sequenceNumber++, firstPTS / scaleFactor, _extends({}, track, {
samples: outputSamples
})); // Clear the track samples. This also clears the samples array in the demuxer, since the reference is shared
track.samples = [];
var start = firstPTS / inputTimeScale;
var end = nextAudioPts / inputTimeScale;
var type = 'audio';
var audioData = {
data1: moof,
data2: mdat,
startPTS: start,
endPTS: end,
startDTS: start,
endDTS: end,
type: type,
hasAudio: true,
hasVideo: false,
nb: nbSamples
};
this.isAudioContiguous = true;
console.assert(mdat.length, 'MDAT length must not be zero');
return audioData;
};
_proto.remuxEmptyAudio = function remuxEmptyAudio(track, timeOffset, contiguous, videoData) {
var inputTimeScale = track.inputTimeScale;
var mp4timeScale = track.samplerate ? track.samplerate : inputTimeScale;
var scaleFactor = inputTimeScale / mp4timeScale;
var nextAudioPts = this.nextAudioPts; // sync with video's timestamp
var startDTS = (nextAudioPts !== null ? nextAudioPts : videoData.startDTS * inputTimeScale) + this._initDTS;
var endDTS = videoData.endDTS * inputTimeScale + this._initDTS; // one sample's duration value
var frameDuration = scaleFactor * AAC_SAMPLES_PER_FRAME; // samples count of this segment's duration
var nbSamples = Math.ceil((endDTS - startDTS) / frameDuration); // silent frame
var silentFrame = _aac_helper__WEBPACK_IMPORTED_MODULE_1__["default"].getSilentFrame(track.manifestCodec || track.codec, track.channelCount);
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].warn('[mp4-remuxer]: remux empty Audio'); // Can't remux if we can't generate a silent frame...
if (!silentFrame) {
_utils_logger__WEBPACK_IMPORTED_MODULE_5__["logger"].trace('[mp4-remuxer]: Unable to remuxEmptyAudio since we were unable to get a silent frame for given audio codec');
return;
}
var samples = [];
for (var i = 0; i < nbSamples; i++) {
var stamp = startDTS + i * frameDuration;
samples.push({
unit: silentFrame,
pts: stamp,
dts: stamp
});
}
track.samples = samples;
return this.remuxAudio(track, timeOffset, contiguous, false);
};
_proto.remuxID3 = function remuxID3(track, timeOffset) {
var length = track.samples.length;
if (!length) {
return;
}
var inputTimeScale = track.inputTimeScale;
var initPTS = this._initPTS;
var initDTS = this._initDTS;
for (var index = 0; index < length; index++) {
var sample = track.samples[index]; // setting id3 pts, dts to relative time
// using this._initPTS and this._initDTS to calculate relative time
sample.pts = normalizePts(sample.pts - initPTS, timeOffset * inputTimeScale) / inputTimeScale;
sample.dts = normalizePts(sample.dts - initDTS, timeOffset * inputTimeScale) / inputTimeScale;
}
var samples = track.samples;
track.samples = [];
return {
samples: samples
};
};
_proto.remuxText = function remuxText(track, timeOffset) {
var length = track.samples.length;
if (!length) {
return;
}
var inputTimeScale = track.inputTimeScale;
var initPTS = this._initPTS;
for (var index = 0; index < length; index++) {
var sample = track.samples[index]; // setting text pts, dts to relative time
// using this._initPTS and this._initDTS to calculate relative time
sample.pts = normalizePts(sample.pts - initPTS, timeOffset * inputTimeScale) / inputTimeScale;
}
track.samples.sort(function (a, b) {
return a.pts - b.pts;
});
var samples = track.samples;
track.samples = [];
return {
samples: samples
};
};
return MP4Remuxer;
}();
function normalizePts(value, reference) {
var offset;
if (reference === null) {
return value;
}
if (reference < value) {
// - 2^33
offset = -8589934592;
} else {
// + 2^33
offset = 8589934592;
}
/* PTS is 33bit (from 0 to 2^33 -1)
if diff between value and reference is bigger than half of the amplitude (2^32) then it means that
PTS looping occured. fill the gap */
while (Math.abs(value - reference) > 4294967296) {
value += offset;
}
return value;
}
function findKeyframeIndex(samples) {
for (var i = 0; i < samples.length; i++) {
if (samples[i].key) {
return i;
}
}
return -1;
}
var Mp4Sample = function Mp4Sample(isKeyframe, duration, size, cts) {
this.size = void 0;
this.duration = void 0;
this.cts = void 0;
this.flags = void 0;
this.duration = duration;
this.size = size;
this.cts = cts;
this.flags = new Mp4SampleFlags(isKeyframe);
};
var Mp4SampleFlags = function Mp4SampleFlags(isKeyframe) {
this.isLeading = 0;
this.isDependedOn = 0;
this.hasRedundancy = 0;
this.degradPrio = 0;
this.dependsOn = 1;
this.isNonSync = 1;
this.dependsOn = isKeyframe ? 2 : 1;
this.isNonSync = isKeyframe ? 0 : 1;
};
/***/ }),
/***/ "./src/remux/passthrough-remuxer.ts":
/*!******************************************!*\
!*** ./src/remux/passthrough-remuxer.ts ***!
\******************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _utils_mp4_tools__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils/mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _loader_fragment__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../loader/fragment */ "./src/loader/fragment.ts");
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
var PassThroughRemuxer = /*#__PURE__*/function () {
function PassThroughRemuxer() {
this.emitInitSegment = false;
this.audioCodec = void 0;
this.videoCodec = void 0;
this.initData = void 0;
this.initPTS = void 0;
this.initTracks = void 0;
this.lastEndDTS = null;
}
var _proto = PassThroughRemuxer.prototype;
_proto.destroy = function destroy() {};
_proto.resetTimeStamp = function resetTimeStamp(defaultInitPTS) {
this.initPTS = defaultInitPTS;
this.lastEndDTS = null;
};
_proto.resetNextTimestamp = function resetNextTimestamp() {
this.lastEndDTS = null;
};
_proto.resetInitSegment = function resetInitSegment(initSegment, audioCodec, videoCodec) {
this.audioCodec = audioCodec;
this.videoCodec = videoCodec;
this.generateInitSegment(initSegment);
this.emitInitSegment = true;
};
_proto.generateInitSegment = function generateInitSegment(initSegment) {
var audioCodec = this.audioCodec,
videoCodec = this.videoCodec;
if (!initSegment || !initSegment.byteLength) {
this.initTracks = undefined;
this.initData = undefined;
return;
}
var initData = this.initData = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_1__["parseInitSegment"])(initSegment); // Get codec from initSegment or fallback to default
if (!audioCodec) {
audioCodec = getParsedTrackCodec(initData.audio, _loader_fragment__WEBPACK_IMPORTED_MODULE_2__["ElementaryStreamTypes"].AUDIO);
}
if (!videoCodec) {
videoCodec = getParsedTrackCodec(initData.video, _loader_fragment__WEBPACK_IMPORTED_MODULE_2__["ElementaryStreamTypes"].VIDEO);
}
var tracks = {};
if (initData.audio && initData.video) {
tracks.audiovideo = {
container: 'video/mp4',
codec: audioCodec + ',' + videoCodec,
initSegment: initSegment,
id: 'main'
};
} else if (initData.audio) {
tracks.audio = {
container: 'audio/mp4',
codec: audioCodec,
initSegment: initSegment,
id: 'audio'
};
} else if (initData.video) {
tracks.video = {
container: 'video/mp4',
codec: videoCodec,
initSegment: initSegment,
id: 'main'
};
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn('[passthrough-remuxer.ts]: initSegment does not contain moov or trak boxes.');
}
this.initTracks = tracks;
};
_proto.remux = function remux(audioTrack, videoTrack, id3Track, textTrack, timeOffset) {
var initPTS = this.initPTS,
lastEndDTS = this.lastEndDTS;
var result = {
audio: undefined,
video: undefined,
text: textTrack,
id3: id3Track,
initSegment: undefined
}; // If we haven't yet set a lastEndDTS, or it was reset, set it to the provided timeOffset. We want to use the
// lastEndDTS over timeOffset whenever possible; during progressive playback, the media source will not update
// the media duration (which is what timeOffset is provided as) before we need to process the next chunk.
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(lastEndDTS)) {
lastEndDTS = this.lastEndDTS = timeOffset || 0;
} // The binary segment data is added to the videoTrack in the mp4demuxer. We don't check to see if the data is only
// audio or video (or both); adding it to video was an arbitrary choice.
var data = videoTrack.samples;
if (!data || !data.length) {
return result;
}
var initSegment = {
initPTS: undefined,
timescale: 1
};
var initData = this.initData;
if (!initData || !initData.length) {
this.generateInitSegment(data);
initData = this.initData;
}
if (!initData || !initData.length) {
// We can't remux if the initSegment could not be generated
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn('[passthrough-remuxer.ts]: Failed to generate initSegment.');
return result;
}
if (this.emitInitSegment) {
initSegment.tracks = this.initTracks;
this.emitInitSegment = false;
}
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(initPTS)) {
this.initPTS = initSegment.initPTS = initPTS = computeInitPTS(initData, data, lastEndDTS);
}
var duration = Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_1__["getDuration"])(data, initData);
var startDTS = lastEndDTS;
var endDTS = duration + startDTS;
Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_1__["offsetStartDTS"])(initData, data, initPTS);
if (duration > 0) {
this.lastEndDTS = endDTS;
} else {
_utils_logger__WEBPACK_IMPORTED_MODULE_3__["logger"].warn('Duration parsed from mp4 should be greater than zero');
this.resetNextTimestamp();
}
var hasAudio = !!initData.audio;
var hasVideo = !!initData.video;
var type = '';
if (hasAudio) {
type += 'audio';
}
if (hasVideo) {
type += 'video';
}
var track = {
data1: data,
startPTS: startDTS,
startDTS: startDTS,
endPTS: endDTS,
endDTS: endDTS,
type: type,
hasAudio: hasAudio,
hasVideo: hasVideo,
nb: 1,
dropped: 0
};
result.audio = track.type === 'audio' ? track : undefined;
result.video = track.type !== 'audio' ? track : undefined;
result.text = textTrack;
result.id3 = id3Track;
result.initSegment = initSegment;
return result;
};
return PassThroughRemuxer;
}();
var computeInitPTS = function computeInitPTS(initData, data, timeOffset) {
return Object(_utils_mp4_tools__WEBPACK_IMPORTED_MODULE_1__["getStartDTS"])(initData, data) - timeOffset;
};
function getParsedTrackCodec(track, type) {
var parsedCodec = track === null || track === void 0 ? void 0 : track.codec;
if (parsedCodec && parsedCodec.length > 4) {
return parsedCodec;
} // Since mp4-tools cannot parse full codec string (see 'TODO: Parse codec details'... in mp4-tools)
// Provide defaults based on codec type
// This allows for some playback of some fmp4 playlists without CODECS defined in manifest
if (parsedCodec === 'hvc1') {
return 'hvc1.1.c.L120.90';
}
if (parsedCodec === 'av01') {
return 'av01.0.04M.08';
}
if (parsedCodec === 'avc1' || type === _loader_fragment__WEBPACK_IMPORTED_MODULE_2__["ElementaryStreamTypes"].VIDEO) {
return 'avc1.42e01e';
}
return 'mp4a.40.5';
}
/* harmony default export */ __webpack_exports__["default"] = (PassThroughRemuxer);
/***/ }),
/***/ "./src/task-loop.ts":
/*!**************************!*\
!*** ./src/task-loop.ts ***!
\**************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return TaskLoop; });
/**
* Sub-class specialization of EventHandler base class.
*
* TaskLoop allows to schedule a task function being called (optionnaly repeatedly) on the main loop,
* scheduled asynchroneously, avoiding recursive calls in the same tick.
*
* The task itself is implemented in `doTick`. It can be requested and called for single execution
* using the `tick` method.
*
* It will be assured that the task execution method (`tick`) only gets called once per main loop "tick",
* no matter how often it gets requested for execution. Execution in further ticks will be scheduled accordingly.
*
* If further execution requests have already been scheduled on the next tick, it can be checked with `hasNextTick`,
* and cancelled with `clearNextTick`.
*
* The task can be scheduled as an interval repeatedly with a period as parameter (see `setInterval`, `clearInterval`).
*
* Sub-classes need to implement the `doTick` method which will effectively have the task execution routine.
*
* Further explanations:
*
* The baseclass has a `tick` method that will schedule the doTick call. It may be called synchroneously
* only for a stack-depth of one. On re-entrant calls, sub-sequent calls are scheduled for next main loop ticks.
*
* When the task execution (`tick` method) is called in re-entrant way this is detected and
* we are limiting the task execution per call stack to exactly one, but scheduling/post-poning further
* task processing on the next main loop iteration (also known as "next tick" in the Node/JS runtime lingo).
*/
var TaskLoop = /*#__PURE__*/function () {
function TaskLoop() {
this._boundTick = void 0;
this._tickTimer = null;
this._tickInterval = null;
this._tickCallCount = 0;
this._boundTick = this.tick.bind(this);
}
var _proto = TaskLoop.prototype;
_proto.destroy = function destroy() {
this.onHandlerDestroying();
this.onHandlerDestroyed();
};
_proto.onHandlerDestroying = function onHandlerDestroying() {
// clear all timers before unregistering from event bus
this.clearNextTick();
this.clearInterval();
};
_proto.onHandlerDestroyed = function onHandlerDestroyed() {}
/**
* @returns {boolean}
*/
;
_proto.hasInterval = function hasInterval() {
return !!this._tickInterval;
}
/**
* @returns {boolean}
*/
;
_proto.hasNextTick = function hasNextTick() {
return !!this._tickTimer;
}
/**
* @param {number} millis Interval time (ms)
* @returns {boolean} True when interval has been scheduled, false when already scheduled (no effect)
*/
;
_proto.setInterval = function setInterval(millis) {
if (!this._tickInterval) {
this._tickInterval = self.setInterval(this._boundTick, millis);
return true;
}
return false;
}
/**
* @returns {boolean} True when interval was cleared, false when none was set (no effect)
*/
;
_proto.clearInterval = function clearInterval() {
if (this._tickInterval) {
self.clearInterval(this._tickInterval);
this._tickInterval = null;
return true;
}
return false;
}
/**
* @returns {boolean} True when timeout was cleared, false when none was set (no effect)
*/
;
_proto.clearNextTick = function clearNextTick() {
if (this._tickTimer) {
self.clearTimeout(this._tickTimer);
this._tickTimer = null;
return true;
}
return false;
}
/**
* Will call the subclass doTick implementation in this main loop tick
* or in the next one (via setTimeout(,0)) in case it has already been called
* in this tick (in case this is a re-entrant call).
*/
;
_proto.tick = function tick() {
this._tickCallCount++;
if (this._tickCallCount === 1) {
this.doTick(); // re-entrant call to tick from previous doTick call stack
// -> schedule a call on the next main loop iteration to process this task processing request
if (this._tickCallCount > 1) {
// make sure only one timer exists at any time at max
this.tickImmediate();
}
this._tickCallCount = 0;
}
};
_proto.tickImmediate = function tickImmediate() {
this.clearNextTick();
this._tickTimer = self.setTimeout(this._boundTick, 0);
}
/**
* For subclass to implement task logic
* @abstract
*/
;
_proto.doTick = function doTick() {};
return TaskLoop;
}();
/***/ }),
/***/ "./src/types/level.ts":
/*!****************************!*\
!*** ./src/types/level.ts ***!
\****************************/
/*! exports provided: HlsSkip, getSkipValue, HlsUrlParameters, Level */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HlsSkip", function() { return HlsSkip; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getSkipValue", function() { return getSkipValue; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "HlsUrlParameters", function() { return HlsUrlParameters; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Level", function() { return Level; });
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
var HlsSkip;
(function (HlsSkip) {
HlsSkip["No"] = "";
HlsSkip["Yes"] = "YES";
HlsSkip["v2"] = "v2";
})(HlsSkip || (HlsSkip = {}));
function getSkipValue(details, msn) {
var canSkipUntil = details.canSkipUntil,
canSkipDateRanges = details.canSkipDateRanges,
endSN = details.endSN;
var snChangeGoal = msn !== undefined ? msn - endSN : 0;
if (canSkipUntil && snChangeGoal < canSkipUntil) {
if (canSkipDateRanges) {
return HlsSkip.v2;
}
return HlsSkip.Yes;
}
return HlsSkip.No;
}
var HlsUrlParameters = /*#__PURE__*/function () {
function HlsUrlParameters(msn, part, skip) {
this.msn = void 0;
this.part = void 0;
this.skip = void 0;
this.msn = msn;
this.part = part;
this.skip = skip;
}
var _proto = HlsUrlParameters.prototype;
_proto.addDirectives = function addDirectives(uri) {
var url = new self.URL(uri);
if (this.msn !== undefined) {
url.searchParams.set('_HLS_msn', this.msn.toString());
}
if (this.part !== undefined) {
url.searchParams.set('_HLS_part', this.part.toString());
}
if (this.skip) {
url.searchParams.set('_HLS_skip', this.skip);
}
return url.toString();
};
return HlsUrlParameters;
}();
var Level = /*#__PURE__*/function () {
function Level(data) {
this.attrs = void 0;
this.audioCodec = void 0;
this.bitrate = void 0;
this.codecSet = void 0;
this.height = void 0;
this.id = void 0;
this.name = void 0;
this.videoCodec = void 0;
this.width = void 0;
this.unknownCodecs = void 0;
this.audioGroupIds = void 0;
this.details = void 0;
this.fragmentError = 0;
this.loadError = 0;
this.loaded = void 0;
this.realBitrate = 0;
this.textGroupIds = void 0;
this.url = void 0;
this._urlId = 0;
this.url = [data.url];
this.attrs = data.attrs;
this.bitrate = data.bitrate;
if (data.details) {
this.details = data.details;
}
this.id = data.id || 0;
this.name = data.name;
this.width = data.width || 0;
this.height = data.height || 0;
this.audioCodec = data.audioCodec;
this.videoCodec = data.videoCodec;
this.unknownCodecs = data.unknownCodecs;
this.codecSet = [data.videoCodec, data.audioCodec].filter(function (c) {
return c;
}).join(',').replace(/\.[^.,]+/g, '');
}
_createClass(Level, [{
key: "maxBitrate",
get: function get() {
return Math.max(this.realBitrate, this.bitrate);
}
}, {
key: "uri",
get: function get() {
return this.url[this._urlId] || '';
}
}, {
key: "urlId",
get: function get() {
return this._urlId;
},
set: function set(value) {
var newValue = value % this.url.length;
if (this._urlId !== newValue) {
this.details = undefined;
this._urlId = newValue;
}
}
}]);
return Level;
}();
/***/ }),
/***/ "./src/types/loader.ts":
/*!*****************************!*\
!*** ./src/types/loader.ts ***!
\*****************************/
/*! exports provided: PlaylistContextType, PlaylistLevelType */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PlaylistContextType", function() { return PlaylistContextType; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PlaylistLevelType", function() { return PlaylistLevelType; });
var PlaylistContextType;
(function (PlaylistContextType) {
PlaylistContextType["MANIFEST"] = "manifest";
PlaylistContextType["LEVEL"] = "level";
PlaylistContextType["AUDIO_TRACK"] = "audioTrack";
PlaylistContextType["SUBTITLE_TRACK"] = "subtitleTrack";
})(PlaylistContextType || (PlaylistContextType = {}));
var PlaylistLevelType;
(function (PlaylistLevelType) {
PlaylistLevelType["MAIN"] = "main";
PlaylistLevelType["AUDIO"] = "audio";
PlaylistLevelType["SUBTITLE"] = "subtitle";
})(PlaylistLevelType || (PlaylistLevelType = {}));
/***/ }),
/***/ "./src/types/transmuxer.ts":
/*!*********************************!*\
!*** ./src/types/transmuxer.ts ***!
\*********************************/
/*! exports provided: ChunkMetadata */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ChunkMetadata", function() { return ChunkMetadata; });
var ChunkMetadata = function ChunkMetadata(level, sn, id, size, part, partial) {
if (size === void 0) {
size = 0;
}
if (part === void 0) {
part = -1;
}
if (partial === void 0) {
partial = false;
}
this.level = void 0;
this.sn = void 0;
this.part = void 0;
this.id = void 0;
this.size = void 0;
this.partial = void 0;
this.transmuxing = getNewPerformanceTiming();
this.buffering = {
audio: getNewPerformanceTiming(),
video: getNewPerformanceTiming(),
audiovideo: getNewPerformanceTiming()
};
this.level = level;
this.sn = sn;
this.id = id;
this.size = size;
this.part = part;
this.partial = partial;
};
function getNewPerformanceTiming() {
return {
start: 0,
executeStart: 0,
executeEnd: 0,
end: 0
};
}
/***/ }),
/***/ "./src/utils/attr-list.ts":
/*!********************************!*\
!*** ./src/utils/attr-list.ts ***!
\********************************/
/*! exports provided: AttrList */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "AttrList", function() { return AttrList; });
var DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/; // eslint-disable-line no-useless-escape
var ATTR_LIST_REGEX = /\s*(.+?)\s*=((?:\".*?\")|.*?)(?:,|$)/g; // eslint-disable-line no-useless-escape
// adapted from https://github.com/kanongil/node-m3u8parse/blob/master/attrlist.js
var AttrList = /*#__PURE__*/function () {
function AttrList(attrs) {
if (typeof attrs === 'string') {
attrs = AttrList.parseAttrList(attrs);
}
for (var attr in attrs) {
if (attrs.hasOwnProperty(attr)) {
this[attr] = attrs[attr];
}
}
}
var _proto = AttrList.prototype;
_proto.decimalInteger = function decimalInteger(attrName) {
var intValue = parseInt(this[attrName], 10);
if (intValue > Number.MAX_SAFE_INTEGER) {
return Infinity;
}
return intValue;
};
_proto.hexadecimalInteger = function hexadecimalInteger(attrName) {
if (this[attrName]) {
var stringValue = (this[attrName] || '0x').slice(2);
stringValue = (stringValue.length & 1 ? '0' : '') + stringValue;
var value = new Uint8Array(stringValue.length / 2);
for (var i = 0; i < stringValue.length / 2; i++) {
value[i] = parseInt(stringValue.slice(i * 2, i * 2 + 2), 16);
}
return value;
} else {
return null;
}
};
_proto.hexadecimalIntegerAsNumber = function hexadecimalIntegerAsNumber(attrName) {
var intValue = parseInt(this[attrName], 16);
if (intValue > Number.MAX_SAFE_INTEGER) {
return Infinity;
}
return intValue;
};
_proto.decimalFloatingPoint = function decimalFloatingPoint(attrName) {
return parseFloat(this[attrName]);
};
_proto.optionalFloat = function optionalFloat(attrName, defaultValue) {
var value = this[attrName];
return value ? parseFloat(value) : defaultValue;
};
_proto.enumeratedString = function enumeratedString(attrName) {
return this[attrName];
};
_proto.bool = function bool(attrName) {
return this[attrName] === 'YES';
};
_proto.decimalResolution = function decimalResolution(attrName) {
var res = DECIMAL_RESOLUTION_REGEX.exec(this[attrName]);
if (res === null) {
return undefined;
}
return {
width: parseInt(res[1], 10),
height: parseInt(res[2], 10)
};
};
AttrList.parseAttrList = function parseAttrList(input) {
var match;
var attrs = {};
var quote = '"';
ATTR_LIST_REGEX.lastIndex = 0;
while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
var value = match[2];
if (value.indexOf(quote) === 0 && value.lastIndexOf(quote) === value.length - 1) {
value = value.slice(1, -1);
}
attrs[match[1]] = value;
}
return attrs;
};
return AttrList;
}();
/***/ }),
/***/ "./src/utils/binary-search.ts":
/*!************************************!*\
!*** ./src/utils/binary-search.ts ***!
\************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
var BinarySearch = {
/**
* Searches for an item in an array which matches a certain condition.
* This requires the condition to only match one item in the array,
* and for the array to be ordered.
*
* @param {Array<T>} list The array to search.
* @param {BinarySearchComparison<T>} comparisonFn
* Called and provided a candidate item as the first argument.
* Should return:
* > -1 if the item should be located at a lower index than the provided item.
* > 1 if the item should be located at a higher index than the provided item.
* > 0 if the item is the item you're looking for.
*
* @return {T | null} The object if it is found or null otherwise.
*/
search: function search(list, comparisonFn) {
var minIndex = 0;
var maxIndex = list.length - 1;
var currentIndex = null;
var currentElement = null;
while (minIndex <= maxIndex) {
currentIndex = (minIndex + maxIndex) / 2 | 0;
currentElement = list[currentIndex];
var comparisonResult = comparisonFn(currentElement);
if (comparisonResult > 0) {
minIndex = currentIndex + 1;
} else if (comparisonResult < 0) {
maxIndex = currentIndex - 1;
} else {
return currentElement;
}
}
return null;
}
};
/* harmony default export */ __webpack_exports__["default"] = (BinarySearch);
/***/ }),
/***/ "./src/utils/buffer-helper.ts":
/*!************************************!*\
!*** ./src/utils/buffer-helper.ts ***!
\************************************/
/*! exports provided: BufferHelper */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "BufferHelper", function() { return BufferHelper; });
/* harmony import */ var _logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./logger */ "./src/utils/logger.ts");
/**
* @module BufferHelper
*
* Providing methods dealing with buffer length retrieval for example.
*
* In general, a helper around HTML5 MediaElement TimeRanges gathered from `buffered` property.
*
* Also @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/buffered
*/
var noopBuffered = {
length: 0,
start: function start() {
return 0;
},
end: function end() {
return 0;
}
};
var BufferHelper = /*#__PURE__*/function () {
function BufferHelper() {}
/**
* Return true if `media`'s buffered include `position`
* @param {Bufferable} media
* @param {number} position
* @returns {boolean}
*/
BufferHelper.isBuffered = function isBuffered(media, position) {
try {
if (media) {
var buffered = BufferHelper.getBuffered(media);
for (var i = 0; i < buffered.length; i++) {
if (position >= buffered.start(i) && position <= buffered.end(i)) {
return true;
}
}
}
} catch (error) {// this is to catch
// InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
// This SourceBuffer has been removed from the parent media source
}
return false;
};
BufferHelper.bufferInfo = function bufferInfo(media, pos, maxHoleDuration) {
try {
if (media) {
var vbuffered = BufferHelper.getBuffered(media);
var buffered = [];
var i;
for (i = 0; i < vbuffered.length; i++) {
buffered.push({
start: vbuffered.start(i),
end: vbuffered.end(i)
});
}
return this.bufferedInfo(buffered, pos, maxHoleDuration);
}
} catch (error) {// this is to catch
// InvalidStateError: Failed to read the 'buffered' property from 'SourceBuffer':
// This SourceBuffer has been removed from the parent media source
}
return {
len: 0,
start: pos,
end: pos,
nextStart: undefined
};
};
BufferHelper.bufferedInfo = function bufferedInfo(buffered, pos, maxHoleDuration) {
pos = Math.max(0, pos); // sort on buffer.start/smaller end (IE does not always return sorted buffered range)
buffered.sort(function (a, b) {
var diff = a.start - b.start;
if (diff) {
return diff;
} else {
return b.end - a.end;
}
});
var buffered2 = [];
if (maxHoleDuration) {
// there might be some small holes between buffer time range
// consider that holes smaller than maxHoleDuration are irrelevant and build another
// buffer time range representations that discards those holes
for (var i = 0; i < buffered.length; i++) {
var buf2len = buffered2.length;
if (buf2len) {
var buf2end = buffered2[buf2len - 1].end; // if small hole (value between 0 or maxHoleDuration ) or overlapping (negative)
if (buffered[i].start - buf2end < maxHoleDuration) {
// merge overlapping time ranges
// update lastRange.end only if smaller than item.end
// e.g. [ 1, 15] with [ 2,8] => [ 1,15] (no need to modify lastRange.end)
// whereas [ 1, 8] with [ 2,15] => [ 1,15] ( lastRange should switch from [1,8] to [1,15])
if (buffered[i].end > buf2end) {
buffered2[buf2len - 1].end = buffered[i].end;
}
} else {
// big hole
buffered2.push(buffered[i]);
}
} else {
// first value
buffered2.push(buffered[i]);
}
}
} else {
buffered2 = buffered;
}
var bufferLen = 0; // bufferStartNext can possibly be undefined based on the conditional logic below
var bufferStartNext; // bufferStart and bufferEnd are buffer boundaries around current video position
var bufferStart = pos;
var bufferEnd = pos;
for (var _i = 0; _i < buffered2.length; _i++) {
var start = buffered2[_i].start;
var end = buffered2[_i].end; // logger.log('buf start/end:' + buffered.start(i) + '/' + buffered.end(i));
if (pos + maxHoleDuration >= start && pos < end) {
// play position is inside this buffer TimeRange, retrieve end of buffer position and buffer length
bufferStart = start;
bufferEnd = end;
bufferLen = bufferEnd - pos;
} else if (pos + maxHoleDuration < start) {
bufferStartNext = start;
break;
}
}
return {
len: bufferLen,
start: bufferStart || 0,
end: bufferEnd || 0,
nextStart: bufferStartNext
};
}
/**
* Safe method to get buffered property.
* SourceBuffer.buffered may throw if SourceBuffer is removed from it's MediaSource
*/
;
BufferHelper.getBuffered = function getBuffered(media) {
try {
return media.buffered;
} catch (e) {
_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].log('failed to get media.buffered', e);
return noopBuffered;
}
};
return BufferHelper;
}();
/***/ }),
/***/ "./src/utils/cea-608-parser.ts":
/*!*************************************!*\
!*** ./src/utils/cea-608-parser.ts ***!
\*************************************/
/*! exports provided: Row, CaptionScreen, default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Row", function() { return Row; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CaptionScreen", function() { return CaptionScreen; });
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/**
*
* This code was ported from the dash.js project at:
* https://github.com/Dash-Industry-Forum/dash.js/blob/development/externals/cea608-parser.js
* https://github.com/Dash-Industry-Forum/dash.js/commit/8269b26a761e0853bb21d78780ed945144ecdd4d#diff-71bc295a2d6b6b7093a1d3290d53a4b2
*
* The original copyright appears below:
*
* The copyright in this software is being made available under the BSD License,
* included below. This software may be subject to other third party and contributor
* rights, including patent rights, and no such rights are granted under this license.
*
* Copyright (c) 2015-2016, DASH Industry Forum.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
* 2. Neither the name of Dash Industry Forum nor the names of its
* contributors may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/**
* Exceptions from regular ASCII. CodePoints are mapped to UTF-16 codes
*/
var specialCea608CharsCodes = {
0x2a: 0xe1,
// lowercase a, acute accent
0x5c: 0xe9,
// lowercase e, acute accent
0x5e: 0xed,
// lowercase i, acute accent
0x5f: 0xf3,
// lowercase o, acute accent
0x60: 0xfa,
// lowercase u, acute accent
0x7b: 0xe7,
// lowercase c with cedilla
0x7c: 0xf7,
// division symbol
0x7d: 0xd1,
// uppercase N tilde
0x7e: 0xf1,
// lowercase n tilde
0x7f: 0x2588,
// Full block
// THIS BLOCK INCLUDES THE 16 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
// THAT COME FROM HI BYTE=0x11 AND LOW BETWEEN 0x30 AND 0x3F
// THIS MEANS THAT \x50 MUST BE ADDED TO THE VALUES
0x80: 0xae,
// Registered symbol (R)
0x81: 0xb0,
// degree sign
0x82: 0xbd,
// 1/2 symbol
0x83: 0xbf,
// Inverted (open) question mark
0x84: 0x2122,
// Trademark symbol (TM)
0x85: 0xa2,
// Cents symbol
0x86: 0xa3,
// Pounds sterling
0x87: 0x266a,
// Music 8'th note
0x88: 0xe0,
// lowercase a, grave accent
0x89: 0x20,
// transparent space (regular)
0x8a: 0xe8,
// lowercase e, grave accent
0x8b: 0xe2,
// lowercase a, circumflex accent
0x8c: 0xea,
// lowercase e, circumflex accent
0x8d: 0xee,
// lowercase i, circumflex accent
0x8e: 0xf4,
// lowercase o, circumflex accent
0x8f: 0xfb,
// lowercase u, circumflex accent
// THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
// THAT COME FROM HI BYTE=0x12 AND LOW BETWEEN 0x20 AND 0x3F
0x90: 0xc1,
// capital letter A with acute
0x91: 0xc9,
// capital letter E with acute
0x92: 0xd3,
// capital letter O with acute
0x93: 0xda,
// capital letter U with acute
0x94: 0xdc,
// capital letter U with diaresis
0x95: 0xfc,
// lowercase letter U with diaeresis
0x96: 0x2018,
// opening single quote
0x97: 0xa1,
// inverted exclamation mark
0x98: 0x2a,
// asterisk
0x99: 0x2019,
// closing single quote
0x9a: 0x2501,
// box drawings heavy horizontal
0x9b: 0xa9,
// copyright sign
0x9c: 0x2120,
// Service mark
0x9d: 0x2022,
// (round) bullet
0x9e: 0x201c,
// Left double quotation mark
0x9f: 0x201d,
// Right double quotation mark
0xa0: 0xc0,
// uppercase A, grave accent
0xa1: 0xc2,
// uppercase A, circumflex
0xa2: 0xc7,
// uppercase C with cedilla
0xa3: 0xc8,
// uppercase E, grave accent
0xa4: 0xca,
// uppercase E, circumflex
0xa5: 0xcb,
// capital letter E with diaresis
0xa6: 0xeb,
// lowercase letter e with diaresis
0xa7: 0xce,
// uppercase I, circumflex
0xa8: 0xcf,
// uppercase I, with diaresis
0xa9: 0xef,
// lowercase i, with diaresis
0xaa: 0xd4,
// uppercase O, circumflex
0xab: 0xd9,
// uppercase U, grave accent
0xac: 0xf9,
// lowercase u, grave accent
0xad: 0xdb,
// uppercase U, circumflex
0xae: 0xab,
// left-pointing double angle quotation mark
0xaf: 0xbb,
// right-pointing double angle quotation mark
// THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
// THAT COME FROM HI BYTE=0x13 AND LOW BETWEEN 0x20 AND 0x3F
0xb0: 0xc3,
// Uppercase A, tilde
0xb1: 0xe3,
// Lowercase a, tilde
0xb2: 0xcd,
// Uppercase I, acute accent
0xb3: 0xcc,
// Uppercase I, grave accent
0xb4: 0xec,
// Lowercase i, grave accent
0xb5: 0xd2,
// Uppercase O, grave accent
0xb6: 0xf2,
// Lowercase o, grave accent
0xb7: 0xd5,
// Uppercase O, tilde
0xb8: 0xf5,
// Lowercase o, tilde
0xb9: 0x7b,
// Open curly brace
0xba: 0x7d,
// Closing curly brace
0xbb: 0x5c,
// Backslash
0xbc: 0x5e,
// Caret
0xbd: 0x5f,
// Underscore
0xbe: 0x7c,
// Pipe (vertical line)
0xbf: 0x223c,
// Tilde operator
0xc0: 0xc4,
// Uppercase A, umlaut
0xc1: 0xe4,
// Lowercase A, umlaut
0xc2: 0xd6,
// Uppercase O, umlaut
0xc3: 0xf6,
// Lowercase o, umlaut
0xc4: 0xdf,
// Esszett (sharp S)
0xc5: 0xa5,
// Yen symbol
0xc6: 0xa4,
// Generic currency sign
0xc7: 0x2503,
// Box drawings heavy vertical
0xc8: 0xc5,
// Uppercase A, ring
0xc9: 0xe5,
// Lowercase A, ring
0xca: 0xd8,
// Uppercase O, stroke
0xcb: 0xf8,
// Lowercase o, strok
0xcc: 0x250f,
// Box drawings heavy down and right
0xcd: 0x2513,
// Box drawings heavy down and left
0xce: 0x2517,
// Box drawings heavy up and right
0xcf: 0x251b // Box drawings heavy up and left
};
/**
* Utils
*/
var getCharForByte = function getCharForByte(_byte) {
var charCode = _byte;
if (specialCea608CharsCodes.hasOwnProperty(_byte)) {
charCode = specialCea608CharsCodes[_byte];
}
return String.fromCharCode(charCode);
};
var NR_ROWS = 15;
var NR_COLS = 100; // Tables to look up row from PAC data
var rowsLowCh1 = {
0x11: 1,
0x12: 3,
0x15: 5,
0x16: 7,
0x17: 9,
0x10: 11,
0x13: 12,
0x14: 14
};
var rowsHighCh1 = {
0x11: 2,
0x12: 4,
0x15: 6,
0x16: 8,
0x17: 10,
0x13: 13,
0x14: 15
};
var rowsLowCh2 = {
0x19: 1,
0x1a: 3,
0x1d: 5,
0x1e: 7,
0x1f: 9,
0x18: 11,
0x1b: 12,
0x1c: 14
};
var rowsHighCh2 = {
0x19: 2,
0x1a: 4,
0x1d: 6,
0x1e: 8,
0x1f: 10,
0x1b: 13,
0x1c: 15
};
var backgroundColors = ['white', 'green', 'blue', 'cyan', 'red', 'yellow', 'magenta', 'black', 'transparent'];
var VerboseLevel;
(function (VerboseLevel) {
VerboseLevel[VerboseLevel["ERROR"] = 0] = "ERROR";
VerboseLevel[VerboseLevel["TEXT"] = 1] = "TEXT";
VerboseLevel[VerboseLevel["WARNING"] = 2] = "WARNING";
VerboseLevel[VerboseLevel["INFO"] = 2] = "INFO";
VerboseLevel[VerboseLevel["DEBUG"] = 3] = "DEBUG";
VerboseLevel[VerboseLevel["DATA"] = 3] = "DATA";
})(VerboseLevel || (VerboseLevel = {}));
var CaptionsLogger = /*#__PURE__*/function () {
function CaptionsLogger() {
this.time = null;
this.verboseLevel = VerboseLevel.ERROR;
}
var _proto = CaptionsLogger.prototype;
_proto.log = function log(severity, msg) {
if (this.verboseLevel >= severity) {
_utils_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].log(this.time + " [" + severity + "] " + msg);
}
};
return CaptionsLogger;
}();
var numArrayToHexArray = function numArrayToHexArray(numArray) {
var hexArray = [];
for (var j = 0; j < numArray.length; j++) {
hexArray.push(numArray[j].toString(16));
}
return hexArray;
};
var PenState = /*#__PURE__*/function () {
function PenState(foreground, underline, italics, background, flash) {
this.foreground = void 0;
this.underline = void 0;
this.italics = void 0;
this.background = void 0;
this.flash = void 0;
this.foreground = foreground || 'white';
this.underline = underline || false;
this.italics = italics || false;
this.background = background || 'black';
this.flash = flash || false;
}
var _proto2 = PenState.prototype;
_proto2.reset = function reset() {
this.foreground = 'white';
this.underline = false;
this.italics = false;
this.background = 'black';
this.flash = false;
};
_proto2.setStyles = function setStyles(styles) {
var attribs = ['foreground', 'underline', 'italics', 'background', 'flash'];
for (var i = 0; i < attribs.length; i++) {
var style = attribs[i];
if (styles.hasOwnProperty(style)) {
this[style] = styles[style];
}
}
};
_proto2.isDefault = function isDefault() {
return this.foreground === 'white' && !this.underline && !this.italics && this.background === 'black' && !this.flash;
};
_proto2.equals = function equals(other) {
return this.foreground === other.foreground && this.underline === other.underline && this.italics === other.italics && this.background === other.background && this.flash === other.flash;
};
_proto2.copy = function copy(newPenState) {
this.foreground = newPenState.foreground;
this.underline = newPenState.underline;
this.italics = newPenState.italics;
this.background = newPenState.background;
this.flash = newPenState.flash;
};
_proto2.toString = function toString() {
return 'color=' + this.foreground + ', underline=' + this.underline + ', italics=' + this.italics + ', background=' + this.background + ', flash=' + this.flash;
};
return PenState;
}();
/**
* Unicode character with styling and background.
* @constructor
*/
var StyledUnicodeChar = /*#__PURE__*/function () {
function StyledUnicodeChar(uchar, foreground, underline, italics, background, flash) {
this.uchar = void 0;
this.penState = void 0;
this.uchar = uchar || ' '; // unicode character
this.penState = new PenState(foreground, underline, italics, background, flash);
}
var _proto3 = StyledUnicodeChar.prototype;
_proto3.reset = function reset() {
this.uchar = ' ';
this.penState.reset();
};
_proto3.setChar = function setChar(uchar, newPenState) {
this.uchar = uchar;
this.penState.copy(newPenState);
};
_proto3.setPenState = function setPenState(newPenState) {
this.penState.copy(newPenState);
};
_proto3.equals = function equals(other) {
return this.uchar === other.uchar && this.penState.equals(other.penState);
};
_proto3.copy = function copy(newChar) {
this.uchar = newChar.uchar;
this.penState.copy(newChar.penState);
};
_proto3.isEmpty = function isEmpty() {
return this.uchar === ' ' && this.penState.isDefault();
};
return StyledUnicodeChar;
}();
/**
* CEA-608 row consisting of NR_COLS instances of StyledUnicodeChar.
* @constructor
*/
var Row = /*#__PURE__*/function () {
function Row(logger) {
this.chars = void 0;
this.pos = void 0;
this.currPenState = void 0;
this.cueStartTime = void 0;
this.logger = void 0;
this.chars = [];
for (var i = 0; i < NR_COLS; i++) {
this.chars.push(new StyledUnicodeChar());
}
this.logger = logger;
this.pos = 0;
this.currPenState = new PenState();
}
var _proto4 = Row.prototype;
_proto4.equals = function equals(other) {
var equal = true;
for (var i = 0; i < NR_COLS; i++) {
if (!this.chars[i].equals(other.chars[i])) {
equal = false;
break;
}
}
return equal;
};
_proto4.copy = function copy(other) {
for (var i = 0; i < NR_COLS; i++) {
this.chars[i].copy(other.chars[i]);
}
};
_proto4.isEmpty = function isEmpty() {
var empty = true;
for (var i = 0; i < NR_COLS; i++) {
if (!this.chars[i].isEmpty()) {
empty = false;
break;
}
}
return empty;
}
/**
* Set the cursor to a valid column.
*/
;
_proto4.setCursor = function setCursor(absPos) {
if (this.pos !== absPos) {
this.pos = absPos;
}
if (this.pos < 0) {
this.logger.log(VerboseLevel.DEBUG, 'Negative cursor position ' + this.pos);
this.pos = 0;
} else if (this.pos > NR_COLS) {
this.logger.log(VerboseLevel.DEBUG, 'Too large cursor position ' + this.pos);
this.pos = NR_COLS;
}
}
/**
* Move the cursor relative to current position.
*/
;
_proto4.moveCursor = function moveCursor(relPos) {
var newPos = this.pos + relPos;
if (relPos > 1) {
for (var i = this.pos + 1; i < newPos + 1; i++) {
this.chars[i].setPenState(this.currPenState);
}
}
this.setCursor(newPos);
}
/**
* Backspace, move one step back and clear character.
*/
;
_proto4.backSpace = function backSpace() {
this.moveCursor(-1);
this.chars[this.pos].setChar(' ', this.currPenState);
};
_proto4.insertChar = function insertChar(_byte2) {
if (_byte2 >= 0x90) {
// Extended char
this.backSpace();
}
var _char = getCharForByte(_byte2);
if (this.pos >= NR_COLS) {
this.logger.log(VerboseLevel.ERROR, 'Cannot insert ' + _byte2.toString(16) + ' (' + _char + ') at position ' + this.pos + '. Skipping it!');
return;
}
this.chars[this.pos].setChar(_char, this.currPenState);
this.moveCursor(1);
};
_proto4.clearFromPos = function clearFromPos(startPos) {
var i;
for (i = startPos; i < NR_COLS; i++) {
this.chars[i].reset();
}
};
_proto4.clear = function clear() {
this.clearFromPos(0);
this.pos = 0;
this.currPenState.reset();
};
_proto4.clearToEndOfRow = function clearToEndOfRow() {
this.clearFromPos(this.pos);
};
_proto4.getTextString = function getTextString() {
var chars = [];
var empty = true;
for (var i = 0; i < NR_COLS; i++) {
var _char2 = this.chars[i].uchar;
if (_char2 !== ' ') {
empty = false;
}
chars.push(_char2);
}
if (empty) {
return '';
} else {
return chars.join('');
}
};
_proto4.setPenStyles = function setPenStyles(styles) {
this.currPenState.setStyles(styles);
var currChar = this.chars[this.pos];
currChar.setPenState(this.currPenState);
};
return Row;
}();
/**
* Keep a CEA-608 screen of 32x15 styled characters
* @constructor
*/
var CaptionScreen = /*#__PURE__*/function () {
function CaptionScreen(logger) {
this.rows = void 0;
this.currRow = void 0;
this.nrRollUpRows = void 0;
this.lastOutputScreen = void 0;
this.logger = void 0;
this.rows = [];
for (var i = 0; i < NR_ROWS; i++) {
this.rows.push(new Row(logger));
} // Note that we use zero-based numbering (0-14)
this.logger = logger;
this.currRow = NR_ROWS - 1;
this.nrRollUpRows = null;
this.lastOutputScreen = null;
this.reset();
}
var _proto5 = CaptionScreen.prototype;
_proto5.reset = function reset() {
for (var i = 0; i < NR_ROWS; i++) {
this.rows[i].clear();
}
this.currRow = NR_ROWS - 1;
};
_proto5.equals = function equals(other) {
var equal = true;
for (var i = 0; i < NR_ROWS; i++) {
if (!this.rows[i].equals(other.rows[i])) {
equal = false;
break;
}
}
return equal;
};
_proto5.copy = function copy(other) {
for (var i = 0; i < NR_ROWS; i++) {
this.rows[i].copy(other.rows[i]);
}
};
_proto5.isEmpty = function isEmpty() {
var empty = true;
for (var i = 0; i < NR_ROWS; i++) {
if (!this.rows[i].isEmpty()) {
empty = false;
break;
}
}
return empty;
};
_proto5.backSpace = function backSpace() {
var row = this.rows[this.currRow];
row.backSpace();
};
_proto5.clearToEndOfRow = function clearToEndOfRow() {
var row = this.rows[this.currRow];
row.clearToEndOfRow();
}
/**
* Insert a character (without styling) in the current row.
*/
;
_proto5.insertChar = function insertChar(_char3) {
var row = this.rows[this.currRow];
row.insertChar(_char3);
};
_proto5.setPen = function setPen(styles) {
var row = this.rows[this.currRow];
row.setPenStyles(styles);
};
_proto5.moveCursor = function moveCursor(relPos) {
var row = this.rows[this.currRow];
row.moveCursor(relPos);
};
_proto5.setCursor = function setCursor(absPos) {
this.logger.log(VerboseLevel.INFO, 'setCursor: ' + absPos);
var row = this.rows[this.currRow];
row.setCursor(absPos);
};
_proto5.setPAC = function setPAC(pacData) {
this.logger.log(VerboseLevel.INFO, 'pacData = ' + JSON.stringify(pacData));
var newRow = pacData.row - 1;
if (this.nrRollUpRows && newRow < this.nrRollUpRows - 1) {
newRow = this.nrRollUpRows - 1;
} // Make sure this only affects Roll-up Captions by checking this.nrRollUpRows
if (this.nrRollUpRows && this.currRow !== newRow) {
// clear all rows first
for (var i = 0; i < NR_ROWS; i++) {
this.rows[i].clear();
} // Copy this.nrRollUpRows rows from lastOutputScreen and place it in the newRow location
// topRowIndex - the start of rows to copy (inclusive index)
var topRowIndex = this.currRow + 1 - this.nrRollUpRows; // We only copy if the last position was already shown.
// We use the cueStartTime value to check this.
var lastOutputScreen = this.lastOutputScreen;
if (lastOutputScreen) {
var prevLineTime = lastOutputScreen.rows[topRowIndex].cueStartTime;
var time = this.logger.time;
if (prevLineTime && time !== null && prevLineTime < time) {
for (var _i = 0; _i < this.nrRollUpRows; _i++) {
this.rows[newRow - this.nrRollUpRows + _i + 1].copy(lastOutputScreen.rows[topRowIndex + _i]);
}
}
}
}
this.currRow = newRow;
var row = this.rows[this.currRow];
if (pacData.indent !== null) {
var indent = pacData.indent;
var prevPos = Math.max(indent - 1, 0);
row.setCursor(pacData.indent);
pacData.color = row.chars[prevPos].penState.foreground;
}
var styles = {
foreground: pacData.color,
underline: pacData.underline,
italics: pacData.italics,
background: 'black',
flash: false
};
this.setPen(styles);
}
/**
* Set background/extra foreground, but first do back_space, and then insert space (backwards compatibility).
*/
;
_proto5.setBkgData = function setBkgData(bkgData) {
this.logger.log(VerboseLevel.INFO, 'bkgData = ' + JSON.stringify(bkgData));
this.backSpace();
this.setPen(bkgData);
this.insertChar(0x20); // Space
};
_proto5.setRollUpRows = function setRollUpRows(nrRows) {
this.nrRollUpRows = nrRows;
};
_proto5.rollUp = function rollUp() {
if (this.nrRollUpRows === null) {
this.logger.log(VerboseLevel.DEBUG, 'roll_up but nrRollUpRows not set yet');
return; // Not properly setup
}
this.logger.log(VerboseLevel.TEXT, this.getDisplayText());
var topRowIndex = this.currRow + 1 - this.nrRollUpRows;
var topRow = this.rows.splice(topRowIndex, 1)[0];
topRow.clear();
this.rows.splice(this.currRow, 0, topRow);
this.logger.log(VerboseLevel.INFO, 'Rolling up'); // this.logger.log(VerboseLevel.TEXT, this.get_display_text())
}
/**
* Get all non-empty rows with as unicode text.
*/
;
_proto5.getDisplayText = function getDisplayText(asOneRow) {
asOneRow = asOneRow || false;
var displayText = [];
var text = '';
var rowNr = -1;
for (var i = 0; i < NR_ROWS; i++) {
var rowText = this.rows[i].getTextString();
if (rowText) {
rowNr = i + 1;
if (asOneRow) {
displayText.push('Row ' + rowNr + ": '" + rowText + "'");
} else {
displayText.push(rowText.trim());
}
}
}
if (displayText.length > 0) {
if (asOneRow) {
text = '[' + displayText.join(' | ') + ']';
} else {
text = displayText.join('\n');
}
}
return text;
};
_proto5.getTextAndFormat = function getTextAndFormat() {
return this.rows;
};
return CaptionScreen;
}(); // var modes = ['MODE_ROLL-UP', 'MODE_POP-ON', 'MODE_PAINT-ON', 'MODE_TEXT'];
var Cea608Channel = /*#__PURE__*/function () {
function Cea608Channel(channelNumber, outputFilter, logger) {
this.chNr = void 0;
this.outputFilter = void 0;
this.mode = void 0;
this.verbose = void 0;
this.displayedMemory = void 0;
this.nonDisplayedMemory = void 0;
this.lastOutputScreen = void 0;
this.currRollUpRow = void 0;
this.writeScreen = void 0;
this.cueStartTime = void 0;
this.logger = void 0;
this.chNr = channelNumber;
this.outputFilter = outputFilter;
this.mode = null;
this.verbose = 0;
this.displayedMemory = new CaptionScreen(logger);
this.nonDisplayedMemory = new CaptionScreen(logger);
this.lastOutputScreen = new CaptionScreen(logger);
this.currRollUpRow = this.displayedMemory.rows[NR_ROWS - 1];
this.writeScreen = this.displayedMemory;
this.mode = null;
this.cueStartTime = null; // Keeps track of where a cue started.
this.logger = logger;
}
var _proto6 = Cea608Channel.prototype;
_proto6.reset = function reset() {
this.mode = null;
this.displayedMemory.reset();
this.nonDisplayedMemory.reset();
this.lastOutputScreen.reset();
this.outputFilter.reset();
this.currRollUpRow = this.displayedMemory.rows[NR_ROWS - 1];
this.writeScreen = this.displayedMemory;
this.mode = null;
this.cueStartTime = null;
};
_proto6.getHandler = function getHandler() {
return this.outputFilter;
};
_proto6.setHandler = function setHandler(newHandler) {
this.outputFilter = newHandler;
};
_proto6.setPAC = function setPAC(pacData) {
this.writeScreen.setPAC(pacData);
};
_proto6.setBkgData = function setBkgData(bkgData) {
this.writeScreen.setBkgData(bkgData);
};
_proto6.setMode = function setMode(newMode) {
if (newMode === this.mode) {
return;
}
this.mode = newMode;
this.logger.log(VerboseLevel.INFO, 'MODE=' + newMode);
if (this.mode === 'MODE_POP-ON') {
this.writeScreen = this.nonDisplayedMemory;
} else {
this.writeScreen = this.displayedMemory;
this.writeScreen.reset();
}
if (this.mode !== 'MODE_ROLL-UP') {
this.displayedMemory.nrRollUpRows = null;
this.nonDisplayedMemory.nrRollUpRows = null;
}
this.mode = newMode;
};
_proto6.insertChars = function insertChars(chars) {
for (var i = 0; i < chars.length; i++) {
this.writeScreen.insertChar(chars[i]);
}
var screen = this.writeScreen === this.displayedMemory ? 'DISP' : 'NON_DISP';
this.logger.log(VerboseLevel.INFO, screen + ': ' + this.writeScreen.getDisplayText(true));
if (this.mode === 'MODE_PAINT-ON' || this.mode === 'MODE_ROLL-UP') {
this.logger.log(VerboseLevel.TEXT, 'DISPLAYED: ' + this.displayedMemory.getDisplayText(true));
this.outputDataUpdate();
}
};
_proto6.ccRCL = function ccRCL() {
// Resume Caption Loading (switch mode to Pop On)
this.logger.log(VerboseLevel.INFO, 'RCL - Resume Caption Loading');
this.setMode('MODE_POP-ON');
};
_proto6.ccBS = function ccBS() {
// BackSpace
this.logger.log(VerboseLevel.INFO, 'BS - BackSpace');
if (this.mode === 'MODE_TEXT') {
return;
}
this.writeScreen.backSpace();
if (this.writeScreen === this.displayedMemory) {
this.outputDataUpdate();
}
};
_proto6.ccAOF = function ccAOF() {// Reserved (formerly Alarm Off)
};
_proto6.ccAON = function ccAON() {// Reserved (formerly Alarm On)
};
_proto6.ccDER = function ccDER() {
// Delete to End of Row
this.logger.log(VerboseLevel.INFO, 'DER- Delete to End of Row');
this.writeScreen.clearToEndOfRow();
this.outputDataUpdate();
};
_proto6.ccRU = function ccRU(nrRows) {
// Roll-Up Captions-2,3,or 4 Rows
this.logger.log(VerboseLevel.INFO, 'RU(' + nrRows + ') - Roll Up');
this.writeScreen = this.displayedMemory;
this.setMode('MODE_ROLL-UP');
this.writeScreen.setRollUpRows(nrRows);
};
_proto6.ccFON = function ccFON() {
// Flash On
this.logger.log(VerboseLevel.INFO, 'FON - Flash On');
this.writeScreen.setPen({
flash: true
});
};
_proto6.ccRDC = function ccRDC() {
// Resume Direct Captioning (switch mode to PaintOn)
this.logger.log(VerboseLevel.INFO, 'RDC - Resume Direct Captioning');
this.setMode('MODE_PAINT-ON');
};
_proto6.ccTR = function ccTR() {
// Text Restart in text mode (not supported, however)
this.logger.log(VerboseLevel.INFO, 'TR');
this.setMode('MODE_TEXT');
};
_proto6.ccRTD = function ccRTD() {
// Resume Text Display in Text mode (not supported, however)
this.logger.log(VerboseLevel.INFO, 'RTD');
this.setMode('MODE_TEXT');
};
_proto6.ccEDM = function ccEDM() {
// Erase Displayed Memory
this.logger.log(VerboseLevel.INFO, 'EDM - Erase Displayed Memory');
this.displayedMemory.reset();
this.outputDataUpdate(true);
};
_proto6.ccCR = function ccCR() {
// Carriage Return
this.logger.log(VerboseLevel.INFO, 'CR - Carriage Return');
this.writeScreen.rollUp();
this.outputDataUpdate(true);
};
_proto6.ccENM = function ccENM() {
// Erase Non-Displayed Memory
this.logger.log(VerboseLevel.INFO, 'ENM - Erase Non-displayed Memory');
this.nonDisplayedMemory.reset();
};
_proto6.ccEOC = function ccEOC() {
// End of Caption (Flip Memories)
this.logger.log(VerboseLevel.INFO, 'EOC - End Of Caption');
if (this.mode === 'MODE_POP-ON') {
var tmp = this.displayedMemory;
this.displayedMemory = this.nonDisplayedMemory;
this.nonDisplayedMemory = tmp;
this.writeScreen = this.nonDisplayedMemory;
this.logger.log(VerboseLevel.TEXT, 'DISP: ' + this.displayedMemory.getDisplayText());
}
this.outputDataUpdate(true);
};
_proto6.ccTO = function ccTO(nrCols) {
// Tab Offset 1,2, or 3 columns
this.logger.log(VerboseLevel.INFO, 'TO(' + nrCols + ') - Tab Offset');
this.writeScreen.moveCursor(nrCols);
};
_proto6.ccMIDROW = function ccMIDROW(secondByte) {
// Parse MIDROW command
var styles = {
flash: false
};
styles.underline = secondByte % 2 === 1;
styles.italics = secondByte >= 0x2e;
if (!styles.italics) {
var colorIndex = Math.floor(secondByte / 2) - 0x10;
var colors = ['white', 'green', 'blue', 'cyan', 'red', 'yellow', 'magenta'];
styles.foreground = colors[colorIndex];
} else {
styles.foreground = 'white';
}
this.logger.log(VerboseLevel.INFO, 'MIDROW: ' + JSON.stringify(styles));
this.writeScreen.setPen(styles);
};
_proto6.outputDataUpdate = function outputDataUpdate(dispatch) {
if (dispatch === void 0) {
dispatch = false;
}
var time = this.logger.time;
if (time === null) {
return;
}
if (this.outputFilter) {
if (this.cueStartTime === null && !this.displayedMemory.isEmpty()) {
// Start of a new cue
this.cueStartTime = time;
} else {
if (!this.displayedMemory.equals(this.lastOutputScreen)) {
this.outputFilter.newCue(this.cueStartTime, time, this.lastOutputScreen);
if (dispatch && this.outputFilter.dispatchCue) {
this.outputFilter.dispatchCue();
}
this.cueStartTime = this.displayedMemory.isEmpty() ? null : time;
}
}
this.lastOutputScreen.copy(this.displayedMemory);
}
};
_proto6.cueSplitAtTime = function cueSplitAtTime(t) {
if (this.outputFilter) {
if (!this.displayedMemory.isEmpty()) {
if (this.outputFilter.newCue) {
this.outputFilter.newCue(this.cueStartTime, t, this.displayedMemory);
}
this.cueStartTime = t;
}
}
};
return Cea608Channel;
}();
var Cea608Parser = /*#__PURE__*/function () {
function Cea608Parser(field, out1, out2) {
this.channels = void 0;
this.currentChannel = 0;
this.cmdHistory = void 0;
this.logger = void 0;
var logger = new CaptionsLogger();
this.channels = [null, new Cea608Channel(field, out1, logger), new Cea608Channel(field + 1, out2, logger)];
this.cmdHistory = createCmdHistory();
this.logger = logger;
}
var _proto7 = Cea608Parser.prototype;
_proto7.getHandler = function getHandler(channel) {
return this.channels[channel].getHandler();
};
_proto7.setHandler = function setHandler(channel, newHandler) {
this.channels[channel].setHandler(newHandler);
}
/**
* Add data for time t in forms of list of bytes (unsigned ints). The bytes are treated as pairs.
*/
;
_proto7.addData = function addData(time, byteList) {
var cmdFound;
var a;
var b;
var charsFound = false;
this.logger.time = time;
for (var i = 0; i < byteList.length; i += 2) {
a = byteList[i] & 0x7f;
b = byteList[i + 1] & 0x7f;
if (a === 0 && b === 0) {
continue;
} else {
this.logger.log(VerboseLevel.DATA, '[' + numArrayToHexArray([byteList[i], byteList[i + 1]]) + '] -> (' + numArrayToHexArray([a, b]) + ')');
}
cmdFound = this.parseCmd(a, b);
if (!cmdFound) {
cmdFound = this.parseMidrow(a, b);
}
if (!cmdFound) {
cmdFound = this.parsePAC(a, b);
}
if (!cmdFound) {
cmdFound = this.parseBackgroundAttributes(a, b);
}
if (!cmdFound) {
charsFound = this.parseChars(a, b);
if (charsFound) {
var currChNr = this.currentChannel;
if (currChNr && currChNr > 0) {
var channel = this.channels[currChNr];
channel.insertChars(charsFound);
} else {
this.logger.log(VerboseLevel.WARNING, 'No channel found yet. TEXT-MODE?');
}
}
}
if (!cmdFound && !charsFound) {
this.logger.log(VerboseLevel.WARNING, "Couldn't parse cleaned data " + numArrayToHexArray([a, b]) + ' orig: ' + numArrayToHexArray([byteList[i], byteList[i + 1]]));
}
}
}
/**
* Parse Command.
* @returns {Boolean} Tells if a command was found
*/
;
_proto7.parseCmd = function parseCmd(a, b) {
var cmdHistory = this.cmdHistory;
var cond1 = (a === 0x14 || a === 0x1c || a === 0x15 || a === 0x1d) && b >= 0x20 && b <= 0x2f;
var cond2 = (a === 0x17 || a === 0x1f) && b >= 0x21 && b <= 0x23;
if (!(cond1 || cond2)) {
return false;
}
if (hasCmdRepeated(a, b, cmdHistory)) {
setLastCmd(null, null, cmdHistory);
this.logger.log(VerboseLevel.DEBUG, 'Repeated command (' + numArrayToHexArray([a, b]) + ') is dropped');
return true;
}
var chNr = a === 0x14 || a === 0x15 || a === 0x17 ? 1 : 2;
var channel = this.channels[chNr];
if (a === 0x14 || a === 0x15 || a === 0x1c || a === 0x1d) {
if (b === 0x20) {
channel.ccRCL();
} else if (b === 0x21) {
channel.ccBS();
} else if (b === 0x22) {
channel.ccAOF();
} else if (b === 0x23) {
channel.ccAON();
} else if (b === 0x24) {
channel.ccDER();
} else if (b === 0x25) {
channel.ccRU(2);
} else if (b === 0x26) {
channel.ccRU(3);
} else if (b === 0x27) {
channel.ccRU(4);
} else if (b === 0x28) {
channel.ccFON();
} else if (b === 0x29) {
channel.ccRDC();
} else if (b === 0x2a) {
channel.ccTR();
} else if (b === 0x2b) {
channel.ccRTD();
} else if (b === 0x2c) {
channel.ccEDM();
} else if (b === 0x2d) {
channel.ccCR();
} else if (b === 0x2e) {
channel.ccENM();
} else if (b === 0x2f) {
channel.ccEOC();
}
} else {
// a == 0x17 || a == 0x1F
channel.ccTO(b - 0x20);
}
setLastCmd(a, b, cmdHistory);
this.currentChannel = chNr;
return true;
}
/**
* Parse midrow styling command
* @returns {Boolean}
*/
;
_proto7.parseMidrow = function parseMidrow(a, b) {
var chNr = 0;
if ((a === 0x11 || a === 0x19) && b >= 0x20 && b <= 0x2f) {
if (a === 0x11) {
chNr = 1;
} else {
chNr = 2;
}
if (chNr !== this.currentChannel) {
this.logger.log(VerboseLevel.ERROR, 'Mismatch channel in midrow parsing');
return false;
}
var channel = this.channels[chNr];
if (!channel) {
return false;
}
channel.ccMIDROW(b);
this.logger.log(VerboseLevel.DEBUG, 'MIDROW (' + numArrayToHexArray([a, b]) + ')');
return true;
}
return false;
}
/**
* Parse Preable Access Codes (Table 53).
* @returns {Boolean} Tells if PAC found
*/
;
_proto7.parsePAC = function parsePAC(a, b) {
var row;
var cmdHistory = this.cmdHistory;
var case1 = (a >= 0x11 && a <= 0x17 || a >= 0x19 && a <= 0x1f) && b >= 0x40 && b <= 0x7f;
var case2 = (a === 0x10 || a === 0x18) && b >= 0x40 && b <= 0x5f;
if (!(case1 || case2)) {
return false;
}
if (hasCmdRepeated(a, b, cmdHistory)) {
setLastCmd(null, null, cmdHistory);
return true; // Repeated commands are dropped (once)
}
var chNr = a <= 0x17 ? 1 : 2;
if (b >= 0x40 && b <= 0x5f) {
row = chNr === 1 ? rowsLowCh1[a] : rowsLowCh2[a];
} else {
// 0x60 <= b <= 0x7F
row = chNr === 1 ? rowsHighCh1[a] : rowsHighCh2[a];
}
var channel = this.channels[chNr];
if (!channel) {
return false;
}
channel.setPAC(this.interpretPAC(row, b));
setLastCmd(a, b, cmdHistory);
this.currentChannel = chNr;
return true;
}
/**
* Interpret the second byte of the pac, and return the information.
* @returns {Object} pacData with style parameters.
*/
;
_proto7.interpretPAC = function interpretPAC(row, _byte3) {
var pacIndex;
var pacData = {
color: null,
italics: false,
indent: null,
underline: false,
row: row
};
if (_byte3 > 0x5f) {
pacIndex = _byte3 - 0x60;
} else {
pacIndex = _byte3 - 0x40;
}
pacData.underline = (pacIndex & 1) === 1;
if (pacIndex <= 0xd) {
pacData.color = ['white', 'green', 'blue', 'cyan', 'red', 'yellow', 'magenta', 'white'][Math.floor(pacIndex / 2)];
} else if (pacIndex <= 0xf) {
pacData.italics = true;
pacData.color = 'white';
} else {
pacData.indent = Math.floor((pacIndex - 0x10) / 2) * 4;
}
return pacData; // Note that row has zero offset. The spec uses 1.
}
/**
* Parse characters.
* @returns An array with 1 to 2 codes corresponding to chars, if found. null otherwise.
*/
;
_proto7.parseChars = function parseChars(a, b) {
var channelNr;
var charCodes = null;
var charCode1 = null;
if (a >= 0x19) {
channelNr = 2;
charCode1 = a - 8;
} else {
channelNr = 1;
charCode1 = a;
}
if (charCode1 >= 0x11 && charCode1 <= 0x13) {
// Special character
var oneCode;
if (charCode1 === 0x11) {
oneCode = b + 0x50;
} else if (charCode1 === 0x12) {
oneCode = b + 0x70;
} else {
oneCode = b + 0x90;
}
this.logger.log(VerboseLevel.INFO, "Special char '" + getCharForByte(oneCode) + "' in channel " + channelNr);
charCodes = [oneCode];
} else if (a >= 0x20 && a <= 0x7f) {
charCodes = b === 0 ? [a] : [a, b];
}
if (charCodes) {
var hexCodes = numArrayToHexArray(charCodes);
this.logger.log(VerboseLevel.DEBUG, 'Char codes = ' + hexCodes.join(','));
setLastCmd(a, b, this.cmdHistory);
}
return charCodes;
}
/**
* Parse extended background attributes as well as new foreground color black.
* @returns {Boolean} Tells if background attributes are found
*/
;
_proto7.parseBackgroundAttributes = function parseBackgroundAttributes(a, b) {
var case1 = (a === 0x10 || a === 0x18) && b >= 0x20 && b <= 0x2f;
var case2 = (a === 0x17 || a === 0x1f) && b >= 0x2d && b <= 0x2f;
if (!(case1 || case2)) {
return false;
}
var index;
var bkgData = {};
if (a === 0x10 || a === 0x18) {
index = Math.floor((b - 0x20) / 2);
bkgData.background = backgroundColors[index];
if (b % 2 === 1) {
bkgData.background = bkgData.background + '_semi';
}
} else if (b === 0x2d) {
bkgData.background = 'transparent';
} else {
bkgData.foreground = 'black';
if (b === 0x2f) {
bkgData.underline = true;
}
}
var chNr = a <= 0x17 ? 1 : 2;
var channel = this.channels[chNr];
channel.setBkgData(bkgData);
setLastCmd(a, b, this.cmdHistory);
return true;
}
/**
* Reset state of parser and its channels.
*/
;
_proto7.reset = function reset() {
for (var i = 0; i < Object.keys(this.channels).length; i++) {
var channel = this.channels[i];
if (channel) {
channel.reset();
}
}
this.cmdHistory = createCmdHistory();
}
/**
* Trigger the generation of a cue, and the start of a new one if displayScreens are not empty.
*/
;
_proto7.cueSplitAtTime = function cueSplitAtTime(t) {
for (var i = 0; i < this.channels.length; i++) {
var channel = this.channels[i];
if (channel) {
channel.cueSplitAtTime(t);
}
}
};
return Cea608Parser;
}();
function setLastCmd(a, b, cmdHistory) {
cmdHistory.a = a;
cmdHistory.b = b;
}
function hasCmdRepeated(a, b, cmdHistory) {
return cmdHistory.a === a && cmdHistory.b === b;
}
function createCmdHistory() {
return {
a: null,
b: null
};
}
/* harmony default export */ __webpack_exports__["default"] = (Cea608Parser);
/***/ }),
/***/ "./src/utils/codecs.ts":
/*!*****************************!*\
!*** ./src/utils/codecs.ts ***!
\*****************************/
/*! exports provided: isCodecType, isCodecSupportedInMp4 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isCodecType", function() { return isCodecType; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isCodecSupportedInMp4", function() { return isCodecSupportedInMp4; });
// from http://mp4ra.org/codecs.html
var sampleEntryCodesISO = {
audio: {
a3ds: true,
'ac-3': true,
'ac-4': true,
alac: true,
alaw: true,
dra1: true,
'dts+': true,
'dts-': true,
dtsc: true,
dtse: true,
dtsh: true,
'ec-3': true,
enca: true,
g719: true,
g726: true,
m4ae: true,
mha1: true,
mha2: true,
mhm1: true,
mhm2: true,
mlpa: true,
mp4a: true,
'raw ': true,
Opus: true,
samr: true,
sawb: true,
sawp: true,
sevc: true,
sqcp: true,
ssmv: true,
twos: true,
ulaw: true
},
video: {
avc1: true,
avc2: true,
avc3: true,
avc4: true,
avcp: true,
av01: true,
drac: true,
dvav: true,
dvhe: true,
encv: true,
hev1: true,
hvc1: true,
mjp2: true,
mp4v: true,
mvc1: true,
mvc2: true,
mvc3: true,
mvc4: true,
resv: true,
rv60: true,
s263: true,
svc1: true,
svc2: true,
'vc-1': true,
vp08: true,
vp09: true
},
text: {
stpp: true,
wvtt: true
}
};
function isCodecType(codec, type) {
var typeCodes = sampleEntryCodesISO[type];
return !!typeCodes && typeCodes[codec.slice(0, 4)] === true;
}
function isCodecSupportedInMp4(codec, type) {
return MediaSource.isTypeSupported((type || 'video') + "/mp4;codecs=\"" + codec + "\"");
}
/***/ }),
/***/ "./src/utils/cues.ts":
/*!***************************!*\
!*** ./src/utils/cues.ts ***!
\***************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _vttparser__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./vttparser */ "./src/utils/vttparser.ts");
/* harmony import */ var _webvtt_parser__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./webvtt-parser */ "./src/utils/webvtt-parser.ts");
/* harmony import */ var _texttrack_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./texttrack-utils */ "./src/utils/texttrack-utils.ts");
var WHITESPACE_CHAR = /\s/;
var Cues = {
newCue: function newCue(track, startTime, endTime, captionScreen) {
var result = [];
var row; // the type data states this is VTTCue, but it can potentially be a TextTrackCue on old browsers
var cue;
var indenting;
var indent;
var text;
var Cue = self.VTTCue || self.TextTrackCue;
for (var r = 0; r < captionScreen.rows.length; r++) {
row = captionScreen.rows[r];
indenting = true;
indent = 0;
text = '';
if (!row.isEmpty()) {
for (var c = 0; c < row.chars.length; c++) {
if (WHITESPACE_CHAR.test(row.chars[c].uchar) && indenting) {
indent++;
} else {
text += row.chars[c].uchar;
indenting = false;
}
} // To be used for cleaning-up orphaned roll-up captions
row.cueStartTime = startTime; // Give a slight bump to the endTime if it's equal to startTime to avoid a SyntaxError in IE
if (startTime === endTime) {
endTime += 0.0001;
}
if (indent >= 16) {
indent--;
} else {
indent++;
}
var cueText = Object(_vttparser__WEBPACK_IMPORTED_MODULE_0__["fixLineBreaks"])(text.trim());
var id = Object(_webvtt_parser__WEBPACK_IMPORTED_MODULE_1__["generateCueId"])(startTime, endTime, cueText); // If this cue already exists in the track do not push it
if (!track || !track.cues || !track.cues.getCueById(id)) {
cue = new Cue(startTime, endTime, cueText);
cue.id = id;
cue.line = r + 1;
cue.align = 'left'; // Clamp the position between 10 and 80 percent (CEA-608 PAC indent code)
// https://dvcs.w3.org/hg/text-tracks/raw-file/default/608toVTT/608toVTT.html#positioning-in-cea-608
// Firefox throws an exception and captions break with out of bounds 0-100 values
cue.position = 10 + Math.min(80, Math.floor(indent * 8 / 32) * 10);
result.push(cue);
}
}
}
if (track && result.length) {
// Sort bottom cues in reverse order so that they render in line order when overlapping in Chrome
result.sort(function (cueA, cueB) {
if (cueA.line === 'auto' || cueB.line === 'auto') {
return 0;
}
if (cueA.line > 8 && cueB.line > 8) {
return cueB.line - cueA.line;
}
return cueA.line - cueB.line;
});
result.forEach(function (cue) {
return Object(_texttrack_utils__WEBPACK_IMPORTED_MODULE_2__["addCueToTrack"])(track, cue);
});
}
return result;
}
};
/* harmony default export */ __webpack_exports__["default"] = (Cues);
/***/ }),
/***/ "./src/utils/discontinuities.ts":
/*!**************************************!*\
!*** ./src/utils/discontinuities.ts ***!
\**************************************/
/*! exports provided: findFirstFragWithCC, shouldAlignOnDiscontinuities, findDiscontinuousReferenceFrag, adjustSlidingStart, alignStream, alignPDT, alignFragmentByPDTDelta, alignMediaPlaylistByPDT */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findFirstFragWithCC", function() { return findFirstFragWithCC; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "shouldAlignOnDiscontinuities", function() { return shouldAlignOnDiscontinuities; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findDiscontinuousReferenceFrag", function() { return findDiscontinuousReferenceFrag; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "adjustSlidingStart", function() { return adjustSlidingStart; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "alignStream", function() { return alignStream; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "alignPDT", function() { return alignPDT; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "alignFragmentByPDTDelta", function() { return alignFragmentByPDTDelta; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "alignMediaPlaylistByPDT", function() { return alignMediaPlaylistByPDT; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _logger__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./logger */ "./src/utils/logger.ts");
/* harmony import */ var _controller_level_helper__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../controller/level-helper */ "./src/controller/level-helper.ts");
function findFirstFragWithCC(fragments, cc) {
var firstFrag = null;
for (var i = 0, len = fragments.length; i < len; i++) {
var currentFrag = fragments[i];
if (currentFrag && currentFrag.cc === cc) {
firstFrag = currentFrag;
break;
}
}
return firstFrag;
}
function shouldAlignOnDiscontinuities(lastFrag, lastLevel, details) {
if (lastLevel.details) {
if (details.endCC > details.startCC || lastFrag && lastFrag.cc < details.startCC) {
return true;
}
}
return false;
} // Find the first frag in the previous level which matches the CC of the first frag of the new level
function findDiscontinuousReferenceFrag(prevDetails, curDetails) {
var prevFrags = prevDetails.fragments;
var curFrags = curDetails.fragments;
if (!curFrags.length || !prevFrags.length) {
_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].log('No fragments to align');
return;
}
var prevStartFrag = findFirstFragWithCC(prevFrags, curFrags[0].cc);
if (!prevStartFrag || prevStartFrag && !prevStartFrag.startPTS) {
_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].log('No frag in previous level to align on');
return;
}
return prevStartFrag;
}
function adjustFragmentStart(frag, sliding) {
if (frag) {
var start = frag.start + sliding;
frag.start = frag.startPTS = start;
frag.endPTS = start + frag.duration;
}
}
function adjustSlidingStart(sliding, details) {
// Update segments
var fragments = details.fragments;
for (var i = 0, len = fragments.length; i < len; i++) {
adjustFragmentStart(fragments[i], sliding);
} // Update LL-HLS parts at the end of the playlist
if (details.fragmentHint) {
adjustFragmentStart(details.fragmentHint, sliding);
}
details.alignedSliding = true;
}
/**
* Using the parameters of the last level, this function computes PTS' of the new fragments so that they form a
* contiguous stream with the last fragments.
* The PTS of a fragment lets Hls.js know where it fits into a stream - by knowing every PTS, we know which fragment to
* download at any given time. PTS is normally computed when the fragment is demuxed, so taking this step saves us time
* and an extra download.
* @param lastFrag
* @param lastLevel
* @param details
*/
function alignStream(lastFrag, lastLevel, details) {
if (!lastLevel) {
return;
}
alignDiscontinuities(lastFrag, details, lastLevel);
if (!details.alignedSliding && lastLevel.details) {
// If the PTS wasn't figured out via discontinuity sequence that means there was no CC increase within the level.
// Aligning via Program Date Time should therefore be reliable, since PDT should be the same within the same
// discontinuity sequence.
alignPDT(details, lastLevel.details);
}
if (!details.alignedSliding && lastLevel.details && !details.skippedSegments) {
// Try to align on sn so that we pick a better start fragment.
// Do not perform this on playlists with delta updates as this is only to align levels on switch
// and adjustSliding only adjusts fragments after skippedSegments.
Object(_controller_level_helper__WEBPACK_IMPORTED_MODULE_2__["adjustSliding"])(lastLevel.details, details);
}
}
/**
* Computes the PTS if a new level's fragments using the PTS of a fragment in the last level which shares the same
* discontinuity sequence.
* @param lastFrag - The last Fragment which shares the same discontinuity sequence
* @param lastLevel - The details of the last loaded level
* @param details - The details of the new level
*/
function alignDiscontinuities(lastFrag, details, lastLevel) {
if (shouldAlignOnDiscontinuities(lastFrag, lastLevel, details)) {
var referenceFrag = findDiscontinuousReferenceFrag(lastLevel.details, details);
if (referenceFrag && Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(referenceFrag.start)) {
_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].log("Adjusting PTS using last level due to CC increase within current level " + details.url);
adjustSlidingStart(referenceFrag.start, details);
}
}
}
/**
* Computes the PTS of a new level's fragments using the difference in Program Date Time from the last level.
* @param details - The details of the new level
* @param lastDetails - The details of the last loaded level
*/
function alignPDT(details, lastDetails) {
// This check protects the unsafe "!" usage below for null program date time access.
if (!lastDetails.fragments.length || !details.hasProgramDateTime || !lastDetails.hasProgramDateTime) {
return;
} // if last level sliding is 1000 and its first frag PROGRAM-DATE-TIME is 2017-08-20 1:10:00 AM
// and if new details first frag PROGRAM DATE-TIME is 2017-08-20 1:10:08 AM
// then we can deduce that playlist B sliding is 1000+8 = 1008s
var lastPDT = lastDetails.fragments[0].programDateTime; // hasProgramDateTime check above makes this safe.
var newPDT = details.fragments[0].programDateTime; // date diff is in ms. frag.start is in seconds
var sliding = (newPDT - lastPDT) / 1000 + lastDetails.fragments[0].start;
if (sliding && Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(sliding)) {
_logger__WEBPACK_IMPORTED_MODULE_1__["logger"].log("Adjusting PTS using programDateTime delta " + (newPDT - lastPDT) + "ms, sliding:" + sliding.toFixed(3) + " " + details.url + " ");
adjustSlidingStart(sliding, details);
}
}
function alignFragmentByPDTDelta(frag, delta) {
var programDateTime = frag.programDateTime;
if (!programDateTime) return;
var start = (programDateTime - delta) / 1000;
frag.start = frag.startPTS = start;
frag.endPTS = start + frag.duration;
}
/**
* Ensures appropriate time-alignment between renditions based on PDT. Unlike `alignPDT`, which adjusts
* the timeline based on the delta between PDTs of the 0th fragment of two playlists/`LevelDetails`,
* this function assumes the timelines represented in `refDetails` are accurate, including the PDTs,
* and uses the "wallclock"/PDT timeline as a cross-reference to `details`, adjusting the presentation
* times/timelines of `details` accordingly.
* Given the asynchronous nature of fetches and initial loads of live `main` and audio/subtitle tracks,
* the primary purpose of this function is to ensure the "local timelines" of audio/subtitle tracks
* are aligned to the main/video timeline, using PDT as the cross-reference/"anchor" that should
* be consistent across playlists, per the HLS spec.
* @param details - The details of the rendition you'd like to time-align (e.g. an audio rendition).
* @param refDetails - The details of the reference rendition with start and PDT times for alignment.
*/
function alignMediaPlaylistByPDT(details, refDetails) {
// This check protects the unsafe "!" usage below for null program date time access.
if (!refDetails.fragments.length || !details.hasProgramDateTime || !refDetails.hasProgramDateTime) {
return;
}
var refPDT = refDetails.fragments[0].programDateTime; // hasProgramDateTime check above makes this safe.
var refStart = refDetails.fragments[0].start; // Use the delta between the reference details' presentation timeline's start time and its PDT
// to align the other rendtion's timeline.
var delta = refPDT - refStart * 1000; // Per spec: "If any Media Playlist in a Master Playlist contains an EXT-X-PROGRAM-DATE-TIME tag, then all
// Media Playlists in that Master Playlist MUST contain EXT-X-PROGRAM-DATE-TIME tags with consistent mappings
// of date and time to media timestamps."
// So we should be able to use each rendition's PDT as a reference time and use the delta to compute our relevant
// start and end times.
// NOTE: This code assumes each level/details timelines have already been made "internally consistent"
details.fragments.forEach(function (frag) {
alignFragmentByPDTDelta(frag, delta);
});
if (details.fragmentHint) {
alignFragmentByPDTDelta(details.fragmentHint, delta);
}
details.alignedSliding = true;
}
/***/ }),
/***/ "./src/utils/ewma-bandwidth-estimator.ts":
/*!***********************************************!*\
!*** ./src/utils/ewma-bandwidth-estimator.ts ***!
\***********************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _utils_ewma__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/ewma */ "./src/utils/ewma.ts");
/*
* EWMA Bandwidth Estimator
* - heavily inspired from shaka-player
* Tracks bandwidth samples and estimates available bandwidth.
* Based on the minimum of two exponentially-weighted moving averages with
* different half-lives.
*/
var EwmaBandWidthEstimator = /*#__PURE__*/function () {
function EwmaBandWidthEstimator(slow, fast, defaultEstimate) {
this.defaultEstimate_ = void 0;
this.minWeight_ = void 0;
this.minDelayMs_ = void 0;
this.slow_ = void 0;
this.fast_ = void 0;
this.defaultEstimate_ = defaultEstimate;
this.minWeight_ = 0.001;
this.minDelayMs_ = 50;
this.slow_ = new _utils_ewma__WEBPACK_IMPORTED_MODULE_0__["default"](slow);
this.fast_ = new _utils_ewma__WEBPACK_IMPORTED_MODULE_0__["default"](fast);
}
var _proto = EwmaBandWidthEstimator.prototype;
_proto.update = function update(slow, fast) {
var slow_ = this.slow_,
fast_ = this.fast_;
if (this.slow_.halfLife !== slow) {
this.slow_ = new _utils_ewma__WEBPACK_IMPORTED_MODULE_0__["default"](slow, slow_.getEstimate(), slow_.getTotalWeight());
}
if (this.fast_.halfLife !== fast) {
this.fast_ = new _utils_ewma__WEBPACK_IMPORTED_MODULE_0__["default"](fast, fast_.getEstimate(), fast_.getTotalWeight());
}
};
_proto.sample = function sample(durationMs, numBytes) {
durationMs = Math.max(durationMs, this.minDelayMs_);
var numBits = 8 * numBytes; // weight is duration in seconds
var durationS = durationMs / 1000; // value is bandwidth in bits/s
var bandwidthInBps = numBits / durationS;
this.fast_.sample(durationS, bandwidthInBps);
this.slow_.sample(durationS, bandwidthInBps);
};
_proto.canEstimate = function canEstimate() {
var fast = this.fast_;
return fast && fast.getTotalWeight() >= this.minWeight_;
};
_proto.getEstimate = function getEstimate() {
if (this.canEstimate()) {
// console.log('slow estimate:'+ Math.round(this.slow_.getEstimate()));
// console.log('fast estimate:'+ Math.round(this.fast_.getEstimate()));
// Take the minimum of these two estimates. This should have the effect of
// adapting down quickly, but up more slowly.
return Math.min(this.fast_.getEstimate(), this.slow_.getEstimate());
} else {
return this.defaultEstimate_;
}
};
_proto.destroy = function destroy() {};
return EwmaBandWidthEstimator;
}();
/* harmony default export */ __webpack_exports__["default"] = (EwmaBandWidthEstimator);
/***/ }),
/***/ "./src/utils/ewma.ts":
/*!***************************!*\
!*** ./src/utils/ewma.ts ***!
\***************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/*
* compute an Exponential Weighted moving average
* - https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
* - heavily inspired from shaka-player
*/
var EWMA = /*#__PURE__*/function () {
// About half of the estimated value will be from the last |halfLife| samples by weight.
function EWMA(halfLife, estimate, weight) {
if (estimate === void 0) {
estimate = 0;
}
if (weight === void 0) {
weight = 0;
}
this.halfLife = void 0;
this.alpha_ = void 0;
this.estimate_ = void 0;
this.totalWeight_ = void 0;
this.halfLife = halfLife; // Larger values of alpha expire historical data more slowly.
this.alpha_ = halfLife ? Math.exp(Math.log(0.5) / halfLife) : 0;
this.estimate_ = estimate;
this.totalWeight_ = weight;
}
var _proto = EWMA.prototype;
_proto.sample = function sample(weight, value) {
var adjAlpha = Math.pow(this.alpha_, weight);
this.estimate_ = value * (1 - adjAlpha) + adjAlpha * this.estimate_;
this.totalWeight_ += weight;
};
_proto.getTotalWeight = function getTotalWeight() {
return this.totalWeight_;
};
_proto.getEstimate = function getEstimate() {
if (this.alpha_) {
var zeroFactor = 1 - Math.pow(this.alpha_, this.totalWeight_);
if (zeroFactor) {
return this.estimate_ / zeroFactor;
}
}
return this.estimate_;
};
return EWMA;
}();
/* harmony default export */ __webpack_exports__["default"] = (EWMA);
/***/ }),
/***/ "./src/utils/fetch-loader.ts":
/*!***********************************!*\
!*** ./src/utils/fetch-loader.ts ***!
\***********************************/
/*! exports provided: fetchSupported, default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fetchSupported", function() { return fetchSupported; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _loader_load_stats__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../loader/load-stats */ "./src/loader/load-stats.ts");
/* harmony import */ var _demux_chunk_cache__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../demux/chunk-cache */ "./src/demux/chunk-cache.ts");
function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; _setPrototypeOf(subClass, superClass); }
function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function fetchSupported() {
if ( // @ts-ignore
self.fetch && self.AbortController && self.ReadableStream && self.Request) {
try {
new self.ReadableStream({}); // eslint-disable-line no-new
return true;
} catch (e) {
/* noop */
}
}
return false;
}
var FetchLoader = /*#__PURE__*/function () {
function FetchLoader(config
/* HlsConfig */
) {
this.fetchSetup = void 0;
this.requestTimeout = void 0;
this.request = void 0;
this.response = void 0;
this.controller = void 0;
this.context = void 0;
this.config = null;
this.callbacks = null;
this.stats = void 0;
this.loader = null;
this.fetchSetup = config.fetchSetup || getRequest;
this.controller = new self.AbortController();
this.stats = new _loader_load_stats__WEBPACK_IMPORTED_MODULE_1__["LoadStats"]();
}
var _proto = FetchLoader.prototype;
_proto.destroy = function destroy() {
this.loader = this.callbacks = null;
this.abortInternal();
};
_proto.abortInternal = function abortInternal() {
var response = this.response;
if (!response || !response.ok) {
this.stats.aborted = true;
this.controller.abort();
}
};
_proto.abort = function abort() {
var _this$callbacks;
this.abortInternal();
if ((_this$callbacks = this.callbacks) !== null && _this$callbacks !== void 0 && _this$callbacks.onAbort) {
this.callbacks.onAbort(this.stats, this.context, this.response);
}
};
_proto.load = function load(context, config, callbacks) {
var _this = this;
var stats = this.stats;
if (stats.loading.start) {
throw new Error('Loader can only be used once.');
}
stats.loading.start = self.performance.now();
var initParams = getRequestParameters(context, this.controller.signal);
var onProgress = callbacks.onProgress;
var isArrayBuffer = context.responseType === 'arraybuffer';
var LENGTH = isArrayBuffer ? 'byteLength' : 'length';
this.context = context;
this.config = config;
this.callbacks = callbacks;
this.request = this.fetchSetup(context, initParams);
self.clearTimeout(this.requestTimeout);
this.requestTimeout = self.setTimeout(function () {
_this.abortInternal();
callbacks.onTimeout(stats, context, _this.response);
}, config.timeout);
self.fetch(this.request).then(function (response) {
_this.response = _this.loader = response;
if (!response.ok) {
var status = response.status,
statusText = response.statusText;
throw new FetchError(statusText || 'fetch, bad network response', status, response);
}
stats.loading.first = Math.max(self.performance.now(), stats.loading.start);
stats.total = parseInt(response.headers.get('Content-Length') || '0');
if (onProgress && Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(config.highWaterMark)) {
return _this.loadProgressively(response, stats, context, config.highWaterMark, onProgress);
}
if (isArrayBuffer) {
return response.arrayBuffer();
}
return response.text();
}).then(function (responseData) {
var response = _this.response;
self.clearTimeout(_this.requestTimeout);
stats.loading.end = Math.max(self.performance.now(), stats.loading.first);
stats.loaded = stats.total = responseData[LENGTH];
var loaderResponse = {
url: response.url,
data: responseData
};
if (onProgress && !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(config.highWaterMark)) {
onProgress(stats, context, responseData, response);
}
callbacks.onSuccess(loaderResponse, stats, context, response);
}).catch(function (error) {
self.clearTimeout(_this.requestTimeout);
if (stats.aborted) {
return;
} // CORS errors result in an undefined code. Set it to 0 here to align with XHR's behavior
var code = error.code || 0;
callbacks.onError({
code: code,
text: error.message
}, context, error.details);
});
};
_proto.getCacheAge = function getCacheAge() {
var result = null;
if (this.response) {
var ageHeader = this.response.headers.get('age');
result = ageHeader ? parseFloat(ageHeader) : null;
}
return result;
};
_proto.loadProgressively = function loadProgressively(response, stats, context, highWaterMark, onProgress) {
if (highWaterMark === void 0) {
highWaterMark = 0;
}
var chunkCache = new _demux_chunk_cache__WEBPACK_IMPORTED_MODULE_2__["default"]();
var reader = response.body.getReader();
var pump = function pump() {
return reader.read().then(function (data) {
if (data.done) {
if (chunkCache.dataLength) {
onProgress(stats, context, chunkCache.flush(), response);
}
return Promise.resolve(new ArrayBuffer(0));
}
var chunk = data.value;
var len = chunk.length;
stats.loaded += len;
if (len < highWaterMark || chunkCache.dataLength) {
// The current chunk is too small to to be emitted or the cache already has data
// Push it to the cache
chunkCache.push(chunk);
if (chunkCache.dataLength >= highWaterMark) {
// flush in order to join the typed arrays
onProgress(stats, context, chunkCache.flush(), response);
}
} else {
// If there's nothing cached already, and the chache is large enough
// just emit the progress event
onProgress(stats, context, chunk, response);
}
return pump();
}).catch(function () {
/* aborted */
return Promise.reject();
});
};
return pump();
};
return FetchLoader;
}();
function getRequestParameters(context, signal) {
var initParams = {
method: 'GET',
mode: 'cors',
credentials: 'same-origin',
signal: signal
};
if (context.rangeEnd) {
initParams.headers = new self.Headers({
Range: 'bytes=' + context.rangeStart + '-' + String(context.rangeEnd - 1)
});
}
return initParams;
}
function getRequest(context, initParams) {
return new self.Request(context.url, initParams);
}
var FetchError = /*#__PURE__*/function (_Error) {
_inheritsLoose(FetchError, _Error);
function FetchError(message, code, details) {
var _this2;
_this2 = _Error.call(this, message) || this;
_this2.code = void 0;
_this2.details = void 0;
_this2.code = code;
_this2.details = details;
return _this2;
}
return FetchError;
}( /*#__PURE__*/_wrapNativeSuper(Error));
/* harmony default export */ __webpack_exports__["default"] = (FetchLoader);
/***/ }),
/***/ "./src/utils/imsc1-ttml-parser.ts":
/*!****************************************!*\
!*** ./src/utils/imsc1-ttml-parser.ts ***!
\****************************************/
/*! exports provided: IMSC1_CODEC, parseIMSC1 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "IMSC1_CODEC", function() { return IMSC1_CODEC; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseIMSC1", function() { return parseIMSC1; });
/* harmony import */ var _mp4_tools__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./mp4-tools */ "./src/utils/mp4-tools.ts");
/* harmony import */ var _vttparser__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./vttparser */ "./src/utils/vttparser.ts");
/* harmony import */ var _vttcue__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./vttcue */ "./src/utils/vttcue.ts");
/* harmony import */ var _demux_id3__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../demux/id3 */ "./src/demux/id3.ts");
/* harmony import */ var _timescale_conversion__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./timescale-conversion */ "./src/utils/timescale-conversion.ts");
/* harmony import */ var _webvtt_parser__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./webvtt-parser */ "./src/utils/webvtt-parser.ts");
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
var IMSC1_CODEC = 'stpp.ttml.im1t'; // Time format: h:m:s:frames(.subframes)
var HMSF_REGEX = /^(\d{2,}):(\d{2}):(\d{2}):(\d{2})\.?(\d+)?$/; // Time format: hours, minutes, seconds, milliseconds, frames, ticks
var TIME_UNIT_REGEX = /^(\d*(?:\.\d*)?)(h|m|s|ms|f|t)$/;
var textAlignToLineAlign = {
left: 'start',
center: 'center',
right: 'end',
start: 'start',
end: 'end'
};
function parseIMSC1(payload, initPTS, timescale, callBack, errorCallBack) {
var results = Object(_mp4_tools__WEBPACK_IMPORTED_MODULE_0__["findBox"])(new Uint8Array(payload), ['mdat']);
if (results.length === 0) {
errorCallBack(new Error('Could not parse IMSC1 mdat'));
return;
}
var mdat = results[0];
var ttml = Object(_demux_id3__WEBPACK_IMPORTED_MODULE_3__["utf8ArrayToStr"])(new Uint8Array(payload, mdat.start, mdat.end - mdat.start));
var syncTime = Object(_timescale_conversion__WEBPACK_IMPORTED_MODULE_4__["toTimescaleFromScale"])(initPTS, 1, timescale);
try {
callBack(parseTTML(ttml, syncTime));
} catch (error) {
errorCallBack(error);
}
}
function parseTTML(ttml, syncTime) {
var parser = new DOMParser();
var xmlDoc = parser.parseFromString(ttml, 'text/xml');
var tt = xmlDoc.getElementsByTagName('tt')[0];
if (!tt) {
throw new Error('Invalid ttml');
}
var defaultRateInfo = {
frameRate: 30,
subFrameRate: 1,
frameRateMultiplier: 0,
tickRate: 0
};
var rateInfo = Object.keys(defaultRateInfo).reduce(function (result, key) {
result[key] = tt.getAttribute("ttp:" + key) || defaultRateInfo[key];
return result;
}, {});
var trim = tt.getAttribute('xml:space') !== 'preserve';
var styleElements = collectionToDictionary(getElementCollection(tt, 'styling', 'style'));
var regionElements = collectionToDictionary(getElementCollection(tt, 'layout', 'region'));
var cueElements = getElementCollection(tt, 'body', '[begin]');
return [].map.call(cueElements, function (cueElement) {
var cueText = getTextContent(cueElement, trim);
if (!cueText || !cueElement.hasAttribute('begin')) {
return null;
}
var startTime = parseTtmlTime(cueElement.getAttribute('begin'), rateInfo);
var duration = parseTtmlTime(cueElement.getAttribute('dur'), rateInfo);
var endTime = parseTtmlTime(cueElement.getAttribute('end'), rateInfo);
if (startTime === null) {
throw timestampParsingError(cueElement);
}
if (endTime === null) {
if (duration === null) {
throw timestampParsingError(cueElement);
}
endTime = startTime + duration;
}
var cue = new _vttcue__WEBPACK_IMPORTED_MODULE_2__["default"](startTime - syncTime, endTime - syncTime, cueText);
cue.id = Object(_webvtt_parser__WEBPACK_IMPORTED_MODULE_5__["generateCueId"])(cue.startTime, cue.endTime, cue.text);
var region = regionElements[cueElement.getAttribute('region')];
var style = styleElements[cueElement.getAttribute('style')]; // TODO: Add regions to track and cue (origin and extend)
// These values are hard-coded (for now) to simulate region settings in the demo
cue.position = 10;
cue.size = 80; // Apply styles to cue
var styles = getTtmlStyles(region, style);
var textAlign = styles.textAlign;
if (textAlign) {
// cue.positionAlign not settable in FF~2016
var lineAlign = textAlignToLineAlign[textAlign];
if (lineAlign) {
cue.lineAlign = lineAlign;
}
cue.align = textAlign;
}
_extends(cue, styles);
return cue;
}).filter(function (cue) {
return cue !== null;
});
}
function getElementCollection(fromElement, parentName, childName) {
var parent = fromElement.getElementsByTagName(parentName)[0];
if (parent) {
return [].slice.call(parent.querySelectorAll(childName));
}
return [];
}
function collectionToDictionary(elementsWithId) {
return elementsWithId.reduce(function (dict, element) {
var id = element.getAttribute('xml:id');
if (id) {
dict[id] = element;
}
return dict;
}, {});
}
function getTextContent(element, trim) {
return [].slice.call(element.childNodes).reduce(function (str, node, i) {
var _node$childNodes;
if (node.nodeName === 'br' && i) {
return str + '\n';
}
if ((_node$childNodes = node.childNodes) !== null && _node$childNodes !== void 0 && _node$childNodes.length) {
return getTextContent(node, trim);
} else if (trim) {
return str + node.textContent.trim().replace(/\s+/g, ' ');
}
return str + node.textContent;
}, '');
}
function getTtmlStyles(region, style) {
var ttsNs = 'http://www.w3.org/ns/ttml#styling';
var styleAttributes = ['displayAlign', 'textAlign', 'color', 'backgroundColor', 'fontSize', 'fontFamily' // 'fontWeight',
// 'lineHeight',
// 'wrapOption',
// 'fontStyle',
// 'direction',
// 'writingMode'
];
return styleAttributes.reduce(function (styles, name) {
var value = getAttributeNS(style, ttsNs, name) || getAttributeNS(region, ttsNs, name);
if (value) {
styles[name] = value;
}
return styles;
}, {});
}
function getAttributeNS(element, ns, name) {
return element.hasAttributeNS(ns, name) ? element.getAttributeNS(ns, name) : null;
}
function timestampParsingError(node) {
return new Error("Could not parse ttml timestamp " + node);
}
function parseTtmlTime(timeAttributeValue, rateInfo) {
if (!timeAttributeValue) {
return null;
}
var seconds = Object(_vttparser__WEBPACK_IMPORTED_MODULE_1__["parseTimeStamp"])(timeAttributeValue);
if (seconds === null) {
if (HMSF_REGEX.test(timeAttributeValue)) {
seconds = parseHoursMinutesSecondsFrames(timeAttributeValue, rateInfo);
} else if (TIME_UNIT_REGEX.test(timeAttributeValue)) {
seconds = parseTimeUnits(timeAttributeValue, rateInfo);
}
}
return seconds;
}
function parseHoursMinutesSecondsFrames(timeAttributeValue, rateInfo) {
var m = HMSF_REGEX.exec(timeAttributeValue);
var frames = (m[4] | 0) + (m[5] | 0) / rateInfo.subFrameRate;
return (m[1] | 0) * 3600 + (m[2] | 0) * 60 + (m[3] | 0) + frames / rateInfo.frameRate;
}
function parseTimeUnits(timeAttributeValue, rateInfo) {
var m = TIME_UNIT_REGEX.exec(timeAttributeValue);
var value = Number(m[1]);
var unit = m[2];
switch (unit) {
case 'h':
return value * 3600;
case 'm':
return value * 60;
case 'ms':
return value * 1000;
case 'f':
return value / rateInfo.frameRate;
case 't':
return value / rateInfo.tickRate;
}
return value;
}
/***/ }),
/***/ "./src/utils/logger.ts":
/*!*****************************!*\
!*** ./src/utils/logger.ts ***!
\*****************************/
/*! exports provided: enableLogs, logger */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "enableLogs", function() { return enableLogs; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "logger", function() { return logger; });
var noop = function noop() {};
var fakeLogger = {
trace: noop,
debug: noop,
log: noop,
warn: noop,
info: noop,
error: noop
};
var exportedLogger = fakeLogger; // let lastCallTime;
// function formatMsgWithTimeInfo(type, msg) {
// const now = Date.now();
// const diff = lastCallTime ? '+' + (now - lastCallTime) : '0';
// lastCallTime = now;
// msg = (new Date(now)).toISOString() + ' | [' + type + '] > ' + msg + ' ( ' + diff + ' ms )';
// return msg;
// }
function consolePrintFn(type) {
var func = self.console[type];
if (func) {
return func.bind(self.console, "[" + type + "] >");
}
return noop;
}
function exportLoggerFunctions(debugConfig) {
for (var _len = arguments.length, functions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
functions[_key - 1] = arguments[_key];
}
functions.forEach(function (type) {
exportedLogger[type] = debugConfig[type] ? debugConfig[type].bind(debugConfig) : consolePrintFn(type);
});
}
function enableLogs(debugConfig) {
// check that console is available
if (self.console && debugConfig === true || typeof debugConfig === 'object') {
exportLoggerFunctions(debugConfig, // Remove out from list here to hard-disable a log-level
// 'trace',
'debug', 'log', 'info', 'warn', 'error'); // Some browsers don't allow to use bind on console object anyway
// fallback to default if needed
try {
exportedLogger.log();
} catch (e) {
exportedLogger = fakeLogger;
}
} else {
exportedLogger = fakeLogger;
}
}
var logger = exportedLogger;
/***/ }),
/***/ "./src/utils/mediakeys-helper.ts":
/*!***************************************!*\
!*** ./src/utils/mediakeys-helper.ts ***!
\***************************************/
/*! exports provided: KeySystems, requestMediaKeySystemAccess */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "KeySystems", function() { return KeySystems; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "requestMediaKeySystemAccess", function() { return requestMediaKeySystemAccess; });
/**
* @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/requestMediaKeySystemAccess
*/
var KeySystems;
(function (KeySystems) {
KeySystems["WIDEVINE"] = "com.widevine.alpha";
KeySystems["PLAYREADY"] = "com.microsoft.playready";
})(KeySystems || (KeySystems = {}));
var requestMediaKeySystemAccess = function () {
if (typeof self !== 'undefined' && self.navigator && self.navigator.requestMediaKeySystemAccess) {
return self.navigator.requestMediaKeySystemAccess.bind(self.navigator);
} else {
return null;
}
}();
/***/ }),
/***/ "./src/utils/mediasource-helper.ts":
/*!*****************************************!*\
!*** ./src/utils/mediasource-helper.ts ***!
\*****************************************/
/*! exports provided: getMediaSource */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getMediaSource", function() { return getMediaSource; });
/**
* MediaSource helper
*/
function getMediaSource() {
return self.MediaSource || self.WebKitMediaSource;
}
/***/ }),
/***/ "./src/utils/mp4-tools.ts":
/*!********************************!*\
!*** ./src/utils/mp4-tools.ts ***!
\********************************/
/*! exports provided: bin2str, readUint16, readUint32, writeUint32, findBox, parseSegmentIndex, parseInitSegment, getStartDTS, getDuration, computeRawDurationFromSamples, offsetStartDTS, segmentValidRange, appendUint8Array */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bin2str", function() { return bin2str; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "readUint16", function() { return readUint16; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "readUint32", function() { return readUint32; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "writeUint32", function() { return writeUint32; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findBox", function() { return findBox; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseSegmentIndex", function() { return parseSegmentIndex; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseInitSegment", function() { return parseInitSegment; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getStartDTS", function() { return getStartDTS; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getDuration", function() { return getDuration; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computeRawDurationFromSamples", function() { return computeRawDurationFromSamples; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "offsetStartDTS", function() { return offsetStartDTS; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "segmentValidRange", function() { return segmentValidRange; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "appendUint8Array", function() { return appendUint8Array; });
/* harmony import */ var _typed_array__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./typed-array */ "./src/utils/typed-array.ts");
/* harmony import */ var _loader_fragment__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../loader/fragment */ "./src/loader/fragment.ts");
var UINT32_MAX = Math.pow(2, 32) - 1;
var push = [].push;
function bin2str(data) {
return String.fromCharCode.apply(null, data);
}
function readUint16(buffer, offset) {
if ('data' in buffer) {
offset += buffer.start;
buffer = buffer.data;
}
var val = buffer[offset] << 8 | buffer[offset + 1];
return val < 0 ? 65536 + val : val;
}
function readUint32(buffer, offset) {
if ('data' in buffer) {
offset += buffer.start;
buffer = buffer.data;
}
var val = buffer[offset] << 24 | buffer[offset + 1] << 16 | buffer[offset + 2] << 8 | buffer[offset + 3];
return val < 0 ? 4294967296 + val : val;
}
function writeUint32(buffer, offset, value) {
if ('data' in buffer) {
offset += buffer.start;
buffer = buffer.data;
}
buffer[offset] = value >> 24;
buffer[offset + 1] = value >> 16 & 0xff;
buffer[offset + 2] = value >> 8 & 0xff;
buffer[offset + 3] = value & 0xff;
} // Find the data for a box specified by its path
function findBox(input, path) {
var results = [];
if (!path.length) {
// short-circuit the search for empty paths
return results;
}
var data;
var start;
var end;
if ('data' in input) {
data = input.data;
start = input.start;
end = input.end;
} else {
data = input;
start = 0;
end = data.byteLength;
}
for (var i = start; i < end;) {
var size = readUint32(data, i);
var type = bin2str(data.subarray(i + 4, i + 8));
var endbox = size > 1 ? i + size : end;
if (type === path[0]) {
if (path.length === 1) {
// this is the end of the path and we've found the box we were
// looking for
results.push({
data: data,
start: i + 8,
end: endbox
});
} else {
// recursively search for the next box along the path
var subresults = findBox({
data: data,
start: i + 8,
end: endbox
}, path.slice(1));
if (subresults.length) {
push.apply(results, subresults);
}
}
}
i = endbox;
} // we've finished searching all of data
return results;
}
function parseSegmentIndex(initSegment) {
var moovBox = findBox(initSegment, ['moov']);
var moov = moovBox[0];
var moovEndOffset = moov ? moov.end : null; // we need this in case we need to chop of garbage of the end of current data
var sidxBox = findBox(initSegment, ['sidx']);
if (!sidxBox || !sidxBox[0]) {
return null;
}
var references = [];
var sidx = sidxBox[0];
var version = sidx.data[0]; // set initial offset, we skip the reference ID (not needed)
var index = version === 0 ? 8 : 16;
var timescale = readUint32(sidx, index);
index += 4; // TODO: parse earliestPresentationTime and firstOffset
// usually zero in our case
var earliestPresentationTime = 0;
var firstOffset = 0;
if (version === 0) {
index += 8;
} else {
index += 16;
} // skip reserved
index += 2;
var startByte = sidx.end + firstOffset;
var referencesCount = readUint16(sidx, index);
index += 2;
for (var i = 0; i < referencesCount; i++) {
var referenceIndex = index;
var referenceInfo = readUint32(sidx, referenceIndex);
referenceIndex += 4;
var referenceSize = referenceInfo & 0x7fffffff;
var referenceType = (referenceInfo & 0x80000000) >>> 31;
if (referenceType === 1) {
// eslint-disable-next-line no-console
console.warn('SIDX has hierarchical references (not supported)');
return null;
}
var subsegmentDuration = readUint32(sidx, referenceIndex);
referenceIndex += 4;
references.push({
referenceSize: referenceSize,
subsegmentDuration: subsegmentDuration,
// unscaled
info: {
duration: subsegmentDuration / timescale,
start: startByte,
end: startByte + referenceSize - 1
}
});
startByte += referenceSize; // Skipping 1 bit for |startsWithSap|, 3 bits for |sapType|, and 28 bits
// for |sapDelta|.
referenceIndex += 4; // skip to next ref
index = referenceIndex;
}
return {
earliestPresentationTime: earliestPresentationTime,
timescale: timescale,
version: version,
referencesCount: referencesCount,
references: references,
moovEndOffset: moovEndOffset
};
}
/**
* Parses an MP4 initialization segment and extracts stream type and
* timescale values for any declared tracks. Timescale values indicate the
* number of clock ticks per second to assume for time-based values
* elsewhere in the MP4.
*
* To determine the start time of an MP4, you need two pieces of
* information: the timescale unit and the earliest base media decode
* time. Multiple timescales can be specified within an MP4 but the
* base media decode time is always expressed in the timescale from
* the media header box for the track:
* ```
* moov > trak > mdia > mdhd.timescale
* moov > trak > mdia > hdlr
* ```
* @param initSegment {Uint8Array} the bytes of the init segment
* @return {InitData} a hash of track type to timescale values or null if
* the init segment is malformed.
*/
function parseInitSegment(initSegment) {
var result = [];
var traks = findBox(initSegment, ['moov', 'trak']);
for (var i = 0; i < traks.length; i++) {
var trak = traks[i];
var tkhd = findBox(trak, ['tkhd'])[0];
if (tkhd) {
var version = tkhd.data[tkhd.start];
var _index = version === 0 ? 12 : 20;
var trackId = readUint32(tkhd, _index);
var mdhd = findBox(trak, ['mdia', 'mdhd'])[0];
if (mdhd) {
version = mdhd.data[mdhd.start];
_index = version === 0 ? 12 : 20;
var timescale = readUint32(mdhd, _index);
var hdlr = findBox(trak, ['mdia', 'hdlr'])[0];
if (hdlr) {
var hdlrType = bin2str(hdlr.data.subarray(hdlr.start + 8, hdlr.start + 12));
var type = {
soun: _loader_fragment__WEBPACK_IMPORTED_MODULE_1__["ElementaryStreamTypes"].AUDIO,
vide: _loader_fragment__WEBPACK_IMPORTED_MODULE_1__["ElementaryStreamTypes"].VIDEO
}[hdlrType];
if (type) {
// Parse codec details
var stsd = findBox(trak, ['mdia', 'minf', 'stbl', 'stsd'])[0];
var codec = void 0;
if (stsd) {
codec = bin2str(stsd.data.subarray(stsd.start + 12, stsd.start + 16)); // TODO: Parse codec details to be able to build MIME type.
// stsd.start += 8;
// const codecBox = findBox(stsd, [codec])[0];
// if (codecBox) {
// TODO: Codec parsing support for avc1, mp4a, hevc, av01...
// }
}
result[trackId] = {
timescale: timescale,
type: type
};
result[type] = {
timescale: timescale,
id: trackId,
codec: codec
};
}
}
}
}
}
var trex = findBox(initSegment, ['moov', 'mvex', 'trex']);
trex.forEach(function (trex) {
var trackId = readUint32(trex, 4);
var track = result[trackId];
if (track) {
track.default = {
duration: readUint32(trex, 12),
flags: readUint32(trex, 20)
};
}
});
return result;
}
/**
* Determine the base media decode start time, in seconds, for an MP4
* fragment. If multiple fragments are specified, the earliest time is
* returned.
*
* The base media decode time can be parsed from track fragment
* metadata:
* ```
* moof > traf > tfdt.baseMediaDecodeTime
* ```
* It requires the timescale value from the mdhd to interpret.
*
* @param initData {InitData} a hash of track type to timescale values
* @param fmp4 {Uint8Array} the bytes of the mp4 fragment
* @return {number} the earliest base media decode start time for the
* fragment, in seconds
*/
function getStartDTS(initData, fmp4) {
// we need info from two children of each track fragment box
return findBox(fmp4, ['moof', 'traf']).reduce(function (result, traf) {
var tfdt = findBox(traf, ['tfdt'])[0];
var version = tfdt.data[tfdt.start];
var start = findBox(traf, ['tfhd']).reduce(function (result, tfhd) {
// get the track id from the tfhd
var id = readUint32(tfhd, 4);
var track = initData[id];
if (track) {
var baseTime = readUint32(tfdt, 4);
if (version === 1) {
baseTime *= Math.pow(2, 32);
baseTime += readUint32(tfdt, 8);
} // assume a 90kHz clock if no timescale was specified
var scale = track.timescale || 90e3; // convert base time to seconds
var startTime = baseTime / scale;
if (isFinite(startTime) && (result === null || startTime < result)) {
return startTime;
}
}
return result;
}, null);
if (start !== null && isFinite(start) && (result === null || start < result)) {
return start;
}
return result;
}, null) || 0;
}
/*
For Reference:
aligned(8) class TrackFragmentHeaderBox
extends FullBox(‘tfhd’, 0, tf_flags){
unsigned int(32) track_ID;
// all the following are optional fields
unsigned int(64) base_data_offset;
unsigned int(32) sample_description_index;
unsigned int(32) default_sample_duration;
unsigned int(32) default_sample_size;
unsigned int(32) default_sample_flags
}
*/
function getDuration(data, initData) {
var rawDuration = 0;
var videoDuration = 0;
var audioDuration = 0;
var trafs = findBox(data, ['moof', 'traf']);
for (var i = 0; i < trafs.length; i++) {
var traf = trafs[i]; // There is only one tfhd & trun per traf
// This is true for CMAF style content, and we should perhaps check the ftyp
// and only look for a single trun then, but for ISOBMFF we should check
// for multiple track runs.
var tfhd = findBox(traf, ['tfhd'])[0]; // get the track id from the tfhd
var id = readUint32(tfhd, 4);
var track = initData[id];
if (!track) {
continue;
}
var trackDefault = track.default;
var tfhdFlags = readUint32(tfhd, 0) | (trackDefault === null || trackDefault === void 0 ? void 0 : trackDefault.flags);
var sampleDuration = trackDefault === null || trackDefault === void 0 ? void 0 : trackDefault.duration;
if (tfhdFlags & 0x000008) {
// 0x000008 indicates the presence of the default_sample_duration field
if (tfhdFlags & 0x000002) {
// 0x000002 indicates the presence of the sample_description_index field, which precedes default_sample_duration
// If present, the default_sample_duration exists at byte offset 12
sampleDuration = readUint32(tfhd, 12);
} else {
// Otherwise, the duration is at byte offset 8
sampleDuration = readUint32(tfhd, 8);
}
} // assume a 90kHz clock if no timescale was specified
var timescale = track.timescale || 90e3;
var truns = findBox(traf, ['trun']);
for (var j = 0; j < truns.length; j++) {
if (sampleDuration) {
var sampleCount = readUint32(truns[j], 4);
rawDuration = sampleDuration * sampleCount;
} else {
rawDuration = computeRawDurationFromSamples(truns[j]);
}
if (track.type === _loader_fragment__WEBPACK_IMPORTED_MODULE_1__["ElementaryStreamTypes"].VIDEO) {
videoDuration += rawDuration / timescale;
} else if (track.type === _loader_fragment__WEBPACK_IMPORTED_MODULE_1__["ElementaryStreamTypes"].AUDIO) {
audioDuration += rawDuration / timescale;
}
}
}
if (videoDuration === 0 && audioDuration === 0) {
// If duration samples are not available in the traf use sidx subsegment_duration
var sidx = parseSegmentIndex(data);
if (sidx !== null && sidx !== void 0 && sidx.references) {
return sidx.references.reduce(function (dur, ref) {
return dur + ref.info.duration || 0;
}, 0);
}
}
if (videoDuration) {
return videoDuration;
}
return audioDuration;
}
/*
For Reference:
aligned(8) class TrackRunBox
extends FullBox(‘trun’, version, tr_flags) {
unsigned int(32) sample_count;
// the following are optional fields
signed int(32) data_offset;
unsigned int(32) first_sample_flags;
// all fields in the following array are optional
{
unsigned int(32) sample_duration;
unsigned int(32) sample_size;
unsigned int(32) sample_flags
if (version == 0)
{ unsigned int(32)
else
{ signed int(32)
}[ sample_count ]
}
*/
function computeRawDurationFromSamples(trun) {
var flags = readUint32(trun, 0); // Flags are at offset 0, non-optional sample_count is at offset 4. Therefore we start 8 bytes in.
// Each field is an int32, which is 4 bytes
var offset = 8; // data-offset-present flag
if (flags & 0x000001) {
offset += 4;
} // first-sample-flags-present flag
if (flags & 0x000004) {
offset += 4;
}
var duration = 0;
var sampleCount = readUint32(trun, 4);
for (var i = 0; i < sampleCount; i++) {
// sample-duration-present flag
if (flags & 0x000100) {
var sampleDuration = readUint32(trun, offset);
duration += sampleDuration;
offset += 4;
} // sample-size-present flag
if (flags & 0x000200) {
offset += 4;
} // sample-flags-present flag
if (flags & 0x000400) {
offset += 4;
} // sample-composition-time-offsets-present flag
if (flags & 0x000800) {
offset += 4;
}
}
return duration;
}
function offsetStartDTS(initData, fmp4, timeOffset) {
findBox(fmp4, ['moof', 'traf']).forEach(function (traf) {
findBox(traf, ['tfhd']).forEach(function (tfhd) {
// get the track id from the tfhd
var id = readUint32(tfhd, 4);
var track = initData[id];
if (!track) {
return;
} // assume a 90kHz clock if no timescale was specified
var timescale = track.timescale || 90e3; // get the base media decode time from the tfdt
findBox(traf, ['tfdt']).forEach(function (tfdt) {
var version = tfdt.data[tfdt.start];
var baseMediaDecodeTime = readUint32(tfdt, 4);
if (version === 0) {
writeUint32(tfdt, 4, baseMediaDecodeTime - timeOffset * timescale);
} else {
baseMediaDecodeTime *= Math.pow(2, 32);
baseMediaDecodeTime += readUint32(tfdt, 8);
baseMediaDecodeTime -= timeOffset * timescale;
baseMediaDecodeTime = Math.max(baseMediaDecodeTime, 0);
var upper = Math.floor(baseMediaDecodeTime / (UINT32_MAX + 1));
var lower = Math.floor(baseMediaDecodeTime % (UINT32_MAX + 1));
writeUint32(tfdt, 4, upper);
writeUint32(tfdt, 8, lower);
}
});
});
});
} // TODO: Check if the last moof+mdat pair is part of the valid range
function segmentValidRange(data) {
var segmentedRange = {
valid: null,
remainder: null
};
var moofs = findBox(data, ['moof']);
if (!moofs) {
return segmentedRange;
} else if (moofs.length < 2) {
segmentedRange.remainder = data;
return segmentedRange;
}
var last = moofs[moofs.length - 1]; // Offset by 8 bytes; findBox offsets the start by as much
segmentedRange.valid = Object(_typed_array__WEBPACK_IMPORTED_MODULE_0__["sliceUint8"])(data, 0, last.start - 8);
segmentedRange.remainder = Object(_typed_array__WEBPACK_IMPORTED_MODULE_0__["sliceUint8"])(data, last.start - 8);
return segmentedRange;
}
function appendUint8Array(data1, data2) {
var temp = new Uint8Array(data1.length + data2.length);
temp.set(data1);
temp.set(data2, data1.length);
return temp;
}
/***/ }),
/***/ "./src/utils/output-filter.ts":
/*!************************************!*\
!*** ./src/utils/output-filter.ts ***!
\************************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return OutputFilter; });
var OutputFilter = /*#__PURE__*/function () {
function OutputFilter(timelineController, trackName) {
this.timelineController = void 0;
this.cueRanges = [];
this.trackName = void 0;
this.startTime = null;
this.endTime = null;
this.screen = null;
this.timelineController = timelineController;
this.trackName = trackName;
}
var _proto = OutputFilter.prototype;
_proto.dispatchCue = function dispatchCue() {
if (this.startTime === null) {
return;
}
this.timelineController.addCues(this.trackName, this.startTime, this.endTime, this.screen, this.cueRanges);
this.startTime = null;
};
_proto.newCue = function newCue(startTime, endTime, screen) {
if (this.startTime === null || this.startTime > startTime) {
this.startTime = startTime;
}
this.endTime = endTime;
this.screen = screen;
this.timelineController.createCaptionsTrack(this.trackName);
};
_proto.reset = function reset() {
this.cueRanges = [];
};
return OutputFilter;
}();
/***/ }),
/***/ "./src/utils/texttrack-utils.ts":
/*!**************************************!*\
!*** ./src/utils/texttrack-utils.ts ***!
\**************************************/
/*! exports provided: sendAddTrackEvent, addCueToTrack, clearCurrentCues, removeCuesInRange, getCuesInRange */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sendAddTrackEvent", function() { return sendAddTrackEvent; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "addCueToTrack", function() { return addCueToTrack; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clearCurrentCues", function() { return clearCurrentCues; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "removeCuesInRange", function() { return removeCuesInRange; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getCuesInRange", function() { return getCuesInRange; });
/* harmony import */ var _logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./logger */ "./src/utils/logger.ts");
function sendAddTrackEvent(track, videoEl) {
var event;
try {
event = new Event('addtrack');
} catch (err) {
// for IE11
event = document.createEvent('Event');
event.initEvent('addtrack', false, false);
}
event.track = track;
videoEl.dispatchEvent(event);
}
function addCueToTrack(track, cue) {
// Sometimes there are cue overlaps on segmented vtts so the same
// cue can appear more than once in different vtt files.
// This avoid showing duplicated cues with same timecode and text.
var mode = track.mode;
if (mode === 'disabled') {
track.mode = 'hidden';
}
if (track.cues && !track.cues.getCueById(cue.id)) {
try {
track.addCue(cue);
if (!track.cues.getCueById(cue.id)) {
throw new Error("addCue is failed for: " + cue);
}
} catch (err) {
_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].debug("[texttrack-utils]: " + err);
var textTrackCue = new self.TextTrackCue(cue.startTime, cue.endTime, cue.text);
textTrackCue.id = cue.id;
track.addCue(textTrackCue);
}
}
if (mode === 'disabled') {
track.mode = mode;
}
}
function clearCurrentCues(track) {
// When track.mode is disabled, track.cues will be null.
// To guarantee the removal of cues, we need to temporarily
// change the mode to hidden
var mode = track.mode;
if (mode === 'disabled') {
track.mode = 'hidden';
}
if (track.cues) {
for (var i = track.cues.length; i--;) {
track.removeCue(track.cues[i]);
}
}
if (mode === 'disabled') {
track.mode = mode;
}
}
function removeCuesInRange(track, start, end) {
var mode = track.mode;
if (mode === 'disabled') {
track.mode = 'hidden';
}
if (track.cues && track.cues.length > 0) {
var cues = getCuesInRange(track.cues, start, end);
for (var i = 0; i < cues.length; i++) {
track.removeCue(cues[i]);
}
}
if (mode === 'disabled') {
track.mode = mode;
}
} // Find first cue starting after given time.
// Modified version of binary search O(log(n)).
function getFirstCueIndexAfterTime(cues, time) {
// If first cue starts after time, start there
if (time < cues[0].startTime) {
return 0;
} // If the last cue ends before time there is no overlap
var len = cues.length - 1;
if (time > cues[len].endTime) {
return -1;
}
var left = 0;
var right = len;
while (left <= right) {
var mid = Math.floor((right + left) / 2);
if (time < cues[mid].startTime) {
right = mid - 1;
} else if (time > cues[mid].startTime && left < len) {
left = mid + 1;
} else {
// If it's not lower or higher, it must be equal.
return mid;
}
} // At this point, left and right have swapped.
// No direct match was found, left or right element must be the closest. Check which one has the smallest diff.
return cues[left].startTime - time < time - cues[right].startTime ? left : right;
}
function getCuesInRange(cues, start, end) {
var cuesFound = [];
var firstCueInRange = getFirstCueIndexAfterTime(cues, start);
if (firstCueInRange > -1) {
for (var i = firstCueInRange, len = cues.length; i < len; i++) {
var cue = cues[i];
if (cue.startTime >= start && cue.endTime <= end) {
cuesFound.push(cue);
} else if (cue.startTime > end) {
return cuesFound;
}
}
}
return cuesFound;
}
/***/ }),
/***/ "./src/utils/time-ranges.ts":
/*!**********************************!*\
!*** ./src/utils/time-ranges.ts ***!
\**********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/**
* TimeRanges to string helper
*/
var TimeRanges = {
toString: function toString(r) {
var log = '';
var len = r.length;
for (var i = 0; i < len; i++) {
log += '[' + r.start(i).toFixed(3) + ',' + r.end(i).toFixed(3) + ']';
}
return log;
}
};
/* harmony default export */ __webpack_exports__["default"] = (TimeRanges);
/***/ }),
/***/ "./src/utils/timescale-conversion.ts":
/*!*******************************************!*\
!*** ./src/utils/timescale-conversion.ts ***!
\*******************************************/
/*! exports provided: toTimescaleFromBase, toTimescaleFromScale, toMsFromMpegTsClock, toMpegTsClockFromTimescale */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toTimescaleFromBase", function() { return toTimescaleFromBase; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toTimescaleFromScale", function() { return toTimescaleFromScale; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toMsFromMpegTsClock", function() { return toMsFromMpegTsClock; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toMpegTsClockFromTimescale", function() { return toMpegTsClockFromTimescale; });
var MPEG_TS_CLOCK_FREQ_HZ = 90000;
function toTimescaleFromBase(value, destScale, srcBase, round) {
if (srcBase === void 0) {
srcBase = 1;
}
if (round === void 0) {
round = false;
}
var result = value * destScale * srcBase; // equivalent to `(value * scale) / (1 / base)`
return round ? Math.round(result) : result;
}
function toTimescaleFromScale(value, destScale, srcScale, round) {
if (srcScale === void 0) {
srcScale = 1;
}
if (round === void 0) {
round = false;
}
return toTimescaleFromBase(value, destScale, 1 / srcScale, round);
}
function toMsFromMpegTsClock(value, round) {
if (round === void 0) {
round = false;
}
return toTimescaleFromBase(value, 1000, 1 / MPEG_TS_CLOCK_FREQ_HZ, round);
}
function toMpegTsClockFromTimescale(value, srcScale) {
if (srcScale === void 0) {
srcScale = 1;
}
return toTimescaleFromBase(value, MPEG_TS_CLOCK_FREQ_HZ, 1 / srcScale);
}
/***/ }),
/***/ "./src/utils/typed-array.ts":
/*!**********************************!*\
!*** ./src/utils/typed-array.ts ***!
\**********************************/
/*! exports provided: sliceUint8 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sliceUint8", function() { return sliceUint8; });
function sliceUint8(array, start, end) {
// @ts-expect-error This polyfills IE11 usage of Uint8Array slice.
// It always exists in the TypeScript definition so fails, but it fails at runtime on IE11.
return Uint8Array.prototype.slice ? array.slice(start, end) : new Uint8Array(Array.prototype.slice.call(array, start, end));
}
/***/ }),
/***/ "./src/utils/vttcue.ts":
/*!*****************************!*\
!*** ./src/utils/vttcue.ts ***!
\*****************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/**
* Copyright 2013 vtt.js Contributors
*
* Licensed under the Apache License, Version 2.0 (the 'License');
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an 'AS IS' BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* harmony default export */ __webpack_exports__["default"] = ((function () {
if (typeof self !== 'undefined' && self.VTTCue) {
return self.VTTCue;
}
var AllowedDirections = ['', 'lr', 'rl'];
var AllowedAlignments = ['start', 'middle', 'end', 'left', 'right'];
function isAllowedValue(allowed, value) {
if (typeof value !== 'string') {
return false;
} // necessary for assuring the generic conforms to the Array interface
if (!Array.isArray(allowed)) {
return false;
} // reset the type so that the next narrowing works well
var lcValue = value.toLowerCase(); // use the allow list to narrow the type to a specific subset of strings
if (~allowed.indexOf(lcValue)) {
return lcValue;
}
return false;
}
function findDirectionSetting(value) {
return isAllowedValue(AllowedDirections, value);
}
function findAlignSetting(value) {
return isAllowedValue(AllowedAlignments, value);
}
function extend(obj) {
for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
rest[_key - 1] = arguments[_key];
}
var i = 1;
for (; i < arguments.length; i++) {
var cobj = arguments[i];
for (var p in cobj) {
obj[p] = cobj[p];
}
}
return obj;
}
function VTTCue(startTime, endTime, text) {
var cue = this;
var baseObj = {
enumerable: true
};
/**
* Shim implementation specific properties. These properties are not in
* the spec.
*/
// Lets us know when the VTTCue's data has changed in such a way that we need
// to recompute its display state. This lets us compute its display state
// lazily.
cue.hasBeenReset = false;
/**
* VTTCue and TextTrackCue properties
* http://dev.w3.org/html5/webvtt/#vttcue-interface
*/
var _id = '';
var _pauseOnExit = false;
var _startTime = startTime;
var _endTime = endTime;
var _text = text;
var _region = null;
var _vertical = '';
var _snapToLines = true;
var _line = 'auto';
var _lineAlign = 'start';
var _position = 50;
var _positionAlign = 'middle';
var _size = 50;
var _align = 'middle';
Object.defineProperty(cue, 'id', extend({}, baseObj, {
get: function get() {
return _id;
},
set: function set(value) {
_id = '' + value;
}
}));
Object.defineProperty(cue, 'pauseOnExit', extend({}, baseObj, {
get: function get() {
return _pauseOnExit;
},
set: function set(value) {
_pauseOnExit = !!value;
}
}));
Object.defineProperty(cue, 'startTime', extend({}, baseObj, {
get: function get() {
return _startTime;
},
set: function set(value) {
if (typeof value !== 'number') {
throw new TypeError('Start time must be set to a number.');
}
_startTime = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'endTime', extend({}, baseObj, {
get: function get() {
return _endTime;
},
set: function set(value) {
if (typeof value !== 'number') {
throw new TypeError('End time must be set to a number.');
}
_endTime = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'text', extend({}, baseObj, {
get: function get() {
return _text;
},
set: function set(value) {
_text = '' + value;
this.hasBeenReset = true;
}
})); // todo: implement VTTRegion polyfill?
Object.defineProperty(cue, 'region', extend({}, baseObj, {
get: function get() {
return _region;
},
set: function set(value) {
_region = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'vertical', extend({}, baseObj, {
get: function get() {
return _vertical;
},
set: function set(value) {
var setting = findDirectionSetting(value); // Have to check for false because the setting an be an empty string.
if (setting === false) {
throw new SyntaxError('An invalid or illegal string was specified.');
}
_vertical = setting;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'snapToLines', extend({}, baseObj, {
get: function get() {
return _snapToLines;
},
set: function set(value) {
_snapToLines = !!value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'line', extend({}, baseObj, {
get: function get() {
return _line;
},
set: function set(value) {
if (typeof value !== 'number' && value !== 'auto') {
throw new SyntaxError('An invalid number or illegal string was specified.');
}
_line = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'lineAlign', extend({}, baseObj, {
get: function get() {
return _lineAlign;
},
set: function set(value) {
var setting = findAlignSetting(value);
if (!setting) {
throw new SyntaxError('An invalid or illegal string was specified.');
}
_lineAlign = setting;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'position', extend({}, baseObj, {
get: function get() {
return _position;
},
set: function set(value) {
if (value < 0 || value > 100) {
throw new Error('Position must be between 0 and 100.');
}
_position = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'positionAlign', extend({}, baseObj, {
get: function get() {
return _positionAlign;
},
set: function set(value) {
var setting = findAlignSetting(value);
if (!setting) {
throw new SyntaxError('An invalid or illegal string was specified.');
}
_positionAlign = setting;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'size', extend({}, baseObj, {
get: function get() {
return _size;
},
set: function set(value) {
if (value < 0 || value > 100) {
throw new Error('Size must be between 0 and 100.');
}
_size = value;
this.hasBeenReset = true;
}
}));
Object.defineProperty(cue, 'align', extend({}, baseObj, {
get: function get() {
return _align;
},
set: function set(value) {
var setting = findAlignSetting(value);
if (!setting) {
throw new SyntaxError('An invalid or illegal string was specified.');
}
_align = setting;
this.hasBeenReset = true;
}
}));
/**
* Other <track> spec defined properties
*/
// http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#text-track-cue-display-state
cue.displayState = undefined;
}
/**
* VTTCue methods
*/
VTTCue.prototype.getCueAsHTML = function () {
// Assume WebVTT.convertCueToDOMTree is on the global.
var WebVTT = self.WebVTT;
return WebVTT.convertCueToDOMTree(self, this.text);
}; // this is a polyfill hack
return VTTCue;
})());
/***/ }),
/***/ "./src/utils/vttparser.ts":
/*!********************************!*\
!*** ./src/utils/vttparser.ts ***!
\********************************/
/*! exports provided: parseTimeStamp, fixLineBreaks, VTTParser */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseTimeStamp", function() { return parseTimeStamp; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fixLineBreaks", function() { return fixLineBreaks; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "VTTParser", function() { return VTTParser; });
/* harmony import */ var _vttcue__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./vttcue */ "./src/utils/vttcue.ts");
/*
* Source: https://github.com/mozilla/vtt.js/blob/master/dist/vtt.js
*/
var StringDecoder = /*#__PURE__*/function () {
function StringDecoder() {}
var _proto = StringDecoder.prototype;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
_proto.decode = function decode(data, options) {
if (!data) {
return '';
}
if (typeof data !== 'string') {
throw new Error('Error - expected string data.');
}
return decodeURIComponent(encodeURIComponent(data));
};
return StringDecoder;
}(); // Try to parse input as a time stamp.
function parseTimeStamp(input) {
function computeSeconds(h, m, s, f) {
return (h | 0) * 3600 + (m | 0) * 60 + (s | 0) + parseFloat(f || 0);
}
var m = input.match(/^(?:(\d+):)?(\d{2}):(\d{2})(\.\d+)?/);
if (!m) {
return null;
}
if (parseFloat(m[2]) > 59) {
// Timestamp takes the form of [hours]:[minutes].[milliseconds]
// First position is hours as it's over 59.
return computeSeconds(m[2], m[3], 0, m[4]);
} // Timestamp takes the form of [hours (optional)]:[minutes]:[seconds].[milliseconds]
return computeSeconds(m[1], m[2], m[3], m[4]);
} // A settings object holds key/value pairs and will ignore anything but the first
// assignment to a specific key.
var Settings = /*#__PURE__*/function () {
function Settings() {
this.values = Object.create(null);
}
var _proto2 = Settings.prototype;
// Only accept the first assignment to any key.
_proto2.set = function set(k, v) {
if (!this.get(k) && v !== '') {
this.values[k] = v;
}
} // Return the value for a key, or a default value.
// If 'defaultKey' is passed then 'dflt' is assumed to be an object with
// a number of possible default values as properties where 'defaultKey' is
// the key of the property that will be chosen; otherwise it's assumed to be
// a single value.
;
_proto2.get = function get(k, dflt, defaultKey) {
if (defaultKey) {
return this.has(k) ? this.values[k] : dflt[defaultKey];
}
return this.has(k) ? this.values[k] : dflt;
} // Check whether we have a value for a key.
;
_proto2.has = function has(k) {
return k in this.values;
} // Accept a setting if its one of the given alternatives.
;
_proto2.alt = function alt(k, v, a) {
for (var n = 0; n < a.length; ++n) {
if (v === a[n]) {
this.set(k, v);
break;
}
}
} // Accept a setting if its a valid (signed) integer.
;
_proto2.integer = function integer(k, v) {
if (/^-?\d+$/.test(v)) {
// integer
this.set(k, parseInt(v, 10));
}
} // Accept a setting if its a valid percentage.
;
_proto2.percent = function percent(k, v) {
if (/^([\d]{1,3})(\.[\d]*)?%$/.test(v)) {
var percent = parseFloat(v);
if (percent >= 0 && percent <= 100) {
this.set(k, percent);
return true;
}
}
return false;
};
return Settings;
}(); // Helper function to parse input into groups separated by 'groupDelim', and
// interpret each group as a key/value pair separated by 'keyValueDelim'.
function parseOptions(input, callback, keyValueDelim, groupDelim) {
var groups = groupDelim ? input.split(groupDelim) : [input];
for (var i in groups) {
if (typeof groups[i] !== 'string') {
continue;
}
var kv = groups[i].split(keyValueDelim);
if (kv.length !== 2) {
continue;
}
var _k = kv[0];
var _v = kv[1];
callback(_k, _v);
}
}
var defaults = new _vttcue__WEBPACK_IMPORTED_MODULE_0__["default"](0, 0, ''); // 'middle' was changed to 'center' in the spec: https://github.com/w3c/webvtt/pull/244
// Safari doesn't yet support this change, but FF and Chrome do.
var center = defaults.align === 'middle' ? 'middle' : 'center';
function parseCue(input, cue, regionList) {
// Remember the original input if we need to throw an error.
var oInput = input; // 4.1 WebVTT timestamp
function consumeTimeStamp() {
var ts = parseTimeStamp(input);
if (ts === null) {
throw new Error('Malformed timestamp: ' + oInput);
} // Remove time stamp from input.
input = input.replace(/^[^\sa-zA-Z-]+/, '');
return ts;
} // 4.4.2 WebVTT cue settings
function consumeCueSettings(input, cue) {
var settings = new Settings();
parseOptions(input, function (k, v) {
var vals;
switch (k) {
case 'region':
// Find the last region we parsed with the same region id.
for (var i = regionList.length - 1; i >= 0; i--) {
if (regionList[i].id === v) {
settings.set(k, regionList[i].region);
break;
}
}
break;
case 'vertical':
settings.alt(k, v, ['rl', 'lr']);
break;
case 'line':
vals = v.split(',');
settings.integer(k, vals[0]);
if (settings.percent(k, vals[0])) {
settings.set('snapToLines', false);
}
settings.alt(k, vals[0], ['auto']);
if (vals.length === 2) {
settings.alt('lineAlign', vals[1], ['start', center, 'end']);
}
break;
case 'position':
vals = v.split(',');
settings.percent(k, vals[0]);
if (vals.length === 2) {
settings.alt('positionAlign', vals[1], ['start', center, 'end', 'line-left', 'line-right', 'auto']);
}
break;
case 'size':
settings.percent(k, v);
break;
case 'align':
settings.alt(k, v, ['start', center, 'end', 'left', 'right']);
break;
}
}, /:/, /\s/); // Apply default values for any missing fields.
cue.region = settings.get('region', null);
cue.vertical = settings.get('vertical', '');
var line = settings.get('line', 'auto');
if (line === 'auto' && defaults.line === -1) {
// set numeric line number for Safari
line = -1;
}
cue.line = line;
cue.lineAlign = settings.get('lineAlign', 'start');
cue.snapToLines = settings.get('snapToLines', true);
cue.size = settings.get('size', 100);
cue.align = settings.get('align', center);
var position = settings.get('position', 'auto');
if (position === 'auto' && defaults.position === 50) {
// set numeric position for Safari
position = cue.align === 'start' || cue.align === 'left' ? 0 : cue.align === 'end' || cue.align === 'right' ? 100 : 50;
}
cue.position = position;
}
function skipWhitespace() {
input = input.replace(/^\s+/, '');
} // 4.1 WebVTT cue timings.
skipWhitespace();
cue.startTime = consumeTimeStamp(); // (1) collect cue start time
skipWhitespace();
if (input.substr(0, 3) !== '-->') {
// (3) next characters must match '-->'
throw new Error("Malformed time stamp (time stamps must be separated by '-->'): " + oInput);
}
input = input.substr(3);
skipWhitespace();
cue.endTime = consumeTimeStamp(); // (5) collect cue end time
// 4.1 WebVTT cue settings list.
skipWhitespace();
consumeCueSettings(input, cue);
}
function fixLineBreaks(input) {
return input.replace(/<br(?: \/)?>/gi, '\n');
}
var VTTParser = /*#__PURE__*/function () {
function VTTParser() {
this.state = 'INITIAL';
this.buffer = '';
this.decoder = new StringDecoder();
this.regionList = [];
this.cue = null;
this.oncue = void 0;
this.onparsingerror = void 0;
this.onflush = void 0;
}
var _proto3 = VTTParser.prototype;
_proto3.parse = function parse(data) {
var _this = this; // If there is no data then we won't decode it, but will just try to parse
// whatever is in buffer already. This may occur in circumstances, for
// example when flush() is called.
if (data) {
// Try to decode the data that we received.
_this.buffer += _this.decoder.decode(data, {
stream: true
});
}
function collectNextLine() {
var buffer = _this.buffer;
var pos = 0;
buffer = fixLineBreaks(buffer);
while (pos < buffer.length && buffer[pos] !== '\r' && buffer[pos] !== '\n') {
++pos;
}
var line = buffer.substr(0, pos); // Advance the buffer early in case we fail below.
if (buffer[pos] === '\r') {
++pos;
}
if (buffer[pos] === '\n') {
++pos;
}
_this.buffer = buffer.substr(pos);
return line;
} // 3.2 WebVTT metadata header syntax
function parseHeader(input) {
parseOptions(input, function (k, v) {// switch (k) {
// case 'region':
// 3.3 WebVTT region metadata header syntax
// console.log('parse region', v);
// parseRegion(v);
// break;
// }
}, /:/);
} // 5.1 WebVTT file parsing.
try {
var line = '';
if (_this.state === 'INITIAL') {
// We can't start parsing until we have the first line.
if (!/\r\n|\n/.test(_this.buffer)) {
return this;
}
line = collectNextLine(); // strip of UTF-8 BOM if any
// https://en.wikipedia.org/wiki/Byte_order_mark#UTF-8
var m = line.match(/^()?WEBVTT([ \t].*)?$/);
if (!m || !m[0]) {
throw new Error('Malformed WebVTT signature.');
}
_this.state = 'HEADER';
}
var alreadyCollectedLine = false;
while (_this.buffer) {
// We can't parse a line until we have the full line.
if (!/\r\n|\n/.test(_this.buffer)) {
return this;
}
if (!alreadyCollectedLine) {
line = collectNextLine();
} else {
alreadyCollectedLine = false;
}
switch (_this.state) {
case 'HEADER':
// 13-18 - Allow a header (metadata) under the WEBVTT line.
if (/:/.test(line)) {
parseHeader(line);
} else if (!line) {
// An empty line terminates the header and starts the body (cues).
_this.state = 'ID';
}
continue;
case 'NOTE':
// Ignore NOTE blocks.
if (!line) {
_this.state = 'ID';
}
continue;
case 'ID':
// Check for the start of NOTE blocks.
if (/^NOTE($|[ \t])/.test(line)) {
_this.state = 'NOTE';
break;
} // 19-29 - Allow any number of line terminators, then initialize new cue values.
if (!line) {
continue;
}
_this.cue = new _vttcue__WEBPACK_IMPORTED_MODULE_0__["default"](0, 0, '');
_this.state = 'CUE'; // 30-39 - Check if self line contains an optional identifier or timing data.
if (line.indexOf('-->') === -1) {
_this.cue.id = line;
continue;
}
// Process line as start of a cue.
/* falls through */
case 'CUE':
// 40 - Collect cue timings and settings.
if (!_this.cue) {
_this.state = 'BADCUE';
continue;
}
try {
parseCue(line, _this.cue, _this.regionList);
} catch (e) {
// In case of an error ignore rest of the cue.
_this.cue = null;
_this.state = 'BADCUE';
continue;
}
_this.state = 'CUETEXT';
continue;
case 'CUETEXT':
{
var hasSubstring = line.indexOf('-->') !== -1; // 34 - If we have an empty line then report the cue.
// 35 - If we have the special substring '-->' then report the cue,
// but do not collect the line as we need to process the current
// one as a new cue.
if (!line || hasSubstring && (alreadyCollectedLine = true)) {
// We are done parsing self cue.
if (_this.oncue && _this.cue) {
_this.oncue(_this.cue);
}
_this.cue = null;
_this.state = 'ID';
continue;
}
if (_this.cue === null) {
continue;
}
if (_this.cue.text) {
_this.cue.text += '\n';
}
_this.cue.text += line;
}
continue;
case 'BADCUE':
// 54-62 - Collect and discard the remaining cue.
if (!line) {
_this.state = 'ID';
}
}
}
} catch (e) {
// If we are currently parsing a cue, report what we have.
if (_this.state === 'CUETEXT' && _this.cue && _this.oncue) {
_this.oncue(_this.cue);
}
_this.cue = null; // Enter BADWEBVTT state if header was not parsed correctly otherwise
// another exception occurred so enter BADCUE state.
_this.state = _this.state === 'INITIAL' ? 'BADWEBVTT' : 'BADCUE';
}
return this;
};
_proto3.flush = function flush() {
var _this = this;
try {
// Finish decoding the stream.
// _this.buffer += _this.decoder.decode();
// Synthesize the end of the current cue or region.
if (_this.cue || _this.state === 'HEADER') {
_this.buffer += '\n\n';
_this.parse();
} // If we've flushed, parsed, and we're still on the INITIAL state then
// that means we don't have enough of the stream to parse the first
// line.
if (_this.state === 'INITIAL' || _this.state === 'BADWEBVTT') {
throw new Error('Malformed WebVTT signature.');
}
} catch (e) {
if (_this.onparsingerror) {
_this.onparsingerror(e);
}
}
if (_this.onflush) {
_this.onflush();
}
return this;
};
return VTTParser;
}();
/***/ }),
/***/ "./src/utils/webvtt-parser.ts":
/*!************************************!*\
!*** ./src/utils/webvtt-parser.ts ***!
\************************************/
/*! exports provided: generateCueId, parseWebVTT */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "generateCueId", function() { return generateCueId; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parseWebVTT", function() { return parseWebVTT; });
/* harmony import */ var _home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./src/polyfills/number */ "./src/polyfills/number.ts");
/* harmony import */ var _vttparser__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./vttparser */ "./src/utils/vttparser.ts");
/* harmony import */ var _demux_id3__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../demux/id3 */ "./src/demux/id3.ts");
/* harmony import */ var _timescale_conversion__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./timescale-conversion */ "./src/utils/timescale-conversion.ts");
/* harmony import */ var _remux_mp4_remuxer__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../remux/mp4-remuxer */ "./src/remux/mp4-remuxer.ts");
var LINEBREAKS = /\r\n|\n\r|\n|\r/g; // String.prototype.startsWith is not supported in IE11
var startsWith = function startsWith(inputString, searchString, position) {
if (position === void 0) {
position = 0;
}
return inputString.substr(position, searchString.length) === searchString;
};
var cueString2millis = function cueString2millis(timeString) {
var ts = parseInt(timeString.substr(-3));
var secs = parseInt(timeString.substr(-6, 2));
var mins = parseInt(timeString.substr(-9, 2));
var hours = timeString.length > 9 ? parseInt(timeString.substr(0, timeString.indexOf(':'))) : 0;
if (!Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(ts) || !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(secs) || !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(mins) || !Object(_home_runner_work_hls_js_hls_js_src_polyfills_number__WEBPACK_IMPORTED_MODULE_0__["isFiniteNumber"])(hours)) {
throw Error("Malformed X-TIMESTAMP-MAP: Local:" + timeString);
}
ts += 1000 * secs;
ts += 60 * 1000 * mins;
ts += 60 * 60 * 1000 * hours;
return ts;
}; // From https://github.com/darkskyapp/string-hash
var hash = function hash(text) {
var hash = 5381;
var i = text.length;
while (i) {
hash = hash * 33 ^ text.charCodeAt(--i);
}
return (hash >>> 0).toString();
}; // Create a unique hash id for a cue based on start/end times and text.
// This helps timeline-controller to avoid showing repeated captions.
function generateCueId(startTime, endTime, text) {
return hash(startTime.toString()) + hash(endTime.toString()) + hash(text);
}
var calculateOffset = function calculateOffset(vttCCs, cc, presentationTime) {
var currCC = vttCCs[cc];
var prevCC = vttCCs[currCC.prevCC]; // This is the first discontinuity or cues have been processed since the last discontinuity
// Offset = current discontinuity time
if (!prevCC || !prevCC.new && currCC.new) {
vttCCs.ccOffset = vttCCs.presentationOffset = currCC.start;
currCC.new = false;
return;
} // There have been discontinuities since cues were last parsed.
// Offset = time elapsed
while ((_prevCC = prevCC) !== null && _prevCC !== void 0 && _prevCC.new) {
var _prevCC;
vttCCs.ccOffset += currCC.start - prevCC.start;
currCC.new = false;
currCC = prevCC;
prevCC = vttCCs[currCC.prevCC];
}
vttCCs.presentationOffset = presentationTime;
};
function parseWebVTT(vttByteArray, initPTS, timescale, vttCCs, cc, timeOffset, callBack, errorCallBack) {
var parser = new _vttparser__WEBPACK_IMPORTED_MODULE_1__["VTTParser"](); // Convert byteArray into string, replacing any somewhat exotic linefeeds with "\n", then split on that character.
// Uint8Array.prototype.reduce is not implemented in IE11
var vttLines = Object(_demux_id3__WEBPACK_IMPORTED_MODULE_2__["utf8ArrayToStr"])(new Uint8Array(vttByteArray)).trim().replace(LINEBREAKS, '\n').split('\n');
var cues = [];
var initPTS90Hz = Object(_timescale_conversion__WEBPACK_IMPORTED_MODULE_3__["toMpegTsClockFromTimescale"])(initPTS, timescale);
var cueTime = '00:00.000';
var timestampMapMPEGTS = 0;
var timestampMapLOCAL = 0;
var parsingError;
var inHeader = true;
var timestampMap = false;
parser.oncue = function (cue) {
// Adjust cue timing; clamp cues to start no earlier than - and drop cues that don't end after - 0 on timeline.
var currCC = vttCCs[cc];
var cueOffset = vttCCs.ccOffset; // Calculate subtitle PTS offset
var webVttMpegTsMapOffset = (timestampMapMPEGTS - initPTS90Hz) / 90000; // Update offsets for new discontinuities
if (currCC !== null && currCC !== void 0 && currCC.new) {
if (timestampMapLOCAL !== undefined) {
// When local time is provided, offset = discontinuity start time - local time
cueOffset = vttCCs.ccOffset = currCC.start;
} else {
calculateOffset(vttCCs, cc, webVttMpegTsMapOffset);
}
}
if (webVttMpegTsMapOffset) {
// If we have MPEGTS, offset = presentation time + discontinuity offset
cueOffset = webVttMpegTsMapOffset - vttCCs.presentationOffset;
}
if (timestampMap) {
var duration = cue.endTime - cue.startTime;
var startTime = Object(_remux_mp4_remuxer__WEBPACK_IMPORTED_MODULE_4__["normalizePts"])((cue.startTime + cueOffset - timestampMapLOCAL) * 90000, timeOffset * 90000) / 90000;
cue.startTime = startTime;
cue.endTime = startTime + duration;
} //trim trailing webvtt block whitespaces
var text = cue.text.trim(); // Fix encoding of special characters
cue.text = decodeURIComponent(encodeURIComponent(text)); // If the cue was not assigned an id from the VTT file (line above the content), create one.
if (!cue.id) {
cue.id = generateCueId(cue.startTime, cue.endTime, text);
}
if (cue.endTime > 0) {
cues.push(cue);
}
};
parser.onparsingerror = function (error) {
parsingError = error;
};
parser.onflush = function () {
if (parsingError) {
errorCallBack(parsingError);
return;
}
callBack(cues);
}; // Go through contents line by line.
vttLines.forEach(function (line) {
if (inHeader) {
// Look for X-TIMESTAMP-MAP in header.
if (startsWith(line, 'X-TIMESTAMP-MAP=')) {
// Once found, no more are allowed anyway, so stop searching.
inHeader = false;
timestampMap = true; // Extract LOCAL and MPEGTS.
line.substr(16).split(',').forEach(function (timestamp) {
if (startsWith(timestamp, 'LOCAL:')) {
cueTime = timestamp.substr(6);
} else if (startsWith(timestamp, 'MPEGTS:')) {
timestampMapMPEGTS = parseInt(timestamp.substr(7));
}
});
try {
// Convert cue time to seconds
timestampMapLOCAL = cueString2millis(cueTime) / 1000;
} catch (error) {
timestampMap = false;
parsingError = error;
} // Return without parsing X-TIMESTAMP-MAP line.
return;
} else if (line === '') {
inHeader = false;
}
} // Parse line by default.
parser.parse(line + '\n');
});
parser.flush();
}
/***/ }),
/***/ "./src/utils/xhr-loader.ts":
/*!*********************************!*\
!*** ./src/utils/xhr-loader.ts ***!
\*********************************/
/*! exports provided: default */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _utils_logger__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils/logger */ "./src/utils/logger.ts");
/* harmony import */ var _loader_load_stats__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../loader/load-stats */ "./src/loader/load-stats.ts");
var AGE_HEADER_LINE_REGEX = /^age:\s*[\d.]+\s*$/m;
var XhrLoader = /*#__PURE__*/function () {
function XhrLoader(config
/* HlsConfig */
) {
this.xhrSetup = void 0;
this.requestTimeout = void 0;
this.retryTimeout = void 0;
this.retryDelay = void 0;
this.config = null;
this.callbacks = null;
this.context = void 0;
this.loader = null;
this.stats = void 0;
this.xhrSetup = config ? config.xhrSetup : null;
this.stats = new _loader_load_stats__WEBPACK_IMPORTED_MODULE_1__["LoadStats"]();
this.retryDelay = 0;
}
var _proto = XhrLoader.prototype;
_proto.destroy = function destroy() {
this.callbacks = null;
this.abortInternal();
this.loader = null;
this.config = null;
};
_proto.abortInternal = function abortInternal() {
var loader = this.loader;
self.clearTimeout(this.requestTimeout);
self.clearTimeout(this.retryTimeout);
if (loader) {
loader.onreadystatechange = null;
loader.onprogress = null;
if (loader.readyState !== 4) {
this.stats.aborted = true;
loader.abort();
}
}
};
_proto.abort = function abort() {
var _this$callbacks;
this.abortInternal();
if ((_this$callbacks = this.callbacks) !== null && _this$callbacks !== void 0 && _this$callbacks.onAbort) {
this.callbacks.onAbort(this.stats, this.context, this.loader);
}
};
_proto.load = function load(context, config, callbacks) {
if (this.stats.loading.start) {
throw new Error('Loader can only be used once.');
}
this.stats.loading.start = self.performance.now();
this.context = context;
this.config = config;
this.callbacks = callbacks;
this.retryDelay = config.retryDelay;
this.loadInternal();
};
_proto.loadInternal = function loadInternal() {
var config = this.config,
context = this.context;
if (!config) {
return;
}
var xhr = this.loader = new self.XMLHttpRequest();
var stats = this.stats;
stats.loading.first = 0;
stats.loaded = 0;
var xhrSetup = this.xhrSetup;
try {
if (xhrSetup) {
try {
xhrSetup(xhr, context.url);
} catch (e) {
// fix xhrSetup: (xhr, url) => {xhr.setRequestHeader("Content-Language", "test");}
// not working, as xhr.setRequestHeader expects xhr.readyState === OPEN
xhr.open('GET', context.url, true);
xhrSetup(xhr, context.url);
}
}
if (!xhr.readyState) {
xhr.open('GET', context.url, true);
}
} catch (e) {
// IE11 throws an exception on xhr.open if attempting to access an HTTP resource over HTTPS
this.callbacks.onError({
code: xhr.status,
text: e.message
}, context, xhr);
return;
}
if (context.rangeEnd) {
xhr.setRequestHeader('Range', 'bytes=' + context.rangeStart + '-' + (context.rangeEnd - 1));
}
xhr.onreadystatechange = this.readystatechange.bind(this);
xhr.onprogress = this.loadprogress.bind(this);
xhr.responseType = context.responseType; // setup timeout before we perform request
self.clearTimeout(this.requestTimeout);
this.requestTimeout = self.setTimeout(this.loadtimeout.bind(this), config.timeout);
xhr.send();
};
_proto.readystatechange = function readystatechange() {
var context = this.context,
xhr = this.loader,
stats = this.stats;
if (!context || !xhr) {
return;
}
var readyState = xhr.readyState;
var config = this.config; // don't proceed if xhr has been aborted
if (stats.aborted) {
return;
} // >= HEADERS_RECEIVED
if (readyState >= 2) {
// clear xhr timeout and rearm it if readyState less than 4
self.clearTimeout(this.requestTimeout);
if (stats.loading.first === 0) {
stats.loading.first = Math.max(self.performance.now(), stats.loading.start);
}
if (readyState === 4) {
xhr.onreadystatechange = null;
xhr.onprogress = null;
var status = xhr.status; // http status between 200 to 299 are all successful
if (status >= 200 && status < 300) {
stats.loading.end = Math.max(self.performance.now(), stats.loading.first);
var data;
var len;
if (context.responseType === 'arraybuffer') {
data = xhr.response;
len = data.byteLength;
} else {
data = xhr.responseText;
len = data.length;
}
stats.loaded = stats.total = len;
if (!this.callbacks) {
return;
}
var onProgress = this.callbacks.onProgress;
if (onProgress) {
onProgress(stats, context, data, xhr);
}
if (!this.callbacks) {
return;
}
var response = {
url: xhr.responseURL,
data: data
};
this.callbacks.onSuccess(response, stats, context, xhr);
} else {
// if max nb of retries reached or if http status between 400 and 499 (such error cannot be recovered, retrying is useless), return error
if (stats.retry >= config.maxRetry || status >= 400 && status < 499) {
_utils_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].error(status + " while loading " + context.url);
this.callbacks.onError({
code: status,
text: xhr.statusText
}, context, xhr);
} else {
// retry
_utils_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].warn(status + " while loading " + context.url + ", retrying in " + this.retryDelay + "..."); // abort and reset internal state
this.abortInternal();
this.loader = null; // schedule retry
self.clearTimeout(this.retryTimeout);
this.retryTimeout = self.setTimeout(this.loadInternal.bind(this), this.retryDelay); // set exponential backoff
this.retryDelay = Math.min(2 * this.retryDelay, config.maxRetryDelay);
stats.retry++;
}
}
} else {
// readyState >= 2 AND readyState !==4 (readyState = HEADERS_RECEIVED || LOADING) rearm timeout as xhr not finished yet
self.clearTimeout(this.requestTimeout);
this.requestTimeout = self.setTimeout(this.loadtimeout.bind(this), config.timeout);
}
}
};
_proto.loadtimeout = function loadtimeout() {
_utils_logger__WEBPACK_IMPORTED_MODULE_0__["logger"].warn("timeout while loading " + this.context.url);
var callbacks = this.callbacks;
if (callbacks) {
this.abortInternal();
callbacks.onTimeout(this.stats, this.context, this.loader);
}
};
_proto.loadprogress = function loadprogress(event) {
var stats = this.stats;
stats.loaded = event.loaded;
if (event.lengthComputable) {
stats.total = event.total;
}
};
_proto.getCacheAge = function getCacheAge() {
var result = null;
if (this.loader && AGE_HEADER_LINE_REGEX.test(this.loader.getAllResponseHeaders())) {
var ageHeader = this.loader.getResponseHeader('age');
result = ageHeader ? parseFloat(ageHeader) : null;
}
return result;
};
return XhrLoader;
}();
/* harmony default export */ __webpack_exports__["default"] = (XhrLoader);
/***/ })
/******/ })["default"];
});
//# sourceMappingURL=hls.js.map |
import{F as t}from"./formatter-1ac8f9c0.js";import{n as e}from"./number-8441f50e.js";import"./index-53ebe934.js";export default class extends t{static get formatter(){return e}}
|
/**
* @license Highcharts Gantt JS v10.0.0 (2022-03-07)
*
* StaticScale
*
* (c) 2016-2021 Torstein Honsi, Lars A. V. Cabrera
*
* License: www.highcharts.com/license
*/
(function (factory) {
if (typeof module === 'object' && module.exports) {
factory['default'] = factory;
module.exports = factory;
} else if (typeof define === 'function' && define.amd) {
define('highcharts/modules/static-scale', ['highcharts'], function (Highcharts) {
factory(Highcharts);
factory.Highcharts = Highcharts;
return factory;
});
} else {
factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
}
}(function (Highcharts) {
'use strict';
var _modules = Highcharts ? Highcharts._modules : {};
function _registerModule(obj, path, args, fn) {
if (!obj.hasOwnProperty(path)) {
obj[path] = fn.apply(null, args);
if (typeof CustomEvent === 'function') {
window.dispatchEvent(
new CustomEvent(
'HighchartsModuleLoaded',
{ detail: { path: path, module: obj[path] }
})
);
}
}
}
_registerModule(_modules, 'Extensions/StaticScale.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Utilities.js']], function (Axis, Chart, U) {
/* *
*
* (c) 2016-2021 Torstein Honsi, Lars Cabrera
*
* License: www.highcharts.com/license
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
var addEvent = U.addEvent,
defined = U.defined,
isNumber = U.isNumber,
pick = U.pick;
/* eslint-disable no-invalid-this */
/**
* For vertical axes only. Setting the static scale ensures that each tick unit
* is translated into a fixed pixel height. For example, setting the static
* scale to 24 results in each Y axis category taking up 24 pixels, and the
* height of the chart adjusts. Adding or removing items will make the chart
* resize.
*
* @sample gantt/xrange-series/demo/
* X-range series with static scale
*
* @type {number}
* @default 50
* @since 6.2.0
* @product gantt
* @apioption yAxis.staticScale
*/
addEvent(Axis, 'afterSetOptions', function () {
var chartOptions = this.chart.options.chart;
if (!this.horiz &&
isNumber(this.options.staticScale) &&
(!chartOptions.height ||
(chartOptions.scrollablePlotArea &&
chartOptions.scrollablePlotArea.minHeight))) {
this.staticScale = this.options.staticScale;
}
});
Chart.prototype.adjustHeight = function () {
if (this.redrawTrigger !== 'adjustHeight') {
(this.axes || []).forEach(function (axis) {
var chart = axis.chart,
animate = !!chart.initiatedScale &&
chart.options.animation,
staticScale = axis.options.staticScale,
height,
diff;
if (axis.staticScale && defined(axis.min)) {
height = pick(axis.brokenAxis && axis.brokenAxis.unitLength, axis.max + axis.tickInterval - axis.min) * staticScale;
// Minimum height is 1 x staticScale.
height = Math.max(height, staticScale);
diff = height - chart.plotHeight;
if (!chart.scrollablePixelsY && Math.abs(diff) >= 1) {
chart.plotHeight = height;
chart.redrawTrigger = 'adjustHeight';
chart.setSize(void 0, chart.chartHeight + diff, animate);
}
// Make sure clip rects have the right height before initial
// animation.
axis.series.forEach(function (series) {
var clipRect = series.sharedClipKey &&
chart.sharedClips[series.sharedClipKey];
if (clipRect) {
clipRect.attr(chart.inverted ? {
width: chart.plotHeight
} : {
height: chart.plotHeight
});
}
});
}
});
this.initiatedScale = true;
}
this.redrawTrigger = null;
};
addEvent(Chart, 'render', Chart.prototype.adjustHeight);
});
_registerModule(_modules, 'masters/modules/static-scale.src.js', [], function () {
});
})); |
/**
* [Partial implementation[ A proposed implementation of the `Promise.all` function,
* that tries to resolve to a `result` which is the same type as the built-in iterable given as an input.
* If it can't match the type, it defaults to an array.
*
* @see https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols#Builtin_iterables
* Note: this is specific to the Q promise library that babel 6 uses.
*
* @param {<Iterator>} iterator Contains promises
* @return {Promise} Promise that resolves if all promises in `iterator` resolve, else rejects immediately (as per spec)
*/
export default function (iterator) {
let hasDefaultIterableBehavior = function (iterator) {
return true; // Not implemented yet
};
return Promise.all(iterator).then( function (result) {
var payload = result;
if (hasDefaultIterableBehavior(iterator)) {
if (Object.getPrototypeOf(iterator) === Map.prototype) {
var index = 0,
keys = iterator.keys(),
payload = new Map();
for (let k of keys) {
let v = result[ index++ ];
payload.set( k, v );
}
} else if (Object.getPrototypeOf(iterator) === TypedArray.prototype) {
throw new Error("promise-all-match-iterable - TypedArray not handled yet");
} else if (Object.getPrototypeOf(iterator) === Set.prototype) {
throw new Error("promise-all-match-iterable - Set not handled yet");
}
}
return payload;
});
}; |
'use strict'
angular.module('filter.fromNow', []).filter('fromNow', function() {
return function(dateString) {
return moment(dateString).fromNow();
};
});
// filter to have all dates with same time zone.
angular.module('filter.moment', []).filter('moment', function() {
return function(input, format) {
// no need to parseint input as input is already with ISO format.
return moment(input).utc().format(format);
};
});
|
/**
* plugin admin area javascript
*/
(function($){$(function () {
if ( ! $('body.wpallimport-plugin').length) return; // do not execute any code if we are not on plugin page
var pmai_repeater_clone = function($parent){
var $clone = $parent.find('tbody:first').children('.row-clone:first').clone();
var $number = parseInt($parent.find('tbody:first').children().length);
$clone.removeClass('row-clone').addClass('row').find('td.order').html($number);
$clone.find('.switcher').each(function(){
$(this).attr({'id':$(this).attr('id').replace('ROWNUMBER', $number)});
});
$clone.find('.chooser_label').each(function(){
$(this).attr({'for':$(this).attr('for').replace('ROWNUMBER', $number)});
});
$clone.find('div[class^=switcher-target]').each(function(){
$(this).attr({'class':$(this).attr('class').replace('ROWNUMBER', $number)});
});
$clone.find('input, select, textarea').each(function(){
var name = $(this).attr('name');
if (name != undefined) $(this).attr({'name':$(this).attr('name').replace('ROWNUMBER', $number)});
});
$parent.find('.acf-input-table:first').find('tbody:first').append($clone);
$parent.find('tr.row').find('.sortable').each(function(){
if ( ! $(this).hasClass('ui-sortable') && ! $(this).parents('tr.row-clone').length ){
$(this).pmxi_nestedSortable({
handle: 'div',
items: 'li.dragging',
toleranceElement: '> div',
update: function () {
$(this).parents('td:first').find('.hierarhy-output').val(window.JSON.stringify($(this).pmxi_nestedSortable('toArray', {startDepthCount: 0})));
if ($(this).parents('td:first').find('input:first').val() == '') $(this).parents('td:first').find('.hierarhy-output').val('');
}
});
}
});
};
$('form.wpallimport-template:visible').find('.repeater').find('.add-row-end').live('click', function(){
var $parent = $(this).parents('.repeater:first');
pmai_repeater_clone($parent);
});
$('.add_layout select').live('click', function(){
if ($(this).val() == "" || $(this).val() == "Select Layout") return;
var $parent = $(this).parents('.acf-flexible-content:first');
var $clone = $parent.children('.clones:first').children('div.layout[data-layout = ' + $(this).val() + ']').clone();
var $number = parseInt($parent.children('.values:first').children().length) + 1;
$clone.find('.fc-layout-order:first').html($number);
$clone.find('.switcher').each(function(){
$(this).attr({'id':$(this).attr('id').replace('ROWNUMBER', $number)});
});
$clone.find('.chooser_label').each(function(){
$(this).attr({'for':$(this).attr('for').replace('ROWNUMBER', $number)});
});
$clone.find('div[class^=switcher-target]').each(function(){
$(this).attr({'class':$(this).attr('class').replace('ROWNUMBER', $number)});
});
$clone.find('input, select, textarea').each(function(){
var name = $(this).attr('name');
if (name != undefined) $(this).attr({'name':$(this).attr('name').replace('ROWNUMBER', $number)});
});
$parent.children('div.values:first').append($clone);
});
$('.delete_layout').live('click', function(){
var $parent = $(this).parents('.acf-flexible-content:first');
$parent.children('.values:first').children(':last').remove();
});
$('.delete_row').live('click', function(){
var $parent = $(this).parents('.repeater:first');
$parent.find('tbody:first').children('.row:last').remove();
});
var pmai_get_acf_group = function(ths){
var request = {
action:'get_acf',
security: wp_all_import_security,
acf: ths.attr('rel')
};
if (typeof import_id != "undefined") request.id = import_id;
var $ths = ths.parents('.pmai_options:first');
$ths.find('.acf_groups').prepend('<div class="pmai_preloader"></div>');
$('.pmai_acf_group').attr('disabled', 'disabled');
$.ajax({
type: 'GET',
url: ajaxurl,
data: request,
success: function(response) {
$('.pmai_acf_group').removeAttr('disabled');
$ths.find('.pmai_preloader').remove();
$ths.find('.acf_groups').prepend(response.html);
pmai_init($ths.find('.acf_signle_group:first'));
// swither show/hide logic
$ths.find('.acf_groups').find('input.switcher').change();
},
error: function(jqXHR, textStatus){
$('.pmai_acf_group').removeAttr('disabled');
$ths.find('.pmai_preloader').remove();
alert('Something went wrong. ' + textStatus );
},
dataType: "json"
});
}
var pmai_reset_acf_groups = function(){
$('.pmai_options').find('.acf_signle_group').remove();
$('.pmai_options:visible').find('.pmai_acf_group:checked').each(function(){
pmai_get_acf_group($(this));
});
}
pmai_reset_acf_groups();
$('.pmxi_plugin').find('.nav-tab').click(function(){
pmai_reset_acf_groups();
});
$('.pmai_acf_group').live('change', function(){
var acf = $(this).attr('rel');
if ($(this).is(':checked')){
// if requsted ACF group doesn't exists
if ( ! $(this).parents('.pmai_options:first').find('.acf_signle_group[rel=' + acf + ']').length){
pmai_get_acf_group($(this));
}
}
else{
if (confirm("Confirm removal?"))
$(this).parents('.pmai_options:first').find('.acf_signle_group[rel=' + acf + ']').remove();
else
$(this).attr('checked','checked');
}
});
function pmai_init(ths){
ths.find('input.datetimepicker').datetimepicker({
dateFormat: 'dd/mm/yy',
timeFormat: 'hh:mm TT',
ampm: true
});
ths.find('input.datepicker').datepicker();
ths.find('.sortable').each(function(){
if ( ! $(this).parents('tr.row-clone').length ){
$(this).pmxi_nestedSortable({
handle: 'div',
items: 'li.dragging',
toleranceElement: '> div',
update: function () {
$(this).parents('td:first').find('.hierarhy-output').val(window.JSON.stringify($(this).pmxi_nestedSortable('toArray', {startDepthCount: 0})));
if ($(this).parents('td:first').find('input:first').val() == '') $(this).parents('td:first').find('.hierarhy-output').val('');
}
});
}
});
}
$('.acf_signle_group').find('.switcher').live('click', function(){
$(this).parents('div.acf-input-wrap:first').find('.sortable').each(function(){
if ( ! $(this).hasClass('ui-sortable') && ! $(this).parents('tr.row-clone').length ){
$(this).pmxi_nestedSortable({
handle: 'div',
items: 'li.dragging',
toleranceElement: '> div',
update: function () {
$(this).parents('td:first').find('.hierarhy-output').val(window.JSON.stringify($(this).pmxi_nestedSortable('toArray', {startDepthCount: 0})));
if ($(this).parents('td:first').find('input:first').val() == '') $(this).parents('td:first').find('.hierarhy-output').val('');
}
});
}
});
});
$('.variable_repeater_mode').live('change', function(){
// if variable mode
if ($(this).is(':checked') && ($(this).val() == 'yes' || $(this).val() == 'csv')){
var $parent = $(this).parents('.repeater:first');
$parent.find('tbody:first').children('.row:not(:first)').remove();
if ( ! $parent.find('tbody:first').children('.row').length) pmai_repeater_clone($parent);
}
});
});})(jQuery);
|
import {Loop} from '../../core/Loop';
import {EventsPatchModule} from './EventsPatchModule';
/**
* @class ControlsModule
* @category modules/app
* @param {Object} [params]
* @memberof module:modules/app
* @example <caption> Creating a rendering module and passing it to App's modules</caption>
* new App([
* new ElementModule(),
* new SceneModule(),
* new DefineModule('camera', new WHS.PerspectiveCamera({
* position: new THREE.Vector3(0, 6, 18),
* far: 10000
* })),
* new RenderingModule(),
* new ControlsModule.from(new THREE.TrackballControls())
* ]);
*/
export class ControlsModule {
static from(controls) {
return new ControlsModule({controls});
}
constructor(params = {}) {
this.params = Object.assign({
controls: false,
fix: controls => controls,
update(c) {
this.controls.update(c.getDelta());
}
}, params);
this.controls = this.params.controls;
this.update = this.params.update;
}
manager(manager) {
manager.define('controls');
manager.require('events', () => new EventsPatchModule());
}
/**
* @method setControls
* @description Set working controls
* @param {Object} controls Working three.js controls object.
* @return {this}
* @memberof module:modules/app.ControlsModule
*/
setControls(controls) {
this.controls = controls;
return this;
}
/**
* @method setUpdate
* @description Set controls update function
* @param {Function} update Update function
* @return {this}
* @memberof module:modules/app.ControlsModule
*/
setUpdate(update) {
this.update = update;
return this;
}
integrate(self) {
self.updateLoop = new Loop(self.update.bind(self));
self.updateLoop.start(this);
}
}
|
import * as React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<path d="M12 13.5c-2.33 0-4.31 1.46-5.11 3.5h10.22c-.8-2.04-2.78-3.5-5.11-3.5zM7.82 12l1.06-1.06L9.94 12 11 10.94 9.94 9.88 11 8.82 9.94 7.76 8.88 8.82 7.82 7.76 6.76 8.82l1.06 1.06-1.06 1.06zm4.17-10C6.47 2 2 6.47 2 12s4.47 10 9.99 10S22 17.53 22 12 17.52 2 11.99 2zM12 20c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8zm4.18-12.24l-1.06 1.06-1.06-1.06L13 8.82l1.06 1.06L13 10.94 14.06 12l1.06-1.06L16.18 12l1.06-1.06-1.06-1.06 1.06-1.06z" />
, 'SentimentVeryDissatisfiedSharp');
|
/* eslint-env browser, jquery */
/* global _ */
// Inject line numbers for sync scroll.
import markdownitContainer from 'markdown-it-container'
import { md } from '../extra'
import modeType from './modeType'
import appState from './appState'
import { renderCSVPreview } from './renderer/csvpreview'
import { parseFenceCodeParams } from './markdown/utils'
function addPart (tokens, idx) {
if (tokens[idx].map && tokens[idx].level === 0) {
const startline = tokens[idx].map[0] + 1
const endline = tokens[idx].map[1]
tokens[idx].attrJoin('class', 'part')
tokens[idx].attrJoin('data-startline', startline)
tokens[idx].attrJoin('data-endline', endline)
}
}
md.renderer.rules.blockquote_open = function (tokens, idx, options, env, self) {
tokens[idx].attrJoin('class', 'raw')
addPart(tokens, idx)
return self.renderToken(...arguments)
}
md.renderer.rules.table_open = function (tokens, idx, options, env, self) {
addPart(tokens, idx)
return self.renderToken(...arguments)
}
const defaultImageRender = md.renderer.rules.image
md.renderer.rules.image = function (tokens, idx, options, env, self) {
tokens[idx].attrJoin('class', 'md-image')
return defaultImageRender(...arguments)
}
md.renderer.rules.bullet_list_open = function (tokens, idx, options, env, self) {
addPart(tokens, idx)
return self.renderToken(...arguments)
}
md.renderer.rules.list_item_open = function (tokens, idx, options, env, self) {
tokens[idx].attrJoin('class', 'raw')
if (tokens[idx].map) {
const startline = tokens[idx].map[0] + 1
const endline = tokens[idx].map[1]
tokens[idx].attrJoin('data-startline', startline)
tokens[idx].attrJoin('data-endline', endline)
}
return self.renderToken(...arguments)
}
md.renderer.rules.ordered_list_open = function (tokens, idx, options, env, self) {
addPart(tokens, idx)
return self.renderToken(...arguments)
}
md.renderer.rules.link_open = function (tokens, idx, options, env, self) {
addPart(tokens, idx)
return self.renderToken(...arguments)
}
md.renderer.rules.paragraph_open = function (tokens, idx, options, env, self) {
addPart(tokens, idx)
return self.renderToken(...arguments)
}
md.renderer.rules.heading_open = function (tokens, idx, options, env, self) {
tokens[idx].attrJoin('class', 'raw')
addPart(tokens, idx)
return self.renderToken(...arguments)
}
md.renderer.rules.fence = (tokens, idx, options, env, self) => {
const token = tokens[idx]
const info = token.info ? md.utils.unescapeAll(token.info).trim() : ''
let langName = ''
let highlighted
if (info) {
langName = info.split(/\s+/g)[0]
if (langName === 'csvpreview') {
const params = parseFenceCodeParams(info)
let attr = ''
if (tokens[idx].map && tokens[idx].level === 0) {
const startline = tokens[idx].map[0] + 1
const endline = tokens[idx].map[1]
attr = `class="part" data-startline="${startline}" data-endline="${endline}"`
}
return renderCSVPreview(token.content, params, attr)
}
if (/!$/.test(info)) token.attrJoin('class', 'wrap')
token.attrJoin('class', options.langPrefix + langName.replace(/=$|=\d+$|=\+$|!$|=!/, ''))
token.attrJoin('class', 'hljs')
token.attrJoin('class', 'raw')
}
if (options.highlight) {
highlighted = options.highlight(token.content, info) || md.utils.escapeHtml(token.content)
} else {
highlighted = md.utils.escapeHtml(token.content)
}
if (highlighted.indexOf('<pre') === 0) {
return `${highlighted}\n`
}
if (tokens[idx].map && tokens[idx].level === 0) {
const startline = tokens[idx].map[0] + 1
const endline = tokens[idx].map[1]
return `<pre class="part" data-startline="${startline}" data-endline="${endline}"><code${self.renderAttrs(token)}>${highlighted}</code></pre>\n`
}
return `<pre><code${self.renderAttrs(token)}>${highlighted}</code></pre>\n`
}
md.renderer.rules.code_block = (tokens, idx, options, env, self) => {
if (tokens[idx].map && tokens[idx].level === 0) {
const startline = tokens[idx].map[0] + 1
const endline = tokens[idx].map[1]
return `<pre class="part" data-startline="${startline}" data-endline="${endline}"><code>${md.utils.escapeHtml(tokens[idx].content)}</code></pre>\n`
}
return `<pre><code>${md.utils.escapeHtml(tokens[idx].content)}</code></pre>\n`
}
function renderContainer (tokens, idx, options, env, self) {
tokens[idx].attrJoin('role', 'alert')
tokens[idx].attrJoin('class', 'alert')
tokens[idx].attrJoin('class', `alert-${tokens[idx].info.trim()}`)
addPart(tokens, idx)
return self.renderToken(...arguments)
}
md.use(markdownitContainer, 'success', { render: renderContainer })
md.use(markdownitContainer, 'info', { render: renderContainer })
md.use(markdownitContainer, 'warning', { render: renderContainer })
md.use(markdownitContainer, 'danger', { render: renderContainer })
md.use(markdownitContainer, 'spoiler', {
validate: function (params) {
return params.trim().match(/^spoiler(\s+.*)?$/)
},
render: function (tokens, idx) {
const m = tokens[idx].info.trim().match(/^spoiler(\s+.*)?$/)
if (tokens[idx].nesting === 1) {
// opening tag
const startline = tokens[idx].map[0] + 1
const endline = tokens[idx].map[1]
const partClass = `class="part raw" data-startline="${startline}" data-endline="${endline}"`
const summary = m[1] && m[1].trim()
if (summary) {
return `<details ${partClass}><summary>${md.renderInline(summary)}</summary>\n`
} else {
return `<details ${partClass}>\n`
}
} else {
// closing tag
return '</details>\n'
}
}
})
window.preventSyncScrollToEdit = false
window.preventSyncScrollToView = false
const editScrollThrottle = 5
const viewScrollThrottle = 5
const buildMapThrottle = 100
let viewScrolling = false
let editScrolling = false
let editArea = null
let viewArea = null
let markdownArea = null
let editor
export function setupSyncAreas (edit, view, markdown, _editor) {
editArea = edit
viewArea = view
markdownArea = markdown
editor = _editor
editArea.on('scroll', _.throttle(syncScrollToView, editScrollThrottle))
viewArea.on('scroll', _.throttle(syncScrollToEdit, viewScrollThrottle))
}
let scrollMap, lineHeightMap, viewTop, viewBottom
export function clearMap () {
scrollMap = null
lineHeightMap = null
viewTop = null
viewBottom = null
}
window.viewAjaxCallback = clearMap
const buildMap = _.throttle(buildMapInner, buildMapThrottle)
// Build offsets for each line (lines can be wrapped)
// That's a bit dirty to process each line everytime, but ok for demo.
// Optimizations are required only for big texts.
function buildMapInner (callback) {
if (!viewArea || !markdownArea) return
let i, pos, a, b, acc
const offset = viewArea.scrollTop() - viewArea.offset().top
const _scrollMap = []
const nonEmptyList = []
const _lineHeightMap = []
viewTop = 0
viewBottom = viewArea[0].scrollHeight - viewArea.height()
acc = 0
const lines = editor.getValue().split('\n')
const lineHeight = editor.defaultTextHeight()
for (i = 0; i < lines.length; i++) {
const str = lines[i]
_lineHeightMap.push(acc)
if (str.length === 0) {
acc++
continue
}
const h = editor.heightAtLine(i + 1) - editor.heightAtLine(i)
acc += Math.round(h / lineHeight)
}
_lineHeightMap.push(acc)
const linesCount = acc
for (i = 0; i < linesCount; i++) {
_scrollMap.push(-1)
}
nonEmptyList.push(0)
// make the first line go top
_scrollMap[0] = viewTop
const parts = markdownArea.find('.part').toArray()
for (i = 0; i < parts.length; i++) {
const $el = $(parts[i])
let t = $el.attr('data-startline') - 1
if (t === '') {
return
}
t = _lineHeightMap[t]
if (t !== 0 && t !== nonEmptyList[nonEmptyList.length - 1]) {
nonEmptyList.push(t)
}
_scrollMap[t] = Math.round($el.offset().top + offset - 10)
}
nonEmptyList.push(linesCount)
_scrollMap[linesCount] = viewArea[0].scrollHeight
pos = 0
for (i = 1; i < linesCount; i++) {
if (_scrollMap[i] !== -1) {
pos++
continue
}
a = nonEmptyList[pos]
b = nonEmptyList[pos + 1]
_scrollMap[i] = Math.round((_scrollMap[b] * (i - a) + _scrollMap[a] * (b - i)) / (b - a))
}
_scrollMap[0] = 0
scrollMap = _scrollMap
lineHeightMap = _lineHeightMap
if (window.loaded && callback) callback()
}
// sync view scroll progress to edit
let viewScrollingTimer = null
export function syncScrollToEdit (event, preventAnimate) {
if (appState.currentMode !== modeType.both || !appState.syncscroll || !editArea) return
if (window.preventSyncScrollToEdit) {
if (typeof window.preventSyncScrollToEdit === 'number') {
window.preventSyncScrollToEdit--
} else {
window.preventSyncScrollToEdit = false
}
return
}
if (!scrollMap || !lineHeightMap) {
buildMap(() => {
syncScrollToEdit(event, preventAnimate)
})
return
}
if (editScrolling) return
const scrollTop = viewArea[0].scrollTop
let lineIndex = 0
for (let i = 0, l = scrollMap.length; i < l; i++) {
if (scrollMap[i] > scrollTop) {
break
} else {
lineIndex = i
}
}
let lineNo = 0
let lineDiff = 0
for (let i = 0, l = lineHeightMap.length; i < l; i++) {
if (lineHeightMap[i] > lineIndex) {
break
} else {
lineNo = lineHeightMap[i]
lineDiff = lineHeightMap[i + 1] - lineNo
}
}
let posTo = 0
let topDiffPercent = 0
let posToNextDiff = 0
const scrollInfo = editor.getScrollInfo()
const textHeight = editor.defaultTextHeight()
const preLastLineHeight = scrollInfo.height - scrollInfo.clientHeight - textHeight
const preLastLineNo = Math.round(preLastLineHeight / textHeight)
const preLastLinePos = scrollMap[preLastLineNo]
if (scrollInfo.height > scrollInfo.clientHeight && scrollTop >= preLastLinePos) {
posTo = preLastLineHeight
topDiffPercent = (scrollTop - preLastLinePos) / (viewBottom - preLastLinePos)
posToNextDiff = textHeight * topDiffPercent
posTo += Math.ceil(posToNextDiff)
} else {
posTo = lineNo * textHeight
topDiffPercent = (scrollTop - scrollMap[lineNo]) / (scrollMap[lineNo + lineDiff] - scrollMap[lineNo])
posToNextDiff = textHeight * lineDiff * topDiffPercent
posTo += Math.ceil(posToNextDiff)
}
if (preventAnimate) {
editArea.scrollTop(posTo)
} else {
const posDiff = Math.abs(scrollInfo.top - posTo)
var duration = posDiff / 50
duration = duration >= 100 ? duration : 100
editArea.stop(true, true).animate({
scrollTop: posTo
}, duration, 'linear')
}
viewScrolling = true
clearTimeout(viewScrollingTimer)
viewScrollingTimer = setTimeout(viewScrollingTimeoutInner, duration * 1.5)
}
function viewScrollingTimeoutInner () {
viewScrolling = false
}
// sync edit scroll progress to view
let editScrollingTimer = null
export function syncScrollToView (event, preventAnimate) {
if (appState.currentMode !== modeType.both || !appState.syncscroll || !viewArea) return
if (window.preventSyncScrollToView) {
if (typeof preventSyncScrollToView === 'number') {
window.preventSyncScrollToView--
} else {
window.preventSyncScrollToView = false
}
return
}
if (!scrollMap || !lineHeightMap) {
buildMap(() => {
syncScrollToView(event, preventAnimate)
})
return
}
if (viewScrolling) return
let posTo
let topDiffPercent, posToNextDiff
const scrollInfo = editor.getScrollInfo()
const textHeight = editor.defaultTextHeight()
const lineNo = Math.floor(scrollInfo.top / textHeight)
// if reach the last line, will start lerp to the bottom
const diffToBottom = (scrollInfo.top + scrollInfo.clientHeight) - (scrollInfo.height - textHeight)
if (scrollInfo.height > scrollInfo.clientHeight && diffToBottom > 0) {
topDiffPercent = diffToBottom / textHeight
posTo = scrollMap[lineNo + 1]
posToNextDiff = (viewBottom - posTo) * topDiffPercent
posTo += Math.floor(posToNextDiff)
} else {
topDiffPercent = (scrollInfo.top % textHeight) / textHeight
posTo = scrollMap[lineNo]
posToNextDiff = (scrollMap[lineNo + 1] - posTo) * topDiffPercent
posTo += Math.floor(posToNextDiff)
}
if (preventAnimate) {
viewArea.scrollTop(posTo)
} else {
const posDiff = Math.abs(viewArea.scrollTop() - posTo)
var duration = posDiff / 50
duration = duration >= 100 ? duration : 100
viewArea.stop(true, true).animate({
scrollTop: posTo
}, duration, 'linear')
}
editScrolling = true
clearTimeout(editScrollingTimer)
editScrollingTimer = setTimeout(editScrollingTimeoutInner, duration * 1.5)
}
function editScrollingTimeoutInner () {
editScrolling = false
}
|
var Message = function() {
this._isAcknowledged = undefined;
}
Message.prototype.acknowledge = function() {
this._isAcknowledged = true;
this._ack(null, true);
}
Message.prototype.reject = function(why) {
if(this._isAcknowledged !== true) {
this._isAcknowledged = false;
this._ack(why, false);
}
}
module.exports = Message; |
var paths = require('../options/paths.js');
var express = require('express');
module.exports = function (gulp) {
gulp.task('preview', function () {
var app = express();
app.use(express.static("./www"));
app.listen(8080);
console.log("Web server listening on http://127.0.0.1:8080");
});
} |
/**
* This router is applied to the
* /subscribers base url in app.js
*/
var cwd = process.cwd();
var express = require('express');
var router = express.Router();
var smsSubcriberService = require(cwd + '/services/smsSubscriber');
var formatter = require(cwd + "/lib/formatter")
router.post("/", function(req, res){
var phone = req.body.phone;
smsSubcriberService.addSubscriber(phone, function(err, rslt){
if (!err)
return res.json(rslt);
console.error(err);
switch (err.type) {
case "BAD_PARAM":
case "DUPLICATE_PARAM":
return res.status(400).json({
error: true,
message: err.message
});
break;
default:
return res.status(500).json({
error: true,
message: "Internal Server Error"
});
break;
}
})
})
router.delete("/:phone", function(req, res){
var phone = req.params.phone;
smsSubcriberService.removeSubscriber(phone, function(err, rslt){
if (!err)
return res.json(rslt);
console.error(err);
switch(err.type) {
case "NOT_FOUND":
return res.status(404).json({
error: true,
message: err.message
});
break;
default:
return res.status(500).json({
error: true,
message: "Internal Server Error"
});
break;
}
})
})
module.exports = router; |
"use strict";
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var e_1, _a;
exports.__esModule = true;
var util_1 = require("../util");
var RBY = {
Abra: {
types: ['Psychic'],
bs: { hp: 25, at: 20, df: 15, sp: 90, sl: 105 },
weightkg: 19.5,
nfe: true
},
Aerodactyl: {
types: ['Rock', 'Flying'],
bs: { hp: 80, at: 105, df: 65, sp: 130, sl: 60 },
weightkg: 59
},
Alakazam: {
types: ['Psychic'],
bs: { hp: 55, at: 50, df: 45, sp: 120, sl: 135 },
weightkg: 48
},
Arbok: { types: ['Poison'], bs: { hp: 60, at: 85, df: 69, sp: 80, sl: 65 }, weightkg: 65 },
Arcanine: {
types: ['Fire'],
bs: { hp: 90, at: 110, df: 80, sp: 95, sl: 80 },
weightkg: 155
},
Articuno: {
types: ['Ice', 'Flying'],
bs: { hp: 90, at: 85, df: 100, sp: 85, sl: 125 },
weightkg: 55.4
},
Beedrill: {
types: ['Bug', 'Poison'],
bs: { hp: 65, at: 80, df: 40, sp: 75, sl: 45 },
weightkg: 29.5
},
Bellsprout: {
types: ['Grass', 'Poison'],
bs: { hp: 50, at: 75, df: 35, sp: 40, sl: 70 },
weightkg: 4,
nfe: true
},
Blastoise: {
types: ['Water'],
bs: { hp: 79, at: 83, df: 100, sp: 78, sl: 85 },
weightkg: 85.5
},
Bulbasaur: {
types: ['Grass', 'Poison'],
bs: { hp: 45, at: 49, df: 49, sp: 45, sl: 65 },
weightkg: 6.9,
nfe: true
},
Butterfree: {
types: ['Bug', 'Flying'],
bs: { hp: 60, at: 45, df: 50, sp: 70, sl: 80 },
weightkg: 32
},
Caterpie: {
types: ['Bug'],
bs: { hp: 45, at: 30, df: 35, sp: 45, sl: 20 },
weightkg: 2.9,
nfe: true
},
Chansey: {
types: ['Normal'],
bs: { hp: 250, at: 5, df: 5, sp: 50, sl: 105 },
weightkg: 34.6
},
Charizard: {
types: ['Fire', 'Flying'],
bs: { hp: 78, at: 84, df: 78, sp: 100, sl: 85 },
weightkg: 90.5
},
Charmander: {
types: ['Fire'],
bs: { hp: 39, at: 52, df: 43, sp: 65, sl: 50 },
weightkg: 8.5,
nfe: true
},
Charmeleon: {
types: ['Fire'],
bs: { hp: 58, at: 64, df: 58, sp: 80, sl: 65 },
weightkg: 19,
nfe: true
},
Clefable: { types: ['Normal'], bs: { hp: 95, at: 70, df: 73, sp: 60, sl: 85 }, weightkg: 40 },
Clefairy: {
types: ['Normal'],
bs: { hp: 70, at: 45, df: 48, sp: 35, sl: 60 },
weightkg: 7.5,
nfe: true
},
Cloyster: {
types: ['Water', 'Ice'],
bs: { hp: 50, at: 95, df: 180, sp: 70, sl: 85 },
weightkg: 132.5
},
Cubone: {
types: ['Ground'],
bs: { hp: 50, at: 50, df: 95, sp: 35, sl: 40 },
weightkg: 6.5,
nfe: true
},
Dewgong: {
types: ['Water', 'Ice'],
bs: { hp: 90, at: 70, df: 80, sp: 70, sl: 95 },
weightkg: 120
},
Diglett: {
types: ['Ground'],
bs: { hp: 10, at: 55, df: 25, sp: 95, sl: 45 },
weightkg: 0.8,
nfe: true
},
Ditto: { types: ['Normal'], bs: { hp: 48, at: 48, df: 48, sp: 48, sl: 48 }, weightkg: 4 },
Dodrio: {
types: ['Normal', 'Flying'],
bs: { hp: 60, at: 110, df: 70, sp: 100, sl: 60 },
weightkg: 85.2
},
Doduo: {
types: ['Normal', 'Flying'],
bs: { hp: 35, at: 85, df: 45, sp: 75, sl: 35 },
weightkg: 39.2,
nfe: true
},
Dragonair: {
types: ['Dragon'],
bs: { hp: 61, at: 84, df: 65, sp: 70, sl: 70 },
weightkg: 16.5,
nfe: true
},
Dragonite: {
types: ['Dragon', 'Flying'],
bs: { hp: 91, at: 134, df: 95, sp: 80, sl: 100 },
weightkg: 210
},
Dratini: {
types: ['Dragon'],
bs: { hp: 41, at: 64, df: 45, sp: 50, sl: 50 },
weightkg: 3.3,
nfe: true
},
Drowzee: {
types: ['Psychic'],
bs: { hp: 60, at: 48, df: 45, sp: 42, sl: 90 },
weightkg: 32.4,
nfe: true
},
Dugtrio: {
types: ['Ground'],
bs: { hp: 35, at: 80, df: 50, sp: 120, sl: 70 },
weightkg: 33.3
},
Eevee: {
types: ['Normal'],
bs: { hp: 55, at: 55, df: 50, sp: 55, sl: 65 },
weightkg: 6.5,
nfe: true
},
Ekans: {
types: ['Poison'],
bs: { hp: 35, at: 60, df: 44, sp: 55, sl: 40 },
weightkg: 6.9,
nfe: true
},
Electabuzz: {
types: ['Electric'],
bs: { hp: 65, at: 83, df: 57, sp: 105, sl: 85 },
weightkg: 30
},
Electrode: {
types: ['Electric'],
bs: { hp: 60, at: 50, df: 70, sp: 140, sl: 80 },
weightkg: 66.6
},
Exeggcute: {
types: ['Grass', 'Psychic'],
bs: { hp: 60, at: 40, df: 80, sp: 40, sl: 60 },
weightkg: 2.5,
nfe: true
},
Exeggutor: {
types: ['Grass', 'Psychic'],
bs: { hp: 95, at: 95, df: 85, sp: 55, sl: 125 },
weightkg: 120
},
'Farfetch\u2019d': {
types: ['Normal', 'Flying'],
bs: { hp: 52, at: 65, df: 55, sp: 60, sl: 58 },
weightkg: 15
},
Fearow: {
types: ['Normal', 'Flying'],
bs: { hp: 65, at: 90, df: 65, sp: 100, sl: 61 },
weightkg: 38
},
Flareon: { types: ['Fire'], bs: { hp: 65, at: 130, df: 60, sp: 65, sl: 110 }, weightkg: 25 },
Gastly: {
types: ['Ghost', 'Poison'],
bs: { hp: 30, at: 35, df: 30, sp: 80, sl: 100 },
weightkg: 0.1,
nfe: true
},
Gengar: {
types: ['Ghost', 'Poison'],
bs: { hp: 60, at: 65, df: 60, sp: 110, sl: 130 },
weightkg: 40.5
},
Geodude: {
types: ['Rock', 'Ground'],
bs: { hp: 40, at: 80, df: 100, sp: 20, sl: 30 },
weightkg: 20,
nfe: true
},
Gloom: {
types: ['Grass', 'Poison'],
bs: { hp: 60, at: 65, df: 70, sp: 40, sl: 85 },
weightkg: 8.6,
nfe: true
},
Golbat: {
types: ['Poison', 'Flying'],
bs: { hp: 75, at: 80, df: 70, sp: 90, sl: 75 },
weightkg: 55
},
Goldeen: {
types: ['Water'],
bs: { hp: 45, at: 67, df: 60, sp: 63, sl: 50 },
weightkg: 15,
nfe: true
},
Golduck: { types: ['Water'], bs: { hp: 80, at: 82, df: 78, sp: 85, sl: 80 }, weightkg: 76.6 },
Golem: {
types: ['Rock', 'Ground'],
bs: { hp: 80, at: 110, df: 130, sp: 45, sl: 55 },
weightkg: 300
},
Graveler: {
types: ['Rock', 'Ground'],
bs: { hp: 55, at: 95, df: 115, sp: 35, sl: 45 },
weightkg: 105,
nfe: true
},
Grimer: {
types: ['Poison'],
bs: { hp: 80, at: 80, df: 50, sp: 25, sl: 40 },
weightkg: 30,
nfe: true
},
Growlithe: {
types: ['Fire'],
bs: { hp: 55, at: 70, df: 45, sp: 60, sl: 50 },
weightkg: 19,
nfe: true
},
Gyarados: {
types: ['Water', 'Flying'],
bs: { hp: 95, at: 125, df: 79, sp: 81, sl: 100 },
weightkg: 235
},
Haunter: {
types: ['Ghost', 'Poison'],
bs: { hp: 45, at: 50, df: 45, sp: 95, sl: 115 },
weightkg: 0.1,
nfe: true
},
Hitmonchan: {
types: ['Fighting'],
bs: { hp: 50, at: 105, df: 79, sp: 76, sl: 35 },
weightkg: 50.2
},
Hitmonlee: {
types: ['Fighting'],
bs: { hp: 50, at: 120, df: 53, sp: 87, sl: 35 },
weightkg: 49.8
},
Horsea: {
types: ['Water'],
bs: { hp: 30, at: 40, df: 70, sp: 60, sl: 70 },
weightkg: 8,
nfe: true
},
Hypno: {
types: ['Psychic'],
bs: { hp: 85, at: 73, df: 70, sp: 67, sl: 115 },
weightkg: 75.6
},
Ivysaur: {
types: ['Grass', 'Poison'],
bs: { hp: 60, at: 62, df: 63, sp: 60, sl: 80 },
weightkg: 13,
nfe: true
},
Jigglypuff: {
types: ['Normal'],
bs: { hp: 115, at: 45, df: 20, sp: 20, sl: 25 },
weightkg: 5.5,
nfe: true
},
Jolteon: {
types: ['Electric'],
bs: { hp: 65, at: 65, df: 60, sp: 130, sl: 110 },
weightkg: 24.5
},
Jynx: {
types: ['Ice', 'Psychic'],
bs: { hp: 65, at: 50, df: 35, sp: 95, sl: 95 },
weightkg: 40.6
},
Kabuto: {
types: ['Rock', 'Water'],
bs: { hp: 30, at: 80, df: 90, sp: 55, sl: 45 },
weightkg: 11.5,
nfe: true
},
Kabutops: {
types: ['Rock', 'Water'],
bs: { hp: 60, at: 115, df: 105, sp: 80, sl: 70 },
weightkg: 40.5
},
Kadabra: {
types: ['Psychic'],
bs: { hp: 40, at: 35, df: 30, sp: 105, sl: 120 },
weightkg: 56.5,
nfe: true
},
Kakuna: {
types: ['Bug', 'Poison'],
bs: { hp: 45, at: 25, df: 50, sp: 35, sl: 25 },
weightkg: 10,
nfe: true
},
Kangaskhan: {
types: ['Normal'],
bs: { hp: 105, at: 95, df: 80, sp: 90, sl: 40 },
weightkg: 80
},
Kingler: { types: ['Water'], bs: { hp: 55, at: 130, df: 115, sp: 75, sl: 50 }, weightkg: 60 },
Koffing: {
types: ['Poison'],
bs: { hp: 40, at: 65, df: 95, sp: 35, sl: 60 },
weightkg: 1,
nfe: true
},
Krabby: {
types: ['Water'],
bs: { hp: 30, at: 105, df: 90, sp: 50, sl: 25 },
weightkg: 6.5,
nfe: true
},
Lapras: {
types: ['Water', 'Ice'],
bs: { hp: 130, at: 85, df: 80, sp: 60, sl: 95 },
weightkg: 220
},
Lickitung: {
types: ['Normal'],
bs: { hp: 90, at: 55, df: 75, sp: 30, sl: 60 },
weightkg: 65.5
},
Machamp: {
types: ['Fighting'],
bs: { hp: 90, at: 130, df: 80, sp: 55, sl: 65 },
weightkg: 130
},
Machoke: {
types: ['Fighting'],
bs: { hp: 80, at: 100, df: 70, sp: 45, sl: 50 },
weightkg: 70.5,
nfe: true
},
Machop: {
types: ['Fighting'],
bs: { hp: 70, at: 80, df: 50, sp: 35, sl: 35 },
weightkg: 19.5,
nfe: true
},
Magikarp: {
types: ['Water'],
bs: { hp: 20, at: 10, df: 55, sp: 80, sl: 20 },
weightkg: 10,
nfe: true
},
Magmar: {
types: ['Fire'],
bs: { hp: 65, at: 95, df: 57, sp: 93, sl: 85 },
weightkg: 44.5
},
Magnemite: {
types: ['Electric'],
bs: { hp: 25, at: 35, df: 70, sp: 45, sl: 95 },
weightkg: 6,
nfe: true
},
Magneton: {
types: ['Electric'],
bs: { hp: 50, at: 60, df: 95, sp: 70, sl: 120 },
weightkg: 60
},
Mankey: {
types: ['Fighting'],
bs: { hp: 40, at: 80, df: 35, sp: 70, sl: 35 },
weightkg: 28,
nfe: true
},
Marowak: { types: ['Ground'], bs: { hp: 60, at: 80, df: 110, sp: 45, sl: 50 }, weightkg: 45 },
Meowth: {
types: ['Normal'],
bs: { hp: 40, at: 45, df: 35, sp: 90, sl: 40 },
weightkg: 4.2,
nfe: true
},
Metapod: {
types: ['Bug'],
bs: { hp: 50, at: 20, df: 55, sp: 30, sl: 25 },
weightkg: 9.9,
nfe: true
},
Mew: {
types: ['Psychic'],
bs: { hp: 100, at: 100, df: 100, sp: 100, sl: 100 },
weightkg: 4
},
Mewtwo: {
types: ['Psychic'],
bs: { hp: 106, at: 110, df: 90, sp: 130, sl: 154 },
weightkg: 122
},
Moltres: {
types: ['Fire', 'Flying'],
bs: { hp: 90, at: 100, df: 90, sp: 90, sl: 125 },
weightkg: 60
},
'Mr. Mime': {
types: ['Psychic'],
bs: { hp: 40, at: 45, df: 65, sp: 90, sl: 100 },
weightkg: 54.5
},
Muk: { types: ['Poison'], bs: { hp: 105, at: 105, df: 75, sp: 50, sl: 65 }, weightkg: 30 },
Nidoking: {
types: ['Poison', 'Ground'],
bs: { hp: 81, at: 92, df: 77, sp: 85, sl: 75 },
weightkg: 62
},
Nidoqueen: {
types: ['Poison', 'Ground'],
bs: { hp: 90, at: 82, df: 87, sp: 76, sl: 75 },
weightkg: 60
},
'Nidoran-F': {
types: ['Poison'],
bs: { hp: 55, at: 47, df: 52, sp: 41, sl: 40 },
weightkg: 7,
nfe: true
},
'Nidoran-M': {
types: ['Poison'],
bs: { hp: 46, at: 57, df: 40, sp: 50, sl: 40 },
weightkg: 9,
nfe: true
},
Nidorina: {
types: ['Poison'],
bs: { hp: 70, at: 62, df: 67, sp: 56, sl: 55 },
weightkg: 20,
nfe: true
},
Nidorino: {
types: ['Poison'],
bs: { hp: 61, at: 72, df: 57, sp: 65, sl: 55 },
weightkg: 19.5,
nfe: true
},
Ninetales: {
types: ['Fire'],
bs: { hp: 73, at: 76, df: 75, sp: 100, sl: 100 },
weightkg: 19.9
},
Oddish: {
types: ['Grass', 'Poison'],
bs: { hp: 45, at: 50, df: 55, sp: 30, sl: 75 },
weightkg: 5.4,
nfe: true
},
Omanyte: {
types: ['Rock', 'Water'],
bs: { hp: 35, at: 40, df: 100, sp: 35, sl: 90 },
weightkg: 7.5,
nfe: true
},
Omastar: {
types: ['Rock', 'Water'],
bs: { hp: 70, at: 60, df: 125, sp: 55, sl: 115 },
weightkg: 35
},
Onix: {
types: ['Rock', 'Ground'],
bs: { hp: 35, at: 45, df: 160, sp: 70, sl: 30 },
weightkg: 210
},
Paras: {
types: ['Bug', 'Grass'],
bs: { hp: 35, at: 70, df: 55, sp: 25, sl: 55 },
weightkg: 5.4,
nfe: true
},
Parasect: {
types: ['Bug', 'Grass'],
bs: { hp: 60, at: 95, df: 80, sp: 30, sl: 80 },
weightkg: 29.5
},
Persian: { types: ['Normal'], bs: { hp: 65, at: 70, df: 60, sp: 115, sl: 65 }, weightkg: 32 },
Pidgeot: {
types: ['Normal', 'Flying'],
bs: { hp: 83, at: 80, df: 75, sp: 91, sl: 70 },
weightkg: 39.5
},
Pidgeotto: {
types: ['Normal', 'Flying'],
bs: { hp: 63, at: 60, df: 55, sp: 71, sl: 50 },
weightkg: 30,
nfe: true
},
Pidgey: {
types: ['Normal', 'Flying'],
bs: { hp: 40, at: 45, df: 40, sp: 56, sl: 35 },
weightkg: 1.8,
nfe: true
},
Pikachu: {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 30, sp: 90, sl: 50 },
weightkg: 6,
nfe: true
},
Pinsir: { types: ['Bug'], bs: { hp: 65, at: 125, df: 100, sp: 85, sl: 55 }, weightkg: 55 },
Poliwag: {
types: ['Water'],
bs: { hp: 40, at: 50, df: 40, sp: 90, sl: 40 },
weightkg: 12.4,
nfe: true
},
Poliwhirl: {
types: ['Water'],
bs: { hp: 65, at: 65, df: 65, sp: 90, sl: 50 },
weightkg: 20,
nfe: true
},
Poliwrath: {
types: ['Water', 'Fighting'],
bs: { hp: 90, at: 85, df: 95, sp: 70, sl: 70 },
weightkg: 54
},
Ponyta: {
types: ['Fire'],
bs: { hp: 50, at: 85, df: 55, sp: 90, sl: 65 },
weightkg: 30,
nfe: true
},
Porygon: {
types: ['Normal'],
bs: { hp: 65, at: 60, df: 70, sp: 40, sl: 75 },
weightkg: 36.5
},
Primeape: {
types: ['Fighting'],
bs: { hp: 65, at: 105, df: 60, sp: 95, sl: 60 },
weightkg: 32
},
Psyduck: {
types: ['Water'],
bs: { hp: 50, at: 52, df: 48, sp: 55, sl: 50 },
weightkg: 19.6,
nfe: true
},
Raichu: {
types: ['Electric'],
bs: { hp: 60, at: 90, df: 55, sp: 100, sl: 90 },
weightkg: 30
},
Rapidash: { types: ['Fire'], bs: { hp: 65, at: 100, df: 70, sp: 105, sl: 80 }, weightkg: 95 },
Raticate: {
types: ['Normal'],
bs: { hp: 55, at: 81, df: 60, sp: 97, sl: 50 },
weightkg: 18.5
},
Rattata: {
types: ['Normal'],
bs: { hp: 30, at: 56, df: 35, sp: 72, sl: 25 },
weightkg: 3.5,
nfe: true
},
Rhydon: {
types: ['Ground', 'Rock'],
bs: { hp: 105, at: 130, df: 120, sp: 40, sl: 45 },
weightkg: 120
},
Rhyhorn: {
types: ['Ground', 'Rock'],
bs: { hp: 80, at: 85, df: 95, sp: 25, sl: 30 },
weightkg: 115,
nfe: true
},
Sandshrew: {
types: ['Ground'],
bs: { hp: 50, at: 75, df: 85, sp: 40, sl: 30 },
weightkg: 12,
nfe: true
},
Sandslash: {
types: ['Ground'],
bs: { hp: 75, at: 100, df: 110, sp: 65, sl: 55 },
weightkg: 29.5
},
Scyther: {
types: ['Bug', 'Flying'],
bs: { hp: 70, at: 110, df: 80, sp: 105, sl: 55 },
weightkg: 56
},
Seadra: { types: ['Water'], bs: { hp: 55, at: 65, df: 95, sp: 85, sl: 95 }, weightkg: 25 },
Seaking: { types: ['Water'], bs: { hp: 80, at: 92, df: 65, sp: 68, sl: 80 }, weightkg: 39 },
Seel: {
types: ['Water'],
bs: { hp: 65, at: 45, df: 55, sp: 45, sl: 70 },
weightkg: 90,
nfe: true
},
Shellder: {
types: ['Water'],
bs: { hp: 30, at: 65, df: 100, sp: 40, sl: 45 },
weightkg: 4,
nfe: true
},
Slowbro: {
types: ['Water', 'Psychic'],
bs: { hp: 95, at: 75, df: 110, sp: 30, sl: 80 },
weightkg: 78.5
},
Slowpoke: {
types: ['Water', 'Psychic'],
bs: { hp: 90, at: 65, df: 65, sp: 15, sl: 40 },
weightkg: 36,
nfe: true
},
Snorlax: {
types: ['Normal'],
bs: { hp: 160, at: 110, df: 65, sp: 30, sl: 65 },
weightkg: 460
},
Spearow: {
types: ['Normal', 'Flying'],
bs: { hp: 40, at: 60, df: 30, sp: 70, sl: 31 },
weightkg: 2,
nfe: true
},
Squirtle: {
types: ['Water'],
bs: { hp: 44, at: 48, df: 65, sp: 43, sl: 50 },
weightkg: 9,
nfe: true
},
Starmie: {
types: ['Water', 'Psychic'],
bs: { hp: 60, at: 75, df: 85, sp: 115, sl: 100 },
weightkg: 80
},
Staryu: {
types: ['Water'],
bs: { hp: 30, at: 45, df: 55, sp: 85, sl: 70 },
weightkg: 34.5,
nfe: true
},
Tangela: {
types: ['Grass'],
bs: { hp: 65, at: 55, df: 115, sp: 60, sl: 100 },
weightkg: 35
},
Tauros: {
types: ['Normal'],
bs: { hp: 75, at: 100, df: 95, sp: 110, sl: 70 },
weightkg: 88.4
},
Tentacool: {
types: ['Water', 'Poison'],
bs: { hp: 40, at: 40, df: 35, sp: 70, sl: 100 },
weightkg: 45.5,
nfe: true
},
Tentacruel: {
types: ['Water', 'Poison'],
bs: { hp: 80, at: 70, df: 65, sp: 100, sl: 120 },
weightkg: 55
},
Vaporeon: {
types: ['Water'],
bs: { hp: 130, at: 65, df: 60, sp: 65, sl: 110 },
weightkg: 29
},
Venomoth: {
types: ['Bug', 'Poison'],
bs: { hp: 70, at: 65, df: 60, sp: 90, sl: 90 },
weightkg: 12.5
},
Venonat: {
types: ['Bug', 'Poison'],
bs: { hp: 60, at: 55, df: 50, sp: 45, sl: 40 },
weightkg: 30,
nfe: true
},
Venusaur: {
types: ['Grass', 'Poison'],
bs: { hp: 80, at: 82, df: 83, sp: 80, sl: 100 },
weightkg: 100
},
Victreebel: {
types: ['Grass', 'Poison'],
bs: { hp: 80, at: 105, df: 65, sp: 70, sl: 100 },
weightkg: 15.5
},
Vileplume: {
types: ['Grass', 'Poison'],
bs: { hp: 75, at: 80, df: 85, sp: 50, sl: 100 },
weightkg: 18.6
},
Voltorb: {
types: ['Electric'],
bs: { hp: 40, at: 30, df: 50, sp: 100, sl: 55 },
weightkg: 10.4,
nfe: true
},
Vulpix: {
types: ['Fire'],
bs: { hp: 38, at: 41, df: 40, sp: 65, sl: 65 },
weightkg: 9.9,
nfe: true
},
Wartortle: {
types: ['Water'],
bs: { hp: 59, at: 63, df: 80, sp: 58, sl: 65 },
weightkg: 22.5,
nfe: true
},
Weedle: {
types: ['Bug', 'Poison'],
bs: { hp: 40, at: 35, df: 30, sp: 50, sl: 20 },
weightkg: 3.2,
nfe: true
},
Weepinbell: {
types: ['Grass', 'Poison'],
bs: { hp: 65, at: 90, df: 50, sp: 55, sl: 85 },
weightkg: 6.4,
nfe: true
},
Weezing: {
types: ['Poison'],
bs: { hp: 65, at: 90, df: 120, sp: 60, sl: 85 },
weightkg: 9.5
},
Wigglytuff: {
types: ['Normal'],
bs: { hp: 140, at: 70, df: 45, sp: 45, sl: 50 },
weightkg: 12
},
Zapdos: {
types: ['Electric', 'Flying'],
bs: { hp: 90, at: 90, df: 85, sp: 100, sl: 125 },
weightkg: 52.6
},
Zubat: {
types: ['Poison', 'Flying'],
bs: { hp: 40, at: 45, df: 35, sp: 55, sl: 40 },
weightkg: 7.5,
nfe: true
}
};
var GSC_PATCH = {
Abra: { bs: { sa: 105, sd: 55 } },
Aerodactyl: { bs: { sa: 60, sd: 75 } },
Alakazam: { bs: { sa: 135, sd: 85 } },
Arbok: { bs: { sa: 65, sd: 79 } },
Arcanine: { bs: { sa: 100, sd: 80 } },
Articuno: { bs: { sa: 95, sd: 125 }, gender: 'N' },
Beedrill: { bs: { sa: 45, sd: 80 } },
Bellsprout: { bs: { sa: 70, sd: 30 } },
Blastoise: { bs: { sa: 85, sd: 105 } },
Bulbasaur: { bs: { sa: 65, sd: 65 } },
Butterfree: { bs: { sa: 80, sd: 80 } },
Caterpie: { bs: { sa: 20, sd: 20 } },
Chansey: { bs: { sa: 35, sd: 105 }, nfe: true },
Charizard: { bs: { sa: 109, sd: 85 } },
Charmander: { bs: { sa: 60, sd: 50 } },
Charmeleon: { bs: { sa: 80, sd: 65 } },
Clefable: { bs: { sa: 85, sd: 90 } },
Clefairy: { bs: { sa: 60, sd: 65 } },
Cloyster: { bs: { sa: 85, sd: 45 } },
Cubone: { bs: { sa: 40, sd: 50 } },
Dewgong: { bs: { sa: 70, sd: 95 } },
Diglett: { bs: { sa: 35, sd: 45 } },
Ditto: { bs: { sa: 48, sd: 48 }, gender: 'N' },
Dodrio: { bs: { sa: 60, sd: 60 } },
Doduo: { bs: { sa: 35, sd: 35 } },
Dragonair: { bs: { sa: 70, sd: 70 } },
Dragonite: { bs: { sa: 100, sd: 100 } },
Dratini: { bs: { sa: 50, sd: 50 } },
Drowzee: { bs: { sa: 43, sd: 90 } },
Dugtrio: { bs: { sa: 50, sd: 70 } },
Eevee: { bs: { sa: 45, sd: 65 } },
Ekans: { bs: { sa: 40, sd: 54 } },
Electabuzz: { bs: { sa: 95, sd: 85 } },
Electrode: { bs: { sa: 80, sd: 80 }, gender: 'N' },
Exeggcute: { bs: { sa: 60, sd: 45 } },
Exeggutor: { bs: { sa: 125, sd: 65 } },
'Farfetch\u2019d': { bs: { sa: 58, sd: 62 } },
Fearow: { bs: { sa: 61, sd: 61 } },
Flareon: { bs: { sa: 95, sd: 110 } },
Gastly: { bs: { sa: 100, sd: 35 } },
Gengar: { bs: { sa: 130, sd: 75 } },
Geodude: { bs: { sa: 30, sd: 30 } },
Gloom: { bs: { sa: 85, sd: 75 } },
Golbat: { bs: { sa: 65, sd: 75 }, nfe: true },
Goldeen: { bs: { sa: 35, sd: 50 } },
Golduck: { bs: { sa: 95, sd: 80 } },
Golem: { bs: { sa: 55, sd: 65 } },
Graveler: { bs: { sa: 45, sd: 45 } },
Grimer: { bs: { sa: 40, sd: 50 } },
Growlithe: { bs: { sa: 70, sd: 50 } },
Gyarados: { bs: { sa: 60, sd: 100 } },
Haunter: { bs: { sa: 115, sd: 55 } },
Hitmonchan: { bs: { sa: 35, sd: 110 } },
Hitmonlee: { bs: { sa: 35, sd: 110 } },
Horsea: { bs: { sa: 70, sd: 25 } },
Hypno: { bs: { sa: 73, sd: 115 } },
Ivysaur: { bs: { sa: 80, sd: 80 } },
Jigglypuff: { bs: { sa: 45, sd: 25 } },
Jolteon: { bs: { sa: 110, sd: 95 } },
Jynx: { bs: { sa: 115, sd: 95 } },
Kabuto: { bs: { sa: 55, sd: 45 } },
Kabutops: { bs: { sa: 65, sd: 70 } },
Kadabra: { bs: { sa: 120, sd: 70 } },
Kakuna: { bs: { sa: 25, sd: 25 } },
Kangaskhan: { bs: { sa: 40, sd: 80 } },
Kingler: { bs: { sa: 50, sd: 50 } },
Koffing: { bs: { sa: 60, sd: 45 } },
Krabby: { bs: { sa: 25, sd: 25 } },
Lapras: { bs: { sa: 85, sd: 95 } },
Lickitung: { bs: { sa: 60, sd: 75 } },
Machamp: { bs: { sa: 65, sd: 85 } },
Machoke: { bs: { sa: 50, sd: 60 } },
Machop: { bs: { sa: 35, sd: 35 } },
Magikarp: { bs: { sa: 15, sd: 20 } },
Magmar: { bs: { sa: 100, sd: 85 } },
Magnemite: { types: ['Electric', 'Steel'], bs: { sa: 95, sd: 55 }, gender: 'N' },
Magneton: { types: ['Electric', 'Steel'], bs: { sa: 120, sd: 70 }, gender: 'N' },
Mankey: { bs: { sa: 35, sd: 45 } },
Marowak: { bs: { sa: 50, sd: 80 } },
Meowth: { bs: { sa: 40, sd: 40 } },
Metapod: { bs: { sa: 25, sd: 25 } },
Mew: { bs: { sa: 100, sd: 100 }, gender: 'N' },
Mewtwo: { bs: { sa: 154, sd: 90 }, gender: 'N' },
Moltres: { bs: { sa: 125, sd: 85 }, gender: 'N' },
'Mr. Mime': { bs: { sa: 100, sd: 120 } },
Muk: { bs: { sa: 65, sd: 100 } },
Nidoking: { bs: { sa: 85, sd: 75 } },
Nidoqueen: { bs: { sa: 75, sd: 85 } },
'Nidoran-F': { bs: { sa: 40, sd: 40 } },
'Nidoran-M': { bs: { sa: 40, sd: 40 } },
Nidorina: { bs: { sa: 55, sd: 55 } },
Nidorino: { bs: { sa: 55, sd: 55 } },
Ninetales: { bs: { sa: 81, sd: 100 } },
Oddish: { bs: { sa: 75, sd: 65 } },
Omanyte: { bs: { sa: 90, sd: 55 } },
Omastar: { bs: { sa: 115, sd: 70 } },
Onix: { bs: { sa: 30, sd: 45 }, nfe: true },
Paras: { bs: { sa: 45, sd: 55 } },
Parasect: { bs: { sa: 60, sd: 80 } },
Persian: { bs: { sa: 65, sd: 65 } },
Pidgeot: { bs: { sa: 70, sd: 70 } },
Pidgeotto: { bs: { sa: 50, sd: 50 } },
Pidgey: { bs: { sa: 35, sd: 35 } },
Pikachu: { bs: { sa: 50, sd: 40 } },
Pinsir: { bs: { sa: 55, sd: 70 } },
Poliwag: { bs: { sa: 40, sd: 40 } },
Poliwhirl: { bs: { sa: 50, sd: 50 } },
Poliwrath: { bs: { sa: 70, sd: 90 } },
Ponyta: { bs: { sa: 65, sd: 65 } },
Porygon: { bs: { sa: 85, sd: 75 }, nfe: true, gender: 'N' },
Primeape: { bs: { sa: 60, sd: 70 } },
Psyduck: { bs: { sa: 65, sd: 50 } },
Raichu: { bs: { sa: 90, sd: 80 } },
Rapidash: { bs: { sa: 80, sd: 80 } },
Raticate: { bs: { sa: 50, sd: 70 } },
Rattata: { bs: { sa: 25, sd: 35 } },
Rhydon: { bs: { sa: 45, sd: 45 } },
Rhyhorn: { bs: { sa: 30, sd: 30 } },
Sandshrew: { bs: { sa: 20, sd: 30 } },
Sandslash: { bs: { sa: 45, sd: 55 } },
Scyther: { bs: { sa: 55, sd: 80 }, nfe: true },
Seadra: { bs: { sa: 95, sd: 45 }, nfe: true },
Seaking: { bs: { sa: 65, sd: 80 } },
Seel: { bs: { sa: 45, sd: 70 } },
Shellder: { bs: { sa: 45, sd: 25 } },
Slowbro: { bs: { sa: 100, sd: 80 } },
Slowpoke: { bs: { sa: 40, sd: 40 } },
Snorlax: { bs: { sa: 65, sd: 110 } },
Spearow: { bs: { sa: 31, sd: 31 } },
Squirtle: { bs: { sa: 50, sd: 64 } },
Starmie: { bs: { sa: 100, sd: 85 }, gender: 'N' },
Staryu: { bs: { sa: 70, sd: 55 }, gender: 'N' },
Tangela: { bs: { sa: 100, sd: 40 } },
Tauros: { bs: { sa: 40, sd: 70 } },
Tentacool: { bs: { sa: 50, sd: 100 } },
Tentacruel: { bs: { sa: 80, sd: 120 } },
Vaporeon: { bs: { sa: 110, sd: 95 } },
Venomoth: { bs: { sa: 90, sd: 75 } },
Venonat: { bs: { sa: 40, sd: 55 } },
Venusaur: { bs: { sa: 100, sd: 100 } },
Victreebel: { bs: { sa: 100, sd: 60 } },
Vileplume: { bs: { sa: 100, sd: 90 } },
Voltorb: { bs: { sa: 55, sd: 55 }, gender: 'N' },
Vulpix: { bs: { sa: 50, sd: 65 } },
Wartortle: { bs: { sa: 65, sd: 80 } },
Weedle: { bs: { sa: 20, sd: 20 } },
Weepinbell: { bs: { sa: 85, sd: 45 } },
Weezing: { bs: { sa: 85, sd: 70 } },
Wigglytuff: { bs: { sa: 75, sd: 50 } },
Zapdos: { bs: { sa: 125, sd: 90 }, gender: 'N' },
Zubat: { bs: { sa: 30, sd: 40 } },
Aipom: { types: ['Normal'], bs: { hp: 55, at: 70, df: 55, sa: 40, sd: 55, sp: 85 }, weightkg: 11.5 },
Ampharos: {
types: ['Electric'],
bs: { hp: 90, at: 75, df: 75, sa: 115, sd: 90, sp: 55 },
weightkg: 61.5
},
Ariados: {
types: ['Bug', 'Poison'],
bs: { hp: 70, at: 90, df: 70, sa: 60, sd: 60, sp: 40 },
weightkg: 33.5
},
Azumarill: {
types: ['Water'],
bs: { hp: 100, at: 50, df: 80, sa: 50, sd: 80, sp: 50 },
weightkg: 28.5
},
Bayleef: {
types: ['Grass'],
bs: { hp: 60, at: 62, df: 80, sa: 63, sd: 80, sp: 60 },
weightkg: 15.8,
nfe: true
},
Bellossom: {
types: ['Grass'],
bs: { hp: 75, at: 80, df: 85, sa: 90, sd: 100, sp: 50 },
weightkg: 5.8
},
Blissey: {
types: ['Normal'],
bs: { hp: 255, at: 10, df: 10, sa: 75, sd: 135, sp: 55 },
weightkg: 46.8
},
Celebi: {
types: ['Psychic', 'Grass'],
bs: { hp: 100, at: 100, df: 100, sa: 100, sd: 100, sp: 100 },
weightkg: 5,
gender: 'N'
},
Chikorita: {
types: ['Grass'],
bs: { hp: 45, at: 49, df: 65, sa: 49, sd: 65, sp: 45 },
weightkg: 6.4,
nfe: true
},
Chinchou: {
types: ['Water', 'Electric'],
bs: { hp: 75, at: 38, df: 38, sa: 56, sd: 56, sp: 67 },
weightkg: 12,
nfe: true
},
Cleffa: {
types: ['Normal'],
bs: { hp: 50, at: 25, df: 28, sa: 45, sd: 55, sp: 15 },
weightkg: 3,
nfe: true
},
Corsola: {
types: ['Water', 'Rock'],
bs: { hp: 55, at: 55, df: 85, sa: 65, sd: 85, sp: 35 },
weightkg: 5
},
Crobat: {
types: ['Poison', 'Flying'],
bs: { hp: 85, at: 90, df: 80, sa: 70, sd: 80, sp: 130 },
weightkg: 75
},
Croconaw: {
types: ['Water'],
bs: { hp: 65, at: 80, df: 80, sa: 59, sd: 63, sp: 58 },
weightkg: 25,
nfe: true
},
Cyndaquil: {
types: ['Fire'],
bs: { hp: 39, at: 52, df: 43, sa: 60, sd: 50, sp: 65 },
weightkg: 7.9,
nfe: true
},
Delibird: {
types: ['Ice', 'Flying'],
bs: { hp: 45, at: 55, df: 45, sa: 65, sd: 45, sp: 75 },
weightkg: 16
},
Donphan: {
types: ['Ground'],
bs: { hp: 90, at: 120, df: 120, sa: 60, sd: 60, sp: 50 },
weightkg: 120
},
Dunsparce: {
types: ['Normal'],
bs: { hp: 100, at: 70, df: 70, sa: 65, sd: 65, sp: 45 },
weightkg: 14
},
Elekid: {
types: ['Electric'],
bs: { hp: 45, at: 63, df: 37, sa: 65, sd: 55, sp: 95 },
weightkg: 23.5,
nfe: true
},
Entei: {
types: ['Fire'],
bs: { hp: 115, at: 115, df: 85, sa: 90, sd: 75, sp: 100 },
weightkg: 198,
gender: 'N'
},
Espeon: {
types: ['Psychic'],
bs: { hp: 65, at: 65, df: 60, sa: 130, sd: 95, sp: 110 },
weightkg: 26.5
},
Feraligatr: {
types: ['Water'],
bs: { hp: 85, at: 105, df: 100, sa: 79, sd: 83, sp: 78 },
weightkg: 88.8
},
Flaaffy: {
types: ['Electric'],
bs: { hp: 70, at: 55, df: 55, sa: 80, sd: 60, sp: 45 },
weightkg: 13.3,
nfe: true
},
Forretress: {
types: ['Bug', 'Steel'],
bs: { hp: 75, at: 90, df: 140, sa: 60, sd: 60, sp: 40 },
weightkg: 125.8
},
Furret: { types: ['Normal'], bs: { hp: 85, at: 76, df: 64, sa: 45, sd: 55, sp: 90 }, weightkg: 32.5 },
Girafarig: {
types: ['Normal', 'Psychic'],
bs: { hp: 70, at: 80, df: 65, sa: 90, sd: 65, sp: 85 },
weightkg: 41.5
},
Gligar: {
types: ['Ground', 'Flying'],
bs: { hp: 65, at: 75, df: 105, sa: 35, sd: 65, sp: 85 },
weightkg: 64.8
},
Granbull: {
types: ['Normal'],
bs: { hp: 90, at: 120, df: 75, sa: 60, sd: 60, sp: 45 },
weightkg: 48.7
},
Heracross: {
types: ['Bug', 'Fighting'],
bs: { hp: 80, at: 125, df: 75, sa: 40, sd: 95, sp: 85 },
weightkg: 54
},
Hitmontop: {
types: ['Fighting'],
bs: { hp: 50, at: 95, df: 95, sa: 35, sd: 110, sp: 70 },
weightkg: 48
},
'Ho-Oh': {
types: ['Fire', 'Flying'],
bs: { hp: 106, at: 130, df: 90, sa: 110, sd: 154, sp: 90 },
weightkg: 199,
gender: 'N'
},
Hoothoot: {
types: ['Normal', 'Flying'],
bs: { hp: 60, at: 30, df: 30, sa: 36, sd: 56, sp: 50 },
weightkg: 21.2,
nfe: true
},
Hoppip: {
types: ['Grass', 'Flying'],
bs: { hp: 35, at: 35, df: 40, sa: 35, sd: 55, sp: 50 },
weightkg: 0.5,
nfe: true
},
Houndoom: {
types: ['Dark', 'Fire'],
bs: { hp: 75, at: 90, df: 50, sa: 110, sd: 80, sp: 95 },
weightkg: 35
},
Houndour: {
types: ['Dark', 'Fire'],
bs: { hp: 45, at: 60, df: 30, sa: 80, sd: 50, sp: 65 },
weightkg: 10.8,
nfe: true
},
Igglybuff: {
types: ['Normal'],
bs: { hp: 90, at: 30, df: 15, sa: 40, sd: 20, sp: 15 },
weightkg: 1,
nfe: true
},
Jumpluff: {
types: ['Grass', 'Flying'],
bs: { hp: 75, at: 55, df: 70, sa: 55, sd: 85, sp: 110 },
weightkg: 3
},
Kingdra: {
types: ['Water', 'Dragon'],
bs: { hp: 75, at: 95, df: 95, sa: 95, sd: 95, sp: 85 },
weightkg: 152
},
Lanturn: {
types: ['Water', 'Electric'],
bs: { hp: 125, at: 58, df: 58, sa: 76, sd: 76, sp: 67 },
weightkg: 22.5
},
Larvitar: {
types: ['Rock', 'Ground'],
bs: { hp: 50, at: 64, df: 50, sa: 45, sd: 50, sp: 41 },
weightkg: 72,
nfe: true
},
Ledian: {
types: ['Bug', 'Flying'],
bs: { hp: 55, at: 35, df: 50, sa: 55, sd: 110, sp: 85 },
weightkg: 35.6
},
Ledyba: {
types: ['Bug', 'Flying'],
bs: { hp: 40, at: 20, df: 30, sa: 40, sd: 80, sp: 55 },
weightkg: 10.8,
nfe: true
},
Lugia: {
types: ['Psychic', 'Flying'],
bs: { hp: 106, at: 90, df: 130, sa: 90, sd: 154, sp: 110 },
weightkg: 216,
gender: 'N'
},
Magby: {
types: ['Fire'],
bs: { hp: 45, at: 75, df: 37, sa: 70, sd: 55, sp: 83 },
weightkg: 21.4,
nfe: true
},
Magcargo: {
types: ['Fire', 'Rock'],
bs: { hp: 50, at: 50, df: 120, sa: 80, sd: 80, sp: 30 },
weightkg: 55
},
Mantine: {
types: ['Water', 'Flying'],
bs: { hp: 65, at: 40, df: 70, sa: 80, sd: 140, sp: 70 },
weightkg: 220
},
Mareep: {
types: ['Electric'],
bs: { hp: 55, at: 40, df: 40, sa: 65, sd: 45, sp: 35 },
weightkg: 7.8,
nfe: true
},
Marill: {
types: ['Water'],
bs: { hp: 70, at: 20, df: 50, sa: 20, sd: 50, sp: 40 },
weightkg: 8.5,
nfe: true
},
Meganium: {
types: ['Grass'],
bs: { hp: 80, at: 82, df: 100, sa: 83, sd: 100, sp: 80 },
weightkg: 100.5
},
Miltank: {
types: ['Normal'],
bs: { hp: 95, at: 80, df: 105, sa: 40, sd: 70, sp: 100 },
weightkg: 75.5
},
Misdreavus: {
types: ['Ghost'],
bs: { hp: 60, at: 60, df: 60, sa: 85, sd: 85, sp: 85 },
weightkg: 1
},
Murkrow: {
types: ['Dark', 'Flying'],
bs: { hp: 60, at: 85, df: 42, sa: 85, sd: 42, sp: 91 },
weightkg: 2.1
},
Natu: {
types: ['Psychic', 'Flying'],
bs: { hp: 40, at: 50, df: 45, sa: 70, sd: 45, sp: 70 },
weightkg: 2,
nfe: true
},
Noctowl: {
types: ['Normal', 'Flying'],
bs: { hp: 100, at: 50, df: 50, sa: 76, sd: 96, sp: 70 },
weightkg: 40.8
},
Octillery: {
types: ['Water'],
bs: { hp: 75, at: 105, df: 75, sa: 105, sd: 75, sp: 45 },
weightkg: 28.5
},
Phanpy: {
types: ['Ground'],
bs: { hp: 90, at: 60, df: 60, sa: 40, sd: 40, sp: 40 },
weightkg: 33.5,
nfe: true
},
Pichu: {
types: ['Electric'],
bs: { hp: 20, at: 40, df: 15, sa: 35, sd: 35, sp: 60 },
weightkg: 2,
nfe: true
},
Piloswine: {
types: ['Ice', 'Ground'],
bs: { hp: 100, at: 100, df: 80, sa: 60, sd: 60, sp: 50 },
weightkg: 55.8
},
Pineco: {
types: ['Bug'],
bs: { hp: 50, at: 65, df: 90, sa: 35, sd: 35, sp: 15 },
weightkg: 7.2,
nfe: true
},
Politoed: {
types: ['Water'],
bs: { hp: 90, at: 75, df: 75, sa: 90, sd: 100, sp: 70 },
weightkg: 33.9
},
Porygon2: {
types: ['Normal'],
bs: { hp: 85, at: 80, df: 90, sa: 105, sd: 95, sp: 60 },
weightkg: 32.5,
gender: 'N'
},
Pupitar: {
types: ['Rock', 'Ground'],
bs: { hp: 70, at: 84, df: 70, sa: 65, sd: 70, sp: 51 },
weightkg: 152,
nfe: true
},
Quagsire: {
types: ['Water', 'Ground'],
bs: { hp: 95, at: 85, df: 85, sa: 65, sd: 65, sp: 35 },
weightkg: 75
},
Quilava: {
types: ['Fire'],
bs: { hp: 58, at: 64, df: 58, sa: 80, sd: 65, sp: 80 },
weightkg: 19,
nfe: true
},
Qwilfish: {
types: ['Water', 'Poison'],
bs: { hp: 65, at: 95, df: 75, sa: 55, sd: 55, sp: 85 },
weightkg: 3.9
},
Raikou: {
types: ['Electric'],
bs: { hp: 90, at: 85, df: 75, sa: 115, sd: 100, sp: 115 },
weightkg: 178,
gender: 'N'
},
Remoraid: {
types: ['Water'],
bs: { hp: 35, at: 65, df: 35, sa: 65, sd: 35, sp: 65 },
weightkg: 12,
nfe: true
},
Scizor: {
types: ['Bug', 'Steel'],
bs: { hp: 70, at: 130, df: 100, sa: 55, sd: 80, sp: 65 },
weightkg: 118
},
Sentret: {
types: ['Normal'],
bs: { hp: 35, at: 46, df: 34, sa: 35, sd: 45, sp: 20 },
weightkg: 6,
nfe: true
},
Shuckle: {
types: ['Bug', 'Rock'],
bs: { hp: 20, at: 10, df: 230, sa: 10, sd: 230, sp: 5 },
weightkg: 20.5
},
Skarmory: {
types: ['Steel', 'Flying'],
bs: { hp: 65, at: 80, df: 140, sa: 40, sd: 70, sp: 70 },
weightkg: 50.5
},
Skiploom: {
types: ['Grass', 'Flying'],
bs: { hp: 55, at: 45, df: 50, sa: 45, sd: 65, sp: 80 },
weightkg: 1,
nfe: true
},
Slowking: {
types: ['Water', 'Psychic'],
bs: { hp: 95, at: 75, df: 80, sa: 100, sd: 110, sp: 30 },
weightkg: 79.5
},
Slugma: {
types: ['Fire'],
bs: { hp: 40, at: 40, df: 40, sa: 70, sd: 40, sp: 20 },
weightkg: 35,
nfe: true
},
Smeargle: { types: ['Normal'], bs: { hp: 55, at: 20, df: 35, sa: 20, sd: 45, sp: 75 }, weightkg: 58 },
Smoochum: {
types: ['Ice', 'Psychic'],
bs: { hp: 45, at: 30, df: 15, sa: 85, sd: 65, sp: 65 },
weightkg: 6,
nfe: true
},
Sneasel: {
types: ['Dark', 'Ice'],
bs: { hp: 55, at: 95, df: 55, sa: 35, sd: 75, sp: 115 },
weightkg: 28
},
Snubbull: {
types: ['Normal'],
bs: { hp: 60, at: 80, df: 50, sa: 40, sd: 40, sp: 30 },
weightkg: 7.8,
nfe: true
},
Spinarak: {
types: ['Bug', 'Poison'],
bs: { hp: 40, at: 60, df: 40, sa: 40, sd: 40, sp: 30 },
weightkg: 8.5,
nfe: true
},
Stantler: {
types: ['Normal'],
bs: { hp: 73, at: 95, df: 62, sa: 85, sd: 65, sp: 85 },
weightkg: 71.2
},
Steelix: {
types: ['Steel', 'Ground'],
bs: { hp: 75, at: 85, df: 200, sa: 55, sd: 65, sp: 30 },
weightkg: 400
},
Sudowoodo: {
types: ['Rock'],
bs: { hp: 70, at: 100, df: 115, sa: 30, sd: 65, sp: 30 },
weightkg: 38
},
Suicune: {
types: ['Water'],
bs: { hp: 100, at: 75, df: 115, sa: 90, sd: 115, sp: 85 },
weightkg: 187,
gender: 'N'
},
Sunflora: {
types: ['Grass'],
bs: { hp: 75, at: 75, df: 55, sa: 105, sd: 85, sp: 30 },
weightkg: 8.5
},
Sunkern: {
types: ['Grass'],
bs: { hp: 30, at: 30, df: 30, sa: 30, sd: 30, sp: 30 },
weightkg: 1.8,
nfe: true
},
Swinub: {
types: ['Ice', 'Ground'],
bs: { hp: 50, at: 50, df: 40, sa: 30, sd: 30, sp: 50 },
weightkg: 6.5,
nfe: true
},
Teddiursa: {
types: ['Normal'],
bs: { hp: 60, at: 80, df: 50, sa: 50, sd: 50, sp: 40 },
weightkg: 8.8,
nfe: true
},
Togepi: {
types: ['Normal'],
bs: { hp: 35, at: 20, df: 65, sa: 40, sd: 65, sp: 20 },
weightkg: 1.5,
nfe: true
},
Togetic: {
types: ['Normal', 'Flying'],
bs: { hp: 55, at: 40, df: 85, sa: 80, sd: 105, sp: 40 },
weightkg: 3.2
},
Totodile: {
types: ['Water'],
bs: { hp: 50, at: 65, df: 64, sa: 44, sd: 48, sp: 43 },
weightkg: 9.5,
nfe: true
},
Typhlosion: {
types: ['Fire'],
bs: { hp: 78, at: 84, df: 78, sa: 109, sd: 85, sp: 100 },
weightkg: 79.5
},
Tyranitar: {
types: ['Rock', 'Dark'],
bs: { hp: 100, at: 134, df: 110, sa: 95, sd: 100, sp: 61 },
weightkg: 202
},
Tyrogue: {
types: ['Fighting'],
bs: { hp: 35, at: 35, df: 35, sa: 35, sd: 35, sp: 35 },
weightkg: 21,
nfe: true
},
Umbreon: { types: ['Dark'], bs: { hp: 95, at: 65, df: 110, sa: 60, sd: 130, sp: 65 }, weightkg: 27 },
Unown: {
types: ['Psychic'],
bs: { hp: 48, at: 72, df: 48, sa: 72, sd: 48, sp: 48 },
weightkg: 5,
gender: 'N'
},
Ursaring: {
types: ['Normal'],
bs: { hp: 90, at: 130, df: 75, sa: 75, sd: 75, sp: 55 },
weightkg: 125.8
},
Wobbuffet: {
types: ['Psychic'],
bs: { hp: 190, at: 33, df: 58, sa: 33, sd: 58, sp: 33 },
weightkg: 28.5
},
Wooper: {
types: ['Water', 'Ground'],
bs: { hp: 55, at: 45, df: 45, sa: 25, sd: 25, sp: 15 },
weightkg: 8.5,
nfe: true
},
Xatu: {
types: ['Psychic', 'Flying'],
bs: { hp: 65, at: 75, df: 70, sa: 95, sd: 70, sp: 95 },
weightkg: 15
},
Yanma: {
types: ['Bug', 'Flying'],
bs: { hp: 65, at: 65, df: 45, sa: 75, sd: 45, sp: 95 },
weightkg: 38
}
};
var GSC = util_1.extend(true, {}, RBY, GSC_PATCH);
var ADV_PATCH = {
Abra: { abilities: { 0: 'Synchronize' } },
Aerodactyl: { abilities: { 0: 'Rock Head' } },
Alakazam: { abilities: { 0: 'Synchronize' } },
Arbok: { abilities: { 0: 'Intimidate' } },
Arcanine: { abilities: { 0: 'Intimidate' } },
Articuno: { abilities: { 0: 'Pressure' } },
Beedrill: { abilities: { 0: 'Swarm' } },
Bellsprout: { abilities: { 0: 'Chlorophyll' } },
Blastoise: { abilities: { 0: 'Torrent' } },
Bulbasaur: { abilities: { 0: 'Overgrow' } },
Butterfree: { abilities: { 0: 'Compound Eyes' } },
Caterpie: { abilities: { 0: 'Shield Dust' } },
Chansey: { abilities: { 0: 'Natural Cure' } },
Charizard: { abilities: { 0: 'Blaze' } },
Charmander: { abilities: { 0: 'Blaze' } },
Charmeleon: { abilities: { 0: 'Blaze' } },
Clefable: { abilities: { 0: 'Cute Charm' } },
Clefairy: { abilities: { 0: 'Cute Charm' } },
Cloyster: { abilities: { 0: 'Shell Armor' } },
Cubone: { abilities: { 0: 'Rock Head' } },
Dewgong: { abilities: { 0: 'Thick Fat' } },
Diglett: { abilities: { 0: 'Sand Veil' } },
Ditto: { abilities: { 0: 'Limber' } },
Dodrio: { abilities: { 0: 'Run Away' } },
Doduo: { abilities: { 0: 'Run Away' } },
Dragonair: { abilities: { 0: 'Shed Skin' } },
Dragonite: { abilities: { 0: 'Inner Focus' } },
Dratini: { abilities: { 0: 'Shed Skin' } },
Drowzee: { abilities: { 0: 'Insomnia' } },
Dugtrio: { abilities: { 0: 'Sand Veil' } },
Eevee: { abilities: { 0: 'Run Away' } },
Ekans: { abilities: { 0: 'Intimidate' } },
Electabuzz: { abilities: { 0: 'Static' } },
Electrode: { abilities: { 0: 'Soundproof' } },
Exeggcute: { abilities: { 0: 'Chlorophyll' } },
Exeggutor: { abilities: { 0: 'Chlorophyll' } },
'Farfetch\u2019d': { abilities: { 0: 'Keen Eye' } },
Fearow: { abilities: { 0: 'Keen Eye' } },
Flareon: { abilities: { 0: 'Flash Fire' } },
Gastly: { abilities: { 0: 'Levitate' } },
Gengar: { abilities: { 0: 'Levitate' } },
Geodude: { abilities: { 0: 'Rock Head' } },
Gloom: { abilities: { 0: 'Chlorophyll' } },
Golbat: { abilities: { 0: 'Inner Focus' } },
Goldeen: { abilities: { 0: 'Swift Swim' } },
Golduck: { abilities: { 0: 'Damp' } },
Golem: { abilities: { 0: 'Rock Head' } },
Graveler: { abilities: { 0: 'Rock Head' } },
Grimer: { abilities: { 0: 'Stench' } },
Growlithe: { abilities: { 0: 'Intimidate' } },
Gyarados: { abilities: { 0: 'Intimidate' } },
Haunter: { abilities: { 0: 'Levitate' } },
Hitmonchan: { abilities: { 0: 'Keen Eye' } },
Hitmonlee: { abilities: { 0: 'Limber' } },
Horsea: { abilities: { 0: 'Swift Swim' } },
Hypno: { abilities: { 0: 'Insomnia' } },
Ivysaur: { abilities: { 0: 'Overgrow' } },
Jigglypuff: { abilities: { 0: 'Cute Charm' } },
Jolteon: { abilities: { 0: 'Volt Absorb' } },
Jynx: { abilities: { 0: 'Oblivious' } },
Kabuto: { abilities: { 0: 'Swift Swim' } },
Kabutops: { abilities: { 0: 'Swift Swim' } },
Kadabra: { abilities: { 0: 'Synchronize' } },
Kakuna: { abilities: { 0: 'Shed Skin' } },
Kangaskhan: { abilities: { 0: 'Early Bird' } },
Kingler: { abilities: { 0: 'Hyper Cutter' } },
Koffing: { abilities: { 0: 'Levitate' } },
Krabby: { abilities: { 0: 'Hyper Cutter' } },
Lapras: { abilities: { 0: 'Water Absorb' } },
Lickitung: { abilities: { 0: 'Own Tempo' } },
Machamp: { abilities: { 0: 'Guts' } },
Machoke: { abilities: { 0: 'Guts' } },
Machop: { abilities: { 0: 'Guts' } },
Magikarp: { abilities: { 0: 'Swift Swim' } },
Magmar: { abilities: { 0: 'Flame Body' } },
Magnemite: { abilities: { 0: 'Magnet Pull' } },
Magneton: { abilities: { 0: 'Magnet Pull' } },
Mankey: { abilities: { 0: 'Vital Spirit' } },
Marowak: { abilities: { 0: 'Rock Head' } },
Meowth: { abilities: { 0: 'Pickup' } },
Metapod: { abilities: { 0: 'Shed Skin' } },
Mew: { abilities: { 0: 'Synchronize' } },
Mewtwo: { abilities: { 0: 'Pressure' } },
Moltres: { abilities: { 0: 'Pressure' } },
'Mr. Mime': { abilities: { 0: 'Soundproof' } },
Muk: { abilities: { 0: 'Stench' } },
Nidoking: { abilities: { 0: 'Poison Point' } },
Nidoqueen: { abilities: { 0: 'Poison Point' } },
'Nidoran-F': { abilities: { 0: 'Poison Point' } },
'Nidoran-M': { abilities: { 0: 'Poison Point' } },
Nidorina: { abilities: { 0: 'Poison Point' } },
Nidorino: { abilities: { 0: 'Poison Point' } },
Ninetales: { abilities: { 0: 'Flash Fire' } },
Oddish: { abilities: { 0: 'Chlorophyll' } },
Omanyte: { abilities: { 0: 'Swift Swim' } },
Omastar: { abilities: { 0: 'Swift Swim' } },
Onix: { abilities: { 0: 'Rock Head' } },
Paras: { abilities: { 0: 'Effect Spore' } },
Parasect: { abilities: { 0: 'Effect Spore' } },
Persian: { abilities: { 0: 'Limber' } },
Pidgeot: { abilities: { 0: 'Keen Eye' } },
Pidgeotto: { abilities: { 0: 'Keen Eye' } },
Pidgey: { abilities: { 0: 'Keen Eye' } },
Pikachu: { abilities: { 0: 'Static' } },
Pinsir: { abilities: { 0: 'Hyper Cutter' } },
Poliwag: { abilities: { 0: 'Water Absorb' } },
Poliwhirl: { abilities: { 0: 'Water Absorb' } },
Poliwrath: { abilities: { 0: 'Water Absorb' } },
Ponyta: { abilities: { 0: 'Run Away' } },
Porygon: { abilities: { 0: 'Trace' } },
Primeape: { abilities: { 0: 'Vital Spirit' } },
Psyduck: { abilities: { 0: 'Damp' } },
Raichu: { abilities: { 0: 'Static' } },
Rapidash: { abilities: { 0: 'Run Away' } },
Raticate: { abilities: { 0: 'Run Away' } },
Rattata: { abilities: { 0: 'Run Away' } },
Rhydon: { abilities: { 0: 'Lightning Rod' } },
Rhyhorn: { abilities: { 0: 'Lightning Rod' } },
Sandshrew: { abilities: { 0: 'Sand Veil' } },
Sandslash: { abilities: { 0: 'Sand Veil' } },
Scyther: { abilities: { 0: 'Swarm' } },
Seadra: { abilities: { 0: 'Poison Point' } },
Seaking: { abilities: { 0: 'Swift Swim' } },
Seel: { abilities: { 0: 'Thick Fat' } },
Shellder: { abilities: { 0: 'Shell Armor' } },
Slowbro: { abilities: { 0: 'Oblivious' } },
Slowpoke: { abilities: { 0: 'Oblivious' } },
Snorlax: { abilities: { 0: 'Immunity' } },
Spearow: { abilities: { 0: 'Keen Eye' } },
Squirtle: { abilities: { 0: 'Torrent' } },
Starmie: { abilities: { 0: 'Illuminate' } },
Staryu: { abilities: { 0: 'Illuminate' } },
Tangela: { abilities: { 0: 'Chlorophyll' } },
Tauros: { abilities: { 0: 'Intimidate' } },
Tentacool: { abilities: { 0: 'Clear Body' } },
Tentacruel: { abilities: { 0: 'Clear Body' } },
Vaporeon: { abilities: { 0: 'Water Absorb' } },
Venomoth: { abilities: { 0: 'Shield Dust' } },
Venonat: { abilities: { 0: 'Compound Eyes' } },
Venusaur: { abilities: { 0: 'Overgrow' } },
Victreebel: { abilities: { 0: 'Chlorophyll' } },
Vileplume: { abilities: { 0: 'Chlorophyll' } },
Voltorb: { abilities: { 0: 'Soundproof' } },
Vulpix: { abilities: { 0: 'Flash Fire' } },
Wartortle: { abilities: { 0: 'Torrent' } },
Weedle: { abilities: { 0: 'Shield Dust' } },
Weepinbell: { abilities: { 0: 'Chlorophyll' } },
Weezing: { abilities: { 0: 'Levitate' } },
Wigglytuff: { abilities: { 0: 'Cute Charm' } },
Zapdos: { abilities: { 0: 'Pressure' } },
Zubat: { abilities: { 0: 'Inner Focus' } },
Aipom: { abilities: { 0: 'Run Away' } },
Ampharos: { abilities: { 0: 'Static' } },
Ariados: { abilities: { 0: 'Swarm' } },
Azumarill: { abilities: { 0: 'Thick Fat' } },
Bayleef: { abilities: { 0: 'Overgrow' } },
Bellossom: { abilities: { 0: 'Chlorophyll' } },
Blissey: { abilities: { 0: 'Natural Cure' } },
Celebi: { abilities: { 0: 'Natural Cure' } },
Chikorita: { abilities: { 0: 'Overgrow' } },
Chinchou: { abilities: { 0: 'Volt Absorb' } },
Cleffa: { abilities: { 0: 'Cute Charm' } },
Corsola: { abilities: { 0: 'Hustle' } },
Crobat: { abilities: { 0: 'Inner Focus' } },
Croconaw: { abilities: { 0: 'Torrent' } },
Cyndaquil: { abilities: { 0: 'Blaze' } },
Delibird: { abilities: { 0: 'Vital Spirit' } },
Donphan: { abilities: { 0: 'Sturdy' } },
Dunsparce: { abilities: { 0: 'Serene Grace' } },
Elekid: { abilities: { 0: 'Static' } },
Entei: { abilities: { 0: 'Pressure' } },
Espeon: { abilities: { 0: 'Synchronize' } },
Feraligatr: { abilities: { 0: 'Torrent' } },
Flaaffy: { abilities: { 0: 'Static' } },
Forretress: { abilities: { 0: 'Sturdy' } },
Furret: { abilities: { 0: 'Run Away' } },
Girafarig: { abilities: { 0: 'Inner Focus' } },
Gligar: { abilities: { 0: 'Hyper Cutter' } },
Granbull: { abilities: { 0: 'Intimidate' } },
Heracross: { abilities: { 0: 'Swarm' } },
Hitmontop: { abilities: { 0: 'Intimidate' } },
'Ho-Oh': { abilities: { 0: 'Pressure' } },
Hoothoot: { abilities: { 0: 'Insomnia' } },
Hoppip: { abilities: { 0: 'Chlorophyll' } },
Houndoom: { abilities: { 0: 'Early Bird' } },
Houndour: { abilities: { 0: 'Early Bird' } },
Igglybuff: { abilities: { 0: 'Cute Charm' } },
Jumpluff: { abilities: { 0: 'Chlorophyll' } },
Kingdra: { abilities: { 0: 'Swift Swim' } },
Lanturn: { abilities: { 0: 'Volt Absorb' } },
Larvitar: { abilities: { 0: 'Guts' } },
Ledian: { abilities: { 0: 'Swarm' } },
Ledyba: { abilities: { 0: 'Swarm' } },
Lugia: { abilities: { 0: 'Pressure' } },
Magby: { abilities: { 0: 'Flame Body' } },
Magcargo: { abilities: { 0: 'Magma Armor' } },
Mantine: { abilities: { 0: 'Swift Swim' } },
Mareep: { abilities: { 0: 'Static' } },
Marill: { abilities: { 0: 'Thick Fat' } },
Meganium: { abilities: { 0: 'Overgrow' } },
Miltank: { abilities: { 0: 'Thick Fat' } },
Misdreavus: { abilities: { 0: 'Levitate' } },
Murkrow: { abilities: { 0: 'Insomnia' } },
Natu: { abilities: { 0: 'Synchronize' } },
Noctowl: { abilities: { 0: 'Insomnia' } },
Octillery: { abilities: { 0: 'Suction Cups' } },
Phanpy: { abilities: { 0: 'Pickup' } },
Pichu: { abilities: { 0: 'Static' } },
Piloswine: { abilities: { 0: 'Oblivious' } },
Pineco: { abilities: { 0: 'Sturdy' } },
Politoed: { abilities: { 0: 'Water Absorb' } },
Porygon2: { abilities: { 0: 'Trace' } },
Pupitar: { abilities: { 0: 'Shed Skin' } },
Quagsire: { abilities: { 0: 'Damp' } },
Quilava: { abilities: { 0: 'Blaze' } },
Qwilfish: { abilities: { 0: 'Poison Point' } },
Raikou: { abilities: { 0: 'Pressure' } },
Remoraid: { abilities: { 0: 'Hustle' } },
Scizor: { abilities: { 0: 'Swarm' } },
Sentret: { abilities: { 0: 'Run Away' } },
Shuckle: { abilities: { 0: 'Sturdy' } },
Skarmory: { abilities: { 0: 'Keen Eye' } },
Skiploom: { abilities: { 0: 'Chlorophyll' } },
Slowking: { abilities: { 0: 'Oblivious' } },
Slugma: { abilities: { 0: 'Magma Armor' } },
Smeargle: { abilities: { 0: 'Own Tempo' } },
Smoochum: { abilities: { 0: 'Oblivious' } },
Sneasel: { abilities: { 0: 'Inner Focus' } },
Snubbull: { abilities: { 0: 'Intimidate' } },
Spinarak: { abilities: { 0: 'Swarm' } },
Stantler: { abilities: { 0: 'Intimidate' } },
Steelix: { abilities: { 0: 'Rock Head' } },
Sudowoodo: { abilities: { 0: 'Sturdy' } },
Suicune: { abilities: { 0: 'Pressure' } },
Sunflora: { abilities: { 0: 'Chlorophyll' } },
Sunkern: { abilities: { 0: 'Chlorophyll' } },
Swinub: { abilities: { 0: 'Oblivious' } },
Teddiursa: { abilities: { 0: 'Pickup' } },
Togepi: { abilities: { 0: 'Hustle' } },
Togetic: { abilities: { 0: 'Hustle' } },
Totodile: { abilities: { 0: 'Torrent' } },
Typhlosion: { abilities: { 0: 'Blaze' } },
Tyranitar: { abilities: { 0: 'Sand Stream' } },
Tyrogue: { abilities: { 0: 'Guts' } },
Umbreon: { abilities: { 0: 'Synchronize' } },
Unown: { abilities: { 0: 'Levitate' } },
Ursaring: { abilities: { 0: 'Guts' } },
Wobbuffet: { abilities: { 0: 'Shadow Tag' } },
Wooper: { abilities: { 0: 'Damp' } },
Xatu: { abilities: { 0: 'Synchronize' } },
Yanma: { abilities: { 0: 'Speed Boost' } },
Absol: {
types: ['Dark'],
bs: { hp: 65, at: 130, df: 60, sa: 75, sd: 60, sp: 75 },
weightkg: 47,
abilities: { 0: 'Pressure' }
},
Aggron: {
types: ['Steel', 'Rock'],
bs: { hp: 70, at: 110, df: 180, sa: 60, sd: 60, sp: 50 },
weightkg: 360,
abilities: { 0: 'Sturdy' }
},
Altaria: {
types: ['Dragon', 'Flying'],
bs: { hp: 75, at: 70, df: 90, sa: 70, sd: 105, sp: 80 },
weightkg: 20.6,
abilities: { 0: 'Natural Cure' }
},
Anorith: {
types: ['Rock', 'Bug'],
bs: { hp: 45, at: 95, df: 50, sa: 40, sd: 50, sp: 75 },
weightkg: 12.5,
nfe: true,
abilities: { 0: 'Battle Armor' }
},
Armaldo: {
types: ['Rock', 'Bug'],
bs: { hp: 75, at: 125, df: 100, sa: 70, sd: 80, sp: 45 },
weightkg: 68.2,
abilities: { 0: 'Battle Armor' }
},
Aron: {
types: ['Steel', 'Rock'],
bs: { hp: 50, at: 70, df: 100, sa: 40, sd: 40, sp: 30 },
weightkg: 60,
nfe: true,
abilities: { 0: 'Sturdy' }
},
Azurill: {
types: ['Normal'],
bs: { hp: 50, at: 20, df: 40, sa: 20, sd: 40, sp: 20 },
weightkg: 2,
nfe: true,
abilities: { 0: 'Thick Fat' }
},
Bagon: {
types: ['Dragon'],
bs: { hp: 45, at: 75, df: 60, sa: 40, sd: 30, sp: 50 },
weightkg: 42.1,
nfe: true,
abilities: { 0: 'Rock Head' }
},
Baltoy: {
types: ['Ground', 'Psychic'],
bs: { hp: 40, at: 40, df: 55, sa: 40, sd: 70, sp: 55 },
weightkg: 21.5,
abilities: { 0: 'Levitate' },
nfe: true,
gender: 'N'
},
Banette: {
types: ['Ghost'],
bs: { hp: 64, at: 115, df: 65, sa: 83, sd: 63, sp: 65 },
weightkg: 12.5,
abilities: { 0: 'Insomnia' }
},
Barboach: {
types: ['Water', 'Ground'],
bs: { hp: 50, at: 48, df: 43, sa: 46, sd: 41, sp: 60 },
weightkg: 1.9,
nfe: true,
abilities: { 0: 'Oblivious' }
},
Beautifly: {
types: ['Bug', 'Flying'],
bs: { hp: 60, at: 70, df: 50, sa: 90, sd: 50, sp: 65 },
weightkg: 28.4,
abilities: { 0: 'Swarm' }
},
Beldum: {
types: ['Steel', 'Psychic'],
bs: { hp: 40, at: 55, df: 80, sa: 35, sd: 60, sp: 30 },
weightkg: 95.2,
nfe: true,
gender: 'N',
abilities: { 0: 'Clear Body' }
},
Blaziken: {
types: ['Fire', 'Fighting'],
bs: { hp: 80, at: 120, df: 70, sa: 110, sd: 70, sp: 80 },
weightkg: 52,
abilities: { 0: 'Blaze' }
},
Breloom: {
types: ['Grass', 'Fighting'],
bs: { hp: 60, at: 130, df: 80, sa: 60, sd: 60, sp: 70 },
weightkg: 39.2,
abilities: { 0: 'Effect Spore' }
},
Cacnea: {
types: ['Grass'],
bs: { hp: 50, at: 85, df: 40, sa: 85, sd: 40, sp: 35 },
weightkg: 51.3,
nfe: true,
abilities: { 0: 'Sand Veil' }
},
Cacturne: {
types: ['Grass', 'Dark'],
bs: { hp: 70, at: 115, df: 60, sa: 115, sd: 60, sp: 55 },
weightkg: 77.4,
abilities: { 0: 'Sand Veil' }
},
Camerupt: {
types: ['Fire', 'Ground'],
bs: { hp: 70, at: 100, df: 70, sa: 105, sd: 75, sp: 40 },
weightkg: 220,
abilities: { 0: 'Magma Armor' }
},
Carvanha: {
types: ['Water', 'Dark'],
bs: { hp: 45, at: 90, df: 20, sa: 65, sd: 20, sp: 65 },
weightkg: 20.8,
nfe: true,
abilities: { 0: 'Rough Skin' }
},
Cascoon: {
types: ['Bug'],
bs: { hp: 50, at: 35, df: 55, sa: 25, sd: 25, sp: 15 },
weightkg: 11.5,
abilities: { 0: 'Shed Skin' },
nfe: true
},
Castform: {
types: ['Normal'],
bs: { hp: 70, at: 70, df: 70, sa: 70, sd: 70, sp: 70 },
weightkg: 0.8,
abilities: { 0: 'Forecast' },
otherFormes: ['Castform-Rainy', 'Castform-Snowy', 'Castform-Sunny']
},
'Castform-Rainy': {
types: ['Water'],
bs: { hp: 70, at: 70, df: 70, sa: 70, sd: 70, sp: 70 },
weightkg: 0.8,
abilities: { 0: 'Forecast' },
baseSpecies: 'Castform'
},
'Castform-Snowy': {
types: ['Ice'],
bs: { hp: 70, at: 70, df: 70, sa: 70, sd: 70, sp: 70 },
weightkg: 0.8,
abilities: { 0: 'Forecast' },
baseSpecies: 'Castform'
},
'Castform-Sunny': {
types: ['Fire'],
bs: { hp: 70, at: 70, df: 70, sa: 70, sd: 70, sp: 70 },
weightkg: 0.8,
abilities: { 0: 'Forecast' },
baseSpecies: 'Castform'
},
Chimecho: {
types: ['Psychic'],
bs: { hp: 65, at: 50, df: 70, sa: 95, sd: 80, sp: 65 },
weightkg: 1,
abilities: { 0: 'Levitate' }
},
Clamperl: {
types: ['Water'],
bs: { hp: 35, at: 64, df: 85, sa: 74, sd: 55, sp: 32 },
weightkg: 52.5,
nfe: true,
abilities: { 0: 'Shell Armor' }
},
Claydol: {
types: ['Ground', 'Psychic'],
bs: { hp: 60, at: 70, df: 105, sa: 70, sd: 120, sp: 75 },
weightkg: 108,
abilities: { 0: 'Levitate' },
gender: 'N'
},
Combusken: {
types: ['Fire', 'Fighting'],
bs: { hp: 60, at: 85, df: 60, sa: 85, sd: 60, sp: 55 },
weightkg: 19.5,
nfe: true,
abilities: { 0: 'Blaze' }
},
Corphish: {
types: ['Water'],
bs: { hp: 43, at: 80, df: 65, sa: 50, sd: 35, sp: 35 },
weightkg: 11.5,
nfe: true,
abilities: { 0: 'Hyper Cutter' }
},
Cradily: {
types: ['Rock', 'Grass'],
bs: { hp: 86, at: 81, df: 97, sa: 81, sd: 107, sp: 43 },
weightkg: 60.4,
abilities: { 0: 'Suction Cups' }
},
Crawdaunt: {
types: ['Water', 'Dark'],
bs: { hp: 63, at: 120, df: 85, sa: 90, sd: 55, sp: 55 },
weightkg: 32.8,
abilities: { 0: 'Hyper Cutter' }
},
Delcatty: {
types: ['Normal'],
bs: { hp: 70, at: 65, df: 65, sa: 55, sd: 55, sp: 70 },
weightkg: 32.6,
abilities: { 0: 'Cute Charm' }
},
Deoxys: {
types: ['Psychic'],
bs: { hp: 50, at: 150, df: 50, sa: 150, sd: 50, sp: 150 },
weightkg: 60.8,
abilities: { 0: 'Pressure' },
gender: 'N',
otherFormes: ['Deoxys-Attack', 'Deoxys-Defense', 'Deoxys-Speed']
},
'Deoxys-Attack': {
types: ['Psychic'],
bs: { hp: 50, at: 180, df: 20, sa: 180, sd: 20, sp: 150 },
weightkg: 60.8,
abilities: { 0: 'Pressure' },
gender: 'N',
baseSpecies: 'Deoxys'
},
'Deoxys-Defense': {
types: ['Psychic'],
bs: { hp: 50, at: 70, df: 160, sa: 70, sd: 160, sp: 90 },
weightkg: 60.8,
abilities: { 0: 'Pressure' },
gender: 'N',
baseSpecies: 'Deoxys'
},
'Deoxys-Speed': {
types: ['Psychic'],
bs: { hp: 50, at: 95, df: 90, sa: 95, sd: 90, sp: 180 },
weightkg: 60.8,
abilities: { 0: 'Pressure' },
gender: 'N',
baseSpecies: 'Deoxys'
},
Dusclops: {
types: ['Ghost'],
bs: { hp: 40, at: 70, df: 130, sa: 60, sd: 130, sp: 25 },
weightkg: 30.6,
abilities: { 0: 'Pressure' }
},
Duskull: {
types: ['Ghost'],
bs: { hp: 20, at: 40, df: 90, sa: 30, sd: 90, sp: 25 },
weightkg: 15,
nfe: true,
abilities: { 0: 'Levitate' }
},
Dustox: {
types: ['Bug', 'Poison'],
bs: { hp: 60, at: 50, df: 70, sa: 50, sd: 90, sp: 65 },
weightkg: 31.6,
abilities: { 0: 'Shield Dust' }
},
Electrike: {
types: ['Electric'],
bs: { hp: 40, at: 45, df: 40, sa: 65, sd: 40, sp: 65 },
weightkg: 15.2,
nfe: true,
abilities: { 0: 'Static' }
},
Exploud: {
types: ['Normal'],
bs: { hp: 104, at: 91, df: 63, sa: 91, sd: 63, sp: 68 },
weightkg: 84,
abilities: { 0: 'Soundproof' }
},
Feebas: {
types: ['Water'],
bs: { hp: 20, at: 15, df: 20, sa: 10, sd: 55, sp: 80 },
weightkg: 7.4,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Flygon: {
types: ['Ground', 'Dragon'],
bs: { hp: 80, at: 100, df: 80, sa: 80, sd: 80, sp: 100 },
weightkg: 82,
abilities: { 0: 'Levitate' }
},
Gardevoir: {
types: ['Psychic'],
bs: { hp: 68, at: 65, df: 65, sa: 125, sd: 115, sp: 80 },
weightkg: 48.4,
abilities: { 0: 'Synchronize' }
},
Glalie: {
types: ['Ice'],
bs: { hp: 80, at: 80, df: 80, sa: 80, sd: 80, sp: 80 },
weightkg: 256.5,
abilities: { 0: 'Inner Focus' }
},
Gorebyss: {
types: ['Water'],
bs: { hp: 55, at: 84, df: 105, sa: 114, sd: 75, sp: 52 },
weightkg: 22.6,
abilities: { 0: 'Swift Swim' }
},
Groudon: {
types: ['Ground'],
bs: { hp: 100, at: 150, df: 140, sa: 100, sd: 90, sp: 90 },
weightkg: 950,
abilities: { 0: 'Drought' },
gender: 'N'
},
Grovyle: {
types: ['Grass'],
bs: { hp: 50, at: 65, df: 45, sa: 85, sd: 65, sp: 95 },
weightkg: 21.6,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Grumpig: {
types: ['Psychic'],
bs: { hp: 80, at: 45, df: 65, sa: 90, sd: 110, sp: 80 },
weightkg: 71.5,
abilities: { 0: 'Thick Fat' }
},
Gulpin: {
types: ['Poison'],
bs: { hp: 70, at: 43, df: 53, sa: 43, sd: 53, sp: 40 },
weightkg: 10.3,
nfe: true,
abilities: { 0: 'Liquid Ooze' }
},
Hariyama: {
types: ['Fighting'],
bs: { hp: 144, at: 120, df: 60, sa: 40, sd: 60, sp: 50 },
weightkg: 253.8,
abilities: { 0: 'Thick Fat' }
},
Huntail: {
types: ['Water'],
bs: { hp: 55, at: 104, df: 105, sa: 94, sd: 75, sp: 52 },
weightkg: 27,
abilities: { 0: 'Swift Swim' }
},
Illumise: {
types: ['Bug'],
bs: { hp: 65, at: 47, df: 55, sa: 73, sd: 75, sp: 85 },
abilities: { 0: 'Oblivious' },
weightkg: 17.7
},
Jirachi: {
types: ['Steel', 'Psychic'],
bs: { hp: 100, at: 100, df: 100, sa: 100, sd: 100, sp: 100 },
weightkg: 1.1,
abilities: { 0: 'Serene Grace' },
gender: 'N'
},
Kecleon: {
types: ['Normal'],
bs: { hp: 60, at: 90, df: 70, sa: 60, sd: 120, sp: 40 },
weightkg: 22,
abilities: { 0: 'Color Change' }
},
Kirlia: {
types: ['Psychic'],
bs: { hp: 38, at: 35, df: 35, sa: 65, sd: 55, sp: 50 },
weightkg: 20.2,
nfe: true,
abilities: { 0: 'Synchronize' }
},
Kyogre: {
types: ['Water'],
bs: { hp: 100, at: 100, df: 90, sa: 150, sd: 140, sp: 90 },
weightkg: 352,
abilities: { 0: 'Drizzle' },
gender: 'N'
},
Lairon: {
types: ['Steel', 'Rock'],
bs: { hp: 60, at: 90, df: 140, sa: 50, sd: 50, sp: 40 },
weightkg: 120,
nfe: true,
abilities: { 0: 'Sturdy' }
},
Latias: {
types: ['Dragon', 'Psychic'],
bs: { hp: 80, at: 80, df: 90, sa: 110, sd: 130, sp: 110 },
weightkg: 40,
abilities: { 0: 'Levitate' }
},
Latios: {
types: ['Dragon', 'Psychic'],
bs: { hp: 80, at: 90, df: 80, sa: 130, sd: 110, sp: 110 },
weightkg: 60,
abilities: { 0: 'Levitate' }
},
Lileep: {
types: ['Rock', 'Grass'],
bs: { hp: 66, at: 41, df: 77, sa: 61, sd: 87, sp: 23 },
weightkg: 23.8,
nfe: true,
abilities: { 0: 'Suction Cups' }
},
Linoone: {
types: ['Normal'],
bs: { hp: 78, at: 70, df: 61, sa: 50, sd: 61, sp: 100 },
weightkg: 32.5,
abilities: { 0: 'Pickup' }
},
Lombre: {
types: ['Water', 'Grass'],
bs: { hp: 60, at: 50, df: 50, sa: 60, sd: 70, sp: 50 },
weightkg: 32.5,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Lotad: {
types: ['Water', 'Grass'],
bs: { hp: 40, at: 30, df: 30, sa: 40, sd: 50, sp: 30 },
weightkg: 2.6,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Loudred: {
types: ['Normal'],
bs: { hp: 84, at: 71, df: 43, sa: 71, sd: 43, sp: 48 },
weightkg: 40.5,
nfe: true,
abilities: { 0: 'Soundproof' }
},
Ludicolo: {
types: ['Water', 'Grass'],
bs: { hp: 80, at: 70, df: 70, sa: 90, sd: 100, sp: 70 },
weightkg: 55,
abilities: { 0: 'Swift Swim' }
},
Lunatone: {
types: ['Rock', 'Psychic'],
bs: { hp: 70, at: 55, df: 65, sa: 95, sd: 85, sp: 70 },
weightkg: 168,
abilities: { 0: 'Levitate' },
gender: 'N'
},
Luvdisc: {
types: ['Water'],
bs: { hp: 43, at: 30, df: 55, sa: 40, sd: 65, sp: 97 },
weightkg: 8.7,
abilities: { 0: 'Swift Swim' }
},
Makuhita: {
types: ['Fighting'],
bs: { hp: 72, at: 60, df: 30, sa: 20, sd: 30, sp: 25 },
weightkg: 86.4,
nfe: true,
abilities: { 0: 'Thick Fat' }
},
Manectric: {
types: ['Electric'],
bs: { hp: 70, at: 75, df: 60, sa: 105, sd: 60, sp: 105 },
weightkg: 40.2,
abilities: { 0: 'Static' }
},
Marshtomp: {
types: ['Water', 'Ground'],
bs: { hp: 70, at: 85, df: 70, sa: 60, sd: 70, sp: 50 },
weightkg: 28,
nfe: true,
abilities: { 0: 'Torrent' }
},
Masquerain: {
types: ['Bug', 'Flying'],
bs: { hp: 70, at: 60, df: 62, sa: 80, sd: 82, sp: 60 },
weightkg: 3.6,
abilities: { 0: 'Intimidate' }
},
Mawile: {
types: ['Steel'],
bs: { hp: 50, at: 85, df: 85, sa: 55, sd: 55, sp: 50 },
weightkg: 11.5,
abilities: { 0: 'Hyper Cutter' }
},
Medicham: {
types: ['Fighting', 'Psychic'],
bs: { hp: 60, at: 60, df: 75, sa: 60, sd: 75, sp: 80 },
weightkg: 31.5,
abilities: { 0: 'Pure Power' }
},
Meditite: {
types: ['Fighting', 'Psychic'],
bs: { hp: 30, at: 40, df: 55, sa: 40, sd: 55, sp: 60 },
weightkg: 11.2,
nfe: true,
abilities: { 0: 'Pure Power' }
},
Metagross: {
types: ['Steel', 'Psychic'],
bs: { hp: 80, at: 135, df: 130, sa: 95, sd: 90, sp: 70 },
weightkg: 550,
gender: 'N',
abilities: { 0: 'Clear Body' }
},
Metang: {
types: ['Steel', 'Psychic'],
bs: { hp: 60, at: 75, df: 100, sa: 55, sd: 80, sp: 50 },
weightkg: 202.5,
nfe: true,
gender: 'N',
abilities: { 0: 'Clear Body' }
},
Mightyena: {
types: ['Dark'],
bs: { hp: 70, at: 90, df: 70, sa: 60, sd: 60, sp: 70 },
weightkg: 37,
abilities: { 0: 'Intimidate' }
},
Milotic: {
types: ['Water'],
bs: { hp: 95, at: 60, df: 79, sa: 100, sd: 125, sp: 81 },
weightkg: 162,
abilities: { 0: 'Marvel Scale' }
},
Minun: {
types: ['Electric'],
bs: { hp: 60, at: 40, df: 50, sa: 75, sd: 85, sp: 95 },
weightkg: 4.2,
abilities: { 0: 'Minus' }
},
Mudkip: {
types: ['Water'],
bs: { hp: 50, at: 70, df: 50, sa: 50, sd: 50, sp: 40 },
weightkg: 7.6,
nfe: true,
abilities: { 0: 'Torrent' }
},
Nincada: {
types: ['Bug', 'Ground'],
bs: { hp: 31, at: 45, df: 90, sa: 30, sd: 30, sp: 40 },
weightkg: 5.5,
nfe: true,
abilities: { 0: 'Compound Eyes' }
},
Ninjask: {
types: ['Bug', 'Flying'],
bs: { hp: 61, at: 90, df: 45, sa: 50, sd: 50, sp: 160 },
weightkg: 12,
abilities: { 0: 'Speed Boost' }
},
Nosepass: {
types: ['Rock'],
bs: { hp: 30, at: 45, df: 135, sa: 45, sd: 90, sp: 30 },
weightkg: 97,
abilities: { 0: 'Sturdy' }
},
Numel: {
types: ['Fire', 'Ground'],
bs: { hp: 60, at: 60, df: 40, sa: 65, sd: 45, sp: 35 },
weightkg: 24,
nfe: true,
abilities: { 0: 'Oblivious' }
},
Nuzleaf: {
types: ['Grass', 'Dark'],
bs: { hp: 70, at: 70, df: 40, sa: 60, sd: 40, sp: 60 },
weightkg: 28,
nfe: true,
abilities: { 0: 'Chlorophyll' }
},
Pelipper: {
types: ['Water', 'Flying'],
bs: { hp: 60, at: 50, df: 100, sa: 85, sd: 70, sp: 65 },
weightkg: 28,
abilities: { 0: 'Keen Eye' }
},
Plusle: {
types: ['Electric'],
bs: { hp: 60, at: 50, df: 40, sa: 85, sd: 75, sp: 95 },
weightkg: 4.2,
abilities: { 0: 'Plus' }
},
Poochyena: {
types: ['Dark'],
bs: { hp: 35, at: 55, df: 35, sa: 30, sd: 30, sp: 35 },
weightkg: 13.6,
nfe: true,
abilities: { 0: 'Run Away' }
},
Ralts: {
types: ['Psychic'],
bs: { hp: 28, at: 25, df: 25, sa: 45, sd: 35, sp: 40 },
weightkg: 6.6,
nfe: true,
abilities: { 0: 'Synchronize' }
},
Rayquaza: {
types: ['Dragon', 'Flying'],
bs: { hp: 105, at: 150, df: 90, sa: 150, sd: 90, sp: 95 },
weightkg: 206.5,
abilities: { 0: 'Air Lock' },
gender: 'N'
},
Regice: {
types: ['Ice'],
bs: { hp: 80, at: 50, df: 100, sa: 100, sd: 200, sp: 50 },
weightkg: 175,
gender: 'N',
abilities: { 0: 'Clear Body' }
},
Regirock: {
types: ['Rock'],
bs: { hp: 80, at: 100, df: 200, sa: 50, sd: 100, sp: 50 },
weightkg: 230,
gender: 'N',
abilities: { 0: 'Clear Body' }
},
Registeel: {
types: ['Steel'],
bs: { hp: 80, at: 75, df: 150, sa: 75, sd: 150, sp: 50 },
weightkg: 205,
gender: 'N',
abilities: { 0: 'Clear Body' }
},
Relicanth: {
types: ['Water', 'Rock'],
bs: { hp: 100, at: 90, df: 130, sa: 45, sd: 65, sp: 55 },
weightkg: 23.4,
abilities: { 0: 'Swift Swim' }
},
Roselia: {
types: ['Grass', 'Poison'],
bs: { hp: 50, at: 60, df: 45, sa: 100, sd: 80, sp: 65 },
weightkg: 2,
abilities: { 0: 'Natural Cure' }
},
Sableye: {
types: ['Dark', 'Ghost'],
bs: { hp: 50, at: 75, df: 75, sa: 65, sd: 65, sp: 50 },
weightkg: 11,
abilities: { 0: 'Keen Eye' }
},
Salamence: {
types: ['Dragon', 'Flying'],
bs: { hp: 95, at: 135, df: 80, sa: 110, sd: 80, sp: 100 },
weightkg: 102.6,
abilities: { 0: 'Intimidate' }
},
Sceptile: {
types: ['Grass'],
bs: { hp: 70, at: 85, df: 65, sa: 105, sd: 85, sp: 120 },
weightkg: 52.2,
abilities: { 0: 'Overgrow' }
},
Sealeo: {
types: ['Ice', 'Water'],
bs: { hp: 90, at: 60, df: 70, sa: 75, sd: 70, sp: 45 },
weightkg: 87.6,
nfe: true,
abilities: { 0: 'Thick Fat' }
},
Seedot: {
types: ['Grass'],
bs: { hp: 40, at: 40, df: 50, sa: 30, sd: 30, sp: 30 },
weightkg: 4,
nfe: true,
abilities: { 0: 'Chlorophyll' }
},
Seviper: {
types: ['Poison'],
bs: { hp: 73, at: 100, df: 60, sa: 100, sd: 60, sp: 65 },
weightkg: 52.5,
abilities: { 0: 'Shed Skin' }
},
Sharpedo: {
types: ['Water', 'Dark'],
bs: { hp: 70, at: 120, df: 40, sa: 95, sd: 40, sp: 95 },
weightkg: 88.8,
abilities: { 0: 'Rough Skin' }
},
Shedinja: {
types: ['Bug', 'Ghost'],
bs: { hp: 1, at: 90, df: 45, sa: 30, sd: 30, sp: 40 },
weightkg: 1.2,
abilities: { 0: 'Wonder Guard' },
gender: 'N'
},
Shelgon: {
types: ['Dragon'],
bs: { hp: 65, at: 95, df: 100, sa: 60, sd: 50, sp: 50 },
weightkg: 110.5,
nfe: true,
abilities: { 0: 'Rock Head' }
},
Shiftry: {
types: ['Grass', 'Dark'],
bs: { hp: 90, at: 100, df: 60, sa: 90, sd: 60, sp: 80 },
weightkg: 59.6,
abilities: { 0: 'Chlorophyll' }
},
Shroomish: {
types: ['Grass'],
bs: { hp: 60, at: 40, df: 60, sa: 40, sd: 60, sp: 35 },
weightkg: 4.5,
nfe: true,
abilities: { 0: 'Effect Spore' }
},
Shuppet: {
types: ['Ghost'],
bs: { hp: 44, at: 75, df: 35, sa: 63, sd: 33, sp: 45 },
weightkg: 2.3,
nfe: true,
abilities: { 0: 'Insomnia' }
},
Silcoon: {
types: ['Bug'],
bs: { hp: 50, at: 35, df: 55, sa: 25, sd: 25, sp: 15 },
weightkg: 10,
abilities: { 0: 'Shed Skin' },
nfe: true
},
Skitty: {
types: ['Normal'],
bs: { hp: 50, at: 45, df: 45, sa: 35, sd: 35, sp: 50 },
weightkg: 11,
nfe: true,
abilities: { 0: 'Cute Charm' }
},
Slaking: {
types: ['Normal'],
bs: { hp: 150, at: 160, df: 100, sa: 95, sd: 65, sp: 100 },
weightkg: 130.5,
abilities: { 0: 'Truant' }
},
Slakoth: {
types: ['Normal'],
bs: { hp: 60, at: 60, df: 60, sa: 35, sd: 35, sp: 30 },
weightkg: 24,
abilities: { 0: 'Truant' },
nfe: true
},
Snorunt: {
types: ['Ice'],
bs: { hp: 50, at: 50, df: 50, sa: 50, sd: 50, sp: 50 },
weightkg: 16.8,
nfe: true,
abilities: { 0: 'Inner Focus' }
},
Solrock: {
types: ['Rock', 'Psychic'],
bs: { hp: 70, at: 95, df: 85, sa: 55, sd: 65, sp: 70 },
weightkg: 154,
abilities: { 0: 'Levitate' },
gender: 'N'
},
Spheal: {
types: ['Ice', 'Water'],
bs: { hp: 70, at: 40, df: 50, sa: 55, sd: 50, sp: 25 },
weightkg: 39.5,
nfe: true,
abilities: { 0: 'Thick Fat' }
},
Spinda: {
types: ['Normal'],
bs: { hp: 60, at: 60, df: 60, sa: 60, sd: 60, sp: 60 },
weightkg: 5,
abilities: { 0: 'Own Tempo' }
},
Spoink: {
types: ['Psychic'],
bs: { hp: 60, at: 25, df: 35, sa: 70, sd: 80, sp: 60 },
weightkg: 30.6,
nfe: true,
abilities: { 0: 'Thick Fat' }
},
Surskit: {
types: ['Bug', 'Water'],
bs: { hp: 40, at: 30, df: 32, sa: 50, sd: 52, sp: 65 },
weightkg: 1.7,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Swablu: {
types: ['Normal', 'Flying'],
bs: { hp: 45, at: 40, df: 60, sa: 40, sd: 75, sp: 50 },
weightkg: 1.2,
nfe: true,
abilities: { 0: 'Natural Cure' }
},
Swalot: {
types: ['Poison'],
bs: { hp: 100, at: 73, df: 83, sa: 73, sd: 83, sp: 55 },
weightkg: 80,
abilities: { 0: 'Liquid Ooze' }
},
Swampert: {
types: ['Water', 'Ground'],
bs: { hp: 100, at: 110, df: 90, sa: 85, sd: 90, sp: 60 },
weightkg: 81.9,
abilities: { 0: 'Torrent' }
},
Swellow: {
types: ['Normal', 'Flying'],
bs: { hp: 60, at: 85, df: 60, sa: 50, sd: 50, sp: 125 },
weightkg: 19.8,
abilities: { 0: 'Guts' }
},
Taillow: {
types: ['Normal', 'Flying'],
bs: { hp: 40, at: 55, df: 30, sa: 30, sd: 30, sp: 85 },
weightkg: 2.3,
nfe: true,
abilities: { 0: 'Guts' }
},
Torchic: {
types: ['Fire'],
bs: { hp: 45, at: 60, df: 40, sa: 70, sd: 50, sp: 45 },
weightkg: 2.5,
nfe: true,
abilities: { 0: 'Blaze' }
},
Torkoal: {
types: ['Fire'],
bs: { hp: 70, at: 85, df: 140, sa: 85, sd: 70, sp: 20 },
weightkg: 80.4,
abilities: { 0: 'White Smoke' }
},
Trapinch: {
types: ['Ground'],
bs: { hp: 45, at: 100, df: 45, sa: 45, sd: 45, sp: 10 },
weightkg: 15,
nfe: true,
abilities: { 0: 'Hyper Cutter' }
},
Treecko: {
types: ['Grass'],
bs: { hp: 40, at: 45, df: 35, sa: 65, sd: 55, sp: 70 },
weightkg: 5,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Tropius: {
types: ['Grass', 'Flying'],
bs: { hp: 99, at: 68, df: 83, sa: 72, sd: 87, sp: 51 },
weightkg: 100,
abilities: { 0: 'Chlorophyll' }
},
Vibrava: {
types: ['Ground', 'Dragon'],
bs: { hp: 50, at: 70, df: 50, sa: 50, sd: 50, sp: 70 },
weightkg: 15.3,
abilities: { 0: 'Levitate' },
nfe: true
},
Vigoroth: {
types: ['Normal'],
bs: { hp: 80, at: 80, df: 80, sa: 55, sd: 55, sp: 90 },
weightkg: 46.5,
abilities: { 0: 'Vital Spirit' },
nfe: true
},
Volbeat: {
types: ['Bug'],
bs: { hp: 65, at: 73, df: 55, sa: 47, sd: 75, sp: 85 },
weightkg: 17.7,
abilities: { 0: 'Illuminate' }
},
Wailmer: {
types: ['Water'],
bs: { hp: 130, at: 70, df: 35, sa: 70, sd: 35, sp: 60 },
weightkg: 130,
nfe: true,
abilities: { 0: 'Water Veil' }
},
Wailord: {
types: ['Water'],
bs: { hp: 170, at: 90, df: 45, sa: 90, sd: 45, sp: 60 },
weightkg: 398,
abilities: { 0: 'Water Veil' }
},
Walrein: {
types: ['Ice', 'Water'],
bs: { hp: 110, at: 80, df: 90, sa: 95, sd: 90, sp: 65 },
weightkg: 150.6,
abilities: { 0: 'Thick Fat' }
},
Whiscash: {
types: ['Water', 'Ground'],
bs: { hp: 110, at: 78, df: 73, sa: 76, sd: 71, sp: 60 },
weightkg: 23.6,
abilities: { 0: 'Oblivious' }
},
Whismur: {
types: ['Normal'],
bs: { hp: 64, at: 51, df: 23, sa: 51, sd: 23, sp: 28 },
weightkg: 16.3,
nfe: true,
abilities: { 0: 'Soundproof' }
},
Wingull: {
types: ['Water', 'Flying'],
bs: { hp: 40, at: 30, df: 30, sa: 55, sd: 30, sp: 85 },
weightkg: 9.5,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Wurmple: {
types: ['Bug'],
bs: { hp: 45, at: 45, df: 35, sa: 20, sd: 30, sp: 20 },
weightkg: 3.6,
nfe: true,
abilities: { 0: 'Shield Dust' }
},
Wynaut: {
types: ['Psychic'],
bs: { hp: 95, at: 23, df: 48, sa: 23, sd: 48, sp: 23 },
weightkg: 14,
nfe: true,
abilities: { 0: 'Shadow Tag' }
},
Zangoose: {
types: ['Normal'],
bs: { hp: 73, at: 115, df: 60, sa: 60, sd: 60, sp: 90 },
weightkg: 40.3,
abilities: { 0: 'Immunity' }
},
Zigzagoon: {
types: ['Normal'],
bs: { hp: 38, at: 30, df: 41, sa: 30, sd: 41, sp: 60 },
weightkg: 17.5,
nfe: true,
abilities: { 0: 'Pickup' }
}
};
var ADV = util_1.extend(true, {}, GSC, ADV_PATCH);
var DPP_PATCH = {
Aipom: { nfe: true },
Dusclops: { nfe: true },
Electabuzz: { nfe: true },
Gligar: { nfe: true },
Lickitung: { nfe: true },
Magmar: { nfe: true },
Magneton: { nfe: true },
Misdreavus: { nfe: true },
Murkrow: { nfe: true },
Nosepass: { nfe: true },
Piloswine: { nfe: true },
Pichu: { otherFormes: ['Pichu-Spiky-eared'] },
Porygon2: { nfe: true },
Rhydon: { nfe: true },
Roselia: { nfe: true },
Sneasel: { nfe: true },
Tangela: { nfe: true },
Togetic: { nfe: true },
Yanma: { nfe: true },
Abomasnow: {
types: ['Grass', 'Ice'],
bs: { hp: 90, at: 92, df: 75, sa: 92, sd: 85, sp: 60 },
weightkg: 135.5,
abilities: { 0: 'Snow Warning' }
},
Ambipom: {
types: ['Normal'],
bs: { hp: 75, at: 100, df: 66, sa: 60, sd: 66, sp: 115 },
weightkg: 20.3,
abilities: { 0: 'Technician' }
},
Arceus: {
types: ['Normal'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
otherFormes: [
'Arceus-Bug',
'Arceus-Dark',
'Arceus-Dragon',
'Arceus-Electric',
'Arceus-Fighting',
'Arceus-Fire',
'Arceus-Flying',
'Arceus-Ghost',
'Arceus-Grass',
'Arceus-Ground',
'Arceus-Ice',
'Arceus-Poison',
'Arceus-Psychic',
'Arceus-Rock',
'Arceus-Steel',
'Arceus-Water',
]
},
'Arceus-Bug': {
types: ['Bug'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Dark': {
types: ['Dark'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Dragon': {
types: ['Dragon'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Electric': {
types: ['Electric'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Fighting': {
types: ['Fighting'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Fire': {
types: ['Fire'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Flying': {
types: ['Flying'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Ghost': {
types: ['Ghost'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Grass': {
types: ['Grass'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Ground': {
types: ['Ground'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Ice': {
types: ['Ice'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Poison': {
types: ['Poison'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Psychic': {
types: ['Psychic'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Rock': {
types: ['Rock'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Steel': {
types: ['Steel'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
'Arceus-Water': {
types: ['Water'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
gender: 'N',
baseSpecies: 'Arceus'
},
Arghonaut: {
types: ['Water', 'Fighting'],
bs: { hp: 105, at: 110, df: 95, sa: 70, sd: 100, sp: 75 },
weightkg: 151,
abilities: { 0: 'Unaware' }
},
Azelf: {
types: ['Psychic'],
bs: { hp: 75, at: 125, df: 70, sa: 125, sd: 70, sp: 115 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N'
},
Bastiodon: {
types: ['Rock', 'Steel'],
bs: { hp: 60, at: 52, df: 168, sa: 47, sd: 138, sp: 30 },
weightkg: 149.5,
abilities: { 0: 'Sturdy' }
},
Bibarel: {
types: ['Normal', 'Water'],
bs: { hp: 79, at: 85, df: 60, sa: 55, sd: 60, sp: 71 },
weightkg: 31.5,
abilities: { 0: 'Simple' }
},
Bidoof: {
types: ['Normal'],
bs: { hp: 59, at: 45, df: 40, sa: 35, sd: 40, sp: 31 },
weightkg: 20,
nfe: true,
abilities: { 0: 'Simple' }
},
Bonsly: {
types: ['Rock'],
bs: { hp: 50, at: 80, df: 95, sa: 10, sd: 45, sp: 10 },
weightkg: 15,
nfe: true,
abilities: { 0: 'Sturdy' }
},
Breezi: {
types: ['Poison', 'Flying'],
bs: { hp: 50, at: 46, df: 69, sa: 60, sd: 50, sp: 75 },
weightkg: 0.6,
nfe: true,
abilities: { 0: 'Unburden' }
},
Bronzong: {
types: ['Steel', 'Psychic'],
bs: { hp: 67, at: 89, df: 116, sa: 79, sd: 116, sp: 33 },
weightkg: 187,
gender: 'N',
abilities: { 0: 'Levitate' }
},
Bronzor: {
types: ['Steel', 'Psychic'],
bs: { hp: 57, at: 24, df: 86, sa: 24, sd: 86, sp: 23 },
weightkg: 60.5,
nfe: true,
gender: 'N',
abilities: { 0: 'Levitate' }
},
Budew: {
types: ['Grass', 'Poison'],
bs: { hp: 40, at: 30, df: 35, sa: 50, sd: 70, sp: 55 },
weightkg: 1.2,
nfe: true,
abilities: { 0: 'Natural Cure' }
},
Buizel: {
types: ['Water'],
bs: { hp: 55, at: 65, df: 35, sa: 60, sd: 30, sp: 85 },
weightkg: 29.5,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Buneary: {
types: ['Normal'],
bs: { hp: 55, at: 66, df: 44, sa: 44, sd: 56, sp: 85 },
weightkg: 5.5,
nfe: true,
abilities: { 0: 'Run Away' }
},
Burmy: {
types: ['Bug'],
bs: { hp: 40, at: 29, df: 45, sa: 29, sd: 45, sp: 36 },
weightkg: 3.4,
nfe: true,
abilities: { 0: 'Shed Skin' }
},
Carnivine: {
types: ['Grass'],
bs: { hp: 74, at: 100, df: 72, sa: 90, sd: 72, sp: 46 },
weightkg: 27,
abilities: { 0: 'Levitate' }
},
Chatot: {
types: ['Normal', 'Flying'],
bs: { hp: 76, at: 65, df: 45, sa: 92, sd: 42, sp: 91 },
weightkg: 1.9,
abilities: { 0: 'Keen Eye' }
},
Cherrim: {
types: ['Grass'],
bs: { hp: 70, at: 60, df: 70, sa: 87, sd: 78, sp: 85 },
weightkg: 9.3,
abilities: { 0: 'Flower Gift' },
otherFormes: ['Cherrim-Sunshine']
},
'Cherrim-Sunshine': {
types: ['Grass'],
bs: { hp: 70, at: 60, df: 70, sa: 87, sd: 78, sp: 85 },
weightkg: 9.3,
abilities: { 0: 'Flower Gift' },
baseSpecies: 'Cherrim'
},
Cherubi: {
types: ['Grass'],
bs: { hp: 45, at: 35, df: 45, sa: 62, sd: 53, sp: 35 },
weightkg: 3.3,
abilities: { 0: 'Chlorophyll' },
nfe: true
},
Chimchar: {
types: ['Fire'],
bs: { hp: 44, at: 58, df: 44, sa: 58, sd: 44, sp: 61 },
weightkg: 6.2,
nfe: true,
abilities: { 0: 'Blaze' }
},
Chingling: {
types: ['Psychic'],
bs: { hp: 45, at: 30, df: 50, sa: 65, sd: 50, sp: 45 },
weightkg: 0.6,
abilities: { 0: 'Levitate' },
nfe: true
},
Colossoil: {
types: ['Dark', 'Ground'],
bs: { hp: 133, at: 122, df: 72, sa: 71, sd: 72, sp: 95 },
weightkg: 683.6,
abilities: { 0: 'Rebound' }
},
Combee: {
types: ['Bug', 'Flying'],
bs: { hp: 30, at: 30, df: 42, sa: 30, sd: 42, sp: 70 },
weightkg: 5.5,
nfe: true,
abilities: { 0: 'Honey Gather' }
},
Cranidos: {
types: ['Rock'],
bs: { hp: 67, at: 125, df: 40, sa: 30, sd: 30, sp: 58 },
weightkg: 31.5,
nfe: true,
abilities: { 0: 'Mold Breaker' }
},
Cresselia: {
types: ['Psychic'],
bs: { hp: 120, at: 70, df: 120, sa: 75, sd: 130, sp: 85 },
weightkg: 85.6,
abilities: { 0: 'Levitate' }
},
Croagunk: {
types: ['Poison', 'Fighting'],
bs: { hp: 48, at: 61, df: 40, sa: 61, sd: 40, sp: 50 },
weightkg: 23,
nfe: true,
abilities: { 0: 'Anticipation' }
},
Cyclohm: {
types: ['Electric', 'Dragon'],
bs: { hp: 108, at: 60, df: 118, sa: 112, sd: 70, sp: 80 },
weightkg: 59,
abilities: { 0: 'Shield Dust' }
},
Darkrai: {
types: ['Dark'],
bs: { hp: 70, at: 90, df: 90, sa: 135, sd: 90, sp: 125 },
weightkg: 50.5,
abilities: { 0: 'Bad Dreams' },
gender: 'N'
},
Dialga: {
types: ['Steel', 'Dragon'],
bs: { hp: 100, at: 120, df: 120, sa: 150, sd: 100, sp: 90 },
weightkg: 683,
gender: 'N',
abilities: { 0: 'Pressure' }
},
Drapion: {
types: ['Poison', 'Dark'],
bs: { hp: 70, at: 90, df: 110, sa: 60, sd: 75, sp: 95 },
weightkg: 61.5,
abilities: { 0: 'Battle Armor' }
},
Drifblim: {
types: ['Ghost', 'Flying'],
bs: { hp: 150, at: 80, df: 44, sa: 90, sd: 54, sp: 80 },
weightkg: 15,
abilities: { 0: 'Aftermath' }
},
Drifloon: {
types: ['Ghost', 'Flying'],
bs: { hp: 90, at: 50, df: 34, sa: 60, sd: 44, sp: 70 },
weightkg: 1.2,
nfe: true,
abilities: { 0: 'Aftermath' }
},
Dusknoir: {
types: ['Ghost'],
bs: { hp: 45, at: 100, df: 135, sa: 65, sd: 135, sp: 45 },
weightkg: 106.6,
abilities: { 0: 'Pressure' }
},
Electivire: {
types: ['Electric'],
bs: { hp: 75, at: 123, df: 67, sa: 95, sd: 85, sp: 95 },
weightkg: 138.6,
abilities: { 0: 'Motor Drive' }
},
Embirch: {
types: ['Fire', 'Grass'],
bs: { hp: 60, at: 40, df: 55, sa: 65, sd: 40, sp: 60 },
weightkg: 15,
nfe: true,
abilities: { 0: 'Reckless' }
},
Empoleon: {
types: ['Water', 'Steel'],
bs: { hp: 84, at: 86, df: 88, sa: 111, sd: 101, sp: 60 },
weightkg: 84.5,
abilities: { 0: 'Torrent' }
},
Fidgit: {
types: ['Poison', 'Ground'],
bs: { hp: 95, at: 76, df: 109, sa: 90, sd: 80, sp: 105 },
weightkg: 53,
abilities: { 0: 'Persistent' }
},
Finneon: {
types: ['Water'],
bs: { hp: 49, at: 49, df: 56, sa: 49, sd: 61, sp: 66 },
weightkg: 7,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Flarelm: {
types: ['Fire', 'Grass'],
bs: { hp: 90, at: 50, df: 95, sa: 75, sd: 70, sp: 40 },
weightkg: 73,
nfe: true,
abilities: { 0: 'Rock Head' }
},
Floatzel: {
types: ['Water'],
bs: { hp: 85, at: 105, df: 55, sa: 85, sd: 50, sp: 115 },
weightkg: 33.5,
abilities: { 0: 'Swift Swim' }
},
Froslass: {
types: ['Ice', 'Ghost'],
bs: { hp: 70, at: 80, df: 70, sa: 80, sd: 70, sp: 110 },
weightkg: 26.6,
abilities: { 0: 'Snow Cloak' }
},
Gabite: {
types: ['Dragon', 'Ground'],
bs: { hp: 68, at: 90, df: 65, sa: 50, sd: 55, sp: 82 },
weightkg: 56,
nfe: true,
abilities: { 0: 'Sand Veil' }
},
Gallade: {
types: ['Psychic', 'Fighting'],
bs: { hp: 68, at: 125, df: 65, sa: 65, sd: 115, sp: 80 },
weightkg: 52,
abilities: { 0: 'Steadfast' }
},
Garchomp: {
types: ['Dragon', 'Ground'],
bs: { hp: 108, at: 130, df: 95, sa: 80, sd: 85, sp: 102 },
weightkg: 95,
abilities: { 0: 'Sand Veil' }
},
Gastrodon: {
types: ['Water', 'Ground'],
bs: { hp: 111, at: 83, df: 68, sa: 92, sd: 82, sp: 39 },
weightkg: 29.9,
abilities: { 0: 'Sticky Hold' }
},
Gible: {
types: ['Dragon', 'Ground'],
bs: { hp: 58, at: 70, df: 45, sa: 40, sd: 45, sp: 42 },
weightkg: 20.5,
nfe: true,
abilities: { 0: 'Sand Veil' }
},
Giratina: {
types: ['Ghost', 'Dragon'],
bs: { hp: 150, at: 100, df: 120, sa: 100, sd: 120, sp: 90 },
weightkg: 750,
gender: 'N',
otherFormes: ['Giratina-Origin'],
abilities: { 0: 'Pressure' }
},
'Giratina-Origin': {
types: ['Ghost', 'Dragon'],
bs: { hp: 150, at: 120, df: 100, sa: 120, sd: 100, sp: 90 },
weightkg: 650,
gender: 'N',
abilities: { 0: 'Levitate' },
baseSpecies: 'Giratina'
},
Glaceon: {
types: ['Ice'],
bs: { hp: 65, at: 60, df: 110, sa: 130, sd: 95, sp: 65 },
weightkg: 25.9,
abilities: { 0: 'Snow Cloak' }
},
Glameow: {
types: ['Normal'],
bs: { hp: 49, at: 55, df: 42, sa: 42, sd: 37, sp: 85 },
weightkg: 3.9,
nfe: true,
abilities: { 0: 'Limber' }
},
Gliscor: {
types: ['Ground', 'Flying'],
bs: { hp: 75, at: 95, df: 125, sa: 45, sd: 75, sp: 95 },
weightkg: 42.5,
abilities: { 0: 'Hyper Cutter' }
},
Grotle: {
types: ['Grass'],
bs: { hp: 75, at: 89, df: 85, sa: 55, sd: 65, sp: 36 },
weightkg: 97,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Happiny: {
types: ['Normal'],
bs: { hp: 100, at: 5, df: 5, sa: 15, sd: 65, sp: 30 },
weightkg: 24.4,
nfe: true,
abilities: { 0: 'Natural Cure' }
},
Heatran: {
types: ['Fire', 'Steel'],
bs: { hp: 91, at: 90, df: 106, sa: 130, sd: 106, sp: 77 },
weightkg: 430,
abilities: { 0: 'Flash Fire' }
},
Hippopotas: {
types: ['Ground'],
bs: { hp: 68, at: 72, df: 78, sa: 38, sd: 42, sp: 32 },
weightkg: 49.5,
nfe: true,
abilities: { 0: 'Sand Stream' }
},
Hippowdon: {
types: ['Ground'],
bs: { hp: 108, at: 112, df: 118, sa: 68, sd: 72, sp: 47 },
weightkg: 300,
abilities: { 0: 'Sand Stream' }
},
Honchkrow: {
types: ['Dark', 'Flying'],
bs: { hp: 100, at: 125, df: 52, sa: 105, sd: 52, sp: 71 },
weightkg: 27.3,
abilities: { 0: 'Insomnia' }
},
Infernape: {
types: ['Fire', 'Fighting'],
bs: { hp: 76, at: 104, df: 71, sa: 104, sd: 71, sp: 108 },
weightkg: 55,
abilities: { 0: 'Blaze' }
},
Kitsunoh: {
types: ['Ghost', 'Steel'],
bs: { hp: 80, at: 103, df: 85, sa: 55, sd: 80, sp: 110 },
weightkg: 51,
abilities: { 0: 'Frisk' }
},
Kricketot: {
types: ['Bug'],
bs: { hp: 37, at: 25, df: 41, sa: 25, sd: 41, sp: 25 },
weightkg: 2.2,
nfe: true,
abilities: { 0: 'Shed Skin' }
},
Kricketune: {
types: ['Bug'],
bs: { hp: 77, at: 85, df: 51, sa: 55, sd: 51, sp: 65 },
weightkg: 25.5,
abilities: { 0: 'Swarm' }
},
Krilowatt: {
types: ['Electric', 'Water'],
bs: { hp: 151, at: 84, df: 73, sa: 83, sd: 74, sp: 105 },
weightkg: 10.6,
abilities: { 0: 'Trace' }
},
Leafeon: {
types: ['Grass'],
bs: { hp: 65, at: 110, df: 130, sa: 60, sd: 65, sp: 95 },
weightkg: 25.5,
abilities: { 0: 'Leaf Guard' }
},
Lickilicky: {
types: ['Normal'],
bs: { hp: 110, at: 85, df: 95, sa: 80, sd: 95, sp: 50 },
weightkg: 140,
abilities: { 0: 'Own Tempo' }
},
Lopunny: {
types: ['Normal'],
bs: { hp: 65, at: 76, df: 84, sa: 54, sd: 96, sp: 105 },
weightkg: 33.3,
abilities: { 0: 'Cute Charm' }
},
Lucario: {
types: ['Fighting', 'Steel'],
bs: { hp: 70, at: 110, df: 70, sa: 115, sd: 70, sp: 90 },
weightkg: 54,
abilities: { 0: 'Steadfast' }
},
Lumineon: {
types: ['Water'],
bs: { hp: 69, at: 69, df: 76, sa: 69, sd: 86, sp: 91 },
weightkg: 24,
abilities: { 0: 'Swift Swim' }
},
Luxio: {
types: ['Electric'],
bs: { hp: 60, at: 85, df: 49, sa: 60, sd: 49, sp: 60 },
weightkg: 30.5,
nfe: true,
abilities: { 0: 'Rivalry' }
},
Luxray: {
types: ['Electric'],
bs: { hp: 80, at: 120, df: 79, sa: 95, sd: 79, sp: 70 },
weightkg: 42,
abilities: { 0: 'Rivalry' }
},
Magmortar: {
types: ['Fire'],
bs: { hp: 75, at: 95, df: 67, sa: 125, sd: 95, sp: 83 },
weightkg: 68,
abilities: { 0: 'Flame Body' }
},
Magnezone: {
types: ['Electric', 'Steel'],
bs: { hp: 70, at: 70, df: 115, sa: 130, sd: 90, sp: 60 },
weightkg: 180,
gender: 'N',
abilities: { 0: 'Magnet Pull' }
},
Mamoswine: {
types: ['Ice', 'Ground'],
bs: { hp: 110, at: 130, df: 80, sa: 70, sd: 60, sp: 80 },
weightkg: 291,
abilities: { 0: 'Oblivious' }
},
Manaphy: {
types: ['Water'],
bs: { hp: 100, at: 100, df: 100, sa: 100, sd: 100, sp: 100 },
weightkg: 1.4,
abilities: { 0: 'Hydration' },
gender: 'N'
},
Mantyke: {
types: ['Water', 'Flying'],
bs: { hp: 45, at: 20, df: 50, sa: 60, sd: 120, sp: 50 },
weightkg: 65,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Mesprit: {
types: ['Psychic'],
bs: { hp: 80, at: 105, df: 105, sa: 105, sd: 105, sp: 80 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N'
},
'Mime Jr.': {
types: ['Psychic'],
bs: { hp: 20, at: 25, df: 45, sa: 70, sd: 90, sp: 60 },
weightkg: 13,
nfe: true,
abilities: { 0: 'Soundproof' }
},
Mismagius: {
types: ['Ghost'],
bs: { hp: 60, at: 60, df: 60, sa: 105, sd: 105, sp: 105 },
weightkg: 4.4,
abilities: { 0: 'Levitate' }
},
Monferno: {
types: ['Fire', 'Fighting'],
bs: { hp: 64, at: 78, df: 52, sa: 78, sd: 52, sp: 81 },
weightkg: 22,
nfe: true,
abilities: { 0: 'Blaze' }
},
Mothim: {
types: ['Bug', 'Flying'],
bs: { hp: 70, at: 94, df: 50, sa: 94, sd: 50, sp: 66 },
weightkg: 23.3,
abilities: { 0: 'Swarm' }
},
Munchlax: {
types: ['Normal'],
bs: { hp: 135, at: 85, df: 40, sa: 40, sd: 85, sp: 5 },
weightkg: 105,
nfe: true,
abilities: { 0: 'Pickup' }
},
Pachirisu: {
types: ['Electric'],
bs: { hp: 60, at: 45, df: 70, sa: 45, sd: 90, sp: 95 },
weightkg: 3.9,
abilities: { 0: 'Run Away' }
},
Palkia: {
types: ['Water', 'Dragon'],
bs: { hp: 90, at: 120, df: 100, sa: 150, sd: 120, sp: 100 },
weightkg: 336,
gender: 'N',
abilities: { 0: 'Pressure' }
},
Phione: {
types: ['Water'],
bs: { hp: 80, at: 80, df: 80, sa: 80, sd: 80, sp: 80 },
weightkg: 3.1,
abilities: { 0: 'Hydration' },
gender: 'N'
},
'Pichu-Spiky-eared': {
types: ['Electric'],
bs: { hp: 20, at: 40, df: 15, sa: 35, sd: 35, sp: 60 },
weightkg: 2,
abilities: { 0: 'Static' },
baseSpecies: 'Pichu'
},
Piplup: {
types: ['Water'],
bs: { hp: 53, at: 51, df: 53, sa: 61, sd: 56, sp: 40 },
weightkg: 5.2,
nfe: true,
abilities: { 0: 'Torrent' }
},
'Porygon-Z': {
types: ['Normal'],
bs: { hp: 85, at: 80, df: 70, sa: 135, sd: 75, sp: 90 },
weightkg: 34,
gender: 'N',
abilities: { 0: 'Adaptability' }
},
Prinplup: {
types: ['Water'],
bs: { hp: 64, at: 66, df: 68, sa: 81, sd: 76, sp: 50 },
weightkg: 23,
nfe: true,
abilities: { 0: 'Torrent' }
},
Privatyke: {
types: ['Water', 'Fighting'],
bs: { hp: 65, at: 75, df: 65, sa: 40, sd: 60, sp: 45 },
weightkg: 35,
nfe: true,
abilities: { 0: 'Unaware' }
},
Probopass: {
types: ['Rock', 'Steel'],
bs: { hp: 60, at: 55, df: 145, sa: 75, sd: 150, sp: 40 },
weightkg: 340,
abilities: { 0: 'Sturdy' }
},
Purugly: {
types: ['Normal'],
bs: { hp: 71, at: 82, df: 64, sa: 64, sd: 59, sp: 112 },
weightkg: 43.8,
abilities: { 0: 'Thick Fat' }
},
Pyroak: {
types: ['Fire', 'Grass'],
bs: { hp: 120, at: 70, df: 105, sa: 95, sd: 90, sp: 60 },
weightkg: 168,
abilities: { 0: 'Rock Head' }
},
Rampardos: {
types: ['Rock'],
bs: { hp: 97, at: 165, df: 60, sa: 65, sd: 50, sp: 58 },
weightkg: 102.5,
abilities: { 0: 'Mold Breaker' }
},
Rebble: {
types: ['Rock'],
bs: { hp: 45, at: 25, df: 65, sa: 75, sd: 55, sp: 80 },
weightkg: 7,
nfe: true,
gender: 'N',
abilities: { 0: 'Levitate' }
},
Regigigas: {
types: ['Normal'],
bs: { hp: 110, at: 160, df: 110, sa: 80, sd: 110, sp: 100 },
weightkg: 420,
abilities: { 0: 'Slow Start' },
gender: 'N'
},
Revenankh: {
types: ['Ghost', 'Fighting'],
bs: { hp: 90, at: 105, df: 90, sa: 65, sd: 110, sp: 65 },
weightkg: 44,
abilities: { 0: 'Shed Skin' }
},
Rhyperior: {
types: ['Ground', 'Rock'],
bs: { hp: 115, at: 140, df: 130, sa: 55, sd: 55, sp: 40 },
weightkg: 282.8,
abilities: { 0: 'Lightning Rod' }
},
Riolu: {
types: ['Fighting'],
bs: { hp: 40, at: 70, df: 40, sa: 35, sd: 40, sp: 60 },
weightkg: 20.2,
nfe: true,
abilities: { 0: 'Steadfast' }
},
Roserade: {
types: ['Grass', 'Poison'],
bs: { hp: 60, at: 70, df: 55, sa: 125, sd: 105, sp: 90 },
weightkg: 14.5,
abilities: { 0: 'Natural Cure' }
},
Rotom: {
types: ['Electric', 'Ghost'],
bs: { hp: 50, at: 50, df: 77, sa: 95, sd: 77, sp: 91 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N',
otherFormes: ['Rotom-Fan', 'Rotom-Frost', 'Rotom-Heat', 'Rotom-Mow', 'Rotom-Wash']
},
'Rotom-Mow': {
types: ['Electric', 'Ghost'],
bs: { hp: 50, at: 65, df: 107, sa: 105, sd: 107, sp: 86 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N',
baseSpecies: 'Rotom'
},
'Rotom-Frost': {
types: ['Electric', 'Ghost'],
bs: { hp: 50, at: 65, df: 107, sa: 105, sd: 107, sp: 86 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N',
baseSpecies: 'Rotom'
},
'Rotom-Heat': {
types: ['Electric', 'Ghost'],
bs: { hp: 50, at: 65, df: 107, sa: 105, sd: 107, sp: 86 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N',
baseSpecies: 'Rotom'
},
'Rotom-Fan': {
types: ['Electric', 'Ghost'],
bs: { hp: 50, at: 65, df: 107, sa: 105, sd: 107, sp: 86 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N',
baseSpecies: 'Rotom'
},
'Rotom-Wash': {
types: ['Electric', 'Ghost'],
bs: { hp: 50, at: 65, df: 107, sa: 105, sd: 107, sp: 86 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N',
baseSpecies: 'Rotom'
},
Shaymin: {
types: ['Grass'],
bs: { hp: 100, at: 100, df: 100, sa: 100, sd: 100, sp: 100 },
weightkg: 2.1,
abilities: { 0: 'Natural Cure' },
gender: 'N',
otherFormes: ['Shaymin-Sky']
},
'Shaymin-Sky': {
types: ['Grass', 'Flying'],
bs: { hp: 100, at: 103, df: 75, sa: 120, sd: 75, sp: 127 },
weightkg: 5.2,
abilities: { 0: 'Serene Grace' },
gender: 'N',
baseSpecies: 'Shaymin'
},
Shellos: {
types: ['Water'],
bs: { hp: 76, at: 48, df: 48, sa: 57, sd: 62, sp: 34 },
weightkg: 6.3,
nfe: true,
abilities: { 0: 'Sticky Hold' }
},
Shieldon: {
types: ['Rock', 'Steel'],
bs: { hp: 30, at: 42, df: 118, sa: 42, sd: 88, sp: 30 },
weightkg: 57,
nfe: true,
abilities: { 0: 'Sturdy' }
},
Shinx: {
types: ['Electric'],
bs: { hp: 45, at: 65, df: 34, sa: 40, sd: 34, sp: 45 },
weightkg: 9.5,
nfe: true,
abilities: { 0: 'Rivalry' }
},
Skorupi: {
types: ['Poison', 'Bug'],
bs: { hp: 40, at: 50, df: 90, sa: 30, sd: 55, sp: 65 },
weightkg: 12,
nfe: true,
abilities: { 0: 'Battle Armor' }
},
Skuntank: {
types: ['Poison', 'Dark'],
bs: { hp: 103, at: 93, df: 67, sa: 71, sd: 61, sp: 84 },
weightkg: 38,
abilities: { 0: 'Stench' }
},
Snover: {
types: ['Grass', 'Ice'],
bs: { hp: 60, at: 62, df: 50, sa: 62, sd: 60, sp: 40 },
weightkg: 50.5,
nfe: true,
abilities: { 0: 'Snow Warning' }
},
Spiritomb: {
types: ['Ghost', 'Dark'],
bs: { hp: 50, at: 92, df: 108, sa: 92, sd: 108, sp: 35 },
weightkg: 108,
abilities: { 0: 'Pressure' }
},
Staraptor: {
types: ['Normal', 'Flying'],
bs: { hp: 85, at: 120, df: 70, sa: 50, sd: 50, sp: 100 },
weightkg: 24.9,
abilities: { 0: 'Intimidate' }
},
Staravia: {
types: ['Normal', 'Flying'],
bs: { hp: 55, at: 75, df: 50, sa: 40, sd: 40, sp: 80 },
weightkg: 15.5,
nfe: true,
abilities: { 0: 'Intimidate' }
},
Starly: {
types: ['Normal', 'Flying'],
bs: { hp: 40, at: 55, df: 30, sa: 30, sd: 30, sp: 60 },
weightkg: 2,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Stratagem: {
types: ['Rock'],
bs: { hp: 90, at: 60, df: 65, sa: 120, sd: 70, sp: 130 },
weightkg: 45,
gender: 'N',
abilities: { 0: 'Levitate' }
},
Stunky: {
types: ['Poison', 'Dark'],
bs: { hp: 63, at: 63, df: 47, sa: 41, sd: 41, sp: 74 },
weightkg: 19.2,
nfe: true,
abilities: { 0: 'Stench' }
},
Syclant: {
types: ['Ice', 'Bug'],
bs: { hp: 70, at: 116, df: 70, sa: 114, sd: 64, sp: 121 },
weightkg: 52,
abilities: { 0: 'Compound Eyes' }
},
Syclar: {
types: ['Ice', 'Bug'],
bs: { hp: 40, at: 76, df: 45, sa: 74, sd: 39, sp: 91 },
weightkg: 4,
nfe: true,
abilities: { 0: 'Compound Eyes' }
},
Tactite: {
types: ['Rock'],
bs: { hp: 70, at: 40, df: 65, sa: 100, sd: 65, sp: 95 },
weightkg: 16,
nfe: true,
gender: 'N',
abilities: { 0: 'Levitate' }
},
Tangrowth: {
types: ['Grass'],
bs: { hp: 100, at: 100, df: 125, sa: 110, sd: 50, sp: 50 },
weightkg: 128.6,
abilities: { 0: 'Chlorophyll' }
},
Togekiss: {
types: ['Normal', 'Flying'],
bs: { hp: 85, at: 50, df: 95, sa: 120, sd: 115, sp: 80 },
weightkg: 38,
abilities: { 0: 'Hustle' }
},
Torterra: {
types: ['Grass', 'Ground'],
bs: { hp: 95, at: 109, df: 105, sa: 75, sd: 85, sp: 56 },
weightkg: 310,
abilities: { 0: 'Overgrow' }
},
Toxicroak: {
types: ['Poison', 'Fighting'],
bs: { hp: 83, at: 106, df: 65, sa: 86, sd: 65, sp: 85 },
weightkg: 44.4,
abilities: { 0: 'Anticipation' }
},
Turtwig: {
types: ['Grass'],
bs: { hp: 55, at: 68, df: 64, sa: 45, sd: 55, sp: 31 },
weightkg: 10.2,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Uxie: {
types: ['Psychic'],
bs: { hp: 75, at: 75, df: 130, sa: 75, sd: 130, sp: 95 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
gender: 'N'
},
Vespiquen: {
types: ['Bug', 'Flying'],
bs: { hp: 70, at: 80, df: 102, sa: 80, sd: 102, sp: 40 },
weightkg: 38.5,
abilities: { 0: 'Pressure' }
},
Voodoll: {
types: ['Normal', 'Dark'],
bs: { hp: 55, at: 40, df: 55, sa: 75, sd: 50, sp: 70 },
weightkg: 25,
nfe: true,
abilities: { 0: 'Volt Absorb' }
},
Voodoom: {
types: ['Fighting', 'Dark'],
bs: { hp: 90, at: 85, df: 80, sa: 105, sd: 80, sp: 110 },
weightkg: 75.5,
abilities: { 0: 'Volt Absorb' }
},
Weavile: {
types: ['Dark', 'Ice'],
bs: { hp: 70, at: 120, df: 65, sa: 45, sd: 85, sp: 125 },
weightkg: 34,
abilities: { 0: 'Pressure' }
},
Wormadam: {
types: ['Bug', 'Grass'],
bs: { hp: 60, at: 59, df: 85, sa: 79, sd: 105, sp: 36 },
weightkg: 6.5,
abilities: { 0: 'Anticipation' },
otherFormes: ['Wormadam-Sandy', 'Wormadam-Trash']
},
'Wormadam-Sandy': {
types: ['Bug', 'Ground'],
bs: { hp: 60, at: 79, df: 105, sa: 59, sd: 85, sp: 36 },
weightkg: 6.5,
abilities: { 0: 'Anticipation' },
baseSpecies: 'Wormadam'
},
'Wormadam-Trash': {
types: ['Bug', 'Steel'],
bs: { hp: 60, at: 69, df: 95, sa: 69, sd: 95, sp: 36 },
weightkg: 6.5,
abilities: { 0: 'Anticipation' },
baseSpecies: 'Wormadam'
},
Yanmega: {
types: ['Bug', 'Flying'],
bs: { hp: 86, at: 76, df: 86, sa: 116, sd: 56, sp: 95 },
weightkg: 51.5,
abilities: { 0: 'Speed Boost' }
}
};
var DPP = util_1.extend(true, {}, ADV, DPP_PATCH);
var BW_PATCH = {
'Rotom-Fan': { types: ['Electric', 'Flying'] },
'Rotom-Frost': { types: ['Electric', 'Ice'] },
'Rotom-Heat': { types: ['Electric', 'Fire'] },
'Rotom-Mow': { types: ['Electric', 'Grass'] },
'Rotom-Wash': { types: ['Electric', 'Water'] },
Accelgor: {
types: ['Bug'],
bs: { hp: 80, at: 70, df: 40, sa: 100, sd: 60, sp: 145 },
weightkg: 25.3,
abilities: { 0: 'Hydration' }
},
Alomomola: {
types: ['Water'],
bs: { hp: 165, at: 75, df: 80, sa: 40, sd: 45, sp: 65 },
weightkg: 31.6,
abilities: { 0: 'Healer' }
},
Amoonguss: {
types: ['Grass', 'Poison'],
bs: { hp: 114, at: 85, df: 70, sa: 85, sd: 80, sp: 30 },
weightkg: 10.5,
abilities: { 0: 'Effect Spore' }
},
Archen: {
types: ['Rock', 'Flying'],
bs: { hp: 55, at: 112, df: 45, sa: 74, sd: 45, sp: 70 },
weightkg: 9.5,
abilities: { 0: 'Defeatist' },
nfe: true
},
Archeops: {
types: ['Rock', 'Flying'],
bs: { hp: 75, at: 140, df: 65, sa: 112, sd: 65, sp: 110 },
weightkg: 32,
abilities: { 0: 'Defeatist' }
},
Argalis: {
types: ['Bug', 'Psychic'],
bs: { hp: 60, at: 90, df: 89, sa: 87, sd: 40, sp: 54 },
weightkg: 341.4,
nfe: true,
abilities: { 0: 'Shed Skin' }
},
Audino: {
types: ['Normal'],
bs: { hp: 103, at: 60, df: 86, sa: 60, sd: 86, sp: 50 },
weightkg: 31,
abilities: { 0: 'Healer' }
},
Aurumoth: {
types: ['Bug', 'Psychic'],
bs: { hp: 110, at: 120, df: 99, sa: 117, sd: 60, sp: 94 },
weightkg: 193,
abilities: { 0: 'Weak Armor' }
},
Axew: {
types: ['Dragon'],
bs: { hp: 46, at: 87, df: 60, sa: 30, sd: 40, sp: 57 },
weightkg: 18,
nfe: true,
abilities: { 0: 'Rivalry' }
},
Basculin: {
types: ['Water'],
bs: { hp: 70, at: 92, df: 65, sa: 80, sd: 55, sp: 98 },
weightkg: 18,
abilities: { 0: 'Reckless' },
otherFormes: ['Basculin-Blue-Striped']
},
'Basculin-Blue-Striped': {
types: ['Water'],
bs: { hp: 70, at: 92, df: 65, sa: 80, sd: 55, sp: 98 },
weightkg: 18,
abilities: { 0: 'Rock Head' },
baseSpecies: 'Basculin'
},
Beartic: {
types: ['Ice'],
bs: { hp: 95, at: 110, df: 80, sa: 70, sd: 80, sp: 50 },
weightkg: 260,
abilities: { 0: 'Snow Cloak' }
},
Beheeyem: {
types: ['Psychic'],
bs: { hp: 75, at: 75, df: 75, sa: 125, sd: 95, sp: 40 },
weightkg: 34.5,
abilities: { 0: 'Telepathy' }
},
Bisharp: {
types: ['Dark', 'Steel'],
bs: { hp: 65, at: 125, df: 100, sa: 60, sd: 70, sp: 70 },
weightkg: 70,
abilities: { 0: 'Defiant' }
},
Blitzle: {
types: ['Electric'],
bs: { hp: 45, at: 60, df: 32, sa: 50, sd: 32, sp: 76 },
weightkg: 29.8,
nfe: true,
abilities: { 0: 'Lightning Rod' }
},
Boldore: {
types: ['Rock'],
bs: { hp: 70, at: 105, df: 105, sa: 50, sd: 40, sp: 20 },
weightkg: 102,
nfe: true,
abilities: { 0: 'Sturdy' }
},
Bouffalant: {
types: ['Normal'],
bs: { hp: 95, at: 110, df: 95, sa: 40, sd: 95, sp: 55 },
weightkg: 94.6,
abilities: { 0: 'Reckless' }
},
Brattler: {
types: ['Dark', 'Grass'],
bs: { hp: 80, at: 70, df: 40, sa: 20, sd: 90, sp: 30 },
weightkg: 11.5,
nfe: true,
abilities: { 0: 'Harvest' }
},
Braviary: {
types: ['Normal', 'Flying'],
bs: { hp: 100, at: 123, df: 75, sa: 57, sd: 75, sp: 80 },
weightkg: 41,
abilities: { 0: 'Keen Eye' }
},
Carracosta: {
types: ['Water', 'Rock'],
bs: { hp: 74, at: 108, df: 133, sa: 83, sd: 65, sp: 32 },
weightkg: 81,
abilities: { 0: 'Solid Rock' }
},
Cawdet: {
types: ['Steel', 'Flying'],
bs: { hp: 35, at: 72, df: 85, sa: 40, sd: 55, sp: 88 },
weightkg: 25,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Cawmodore: {
types: ['Steel', 'Flying'],
bs: { hp: 50, at: 92, df: 130, sa: 65, sd: 75, sp: 118 },
weightkg: 37,
abilities: { 0: 'Intimidate' }
},
Chandelure: {
types: ['Ghost', 'Fire'],
bs: { hp: 60, at: 55, df: 90, sa: 145, sd: 90, sp: 80 },
weightkg: 34.3,
abilities: { 0: 'Flash Fire' }
},
Cinccino: {
types: ['Normal'],
bs: { hp: 75, at: 95, df: 60, sa: 65, sd: 60, sp: 115 },
weightkg: 7.5,
abilities: { 0: 'Cute Charm' }
},
Cobalion: {
types: ['Steel', 'Fighting'],
bs: { hp: 91, at: 90, df: 129, sa: 90, sd: 72, sp: 108 },
weightkg: 250,
abilities: { 0: 'Justified' },
gender: 'N'
},
Cofagrigus: {
types: ['Ghost'],
bs: { hp: 58, at: 50, df: 145, sa: 95, sd: 105, sp: 30 },
weightkg: 76.5,
abilities: { 0: 'Mummy' }
},
Conkeldurr: {
types: ['Fighting'],
bs: { hp: 105, at: 140, df: 95, sa: 55, sd: 65, sp: 45 },
weightkg: 87,
abilities: { 0: 'Guts' }
},
Cottonee: {
types: ['Grass'],
bs: { hp: 40, at: 27, df: 60, sa: 37, sd: 50, sp: 66 },
weightkg: 0.6,
nfe: true,
abilities: { 0: 'Prankster' }
},
Crustle: {
types: ['Bug', 'Rock'],
bs: { hp: 70, at: 95, df: 125, sa: 65, sd: 75, sp: 45 },
weightkg: 200,
abilities: { 0: 'Sturdy' }
},
Cryogonal: {
types: ['Ice'],
bs: { hp: 70, at: 50, df: 30, sa: 95, sd: 135, sp: 105 },
weightkg: 148,
abilities: { 0: 'Levitate' },
gender: 'N'
},
Cubchoo: {
types: ['Ice'],
bs: { hp: 55, at: 70, df: 40, sa: 60, sd: 40, sp: 40 },
weightkg: 8.5,
nfe: true,
abilities: { 0: 'Snow Cloak' }
},
Cupra: {
types: ['Bug', 'Psychic'],
bs: { hp: 50, at: 60, df: 49, sa: 67, sd: 30, sp: 44 },
weightkg: 4.8,
nfe: true,
abilities: { 0: 'Shield Dust' }
},
Darmanitan: {
types: ['Fire'],
bs: { hp: 105, at: 140, df: 55, sa: 30, sd: 55, sp: 95 },
weightkg: 92.9,
abilities: { 0: 'Sheer Force' },
otherFormes: ['Darmanitan-Zen']
},
'Darmanitan-Zen': {
types: ['Fire', 'Psychic'],
bs: { hp: 105, at: 30, df: 105, sa: 140, sd: 105, sp: 55 },
weightkg: 92.9,
baseSpecies: 'Darmanitan',
abilities: { 0: 'Zen Mode' }
},
Darumaka: {
types: ['Fire'],
bs: { hp: 70, at: 90, df: 45, sa: 15, sd: 45, sp: 50 },
weightkg: 37.5,
nfe: true,
abilities: { 0: 'Hustle' }
},
Deerling: {
types: ['Normal', 'Grass'],
bs: { hp: 60, at: 60, df: 50, sa: 40, sd: 50, sp: 75 },
weightkg: 19.5,
nfe: true,
abilities: { 0: 'Chlorophyll' }
},
Deino: {
types: ['Dark', 'Dragon'],
bs: { hp: 52, at: 65, df: 50, sa: 45, sd: 50, sp: 38 },
weightkg: 17.3,
abilities: { 0: 'Hustle' },
nfe: true
},
Dewott: {
types: ['Water'],
bs: { hp: 75, at: 75, df: 60, sa: 83, sd: 60, sp: 60 },
weightkg: 24.5,
nfe: true,
abilities: { 0: 'Torrent' }
},
Drilbur: {
types: ['Ground'],
bs: { hp: 60, at: 85, df: 40, sa: 30, sd: 45, sp: 68 },
weightkg: 8.5,
nfe: true,
abilities: { 0: 'Sand Rush' }
},
Druddigon: {
types: ['Dragon'],
bs: { hp: 77, at: 120, df: 90, sa: 60, sd: 90, sp: 48 },
weightkg: 139,
abilities: { 0: 'Rough Skin' }
},
Ducklett: {
types: ['Water', 'Flying'],
bs: { hp: 62, at: 44, df: 50, sa: 44, sd: 50, sp: 55 },
weightkg: 5.5,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Duosion: {
types: ['Psychic'],
bs: { hp: 65, at: 40, df: 50, sa: 125, sd: 60, sp: 30 },
weightkg: 8,
nfe: true,
abilities: { 0: 'Overcoat' }
},
Durant: {
types: ['Bug', 'Steel'],
bs: { hp: 58, at: 109, df: 112, sa: 48, sd: 48, sp: 109 },
weightkg: 33,
abilities: { 0: 'Swarm' }
},
Dwebble: {
types: ['Bug', 'Rock'],
bs: { hp: 50, at: 65, df: 85, sa: 35, sd: 35, sp: 55 },
weightkg: 14.5,
nfe: true,
abilities: { 0: 'Sturdy' }
},
Eelektrik: {
types: ['Electric'],
bs: { hp: 65, at: 85, df: 70, sa: 75, sd: 70, sp: 40 },
weightkg: 22,
abilities: { 0: 'Levitate' },
nfe: true
},
Eelektross: {
types: ['Electric'],
bs: { hp: 85, at: 115, df: 80, sa: 105, sd: 80, sp: 50 },
weightkg: 80.5,
abilities: { 0: 'Levitate' }
},
Elgyem: {
types: ['Psychic'],
bs: { hp: 55, at: 55, df: 55, sa: 85, sd: 55, sp: 30 },
weightkg: 9,
nfe: true,
abilities: { 0: 'Telepathy' }
},
Emboar: {
types: ['Fire', 'Fighting'],
bs: { hp: 110, at: 123, df: 65, sa: 100, sd: 65, sp: 65 },
weightkg: 150,
abilities: { 0: 'Blaze' }
},
Emolga: {
types: ['Electric', 'Flying'],
bs: { hp: 55, at: 75, df: 60, sa: 75, sd: 60, sp: 103 },
weightkg: 5,
abilities: { 0: 'Static' }
},
Escavalier: {
types: ['Bug', 'Steel'],
bs: { hp: 70, at: 135, df: 105, sa: 60, sd: 105, sp: 20 },
weightkg: 33,
abilities: { 0: 'Swarm' }
},
Excadrill: {
types: ['Ground', 'Steel'],
bs: { hp: 110, at: 135, df: 60, sa: 50, sd: 65, sp: 88 },
weightkg: 40.4,
abilities: { 0: 'Sand Rush' }
},
Ferroseed: {
types: ['Grass', 'Steel'],
bs: { hp: 44, at: 50, df: 91, sa: 24, sd: 86, sp: 10 },
weightkg: 18.8,
nfe: true,
abilities: { 0: 'Iron Barbs' }
},
Ferrothorn: {
types: ['Grass', 'Steel'],
bs: { hp: 74, at: 94, df: 131, sa: 54, sd: 116, sp: 20 },
weightkg: 110,
abilities: { 0: 'Iron Barbs' }
},
Foongus: {
types: ['Grass', 'Poison'],
bs: { hp: 69, at: 55, df: 45, sa: 55, sd: 55, sp: 15 },
weightkg: 1,
nfe: true,
abilities: { 0: 'Effect Spore' }
},
Fraxure: {
types: ['Dragon'],
bs: { hp: 66, at: 117, df: 70, sa: 40, sd: 50, sp: 67 },
weightkg: 36,
nfe: true,
abilities: { 0: 'Rivalry' }
},
Frillish: {
types: ['Water', 'Ghost'],
bs: { hp: 55, at: 40, df: 50, sa: 65, sd: 85, sp: 40 },
weightkg: 33,
nfe: true,
abilities: { 0: 'Water Absorb' }
},
Galvantula: {
types: ['Bug', 'Electric'],
bs: { hp: 70, at: 77, df: 60, sa: 97, sd: 60, sp: 108 },
weightkg: 14.3,
abilities: { 0: 'Compound Eyes' }
},
Garbodor: {
types: ['Poison'],
bs: { hp: 80, at: 95, df: 82, sa: 60, sd: 82, sp: 75 },
weightkg: 107.3,
abilities: { 0: 'Stench' }
},
Genesect: {
types: ['Bug', 'Steel'],
bs: { hp: 71, at: 120, df: 95, sa: 120, sd: 95, sp: 99 },
weightkg: 82.5,
abilities: { 0: 'Download' },
gender: 'N',
otherFormes: ['Genesect-Burn', 'Genesect-Chill', 'Genesect-Douse', 'Genesect-Shock']
},
'Genesect-Burn': {
types: ['Bug', 'Steel'],
bs: { hp: 71, at: 120, df: 95, sa: 120, sd: 95, sp: 99 },
weightkg: 82.5,
abilities: { 0: 'Download' },
gender: 'N',
baseSpecies: 'Genesect'
},
'Genesect-Chill': {
types: ['Bug', 'Steel'],
bs: { hp: 71, at: 120, df: 95, sa: 120, sd: 95, sp: 99 },
weightkg: 82.5,
abilities: { 0: 'Download' },
gender: 'N',
baseSpecies: 'Genesect'
},
'Genesect-Douse': {
types: ['Bug', 'Steel'],
bs: { hp: 71, at: 120, df: 95, sa: 120, sd: 95, sp: 99 },
weightkg: 82.5,
abilities: { 0: 'Download' },
gender: 'N',
baseSpecies: 'Genesect'
},
'Genesect-Shock': {
types: ['Bug', 'Steel'],
bs: { hp: 71, at: 120, df: 95, sa: 120, sd: 95, sp: 99 },
weightkg: 82.5,
abilities: { 0: 'Download' },
gender: 'N',
baseSpecies: 'Genesect'
},
Gigalith: {
types: ['Rock'],
bs: { hp: 85, at: 135, df: 130, sa: 60, sd: 70, sp: 25 },
weightkg: 260,
abilities: { 0: 'Sturdy' }
},
Golett: {
types: ['Ground', 'Ghost'],
bs: { hp: 59, at: 74, df: 50, sa: 35, sd: 50, sp: 35 },
weightkg: 92,
nfe: true,
gender: 'N',
abilities: { 0: 'Iron Fist' }
},
Golurk: {
types: ['Ground', 'Ghost'],
bs: { hp: 89, at: 124, df: 80, sa: 55, sd: 80, sp: 55 },
weightkg: 330,
gender: 'N',
abilities: { 0: 'Iron Fist' }
},
Gothita: {
types: ['Psychic'],
bs: { hp: 45, at: 30, df: 50, sa: 55, sd: 65, sp: 45 },
weightkg: 5.8,
nfe: true,
abilities: { 0: 'Frisk' }
},
Gothitelle: {
types: ['Psychic'],
bs: { hp: 70, at: 55, df: 95, sa: 95, sd: 110, sp: 65 },
weightkg: 44,
abilities: { 0: 'Frisk' }
},
Gothorita: {
types: ['Psychic'],
bs: { hp: 60, at: 45, df: 70, sa: 75, sd: 85, sp: 55 },
weightkg: 18,
nfe: true,
abilities: { 0: 'Frisk' }
},
Gurdurr: {
types: ['Fighting'],
bs: { hp: 85, at: 105, df: 85, sa: 40, sd: 50, sp: 40 },
weightkg: 40,
nfe: true,
abilities: { 0: 'Guts' }
},
Haxorus: {
types: ['Dragon'],
bs: { hp: 76, at: 147, df: 90, sa: 60, sd: 70, sp: 97 },
weightkg: 105.5,
abilities: { 0: 'Rivalry' }
},
Heatmor: {
types: ['Fire'],
bs: { hp: 85, at: 97, df: 66, sa: 105, sd: 66, sp: 65 },
weightkg: 58,
abilities: { 0: 'Gluttony' }
},
Herdier: {
types: ['Normal'],
bs: { hp: 65, at: 80, df: 65, sa: 35, sd: 65, sp: 60 },
weightkg: 14.7,
nfe: true,
abilities: { 0: 'Intimidate' }
},
Hydreigon: {
types: ['Dark', 'Dragon'],
bs: { hp: 92, at: 105, df: 90, sa: 125, sd: 90, sp: 98 },
weightkg: 160,
abilities: { 0: 'Levitate' }
},
Jellicent: {
types: ['Water', 'Ghost'],
bs: { hp: 100, at: 60, df: 70, sa: 85, sd: 105, sp: 60 },
weightkg: 135,
abilities: { 0: 'Water Absorb' }
},
Joltik: {
types: ['Bug', 'Electric'],
bs: { hp: 50, at: 47, df: 50, sa: 57, sd: 50, sp: 65 },
weightkg: 0.6,
nfe: true,
abilities: { 0: 'Compound Eyes' }
},
Karrablast: {
types: ['Bug'],
bs: { hp: 50, at: 75, df: 45, sa: 40, sd: 45, sp: 60 },
weightkg: 5.9,
nfe: true,
abilities: { 0: 'Swarm' }
},
Keldeo: {
types: ['Water', 'Fighting'],
bs: { hp: 91, at: 72, df: 90, sa: 129, sd: 90, sp: 108 },
weightkg: 48.5,
abilities: { 0: 'Justified' },
gender: 'N',
otherFormes: ['Keldeo-Resolute']
},
'Keldeo-Resolute': {
types: ['Water', 'Fighting'],
bs: { hp: 91, at: 72, df: 90, sa: 129, sd: 90, sp: 108 },
weightkg: 48.5,
abilities: { 0: 'Justified' },
gender: 'N',
baseSpecies: 'Keldeo'
},
Klang: {
types: ['Steel'],
bs: { hp: 60, at: 80, df: 95, sa: 70, sd: 85, sp: 50 },
weightkg: 51,
nfe: true,
gender: 'N',
abilities: { 0: 'Plus' }
},
Klink: {
types: ['Steel'],
bs: { hp: 40, at: 55, df: 70, sa: 45, sd: 60, sp: 30 },
weightkg: 21,
nfe: true,
gender: 'N',
abilities: { 0: 'Plus' }
},
Klinklang: {
types: ['Steel'],
bs: { hp: 60, at: 100, df: 115, sa: 70, sd: 85, sp: 90 },
weightkg: 81,
gender: 'N',
abilities: { 0: 'Plus' }
},
Krokorok: {
types: ['Ground', 'Dark'],
bs: { hp: 60, at: 82, df: 45, sa: 45, sd: 45, sp: 74 },
weightkg: 33.4,
nfe: true,
abilities: { 0: 'Intimidate' }
},
Krookodile: {
types: ['Ground', 'Dark'],
bs: { hp: 95, at: 117, df: 70, sa: 65, sd: 70, sp: 92 },
weightkg: 96.3,
abilities: { 0: 'Intimidate' }
},
Kyurem: {
types: ['Dragon', 'Ice'],
bs: { hp: 125, at: 130, df: 90, sa: 130, sd: 90, sp: 95 },
weightkg: 325,
abilities: { 0: 'Pressure' },
gender: 'N',
otherFormes: ['Kyurem-Black', 'Kyurem-White']
},
'Kyurem-Black': {
types: ['Dragon', 'Ice'],
bs: { hp: 125, at: 170, df: 100, sa: 120, sd: 90, sp: 95 },
weightkg: 325,
abilities: { 0: 'Teravolt' },
gender: 'N',
baseSpecies: 'Kyurem'
},
'Kyurem-White': {
types: ['Dragon', 'Ice'],
bs: { hp: 125, at: 120, df: 90, sa: 170, sd: 100, sp: 95 },
weightkg: 325,
abilities: { 0: 'Turboblaze' },
gender: 'N',
baseSpecies: 'Kyurem'
},
Lampent: {
types: ['Ghost', 'Fire'],
bs: { hp: 60, at: 40, df: 60, sa: 95, sd: 60, sp: 55 },
weightkg: 13,
nfe: true,
abilities: { 0: 'Flash Fire' }
},
Landorus: {
types: ['Ground', 'Flying'],
bs: { hp: 89, at: 125, df: 90, sa: 115, sd: 80, sp: 101 },
weightkg: 68,
abilities: { 0: 'Sand Force' },
otherFormes: ['Landorus-Therian']
},
'Landorus-Therian': {
types: ['Ground', 'Flying'],
bs: { hp: 89, at: 145, df: 90, sa: 105, sd: 80, sp: 91 },
weightkg: 68,
abilities: { 0: 'Intimidate' },
baseSpecies: 'Landorus'
},
Larvesta: {
types: ['Bug', 'Fire'],
bs: { hp: 55, at: 85, df: 55, sa: 50, sd: 55, sp: 60 },
weightkg: 28.8,
nfe: true,
abilities: { 0: 'Flame Body' }
},
Leavanny: {
types: ['Bug', 'Grass'],
bs: { hp: 75, at: 103, df: 80, sa: 70, sd: 70, sp: 92 },
weightkg: 20.5,
abilities: { 0: 'Swarm' }
},
Liepard: {
types: ['Dark'],
bs: { hp: 64, at: 88, df: 50, sa: 88, sd: 50, sp: 106 },
weightkg: 37.5,
abilities: { 0: 'Limber' }
},
Lilligant: {
types: ['Grass'],
bs: { hp: 70, at: 60, df: 75, sa: 110, sd: 75, sp: 90 },
weightkg: 16.3,
abilities: { 0: 'Chlorophyll' }
},
Lillipup: {
types: ['Normal'],
bs: { hp: 45, at: 60, df: 45, sa: 25, sd: 45, sp: 55 },
weightkg: 4.1,
nfe: true,
abilities: { 0: 'Vital Spirit' }
},
Litwick: {
types: ['Ghost', 'Fire'],
bs: { hp: 50, at: 30, df: 55, sa: 65, sd: 55, sp: 20 },
weightkg: 3.1,
nfe: true,
abilities: { 0: 'Flash Fire' }
},
Malaconda: {
types: ['Dark', 'Grass'],
bs: { hp: 115, at: 100, df: 60, sa: 40, sd: 130, sp: 55 },
weightkg: 108.8,
abilities: { 0: 'Harvest' }
},
Mandibuzz: {
types: ['Dark', 'Flying'],
bs: { hp: 110, at: 65, df: 105, sa: 55, sd: 95, sp: 80 },
weightkg: 39.5,
abilities: { 0: 'Big Pecks' }
},
Maractus: {
types: ['Grass'],
bs: { hp: 75, at: 86, df: 67, sa: 106, sd: 67, sp: 60 },
weightkg: 28,
abilities: { 0: 'Water Absorb' }
},
Meloetta: {
types: ['Normal', 'Psychic'],
bs: { hp: 100, at: 77, df: 77, sa: 128, sd: 128, sp: 90 },
weightkg: 6.5,
abilities: { 0: 'Serene Grace' },
otherFormes: ['Meloetta-Pirouette'],
gender: 'N'
},
'Meloetta-Pirouette': {
types: ['Normal', 'Fighting'],
bs: { hp: 100, at: 128, df: 90, sa: 77, sd: 77, sp: 128 },
weightkg: 6.5,
abilities: { 0: 'Serene Grace' },
baseSpecies: 'Meloetta',
gender: 'N'
},
Mienfoo: {
types: ['Fighting'],
bs: { hp: 45, at: 85, df: 50, sa: 55, sd: 50, sp: 65 },
weightkg: 20,
nfe: true,
abilities: { 0: 'Inner Focus' }
},
Mienshao: {
types: ['Fighting'],
bs: { hp: 65, at: 125, df: 60, sa: 95, sd: 60, sp: 105 },
weightkg: 35.5,
abilities: { 0: 'Inner Focus' }
},
Minccino: {
types: ['Normal'],
bs: { hp: 55, at: 50, df: 40, sa: 40, sd: 40, sp: 75 },
weightkg: 5.8,
nfe: true,
abilities: { 0: 'Cute Charm' }
},
Mollux: {
types: ['Fire', 'Poison'],
bs: { hp: 95, at: 45, df: 83, sa: 131, sd: 105, sp: 76 },
weightkg: 41,
abilities: { 0: 'Dry Skin' }
},
Munna: {
types: ['Psychic'],
bs: { hp: 76, at: 25, df: 45, sa: 67, sd: 55, sp: 24 },
weightkg: 23.3,
nfe: true,
abilities: { 0: 'Forewarn' }
},
Musharna: {
types: ['Psychic'],
bs: { hp: 116, at: 55, df: 85, sa: 107, sd: 95, sp: 29 },
weightkg: 60.5,
abilities: { 0: 'Forewarn' }
},
Necturine: {
types: ['Grass', 'Ghost'],
bs: { hp: 49, at: 55, df: 60, sa: 50, sd: 75, sp: 51 },
weightkg: 1.8,
nfe: true,
abilities: { 0: 'Anticipation' }
},
Necturna: {
types: ['Grass', 'Ghost'],
bs: { hp: 64, at: 120, df: 100, sa: 85, sd: 120, sp: 81 },
weightkg: 49.6,
abilities: { 0: 'Forewarn' }
},
Oshawott: {
types: ['Water'],
bs: { hp: 55, at: 55, df: 45, sa: 63, sd: 45, sp: 45 },
weightkg: 5.9,
nfe: true,
abilities: { 0: 'Torrent' }
},
Palpitoad: {
types: ['Water', 'Ground'],
bs: { hp: 75, at: 65, df: 55, sa: 65, sd: 55, sp: 69 },
weightkg: 17,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Panpour: {
types: ['Water'],
bs: { hp: 50, at: 53, df: 48, sa: 53, sd: 48, sp: 64 },
weightkg: 13.5,
nfe: true,
abilities: { 0: 'Gluttony' }
},
Pansage: {
types: ['Grass'],
bs: { hp: 50, at: 53, df: 48, sa: 53, sd: 48, sp: 64 },
weightkg: 10.5,
nfe: true,
abilities: { 0: 'Gluttony' }
},
Pansear: {
types: ['Fire'],
bs: { hp: 50, at: 53, df: 48, sa: 53, sd: 48, sp: 64 },
weightkg: 11,
nfe: true,
abilities: { 0: 'Gluttony' }
},
Patrat: {
types: ['Normal'],
bs: { hp: 45, at: 55, df: 39, sa: 35, sd: 39, sp: 42 },
weightkg: 11.6,
nfe: true,
abilities: { 0: 'Run Away' }
},
Pawniard: {
types: ['Dark', 'Steel'],
bs: { hp: 45, at: 85, df: 70, sa: 40, sd: 40, sp: 60 },
weightkg: 10.2,
nfe: true,
abilities: { 0: 'Defiant' }
},
Petilil: {
types: ['Grass'],
bs: { hp: 45, at: 35, df: 50, sa: 70, sd: 50, sp: 30 },
weightkg: 6.6,
nfe: true,
abilities: { 0: 'Chlorophyll' }
},
Pidove: {
types: ['Normal', 'Flying'],
bs: { hp: 50, at: 55, df: 50, sa: 36, sd: 30, sp: 43 },
weightkg: 2.1,
nfe: true,
abilities: { 0: 'Big Pecks' }
},
Pignite: {
types: ['Fire', 'Fighting'],
bs: { hp: 90, at: 93, df: 55, sa: 70, sd: 55, sp: 55 },
weightkg: 55.5,
nfe: true,
abilities: { 0: 'Blaze' }
},
Purrloin: {
types: ['Dark'],
bs: { hp: 41, at: 50, df: 37, sa: 50, sd: 37, sp: 66 },
weightkg: 10.1,
nfe: true,
abilities: { 0: 'Limber' }
},
Reshiram: {
types: ['Dragon', 'Fire'],
bs: { hp: 100, at: 120, df: 100, sa: 150, sd: 120, sp: 90 },
weightkg: 330,
abilities: { 0: 'Turboblaze' },
gender: 'N'
},
Reuniclus: {
types: ['Psychic'],
bs: { hp: 110, at: 65, df: 75, sa: 125, sd: 85, sp: 30 },
weightkg: 20.1,
abilities: { 0: 'Overcoat' }
},
Roggenrola: {
types: ['Rock'],
bs: { hp: 55, at: 75, df: 85, sa: 25, sd: 25, sp: 15 },
weightkg: 18,
nfe: true,
abilities: { 0: 'Sturdy' }
},
Rufflet: {
types: ['Normal', 'Flying'],
bs: { hp: 70, at: 83, df: 50, sa: 37, sd: 50, sp: 60 },
weightkg: 10.5,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Samurott: {
types: ['Water'],
bs: { hp: 95, at: 100, df: 85, sa: 108, sd: 70, sp: 70 },
weightkg: 94.6,
abilities: { 0: 'Torrent' }
},
Sandile: {
types: ['Ground', 'Dark'],
bs: { hp: 50, at: 72, df: 35, sa: 35, sd: 35, sp: 65 },
weightkg: 15.2,
nfe: true,
abilities: { 0: 'Intimidate' }
},
Sawk: {
types: ['Fighting'],
bs: { hp: 75, at: 125, df: 75, sa: 30, sd: 75, sp: 85 },
weightkg: 51,
abilities: { 0: 'Sturdy' }
},
Sawsbuck: {
types: ['Normal', 'Grass'],
bs: { hp: 80, at: 100, df: 70, sa: 60, sd: 70, sp: 95 },
weightkg: 92.5,
abilities: { 0: 'Chlorophyll' }
},
Scolipede: {
types: ['Bug', 'Poison'],
bs: { hp: 60, at: 90, df: 89, sa: 55, sd: 69, sp: 112 },
weightkg: 200.5,
abilities: { 0: 'Poison Point' }
},
Scrafty: {
types: ['Dark', 'Fighting'],
bs: { hp: 65, at: 90, df: 115, sa: 45, sd: 115, sp: 58 },
weightkg: 30,
abilities: { 0: 'Shed Skin' }
},
Scraggy: {
types: ['Dark', 'Fighting'],
bs: { hp: 50, at: 75, df: 70, sa: 35, sd: 70, sp: 48 },
weightkg: 11.8,
nfe: true,
abilities: { 0: 'Shed Skin' }
},
Scratchet: {
types: ['Normal', 'Fighting'],
bs: { hp: 55, at: 85, df: 80, sa: 20, sd: 70, sp: 40 },
weightkg: 20,
nfe: true,
abilities: { 0: 'Scrappy' }
},
Seismitoad: {
types: ['Water', 'Ground'],
bs: { hp: 105, at: 85, df: 75, sa: 85, sd: 75, sp: 74 },
weightkg: 62,
abilities: { 0: 'Swift Swim' }
},
Serperior: {
types: ['Grass'],
bs: { hp: 75, at: 75, df: 95, sa: 75, sd: 95, sp: 113 },
weightkg: 63,
abilities: { 0: 'Overgrow' }
},
Servine: {
types: ['Grass'],
bs: { hp: 60, at: 60, df: 75, sa: 60, sd: 75, sp: 83 },
weightkg: 16,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Sewaddle: {
types: ['Bug', 'Grass'],
bs: { hp: 45, at: 53, df: 70, sa: 40, sd: 60, sp: 42 },
weightkg: 2.5,
nfe: true,
abilities: { 0: 'Swarm' }
},
Shelmet: {
types: ['Bug'],
bs: { hp: 50, at: 40, df: 85, sa: 40, sd: 65, sp: 25 },
weightkg: 7.7,
nfe: true,
abilities: { 0: 'Hydration' }
},
Sigilyph: {
types: ['Psychic', 'Flying'],
bs: { hp: 72, at: 58, df: 80, sa: 103, sd: 80, sp: 97 },
weightkg: 14,
abilities: { 0: 'Wonder Skin' }
},
Simipour: {
types: ['Water'],
bs: { hp: 75, at: 98, df: 63, sa: 98, sd: 63, sp: 101 },
weightkg: 29,
abilities: { 0: 'Gluttony' }
},
Simisage: {
types: ['Grass'],
bs: { hp: 75, at: 98, df: 63, sa: 98, sd: 63, sp: 101 },
weightkg: 30.5,
abilities: { 0: 'Gluttony' }
},
Simisear: {
types: ['Fire'],
bs: { hp: 75, at: 98, df: 63, sa: 98, sd: 63, sp: 101 },
weightkg: 28,
abilities: { 0: 'Gluttony' }
},
Snivy: {
types: ['Grass'],
bs: { hp: 45, at: 45, df: 55, sa: 45, sd: 55, sp: 63 },
weightkg: 8.1,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Solosis: {
types: ['Psychic'],
bs: { hp: 45, at: 30, df: 40, sa: 105, sd: 50, sp: 20 },
weightkg: 1,
nfe: true,
abilities: { 0: 'Overcoat' }
},
Stoutland: {
types: ['Normal'],
bs: { hp: 85, at: 100, df: 90, sa: 45, sd: 90, sp: 80 },
weightkg: 61,
abilities: { 0: 'Intimidate' }
},
Stunfisk: {
types: ['Ground', 'Electric'],
bs: { hp: 109, at: 66, df: 84, sa: 81, sd: 99, sp: 32 },
weightkg: 11,
abilities: { 0: 'Static' }
},
Swadloon: {
types: ['Bug', 'Grass'],
bs: { hp: 55, at: 63, df: 90, sa: 50, sd: 80, sp: 42 },
weightkg: 7.3,
nfe: true,
abilities: { 0: 'Leaf Guard' }
},
Swanna: {
types: ['Water', 'Flying'],
bs: { hp: 75, at: 87, df: 63, sa: 87, sd: 63, sp: 98 },
weightkg: 24.2,
abilities: { 0: 'Keen Eye' }
},
Swoobat: {
types: ['Psychic', 'Flying'],
bs: { hp: 67, at: 57, df: 55, sa: 77, sd: 55, sp: 114 },
weightkg: 10.5,
abilities: { 0: 'Unaware' }
},
Tepig: {
types: ['Fire'],
bs: { hp: 65, at: 63, df: 45, sa: 45, sd: 45, sp: 45 },
weightkg: 9.9,
nfe: true,
abilities: { 0: 'Blaze' }
},
Terrakion: {
types: ['Rock', 'Fighting'],
bs: { hp: 91, at: 129, df: 90, sa: 72, sd: 90, sp: 108 },
weightkg: 260,
abilities: { 0: 'Justified' },
gender: 'N'
},
Throh: {
types: ['Fighting'],
bs: { hp: 120, at: 100, df: 85, sa: 30, sd: 85, sp: 45 },
weightkg: 55.5,
abilities: { 0: 'Guts' }
},
Thundurus: {
types: ['Electric', 'Flying'],
bs: { hp: 79, at: 115, df: 70, sa: 125, sd: 80, sp: 111 },
weightkg: 61,
abilities: { 0: 'Prankster' },
otherFormes: ['Thundurus-Therian']
},
'Thundurus-Therian': {
types: ['Electric', 'Flying'],
bs: { hp: 79, at: 105, df: 70, sa: 145, sd: 80, sp: 101 },
weightkg: 61,
abilities: { 0: 'Volt Absorb' },
baseSpecies: 'Thundurus'
},
Timburr: {
types: ['Fighting'],
bs: { hp: 75, at: 80, df: 55, sa: 25, sd: 35, sp: 35 },
weightkg: 12.5,
nfe: true,
abilities: { 0: 'Guts' }
},
Tirtouga: {
types: ['Water', 'Rock'],
bs: { hp: 54, at: 78, df: 103, sa: 53, sd: 45, sp: 22 },
weightkg: 16.5,
nfe: true,
abilities: { 0: 'Solid Rock' }
},
Tomohawk: {
types: ['Flying', 'Fighting'],
bs: { hp: 105, at: 60, df: 90, sa: 115, sd: 80, sp: 85 },
weightkg: 37.2,
abilities: { 0: 'Intimidate' }
},
Tornadus: {
types: ['Flying'],
bs: { hp: 79, at: 115, df: 70, sa: 125, sd: 80, sp: 111 },
weightkg: 63,
abilities: { 0: 'Prankster' },
otherFormes: ['Tornadus-Therian']
},
'Tornadus-Therian': {
types: ['Flying'],
bs: { hp: 79, at: 100, df: 80, sa: 110, sd: 90, sp: 121 },
weightkg: 63,
abilities: { 0: 'Regenerator' },
baseSpecies: 'Tornadus'
},
Tranquill: {
types: ['Normal', 'Flying'],
bs: { hp: 62, at: 77, df: 62, sa: 50, sd: 42, sp: 65 },
weightkg: 15,
nfe: true,
abilities: { 0: 'Big Pecks' }
},
Trubbish: {
types: ['Poison'],
bs: { hp: 50, at: 50, df: 62, sa: 40, sd: 62, sp: 65 },
weightkg: 31,
nfe: true,
abilities: { 0: 'Stench' }
},
Tympole: {
types: ['Water'],
bs: { hp: 50, at: 50, df: 40, sa: 50, sd: 40, sp: 64 },
weightkg: 4.5,
nfe: true,
abilities: { 0: 'Swift Swim' }
},
Tynamo: {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 45, sd: 40, sp: 60 },
weightkg: 0.3,
abilities: { 0: 'Levitate' },
nfe: true
},
Unfezant: {
types: ['Normal', 'Flying'],
bs: { hp: 80, at: 105, df: 80, sa: 65, sd: 55, sp: 93 },
weightkg: 29,
abilities: { 0: 'Big Pecks' }
},
Vanillish: {
types: ['Ice'],
bs: { hp: 51, at: 65, df: 65, sa: 80, sd: 75, sp: 59 },
weightkg: 41,
nfe: true,
abilities: { 0: 'Ice Body' }
},
Vanillite: {
types: ['Ice'],
bs: { hp: 36, at: 50, df: 50, sa: 65, sd: 60, sp: 44 },
weightkg: 5.7,
nfe: true,
abilities: { 0: 'Ice Body' }
},
Vanilluxe: {
types: ['Ice'],
bs: { hp: 71, at: 95, df: 85, sa: 110, sd: 95, sp: 79 },
weightkg: 57.5,
abilities: { 0: 'Ice Body' }
},
Venipede: {
types: ['Bug', 'Poison'],
bs: { hp: 30, at: 45, df: 59, sa: 30, sd: 39, sp: 57 },
weightkg: 5.3,
nfe: true,
abilities: { 0: 'Poison Point' }
},
Victini: {
types: ['Psychic', 'Fire'],
bs: { hp: 100, at: 100, df: 100, sa: 100, sd: 100, sp: 100 },
weightkg: 4,
abilities: { 0: 'Victory Star' },
gender: 'N'
},
Virizion: {
types: ['Grass', 'Fighting'],
bs: { hp: 91, at: 90, df: 72, sa: 90, sd: 129, sp: 108 },
weightkg: 200,
abilities: { 0: 'Justified' },
gender: 'N'
},
Volcarona: {
types: ['Bug', 'Fire'],
bs: { hp: 85, at: 60, df: 65, sa: 135, sd: 105, sp: 100 },
weightkg: 46,
abilities: { 0: 'Flame Body' }
},
Vullaby: {
types: ['Dark', 'Flying'],
bs: { hp: 70, at: 55, df: 75, sa: 45, sd: 65, sp: 60 },
weightkg: 9,
nfe: true,
abilities: { 0: 'Big Pecks' }
},
Watchog: {
types: ['Normal'],
bs: { hp: 60, at: 85, df: 69, sa: 60, sd: 69, sp: 77 },
weightkg: 27,
abilities: { 0: 'Illuminate' }
},
Whimsicott: {
types: ['Grass'],
bs: { hp: 60, at: 67, df: 85, sa: 77, sd: 75, sp: 116 },
weightkg: 6.6,
abilities: { 0: 'Prankster' }
},
Whirlipede: {
types: ['Bug', 'Poison'],
bs: { hp: 40, at: 55, df: 99, sa: 40, sd: 79, sp: 47 },
weightkg: 58.5,
nfe: true,
abilities: { 0: 'Poison Point' }
},
Woobat: {
types: ['Psychic', 'Flying'],
bs: { hp: 55, at: 45, df: 43, sa: 55, sd: 43, sp: 72 },
weightkg: 2.1,
nfe: true,
abilities: { 0: 'Unaware' }
},
Yamask: {
types: ['Ghost'],
bs: { hp: 38, at: 30, df: 85, sa: 55, sd: 65, sp: 30 },
weightkg: 1.5,
abilities: { 0: 'Mummy' },
nfe: true
},
Zebstrika: {
types: ['Electric'],
bs: { hp: 75, at: 100, df: 63, sa: 80, sd: 63, sp: 116 },
weightkg: 79.5,
abilities: { 0: 'Lightning Rod' }
},
Zekrom: {
types: ['Dragon', 'Electric'],
bs: { hp: 100, at: 150, df: 120, sa: 120, sd: 100, sp: 90 },
weightkg: 345,
abilities: { 0: 'Teravolt' },
gender: 'N'
},
Zoroark: {
types: ['Dark'],
bs: { hp: 60, at: 105, df: 60, sa: 120, sd: 60, sp: 105 },
weightkg: 81.1,
abilities: { 0: 'Illusion' }
},
Zorua: {
types: ['Dark'],
bs: { hp: 40, at: 65, df: 40, sa: 80, sd: 40, sp: 65 },
weightkg: 12.5,
abilities: { 0: 'Illusion' },
nfe: true
},
Zweilous: {
types: ['Dark', 'Dragon'],
bs: { hp: 72, at: 85, df: 70, sa: 65, sd: 70, sp: 58 },
weightkg: 50,
abilities: { 0: 'Hustle' },
nfe: true
}
};
var BW = util_1.extend(true, {}, DPP, BW_PATCH);
delete BW['Pichu'].otherFormes;
delete BW['Pichu-Spiky-eared'];
var XY_PATCH = {
Abomasnow: { otherFormes: ['Abomasnow-Mega'] },
Absol: { otherFormes: ['Absol-Mega'] },
Aerodactyl: { otherFormes: ['Aerodactyl-Mega'] },
Aggron: { otherFormes: ['Aggron-Mega'] },
Alakazam: { bs: { sd: 95 }, otherFormes: ['Alakazam-Mega'] },
Altaria: { otherFormes: ['Altaria-Mega'] },
Ampharos: { bs: { df: 85 }, otherFormes: ['Ampharos-Mega'] },
Audino: { otherFormes: ['Audino-Mega'] },
Azumarill: { types: ['Water', 'Fairy'], bs: { sa: 60 } },
Azurill: { types: ['Normal', 'Fairy'] },
Banette: { otherFormes: ['Banette-Mega'] },
Beautifly: { bs: { sa: 100 } },
Beedrill: { bs: { at: 90 }, otherFormes: ['Beedrill-Mega'] },
Bellossom: { bs: { df: 95 } },
Blastoise: { otherFormes: ['Blastoise-Mega'] },
Blaziken: { otherFormes: ['Blaziken-Mega'] },
Butterfree: { bs: { sa: 90 } },
Camerupt: { otherFormes: ['Camerupt-Mega'] },
Charizard: { otherFormes: ['Charizard-Mega-X', 'Charizard-Mega-Y'] },
Clefable: { types: ['Fairy'], bs: { sa: 95 } },
Clefairy: { types: ['Fairy'] },
Cleffa: { types: ['Fairy'] },
Cottonee: { types: ['Grass', 'Fairy'] },
Exploud: { bs: { sd: 73 } },
Gallade: { otherFormes: ['Gallade-Mega'] },
Garchomp: { otherFormes: ['Garchomp-Mega'] },
Gardevoir: { types: ['Psychic', 'Fairy'], otherFormes: ['Gardevoir-Mega'] },
Gengar: { otherFormes: ['Gengar-Mega'] },
Gigalith: { bs: { sd: 80 } },
Glalie: { otherFormes: ['Glalie-Mega'] },
Golem: { bs: { at: 120 } },
Granbull: { types: ['Fairy'] },
Groudon: { otherFormes: ['Groudon-Primal'] },
Gyarados: { otherFormes: ['Gyarados-Mega'] },
Heracross: { otherFormes: ['Heracross-Mega'] },
Houndoom: { otherFormes: ['Houndoom-Mega'] },
Igglybuff: { types: ['Normal', 'Fairy'] },
Jigglypuff: { types: ['Normal', 'Fairy'] },
Jumpluff: { bs: { sd: 95 } },
Kangaskhan: { otherFormes: ['Kangaskhan-Mega'] },
Kirlia: { types: ['Psychic', 'Fairy'] },
Krookodile: { bs: { df: 80 } },
Kyogre: { otherFormes: ['Kyogre-Primal'] },
Latias: { otherFormes: ['Latias-Mega'] },
Latios: { otherFormes: ['Latios-Mega'] },
Leavanny: { bs: { sd: 80 } },
Lopunny: { otherFormes: ['Lopunny-Mega'] },
Lucario: { otherFormes: ['Lucario-Mega'] },
Manectric: { otherFormes: ['Manectric-Mega'] },
Marill: { types: ['Water', 'Fairy'] },
Mawile: { types: ['Steel', 'Fairy'], otherFormes: ['Mawile-Mega'] },
Medicham: { otherFormes: ['Medicham-Mega'] },
Metagross: { otherFormes: ['Metagross-Mega'] },
Mewtwo: { otherFormes: ['Mewtwo-Mega-X', 'Mewtwo-Mega-Y'] },
'Mime Jr.': { types: ['Psychic', 'Fairy'] },
'Mr. Mime': { types: ['Psychic', 'Fairy'] },
Nidoking: { bs: { at: 102 } },
Nidoqueen: { bs: { at: 92 } },
Pidgeot: { bs: { sp: 101 }, otherFormes: ['Pidgeot-Mega'] },
Pikachu: {
bs: { df: 40, sd: 50 },
otherFormes: [
'Pikachu-Belle',
'Pikachu-Cosplay',
'Pikachu-Libre',
'Pikachu-PhD',
'Pikachu-Pop-Star',
'Pikachu-Rock-Star',
]
},
Pinsir: { otherFormes: ['Pinsir-Mega'] },
Poliwrath: { bs: { at: 95 } },
Raichu: { bs: { sp: 110 } },
Ralts: { types: ['Psychic', 'Fairy'] },
Rayquaza: { otherFormes: ['Rayquaza-Mega'] },
Roserade: { bs: { df: 65 } },
Sableye: { otherFormes: ['Sableye-Mega'] },
Salamence: { otherFormes: ['Salamence-Mega'] },
Sceptile: { otherFormes: ['Sceptile-Mega'] },
Scizor: { otherFormes: ['Scizor-Mega'] },
Scolipede: { bs: { at: 100 } },
Seismitoad: { bs: { at: 95 } },
Sharpedo: { otherFormes: ['Sharpedo-Mega'] },
Slowbro: { otherFormes: ['Slowbro-Mega'] },
Snubbull: { types: ['Fairy'] },
Staraptor: { bs: { sd: 60 } },
Steelix: { otherFormes: ['Steelix-Mega'] },
Stoutland: { bs: { at: 110 } },
Swampert: { otherFormes: ['Swampert-Mega'] },
Togekiss: { types: ['Fairy', 'Flying'] },
Togepi: { types: ['Fairy'] },
Togetic: { types: ['Fairy', 'Flying'] },
Tyranitar: { otherFormes: ['Tyranitar-Mega'] },
Unfezant: { bs: { at: 115 } },
Venusaur: { otherFormes: ['Venusaur-Mega'] },
Victreebel: { bs: { sd: 70 } },
Vileplume: { bs: { sa: 110 } },
Whimsicott: { types: ['Grass', 'Fairy'] },
Wigglytuff: { types: ['Normal', 'Fairy'], bs: { sa: 85 } },
'Aegislash-Blade': {
types: ['Steel', 'Ghost'],
bs: { hp: 60, at: 150, df: 50, sa: 150, sd: 50, sp: 60 },
weightkg: 53,
abilities: { 0: 'Stance Change' },
otherFormes: ['Aegislash-Shield', 'Aegislash-Both']
},
'Aegislash-Shield': {
types: ['Steel', 'Ghost'],
bs: { hp: 60, at: 50, df: 150, sa: 50, sd: 150, sp: 60 },
weightkg: 53,
abilities: { 0: 'Stance Change' },
baseSpecies: 'Aegislash-Blade'
},
'Aegislash-Both': {
types: ['Steel', 'Ghost'],
bs: { hp: 60, at: 150, df: 150, sa: 150, sd: 150, sp: 60 },
weightkg: 53,
abilities: { 0: 'Stance Change' },
baseSpecies: 'Aegislash-Blade'
},
Amaura: {
types: ['Rock', 'Ice'],
bs: { hp: 77, at: 59, df: 50, sa: 67, sd: 63, sp: 46 },
weightkg: 25.2,
nfe: true,
abilities: { 0: 'Refrigerate' }
},
'Arceus-Fairy': {
types: ['Fairy'],
bs: { hp: 120, at: 120, df: 120, sa: 120, sd: 120, sp: 120 },
weightkg: 320,
abilities: { 0: 'Multitype' },
baseSpecies: 'Arceus',
gender: 'N'
},
Aromatisse: {
types: ['Fairy'],
bs: { hp: 101, at: 72, df: 72, sa: 99, sd: 89, sp: 29 },
weightkg: 15.5,
abilities: { 0: 'Healer' }
},
Aurorus: {
types: ['Rock', 'Ice'],
bs: { hp: 123, at: 77, df: 72, sa: 99, sd: 92, sp: 58 },
weightkg: 225,
abilities: { 0: 'Refrigerate' }
},
Avalugg: {
types: ['Ice'],
bs: { hp: 95, at: 117, df: 184, sa: 44, sd: 46, sp: 28 },
weightkg: 505,
abilities: { 0: 'Own Tempo' }
},
Barbaracle: {
types: ['Rock', 'Water'],
bs: { hp: 72, at: 105, df: 115, sa: 54, sd: 86, sp: 68 },
weightkg: 96,
abilities: { 0: 'Tough Claws' }
},
Bergmite: {
types: ['Ice'],
bs: { hp: 55, at: 69, df: 85, sa: 32, sd: 35, sp: 28 },
weightkg: 99.5,
nfe: true,
abilities: { 0: 'Own Tempo' }
},
Binacle: {
types: ['Rock', 'Water'],
bs: { hp: 42, at: 52, df: 67, sa: 39, sd: 56, sp: 50 },
weightkg: 31,
nfe: true,
abilities: { 0: 'Tough Claws' }
},
Braixen: {
types: ['Fire'],
bs: { hp: 59, at: 59, df: 58, sa: 90, sd: 70, sp: 73 },
weightkg: 14.5,
nfe: true,
abilities: { 0: 'Blaze' }
},
Bunnelby: {
types: ['Normal'],
bs: { hp: 38, at: 36, df: 38, sa: 32, sd: 36, sp: 57 },
weightkg: 5,
nfe: true,
abilities: { 0: 'Pickup' }
},
Caimanoe: {
types: ['Water', 'Steel'],
bs: { hp: 73, at: 85, df: 65, sa: 80, sd: 40, sp: 87 },
weightkg: 72.5,
nfe: true,
abilities: { 0: 'Water Veil' }
},
Carbink: {
types: ['Rock', 'Fairy'],
bs: { hp: 50, at: 50, df: 150, sa: 50, sd: 150, sp: 50 },
weightkg: 5.7,
gender: 'N',
abilities: { 0: 'Clear Body' }
},
Chesnaught: {
types: ['Grass', 'Fighting'],
bs: { hp: 88, at: 107, df: 122, sa: 74, sd: 75, sp: 64 },
weightkg: 90,
abilities: { 0: 'Overgrow' }
},
Chespin: {
types: ['Grass'],
bs: { hp: 56, at: 61, df: 65, sa: 48, sd: 45, sp: 38 },
weightkg: 9,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Clauncher: {
types: ['Water'],
bs: { hp: 50, at: 53, df: 62, sa: 58, sd: 63, sp: 44 },
weightkg: 8.3,
abilities: { 0: 'Mega Launcher' },
nfe: true
},
Clawitzer: {
types: ['Water'],
bs: { hp: 71, at: 73, df: 88, sa: 120, sd: 89, sp: 59 },
weightkg: 35.3,
abilities: { 0: 'Mega Launcher' }
},
Crucibelle: {
types: ['Rock', 'Poison'],
bs: { hp: 106, at: 105, df: 65, sa: 75, sd: 85, sp: 104 },
weightkg: 23.6,
abilities: { 0: 'Regenerator' },
otherFormes: ['Crucibelle-Mega']
},
Diancie: {
types: ['Rock', 'Fairy'],
bs: { hp: 50, at: 100, df: 150, sa: 100, sd: 150, sp: 50 },
weightkg: 8.8,
abilities: { 0: 'Clear Body' },
otherFormes: ['Diancie-Mega'],
gender: 'N'
},
Dedenne: {
types: ['Electric', 'Fairy'],
bs: { hp: 67, at: 58, df: 57, sa: 81, sd: 67, sp: 101 },
weightkg: 2.2,
abilities: { 0: 'Cheek Pouch' }
},
Delphox: {
types: ['Fire', 'Psychic'],
bs: { hp: 75, at: 69, df: 72, sa: 114, sd: 100, sp: 104 },
weightkg: 39,
abilities: { 0: 'Blaze' }
},
Diggersby: {
types: ['Normal', 'Ground'],
bs: { hp: 85, at: 56, df: 77, sa: 50, sd: 77, sp: 78 },
weightkg: 42.4,
abilities: { 0: 'Pickup' }
},
Doublade: {
types: ['Steel', 'Ghost'],
bs: { hp: 59, at: 110, df: 150, sa: 45, sd: 49, sp: 35 },
weightkg: 4.5,
abilities: { 0: 'No Guard' },
nfe: true
},
Dragalge: {
types: ['Poison', 'Dragon'],
bs: { hp: 65, at: 75, df: 90, sa: 97, sd: 123, sp: 44 },
weightkg: 81.5,
abilities: { 0: 'Poison Point' }
},
Espurr: {
types: ['Psychic'],
bs: { hp: 62, at: 48, df: 54, sa: 63, sd: 60, sp: 68 },
weightkg: 3.5,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Fennekin: {
types: ['Fire'],
bs: { hp: 40, at: 45, df: 40, sa: 62, sd: 60, sp: 60 },
weightkg: 9.4,
nfe: true,
abilities: { 0: 'Blaze' }
},
Flabébé: {
types: ['Fairy'],
bs: { hp: 44, at: 38, df: 39, sa: 61, sd: 79, sp: 42 },
weightkg: 0.1,
nfe: true,
abilities: { 0: 'Flower Veil' }
},
Fletchinder: {
types: ['Fire', 'Flying'],
bs: { hp: 62, at: 73, df: 55, sa: 56, sd: 52, sp: 84 },
weightkg: 16,
nfe: true,
abilities: { 0: 'Flame Body' }
},
Fletchling: {
types: ['Normal', 'Flying'],
bs: { hp: 45, at: 50, df: 43, sa: 40, sd: 38, sp: 62 },
weightkg: 1.7,
nfe: true,
abilities: { 0: 'Big Pecks' }
},
Floatoy: {
types: ['Water'],
bs: { hp: 48, at: 70, df: 40, sa: 70, sd: 30, sp: 77 },
weightkg: 1.9,
nfe: true,
abilities: { 0: 'Water Veil' }
},
Floette: {
types: ['Fairy'],
bs: { hp: 54, at: 45, df: 47, sa: 75, sd: 98, sp: 52 },
weightkg: 0.9,
nfe: true,
abilities: { 0: 'Flower Veil' }
},
Florges: {
types: ['Fairy'],
bs: { hp: 78, at: 65, df: 68, sa: 112, sd: 154, sp: 75 },
weightkg: 10,
abilities: { 0: 'Flower Veil' }
},
Froakie: {
types: ['Water'],
bs: { hp: 41, at: 56, df: 40, sa: 62, sd: 44, sp: 71 },
weightkg: 7,
nfe: true,
abilities: { 0: 'Torrent' }
},
Frogadier: {
types: ['Water'],
bs: { hp: 54, at: 63, df: 52, sa: 83, sd: 56, sp: 97 },
weightkg: 10.9,
nfe: true,
abilities: { 0: 'Torrent' }
},
Furfrou: {
types: ['Normal'],
bs: { hp: 75, at: 80, df: 60, sa: 65, sd: 90, sp: 102 },
weightkg: 28,
abilities: { 0: 'Fur Coat' }
},
Gogoat: {
types: ['Grass'],
bs: { hp: 123, at: 100, df: 62, sa: 97, sd: 81, sp: 68 },
weightkg: 91,
abilities: { 0: 'Sap Sipper' }
},
Goodra: {
types: ['Dragon'],
bs: { hp: 90, at: 100, df: 70, sa: 110, sd: 150, sp: 80 },
weightkg: 150.5,
abilities: { 0: 'Sap Sipper' }
},
Goomy: {
types: ['Dragon'],
bs: { hp: 45, at: 50, df: 35, sa: 55, sd: 75, sp: 40 },
weightkg: 2.8,
nfe: true,
abilities: { 0: 'Sap Sipper' }
},
Gourgeist: {
types: ['Ghost', 'Grass'],
bs: { hp: 65, at: 90, df: 122, sa: 58, sd: 75, sp: 84 },
weightkg: 12.5,
abilities: { 0: 'Pickup' },
otherFormes: ['Gourgeist-Large', 'Gourgeist-Small', 'Gourgeist-Super']
},
'Gourgeist-Large': {
types: ['Ghost', 'Grass'],
bs: { hp: 75, at: 95, df: 122, sa: 58, sd: 75, sp: 69 },
weightkg: 14,
abilities: { 0: 'Pickup' },
baseSpecies: 'Gourgeist'
},
'Gourgeist-Small': {
types: ['Ghost', 'Grass'],
bs: { hp: 55, at: 85, df: 122, sa: 58, sd: 75, sp: 99 },
weightkg: 9.5,
abilities: { 0: 'Pickup' },
baseSpecies: 'Gourgeist'
},
'Gourgeist-Super': {
types: ['Ghost', 'Grass'],
bs: { hp: 85, at: 100, df: 122, sa: 58, sd: 75, sp: 54 },
weightkg: 39,
abilities: { 0: 'Pickup' },
baseSpecies: 'Gourgeist'
},
Greninja: {
types: ['Water', 'Dark'],
bs: { hp: 72, at: 95, df: 67, sa: 103, sd: 71, sp: 122 },
weightkg: 40,
abilities: { 0: 'Torrent' }
},
Hawlucha: {
types: ['Fighting', 'Flying'],
bs: { hp: 78, at: 92, df: 75, sa: 74, sd: 63, sp: 118 },
weightkg: 21.5,
abilities: { 0: 'Limber' }
},
Heliolisk: {
types: ['Electric', 'Normal'],
bs: { hp: 62, at: 55, df: 52, sa: 109, sd: 94, sp: 109 },
weightkg: 21,
abilities: { 0: 'Dry Skin' }
},
Helioptile: {
types: ['Electric', 'Normal'],
bs: { hp: 44, at: 38, df: 33, sa: 61, sd: 43, sp: 70 },
weightkg: 6,
nfe: true,
abilities: { 0: 'Dry Skin' }
},
Honedge: {
types: ['Steel', 'Ghost'],
bs: { hp: 45, at: 80, df: 100, sa: 35, sd: 37, sp: 28 },
weightkg: 2,
abilities: { 0: 'No Guard' },
nfe: true
},
Hoopa: {
types: ['Psychic', 'Ghost'],
bs: { hp: 80, at: 110, df: 60, sa: 150, sd: 130, sp: 70 },
weightkg: 9,
gender: 'N',
abilities: { 0: 'Magician' },
otherFormes: ['Hoopa-Unbound']
},
'Hoopa-Unbound': {
types: ['Psychic', 'Dark'],
bs: { hp: 80, at: 160, df: 60, sa: 170, sd: 130, sp: 80 },
weightkg: 490,
gender: 'N',
abilities: { 0: 'Magician' },
baseSpecies: 'Hoopa'
},
Inkay: {
types: ['Dark', 'Psychic'],
bs: { hp: 53, at: 54, df: 53, sa: 37, sd: 46, sp: 45 },
weightkg: 3.5,
nfe: true,
abilities: { 0: 'Contrary' }
},
Kerfluffle: {
types: ['Fairy', 'Fighting'],
bs: { hp: 84, at: 78, df: 86, sa: 115, sd: 88, sp: 119 },
weightkg: 24.2,
abilities: { 0: 'Natural Cure' }
},
Klefki: {
types: ['Steel', 'Fairy'],
bs: { hp: 57, at: 80, df: 91, sa: 80, sd: 87, sp: 75 },
weightkg: 3,
abilities: { 0: 'Prankster' }
},
Litleo: {
types: ['Fire', 'Normal'],
bs: { hp: 62, at: 50, df: 58, sa: 73, sd: 54, sp: 72 },
weightkg: 13.5,
nfe: true,
abilities: { 0: 'Rivalry' }
},
Malamar: {
types: ['Dark', 'Psychic'],
bs: { hp: 86, at: 92, df: 88, sa: 68, sd: 75, sp: 73 },
weightkg: 47,
abilities: { 0: 'Contrary' }
},
'Abomasnow-Mega': {
types: ['Grass', 'Ice'],
bs: { hp: 90, at: 132, df: 105, sa: 132, sd: 105, sp: 30 },
weightkg: 185,
abilities: { 0: 'Snow Warning' },
baseSpecies: 'Abomasnow'
},
'Absol-Mega': {
types: ['Dark'],
bs: { hp: 65, at: 150, df: 60, sa: 115, sd: 60, sp: 115 },
weightkg: 49,
abilities: { 0: 'Magic Bounce' },
baseSpecies: 'Absol'
},
'Aerodactyl-Mega': {
types: ['Rock', 'Flying'],
bs: { hp: 80, at: 135, df: 85, sa: 70, sd: 95, sp: 150 },
weightkg: 79,
abilities: { 0: 'Tough Claws' },
baseSpecies: 'Aerodactyl'
},
'Aggron-Mega': {
types: ['Steel'],
bs: { hp: 70, at: 140, df: 230, sa: 60, sd: 80, sp: 50 },
weightkg: 395,
abilities: { 0: 'Filter' },
baseSpecies: 'Aggron'
},
'Alakazam-Mega': {
types: ['Psychic'],
bs: { hp: 55, at: 50, df: 65, sa: 175, sd: 95, sp: 150 },
weightkg: 48,
abilities: { 0: 'Trace' },
baseSpecies: 'Alakazam'
},
'Altaria-Mega': {
types: ['Dragon', 'Fairy'],
bs: { hp: 75, at: 110, df: 110, sa: 110, sd: 105, sp: 80 },
weightkg: 20.6,
abilities: { 0: 'Pixilate' },
baseSpecies: 'Altaria'
},
'Ampharos-Mega': {
types: ['Electric', 'Dragon'],
bs: { hp: 90, at: 95, df: 105, sa: 165, sd: 110, sp: 45 },
weightkg: 61.5,
abilities: { 0: 'Mold Breaker' },
baseSpecies: 'Ampharos'
},
'Audino-Mega': {
types: ['Normal', 'Fairy'],
bs: { hp: 103, at: 60, df: 126, sa: 80, sd: 126, sp: 50 },
weightkg: 32,
abilities: { 0: 'Healer' },
baseSpecies: 'Audino'
},
'Banette-Mega': {
types: ['Ghost'],
bs: { hp: 64, at: 165, df: 75, sa: 93, sd: 83, sp: 75 },
weightkg: 13,
abilities: { 0: 'Prankster' },
baseSpecies: 'Banette'
},
'Beedrill-Mega': {
types: ['Bug', 'Poison'],
bs: { hp: 65, at: 150, df: 40, sa: 15, sd: 80, sp: 145 },
weightkg: 40.5,
abilities: { 0: 'Adaptability' },
baseSpecies: 'Beedrill'
},
'Blastoise-Mega': {
types: ['Water'],
bs: { hp: 79, at: 103, df: 120, sa: 135, sd: 115, sp: 78 },
weightkg: 101.1,
abilities: { 0: 'Mega Launcher' },
baseSpecies: 'Blastoise'
},
'Blaziken-Mega': {
types: ['Fire', 'Fighting'],
bs: { hp: 80, at: 160, df: 80, sa: 130, sd: 80, sp: 100 },
weightkg: 52,
abilities: { 0: 'Speed Boost' },
baseSpecies: 'Blaziken'
},
'Camerupt-Mega': {
types: ['Fire', 'Ground'],
bs: { hp: 70, at: 120, df: 100, sa: 145, sd: 105, sp: 20 },
weightkg: 320.5,
abilities: { 0: 'Sheer Force' },
baseSpecies: 'Camerupt'
},
'Charizard-Mega-X': {
types: ['Fire', 'Dragon'],
bs: { hp: 78, at: 130, df: 111, sa: 130, sd: 85, sp: 100 },
weightkg: 110.5,
abilities: { 0: 'Tough Claws' },
baseSpecies: 'Charizard'
},
'Charizard-Mega-Y': {
types: ['Fire', 'Flying'],
bs: { hp: 78, at: 104, df: 78, sa: 159, sd: 115, sp: 100 },
weightkg: 100.5,
abilities: { 0: 'Drought' },
baseSpecies: 'Charizard'
},
'Crucibelle-Mega': {
types: ['Rock', 'Poison'],
bs: { hp: 106, at: 135, df: 75, sa: 85, sd: 125, sp: 114 },
weightkg: 22.5,
abilities: { 0: 'Magic Guard' },
baseSpecies: 'Crucibelle'
},
'Diancie-Mega': {
types: ['Rock', 'Fairy'],
bs: { hp: 50, at: 160, df: 110, sa: 160, sd: 110, sp: 110 },
weightkg: 27.8,
abilities: { 0: 'Magic Bounce' },
baseSpecies: 'Diancie',
gender: 'N'
},
'Gallade-Mega': {
types: ['Psychic', 'Fighting'],
bs: { hp: 68, at: 165, df: 95, sa: 65, sd: 115, sp: 110 },
weightkg: 56.4,
abilities: { 0: 'Inner Focus' },
baseSpecies: 'Gallade'
},
'Garchomp-Mega': {
types: ['Dragon', 'Ground'],
bs: { hp: 108, at: 170, df: 115, sa: 120, sd: 95, sp: 92 },
weightkg: 95,
abilities: { 0: 'Sand Force' },
baseSpecies: 'Garchomp'
},
'Gardevoir-Mega': {
types: ['Psychic', 'Fairy'],
bs: { hp: 68, at: 85, df: 65, sa: 165, sd: 135, sp: 100 },
weightkg: 48.4,
abilities: { 0: 'Pixilate' },
baseSpecies: 'Gardevoir'
},
'Gengar-Mega': {
types: ['Ghost', 'Poison'],
bs: { hp: 60, at: 65, df: 80, sa: 170, sd: 95, sp: 130 },
weightkg: 40.5,
abilities: { 0: 'Shadow Tag' },
baseSpecies: 'Gengar'
},
'Glalie-Mega': {
types: ['Ice'],
bs: { hp: 80, at: 120, df: 80, sa: 120, sd: 80, sp: 100 },
weightkg: 350.2,
abilities: { 0: 'Refrigerate' },
baseSpecies: 'Glalie'
},
'Gyarados-Mega': {
types: ['Water', 'Dark'],
bs: { hp: 95, at: 155, df: 109, sa: 70, sd: 130, sp: 81 },
weightkg: 305,
abilities: { 0: 'Mold Breaker' },
baseSpecies: 'Gyarados'
},
'Heracross-Mega': {
types: ['Bug', 'Fighting'],
bs: { hp: 80, at: 185, df: 115, sa: 40, sd: 105, sp: 75 },
weightkg: 62.5,
abilities: { 0: 'Skill Link' },
baseSpecies: 'Heracross'
},
'Houndoom-Mega': {
types: ['Dark', 'Fire'],
bs: { hp: 75, at: 90, df: 90, sa: 140, sd: 90, sp: 115 },
weightkg: 49.5,
abilities: { 0: 'Solar Power' },
baseSpecies: 'Houndoom'
},
'Kangaskhan-Mega': {
types: ['Normal'],
bs: { hp: 105, at: 125, df: 100, sa: 60, sd: 100, sp: 100 },
weightkg: 100,
abilities: { 0: 'Parental Bond' },
baseSpecies: 'Kangaskhan'
},
'Latias-Mega': {
types: ['Dragon', 'Psychic'],
bs: { hp: 80, at: 100, df: 120, sa: 140, sd: 150, sp: 110 },
weightkg: 52,
abilities: { 0: 'Levitate' },
baseSpecies: 'Latias'
},
'Latios-Mega': {
types: ['Dragon', 'Psychic'],
bs: { hp: 80, at: 130, df: 100, sa: 160, sd: 120, sp: 110 },
weightkg: 70,
abilities: { 0: 'Levitate' },
baseSpecies: 'Latios'
},
'Lopunny-Mega': {
types: ['Normal', 'Fighting'],
bs: { hp: 65, at: 136, df: 94, sa: 54, sd: 96, sp: 135 },
weightkg: 28.3,
abilities: { 0: 'Scrappy' },
baseSpecies: 'Lopunny'
},
'Lucario-Mega': {
types: ['Fighting', 'Steel'],
bs: { hp: 70, at: 145, df: 88, sa: 140, sd: 70, sp: 112 },
weightkg: 57.5,
abilities: { 0: 'Adaptability' },
baseSpecies: 'Lucario'
},
'Manectric-Mega': {
types: ['Electric'],
bs: { hp: 70, at: 75, df: 80, sa: 135, sd: 80, sp: 135 },
weightkg: 44,
abilities: { 0: 'Intimidate' },
baseSpecies: 'Manectric'
},
'Mawile-Mega': {
types: ['Steel', 'Fairy'],
bs: { hp: 50, at: 105, df: 125, sa: 55, sd: 95, sp: 50 },
weightkg: 23.5,
abilities: { 0: 'Huge Power' },
baseSpecies: 'Mawile'
},
'Medicham-Mega': {
types: ['Fighting', 'Psychic'],
bs: { hp: 60, at: 100, df: 85, sa: 80, sd: 85, sp: 100 },
weightkg: 31.5,
abilities: { 0: 'Pure Power' },
baseSpecies: 'Medicham'
},
'Metagross-Mega': {
types: ['Steel', 'Psychic'],
bs: { hp: 80, at: 145, df: 150, sa: 105, sd: 110, sp: 110 },
weightkg: 942.9,
abilities: { 0: 'Tough Claws' },
baseSpecies: 'Metagross',
gender: 'N'
},
'Mewtwo-Mega-X': {
types: ['Psychic', 'Fighting'],
bs: { hp: 106, at: 190, df: 100, sa: 154, sd: 100, sp: 130 },
weightkg: 127,
abilities: { 0: 'Steadfast' },
baseSpecies: 'Mewtwo',
gender: 'N'
},
'Mewtwo-Mega-Y': {
types: ['Psychic'],
bs: { hp: 106, at: 150, df: 70, sa: 194, sd: 120, sp: 140 },
weightkg: 33,
abilities: { 0: 'Insomnia' },
baseSpecies: 'Mewtwo',
gender: 'N'
},
'Pidgeot-Mega': {
types: ['Normal', 'Flying'],
bs: { hp: 83, at: 80, df: 80, sa: 135, sd: 80, sp: 121 },
weightkg: 50.5,
abilities: { 0: 'No Guard' },
baseSpecies: 'Pidgeot'
},
'Pinsir-Mega': {
types: ['Bug', 'Flying'],
bs: { hp: 65, at: 155, df: 120, sa: 65, sd: 90, sp: 105 },
weightkg: 59,
abilities: { 0: 'Aerilate' },
baseSpecies: 'Pinsir'
},
'Rayquaza-Mega': {
types: ['Dragon', 'Flying'],
bs: { hp: 105, at: 180, df: 100, sa: 180, sd: 100, sp: 115 },
weightkg: 392,
gender: 'N',
abilities: { 0: 'Delta Stream' },
baseSpecies: 'Rayquaza'
},
'Sableye-Mega': {
types: ['Dark', 'Ghost'],
bs: { hp: 50, at: 85, df: 125, sa: 85, sd: 115, sp: 20 },
weightkg: 161,
abilities: { 0: 'Magic Bounce' },
baseSpecies: 'Sableye'
},
'Salamence-Mega': {
types: ['Dragon', 'Flying'],
bs: { hp: 95, at: 145, df: 130, sa: 120, sd: 90, sp: 120 },
weightkg: 112.6,
abilities: { 0: 'Aerilate' },
baseSpecies: 'Salamence'
},
'Sceptile-Mega': {
types: ['Grass', 'Dragon'],
bs: { hp: 70, at: 110, df: 75, sa: 145, sd: 85, sp: 145 },
weightkg: 55.2,
abilities: { 0: 'Lightning Rod' },
baseSpecies: 'Sceptile'
},
'Scizor-Mega': {
types: ['Bug', 'Steel'],
bs: { hp: 70, at: 150, df: 140, sa: 65, sd: 100, sp: 75 },
weightkg: 125,
abilities: { 0: 'Technician' },
baseSpecies: 'Scizor'
},
'Sharpedo-Mega': {
types: ['Water', 'Dark'],
bs: { hp: 70, at: 140, df: 70, sa: 110, sd: 65, sp: 105 },
weightkg: 130.3,
abilities: { 0: 'Strong Jaw' },
baseSpecies: 'Sharpedo'
},
'Slowbro-Mega': {
types: ['Water', 'Psychic'],
bs: { hp: 95, at: 75, df: 180, sa: 130, sd: 80, sp: 30 },
weightkg: 120,
abilities: { 0: 'Shell Armor' },
baseSpecies: 'Slowbro'
},
'Steelix-Mega': {
types: ['Steel', 'Ground'],
bs: { hp: 75, at: 125, df: 230, sa: 55, sd: 95, sp: 30 },
weightkg: 740,
abilities: { 0: 'Sand Force' },
baseSpecies: 'Steelix'
},
'Swampert-Mega': {
types: ['Water', 'Ground'],
bs: { hp: 100, at: 150, df: 110, sa: 95, sd: 110, sp: 70 },
weightkg: 102,
abilities: { 0: 'Swift Swim' },
baseSpecies: 'Swampert'
},
'Tyranitar-Mega': {
types: ['Rock', 'Dark'],
bs: { hp: 100, at: 164, df: 150, sa: 95, sd: 120, sp: 71 },
weightkg: 255,
abilities: { 0: 'Sand Stream' },
baseSpecies: 'Tyranitar'
},
'Venusaur-Mega': {
types: ['Grass', 'Poison'],
bs: { hp: 80, at: 100, df: 123, sa: 122, sd: 120, sp: 80 },
weightkg: 155.5,
abilities: { 0: 'Thick Fat' },
baseSpecies: 'Venusaur'
},
Meowstic: {
types: ['Psychic'],
bs: { hp: 74, at: 48, df: 76, sa: 83, sd: 81, sp: 104 },
weightkg: 8.5,
abilities: { 0: 'Keen Eye' },
otherFormes: ['Meowstic-F']
},
'Meowstic-F': {
types: ['Psychic'],
bs: { hp: 74, at: 48, df: 76, sa: 83, sd: 81, sp: 104 },
weightkg: 8.5,
abilities: { 0: 'Keen Eye' },
baseSpecies: 'Meowstic'
},
Naviathan: {
types: ['Water', 'Steel'],
bs: { hp: 103, at: 110, df: 90, sa: 95, sd: 65, sp: 97 },
weightkg: 510,
abilities: { 0: 'Water Veil' }
},
Noibat: {
types: ['Flying', 'Dragon'],
bs: { hp: 40, at: 30, df: 35, sa: 45, sd: 40, sp: 55 },
weightkg: 8,
nfe: true,
abilities: { 0: 'Frisk' }
},
Noivern: {
types: ['Flying', 'Dragon'],
bs: { hp: 85, at: 70, df: 80, sa: 97, sd: 80, sp: 123 },
weightkg: 85,
abilities: { 0: 'Frisk' }
},
Pancham: {
types: ['Fighting'],
bs: { hp: 67, at: 82, df: 62, sa: 46, sd: 48, sp: 43 },
weightkg: 8,
nfe: true,
abilities: { 0: 'Iron Fist' }
},
Pangoro: {
types: ['Fighting', 'Dark'],
bs: { hp: 95, at: 124, df: 78, sa: 69, sd: 71, sp: 58 },
weightkg: 136,
abilities: { 0: 'Iron Fist' }
},
Phantump: {
types: ['Ghost', 'Grass'],
bs: { hp: 43, at: 70, df: 48, sa: 50, sd: 60, sp: 38 },
weightkg: 7,
nfe: true,
abilities: { 0: 'Natural Cure' }
},
'Pikachu-Cosplay': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Lightning Rod' },
baseSpecies: 'Pikachu'
},
'Pikachu-Rock-Star': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Lightning Rod' },
baseSpecies: 'Pikachu'
},
'Pikachu-Belle': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Lightning Rod' },
baseSpecies: 'Pikachu'
},
'Pikachu-PhD': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Lightning Rod' },
baseSpecies: 'Pikachu'
},
'Pikachu-Pop-Star': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Lightning Rod' },
baseSpecies: 'Pikachu'
},
'Pikachu-Libre': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Lightning Rod' },
baseSpecies: 'Pikachu'
},
Plasmanta: {
types: ['Electric', 'Poison'],
bs: { hp: 60, at: 57, df: 119, sa: 131, sd: 98, sp: 100 },
weightkg: 460,
abilities: { 0: 'Storm Drain' }
},
Pluffle: {
types: ['Fairy'],
bs: { hp: 74, at: 38, df: 51, sa: 65, sd: 78, sp: 49 },
weightkg: 1.8,
nfe: true,
abilities: { 0: 'Natural Cure' }
},
'Groudon-Primal': {
types: ['Ground', 'Fire'],
bs: { hp: 100, at: 180, df: 160, sa: 150, sd: 90, sp: 90 },
weightkg: 999.7,
abilities: { 0: 'Desolate Land' },
baseSpecies: 'Groudon',
gender: 'N'
},
'Kyogre-Primal': {
types: ['Water'],
bs: { hp: 100, at: 150, df: 90, sa: 180, sd: 160, sp: 90 },
weightkg: 430,
abilities: { 0: 'Primordial Sea' },
baseSpecies: 'Kyogre',
gender: 'N'
},
Pumpkaboo: {
types: ['Ghost', 'Grass'],
bs: { hp: 49, at: 66, df: 70, sa: 44, sd: 55, sp: 51 },
weightkg: 5,
nfe: true,
abilities: { 0: 'Pickup' },
otherFormes: ['Pumpkaboo-Large', 'Pumpkaboo-Small', 'Pumpkaboo-Super']
},
'Pumpkaboo-Large': {
types: ['Ghost', 'Grass'],
bs: { hp: 54, at: 66, df: 70, sa: 44, sd: 55, sp: 46 },
weightkg: 7.5,
nfe: true,
abilities: { 0: 'Pickup' },
baseSpecies: 'Pumpkaboo'
},
'Pumpkaboo-Small': {
types: ['Ghost', 'Grass'],
bs: { hp: 44, at: 66, df: 70, sa: 44, sd: 55, sp: 56 },
weightkg: 3.5,
nfe: true,
abilities: { 0: 'Pickup' },
baseSpecies: 'Pumpkaboo'
},
'Pumpkaboo-Super': {
types: ['Ghost', 'Grass'],
bs: { hp: 59, at: 66, df: 70, sa: 44, sd: 55, sp: 41 },
weightkg: 15,
nfe: true,
abilities: { 0: 'Pickup' },
baseSpecies: 'Pumpkaboo'
},
Pyroar: {
types: ['Fire', 'Normal'],
bs: { hp: 86, at: 68, df: 72, sa: 109, sd: 66, sp: 106 },
weightkg: 81.5,
abilities: { 0: 'Rivalry' }
},
Quilladin: {
types: ['Grass'],
bs: { hp: 61, at: 78, df: 95, sa: 56, sd: 58, sp: 57 },
weightkg: 29,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Scatterbug: {
types: ['Bug'],
bs: { hp: 38, at: 35, df: 40, sa: 27, sd: 25, sp: 35 },
weightkg: 2.5,
nfe: true,
abilities: { 0: 'Shield Dust' }
},
Skiddo: {
types: ['Grass'],
bs: { hp: 66, at: 65, df: 48, sa: 62, sd: 57, sp: 52 },
weightkg: 31,
nfe: true,
abilities: { 0: 'Sap Sipper' }
},
Skrelp: {
types: ['Poison', 'Water'],
bs: { hp: 50, at: 60, df: 60, sa: 60, sd: 60, sp: 30 },
weightkg: 7.3,
nfe: true,
abilities: { 0: 'Poison Point' }
},
Sliggoo: {
types: ['Dragon'],
bs: { hp: 68, at: 75, df: 53, sa: 83, sd: 113, sp: 60 },
weightkg: 17.5,
nfe: true,
abilities: { 0: 'Sap Sipper' }
},
Slurpuff: {
types: ['Fairy'],
bs: { hp: 82, at: 80, df: 86, sa: 85, sd: 75, sp: 72 },
weightkg: 5,
abilities: { 0: 'Sweet Veil' }
},
Snugglow: {
types: ['Electric', 'Poison'],
bs: { hp: 40, at: 37, df: 79, sa: 91, sd: 68, sp: 70 },
weightkg: 6,
nfe: true,
abilities: { 0: 'Storm Drain' }
},
Spewpa: {
types: ['Bug'],
bs: { hp: 45, at: 22, df: 60, sa: 27, sd: 30, sp: 29 },
weightkg: 8.4,
nfe: true,
abilities: { 0: 'Shed Skin' }
},
Spritzee: {
types: ['Fairy'],
bs: { hp: 78, at: 52, df: 60, sa: 63, sd: 65, sp: 23 },
weightkg: 0.5,
nfe: true,
abilities: { 0: 'Healer' }
},
Swirlix: {
types: ['Fairy'],
bs: { hp: 62, at: 48, df: 66, sa: 59, sd: 57, sp: 49 },
weightkg: 3.5,
nfe: true,
abilities: { 0: 'Sweet Veil' }
},
Sylveon: {
types: ['Fairy'],
bs: { hp: 95, at: 65, df: 65, sa: 110, sd: 130, sp: 60 },
weightkg: 23.5,
abilities: { 0: 'Cute Charm' }
},
Talonflame: {
types: ['Fire', 'Flying'],
bs: { hp: 78, at: 81, df: 71, sa: 74, sd: 69, sp: 126 },
weightkg: 24.5,
abilities: { 0: 'Flame Body' }
},
Trevenant: {
types: ['Ghost', 'Grass'],
bs: { hp: 85, at: 110, df: 76, sa: 65, sd: 82, sp: 56 },
weightkg: 71,
abilities: { 0: 'Natural Cure' }
},
Tyrantrum: {
types: ['Rock', 'Dragon'],
bs: { hp: 82, at: 121, df: 119, sa: 69, sd: 59, sp: 71 },
weightkg: 270,
abilities: { 0: 'Strong Jaw' }
},
Tyrunt: {
types: ['Rock', 'Dragon'],
bs: { hp: 58, at: 89, df: 77, sa: 45, sd: 45, sp: 48 },
weightkg: 26,
nfe: true,
abilities: { 0: 'Strong Jaw' }
},
Vivillon: {
types: ['Bug', 'Flying'],
bs: { hp: 80, at: 52, df: 50, sa: 90, sd: 50, sp: 89 },
weightkg: 17,
abilities: { 0: 'Shield Dust' },
otherFormes: ['Vivillon-Fancy', 'Vivillon-Pokeball']
},
'Vivillon-Fancy': {
types: ['Bug', 'Flying'],
bs: { hp: 80, at: 52, df: 50, sa: 90, sd: 50, sp: 89 },
weightkg: 17,
abilities: { 0: 'Shield Dust' },
baseSpecies: 'Vivillon'
},
'Vivillon-Pokeball': {
types: ['Bug', 'Flying'],
bs: { hp: 80, at: 52, df: 50, sa: 90, sd: 50, sp: 89 },
weightkg: 17,
abilities: { 0: 'Shield Dust' },
baseSpecies: 'Vivillon'
},
Volcanion: {
types: ['Fire', 'Water'],
bs: { hp: 80, at: 110, df: 120, sa: 130, sd: 90, sp: 70 },
weightkg: 195,
gender: 'N',
abilities: { 0: 'Water Absorb' }
},
Volkraken: {
types: ['Water', 'Fire'],
bs: { hp: 100, at: 45, df: 80, sa: 135, sd: 100, sp: 95 },
weightkg: 44.5,
abilities: { 0: 'Analytic' }
},
Volkritter: {
types: ['Water', 'Fire'],
bs: { hp: 60, at: 30, df: 50, sa: 80, sd: 60, sp: 70 },
weightkg: 15,
nfe: true,
abilities: { 0: 'Anticipation' }
},
Xerneas: {
types: ['Fairy'],
bs: { hp: 126, at: 131, df: 95, sa: 131, sd: 98, sp: 99 },
weightkg: 215,
abilities: { 0: 'Fairy Aura' },
gender: 'N'
},
Yveltal: {
types: ['Dark', 'Flying'],
bs: { hp: 126, at: 131, df: 95, sa: 131, sd: 98, sp: 99 },
weightkg: 203,
abilities: { 0: 'Dark Aura' },
gender: 'N'
},
Zygarde: {
types: ['Dragon', 'Ground'],
bs: { hp: 108, at: 100, df: 121, sa: 81, sd: 95, sp: 95 },
weightkg: 305,
abilities: { 0: 'Aura Break' },
gender: 'N'
}
};
var XY = util_1.extend(true, {}, BW, XY_PATCH);
XY['Arceus'].otherFormes.push('Arceus-Fairy');
XY['Arceus'].otherFormes.sort();
var SM_PATCH = {
'Alakazam-Mega': { bs: { sd: 105 } },
Arbok: { bs: { at: 95 } },
Ariados: { bs: { sd: 70 } },
Beartic: { bs: { at: 130 } },
Chimecho: { bs: { hp: 75, df: 80, sd: 90 } },
Corsola: { bs: { hp: 65, df: 95, sd: 95 } },
'Crucibelle-Mega': { bs: { sa: 91, sp: 108 } },
Crustle: { bs: { at: 105 } },
Cryogonal: { bs: { hp: 80, df: 50 } },
Delcatty: { bs: { sp: 90 } },
Diglett: { otherFormes: ['Diglett-Alola'] },
Dodrio: { bs: { sp: 110 } },
Dugtrio: { bs: { at: 100 }, otherFormes: ['Dugtrio-Alola'] },
Eevee: { otherFormes: ['Eevee-Starter'] },
Electrode: { bs: { sp: 150 } },
Exeggutor: { bs: { sd: 75 }, otherFormes: ['Exeggutor-Alola'] },
'Farfetch\u2019d': { bs: { at: 90 } },
Gengar: { abilities: { 0: 'Cursed Body' } },
Geodude: { otherFormes: ['Geodude-Alola'] },
Golem: { otherFormes: ['Golem-Alola'] },
Graveler: { otherFormes: ['Graveler-Alola'] },
Greninja: { otherFormes: ['Greninja-Ash'] },
Grimer: { otherFormes: ['Grimer-Alola'] },
Illumise: { bs: { df: 75, sd: 85 } },
Lunatone: { bs: { hp: 90 } },
Magcargo: { bs: { hp: 60, sa: 90 } },
Mantine: { bs: { hp: 85 } },
Marowak: { otherFormes: ['Marowak-Alola', 'Marowak-Alola-Totem'] },
Masquerain: { bs: { sa: 100, sp: 80 } },
Meowth: { otherFormes: ['Meowth-Alola'] },
Muk: { otherFormes: ['Muk-Alola'] },
Necturna: { bs: { sp: 58 } },
Ninetales: { otherFormes: ['Ninetales-Alola'] },
Naviathan: { abilities: { 0: 'Guts' } },
Noctowl: { bs: { sa: 86 } },
Pelipper: { bs: { sa: 95 } },
Persian: { otherFormes: ['Persian-Alola'] },
Pikachu: {
otherFormes: [
'Pikachu-Alola',
'Pikachu-Hoenn',
'Pikachu-Kalos',
'Pikachu-Original',
'Pikachu-Partner',
'Pikachu-Sinnoh',
'Pikachu-Starter',
'Pikachu-Unova',
]
},
Qwilfish: { bs: { df: 85 } },
Raichu: { otherFormes: ['Raichu-Alola'] },
Raticate: { otherFormes: ['Raticate-Alola', 'Raticate-Alola-Totem'] },
Rattata: { otherFormes: ['Rattata-Alola'] },
Sandshrew: { otherFormes: ['Sandshrew-Alola'] },
Sandslash: { otherFormes: ['Sandslash-Alola'] },
Solrock: { bs: { hp: 90 } },
Swellow: { bs: { sa: 75 } },
Volbeat: { bs: { df: 75, sd: 85 } },
Vulpix: { otherFormes: ['Vulpix-Alola'] },
Woobat: { bs: { hp: 65 } },
Zygarde: { otherFormes: ['Zygarde-10%', 'Zygarde-Complete'] },
Araquanid: {
types: ['Water', 'Bug'],
bs: { hp: 68, at: 70, df: 92, sa: 50, sd: 132, sp: 42 },
abilities: { 0: 'Water Bubble' },
weightkg: 82,
otherFormes: ['Araquanid-Totem']
},
'Araquanid-Totem': {
types: ['Water', 'Bug'],
bs: { hp: 68, at: 70, df: 92, sa: 50, sd: 132, sp: 42 },
abilities: { 0: 'Water Bubble' },
weightkg: 217.5,
baseSpecies: 'Araquanid'
},
Bewear: {
types: ['Normal', 'Fighting'],
bs: { hp: 120, at: 125, df: 80, sa: 55, sd: 60, sp: 60 },
abilities: { 0: 'Fluffy' },
weightkg: 135
},
Blacephalon: {
types: ['Fire', 'Ghost'],
bs: { hp: 53, at: 127, df: 53, sa: 151, sd: 79, sp: 107 },
weightkg: 13,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
Bounsweet: {
types: ['Grass'],
bs: { hp: 42, at: 30, df: 38, sa: 30, sd: 38, sp: 32 },
weightkg: 3.2,
nfe: true,
abilities: { 0: 'Leaf Guard' }
},
Brionne: {
types: ['Water'],
bs: { hp: 60, at: 69, df: 69, sa: 91, sd: 81, sp: 50 },
weightkg: 17.5,
nfe: true,
abilities: { 0: 'Torrent' }
},
Bruxish: {
types: ['Water', 'Psychic'],
bs: { hp: 68, at: 105, df: 70, sa: 70, sd: 70, sp: 92 },
weightkg: 19,
abilities: { 0: 'Dazzling' }
},
Buzzwole: {
types: ['Bug', 'Fighting'],
bs: { hp: 107, at: 139, df: 139, sa: 53, sd: 53, sp: 79 },
weightkg: 333.6,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
Caribolt: {
types: ['Grass', 'Electric'],
bs: { hp: 84, at: 106, df: 82, sa: 77, sd: 80, sp: 106 },
weightkg: 140,
abilities: { 0: 'Overgrow' }
},
Celesteela: {
types: ['Steel', 'Flying'],
bs: { hp: 97, at: 101, df: 103, sa: 107, sd: 101, sp: 61 },
weightkg: 999.9,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
Charjabug: {
types: ['Bug', 'Electric'],
bs: { hp: 57, at: 82, df: 95, sa: 55, sd: 75, sp: 36 },
weightkg: 10.5,
nfe: true,
abilities: { 0: 'Battery' }
},
Comfey: {
types: ['Fairy'],
bs: { hp: 51, at: 52, df: 90, sa: 82, sd: 110, sp: 100 },
weightkg: 0.3,
abilities: { 0: 'Flower Veil' }
},
Cosmoem: {
types: ['Psychic'],
bs: { hp: 43, at: 29, df: 131, sa: 29, sd: 131, sp: 37 },
weightkg: 999.9,
nfe: true,
gender: 'N',
abilities: { 0: 'Sturdy' }
},
Coribalis: {
types: ['Water', 'Bug'],
bs: { hp: 76, at: 69, df: 90, sa: 65, sd: 77, sp: 43 },
weightkg: 24.5,
nfe: true,
abilities: { 0: 'Torrent' }
},
Cosmog: {
types: ['Psychic'],
bs: { hp: 43, at: 29, df: 31, sa: 29, sd: 31, sp: 37 },
weightkg: 0.1,
nfe: true,
gender: 'N',
abilities: { 0: 'Unaware' }
},
Crabominable: {
types: ['Fighting', 'Ice'],
bs: { hp: 97, at: 132, df: 77, sa: 62, sd: 67, sp: 43 },
weightkg: 180,
abilities: { 0: 'Hyper Cutter' }
},
Crabrawler: {
types: ['Fighting'],
bs: { hp: 47, at: 82, df: 57, sa: 42, sd: 47, sp: 63 },
weightkg: 7,
nfe: true,
abilities: { 0: 'Hyper Cutter' }
},
Cutiefly: {
types: ['Bug', 'Fairy'],
bs: { hp: 40, at: 45, df: 40, sa: 55, sd: 40, sp: 84 },
weightkg: 0.2,
nfe: true,
abilities: { 0: 'Honey Gather' }
},
Dartrix: {
types: ['Grass', 'Flying'],
bs: { hp: 78, at: 75, df: 75, sa: 70, sd: 70, sp: 52 },
weightkg: 16,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Decidueye: {
types: ['Grass', 'Ghost'],
bs: { hp: 78, at: 107, df: 75, sa: 100, sd: 100, sp: 70 },
weightkg: 36.6,
abilities: { 0: 'Overgrow' }
},
Dewpider: {
types: ['Water', 'Bug'],
bs: { hp: 38, at: 40, df: 52, sa: 40, sd: 72, sp: 27 },
weightkg: 4,
nfe: true,
abilities: { 0: 'Water Bubble' }
},
Dhelmise: {
types: ['Ghost', 'Grass'],
bs: { hp: 70, at: 131, df: 100, sa: 86, sd: 90, sp: 40 },
weightkg: 210,
gender: 'N',
abilities: { 0: 'Steelworker' }
},
Drampa: {
types: ['Normal', 'Dragon'],
bs: { hp: 78, at: 60, df: 85, sa: 135, sd: 91, sp: 36 },
weightkg: 185,
abilities: { 0: 'Berserk' }
},
'Diglett-Alola': {
types: ['Ground', 'Steel'],
bs: { hp: 10, at: 55, df: 30, sa: 35, sd: 45, sp: 90 },
weightkg: 1,
baseSpecies: 'Diglett',
nfe: true,
abilities: { 0: 'Sand Veil' }
},
'Dugtrio-Alola': {
types: ['Ground', 'Steel'],
bs: { hp: 35, at: 100, df: 60, sa: 50, sd: 70, sp: 110 },
weightkg: 66.6,
baseSpecies: 'Dugtrio',
abilities: { 0: 'Sand Veil' }
},
'Eevee-Starter': {
types: ['Normal'],
bs: { hp: 65, at: 75, df: 70, sa: 65, sd: 85, sp: 75 },
weightkg: 6.5,
abilities: { 0: 'Run Away' },
baseSpecies: 'Eevee'
},
Electrelk: {
types: ['Grass', 'Electric'],
bs: { hp: 59, at: 81, df: 67, sa: 57, sd: 55, sp: 101 },
weightkg: 41.5,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Equilibra: {
types: ['Steel', 'Ground'],
bs: { hp: 102, at: 50, df: 96, sa: 133, sd: 118, sp: 60 },
weightkg: 51.3,
gender: 'N',
abilities: { 0: 'Levitate' }
},
'Exeggutor-Alola': {
types: ['Grass', 'Dragon'],
bs: { hp: 95, at: 105, df: 85, sa: 125, sd: 75, sp: 45 },
weightkg: 415.6,
baseSpecies: 'Exeggutor',
abilities: { 0: 'Frisk' }
},
Fawnifer: {
types: ['Grass'],
bs: { hp: 49, at: 61, df: 42, sa: 52, sd: 40, sp: 76 },
weightkg: 6.9,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Fomantis: {
types: ['Grass'],
bs: { hp: 40, at: 55, df: 35, sa: 50, sd: 35, sp: 35 },
weightkg: 1.5,
nfe: true,
abilities: { 0: 'Leaf Guard' }
},
'Geodude-Alola': {
types: ['Rock', 'Electric'],
bs: { hp: 40, at: 80, df: 100, sa: 30, sd: 30, sp: 20 },
weightkg: 20.3,
baseSpecies: 'Geodude',
nfe: true,
abilities: { 0: 'Magnet Pull' }
},
'Golem-Alola': {
types: ['Rock', 'Electric'],
bs: { hp: 80, at: 120, df: 130, sa: 55, sd: 65, sp: 45 },
weightkg: 316,
abilities: { 0: 'Magnet Pull' },
baseSpecies: 'Golem'
},
Golisopod: {
types: ['Bug', 'Water'],
bs: { hp: 75, at: 125, df: 140, sa: 60, sd: 90, sp: 40 },
weightkg: 108,
abilities: { 0: 'Emergency Exit' }
},
'Graveler-Alola': {
types: ['Rock', 'Electric'],
bs: { hp: 55, at: 95, df: 115, sa: 45, sd: 45, sp: 35 },
weightkg: 110,
baseSpecies: 'Graveler',
nfe: true,
abilities: { 0: 'Magnet Pull' }
},
'Grimer-Alola': {
types: ['Poison', 'Dark'],
bs: { hp: 80, at: 80, df: 50, sa: 40, sd: 50, sp: 25 },
weightkg: 42,
baseSpecies: 'Grimer',
nfe: true,
abilities: { 0: 'Poison Touch' }
},
'Greninja-Ash': {
types: ['Water', 'Dark'],
bs: { hp: 72, at: 145, df: 67, sa: 153, sd: 71, sp: 132 },
weightkg: 40,
abilities: { 0: 'Battle Bond' },
baseSpecies: 'Greninja'
},
Grubbin: {
types: ['Bug'],
bs: { hp: 47, at: 62, df: 45, sa: 55, sd: 45, sp: 46 },
weightkg: 4.4,
nfe: true,
abilities: { 0: 'Swarm' }
},
Gumshoos: {
types: ['Normal'],
bs: { hp: 88, at: 110, df: 60, sa: 55, sd: 60, sp: 45 },
weightkg: 14.2,
otherFormes: ['Gumshoos-Totem'],
abilities: { 0: 'Stakeout' }
},
'Gumshoos-Totem': {
types: ['Normal'],
bs: { hp: 88, at: 110, df: 60, sa: 55, sd: 60, sp: 45 },
weightkg: 60,
baseSpecies: 'Gumshoos',
abilities: { 0: 'Adaptability' }
},
Guzzlord: {
types: ['Dark', 'Dragon'],
bs: { hp: 223, at: 101, df: 53, sa: 97, sd: 53, sp: 43 },
weightkg: 888,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
'Hakamo-o': {
types: ['Dragon', 'Fighting'],
bs: { hp: 55, at: 75, df: 90, sa: 65, sd: 70, sp: 65 },
weightkg: 47,
nfe: true,
abilities: { 0: 'Bulletproof' }
},
Incineroar: {
types: ['Fire', 'Dark'],
bs: { hp: 95, at: 115, df: 90, sa: 80, sd: 90, sp: 60 },
weightkg: 83,
abilities: { 0: 'Blaze' }
},
'Jangmo-o': {
types: ['Dragon'],
bs: { hp: 45, at: 55, df: 65, sa: 45, sd: 45, sp: 45 },
weightkg: 29.7,
nfe: true,
abilities: { 0: 'Bulletproof' }
},
Justyke: {
types: ['Steel', 'Ground'],
bs: { hp: 72, at: 70, df: 56, sa: 83, sd: 68, sp: 30 },
weightkg: 36.5,
nfe: true,
abilities: { 0: 'Levitate' },
gender: 'N'
},
Jumbao: {
types: ['Grass', 'Fairy'],
bs: { hp: 92, at: 63, df: 97, sa: 124, sd: 104, sp: 96 },
weightkg: 600,
abilities: { 0: 'Drought' }
},
Kartana: {
types: ['Grass', 'Steel'],
bs: { hp: 59, at: 181, df: 131, sa: 59, sd: 31, sp: 109 },
weightkg: 0.1,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
Komala: {
types: ['Normal'],
bs: { hp: 65, at: 115, df: 65, sa: 75, sd: 95, sp: 65 },
weightkg: 19.9,
abilities: { 0: 'Comatose' }
},
'Kommo-o': {
types: ['Dragon', 'Fighting'],
bs: { hp: 75, at: 110, df: 125, sa: 100, sd: 105, sp: 85 },
weightkg: 78.2,
otherFormes: ['Kommo-o-Totem'],
abilities: { 0: 'Bulletproof' }
},
'Kommo-o-Totem': {
types: ['Dragon', 'Fighting'],
bs: { hp: 75, at: 110, df: 125, sa: 100, sd: 105, sp: 85 },
weightkg: 207.5,
abilities: { 0: 'Overcoat' },
baseSpecies: 'Kommo-o'
},
Litten: {
types: ['Fire'],
bs: { hp: 45, at: 65, df: 40, sa: 60, sd: 40, sp: 70 },
weightkg: 4.3,
nfe: true,
abilities: { 0: 'Blaze' }
},
Lunala: {
types: ['Psychic', 'Ghost'],
bs: { hp: 137, at: 113, df: 89, sa: 137, sd: 107, sp: 97 },
weightkg: 120,
abilities: { 0: 'Shadow Shield' },
gender: 'N'
},
Lurantis: {
types: ['Grass'],
bs: { hp: 70, at: 105, df: 90, sa: 80, sd: 90, sp: 45 },
weightkg: 18.5,
otherFormes: ['Lurantis-Totem'],
abilities: { 0: 'Leaf Guard' }
},
'Lurantis-Totem': {
types: ['Grass'],
bs: { hp: 70, at: 105, df: 90, sa: 80, sd: 90, sp: 45 },
weightkg: 58,
abilities: { 0: 'Leaf Guard' },
baseSpecies: 'Lurantis'
},
Lycanroc: {
types: ['Rock'],
bs: { hp: 75, at: 115, df: 65, sa: 55, sd: 65, sp: 112 },
weightkg: 25,
otherFormes: ['Lycanroc-Dusk', 'Lycanroc-Midnight'],
abilities: { 0: 'Keen Eye' }
},
'Lycanroc-Dusk': {
types: ['Rock'],
bs: { hp: 75, at: 117, df: 65, sa: 55, sd: 65, sp: 110 },
weightkg: 25,
abilities: { 0: 'Tough Claws' },
baseSpecies: 'Lycanroc'
},
'Lycanroc-Midnight': {
types: ['Rock'],
bs: { hp: 85, at: 115, df: 75, sa: 55, sd: 75, sp: 82 },
weightkg: 25,
baseSpecies: 'Lycanroc',
abilities: { 0: 'Keen Eye' }
},
Magearna: {
types: ['Steel', 'Fairy'],
bs: { hp: 80, at: 95, df: 115, sa: 130, sd: 115, sp: 65 },
weightkg: 80.5,
gender: 'N',
abilities: { 0: 'Soul-Heart' }
},
Mareanie: {
types: ['Poison', 'Water'],
bs: { hp: 50, at: 53, df: 62, sa: 43, sd: 52, sp: 45 },
weightkg: 8,
nfe: true,
abilities: { 0: 'Merciless' }
},
'Marowak-Alola': {
types: ['Fire', 'Ghost'],
bs: { hp: 60, at: 80, df: 110, sa: 50, sd: 80, sp: 45 },
weightkg: 34,
abilities: { 0: 'Cursed Body' },
baseSpecies: 'Marowak'
},
'Marowak-Alola-Totem': {
types: ['Fire', 'Ghost'],
bs: { hp: 60, at: 80, df: 110, sa: 50, sd: 80, sp: 45 },
weightkg: 98,
abilities: { 0: 'Rock Head' },
baseSpecies: 'Marowak'
},
Marshadow: {
types: ['Fighting', 'Ghost'],
bs: { hp: 90, at: 125, df: 80, sa: 90, sd: 90, sp: 125 },
weightkg: 22.2,
gender: 'N',
abilities: { 0: 'Technician' }
},
Melmetal: {
types: ['Steel'],
bs: { hp: 135, at: 143, df: 143, sa: 80, sd: 65, sp: 34 },
weightkg: 800,
gender: 'N',
abilities: { 0: 'Iron Fist' }
},
Meltan: {
types: ['Steel'],
bs: { hp: 46, at: 65, df: 65, sa: 55, sd: 35, sp: 34 },
weightkg: 8,
gender: 'N',
abilities: { 0: 'Magnet Pull' }
},
'Meowth-Alola': {
types: ['Dark'],
bs: { hp: 40, at: 35, df: 35, sa: 50, sd: 40, sp: 90 },
weightkg: 4.2,
baseSpecies: 'Meowth',
nfe: true,
abilities: { 0: 'Pickup' }
},
Mimikyu: {
types: ['Ghost', 'Fairy'],
bs: { hp: 55, at: 90, df: 80, sa: 50, sd: 105, sp: 96 },
weightkg: 0.7,
otherFormes: ['Mimikyu-Busted', 'Mimikyu-Busted-Totem', 'Mimikyu-Totem'],
abilities: { 0: 'Disguise' }
},
'Mimikyu-Busted': {
types: ['Ghost', 'Fairy'],
bs: { hp: 55, at: 90, df: 80, sa: 50, sd: 105, sp: 96 },
weightkg: 0.7,
baseSpecies: 'Mimikyu',
abilities: { 0: 'Disguise' }
},
'Mimikyu-Busted-Totem': {
types: ['Ghost', 'Fairy'],
bs: { hp: 55, at: 90, df: 80, sa: 50, sd: 105, sp: 96 },
weightkg: 2.8,
baseSpecies: 'Mimikyu',
abilities: { 0: 'Disguise' }
},
'Mimikyu-Totem': {
types: ['Ghost', 'Fairy'],
bs: { hp: 55, at: 90, df: 80, sa: 50, sd: 105, sp: 96 },
weightkg: 2.8,
baseSpecies: 'Mimikyu',
abilities: { 0: 'Disguise' }
},
Minior: {
types: ['Rock', 'Flying'],
bs: { hp: 60, at: 100, df: 60, sa: 100, sd: 60, sp: 120 },
weightkg: 0.3,
otherFormes: ['Minior-Meteor'],
gender: 'N',
abilities: { 0: 'Shields Down' }
},
'Minior-Meteor': {
types: ['Rock', 'Flying'],
bs: { hp: 60, at: 60, df: 100, sa: 60, sd: 100, sp: 60 },
weightkg: 40,
gender: 'N',
baseSpecies: 'Minior',
abilities: { 0: 'Shields Down' }
},
Morelull: {
types: ['Grass', 'Fairy'],
bs: { hp: 40, at: 35, df: 55, sa: 65, sd: 75, sp: 15 },
weightkg: 1.5,
nfe: true,
abilities: { 0: 'Illuminate' }
},
Mudbray: {
types: ['Ground'],
bs: { hp: 70, at: 100, df: 70, sa: 45, sd: 55, sp: 45 },
weightkg: 110,
nfe: true,
abilities: { 0: 'Own Tempo' }
},
Mudsdale: {
types: ['Ground'],
bs: { hp: 100, at: 125, df: 100, sa: 55, sd: 85, sp: 35 },
weightkg: 920,
abilities: { 0: 'Own Tempo' }
},
'Muk-Alola': {
types: ['Poison', 'Dark'],
bs: { hp: 105, at: 105, df: 75, sa: 65, sd: 100, sp: 50 },
weightkg: 52,
baseSpecies: 'Muk',
abilities: { 0: 'Poison Touch' }
},
Mumbao: {
types: ['Grass', 'Fairy'],
bs: { hp: 55, at: 30, df: 64, sa: 87, sd: 73, sp: 66 },
weightkg: 250,
nfe: true,
abilities: { 0: 'Solar Power' }
},
Naganadel: {
types: ['Poison', 'Dragon'],
bs: { hp: 73, at: 73, df: 73, sa: 127, sd: 73, sp: 121 },
weightkg: 150,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
Necrozma: {
types: ['Psychic'],
bs: { hp: 97, at: 107, df: 101, sa: 127, sd: 89, sp: 79 },
weightkg: 230,
abilities: { 0: 'Prism Armor' },
otherFormes: ['Necrozma-Dawn-Wings', 'Necrozma-Dusk-Mane', 'Necrozma-Ultra'],
gender: 'N'
},
'Necrozma-Dawn-Wings': {
types: ['Psychic', 'Ghost'],
bs: { hp: 97, at: 113, df: 109, sa: 157, sd: 127, sp: 77 },
weightkg: 350,
abilities: { 0: 'Prism Armor' },
baseSpecies: 'Necrozma',
gender: 'N'
},
'Necrozma-Dusk-Mane': {
types: ['Psychic', 'Steel'],
bs: { hp: 97, at: 157, df: 127, sa: 113, sd: 109, sp: 77 },
weightkg: 460,
abilities: { 0: 'Prism Armor' },
baseSpecies: 'Necrozma',
gender: 'N'
},
'Necrozma-Ultra': {
types: ['Psychic', 'Dragon'],
bs: { hp: 97, at: 167, df: 97, sa: 167, sd: 97, sp: 129 },
weightkg: 230,
abilities: { 0: 'Neuroforce' },
baseSpecies: 'Necrozma',
gender: 'N'
},
Nihilego: {
types: ['Rock', 'Poison'],
bs: { hp: 109, at: 53, df: 47, sa: 127, sd: 131, sp: 103 },
weightkg: 55.5,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
'Ninetales-Alola': {
types: ['Ice', 'Fairy'],
bs: { hp: 73, at: 67, df: 75, sa: 81, sd: 100, sp: 109 },
weightkg: 19.9,
abilities: { 0: 'Snow Cloak' },
baseSpecies: 'Ninetales'
},
Oranguru: {
types: ['Normal', 'Psychic'],
bs: { hp: 90, at: 60, df: 80, sa: 90, sd: 110, sp: 60 },
weightkg: 76,
abilities: { 0: 'Inner Focus' }
},
Oricorio: {
types: ['Fire', 'Flying'],
bs: { hp: 75, at: 70, df: 70, sa: 98, sd: 70, sp: 93 },
weightkg: 3.4,
abilities: { 0: 'Dancer' },
otherFormes: ['Oricorio-Pa\'u', 'Oricorio-Pom-Pom', 'Oricorio-Sensu']
},
'Oricorio-Pa\'u': {
types: ['Psychic', 'Flying'],
bs: { hp: 75, at: 70, df: 70, sa: 98, sd: 70, sp: 93 },
weightkg: 3.4,
abilities: { 0: 'Dancer' },
baseSpecies: 'Oricorio'
},
'Oricorio-Pom-Pom': {
types: ['Electric', 'Flying'],
bs: { hp: 75, at: 70, df: 70, sa: 98, sd: 70, sp: 93 },
weightkg: 3.4,
abilities: { 0: 'Dancer' },
baseSpecies: 'Oricorio'
},
'Oricorio-Sensu': {
types: ['Ghost', 'Flying'],
bs: { hp: 75, at: 70, df: 70, sa: 98, sd: 70, sp: 93 },
weightkg: 3.4,
abilities: { 0: 'Dancer' },
baseSpecies: 'Oricorio'
},
Pajantom: {
types: ['Dragon', 'Ghost'],
bs: { hp: 84, at: 133, df: 71, sa: 51, sd: 111, sp: 101 },
weightkg: 3.1,
abilities: { 0: 'Comatose' }
},
Palossand: {
types: ['Ghost', 'Ground'],
bs: { hp: 85, at: 75, df: 110, sa: 100, sd: 75, sp: 35 },
weightkg: 250,
abilities: { 0: 'Water Compaction' }
},
Passimian: {
types: ['Fighting'],
bs: { hp: 100, at: 120, df: 90, sa: 40, sd: 60, sp: 80 },
weightkg: 82.8,
abilities: { 0: 'Receiver' }
},
'Persian-Alola': {
types: ['Dark'],
bs: { hp: 65, at: 60, df: 60, sa: 75, sd: 65, sp: 115 },
weightkg: 33,
baseSpecies: 'Persian',
abilities: { 0: 'Fur Coat' }
},
Pheromosa: {
types: ['Bug', 'Fighting'],
bs: { hp: 71, at: 137, df: 37, sa: 137, sd: 37, sp: 151 },
weightkg: 25,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
'Pikachu-Alola': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
'Pikachu-Hoenn': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
'Pikachu-Kalos': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
'Pikachu-Original': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
'Pikachu-Partner': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
'Pikachu-Sinnoh': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
'Pikachu-Starter': {
types: ['Electric'],
bs: { hp: 45, at: 80, df: 50, sa: 75, sd: 60, sp: 120 },
weightkg: 6,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
'Pikachu-Unova': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 6,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
Pikipek: {
types: ['Normal', 'Flying'],
bs: { hp: 35, at: 75, df: 30, sa: 30, sd: 30, sp: 65 },
weightkg: 1.2,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Poipole: {
types: ['Poison'],
bs: { hp: 67, at: 73, df: 67, sa: 73, sd: 67, sp: 73 },
weightkg: 1.8,
abilities: { 0: 'Beast Boost' },
nfe: true,
gender: 'N'
},
Popplio: {
types: ['Water'],
bs: { hp: 50, at: 54, df: 54, sa: 66, sd: 56, sp: 40 },
weightkg: 7.5,
nfe: true,
abilities: { 0: 'Torrent' }
},
Primarina: {
types: ['Water', 'Fairy'],
bs: { hp: 80, at: 74, df: 74, sa: 126, sd: 116, sp: 60 },
weightkg: 44,
abilities: { 0: 'Torrent' }
},
Pyukumuku: {
types: ['Water'],
bs: { hp: 55, at: 60, df: 130, sa: 30, sd: 130, sp: 5 },
weightkg: 1.2,
abilities: { 0: 'Innards Out' }
},
'Raichu-Alola': {
types: ['Electric', 'Psychic'],
bs: { hp: 60, at: 85, df: 50, sa: 95, sd: 85, sp: 110 },
weightkg: 21,
baseSpecies: 'Raichu',
abilities: { 0: 'Surge Surfer' }
},
'Raticate-Alola': {
types: ['Dark', 'Normal'],
bs: { hp: 75, at: 71, df: 70, sa: 40, sd: 80, sp: 77 },
weightkg: 25.5,
baseSpecies: 'Raticate',
abilities: { 0: 'Gluttony' }
},
'Raticate-Alola-Totem': {
types: ['Dark', 'Normal'],
bs: { hp: 75, at: 71, df: 70, sa: 40, sd: 80, sp: 77 },
weightkg: 105,
abilities: { 0: 'Thick Fat' },
baseSpecies: 'Raticate'
},
'Rattata-Alola': {
types: ['Dark', 'Normal'],
bs: { hp: 30, at: 56, df: 35, sa: 25, sd: 35, sp: 72 },
weightkg: 3.8,
baseSpecies: 'Rattata',
nfe: true,
abilities: { 0: 'Gluttony' }
},
Ribombee: {
types: ['Bug', 'Fairy'],
bs: { hp: 60, at: 55, df: 60, sa: 95, sd: 70, sp: 124 },
weightkg: 0.5,
otherFormes: ['Ribombee-Totem'],
abilities: { 0: 'Honey Gather' }
},
'Ribombee-Totem': {
types: ['Bug', 'Fairy'],
bs: { hp: 60, at: 55, df: 60, sa: 95, sd: 70, sp: 124 },
weightkg: 2,
abilities: { 0: 'Sweet Veil' },
baseSpecies: 'Ribombee'
},
Rockruff: {
types: ['Rock'],
bs: { hp: 45, at: 65, df: 40, sa: 30, sd: 40, sp: 60 },
weightkg: 9.2,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Rowlet: {
types: ['Grass', 'Flying'],
bs: { hp: 68, at: 55, df: 55, sa: 50, sd: 50, sp: 42 },
weightkg: 1.5,
nfe: true,
abilities: { 0: 'Overgrow' }
},
Salandit: {
types: ['Poison', 'Fire'],
bs: { hp: 48, at: 44, df: 40, sa: 71, sd: 40, sp: 77 },
weightkg: 4.8,
nfe: true,
abilities: { 0: 'Corrosion' }
},
Salazzle: {
types: ['Poison', 'Fire'],
bs: { hp: 68, at: 64, df: 60, sa: 111, sd: 60, sp: 117 },
weightkg: 22.2,
otherFormes: ['Salazzle-Totem'],
abilities: { 0: 'Corrosion' }
},
'Salazzle-Totem': {
types: ['Poison', 'Fire'],
bs: { hp: 68, at: 64, df: 60, sa: 111, sd: 60, sp: 117 },
weightkg: 81,
abilities: { 0: 'Corrosion' },
baseSpecies: 'Salazzle'
},
'Sandshrew-Alola': {
types: ['Ice', 'Steel'],
bs: { hp: 50, at: 75, df: 90, sa: 10, sd: 35, sp: 40 },
weightkg: 40,
baseSpecies: 'Sandshrew',
nfe: true,
abilities: { 0: 'Snow Cloak' }
},
'Sandslash-Alola': {
types: ['Ice', 'Steel'],
bs: { hp: 75, at: 100, df: 120, sa: 25, sd: 65, sp: 65 },
weightkg: 55,
baseSpecies: 'Sandslash',
abilities: { 0: 'Snow Cloak' }
},
Sandygast: {
types: ['Ghost', 'Ground'],
bs: { hp: 55, at: 55, df: 80, sa: 70, sd: 45, sp: 15 },
weightkg: 70,
nfe: true,
abilities: { 0: 'Water Compaction' }
},
Shiinotic: {
types: ['Grass', 'Fairy'],
bs: { hp: 60, at: 45, df: 80, sa: 90, sd: 100, sp: 30 },
weightkg: 11.5,
abilities: { 0: 'Illuminate' }
},
Silvally: {
types: ['Normal'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
gender: 'N',
otherFormes: [
'Silvally-Bug',
'Silvally-Dark',
'Silvally-Dragon',
'Silvally-Electric',
'Silvally-Fairy',
'Silvally-Fighting',
'Silvally-Fire',
'Silvally-Flying',
'Silvally-Ghost',
'Silvally-Grass',
'Silvally-Ground',
'Silvally-Ice',
'Silvally-Poison',
'Silvally-Psychic',
'Silvally-Rock',
'Silvally-Steel',
'Silvally-Water',
]
},
'Silvally-Bug': {
types: ['Bug'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Dark': {
types: ['Dark'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Dragon': {
types: ['Dragon'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Electric': {
types: ['Electric'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Fairy': {
types: ['Fairy'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Fighting': {
types: ['Fighting'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Fire': {
types: ['Fire'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Flying': {
types: ['Flying'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Ghost': {
types: ['Ghost'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Grass': {
types: ['Grass'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Ground': {
types: ['Ground'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Ice': {
types: ['Ice'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Poison': {
types: ['Poison'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Psychic': {
types: ['Psychic'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Rock': {
types: ['Rock'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Steel': {
types: ['Steel'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
'Silvally-Water': {
types: ['Water'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 95 },
weightkg: 100.5,
abilities: { 0: 'RKS System' },
baseSpecies: 'Silvally',
gender: 'N'
},
Smogecko: {
types: ['Fire'],
bs: { hp: 48, at: 66, df: 43, sa: 58, sd: 48, sp: 56 },
weightkg: 8.5,
nfe: true,
abilities: { 0: 'Blaze' }
},
Smoguana: {
types: ['Fire', 'Ground'],
bs: { hp: 68, at: 86, df: 53, sa: 68, sd: 68, sp: 76 },
weightkg: 22.2,
nfe: true,
abilities: { 0: 'Blaze' }
},
Smokomodo: {
types: ['Fire', 'Ground'],
bs: { hp: 88, at: 116, df: 67, sa: 88, sd: 78, sp: 97 },
weightkg: 205,
abilities: { 0: 'Blaze' }
},
Snaelstrom: {
types: ['Water', 'Bug'],
bs: { hp: 91, at: 94, df: 110, sa: 80, sd: 97, sp: 63 },
weightkg: 120,
abilities: { 0: 'Torrent' }
},
Solgaleo: {
types: ['Psychic', 'Steel'],
bs: { hp: 137, at: 137, df: 107, sa: 113, sd: 89, sp: 97 },
weightkg: 230,
abilities: { 0: 'Full Metal Body' },
gender: 'N'
},
Stakataka: {
types: ['Rock', 'Steel'],
bs: { hp: 61, at: 131, df: 211, sa: 53, sd: 101, sp: 13 },
weightkg: 820,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
Steenee: {
types: ['Grass'],
bs: { hp: 52, at: 40, df: 48, sa: 40, sd: 48, sp: 62 },
weightkg: 8.2,
nfe: true,
abilities: { 0: 'Leaf Guard' }
},
Stufful: {
types: ['Normal', 'Fighting'],
bs: { hp: 70, at: 75, df: 50, sa: 45, sd: 50, sp: 50 },
weightkg: 6.8,
abilities: { 0: 'Fluffy' },
nfe: true
},
Swirlpool: {
types: ['Water'],
bs: { hp: 61, at: 49, df: 70, sa: 50, sd: 62, sp: 28 },
weightkg: 7,
nfe: true,
abilities: { 0: 'Torrent' }
},
'Tapu Bulu': {
types: ['Grass', 'Fairy'],
bs: { hp: 70, at: 130, df: 115, sa: 85, sd: 95, sp: 75 },
weightkg: 45.5,
abilities: { 0: 'Grassy Surge' },
gender: 'N'
},
'Tapu Fini': {
types: ['Water', 'Fairy'],
bs: { hp: 70, at: 75, df: 115, sa: 95, sd: 130, sp: 85 },
weightkg: 21.2,
abilities: { 0: 'Misty Surge' },
gender: 'N'
},
'Tapu Koko': {
types: ['Electric', 'Fairy'],
bs: { hp: 70, at: 115, df: 85, sa: 95, sd: 75, sp: 130 },
weightkg: 20.5,
abilities: { 0: 'Electric Surge' },
gender: 'N'
},
'Tapu Lele': {
types: ['Psychic', 'Fairy'],
bs: { hp: 70, at: 85, df: 75, sa: 130, sd: 115, sp: 95 },
weightkg: 18.6,
abilities: { 0: 'Psychic Surge' },
gender: 'N'
},
Togedemaru: {
types: ['Electric', 'Steel'],
bs: { hp: 65, at: 98, df: 63, sa: 40, sd: 73, sp: 96 },
weightkg: 3.3,
abilities: { 0: 'Iron Barbs' },
otherFormes: ['Togedemaru-Totem']
},
'Togedemaru-Totem': {
types: ['Electric', 'Steel'],
bs: { hp: 65, at: 98, df: 63, sa: 40, sd: 73, sp: 96 },
weightkg: 13,
abilities: { 0: 'Sturdy' },
baseSpecies: 'Togedemaru'
},
Torracat: {
types: ['Fire'],
bs: { hp: 65, at: 85, df: 50, sa: 80, sd: 50, sp: 90 },
weightkg: 25,
nfe: true,
abilities: { 0: 'Blaze' }
},
Toucannon: {
types: ['Normal', 'Flying'],
bs: { hp: 80, at: 120, df: 75, sa: 75, sd: 75, sp: 60 },
weightkg: 26,
abilities: { 0: 'Keen Eye' }
},
Toxapex: {
types: ['Poison', 'Water'],
bs: { hp: 50, at: 63, df: 152, sa: 53, sd: 142, sp: 35 },
weightkg: 14.5,
abilities: { 0: 'Merciless' }
},
Trumbeak: {
types: ['Normal', 'Flying'],
bs: { hp: 55, at: 85, df: 50, sa: 40, sd: 50, sp: 75 },
weightkg: 14.8,
nfe: true,
abilities: { 0: 'Keen Eye' }
},
Tsareena: {
types: ['Grass'],
bs: { hp: 72, at: 120, df: 98, sa: 50, sd: 98, sp: 72 },
weightkg: 21.4,
abilities: { 0: 'Leaf Guard' }
},
Turtonator: {
types: ['Fire', 'Dragon'],
bs: { hp: 60, at: 78, df: 135, sa: 91, sd: 85, sp: 36 },
weightkg: 212,
abilities: { 0: 'Shell Armor' }
},
'Type: Null': {
types: ['Normal'],
bs: { hp: 95, at: 95, df: 95, sa: 95, sd: 95, sp: 59 },
weightkg: 120.5,
abilities: { 0: 'Battle Armor' },
nfe: true,
gender: 'N'
},
Vikavolt: {
types: ['Bug', 'Electric'],
bs: { hp: 77, at: 70, df: 90, sa: 145, sd: 75, sp: 43 },
weightkg: 45,
abilities: { 0: 'Levitate' },
otherFormes: ['Vikavolt-Totem']
},
'Vikavolt-Totem': {
types: ['Bug', 'Electric'],
bs: { hp: 77, at: 70, df: 90, sa: 145, sd: 75, sp: 43 },
weightkg: 147.5,
abilities: { 0: 'Levitate' },
baseSpecies: 'Vikavolt'
},
'Vulpix-Alola': {
types: ['Ice'],
bs: { hp: 38, at: 41, df: 40, sa: 50, sd: 65, sp: 65 },
weightkg: 9.9,
baseSpecies: 'Vulpix',
nfe: true,
abilities: { 0: 'Snow Cloak' }
},
Wimpod: {
types: ['Bug', 'Water'],
bs: { hp: 25, at: 35, df: 40, sa: 20, sd: 30, sp: 80 },
weightkg: 12,
abilities: { 0: 'Wimp Out' },
nfe: true
},
Wishiwashi: {
types: ['Water'],
bs: { hp: 45, at: 20, df: 20, sa: 25, sd: 25, sp: 40 },
weightkg: 0.3,
otherFormes: ['Wishiwashi-School'],
abilities: { 0: 'Schooling' }
},
'Wishiwashi-School': {
types: ['Water'],
bs: { hp: 45, at: 140, df: 130, sa: 140, sd: 135, sp: 30 },
weightkg: 78.6,
baseSpecies: 'Wishiwashi',
abilities: { 0: 'Schooling' }
},
Xurkitree: {
types: ['Electric'],
bs: { hp: 83, at: 89, df: 71, sa: 173, sd: 71, sp: 83 },
weightkg: 100,
abilities: { 0: 'Beast Boost' },
gender: 'N'
},
Yungoos: {
types: ['Normal'],
bs: { hp: 48, at: 70, df: 30, sa: 30, sd: 30, sp: 45 },
weightkg: 6,
nfe: true,
abilities: { 0: 'Stakeout' }
},
Zeraora: {
types: ['Electric'],
bs: { hp: 88, at: 112, df: 75, sa: 102, sd: 80, sp: 143 },
weightkg: 44.5,
abilities: { 0: 'Volt Absorb' },
gender: 'N'
},
'Zygarde-10%': {
types: ['Dragon', 'Ground'],
bs: { hp: 54, at: 100, df: 71, sa: 61, sd: 85, sp: 115 },
weightkg: 33.5,
abilities: { 0: 'Aura Break' },
baseSpecies: 'Zygarde',
gender: 'N'
},
'Zygarde-Complete': {
types: ['Dragon', 'Ground'],
bs: { hp: 216, at: 100, df: 121, sa: 91, sd: 95, sp: 85 },
weightkg: 610,
abilities: { 0: 'Power Construct' },
baseSpecies: 'Zygarde',
gender: 'N'
}
};
var SM = util_1.extend(true, {}, XY, SM_PATCH);
delete SM['Pikachu-Cosplay'];
delete SM['Pikachu-Rock-Star'];
delete SM['Pikachu-Belle'];
delete SM['Pikachu-PhD'];
delete SM['Pikachu-Pop-Star'];
delete SM['Pikachu-Libre'];
var SS_PATCH = {
'Aegislash-Blade': { bs: { at: 140, sa: 140 } },
'Aegislash-Both': { bs: { at: 140, df: 140, sa: 140, sd: 140 } },
'Aegislash-Shield': { bs: { df: 140, sd: 140 } },
Blastoise: { otherFormes: ['Blastoise-Gmax', 'Blastoise-Mega'] },
Butterfree: { otherFormes: ['Butterfree-Gmax'] },
Charizard: { otherFormes: ['Charizard-Gmax', 'Charizard-Mega-X', 'Charizard-Mega-Y'] },
Corsola: { otherFormes: ['Corsola-Galar'] },
Darmanitan: {
otherFormes: ['Darmanitan-Galar', 'Darmanitan-Galar-Zen', 'Darmanitan-Zen']
},
Darumaka: { otherFormes: ['Darumaka-Galar'] },
Eevee: { otherFormes: ['Eevee-Gmax'] },
Equilibra: { bs: { sa: 121 } },
'Farfetch\u2019d': { otherFormes: ['Farfetch\u2019d-Galar'] },
Garbodor: { otherFormes: ['Garbodor-Gmax'] },
Gengar: { otherFormes: ['Gengar-Gmax', 'Gengar-Mega'] },
Kingler: { otherFormes: ['Kingler-Gmax'] },
Lapras: { otherFormes: ['Lapras-Gmax'] },
Linoone: { otherFormes: ['Linoone-Galar'] },
Machamp: { otherFormes: ['Machamp-Gmax'] },
Meowth: { otherFormes: ['Meowth-Alola', 'Meowth-Galar', 'Meowth-Gmax'] },
'Mr. Mime': { otherFormes: ['Mr. Mime-Galar'] },
Pikachu: {
otherFormes: [
'Pikachu-Alola',
'Pikachu-Gmax',
'Pikachu-Hoenn',
'Pikachu-Kalos',
'Pikachu-Original',
'Pikachu-Partner',
'Pikachu-Sinnoh',
'Pikachu-Unova',
]
},
Ponyta: { otherFormes: ['Ponyta-Galar'] },
Rapidash: { otherFormes: ['Rapidash-Galar'] },
Slowbro: { otherFormes: ['Slowbro-Galar', 'Slowbro-Mega'] },
Slowpoke: { otherFormes: ['Slowpoke-Galar'] },
Snorlax: { otherFormes: ['Snorlax-Gmax'] },
Stunfisk: { otherFormes: ['Stunfisk-Galar'] },
Venusaur: { otherFormes: ['Venusaur-Gmax', 'Venusaur-Mega'] },
Weezing: { otherFormes: ['Weezing-Galar'] },
Yamask: { otherFormes: ['Yamask-Galar'] },
Zigzagoon: { otherFormes: ['Zigzagoon-Galar'] },
Alcremie: {
types: ['Fairy'],
bs: { hp: 65, at: 60, df: 75, sa: 110, sd: 121, sp: 64 },
weightkg: 0.5,
abilities: { 0: 'Sweet Veil' },
otherFormes: ['Alcremie-Gmax']
},
'Alcremie-Gmax': {
types: ['Fairy'],
bs: { hp: 65, at: 60, df: 75, sa: 110, sd: 121, sp: 64 },
weightkg: 0,
abilities: { 0: 'Sweet Veil' },
baseSpecies: 'Alcremie'
},
Appletun: {
types: ['Grass', 'Dragon'],
bs: { hp: 110, at: 85, df: 80, sa: 100, sd: 80, sp: 30 },
weightkg: 13,
abilities: { 0: 'Ripen' },
otherFormes: ['Appletun-Gmax']
},
'Appletun-Gmax': {
types: ['Grass', 'Dragon'],
bs: { hp: 110, at: 85, df: 80, sa: 100, sd: 80, sp: 30 },
weightkg: 0,
abilities: { 0: 'Ripen' },
baseSpecies: 'Appletun'
},
Applin: {
types: ['Grass', 'Dragon'],
bs: { hp: 40, at: 40, df: 80, sa: 40, sd: 40, sp: 20 },
weightkg: 0.5,
abilities: { 0: 'Ripen' },
nfe: true
},
Arctovish: {
types: ['Water', 'Ice'],
bs: { hp: 90, at: 90, df: 100, sa: 80, sd: 90, sp: 55 },
weightkg: 175,
abilities: { 0: 'Water Absorb' },
gender: 'N'
},
Arctozolt: {
types: ['Electric', 'Ice'],
bs: { hp: 90, at: 100, df: 90, sa: 90, sd: 80, sp: 55 },
weightkg: 150,
abilities: { 0: 'Volt Absorb' },
gender: 'N'
},
Arrokuda: {
types: ['Water'],
bs: { hp: 41, at: 63, df: 40, sa: 40, sd: 30, sp: 66 },
weightkg: 1,
abilities: { 0: 'Swift Swim' },
nfe: true
},
Astrolotl: {
types: ['Fire', 'Dragon'],
bs: { hp: 108, at: 108, df: 74, sa: 92, sd: 64, sp: 114 },
weightkg: 50,
abilities: { 0: 'Regenerator' }
},
Barraskewda: {
types: ['Water'],
bs: { hp: 61, at: 123, df: 60, sa: 60, sd: 50, sp: 136 },
weightkg: 30,
abilities: { 0: 'Swift Swim' }
},
'Blastoise-Gmax': {
types: ['Water'],
bs: { hp: 79, at: 83, df: 100, sa: 85, sd: 105, sp: 78 },
weightkg: 0,
abilities: { 0: 'Torrent' },
baseSpecies: 'Blastoise'
},
Blipbug: {
types: ['Bug'],
bs: { hp: 25, at: 20, df: 20, sa: 25, sd: 45, sp: 45 },
weightkg: 8,
abilities: { 0: 'Swarm' },
nfe: true
},
Boltund: {
types: ['Electric'],
bs: { hp: 69, at: 90, df: 60, sa: 90, sd: 60, sp: 121 },
weightkg: 34,
abilities: { 0: 'Strong Jaw' }
},
'Butterfree-Gmax': {
types: ['Bug', 'Flying'],
bs: { hp: 60, at: 45, df: 50, sa: 90, sd: 80, sp: 70 },
weightkg: 0,
abilities: { 0: 'Compound Eyes' },
baseSpecies: 'Butterfree'
},
Carkol: {
types: ['Rock', 'Fire'],
bs: { hp: 80, at: 60, df: 90, sa: 60, sd: 70, sp: 50 },
weightkg: 78,
abilities: { 0: 'Steam Engine' },
nfe: true
},
Centiskorch: {
types: ['Fire', 'Bug'],
bs: { hp: 100, at: 115, df: 65, sa: 90, sd: 90, sp: 65 },
weightkg: 120,
abilities: { 0: 'Flash Fire' },
otherFormes: ['Centiskorch-Gmax']
},
'Centiskorch-Gmax': {
types: ['Fire', 'Bug'],
bs: { hp: 100, at: 115, df: 65, sa: 90, sd: 90, sp: 65 },
weightkg: 0,
abilities: { 0: 'Flash Fire' },
baseSpecies: 'Centiskorch'
},
'Charizard-Gmax': {
types: ['Fire', 'Flying'],
bs: { hp: 78, at: 84, df: 78, sa: 109, sd: 85, sp: 100 },
weightkg: 0,
abilities: { 0: 'Blaze' },
baseSpecies: 'Charizard'
},
Chewtle: {
types: ['Water'],
bs: { hp: 50, at: 64, df: 50, sa: 38, sd: 38, sp: 44 },
weightkg: 8.5,
abilities: { 0: 'Strong Jaw' },
nfe: true
},
Cinderace: {
types: ['Fire'],
bs: { hp: 80, at: 116, df: 75, sa: 65, sd: 75, sp: 119 },
weightkg: 33,
abilities: { 0: 'Blaze' },
otherFormes: ['Cinderace-Gmax']
},
'Cinderace-Gmax': {
types: ['Fire'],
bs: { hp: 80, at: 116, df: 75, sa: 65, sd: 75, sp: 119 },
weightkg: 0,
abilities: { 0: 'Blaze' },
baseSpecies: 'Cinderace'
},
Clobbopus: {
types: ['Fighting'],
bs: { hp: 50, at: 68, df: 60, sa: 50, sd: 50, sp: 32 },
weightkg: 4,
abilities: { 0: 'Limber' },
nfe: true
},
Coalossal: {
types: ['Rock', 'Fire'],
bs: { hp: 110, at: 80, df: 120, sa: 80, sd: 90, sp: 30 },
weightkg: 310.5,
abilities: { 0: 'Steam Engine' },
otherFormes: ['Coalossal-Gmax']
},
'Coalossal-Gmax': {
types: ['Rock', 'Fire'],
bs: { hp: 110, at: 80, df: 120, sa: 80, sd: 90, sp: 30 },
weightkg: 0,
abilities: { 0: 'Steam Engine' },
baseSpecies: 'Coalossal'
},
Copperajah: {
types: ['Steel'],
bs: { hp: 122, at: 130, df: 69, sa: 80, sd: 69, sp: 30 },
weightkg: 650,
abilities: { 0: 'Sheer Force' },
otherFormes: ['Copperajah-Gmax']
},
'Copperajah-Gmax': {
types: ['Steel'],
bs: { hp: 122, at: 130, df: 69, sa: 80, sd: 69, sp: 30 },
weightkg: 0,
abilities: { 0: 'Sheer Force' },
baseSpecies: 'Copperajah'
},
'Corsola-Galar': {
types: ['Ghost'],
bs: { hp: 60, at: 55, df: 100, sa: 65, sd: 100, sp: 30 },
weightkg: 0.5,
abilities: { 0: 'Weak Armor' },
nfe: true,
baseSpecies: 'Corsola'
},
Corviknight: {
types: ['Flying', 'Steel'],
bs: { hp: 98, at: 87, df: 105, sa: 53, sd: 85, sp: 67 },
weightkg: 75,
abilities: { 0: 'Pressure' },
otherFormes: ['Corviknight-Gmax']
},
'Corviknight-Gmax': {
types: ['Flying', 'Steel'],
bs: { hp: 98, at: 87, df: 105, sa: 53, sd: 85, sp: 67 },
weightkg: 0,
abilities: { 0: 'Pressure' },
baseSpecies: 'Corviknight'
},
Corvisquire: {
types: ['Flying'],
bs: { hp: 68, at: 67, df: 55, sa: 43, sd: 55, sp: 77 },
weightkg: 16,
abilities: { 0: 'Keen Eye' },
nfe: true
},
Cramorant: {
types: ['Flying', 'Water'],
bs: { hp: 70, at: 85, df: 55, sa: 85, sd: 95, sp: 85 },
weightkg: 18,
abilities: { 0: 'Gulp Missile' },
otherFormes: ['Cramorant-Gorging', 'Cramorant-Gulping']
},
'Cramorant-Gorging': {
types: ['Flying', 'Water'],
bs: { hp: 70, at: 85, df: 55, sa: 85, sd: 95, sp: 85 },
weightkg: 18,
abilities: { 0: 'Gulp Missile' },
baseSpecies: 'Cramorant'
},
'Cramorant-Gulping': {
types: ['Flying', 'Water'],
bs: { hp: 70, at: 85, df: 55, sa: 85, sd: 95, sp: 85 },
weightkg: 18,
abilities: { 0: 'Gulp Missile' },
baseSpecies: 'Cramorant'
},
Cufant: {
types: ['Steel'],
bs: { hp: 72, at: 80, df: 49, sa: 40, sd: 49, sp: 40 },
weightkg: 100,
abilities: { 0: 'Sheer Force' },
nfe: true
},
Cursola: {
types: ['Ghost'],
bs: { hp: 60, at: 95, df: 50, sa: 145, sd: 130, sp: 30 },
weightkg: 0.4,
abilities: { 0: 'Weak Armor' }
},
'Darmanitan-Galar': {
types: ['Ice'],
bs: { hp: 105, at: 140, df: 55, sa: 30, sd: 55, sp: 95 },
weightkg: 120,
abilities: { 0: 'Gorilla Tactics' },
baseSpecies: 'Darmanitan'
},
'Darmanitan-Galar-Zen': {
types: ['Ice', 'Fire'],
bs: { hp: 105, at: 160, df: 55, sa: 30, sd: 55, sp: 135 },
weightkg: 120,
abilities: { 0: 'Zen Mode' },
baseSpecies: 'Darmanitan'
},
'Darumaka-Galar': {
types: ['Ice'],
bs: { hp: 70, at: 90, df: 45, sa: 15, sd: 45, sp: 50 },
weightkg: 40,
abilities: { 0: 'Hustle' },
nfe: true,
baseSpecies: 'Darumaka'
},
Dottler: {
types: ['Bug', 'Psychic'],
bs: { hp: 50, at: 35, df: 80, sa: 50, sd: 90, sp: 30 },
weightkg: 19.5,
abilities: { 0: 'Swarm' },
nfe: true
},
Dracovish: {
types: ['Water', 'Dragon'],
bs: { hp: 90, at: 90, df: 100, sa: 70, sd: 80, sp: 75 },
weightkg: 215,
abilities: { 0: 'Water Absorb' },
gender: 'N'
},
Dracozolt: {
types: ['Electric', 'Dragon'],
bs: { hp: 90, at: 100, df: 90, sa: 80, sd: 70, sp: 75 },
weightkg: 190,
abilities: { 0: 'Volt Absorb' },
gender: 'N'
},
Dragapult: {
types: ['Dragon', 'Ghost'],
bs: { hp: 88, at: 120, df: 75, sa: 100, sd: 75, sp: 142 },
weightkg: 50,
abilities: { 0: 'Clear Body' }
},
Drakloak: {
types: ['Dragon', 'Ghost'],
bs: { hp: 68, at: 80, df: 50, sa: 60, sd: 50, sp: 102 },
weightkg: 11,
abilities: { 0: 'Clear Body' },
nfe: true
},
Drednaw: {
types: ['Water', 'Rock'],
bs: { hp: 90, at: 115, df: 90, sa: 48, sd: 68, sp: 74 },
weightkg: 115.5,
abilities: { 0: 'Strong Jaw' },
otherFormes: ['Drednaw-Gmax']
},
'Drednaw-Gmax': {
types: ['Water', 'Rock'],
bs: { hp: 90, at: 115, df: 90, sa: 48, sd: 68, sp: 74 },
weightkg: 0,
abilities: { 0: 'Strong Jaw' },
baseSpecies: 'Drednaw'
},
Dreepy: {
types: ['Dragon', 'Ghost'],
bs: { hp: 28, at: 60, df: 30, sa: 40, sd: 30, sp: 82 },
weightkg: 2,
abilities: { 0: 'Clear Body' },
nfe: true
},
Drizzile: {
types: ['Water'],
bs: { hp: 65, at: 60, df: 55, sa: 95, sd: 55, sp: 90 },
weightkg: 11.5,
abilities: { 0: 'Torrent' },
nfe: true
},
Dubwool: {
types: ['Normal'],
bs: { hp: 72, at: 80, df: 100, sa: 60, sd: 90, sp: 88 },
weightkg: 43,
abilities: { 0: 'Fluffy' }
},
Duraludon: {
types: ['Steel', 'Dragon'],
bs: { hp: 70, at: 95, df: 115, sa: 120, sd: 50, sp: 85 },
weightkg: 40,
abilities: { 0: 'Light Metal' },
otherFormes: ['Duraludon-Gmax']
},
'Duraludon-Gmax': {
types: ['Steel', 'Dragon'],
bs: { hp: 70, at: 95, df: 115, sa: 120, sd: 50, sp: 85 },
weightkg: 0,
abilities: { 0: 'Light Metal' },
baseSpecies: 'Duraludon'
},
'Eevee-Gmax': {
types: ['Normal'],
bs: { hp: 55, at: 55, df: 50, sa: 45, sd: 65, sp: 55 },
weightkg: 0,
abilities: { 0: 'Run Away' },
baseSpecies: 'Eevee'
},
Eiscue: {
types: ['Ice'],
bs: { hp: 75, at: 80, df: 110, sa: 65, sd: 90, sp: 50 },
weightkg: 89,
abilities: { 0: 'Ice Face' },
otherFormes: ['Eiscue-Noice']
},
'Eiscue-Noice': {
types: ['Ice'],
bs: { hp: 75, at: 80, df: 70, sa: 65, sd: 50, sp: 130 },
weightkg: 89,
abilities: { 0: 'Ice Face' },
baseSpecies: 'Eiscue'
},
Eldegoss: {
types: ['Grass'],
bs: { hp: 60, at: 50, df: 90, sa: 80, sd: 120, sp: 60 },
weightkg: 2.5,
abilities: { 0: 'Cotton Down' }
},
Eternatus: {
types: ['Poison', 'Dragon'],
bs: { hp: 140, at: 85, df: 95, sa: 145, sd: 95, sp: 130 },
weightkg: 950,
abilities: { 0: 'Pressure' },
gender: 'N',
otherFormes: ['Eternatus-Eternamax']
},
'Eternatus-Eternamax': {
types: ['Poison', 'Dragon'],
bs: { hp: 255, at: 115, df: 250, sa: 125, sd: 250, sp: 130 },
weightkg: 0,
abilities: { 0: 'Pressure' },
gender: 'N',
baseSpecies: 'Eternatus'
},
Falinks: {
types: ['Fighting'],
bs: { hp: 65, at: 100, df: 100, sa: 70, sd: 60, sp: 75 },
weightkg: 62,
abilities: { 0: 'Battle Armor' },
gender: 'N'
},
'Farfetch\u2019d-Galar': {
types: ['Fighting'],
bs: { hp: 52, at: 95, df: 55, sa: 58, sd: 62, sp: 55 },
weightkg: 15,
abilities: { 0: 'Steadfast' },
nfe: true,
baseSpecies: 'Farfetch\u2019d'
},
Flapple: {
types: ['Grass', 'Dragon'],
bs: { hp: 70, at: 110, df: 80, sa: 95, sd: 60, sp: 70 },
weightkg: 1,
abilities: { 0: 'Ripen' },
otherFormes: ['Flapple-Gmax']
},
'Flapple-Gmax': {
types: ['Grass', 'Dragon'],
bs: { hp: 70, at: 110, df: 80, sa: 95, sd: 60, sp: 70 },
weightkg: 0,
abilities: { 0: 'Ripen' },
baseSpecies: 'Flapple'
},
Frosmoth: {
types: ['Ice', 'Bug'],
bs: { hp: 70, at: 65, df: 60, sa: 125, sd: 90, sp: 65 },
weightkg: 42,
abilities: { 0: 'Shield Dust' }
},
'Garbodor-Gmax': {
types: ['Poison'],
bs: { hp: 80, at: 95, df: 82, sa: 60, sd: 82, sp: 75 },
weightkg: 0,
abilities: { 0: 'Stench' },
baseSpecies: 'Garbodor'
},
'Gengar-Gmax': {
types: ['Ghost', 'Poison'],
bs: { hp: 60, at: 65, df: 60, sa: 130, sd: 75, sp: 110 },
weightkg: 0,
abilities: { 0: 'Cursed Body' },
baseSpecies: 'Gengar'
},
Gossifleur: {
types: ['Grass'],
bs: { hp: 40, at: 40, df: 60, sa: 40, sd: 60, sp: 10 },
weightkg: 2.2,
abilities: { 0: 'Cotton Down' },
nfe: true
},
Grapploct: {
types: ['Fighting'],
bs: { hp: 80, at: 118, df: 90, sa: 70, sd: 80, sp: 42 },
weightkg: 39,
abilities: { 0: 'Limber' }
},
Greedent: {
types: ['Normal'],
bs: { hp: 120, at: 95, df: 95, sa: 55, sd: 75, sp: 20 },
weightkg: 6,
abilities: { 0: 'Cheek Pouch' }
},
Grimmsnarl: {
types: ['Dark', 'Fairy'],
bs: { hp: 95, at: 120, df: 65, sa: 95, sd: 75, sp: 60 },
weightkg: 61,
abilities: { 0: 'Prankster' },
otherFormes: ['Grimmsnarl-Gmax']
},
'Grimmsnarl-Gmax': {
types: ['Dark', 'Fairy'],
bs: { hp: 95, at: 120, df: 65, sa: 95, sd: 75, sp: 60 },
weightkg: 0,
abilities: { 0: 'Prankster' },
baseSpecies: 'Grimmsnarl'
},
Grookey: {
types: ['Grass'],
bs: { hp: 50, at: 65, df: 50, sa: 40, sd: 40, sp: 65 },
weightkg: 5,
abilities: { 0: 'Overgrow' },
nfe: true
},
Hatenna: {
types: ['Psychic'],
bs: { hp: 42, at: 30, df: 45, sa: 56, sd: 53, sp: 39 },
weightkg: 3.4,
abilities: { 0: 'Healer' },
nfe: true
},
Hatterene: {
types: ['Psychic', 'Fairy'],
bs: { hp: 57, at: 90, df: 95, sa: 136, sd: 103, sp: 29 },
weightkg: 5.1,
abilities: { 0: 'Healer' },
otherFormes: ['Hatterene-Gmax']
},
'Hatterene-Gmax': {
types: ['Psychic', 'Fairy'],
bs: { hp: 57, at: 90, df: 95, sa: 136, sd: 103, sp: 29 },
weightkg: 0,
abilities: { 0: 'Healer' },
baseSpecies: 'Hatterene'
},
Hattrem: {
types: ['Psychic'],
bs: { hp: 57, at: 40, df: 65, sa: 86, sd: 73, sp: 49 },
weightkg: 4.8,
abilities: { 0: 'Healer' },
nfe: true
},
Impidimp: {
types: ['Dark', 'Fairy'],
bs: { hp: 45, at: 45, df: 30, sa: 55, sd: 40, sp: 50 },
weightkg: 5.5,
abilities: { 0: 'Prankster' },
nfe: true
},
Indeedee: {
types: ['Psychic', 'Normal'],
bs: { hp: 60, at: 65, df: 55, sa: 105, sd: 95, sp: 95 },
weightkg: 28,
abilities: { 0: 'Inner Focus' },
otherFormes: ['Indeedee-F']
},
'Indeedee-F': {
types: ['Psychic', 'Normal'],
bs: { hp: 70, at: 55, df: 65, sa: 95, sd: 105, sp: 85 },
weightkg: 28,
abilities: { 0: 'Own Tempo' },
baseSpecies: 'Indeedee'
},
Inteleon: {
types: ['Water'],
bs: { hp: 70, at: 85, df: 65, sa: 125, sd: 65, sp: 120 },
weightkg: 45.2,
abilities: { 0: 'Torrent' },
otherFormes: ['Inteleon-Gmax']
},
'Inteleon-Gmax': {
types: ['Water'],
bs: { hp: 70, at: 85, df: 65, sa: 125, sd: 65, sp: 120 },
weightkg: 0,
abilities: { 0: 'Torrent' },
baseSpecies: 'Inteleon'
},
'Kingler-Gmax': {
types: ['Water'],
bs: { hp: 55, at: 130, df: 115, sa: 50, sd: 50, sp: 75 },
weightkg: 0,
abilities: { 0: 'Hyper Cutter' },
baseSpecies: 'Kingler'
},
'Kubfu': {
types: ['Fighting'],
bs: { hp: 60, at: 90, df: 60, sa: 53, sd: 50, sp: 72 },
weightkg: 12,
nfe: true,
abilities: { 0: 'Inner Focus' }
},
'Lapras-Gmax': {
types: ['Water', 'Ice'],
bs: { hp: 130, at: 85, df: 80, sa: 85, sd: 95, sp: 60 },
weightkg: 0,
abilities: { 0: 'Water Absorb' },
baseSpecies: 'Lapras'
},
'Linoone-Galar': {
types: ['Dark', 'Normal'],
bs: { hp: 78, at: 70, df: 61, sa: 50, sd: 61, sp: 100 },
weightkg: 32.5,
abilities: { 0: 'Pickup' },
nfe: true,
baseSpecies: 'Linoone'
},
Magearna: { otherFormes: ['Magearna-Original'] },
'Magearna-Original': {
baseSpecies: 'Magearna',
types: ['Steel', 'Fairy'],
bs: { hp: 80, at: 95, df: 115, sa: 130, sd: 115, sp: 65 },
weightkg: 80.5,
gender: 'N',
abilities: { 0: 'Soul-Heart' }
},
'Machamp-Gmax': {
types: ['Fighting'],
bs: { hp: 90, at: 130, df: 80, sa: 65, sd: 85, sp: 55 },
weightkg: 0,
abilities: { 0: 'Guts' },
baseSpecies: 'Machamp'
},
'Meowth-Galar': {
types: ['Steel'],
bs: { hp: 50, at: 65, df: 55, sa: 40, sd: 40, sp: 40 },
weightkg: 7.5,
abilities: { 0: 'Pickup' },
nfe: true,
baseSpecies: 'Meowth'
},
'Meowth-Gmax': {
types: ['Normal'],
bs: { hp: 40, at: 45, df: 35, sa: 40, sd: 40, sp: 90 },
weightkg: 0,
abilities: { 0: 'Pickup' },
baseSpecies: 'Meowth'
},
Milcery: {
types: ['Fairy'],
bs: { hp: 45, at: 40, df: 40, sa: 50, sd: 61, sp: 34 },
weightkg: 0.3,
abilities: { 0: 'Sweet Veil' },
nfe: true
},
Morgrem: {
types: ['Dark', 'Fairy'],
bs: { hp: 65, at: 60, df: 45, sa: 75, sd: 55, sp: 70 },
weightkg: 12.5,
abilities: { 0: 'Prankster' },
nfe: true
},
Morpeko: {
types: ['Electric', 'Dark'],
bs: { hp: 58, at: 95, df: 58, sa: 70, sd: 58, sp: 97 },
weightkg: 3,
abilities: { 0: 'Hunger Switch' },
otherFormes: ['Morpeko-Hangry']
},
'Morpeko-Hangry': {
types: ['Electric', 'Dark'],
bs: { hp: 58, at: 95, df: 58, sa: 70, sd: 58, sp: 97 },
weightkg: 3,
abilities: { 0: 'Hunger Switch' },
baseSpecies: 'Morpeko'
},
'Mr. Mime-Galar': {
types: ['Ice', 'Psychic'],
bs: { hp: 50, at: 65, df: 65, sa: 90, sd: 90, sp: 100 },
weightkg: 56.8,
abilities: { 0: 'Vital Spirit' },
nfe: true,
baseSpecies: 'Mr. Mime'
},
'Mr. Rime': {
types: ['Ice', 'Psychic'],
bs: { hp: 80, at: 85, df: 75, sa: 110, sd: 100, sp: 70 },
weightkg: 58.2,
abilities: { 0: 'Tangled Feet' }
},
Nickit: {
types: ['Dark'],
bs: { hp: 40, at: 28, df: 28, sa: 47, sd: 52, sp: 50 },
weightkg: 8.9,
abilities: { 0: 'Run Away' },
nfe: true
},
Obstagoon: {
types: ['Dark', 'Normal'],
bs: { hp: 93, at: 90, df: 101, sa: 60, sd: 81, sp: 95 },
weightkg: 46,
abilities: { 0: 'Reckless' }
},
Orbeetle: {
types: ['Bug', 'Psychic'],
bs: { hp: 60, at: 45, df: 110, sa: 80, sd: 120, sp: 90 },
weightkg: 40.8,
abilities: { 0: 'Swarm' },
otherFormes: ['Orbeetle-Gmax']
},
'Orbeetle-Gmax': {
types: ['Bug', 'Psychic'],
bs: { hp: 60, at: 45, df: 110, sa: 80, sd: 120, sp: 90 },
weightkg: 0,
abilities: { 0: 'Swarm' },
baseSpecies: 'Orbeetle'
},
Perrserker: {
types: ['Steel'],
bs: { hp: 70, at: 110, df: 100, sa: 50, sd: 60, sp: 50 },
weightkg: 28,
abilities: { 0: 'Battle Armor' }
},
'Pikachu-Gmax': {
types: ['Electric'],
bs: { hp: 35, at: 55, df: 40, sa: 50, sd: 50, sp: 90 },
weightkg: 0,
abilities: { 0: 'Static' },
baseSpecies: 'Pikachu'
},
Pincurchin: {
types: ['Electric'],
bs: { hp: 48, at: 101, df: 95, sa: 91, sd: 85, sp: 15 },
weightkg: 1,
abilities: { 0: 'Lightning Rod' }
},
Polteageist: {
types: ['Ghost'],
bs: { hp: 60, at: 65, df: 65, sa: 134, sd: 114, sp: 70 },
weightkg: 0.4,
abilities: { 0: 'Weak Armor' },
otherFormes: ['Polteageist-Antique'],
gender: 'N'
},
'Polteageist-Antique': {
types: ['Ghost'],
bs: { hp: 60, at: 65, df: 65, sa: 134, sd: 114, sp: 70 },
weightkg: 0.4,
abilities: { 0: 'Weak Armor' },
baseSpecies: 'Polteageist',
gender: 'N'
},
'Ponyta-Galar': {
types: ['Psychic'],
bs: { hp: 50, at: 85, df: 55, sa: 65, sd: 65, sp: 90 },
weightkg: 24,
abilities: { 0: 'Run Away' },
nfe: true,
baseSpecies: 'Ponyta'
},
Raboot: {
types: ['Fire'],
bs: { hp: 65, at: 86, df: 60, sa: 55, sd: 60, sp: 94 },
weightkg: 9,
abilities: { 0: 'Blaze' },
nfe: true
},
'Rapidash-Galar': {
types: ['Psychic', 'Fairy'],
bs: { hp: 65, at: 100, df: 70, sa: 80, sd: 80, sp: 105 },
weightkg: 80,
abilities: { 0: 'Run Away' },
baseSpecies: 'Rapidash'
},
Rillaboom: {
types: ['Grass'],
bs: { hp: 100, at: 125, df: 90, sa: 60, sd: 70, sp: 85 },
weightkg: 90,
abilities: { 0: 'Overgrow' },
otherFormes: ['Rillaboom-Gmax']
},
'Rillaboom-Gmax': {
types: ['Grass'],
bs: { hp: 100, at: 125, df: 90, sa: 60, sd: 70, sp: 85 },
weightkg: 0,
abilities: { 0: 'Overgrow' },
baseSpecies: 'Rillaboom'
},
Rolycoly: {
types: ['Rock'],
bs: { hp: 30, at: 40, df: 50, sa: 40, sd: 50, sp: 30 },
weightkg: 12,
abilities: { 0: 'Steam Engine' },
nfe: true
},
Rookidee: {
types: ['Flying'],
bs: { hp: 38, at: 47, df: 35, sa: 33, sd: 35, sp: 57 },
weightkg: 1.8,
abilities: { 0: 'Keen Eye' },
nfe: true
},
Runerigus: {
types: ['Ground', 'Ghost'],
bs: { hp: 58, at: 95, df: 145, sa: 50, sd: 105, sp: 30 },
weightkg: 66.6,
abilities: { 0: 'Wandering Spirit' }
},
Sandaconda: {
types: ['Ground'],
bs: { hp: 72, at: 107, df: 125, sa: 65, sd: 70, sp: 71 },
weightkg: 65.5,
abilities: { 0: 'Sand Spit' },
otherFormes: ['Sandaconda-Gmax']
},
'Sandaconda-Gmax': {
types: ['Ground'],
bs: { hp: 72, at: 107, df: 125, sa: 65, sd: 70, sp: 71 },
weightkg: 0,
abilities: { 0: 'Sand Spit' },
baseSpecies: 'Sandaconda'
},
Scorbunny: {
types: ['Fire'],
bs: { hp: 50, at: 71, df: 40, sa: 40, sd: 40, sp: 69 },
weightkg: 4.5,
abilities: { 0: 'Blaze' },
nfe: true
},
Silicobra: {
types: ['Ground'],
bs: { hp: 52, at: 57, df: 75, sa: 35, sd: 50, sp: 46 },
weightkg: 7.6,
abilities: { 0: 'Sand Spit' },
nfe: true
},
Sinistea: {
types: ['Ghost'],
bs: { hp: 40, at: 45, df: 45, sa: 74, sd: 54, sp: 50 },
weightkg: 0.2,
abilities: { 0: 'Weak Armor' },
nfe: true,
otherFormes: ['Sinistea-Antique'],
gender: 'N'
},
'Sinistea-Antique': {
types: ['Ghost'],
bs: { hp: 40, at: 45, df: 45, sa: 74, sd: 54, sp: 50 },
weightkg: 0.2,
abilities: { 0: 'Weak Armor' },
nfe: true,
baseSpecies: 'Sinistea',
gender: 'N'
},
'Sirfetch\u2019d': {
types: ['Fighting'],
bs: { hp: 62, at: 135, df: 95, sa: 68, sd: 82, sp: 65 },
weightkg: 117,
abilities: { 0: 'Steadfast' }
},
Sizzlipede: {
types: ['Fire', 'Bug'],
bs: { hp: 50, at: 65, df: 45, sa: 50, sd: 50, sp: 45 },
weightkg: 1,
abilities: { 0: 'Flash Fire' },
nfe: true
},
Skwovet: {
types: ['Normal'],
bs: { hp: 70, at: 55, df: 55, sa: 35, sd: 35, sp: 25 },
weightkg: 2.5,
abilities: { 0: 'Cheek Pouch' },
nfe: true
},
'Slowbro-Galar': {
types: ['Poison', 'Psychic'],
bs: { hp: 95, at: 100, df: 95, sa: 100, sd: 70, sp: 30 },
weightkg: 70.5,
abilities: { 0: 'Quick Draw' },
baseSpecies: 'Slowbro'
},
'Slowpoke-Galar': {
types: ['Psychic'],
bs: { hp: 90, at: 65, df: 65, sa: 40, sd: 40, sp: 15 },
weightkg: 36,
nfe: true,
abilities: { 0: 'Gluttony' },
baseSpecies: 'Slowpoke'
},
Solotl: {
types: ['Fire', 'Dragon'],
bs: { hp: 68, at: 48, df: 34, sa: 72, sd: 24, sp: 84 },
weightkg: 11.8,
nfe: true,
abilities: { 0: 'Regenerator' }
},
Snom: {
types: ['Ice', 'Bug'],
bs: { hp: 30, at: 25, df: 35, sa: 45, sd: 30, sp: 20 },
weightkg: 3.8,
abilities: { 0: 'Shield Dust' },
nfe: true
},
'Snorlax-Gmax': {
types: ['Normal'],
bs: { hp: 160, at: 110, df: 65, sa: 65, sd: 110, sp: 30 },
weightkg: 0,
abilities: { 0: 'Immunity' },
baseSpecies: 'Snorlax'
},
Sobble: {
types: ['Water'],
bs: { hp: 50, at: 40, df: 40, sa: 70, sd: 40, sp: 70 },
weightkg: 4,
abilities: { 0: 'Torrent' },
nfe: true
},
Stonjourner: {
types: ['Rock'],
bs: { hp: 100, at: 125, df: 135, sa: 20, sd: 20, sp: 70 },
weightkg: 520,
abilities: { 0: 'Power Spot' }
},
'Stunfisk-Galar': {
types: ['Ground', 'Steel'],
bs: { hp: 109, at: 81, df: 99, sa: 66, sd: 84, sp: 32 },
weightkg: 20.5,
abilities: { 0: 'Mimicry' },
baseSpecies: 'Stunfisk'
},
Thievul: {
types: ['Dark'],
bs: { hp: 70, at: 58, df: 58, sa: 87, sd: 92, sp: 90 },
weightkg: 19.9,
abilities: { 0: 'Run Away' }
},
Thwackey: {
types: ['Grass'],
bs: { hp: 70, at: 85, df: 70, sa: 55, sd: 60, sp: 80 },
weightkg: 14,
abilities: { 0: 'Overgrow' },
nfe: true
},
Toxel: {
types: ['Electric', 'Poison'],
bs: { hp: 40, at: 38, df: 35, sa: 54, sd: 35, sp: 40 },
weightkg: 11,
abilities: { 0: 'Rattled' },
nfe: true
},
Toxtricity: {
types: ['Electric', 'Poison'],
bs: { hp: 75, at: 98, df: 70, sa: 114, sd: 70, sp: 75 },
weightkg: 40,
abilities: { 0: 'Punk Rock' },
otherFormes: ['Toxtricity-Gmax', 'Toxtricity-Low-Key', 'Toxtricity-Low-Key-Gmax']
},
'Toxtricity-Gmax': {
types: ['Electric', 'Poison'],
bs: { hp: 75, at: 98, df: 70, sa: 114, sd: 70, sp: 75 },
weightkg: 0,
abilities: { 0: 'Punk Rock' },
baseSpecies: 'Toxtricity'
},
'Toxtricity-Low-Key': {
types: ['Electric', 'Poison'],
bs: { hp: 75, at: 98, df: 70, sa: 114, sd: 70, sp: 75 },
weightkg: 40,
abilities: { 0: 'Punk Rock' },
baseSpecies: 'Toxtricity'
},
'Toxtricity-Low-Key-Gmax': {
types: ['Electric', 'Poison'],
bs: { hp: 75, at: 98, df: 70, sa: 114, sd: 70, sp: 75 },
weightkg: 0,
abilities: { 0: 'Punk Rock' },
baseSpecies: 'Toxtricity'
},
Urshifu: {
types: ['Fighting', 'Dark'],
bs: { hp: 100, at: 130, df: 100, sa: 63, sd: 60, sp: 97 },
weightkg: 105,
abilities: { 0: 'Unseen Fist' },
otherFormes: ['Urshifu-Gmax', 'Urshifu-Rapid-Strike', 'Urshifu-Rapid-Strike-Gmax']
},
'Urshifu-Rapid-Strike': {
types: ['Fighting', 'Water'],
bs: { hp: 100, at: 130, df: 100, sa: 63, sd: 60, sp: 97 },
weightkg: 105,
abilities: { 0: 'Unseen Fist' },
baseSpecies: 'Urshifu'
},
'Urshifu-Rapid-Strike-Gmax': {
types: ['Fighting', 'Water'],
bs: { hp: 100, at: 130, df: 100, sa: 63, sd: 60, sp: 97 },
weightkg: 105,
abilities: { 0: 'Unseen Fist' },
baseSpecies: 'Urshifu'
},
'Urshifu-Gmax': {
types: ['Fighting', 'Dark'],
bs: { hp: 100, at: 130, df: 100, sa: 63, sd: 60, sp: 97 },
weightkg: 0,
abilities: { 0: 'Unseen Fist' },
baseSpecies: 'Urshifu'
},
'Venusaur-Gmax': {
types: ['Grass', 'Poison'],
bs: { hp: 80, at: 82, df: 83, sa: 100, sd: 100, sp: 80 },
weightkg: 0,
abilities: { 0: 'Overgrow' },
baseSpecies: 'Venusaur'
},
'Weezing-Galar': {
types: ['Poison', 'Fairy'],
bs: { hp: 65, at: 90, df: 120, sa: 85, sd: 70, sp: 60 },
weightkg: 16,
abilities: { 0: 'Levitate' },
baseSpecies: 'Weezing'
},
Wooloo: {
types: ['Normal'],
bs: { hp: 42, at: 40, df: 55, sa: 40, sd: 45, sp: 48 },
weightkg: 6,
abilities: { 0: 'Fluffy' },
nfe: true
},
'Yamask-Galar': {
types: ['Ground', 'Ghost'],
bs: { hp: 38, at: 55, df: 85, sa: 30, sd: 65, sp: 30 },
weightkg: 1.5,
abilities: { 0: 'Wandering Spirit' },
nfe: true,
baseSpecies: 'Yamask'
},
Yamper: {
types: ['Electric'],
bs: { hp: 59, at: 45, df: 50, sa: 40, sd: 50, sp: 26 },
weightkg: 13.5,
abilities: { 0: 'Ball Fetch' },
nfe: true
},
Zacian: {
types: ['Fairy'],
bs: { hp: 92, at: 130, df: 115, sa: 80, sd: 115, sp: 138 },
weightkg: 110,
abilities: { 0: 'Intrepid Sword' },
gender: 'N',
otherFormes: ['Zacian-Crowned']
},
'Zacian-Crowned': {
types: ['Fairy', 'Steel'],
bs: { hp: 92, at: 170, df: 115, sa: 80, sd: 115, sp: 148 },
weightkg: 355,
abilities: { 0: 'Intrepid Sword' },
baseSpecies: 'Zacian',
gender: 'N'
},
Zamazenta: {
types: ['Fighting'],
bs: { hp: 92, at: 130, df: 115, sa: 80, sd: 115, sp: 138 },
weightkg: 210,
abilities: { 0: 'Dauntless Shield' },
gender: 'N',
otherFormes: ['Zamazenta-Crowned']
},
'Zamazenta-Crowned': {
types: ['Fighting', 'Steel'],
bs: { hp: 92, at: 130, df: 145, sa: 80, sd: 145, sp: 128 },
weightkg: 785,
abilities: { 0: 'Dauntless Shield' },
baseSpecies: 'Zamazenta',
gender: 'N'
},
Zarude: {
types: ['Dark', 'Grass'],
bs: { hp: 105, at: 120, df: 105, sa: 70, sd: 95, sp: 105 },
weightkg: 70,
abilities: { 0: 'Leaf Guard' },
gender: 'N',
otherFormes: ['Zarude-Dada']
},
'Zarude-Dada': {
types: ['Dark', 'Grass'],
bs: { hp: 105, at: 120, df: 105, sa: 70, sd: 95, sp: 105 },
weightkg: 70,
abilities: { 0: 'Leaf Guard' },
baseSpecies: 'Zarude',
gender: 'N'
},
'Zigzagoon-Galar': {
types: ['Dark', 'Normal'],
bs: { hp: 38, at: 30, df: 41, sa: 30, sd: 41, sp: 60 },
weightkg: 17.5,
abilities: { 0: 'Pickup' },
nfe: true,
baseSpecies: 'Zigzagoon'
}
};
var SS = util_1.extend(true, {}, SM, SS_PATCH);
delete SS['Pikachu-Starter'];
delete SS['Eevee-Starter'];
exports.SPECIES = [{}, RBY, GSC, ADV, DPP, BW, XY, SM, SS];
var Species = (function () {
function Species(gen) {
this.gen = gen;
}
Species.prototype.get = function (id) {
return SPECIES_BY_ID[this.gen][id];
};
Species.prototype[Symbol.iterator] = function () {
var _a, _b, _i, id;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_a = [];
for (_b in SPECIES_BY_ID[this.gen])
_a.push(_b);
_i = 0;
_c.label = 1;
case 1:
if (!(_i < _a.length)) return [3, 4];
id = _a[_i];
return [4, this.get(id)];
case 2:
_c.sent();
_c.label = 3;
case 3:
_i++;
return [3, 1];
case 4: return [2];
}
});
};
return Species;
}());
exports.Species = Species;
var Specie = (function () {
function Specie(name, data) {
this.kind = 'Species';
this.id = util_1.toID(name);
this.name = name;
var baseStats = {};
baseStats.hp = data.bs.hp;
baseStats.atk = data.bs.at;
baseStats.def = data.bs.df;
baseStats.spa = gen >= 2 ? data.bs.sa : data.bs.sl;
baseStats.spd = gen >= 2 ? data.bs.sd : data.bs.sl;
baseStats.spe = data.bs.sp;
this.baseStats = baseStats;
util_1.assignWithout(this, data, Specie.EXCLUDE);
}
Specie.EXCLUDE = new Set(['bs']);
return Specie;
}());
var SPECIES_BY_ID = [];
var gen = 0;
try {
for (var SPECIES_1 = __values(exports.SPECIES), SPECIES_1_1 = SPECIES_1.next(); !SPECIES_1_1.done; SPECIES_1_1 = SPECIES_1.next()) {
var species = SPECIES_1_1.value;
var map = {};
for (var specie in species) {
if (gen >= 2 && species[specie].bs.sl)
delete species[specie].bs.sl;
var m = new Specie(specie, species[specie]);
map[m.id] = m;
}
SPECIES_BY_ID.push(map);
gen++;
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (SPECIES_1_1 && !SPECIES_1_1.done && (_a = SPECIES_1["return"])) _a.call(SPECIES_1);
}
finally { if (e_1) throw e_1.error; }
}
//# sourceMappingURL=species.js.map |
/* eslint no-console: 0 no-sync: 0 */
// Automatic cancellation in node-telegram-bot-api is deprecated, disable it
process.env.NTBA_FIX_319 = 1;
const fs = require("fs");
const path = require("path");
const TelegramBot = require(process.env.IS_TEST_ENVIRONMENT ? process.env.MOCK_NTBA : "node-telegram-bot-api");
const PluginManager = require("./PluginManager");
const Config = JSON.parse(fs.readFileSync("./config.json", "utf8"));
const Logger = require("./Log");
const log = new Logger("Bot", Config);
if (process.env.IS_TEST_ENVIRONMENT)
log.warn("Running in test mode (mocking Telegram)");
const Auth = require("./helpers/Auth");
const auth = new Auth(Config, log);
if (typeof Config.TELEGRAM_TOKEN !== "string" || Config.TELEGRAM_TOKEN === "") {
log.error("You must provide a Telegram bot token in config.json. Try running \"npm run configure:guided\" or \"npm run configure:expert\".");
process.exit(1);
}
// Version reporting, useful for bug reports
let commit = "";
if (fs.existsSync(path.join(__dirname, "../.git"))) {
const branchRef = fs.readFileSync(path.join(__dirname, "../.git/HEAD"), "utf8").replace(/^ref: /, "").replace(/\n$/, "");
commit = fs.readFileSync(path.join(__dirname, "../.git", branchRef), "utf8").substr(0, 7);
}
log.info(`Nikoro version ${require("../package.json").version}` + (commit ? `, commit ${commit}` : ""));
if (Config.globalAdmins) {
log.warn("Config contains deprecated key 'globalAdmins', replacing with 'owners'");
Config.owners = Config.globalAdmins;
delete Config.globalAdmins;
fs.writeFileSync("./config.json", JSON.stringify(Config, null, 4));
}
log.verbose("Creating a TelegramBot instance...");
const bot = new TelegramBot(Config.TELEGRAM_TOKEN, {polling: true});
log.info("Instance created.");
log.verbose("Loading plugins...");
const pluginManager = new PluginManager(bot, Config, auth);
pluginManager.loadPlugins(Config.activePlugins, false);
pluginManager.startSynchronization();
log.info("Plugins loaded.");
log.info("The bot is online!");
function handleShutdown(reason) {
return err => {
if (err && (err != "SIGINT")) log.error(err);
log.warn("Shutting down, reason: " + reason);
log.info("Stopping safely all the plugins...");
pluginManager.stopSynchronization();
pluginManager.stopPlugins().then(function() {
log.info("All plugins stopped correctly.");
process.exit();
});
};
}
// If `CTRL+C` is pressed we stop the bot safely.
process.on("SIGINT", handleShutdown("Terminated by user"));
// Stop safely in case of `uncaughtException`.
process.on("uncaughtException", handleShutdown("Uncaught exception"));
process.on("unhandledRejection", (reason, p) => {
log.error("Unhandled rejection at Promise ", p, " with reason ", reason);
});
if (process.env.IS_TEST_ENVIRONMENT)
module.exports = bot; // The test instance will reuse this to push messages |
'use strict';
module.exports = function(grunt) {
grunt.initConfig({
clean: {
dist: ['dist'],
},
bosonic: {
components: {
src: ['src/*.html'],
css: 'dist/b-sortable.css',
js: 'dist/b-sortable.js'
}
},
karma: {
unit: {
configFile: 'karma.conf.js'
}
},
watch: {
source: {
files: ['src/*.html'],
tasks: ['clean', 'bosonic', 'copy:dist']
}
},
copy: {
lib: {
files: [
{ src: ['node_modules/bosonic/dist/*.js'], dest: 'demo/js/', filter: 'isFile', expand: true, flatten: true }
]
},
dist: {
files: [
{ src: ['dist/*.js'], dest: 'demo/js/', filter: 'isFile', expand: true, flatten: true },
{ src: ['dist/*.css'], dest: 'demo/css/', filter: 'isFile', expand: true, flatten: true }
]
}
},
connect: {
demo: {
options: {
port: 8020,
base: './demo',
hostname: '*'
}
}
}
});
grunt.loadNpmTasks('grunt-contrib-watch');
grunt.loadNpmTasks('grunt-contrib-clean');
grunt.loadNpmTasks('grunt-contrib-connect');
grunt.loadNpmTasks('grunt-contrib-copy');
grunt.loadNpmTasks('grunt-bosonic');
grunt.loadNpmTasks('grunt-karma');
grunt.registerTask('default', ['dist', 'watch']);
grunt.registerTask('test', ['dist', 'karma']);
grunt.registerTask('demo', ['dist', 'copy', 'connect', 'watch']);
grunt.registerTask('dist', ['clean', 'bosonic']);
};
|
const _ = require('underscore');
class ChallengeTracker {
constructor() {
this.complete = 0;
this.challengeTypes = {
military: {
performed: 0,
max: 1,
won: 0,
lost: 0
},
intrigue: {
performed: 0,
max: 1,
won: 0,
lost: 0
},
power: {
performed: 0,
max: 1,
won: 0,
lost: 0
},
defender: {
performed: 0,
won: 0,
lost: 0
},
attacker: {
performed: 0,
won: 0,
lost: 0
}
};
}
reset() {
this.complete = 0;
this.resetForType('military');
this.resetForType('intrigue');
this.resetForType('power');
this.resetForType('defender');
this.resetForType('attacker');
}
resetForType(challengeType) {
this.challengeTypes[challengeType].performed = 0;
this.challengeTypes[challengeType].won = 0;
this.challengeTypes[challengeType].lost = 0;
}
isAtMax(challengeType) {
if(!_.isUndefined(this.maxTotal) && this.complete >= this.maxTotal) {
return true;
}
if(this.challengeTypes[challengeType].cannotInitiate) {
return true;
}
return this.challengeTypes[challengeType].performed >= this.challengeTypes[challengeType].max;
}
getWon(challengeType) {
return this.challengeTypes[challengeType].won;
}
getLost(challengeType) {
return this.challengeTypes[challengeType].lost;
}
getPerformed(challengeType) {
return this.challengeTypes[challengeType].performed;
}
setMax(max) {
this.maxTotal = max;
}
clearMax() {
delete this.maxTotal;
}
setCannotInitiateForType(challengeType, value) {
this.challengeTypes[challengeType].cannotInitiate = value;
}
perform(challengeType) {
this.challengeTypes[challengeType].performed++;
this.complete++;
}
won(challengeType, wasAttacker) {
this.challengeTypes[challengeType].won++;
this.challengeTypes[wasAttacker ? 'attacker' : 'defender'].won++;
}
lost(challengeType, wasAttacker) {
this.challengeTypes[challengeType].lost++;
this.challengeTypes[wasAttacker ? 'attacker' : 'defender'].lost++;
}
modifyMaxForType(challengeType, number) {
this.challengeTypes[challengeType].max += number;
}
}
module.exports = ChallengeTracker;
|
const expect = require('chai').expect;
describe('[Raw API] Assertions', function () {
it('Should perform eql assertion', function () {
return runTests('./testcafe-fixtures/assertions.testcafe', 'eql assertion', {
shouldFail: true,
only: 'chrome'
})
.catch(function (errs) {
expect(errs[0]).contains("AssertionError: testMessage: expected 'hey' to deeply equal 'yo'");
expect(errs[0]).contains('[[Eql assertion failed callsite]]');
});
});
it('Should perform notEql assertion', function () {
return runTests('./testcafe-fixtures/assertions.testcafe', 'notEql assertion', {
shouldFail: true,
only: 'chrome'
})
.catch(function (errs) {
expect(errs[0]).contains('AssertionError: expected 2 to not deeply equal 2');
expect(errs[0]).contains('[[NotEql assertion failed callsite]]');
});
});
it('Should perform ok assertion', function () {
return runTests('./testcafe-fixtures/assertions.testcafe', 'ok assertion', {
shouldFail: true,
only: 'chrome'
})
.catch(function (errs) {
expect(errs[0]).contains('AssertionError: expected false to be truthy');
expect(errs[0]).contains('[[Ok assertion failed callsite]]');
});
});
it('Should perform notOk assertion', function () {
return runTests('./testcafe-fixtures/assertions.testcafe', 'notOk assertion', {
shouldFail: true,
only: 'chrome'
})
.catch(function (errs) {
expect(errs[0]).contains('AssertionError: expected 1 to be falsy');
expect(errs[0]).contains('[[NotOk assertion failed callsite]]');
});
});
it('Should perform within assertion', function () {
return runTests('./testcafe-fixtures/assertions.testcafe', 'within assertion', {
shouldFail: true,
only: 'chrome'
})
.catch(function (errs) {
expect(errs[0]).contains('AssertionError: expected 4.5 to be within 4.6..7');
expect(errs[0]).contains('[[Within assertion failed callsite]]');
});
});
it('Should perform notWithin assertion', function () {
return runTests('./testcafe-fixtures/assertions.testcafe', 'notWithin assertion', {
shouldFail: true,
only: 'chrome'
})
.catch(function (errs) {
expect(errs[0]).contains('AssertionError: expected 2.3 to not be within 2..3');
expect(errs[0]).contains('[[NotWithin assertion failed callsite]]');
});
});
it('Should raise error if "timeout" option is not a number', function () {
return runTests('./testcafe-fixtures/assertions.testcafe', 'timeout is not a number', {
shouldFail: true,
only: 'chrome'
})
.catch(function (errs) {
expect(errs[0]).contains('The "timeout" option is expected to be a positive integer, but it was string.');
expect(errs[0]).contains('[[Timeout option is string callsite]]');
});
});
it('Should process js expression', function () {
return runTests('./testcafe-fixtures/assertions.testcafe', 'js expression', {
shouldFail: false,
only: 'chrome'
});
});
});
|
define(["angular","angular-modules"],function(e,t){t.controllers.controller("subCtrl",["$scope",function(
e){e.name="sub app"}])}); |
const meta = require('../meta.html')
const noscript = require('../noscript.html')
const markdown = require('./luyan.md')
const footer = require('../../Components/Footer.html')
const html = (templateParams) =>
`<!DOCTYPE html>
<html>
<head>
${meta}
<title>${templateParams.htmlWebpackPlugin.options.title}</title>
</head>
<body>
${noscript}
<div id='body' class="main-content">
${markdown}
${footer}
</div>
<!--<div>development mode</div>-->
</body>
</html>`
module.exports = html
|
import { IE11OrLess, Edge } from './BrowserInfo.js';
import { expando } from './utils.js';
import PluginManager from './PluginManager.js';
export default function dispatchEvent(
{
sortable, rootEl, name,
targetEl, cloneEl, toEl, fromEl,
oldIndex, newIndex,
oldDraggableIndex, newDraggableIndex,
originalEvent, putSortable, extraEventProperties
}
) {
sortable = (sortable || (rootEl && rootEl[expando]));
if (!sortable) return;
let evt,
options = sortable.options,
onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1);
// Support for new CustomEvent feature
if (window.CustomEvent && !IE11OrLess && !Edge) {
evt = new CustomEvent(name, {
bubbles: true,
cancelable: true
});
} else {
evt = document.createEvent('Event');
evt.initEvent(name, true, true);
}
evt.to = toEl || rootEl;
evt.from = fromEl || rootEl;
evt.item = targetEl || rootEl;
evt.clone = cloneEl;
evt.oldIndex = oldIndex;
evt.newIndex = newIndex;
evt.oldDraggableIndex = oldDraggableIndex;
evt.newDraggableIndex = newDraggableIndex;
evt.originalEvent = originalEvent;
evt.pullMode = putSortable ? putSortable.lastPutMode : undefined;
let allEventProperties = { ...extraEventProperties, ...PluginManager.getEventProperties(name, sortable) };
for (let option in allEventProperties) {
evt[option] = allEventProperties[option];
}
if (rootEl) {
rootEl.dispatchEvent(evt);
}
if (options[onName]) {
options[onName].call(sortable, evt);
}
}
|
define({
"addLayer": "Adicionar Camada",
"layerName": "Camada",
"layerRefresh": "Atualizar",
"layerLabel": "Rótulo",
"actions": "Acções",
"mainPanelTextPlaceholder": "ex: Ùltima Atualização:",
"invalidInterval": "Apenas números inteiros positivos são permitidos",
"uploadImage": "Carregar Imagem",
"iconColumnText": "Exibir",
"refreshInterval": "Tempo em Minutos",
"refreshIntervalTitle": "Avaliada como o tempo em Minutos",
"mainPanelText": "Texto de Painel Principal",
"mainPanelIcon": "Imagem de Painel Principal",
"refreshIntervalInstruction": "Atualizar camadas a cada:",
"optionsText": "Opções",
"symbolOptionsText": "Simbologia do Mapa",
"iconOptionsText": "Simbologia do Painel",
"sympolPopupTitle": "Exibir Definições",
"rdoLayer": "Símbolo Padrão",
"rdoCustom": "Utilizar uma Imagem",
"chkCluster": "Permitir Clustering",
"defineClusterSymbol": "Especificar Símbolo do Cluster",
"rdoEsri": "Escolher um símbolo",
"rdoLayerIcon": "Utilizar símbolo de mapa",
"rdoCustomIcon": "Utilizar uma imagem",
"editCustomSymbol": "Editar Símbolo Personalizado",
"editCustomIcon": "Editar Ícone Personalizado",
"missingRefreshValue": "Por favor forneça uma actualização de valor de intervalo.",
"panelIconOption": "Exibir Imagem do Logótipo",
"enableRefresh": "Ativar atualização de camada",
"disableRefresh": "Atualização de camada apenas suportada para coleções de elementos.",
"refreshUnit": "minutos.",
"symbolOptions": "Símbolo",
"panelFeatureDisplay": "Painel",
"chkGroup": "Elementos de grupo",
"selectField": "Campo",
"fieldLabel": "Rótulo",
"addField": "Adicionar Campo",
"featureOptionsText": "Opções de Camadas",
"groupOptionsText": "Opções de Grupos",
"panelCountOption": "Exibir Contagens de Elementos",
"missingLayerInWebMap": "Nenhuma camada operacional encontrada.",
"displayClusterCnt": "Exibir Contagem de Elementos",
"defineClusterFont": "Especificar Cor da Letra",
"max_records": "Limite máximo do campo atingido",
"hidePanel": "Ocultar Painel",
"hidePanelHelp": "Ativar/Desativar exibição do painel principal.",
"continuousRefreshHelp": "Nota: A atualização da coleção de elementos irá ocorrer de forma contínua.",
"panelCountOptionHelp": "Ativar/Desativar exibição de contagens de elementos.",
"panelIconOptionHelp": "Ativar/Desativar exibição de um logótipo no painel principal.",
"rdoGroupByField": "por campo",
"rdoGroupByRenderer": "por renderizador"
}); |
import createSvgIcon from './utils/createSvgIcon';
import { jsx as _jsx } from "react/jsx-runtime";
export default createSvgIcon([/*#__PURE__*/_jsx("path", {
d: "M5 5h14v14H5z",
opacity: ".3"
}, "0"), /*#__PURE__*/_jsx("path", {
d: "M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zm0 16H5V5h14v14z"
}, "1"), /*#__PURE__*/_jsx("path", {
d: "M7 12h2v5H7zm8-5h2v10h-2zm-4 7h2v3h-2zm0-4h2v2h-2z"
}, "2")], 'AnalyticsTwoTone'); |
import createSvgIcon from './utils/createSvgIcon';
import { jsx as _jsx } from "react/jsx-runtime";
export default createSvgIcon([/*#__PURE__*/_jsx("path", {
d: "M21 12.22C21 6.73 16.74 3 12 3c-4.69 0-9 3.65-9 9.28-.6.34-1 .98-1 1.72v2c0 1.1.9 2 2 2 .55 0 1-.45 1-1v-4.81c0-3.83 2.95-7.18 6.78-7.29 3.96-.12 7.22 3.06 7.22 7V19h-7c-.55 0-1 .45-1 1s.45 1 1 1h7c1.1 0 2-.9 2-2v-1.22c.59-.31 1-.92 1-1.64v-2.3c0-.7-.41-1.31-1-1.62z"
}, "0"), /*#__PURE__*/_jsx("circle", {
cx: "9",
cy: "13",
r: "1"
}, "1"), /*#__PURE__*/_jsx("circle", {
cx: "15",
cy: "13",
r: "1"
}, "2"), /*#__PURE__*/_jsx("path", {
d: "M18 11.03C17.52 8.18 15.04 6 12.05 6c-3.03 0-6.29 2.51-6.03 6.45 2.47-1.01 4.33-3.21 4.86-5.89 1.31 2.63 4 4.44 7.12 4.47z"
}, "3")], 'SupportAgentRounded'); |
// Copyright 2009 the Sputnik authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/**
* @name: S11.3.2_A2.1_T3;
* @section: 11.3.2, 11.6.3;
* @assertion: Operator x-- uses GetValue and PutValue;
* @description: If Type(x) is not Reference, throw ReferenceError (or SyntaxError);
* @negative
*/
//CHECK#1
try {
1--;
$ERROR('#1.1: 1-- throw ReferenceError (or SyntaxError). Actual: ' + (1--));
}
catch (e) {
if ((e instanceof ReferenceError) !== true) {
$ERROR('#1.2: 1-- throw ReferenceError (or SyntaxError). Actual: ' + (e));
} else {
1--;
}
}
|
//----------------------------------------------------------------------
//
// This source file is part of the Folktale project.
//
// Licensed under MIT. See LICENCE for full licence information.
// See CONTRIBUTORS for the list of contributors to the project.
//
//----------------------------------------------------------------------
const { property } = require('jsverify');
const { union, derivations } = require('folktale/adt/union');
const { any } = union;
const { serialization, equality, debugRepresentation } = derivations;
// --[ Helpers ]--------------------------------------------------------
const methodThrowsError = method => () => {
try {
method();
return false;
}
catch(err) {
return true;
}
};
describe('ADT: union', () => {
describe('union(typeId, patterns)', () => {
property('Constructs an union with the given type', 'json', (a) =>
union(a, {})[union.typeSymbol] === a
);
it('Creates a variant constructor for each pattern', () => {
const { A, B, C } = union('', {
A() { return {} },
B(a) { return { a } },
C(a, b){ return { a, b }}
});
$ASSERT(A() == {});
$ASSERT(B(1) == { a: 1 });
$ASSERT(C(1, 2) == { a: 1, b: 2 });
});
it('Constructs unions that inherit from Union', () => {
const adt = union('', {});
$ASSERT(Object.getPrototypeOf(adt) === union.Union);
});
describe('#hasInstance(value)', () => {
property('Checks only the type tag by ref equality', 'dict nat', 'dict nat', (a, b) => {
const x = union(a, {});
const y = union(a, {});
const z = union(b, {});
return x.hasInstance(y) && y.hasInstance(x)
&& !x.hasInstance(z) && !z.hasInstance(x);
});
});
describe('#derive(derivation)', () => {
it('Is invoked for each variant', () => {
const adt = union('', {
A(){ return {} },
B(){ return {} },
C(){ return {} }
});
let visited = {};
adt.derive((variant, adt) => {
visited[variant.tag] = true;
});
$ASSERT(visited == { A: true, B: true, C: true });
});
it('May change the prototype of the variant', () => {
const adt = union('', {
A(){ return {} }
});
const a = adt.A();
adt.derive((variant, adt) => {
variant.prototype.f = () => 1
});
const b = adt.A();
$ASSERT(a.f() == 1);
$ASSERT(b.f() == 1);
});
it('Provides an object of the Variant interface', () => {
const adt = union('adt', {
A(){ return {} }
});
adt.derive((variant, adt) => {
$ASSERT(variant == { tag: 'A', type: 'adt', ..._ });
$ASSERT(variant.prototype === adt.A.prototype);
});
});
});
describe('each union', () => {
it('Is an instance of its constructor', () => {
const adt = union('', {
A(){ return {} },
B(){ return {} }
});
const { A, B } = adt;
$ASSERT(adt.isPrototypeOf(A()));
$ASSERT(A() instanceof A);
$ASSERT(B() instanceof B);
$ASSERT(!(A() instanceof B));
});
if (Number(process.env.ES_VERSION || 0) >= 2015) {
it('Shorthand methods should work properly as variant initialisers', () => {
const adt = eval(`union('', {
A() {
return { value: 1 }
}
})`);
$ASSERT(adt.A.constructor.prototype !== undefined);
$ASSERT(adt.A(1) == { value: 1, ..._ });
$ASSERT(adt.A(1) instanceof adt.A);
});
}
it('Gets a matchWith method for pattern matching', () => {
const { A, B } = union('', {
A(a) { return { a } },
B(a, b) { return { a, b } }
});
$ASSERT(
A(1).matchWith({
A: ({ a }) => a,
B: ({ a, b }) => a + b
})
== 1
);
$ASSERT(
B(1, 2).matchWith({
A: ({ a }) => a,
B: ({ a, b }) => a + b
})
== 3
);
});
it('Blows up with a customer error message if you are missing a variant', () => {
const { A, B } = union('', {
A(a) { return { a } },
B() { return {} }
});
const matchWrapper = ()=>
A(1).matchWith({
B: ({ a }) => a
}) == 'cow';
$ASSERT(methodThrowsError(matchWrapper)() === true);
});
it('works with any if you do not care and just want a default match', ()=> {
const { Red, Green, Blue } = union('', {
Red() { return { } },
Green() { return { } },
Blue() { return { } }
});
$ASSERT(
Red().matchWith({
Red: () => 'red',
Green: () => 'green',
Blue: () => 'blue'
})
== 'red'
);
$ASSERT(
Red().matchWith({
Green: () => 'green',
Blue: () => 'blue',
[any]: ()=> 'black'
})
== 'black'
);
});
it('any works with all nested variants', ()=> {
const { Miss, Hit, Attack } = union('', {
Miss() { return { } },
Hit(damage, critical) { return { damage, critical } },
Attack(attackResult) { return { attackResult } }
});
$ASSERT(
Attack(Hit(1, false)).matchWith({
Miss: ()=> 'miss',
Hit: ({damage, critical}) => 'damage',
[any]: () => 'nothing'
})
== 'nothing'
);
});
// NOTE: this fails randomly in Node 5's v8. Seems to be a v8
// optimisation bug, although I haven't had the time to analyse
// it yet.
property('Gets a tag with the same name as the constructor', 'string', (a) => {
const adt = union('', { [a](){ return {} }});
return adt[a]()[union.tagSymbol] === a;
});
property('Gets a hasInstance method that only looks at type/tag', 'string', (a) => {
const b = a + '2';
const adt1 = union(a, { [b](){ return {} }});
const adt2 = union(a, { [a](){ return {} }, [b](){ return {} }});
const adt3 = union(b, { [b](){ return {} }});
$ASSERT(adt1[b].hasInstance(adt1[b]()));
$ASSERT(adt1[b].hasInstance(adt2[b]()));
$ASSERT(!adt1[b].hasInstance(adt2[a]()));
$ASSERT(!adt1[b].hasInstance(adt3[b]()));
return true;
});
});
});
describe('Equality', () => {
const { A, B } = union('AB', {
A: (value) => ({ value }),
B: (value) => ({ value })
}).derive(equality)
property('Different simple values are NOT equal', 'json', (a) => {
return !A(a).equals(B(a))
});
property('Different composite values are NOT equal', 'json', (a) => {
return !A(B(a)).equals(A(a))
});
property('Similar simple values are equal', 'json', (a) => {
return A(a).equals(A(a))
});
property('Similar composite values are equal', 'json', (a) => {
return A(B(a)).equals(A(B(a)))
});
describe('Equality#withCustomComparison', () => {
const { A } = union('A', {
A: (value) => ({ value }),
}).derive(equality.withCustomComparison((a, b) => a.id === b.id));
property('Values are compared using a custom function if provided', 'json', 'json', function(a, b) {
return A({id:1, _irrelevantValue:a}).equals(A({id:1, _irrelevantValue: b}))
});
});
});
describe('Debug Representation', () => {
const AB = union('AB', {
A: (value) => ({ value }),
B: (value) => ({ value })
}).derive(debugRepresentation)
property('Types have a string representation', () => {
return AB.toString() === 'AB';
})
property('Variants have a string representation', () => {
return AB.A.toString() === 'AB.A';
})
property('Primitive Values have a string representation', () => {
return AB.A(1).toString() === 'AB.A({ value: 1 })';
})
property('Special IEEE 754 values have a correct string representation', () => {
return AB.A(NaN).toString() === 'AB.A({ value: NaN })'
&& AB.A(Infinity).toString() === 'AB.A({ value: Infinity })'
&& AB.A(-Infinity).toString() === 'AB.A({ value: -Infinity })'
&& AB.A(-0).toString() === 'AB.A({ value: -0 })'
})
property('Complex Values have a string representation', () => {
return AB.A({foo: "bar"}).toString() === 'AB.A({ value: { foo: "bar" } })';
})
property('Functions have a string representation', () => {
return AB.A((a) => a ).toString() === 'AB.A({ value: [Function] })';
})
property('Named functions have a string representation', () => {
return AB.A(function foo(){ }).toString() === 'AB.A({ value: [Function: foo] })';
})
property('Symbols have a string representation', () => {
// Older engines don't have proper Symbol representations, so we account for
// es6-shim stuff here
return /AB\.A\({ value: Symbol\(foo\)\S* }\)/.test(AB.A(Symbol('foo')).toString());
})
property('Recursive Values have a string representation', () => {
return AB.A({rec:AB.A(1)}).toString() === 'AB.A({ value: { rec: AB.A({ value: 1 }) } })'
})
property('ADTs containing objects with custom .toString get serialised properly', () => {
const a = { toString(){ return 'hello' }};
return AB.A(a).toString() === 'AB.A({ value: hello })'
});
// Issue https://github.com/origamitower/folktale/issues/168
property('ADTs containing objects without a .toString get serialised properly', () => {
const a = Object.create(null);
a.foo = 1;
return AB.A(a).toString() === 'AB.A({ value: { foo: 1 } })'
});
// TODO: Issue https://github.com/origamitower/folktale/issues/167
xit('Circular objects get serialised properly', () => {
const a = Object.create(null);
a.a = a;
return AB.A(a).toString() === 'AB.A({ value: { a: [Circular] } })'
});
});
describe('Serialization', () => {
const AB = union('folktale:AB', {
A: (value) => ({ value }),
B: (value) => ({ value })
}).derive(serialization, equality);
const CD = union('folktale:CD', {
C: (value) => ({value}),
D: (value) => ({value})
}).derive(serialization, equality);
const {A, B} = AB;
const {C, D} = CD;
property('Serializing a value and deserializing it yields a similar value', 'json', (a) => {
return AB.fromJSON(A(a).toJSON()).equals(A(a))
})
property('Serializing a *recursive* value and deserializing it yields a similar value', 'json', (a) => {
return AB.fromJSON(A(B(a)).toJSON()).equals(A(B(a)))
})
property('Serializing a *composite* value and deserializing it yields a similar value (when the proper parsers are provided).', 'json', (a) => {
return AB.fromJSON(A(B(C(a))).toJSON(), {AB, CD}).equals(A(B(C(a))))
})
});
});
|
// TODO: Add test for React Redux connect function
import chai from 'chai';
import { createSelector, createSelectorCreator, defaultMemoize, createStructuredSelector } from '../src/index';
import { default as lodashMemoize } from 'lodash.memoize';
let assert = chai.assert;
suite('selector', () => {
test('basic selector', () => {
const selector = createSelector(
state => state.a,
a => a
);
assert.equal(selector({a: 1}), 1);
assert.equal(selector({a: 1}), 1);
assert.equal(selector.recomputations(), 1);
assert.equal(selector({a: 2}), 2);
assert.equal(selector.recomputations(), 2);
});
test('basic selector multiple keys', () => {
const selector = createSelector(
state => state.a,
state => state.b,
(a, b) => a + b
);
const state1 = {a: 1, b: 2};
assert.equal(selector(state1), 3);
assert.equal(selector(state1), 3);
assert.equal(selector.recomputations(), 1);
const state2 = {a: 3, b: 2};
assert.equal(selector(state2), 5);
assert.equal(selector(state2), 5);
assert.equal(selector.recomputations(), 2);
});
test('memoized composite arguments', () => {
const selector = createSelector(
state => state.sub,
sub => sub
);
const state1 = { sub: { a: 1 } };
assert.deepEqual(selector(state1), { a: 1 });
assert.deepEqual(selector(state1), { a: 1 });
assert.equal(selector.recomputations(), 1);
const state2 = { sub: { a: 2 } };
assert.deepEqual(selector(state2), { a: 2 });
assert.equal(selector.recomputations(), 2);
});
test('first argument can be an array', () => {
const selector = createSelector(
[state => state.a, state => state.b],
(a, b) => {
return a + b;
}
);
assert.equal(selector({a: 1, b: 2}), 3);
assert.equal(selector({a: 1, b: 2}), 3);
assert.equal(selector.recomputations(), 1);
assert.equal(selector({a: 3, b: 2}), 5);
assert.equal(selector.recomputations(), 2);
});
test('can accept props', () => {
let called = 0;
const selector = createSelector(
state => state.a,
state => state.b,
(state, props) => props.c,
(a, b, c) => {
called++;
return a + b + c;
}
);
assert.equal(selector({a: 1, b: 2}, {c: 100}), 103);
});
test('chained selector', () => {
const selector1 = createSelector(
state => state.sub,
sub => sub
);
const selector2 = createSelector(
selector1,
sub => sub.value
);
const state1 = {sub: { value: 1}};
assert.equal(selector2(state1), 1);
assert.equal(selector2(state1), 1);
assert.equal(selector2.recomputations(), 1);
const state2 = {sub: { value: 2}};
assert.equal(selector2(state2), 2);
assert.equal(selector2.recomputations(), 2);
});
test('chained selector with props', () => {
const selector1 = createSelector(
state => state.sub,
(state, props) => props.x,
(sub, x) => ({sub, x})
);
const selector2 = createSelector(
selector1,
(state, props) => props.y,
(param, y) => param.sub.value + param.x + y
);
const state1 = {sub: { value: 1}};
assert.equal(selector2(state1, {x: 100, y: 200}), 301);
assert.equal(selector2(state1, {x: 100, y: 200}), 301);
assert.equal(selector2.recomputations(), 1);
const state2 = {sub: { value: 2}};
assert.equal(selector2(state2, {x: 100, y: 201}), 303);
assert.equal(selector2.recomputations(), 2);
});
test('chained selector with variadic args', () => {
const selector1 = createSelector(
state => state.sub,
(state, props, another) => props.x + another,
(sub, x) => ({sub, x})
);
const selector2 = createSelector(
selector1,
(state, props) => props.y,
(param, y) => param.sub.value + param.x + y
);
const state1 = {sub: { value: 1}};
assert.equal(selector2(state1, {x: 100, y: 200}, 100), 401);
assert.equal(selector2(state1, {x: 100, y: 200}, 100), 401);
assert.equal(selector2.recomputations(), 1);
const state2 = {sub: { value: 2}};
assert.equal(selector2(state2, {x: 100, y: 201}, 200), 503);
assert.equal(selector2.recomputations(), 2);
});
test('override valueEquals', () => {
// a rather absurd equals operation we can verify in tests
const createOverridenSelector = createSelectorCreator(
defaultMemoize,
(a, b) => typeof a === typeof b
);
const selector = createOverridenSelector(
state => state.a,
a => a
);
assert.equal(selector({a: 1}), 1);
assert.equal(selector({a: 2}), 1); // yes, really true
assert.equal(selector.recomputations(), 1);
assert.equal(selector({a: 'A'}), 'A');
assert.equal(selector.recomputations(), 2);
});
test('custom memoize', () => {
const customSelectorCreator = createSelectorCreator(lodashMemoize, JSON.stringify);
const selector = customSelectorCreator(
state => state.a,
state => state.b,
(a, b) => a + b
);
assert.equal(selector({a: 1, b: 2}), 3);
assert.equal(selector({a: 1, b: 2}), 3);
assert.equal(selector.recomputations(), 1);
assert.equal(selector({a: 2, b: 3}), 5);
assert.equal(selector.recomputations(), 2);
// TODO: Check correct memoize function was called
});
test('exported memoize', () => {
let called = 0;
const memoized = defaultMemoize(state => {
called++;
return state.a;
});
const o1 = {a: 1};
const o2 = {a: 2};
assert.equal(memoized(o1), 1);
assert.equal(memoized(o1), 1);
assert.equal(called, 1);
assert.equal(memoized(o2), 2);
assert.equal(called, 2);
});
test('exported memoize with valueEquals override', () => {
// a rather absurd equals operation we can verify in tests
let called = 0;
const valueEquals = (a, b) => typeof a === typeof b;
const memoized = defaultMemoize(
a => {
called++;
return a;
},
valueEquals
);
assert.equal(memoized(1), 1);
assert.equal(memoized(2), 1); // yes, really true
assert.equal(called, 1);
assert.equal(memoized('A'), 'A');
assert.equal(called, 2);
});
test('structured selector', () => {
const selector = createStructuredSelector({
x: state => state.a,
y: state => state.b
});
let firstResult = selector({a: 1, b: 2});
assert.deepEqual(firstResult, {x: 1, y: 2});
assert.strictEqual(selector({a: 1, b: 2}), firstResult);
let secondResult = selector({a: 2, b: 2});
assert.deepEqual(secondResult, {x: 2, y: 2});
assert.strictEqual(selector({a: 2, b: 2}), secondResult);
});
test('structured selector with custom selector creator', () => {
const customSelectorCreator = createSelectorCreator(
defaultMemoize,
(a, b) => a === b
);
const selector = createStructuredSelector({
x: state => state.a,
y: state => state.b
}, customSelectorCreator);
let firstResult = selector({a: 1, b: 2});
assert.deepEqual(firstResult, {x: 1, y: 2});
assert.strictEqual(selector({a: 1, b: 2}), firstResult);
assert.deepEqual(selector({a: 2, b: 2}), {x: 2, y: 2});
});
});
|
const crypto = require(`crypto`)
const select = require(`unist-util-select`)
const sharp = require(`sharp`)
const axios = require(`axios`)
const _ = require(`lodash`)
const Promise = require(`bluebird`)
const cheerio = require(`cheerio`)
const { buildResponsiveSizes } = require(`./utils`)
// If the image is hosted on contentful
// 1. Find the image file
// 2. Find the image's size
// 3. Filter out any responsive image sizes that are greater than the image's width
// 4. Create the responsive images.
// 5. Set the html w/ aspect ratio helper.
module.exports = async (
{ files, markdownNode, markdownAST, pathPrefix, getNode, reporter, cache },
pluginOptions
) => {
const defaults = {
maxWidth: 650,
wrapperStyle: ``,
backgroundColor: `white`,
linkImagesToOriginal: true,
showCaptions: false,
pathPrefix,
}
// This will only work for markdown syntax image tags
const markdownImageNodes = select(markdownAST, `image`)
// This will also allow the use of html image tags
const rawHtmlNodes = select(markdownAST, `html`)
const generateImagesAndUpdateNode = async function(node, resolve) {
// Ignore if it is not contentful image
if (node.url.indexOf(`images.ctfassets.net`) === -1) {
return resolve()
}
const srcSplit = node.url.split(`/`)
const fileName = srcSplit[srcSplit.length - 1]
const options = _.defaults(pluginOptions, defaults)
const optionsHash = crypto
.createHash(`md5`)
.update(JSON.stringify(options))
.digest(`hex`)
const cacheKey = `remark-images-ctf-${fileName}-${optionsHash}`
let cahedRawHTML = await cache.get(cacheKey)
if (cahedRawHTML) {
return cahedRawHTML
}
const metaReader = sharp()
const response = await axios({
method: `GET`,
url: `https:${node.url}`, // for some reason there is a './' prefix
responseType: `stream`,
})
response.data.pipe(metaReader)
const metadata = await metaReader.metadata()
response.data.destroy()
const responsiveSizesResult = await buildResponsiveSizes({
metadata,
imageUrl: `https:${node.url}`,
options,
})
// Calculate the paddingBottom %
const ratio = `${(1 / responsiveSizesResult.aspectRatio) * 100}%`
const fallbackSrc = `https${node.url}`
const srcSet = responsiveSizesResult.srcSet
const presentationWidth = responsiveSizesResult.presentationWidth
// Generate default alt tag
const originalImg = node.url
const fileNameNoExt = fileName.replace(/\.[^/.]+$/, ``)
const defaultAlt = fileNameNoExt.replace(/[^A-Z0-9]/gi, ` `)
// Construct new image node w/ aspect ratio placeholder
let rawHTML = `
<span
class="gatsby-resp-image-wrapper"
style="position: relative; display: block; ${
options.wrapperStyle
}; max-width: ${presentationWidth}px; margin-left: auto; margin-right: auto;"
>
<span
class="gatsby-resp-image-background-image"
style="padding-bottom: ${ratio}; position: relative; bottom: 0; left: 0; background-image: url('${
responsiveSizesResult.base64
}'); background-size: cover; display: block;"
>
<img
class="gatsby-resp-image-image"
style="width: 100%; height: 100%; margin: 0; vertical-align: middle; position: absolute; top: 0; left: 0; box-shadow: inset 0px 0px 0px 400px ${
options.backgroundColor
};"
alt="${node.alt ? node.alt : defaultAlt}"
title="${node.title ? node.title : ``}"
src="${fallbackSrc}"
srcset="${srcSet}"
sizes="${responsiveSizesResult.sizes}"
/>
</span>
</span>
`
// Make linking to original image optional.
if (options.linkImagesToOriginal) {
rawHTML = `
<a
class="gatsby-resp-image-link"
href="${originalImg}"
style="display: block"
target="_blank"
rel="noopener"
>
${rawHTML}
</a>
`
}
// Wrap in figure and use title as caption
if (options.showCaptions && node.title) {
rawHTML = `
<figure class="gatsby-resp-image-figure">
${rawHTML}
<figcaption class="gatsby-resp-image-figcaption">${node.title}</figcaption>
</figure>`
}
await cache.set(cacheKey, rawHTML)
return rawHTML
}
return Promise.all(
// Simple because there is no nesting in markdown
markdownImageNodes.map(
node =>
new Promise(async (resolve, reject) => {
if (node.url.indexOf(`images.ctfassets.net`) !== -1) {
const rawHTML = await generateImagesAndUpdateNode(node, resolve)
if (rawHTML) {
// Replace the image node with an inline HTML node.
node.type = `html`
node.value = rawHTML
}
return resolve(node)
} else {
// Image isn't relative so there's nothing for us to do.
return resolve()
}
})
)
).then(markdownImageNodes =>
// HTML image node stuff
Promise.all(
// Complex because HTML nodes can contain multiple images
rawHtmlNodes.map(
node =>
new Promise(async (resolve, reject) => {
if (!node.value) {
return resolve()
}
const $ = cheerio.load(node.value)
if ($(`img`).length === 0) {
// No img tags
return resolve()
}
let imageRefs = []
$(`img`).each(function() {
imageRefs.push($(this))
})
for (let thisImg of imageRefs) {
// Get the details we need.
let formattedImgTag = {}
formattedImgTag.url = thisImg.attr(`src`)
formattedImgTag.title = thisImg.attr(`title`)
formattedImgTag.alt = thisImg.attr(`alt`)
if (!formattedImgTag.url) {
return resolve()
}
if (formattedImgTag.url.indexOf(`images.ctfassets.net`) !== -1) {
const rawHTML = await generateImagesAndUpdateNode(
formattedImgTag,
resolve
)
if (rawHTML) {
// Replace the image string
thisImg.replaceWith(rawHTML)
} else {
return resolve()
}
}
}
// Replace the image node with an inline HTML node.
node.type = `html`
node.value = $(`body`).html() // fix for cheerio v1
return resolve(node)
})
)
).then(htmlImageNodes =>
markdownImageNodes.concat(htmlImageNodes).filter(node => !!node)
)
)
}
|
var assert = require('assert');
var common = require('../../common');
var path = common.fixtures + '/data.csv';
var table = 'load_data_test';
var newline = common.detectNewline(path);
common.getTestConnection({localInfile: false}, function (err, connection) {
assert.ifError(err);
common.useTestDb(connection);
connection.query([
'CREATE TEMPORARY TABLE ?? (',
'`id` int(11) unsigned NOT NULL AUTO_INCREMENT,',
'`title` varchar(400),',
'PRIMARY KEY (`id`)',
') ENGINE=InnoDB DEFAULT CHARSET=utf8'
].join('\n'), [table], assert.ifError);
var sql =
'LOAD DATA LOCAL INFILE ? INTO TABLE ?? CHARACTER SET utf8 ' +
'FIELDS TERMINATED BY ? ' +
'LINES TERMINATED BY ? ' +
'(id, title)';
connection.query(sql, [path, table, ',', newline], function (err) {
assert.ok(err);
assert.equal(err.code, 'ER_NOT_ALLOWED_COMMAND');
});
connection.query('SELECT * FROM ??', [table], function (err, rows) {
assert.ifError(err);
assert.equal(rows.length, 0);
});
connection.end(assert.ifError);
});
|
var Event = require('../../events/Event');
var LoaderStartEvent = function (loader)
{
Event.call(this, 'LOADER_START_EVENT');
this.loader = loader;
};
LoaderStartEvent.prototype = Object.create(Event.prototype);
LoaderStartEvent.prototype.constructor = LoaderStartEvent;
module.exports = LoaderStartEvent;
|
/* global chrome, BugMagnet */
chrome.runtime.onMessage.addListener(function (request /*, sender, sendResponse */) {
'use strict';
BugMagnet.executeRequest(request);
});
|
var dom_adapter_1 = require('angular2/src/dom/dom_adapter');
var collection_1 = require('angular2/src/facade/collection');
var lang_1 = require('angular2/src/facade/lang');
/**
* This file is a port of shadowCSS from webcomponents.js to AtScript.
*
* Please make sure to keep to edits in sync with the source file.
*
* Source:
* https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
*
* The original file level comment is reproduced below
*/
/*
This is a limited shim for ShadowDOM css styling.
https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles
The intention here is to support only the styling features which can be
relatively simply implemented. The goal is to allow users to avoid the
most obvious pitfalls and do so without compromising performance significantly.
For ShadowDOM styling that's not covered here, a set of best practices
can be provided that should allow users to accomplish more complex styling.
The following is a list of specific ShadowDOM styling features and a brief
discussion of the approach used to shim.
Shimmed features:
* :host, :host-context: ShadowDOM allows styling of the shadowRoot's host
element using the :host rule. To shim this feature, the :host styles are
reformatted and prefixed with a given scope name and promoted to a
document level stylesheet.
For example, given a scope name of .foo, a rule like this:
:host {
background: red;
}
}
becomes:
.foo {
background: red;
}
* encapsultion: Styles defined within ShadowDOM, apply only to
dom inside the ShadowDOM. Polymer uses one of two techniques to imlement
this feature.
By default, rules are prefixed with the host element tag name
as a descendant selector. This ensures styling does not leak out of the 'top'
of the element's ShadowDOM. For example,
div {
font-weight: bold;
}
becomes:
x-foo div {
font-weight: bold;
}
becomes:
Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then
selectors are scoped by adding an attribute selector suffix to each
simple selector that contains the host element tag name. Each element
in the element's ShadowDOM template is also given the scope attribute.
Thus, these rules match only elements that have the scope attribute.
For example, given a scope name of x-foo, a rule like this:
div {
font-weight: bold;
}
becomes:
div[x-foo] {
font-weight: bold;
}
Note that elements that are dynamically added to a scope must have the scope
selector added to them manually.
* upper/lower bound encapsulation: Styles which are defined outside a
shadowRoot should not cross the ShadowDOM boundary and should not apply
inside a shadowRoot.
This styling behavior is not emulated. Some possible ways to do this that
were rejected due to complexity and/or performance concerns include: (1) reset
every possible property for every possible selector for a given scope name;
(2) re-implement css in javascript.
As an alternative, users should make sure to use selectors
specific to the scope in which they are working.
* ::distributed: This behavior is not emulated. It's often not necessary
to style the contents of a specific insertion point and instead, descendants
of the host element can be styled selectively. Users can also create an
extra node around an insertion point and style that node's contents
via descendent selectors. For example, with a shadowRoot like this:
<style>
::content(div) {
background: red;
}
</style>
<content></content>
could become:
<style>
/ *@polyfill .content-container div * /
::content(div) {
background: red;
}
</style>
<div class="content-container">
<content></content>
</div>
Note the use of @polyfill in the comment above a ShadowDOM specific style
declaration. This is a directive to the styling shim to use the selector
in comments in lieu of the next selector when running under polyfill.
*/
var ShadowCss = (function () {
function ShadowCss() {
this.strictStyling = true;
}
/*
* Shim a style element with the given selector. Returns cssText that can
* be included in the document via WebComponents.ShadowCSS.addCssToDocument(css).
*/
ShadowCss.prototype.shimStyle = function (style, selector, hostSelector) {
if (hostSelector === void 0) { hostSelector = ''; }
var cssText = dom_adapter_1.DOM.getText(style);
return this.shimCssText(cssText, selector, hostSelector);
};
/*
* Shim some cssText with the given selector. Returns cssText that can
* be included in the document via WebComponents.ShadowCSS.addCssToDocument(css).
*
* When strictStyling is true:
* - selector is the attribute added to all elements inside the host,
* - hostSelector is the attribute added to the host itself.
*/
ShadowCss.prototype.shimCssText = function (cssText, selector, hostSelector) {
if (hostSelector === void 0) { hostSelector = ''; }
cssText = this._insertDirectives(cssText);
return this._scopeCssText(cssText, selector, hostSelector);
};
ShadowCss.prototype._insertDirectives = function (cssText) {
cssText = this._insertPolyfillDirectivesInCssText(cssText);
return this._insertPolyfillRulesInCssText(cssText);
};
/*
* Process styles to convert native ShadowDOM rules that will trip
* up the css parser; we rely on decorating the stylesheet with inert rules.
*
* For example, we convert this rule:
*
* polyfill-next-selector { content: ':host menu-item'; }
* ::content menu-item {
*
* to this:
*
* scopeName menu-item {
*
**/
ShadowCss.prototype._insertPolyfillDirectivesInCssText = function (cssText) {
// Difference with webcomponents.js: does not handle comments
return lang_1.StringWrapper.replaceAllMapped(cssText, _cssContentNextSelectorRe, function (m) { return m[1] + '{'; });
};
/*
* Process styles to add rules which will only apply under the polyfill
*
* For example, we convert this rule:
*
* polyfill-rule {
* content: ':host menu-item';
* ...
* }
*
* to this:
*
* scopeName menu-item {...}
*
**/
ShadowCss.prototype._insertPolyfillRulesInCssText = function (cssText) {
// Difference with webcomponents.js: does not handle comments
return lang_1.StringWrapper.replaceAllMapped(cssText, _cssContentRuleRe, function (m) {
var rule = m[0];
rule = lang_1.StringWrapper.replace(rule, m[1], '');
rule = lang_1.StringWrapper.replace(rule, m[2], '');
return m[3] + rule;
});
};
/* Ensure styles are scoped. Pseudo-scoping takes a rule like:
*
* .foo {... }
*
* and converts this to
*
* scopeName .foo { ... }
*/
ShadowCss.prototype._scopeCssText = function (cssText, scopeSelector, hostSelector) {
var _this = this;
var unscoped = this._extractUnscopedRulesFromCssText(cssText);
cssText = this._insertPolyfillHostInCssText(cssText);
cssText = this._convertColonHost(cssText);
cssText = this._convertColonHostContext(cssText);
cssText = this._convertShadowDOMSelectors(cssText);
if (lang_1.isPresent(scopeSelector)) {
_withCssRules(cssText, function (rules) { cssText = _this._scopeRules(rules, scopeSelector, hostSelector); });
}
cssText = cssText + '\n' + unscoped;
return cssText.trim();
};
/*
* Process styles to add rules which will only apply under the polyfill
* and do not process via CSSOM. (CSSOM is destructive to rules on rare
* occasions, e.g. -webkit-calc on Safari.)
* For example, we convert this rule:
*
* @polyfill-unscoped-rule {
* content: 'menu-item';
* ... }
*
* to this:
*
* menu-item {...}
*
**/
ShadowCss.prototype._extractUnscopedRulesFromCssText = function (cssText) {
// Difference with webcomponents.js: does not handle comments
var r = '', m;
var matcher = lang_1.RegExpWrapper.matcher(_cssContentUnscopedRuleRe, cssText);
while (lang_1.isPresent(m = lang_1.RegExpMatcherWrapper.next(matcher))) {
var rule = m[0];
rule = lang_1.StringWrapper.replace(rule, m[2], '');
rule = lang_1.StringWrapper.replace(rule, m[1], m[3]);
r = rule + '\n\n';
}
return r;
};
/*
* convert a rule like :host(.foo) > .bar { }
*
* to
*
* scopeName.foo > .bar
*/
ShadowCss.prototype._convertColonHost = function (cssText) {
return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);
};
/*
* convert a rule like :host-context(.foo) > .bar { }
*
* to
*
* scopeName.foo > .bar, .foo scopeName > .bar { }
*
* and
*
* :host-context(.foo:host) .bar { ... }
*
* to
*
* scopeName.foo .bar { ... }
*/
ShadowCss.prototype._convertColonHostContext = function (cssText) {
return this._convertColonRule(cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);
};
ShadowCss.prototype._convertColonRule = function (cssText, regExp, partReplacer) {
// p1 = :host, p2 = contents of (), p3 rest of rule
return lang_1.StringWrapper.replaceAllMapped(cssText, regExp, function (m) {
if (lang_1.isPresent(m[2])) {
var parts = m[2].split(','), r = [];
for (var i = 0; i < parts.length; i++) {
var p = parts[i];
if (lang_1.isBlank(p))
break;
p = p.trim();
collection_1.ListWrapper.push(r, partReplacer(_polyfillHostNoCombinator, p, m[3]));
}
return r.join(',');
}
else {
return _polyfillHostNoCombinator + m[3];
}
});
};
ShadowCss.prototype._colonHostContextPartReplacer = function (host, part, suffix) {
if (lang_1.StringWrapper.contains(part, _polyfillHost)) {
return this._colonHostPartReplacer(host, part, suffix);
}
else {
return host + part + suffix + ', ' + part + ' ' + host + suffix;
}
};
ShadowCss.prototype._colonHostPartReplacer = function (host, part, suffix) {
return host + lang_1.StringWrapper.replace(part, _polyfillHost, '') + suffix;
};
/*
* Convert combinators like ::shadow and pseudo-elements like ::content
* by replacing with space.
*/
ShadowCss.prototype._convertShadowDOMSelectors = function (cssText) {
for (var i = 0; i < _shadowDOMSelectorsRe.length; i++) {
cssText = lang_1.StringWrapper.replaceAll(cssText, _shadowDOMSelectorsRe[i], ' ');
}
return cssText;
};
// change a selector like 'div' to 'name div'
ShadowCss.prototype._scopeRules = function (cssRules, scopeSelector, hostSelector) {
var cssText = '';
if (lang_1.isPresent(cssRules)) {
for (var i = 0; i < cssRules.length; i++) {
var rule = cssRules[i];
if (dom_adapter_1.DOM.isStyleRule(rule) || dom_adapter_1.DOM.isPageRule(rule)) {
cssText += this._scopeSelector(rule.selectorText, scopeSelector, hostSelector, this.strictStyling) +
' {\n';
cssText += this._propertiesFromRule(rule) + '\n}\n\n';
}
else if (dom_adapter_1.DOM.isMediaRule(rule)) {
cssText += '@media ' + rule.media.mediaText + ' {\n';
cssText += this._scopeRules(rule.cssRules, scopeSelector, hostSelector);
cssText += '\n}\n\n';
}
else {
// KEYFRAMES_RULE in IE throws when we query cssText
// when it contains a -webkit- property.
// if this happens, we fallback to constructing the rule
// from the CSSRuleSet
// https://connect.microsoft.com/IE/feedbackdetail/view/955703/accessing-csstext-of-a-keyframe-rule-that-contains-a-webkit-property-via-cssom-generates-exception
try {
if (lang_1.isPresent(rule.cssText)) {
cssText += rule.cssText + '\n\n';
}
}
catch (x) {
if (dom_adapter_1.DOM.isKeyframesRule(rule) && lang_1.isPresent(rule.cssRules)) {
cssText += this._ieSafeCssTextFromKeyFrameRule(rule);
}
}
}
}
}
return cssText;
};
ShadowCss.prototype._ieSafeCssTextFromKeyFrameRule = function (rule) {
var cssText = '@keyframes ' + rule.name + ' {';
for (var i = 0; i < rule.cssRules.length; i++) {
var r = rule.cssRules[i];
cssText += ' ' + r.keyText + ' {' + r.style.cssText + '}';
}
cssText += ' }';
return cssText;
};
ShadowCss.prototype._scopeSelector = function (selector, scopeSelector, hostSelector, strict) {
var r = [], parts = selector.split(',');
for (var i = 0; i < parts.length; i++) {
var p = parts[i];
p = p.trim();
if (this._selectorNeedsScoping(p, scopeSelector)) {
p = strict && !lang_1.StringWrapper.contains(p, _polyfillHostNoCombinator) ?
this._applyStrictSelectorScope(p, scopeSelector) :
this._applySelectorScope(p, scopeSelector, hostSelector);
}
collection_1.ListWrapper.push(r, p);
}
return r.join(', ');
};
ShadowCss.prototype._selectorNeedsScoping = function (selector, scopeSelector) {
var re = this._makeScopeMatcher(scopeSelector);
return !lang_1.isPresent(lang_1.RegExpWrapper.firstMatch(re, selector));
};
ShadowCss.prototype._makeScopeMatcher = function (scopeSelector) {
var lre = lang_1.RegExpWrapper.create('\\[');
var rre = lang_1.RegExpWrapper.create('\\]');
scopeSelector = lang_1.StringWrapper.replaceAll(scopeSelector, lre, '\\[');
scopeSelector = lang_1.StringWrapper.replaceAll(scopeSelector, rre, '\\]');
return lang_1.RegExpWrapper.create('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
};
ShadowCss.prototype._applySelectorScope = function (selector, scopeSelector, hostSelector) {
// Difference from webcomponentsjs: scopeSelector could not be an array
return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);
};
// scope via name and [is=name]
ShadowCss.prototype._applySimpleSelectorScope = function (selector, scopeSelector, hostSelector) {
if (lang_1.isPresent(lang_1.RegExpWrapper.firstMatch(_polyfillHostRe, selector))) {
var replaceBy = this.strictStyling ? "[" + hostSelector + "]" : scopeSelector;
selector = lang_1.StringWrapper.replace(selector, _polyfillHostNoCombinator, replaceBy);
return lang_1.StringWrapper.replaceAll(selector, _polyfillHostRe, replaceBy + ' ');
}
else {
return scopeSelector + ' ' + selector;
}
};
// return a selector with [name] suffix on each simple selector
// e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]
ShadowCss.prototype._applyStrictSelectorScope = function (selector, scopeSelector) {
var isRe = lang_1.RegExpWrapper.create('\\[is=([^\\]]*)\\]');
scopeSelector = lang_1.StringWrapper.replaceAllMapped(scopeSelector, isRe, function (m) { return m[1]; });
var splits = [' ', '>', '+', '~'], scoped = selector, attrName = '[' + scopeSelector + ']';
for (var i = 0; i < splits.length; i++) {
var sep = splits[i];
var parts = scoped.split(sep);
scoped = collection_1.ListWrapper.map(parts, function (p) {
// remove :host since it should be unnecessary
var t = lang_1.StringWrapper.replaceAll(p.trim(), _polyfillHostRe, '');
if (t.length > 0 && !collection_1.ListWrapper.contains(splits, t) &&
!lang_1.StringWrapper.contains(t, attrName)) {
var re = lang_1.RegExpWrapper.create('([^:]*)(:*)(.*)');
var m = lang_1.RegExpWrapper.firstMatch(re, t);
if (lang_1.isPresent(m)) {
p = m[1] + attrName + m[2] + m[3];
}
}
return p;
}).join(sep);
}
return scoped;
};
ShadowCss.prototype._insertPolyfillHostInCssText = function (selector) {
selector = lang_1.StringWrapper.replaceAll(selector, _colonHostContextRe, _polyfillHostContext);
selector = lang_1.StringWrapper.replaceAll(selector, _colonHostRe, _polyfillHost);
return selector;
};
ShadowCss.prototype._propertiesFromRule = function (rule) {
var cssText = rule.style.cssText;
// TODO(sorvell): Safari cssom incorrectly removes quotes from the content
// property. (https://bugs.webkit.org/show_bug.cgi?id=118045)
// don't replace attr rules
var attrRe = lang_1.RegExpWrapper.create('[\'"]+|attr');
if (rule.style.content.length > 0 &&
!lang_1.isPresent(lang_1.RegExpWrapper.firstMatch(attrRe, rule.style.content))) {
var contentRe = lang_1.RegExpWrapper.create('content:[^;]*;');
cssText =
lang_1.StringWrapper.replaceAll(cssText, contentRe, 'content: \'' + rule.style.content + '\';');
}
// TODO(sorvell): we can workaround this issue here, but we need a list
// of troublesome properties to fix https://github.com/Polymer/platform/issues/53
//
// inherit rules can be omitted from cssText
// TODO(sorvell): remove when Blink bug is fixed:
// https://code.google.com/p/chromium/issues/detail?id=358273
// var style = rule.style;
// for (var i = 0; i < style.length; i++) {
// var name = style.item(i);
// var value = style.getPropertyValue(name);
// if (value == 'initial') {
// cssText += name + ': initial; ';
// }
//}
return cssText;
};
return ShadowCss;
})();
exports.ShadowCss = ShadowCss;
var _cssContentNextSelectorRe = lang_1.RegExpWrapper.create('polyfill-next-selector[^}]*content:[\\s]*?[\'"](.*?)[\'"][;\\s]*}([^{]*?){', 'im');
var _cssContentRuleRe = lang_1.RegExpWrapper.create('(polyfill-rule)[^}]*(content:[\\s]*[\'"](.*?)[\'"])[;\\s]*[^}]*}', 'im');
var _cssContentUnscopedRuleRe = lang_1.RegExpWrapper.create('(polyfill-unscoped-rule)[^}]*(content:[\\s]*[\'"](.*?)[\'"])[;\\s]*[^}]*}', 'im');
var _polyfillHost = '-shadowcsshost';
// note: :host-context pre-processed to -shadowcsshostcontext.
var _polyfillHostContext = '-shadowcsscontext';
var _parenSuffix = ')(?:\\((' +
'(?:\\([^)(]*\\)|[^)(]*)+?' +
')\\))?([^,{]*)';
var _cssColonHostRe = lang_1.RegExpWrapper.create('(' + _polyfillHost + _parenSuffix, 'im');
var _cssColonHostContextRe = lang_1.RegExpWrapper.create('(' + _polyfillHostContext + _parenSuffix, 'im');
var _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
var _shadowDOMSelectorsRe = [
lang_1.RegExpWrapper.create('>>>'),
lang_1.RegExpWrapper.create('::shadow'),
lang_1.RegExpWrapper.create('::content'),
// Deprecated selectors
lang_1.RegExpWrapper.create('/deep/'),
lang_1.RegExpWrapper.create('/shadow-deep/'),
lang_1.RegExpWrapper.create('/shadow/'),
];
var _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$';
var _polyfillHostRe = lang_1.RegExpWrapper.create(_polyfillHost, 'im');
var _colonHostRe = lang_1.RegExpWrapper.create(':host', 'im');
var _colonHostContextRe = lang_1.RegExpWrapper.create(':host-context', 'im');
function _cssToRules(cssText) {
return dom_adapter_1.DOM.cssToRules(cssText);
}
function _withCssRules(cssText, callback) {
// Difference from webcomponentjs: remove the workaround for an old bug in Chrome
if (lang_1.isBlank(callback))
return;
var rules = _cssToRules(cssText);
callback(rules);
}
exports.__esModule = true;
//# sourceMappingURL=shadow_css.js.map |
import React from 'react'
import { render } from 'react-dom'
import { Provider } from 'react-redux'
import { combineReducers, createStore } from 'typed-redux'
import InputContainer from './components/Input/Container'
import CheckboxContainer from './components/Checkbox/Container'
import GreetContainer from './components/Greet/Container'
import * as reducers from './reducers'
const store = createStore(combineReducers(reducers));
const App = () => (
<div>
<InputContainer stateKey="name" />
<CheckboxContainer stateKey="remember" />
<GreetContainer stateKey="name" />
</div>
)
render(
<Provider store={store}>
<App />
</Provider>,
document.getElementById('root')
)
|
module.exports = function(grunt) {
require('grunt');
var config_file_name = 'config.json';
var auth_file_name = 'auth.json';
var config = { auth: {} };
if ( grunt.file.exists(config_file_name) ) {
config = grunt.file.readJSON('config.json');
config.js_files = grunt.file.expand(['src/javascript/**/*.js']);
config.ugly_files = grunt.file.expand(['deploy/app.min.*.js']);
config.css_files = grunt.file.expand( 'src/style/*.css' );
config.checksum = "<!= checksum !>";
config.js_contents = " ";
for (var i=0;i<config.js_files.length;i++) {
grunt.log.writeln( config.js_files[i]);
config.js_contents = config.js_contents + "\n" + grunt.file.read(config.js_files[i]);
}
config.style_contents = "";
for (var i=0;i<config.css_files.length;i++) {
grunt.log.writeln( config.css_files[i]);
config.style_contents = config.style_contents + "\n" + grunt.file.read(config.css_files[i]);
}
config.ugly_contents = "";
for ( var i=0;i<config.ugly_files;i++ ) {
grunt.file.read(config.ugly_files[i]);
}
}
if ( grunt.file.exists(auth_file_name) ) {
// grunt.log.writeln( config.js_contents );
var auth = grunt.file.readJSON(auth_file_name);
config.auth = auth
} else {
grunt.log.writeln("");
grunt.log.writeln("WARNING: Slow tests won't run without an auth.json file");
}
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
uglify: {
options: {
mangle: true
},
ugly: {
files: { 'deploy/app.min.js': config.js_files }
}
},
template: {
dev: {
src: 'templates/App-debug-tpl.html',
dest: 'App-debug.html',
engine: 'underscore',
variables: config
},
prod: {
src: 'templates/App-tpl.html',
dest: 'deploy/App.txt',
engine: 'underscore',
variables: config
},
ugly: {
src: 'templates/App-ugly-tpl.html',
dest: 'deploy/Ugly.txt',
engine: 'underscore',
variables: config
}
},
jasmine: {
fast: {
src: 'src/**/*.js',
options: {
specs: 'test/fast/*-spec.js',
helpers: 'test/fast/*Helper.js',
template: 'test/fast/custom.tmpl',
templateOptions: config,
keepRunner: true,
junit: {
path: 'test/logs/fast'
}
}
},
slow: {
src: 'src/**/*.js',
options: {
specs: 'test/slow/*-spec.js',
helpers: 'test/slow/*Helper.js',
template: 'test/slow/custom.tmpl',
templateOptions: config,
keepRunner: true,
timeout: 50000,
junit: {
path: 'test/logs/slow'
}
}
}
}
});
grunt.registerTask('setChecksum', 'Make a sloppy checksum', function() {
var fs = require('fs');
var chk = 0x12345678,
i;
var deploy_file = 'deploy/App.txt';
var file = grunt.file.read(deploy_file);
string = file.replace(/var CHECKSUM = .*;/,"");
string = string.replace(/\s/g,""); //Remove all whitespace from the string.
for (i = 0; i < string.length; i++) {
chk += (string.charCodeAt(i) * i);
}
grunt.log.writeln('sloppy checksum: ' + chk);
grunt.log.writeln('length: ' + string.length);
//
grunt.template.addDelimiters('square-brackets','[%','%]');
var output = grunt.template.process(file, { data: { checksum: chk }, delimiters: 'square-brackets' });
grunt.file.write(deploy_file,output);
});
//load
grunt.loadNpmTasks('grunt-templater');
grunt.loadNpmTasks('grunt-contrib-jasmine');
grunt.loadNpmTasks('grunt-contrib-uglify');
//tasks
grunt.registerTask('default', ['debug','build','ugly']);
// (uses all the files in src/javascript)
grunt.registerTask('build', "Create the html for deployment",['template:prod','setChecksum']);
//
grunt.registerTask('debug', "Create an html file that can run in its own tab", ['template:dev']);
//
grunt.registerTask('ugly', "Create the ugly html for deployment",['uglify:ugly','template:ugly']);
grunt.registerTask('test-fast', "Run tests that don't need to connect to Rally", ['jasmine:fast']);
grunt.registerTask('test-slow', "Run tests that need to connect to Rally", ['jasmine:slow']);
};
|
import React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<React.Fragment><path fill="none" d="M0 0h24v24H0V0z" /><path d="M21 5h2v14h-2zM17 5h2v14h-2zM14 5H2c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h12c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm-1 12H3V7h10v10z" /><circle cx="8" cy="9.94" r="1.95" /><path d="M11.89 15.35c0-1.3-2.59-1.95-3.89-1.95s-3.89.65-3.89 1.95V16h7.78v-.65z" /></React.Fragment>
, 'RecentActorsOutlined');
|
/**
* # Login.js
*
* This class is a little complicated as it handles multiple states.
*
*/
'use strict'
/**
* ## Imports
*
* Redux
*/
import { bindActionCreators } from 'redux'
import { connect } from 'react-redux'
/**
* The actions we need
*/
import * as authActions from '../reducers/auth/authActions'
import * as globalActions from '../reducers/global/globalActions'
/**
* Router actions
*/
import { Actions } from 'react-native-router-flux'
/**
* The Header will display a Image and support Hot Loading
*/
import Header from '../components/Header'
/**
* The ErrorAlert displays an alert for both ios & android
*/
import ErrorAlert from '../components/ErrorAlert'
/**
* The FormButton will change it's text between the 4 states as necessary
*/
import FormButton from '../components/FormButton'
/**
* The LoginForm does the heavy lifting of displaying the fields for
* textinput and displays the error messages
*/
import LoginForm from '../components/LoginForm'
/**
* The itemCheckbox will toggle the display of the password fields
*/
import ItemCheckbox from '../components/ItemCheckbox'
/**
* The necessary React components
*/
import React, {Component} from 'react'
import
{
StyleSheet,
ScrollView,
Text,
TouchableHighlight,
View
}
from 'react-native'
import Dimensions from 'Dimensions'
var {height, width} = Dimensions.get('window') // Screen dimensions in current orientation
/**
* The states were interested in
*/
const {
LOGIN,
REGISTER,
FORGOT_PASSWORD
} = require('../lib/constants').default
/**
* ## Styles
*/
var styles = StyleSheet.create({
container: {
flexDirection: 'column',
flex: 1
},
inputs: {
marginTop: 10,
marginBottom: 10,
marginLeft: 10,
marginRight: 10
},
forgotContainer: {
flexDirection: 'row',
justifyContent: 'space-between',
marginTop: 10,
marginLeft: 10,
marginRight: 10
}
})
/**
* ## Redux boilerplate
*/
function mapDispatchToProps (dispatch) {
return {
actions: bindActionCreators({ ...authActions, ...globalActions }, dispatch)
}
}
/**
* ### Translations
*/
var I18n = require('react-native-i18n')
import Translations from '../lib/Translations'
I18n.translations = Translations
class LoginRender extends Component {
constructor (props) {
super(props)
this.errorAlert = new ErrorAlert()
this.state = {
value: {
username: this.props.auth.form.fields.username,
email: this.props.auth.form.fields.email,
password: this.props.auth.form.fields.password,
passwordAgain: this.props.auth.form.fields.passwordAgain
}
}
}
/**
* ### componentWillReceiveProps
* As the properties are validated they will be set here.
*/
componentWillReceiveProps (nextprops) {
this.setState({
value: {
username: nextprops.auth.form.fields.username,
email: nextprops.auth.form.fields.email,
password: nextprops.auth.form.fields.password,
passwordAgain: nextprops.auth.form.fields.passwordAgain
}
})
}
/**
* ### onChange
*
* As the user enters keys, this is called for each key stroke.
* Rather then publish the rules for each of the fields, I find it
* better to display the rules required as long as the field doesn't
* meet the requirements.
* *Note* that the fields are validated by the authReducer
*/
onChange (value) {
if (value.username !== '') {
this.props.actions.onAuthFormFieldChange('username', value.username)
}
if (value.email !== '') {
this.props.actions.onAuthFormFieldChange('email', value.email)
}
if (value.password !== '') {
this.props.actions.onAuthFormFieldChange('password', value.password)
}
if (value.passwordAgain !== '') {
this.props.actions.onAuthFormFieldChange('passwordAgain', value.passwordAgain)
}
this.setState(
{value}
)
}
/**
* Get the appropriate message for the current action
* @param messageType FORGOT_PASSWORD, or LOGIN, or REGISTER
* @param actions the action for the message type
*/
getMessage (messageType, actions) {
let forgotPassword =
<TouchableHighlight
onPress={() => {
actions.forgotPasswordState()
Actions.ForgotPassword()
}} >
<Text>{I18n.t('LoginRender.forgot_password')}</Text>
</TouchableHighlight>
let alreadyHaveAccount =
<TouchableHighlight
onPress={() => {
actions.loginState()
Actions.Login()
}} >
<Text>{I18n.t('LoginRender.already_have_account')}</Text>
</TouchableHighlight>
let register =
<TouchableHighlight
onPress={() => {
actions.registerState()
Actions.Register()
}} >
<Text>{I18n.t('LoginRender.register')}</Text>
</TouchableHighlight>
switch (messageType) {
case FORGOT_PASSWORD:
return forgotPassword
case LOGIN:
return alreadyHaveAccount
case REGISTER:
return register
}
}
/**
* ### render
* Setup some default presentations and render
*/
render () {
var formType = this.props.formType
var loginButtonText = this.props.loginButtonText
var onButtonPress = this.props.onButtonPress
var displayPasswordCheckbox = this.props.displayPasswordCheckbox
var leftMessageType = this.props.leftMessageType
var rightMessageType = this.props.rightMessageType
var passwordCheckbox = <Text />
let leftMessage = this.getMessage(leftMessageType, this.props.actions)
let rightMessage = this.getMessage(rightMessageType, this.props.actions)
let self = this
// display the login / register / change password screens
this.errorAlert.checkError(this.props.auth.form.error)
/**
* Toggle the display of the Password and PasswordAgain fields
*/
if (displayPasswordCheckbox) {
passwordCheckbox =
<ItemCheckbox
text={I18n.t('LoginRender.show_password')}
disabled={this.props.auth.form.isFetching}
onCheck={() => {
this.props.actions.onAuthFormFieldChange('showPassword', true)
}}
onUncheck={() => {
this.props.actions.onAuthFormFieldChange('showPassword', false)
}}
/>
}
/**
* The LoginForm is now defined with the required fields. Just
* surround it with the Header and the navigation messages
* Note how the button too is disabled if we're fetching. The
* header props are mostly for support of Hot reloading.
* See the docs for Header for more info.
*/
return (
<View style={styles.container}>
<ScrollView horizontal={false} width={width} height={height}>
<View>
<Header isFetching={this.props.auth.form.isFetching}
showState={this.props.global.showState}
currentState={this.props.global.currentState}
onGetState={this.props.actions.getState}
onSetState={this.props.actions.setState} />
<View style={styles.inputs}>
<LoginForm
formType={formType}
form={this.props.auth.form}
value={this.state.value}
onChange={self.onChange.bind(self)} />
{passwordCheckbox}
</View>
<FormButton
isDisabled={!this.props.auth.form.isValid || this.props.auth.form.isFetching}
onPress={onButtonPress}
buttonText={loginButtonText} />
<View >
<View style={styles.forgotContainer}>
{leftMessage}
{rightMessage}
</View>
</View>
</View>
</ScrollView>
</View>
)
}
}
export default connect(null, mapDispatchToProps)(LoginRender)
|
require("ember-data/system/record_arrays/record_array");
var get = Ember.get, set = Ember.set;
DS.AdapterPopulatedRecordArray = DS.RecordArray.extend({
query: null,
replace: function() {
var type = get(this, 'type').toString();
throw new Error("The result of a server query (on " + type + ") is immutable.");
},
load: function(array) {
var store = get(this, 'store'), type = get(this, 'type');
var clientIds = store.loadMany(type, array).clientIds;
this.beginPropertyChanges();
set(this, 'content', Ember.A(clientIds));
set(this, 'isLoaded', true);
this.endPropertyChanges();
this.trigger('didLoad');
}
});
|
/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow
* @format
*/
'use strict';
const areEqual = require('areEqual');
const deepFreeze = require('../util/deepFreeze');
const invariant = require('invariant');
const warning = require('warning');
const {
ID_KEY,
REF_KEY,
REFS_KEY,
TYPENAME_KEY,
UNPUBLISH_FIELD_SENTINEL,
} = require('./RelayStoreUtils');
import type {Record} from '../util/RelayCombinedEnvironmentTypes';
import type {DataID} from '../util/RelayRuntimeTypes';
/**
* @public
*
* Low-level record manipulation methods.
*
* A note about perf: we use long-hand property access rather than computed
* properties in this file for speed ie.
*
* const object = {};
* object[KEY] = value;
* record[storageKey] = object;
*
* instead of:
*
* record[storageKey] = {
* [KEY]: value,
* };
*
* The latter gets transformed by Babel into something like:
*
* function _defineProperty(obj, key, value) {
* if (key in obj) {
* Object.defineProperty(obj, key, {
* value: value,
* enumerable: true,
* configurable: true,
* writable: true,
* });
* } else {
* obj[key] = value;
* }
* return obj;
* }
*
* record[storageKey] = _defineProperty({}, KEY, value);
*
* A quick benchmark shows that computed property access is an order of
* magnitude slower (times in seconds for 100,000 iterations):
*
* best avg sd
* computed 0.02175 0.02292 0.00113
* manual 0.00110 0.00123 0.00008
*/
/**
* @public
*
* Clone a record.
*/
function clone(record: Record): Record {
return {
...record,
};
}
/**
* @public
*
* Copies all fields from `source` to `sink`, excluding `__id` and `__typename`.
*
* NOTE: This function does not treat `id` specially. To preserve the id,
* manually reset it after calling this function. Also note that values are
* copied by reference and not value; callers should ensure that values are
* copied on write.
*/
function copyFields(source: Record, sink: Record): void {
for (const key in source) {
if (source.hasOwnProperty(key)) {
if (key !== ID_KEY && key !== TYPENAME_KEY) {
sink[key] = source[key];
}
}
}
}
/**
* @public
*
* Create a new record.
*/
function create(dataID: DataID, typeName: string): Record {
// See perf note above for why we aren't using computed property access.
const record = {};
record[ID_KEY] = dataID;
record[TYPENAME_KEY] = typeName;
return record;
}
/**
* @public
*
* Get the record's `id` if available or the client-generated identifier.
*/
function getDataID(record: Record): DataID {
return (record[ID_KEY]: any);
}
/**
* @public
*
* Get the concrete type of the record.
*/
function getType(record: Record): string {
return (record[TYPENAME_KEY]: any);
}
/**
* @public
*
* Get a scalar (non-link) field value.
*/
function getValue(record: Record, storageKey: string): mixed {
const value = record[storageKey];
if (value && typeof value === 'object') {
invariant(
!value.hasOwnProperty(REF_KEY) && !value.hasOwnProperty(REFS_KEY),
'RelayModernRecord.getValue(): Expected a scalar (non-link) value for `%s.%s` ' +
'but found %s.',
record[ID_KEY],
storageKey,
value.hasOwnProperty(REF_KEY)
? 'a linked record'
: 'plural linked records',
);
}
return value;
}
/**
* @public
*
* Get the value of a field as a reference to another record. Throws if the
* field has a different type.
*/
function getLinkedRecordID(record: Record, storageKey: string): ?DataID {
const link = record[storageKey];
if (link == null) {
return link;
}
invariant(
typeof link === 'object' && link && typeof link[REF_KEY] === 'string',
'RelayModernRecord.getLinkedRecordID(): Expected `%s.%s` to be a linked ID, ' +
'was `%s`.',
record[ID_KEY],
storageKey,
JSON.stringify(link),
);
return link[REF_KEY];
}
/**
* @public
*
* Get the value of a field as a list of references to other records. Throws if
* the field has a different type.
*/
function getLinkedRecordIDs(
record: Record,
storageKey: string,
): ?Array<?DataID> {
const links = record[storageKey];
if (links == null) {
return links;
}
invariant(
typeof links === 'object' && Array.isArray(links[REFS_KEY]),
'RelayModernRecord.getLinkedRecordIDs(): Expected `%s.%s` to contain an array ' +
'of linked IDs, got `%s`.',
record[ID_KEY],
storageKey,
JSON.stringify(links),
);
// assume items of the array are ids
return (links[REFS_KEY]: any);
}
/**
* @public
*
* Compares the fields of a previous and new record, returning either the
* previous record if all fields are equal or a new record (with merged fields)
* if any fields have changed.
*/
function update(prevRecord: Record, nextRecord: Record): Record {
if (__DEV__) {
const prevID = getDataID(prevRecord);
const nextID = getDataID(nextRecord);
warning(
prevID === nextID,
'RelayModernRecord: Invalid record update, expected both versions of ' +
'the record to have the same id, got `%s` and `%s`.',
prevID,
nextID,
);
// note: coalesce null/undefined to null
const prevType = getType(prevRecord) ?? null;
const nextType = getType(nextRecord) ?? null;
warning(
prevType === nextType,
'RelayModernRecord: Invalid record update, expected both versions of ' +
'record `%s` to have the same `%s` but got conflicting types `%s` ' +
'and `%s`. The GraphQL server likely violated the globally unique ' +
'id requirement by returning the same id for different objects.',
prevID,
TYPENAME_KEY,
prevType,
nextType,
);
}
let updated: Record | null = null;
const keys = Object.keys(nextRecord);
for (let ii = 0; ii < keys.length; ii++) {
const key = keys[ii];
if (updated || !areEqual(prevRecord[key], nextRecord[key])) {
updated = updated !== null ? updated : {...prevRecord};
if (nextRecord[key] !== UNPUBLISH_FIELD_SENTINEL) {
updated[key] = nextRecord[key];
} else {
delete updated[key];
}
}
}
return updated !== null ? updated : prevRecord;
}
/**
* @public
*
* Returns a new record with the contents of the given records. Fields in the
* second record will overwrite identical fields in the first record.
*/
function merge(record1: Record, record2: Record): Record {
if (__DEV__) {
const prevID = getDataID(record1);
const nextID = getDataID(record2);
warning(
prevID === nextID,
'RelayModernRecord: Invalid record merge, expected both versions of ' +
'the record to have the same id, got `%s` and `%s`.',
prevID,
nextID,
);
// note: coalesce null/undefined to null
const prevType = getType(record1) ?? null;
const nextType = getType(record2) ?? null;
warning(
prevType === nextType,
'RelayModernRecord: Invalid record merge, expected both versions of ' +
'record `%s` to have the same `%s` but got conflicting types `%s` ' +
'and `%s`. The GraphQL server likely violated the globally unique ' +
'id requirement by returning the same id for different objects.',
prevID,
TYPENAME_KEY,
prevType,
nextType,
);
}
return Object.assign({}, record1, record2);
}
/**
* @public
*
* Prevent modifications to the record. Attempts to call `set*` functions on a
* frozen record will fatal at runtime.
*/
function freeze(record: Record): void {
deepFreeze(record);
}
/**
* @public
*
* Set the value of a storageKey to a scalar.
*/
function setValue(record: Record, storageKey: string, value: mixed): void {
if (__DEV__) {
const prevID = getDataID(record);
if (storageKey === ID_KEY) {
warning(
prevID === value,
'RelayModernRecord: Invalid field update, expected both versions of ' +
'the record to have the same id, got `%s` and `%s`.',
prevID,
value,
);
} else if (storageKey === TYPENAME_KEY) {
// note: coalesce null/undefined to null
const prevType = getType(record) ?? null;
const nextType = value ?? null;
warning(
prevType === nextType,
'RelayModernRecord: Invalid field update, expected both versions of ' +
'record `%s` to have the same `%s` but got conflicting types `%s` ' +
'and `%s`. The GraphQL server likely violated the globally unique ' +
'id requirement by returning the same id for different objects.',
prevID,
TYPENAME_KEY,
prevType,
nextType,
);
}
}
record[storageKey] = value;
}
/**
* @public
*
* Set the value of a field to a reference to another record.
*/
function setLinkedRecordID(
record: Record,
storageKey: string,
linkedID: DataID,
): void {
// See perf note above for why we aren't using computed property access.
const link = {};
link[REF_KEY] = linkedID;
record[storageKey] = link;
}
/**
* @public
*
* Set the value of a field to a list of references other records.
*/
function setLinkedRecordIDs(
record: Record,
storageKey: string,
linkedIDs: Array<?DataID>,
): void {
// See perf note above for why we aren't using computed property access.
const links = {};
links[REFS_KEY] = linkedIDs;
record[storageKey] = links;
}
module.exports = {
clone,
copyFields,
create,
freeze,
getDataID,
getLinkedRecordID,
getLinkedRecordIDs,
getType,
getValue,
merge,
setValue,
setLinkedRecordID,
setLinkedRecordIDs,
update,
};
|
version https://git-lfs.github.com/spec/v1
oid sha256:dc940ea29de0273e92f0071e7c0bab9ab1e958914d4c8c7ca602af8da78841a9
size 1643
|
'use strict';
(function() {
// Music Controller Spec
describe('Music Controller Tests', function() {
// Initialize global variables
var MusicController,
scope,
$httpBackend,
$stateParams,
$location;
// The $resource service augments the response object with methods for updating and deleting the resource.
// If we were to use the standard toEqual matcher, our tests would fail because the test values would not match
// the responses exactly. To solve the problem, we define a new toEqualData Jasmine matcher.
// When the toEqualData matcher compares two objects, it takes only object properties into
// account and ignores methods.
beforeEach(function() {
jasmine.addMatchers({
toEqualData: function(util, customEqualityTesters) {
return {
compare: function(actual, expected) {
return {
pass: angular.equals(actual, expected)
};
}
};
}
});
});
// Then we can start by loading the main application module
beforeEach(module(ApplicationConfiguration.applicationModuleName));
// The injector ignores leading and trailing underscores here (i.e. _$httpBackend_).
// This allows us to inject a service but then attach it to a variable
// with the same name as the service.
beforeEach(inject(function($controller, $rootScope, _$location_, _$stateParams_, _$httpBackend_) {
// Set a new global scope
scope = $rootScope.$new();
// Point global variables to injected services
$stateParams = _$stateParams_;
$httpBackend = _$httpBackend_;
$location = _$location_;
// Initialize the Music controller.
MusicController = $controller('MusicController', {
$scope: scope
});
}));
it('$scope.find() should create an array with at least one Music object fetched from XHR', inject(function(Music) {
// Create sample Music using the Music service
var sampleMusic = new Music({
name: 'New Music'
});
// Create a sample Music array that includes the new Music
sampleMusic = [sampleMusic];
// Set GET response
$httpBackend.expectGET('music').respond(sampleMusic);
// Run controller functionality
scope.find();
$httpBackend.flush();
// Test scope value
expect(scope.music).toEqualData(sampleMusic);
}));
it('$scope.findOne() should create an array with one Music object fetched from XHR using a musicId URL parameter', inject(function(Music) {
// Define a sample Music object
var sampleMusic = new Music({
name: 'New Music'
});
// Set the URL parameter
$stateParams.musicId = '525a8422f6d0f87f0e407a33';
// Set GET response
$httpBackend.expectGET(/music\/([0-9a-fA-F]{24})$/).respond(sampleMusic);
// Run controller functionality
scope.findOne();
$httpBackend.flush();
// Test scope value
expect(scope.music).toEqualData(sampleMusic);
}));
it('$scope.create() with valid form data should send a POST request with the form input values and then locate to new object URL', inject(function(Music) {
// Create a sample Music object
var sampleMusicPostData = new Music({
name: 'New Music'
});
// Create a sample Music response
var sampleMusicResponse = new Music({
_id: '525cf20451979dea2c000001',
name: 'New Music'
});
// Fixture mock form input values
scope.name = 'New Music';
// Set POST response
$httpBackend.expectPOST('music', sampleMusicPostData).respond(sampleMusicResponse);
// Run controller functionality
scope.create();
$httpBackend.flush();
// Test form inputs are reset
expect(scope.name).toEqual('');
// Test URL redirection after the Music was created
expect($location.path()).toBe('/music/' + sampleMusicResponse._id);
}));
it('$scope.update() should update a valid Music', inject(function(Music) {
// Define a sample Music put data
var sampleMusicPutData = new Music({
_id: '525cf20451979dea2c000001',
name: 'New Music'
});
// Mock Music in scope
scope.music = sampleMusicPutData;
// Set PUT response
$httpBackend.expectPUT(/music\/([0-9a-fA-F]{24})$/).respond();
// Run controller functionality
scope.update();
$httpBackend.flush();
// Test URL location to new object
expect($location.path()).toBe('/music/' + sampleMusicPutData._id);
}));
it('$scope.remove() should send a DELETE request with a valid musicId and remove the Music from the scope', inject(function(Music) {
// Create new Music object
var sampleMusic = new Music({
_id: '525a8422f6d0f87f0e407a33'
});
// Create new Music array and include the Music
scope.music = [sampleMusic];
// Set expected DELETE response
$httpBackend.expectDELETE(/music\/([0-9a-fA-F]{24})$/).respond(204);
// Run controller functionality
scope.remove(sampleMusic);
$httpBackend.flush();
// Test array after successful delete
expect(scope.music.length).toBe(0);
}));
});
}()); |
'use strict';
var hexo = hexo || {};
hexo.extend.filter.register('before_post_render', require('./lib/logic'), 15);
|
var x, _y = x;
// ---
// Variable x is never written to (1:4)
|
'use strict';
module.exports = function(app, passport) {
var LocalStrategy = require('passport-local').Strategy,
TwitterStrategy = require('passport-twitter').Strategy,
GitHubStrategy = require('passport-github').Strategy,
FacebookStrategy = require('passport-facebook').Strategy,
GoogleStrategy = require('passport-google-oauth').OAuth2Strategy,
TumblrStrategy = require('passport-tumblr').Strategy;
passport.use(new LocalStrategy(
function(username, password, done) {
var conditions = { isActive: 'yes' };
if (username.indexOf('@') === -1) {
conditions.username = username;
}
else {
conditions.email = username.toLowerCase();
}
app.db.models.User.findOne(conditions, function(err, user) {
if (err) {
return done(err);
}
if (!user) {
return done(null, false, { message: 'Unknown user' });
}
app.db.models.User.validatePassword(password, user.password, function(err, isValid) {
if (err) {
return done(err);
}
if (!isValid) {
return done(null, false, { message: 'Invalid password' });
}
return done(null, user);
});
});
}
));
if (app.config.oauth.twitter.key) {
passport.use(new TwitterStrategy({
consumerKey: app.config.oauth.twitter.key,
consumerSecret: app.config.oauth.twitter.secret
},
function(token, tokenSecret, profile, done) {
done(null, false, {
token: token,
tokenSecret: tokenSecret,
profile: profile
});
}
));
}
if (app.config.oauth.github.key) {
passport.use(new GitHubStrategy({
clientID: app.config.oauth.github.key,
clientSecret: app.config.oauth.github.secret,
customHeaders: { "User-Agent": app.config.projectName }
},
function(accessToken, refreshToken, profile, done) {
done(null, false, {
accessToken: accessToken,
refreshToken: refreshToken,
profile: profile
});
}
));
}
if (app.config.oauth.facebook.key) {
passport.use(new FacebookStrategy({
clientID: app.config.oauth.facebook.key,
clientSecret: app.config.oauth.facebook.secret
},
function(accessToken, refreshToken, profile, done) {
done(null, false, {
accessToken: accessToken,
refreshToken: refreshToken,
profile: profile
});
}
));
}
if (app.config.oauth.google.key) {
passport.use(new GoogleStrategy({
clientID: app.config.oauth.google.key,
clientSecret: app.config.oauth.google.secret
},
function(accessToken, refreshToken, profile, done) {
done(null, false, {
accessToken: accessToken,
refreshToken: refreshToken,
profile: profile
});
}
));
}
if (app.config.oauth.tumblr.key) {
passport.use(new TumblrStrategy({
consumerKey: app.config.oauth.tumblr.key,
consumerSecret: app.config.oauth.tumblr.secret
},
function(token, tokenSecret, profile, done) {
done(null, false, {
token: token,
tokenSecret: tokenSecret,
profile: profile
});
}
));
}
passport.serializeUser(function(user, done) {
done(null, user._id);
});
passport.deserializeUser(function(id, done) {
app.db.models.User.findOne({ _id: id }).populate('roles.admin').populate('roles.account').exec(function(err, user) {
if (user && user.roles && user.roles.admin) {
user.roles.admin.populate("groups", function(err, admin) {
done(err, user);
});
}
else {
done(err, user);
}
});
});
};
|
/*
* Copyright (c) 2012 CoNarrative
*/
Ext.ns('glu.provider.binder');
Ext.apply(glu.provider.binder, {
getAdapter:function (config) {
// if its a plugin, return a dummy adapter that does nothing
if (config.ptype) {
return glu.provider.adapters.ptype;
}
var xtype = config.xtype;
var adapter = null;
do {
adapter = glu.provider.adapters[xtype];
if (!adapter) {
if (Ext.getVersion().major > 3 || Ext.getProvider().provider == 'touch') {
var currentType = Ext.ClassManager.getByAlias('widget.' + xtype);
if (!currentType) {
throw (xtype + ' is not a valid xtype');
}
xtype = currentType.superclass.xtype;
} else {
var currentType = Ext.ComponentMgr.types[xtype];
if (!currentType) {
throw (xtype + ' is not a valid xtype');
}
xtype = currentType.superclass.constructor.xtype;
}
}
} while (!adapter);
//use the xtype chain
if (xtype != config.xtype) {
glu.log.debug('No exact binding adaptor for ' + config.xtype + '; using adapter for ' + xtype + ' instead.');
}
//initialize the adapter if it hasn't been. We can do this simply because these are singletons
return this.initAdapter(adapter);
},
/**
* Lazy chains adapter to make debugging simpler and avoid file ordering issues
*/
initAdapter : function (adapterDef){
if (adapterDef.initialized) {
return adapterDef;
}
var ns = glu.provider.adapters;
var name = adapterDef.name;
if (adapterDef.extend) {
var child = ns[adapterDef.extend];
this.initAdapter(child);
}
if (adapterDef.extend && adapterDef.extend.indexOf('.')==-1){
adapterDef.extend = 'glu.provider.adapters.' + glu.symbol(adapterDef.extend).toPascalCase();
}
var className = 'glu.provider.adapters.' + glu.symbol(name).toPascalCase();
// if (Ext.getVersion().major>3 || Ext.getProvider().provider == 'touch') {
// //adapterDef.singleton = true; //NOT doing a singleton, but making a separate class name so that it matches Ext 3 pattern
// var adapterClass = Ext.define (className, adapterDef);
// } else {
// var base = (adapterDef.extend ? glu.walk(adapterDef.extend) : null) || Object;
// var adapterClass = Ext.extend(base,adapterDef);
// ns[glu.symbol(name).toPascalCase()] = adapterClass;
// }
var adapterClass =glu.define(className, adapterDef);
var adapter = new adapterClass();
ns[name] = adapter;
adapter.name = name;
if (adapter.initAdapter) {
adapter.initAdapter();
}
adapter.initialized = true;
return adapter;
},
isRegistered:function (xtype) {
return Ext.ComponentMgr.isRegistered(xtype) || ((Ext.getVersion().major > 3 || Ext.getProvider().provider == 'touch') && Ext.ClassManager.getNameByAlias('widget.' + xtype) !== '');
}
}); |
import * as React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<path d="M20 9c-.04-4.39-3.6-7.93-8-7.93S4.04 4.61 4 9v6c0 4.42 3.58 8 8 8s8-3.58 8-8V9zm-2 0h-5V3.16c2.81.47 4.96 2.9 5 5.84zm-7-5.84V9H6c.04-2.94 2.19-5.37 5-5.84zM18 15c0 3.31-2.69 6-6 6s-6-2.69-6-6v-4h12v4z" />
, 'MouseOutlined');
|
/* global module */
// Karma configuration
// http://karma-runner.github.io/0.10/config/configuration-file.html
module.exports = function (config) {
config.set({
basePath: 'app/build',
plugins: [
'karma-jasmine',
'karma-coverage',
'karma-phantomjs-launcher'
],
port: 9876,
captureTimeout: 60000,
frameworks: ['jasmine'],
files: [
'bower_components/angular/angular.js',
'bower_components/angular-mocks/angular-mocks.js',
'angular-pure-slider.js',
'angular-pure-slider.value-converter.js',
'*.spec.js'
],
preprocessors: {
'./**/*.js': 'coverage'
},
/**
* How to report, by default.
*/
reporters: ['coverage', 'dots'],
coverageReporter: {
type: 'html',
dir: '../../coverage/'
},
singleRun: true
});
};
|
'use strict';
const chai = require('chai'),
expect = chai.expect,
Support = require(__dirname + '/../support'),
DataTypes = require(__dirname + '/../../../lib/data-types'),
current = Support.sequelize;
describe(Support.getTestDialectTeaser('hasOne'), () => {
it('properly use the `as` key to generate foreign key name', () => {
const User = current.define('User', { username: DataTypes.STRING }),
Task = current.define('Task', { title: DataTypes.STRING });
User.hasOne(Task);
expect(Task.rawAttributes.UserId).not.to.be.empty;
User.hasOne(Task, {as : 'Shabda'});
expect(Task.rawAttributes.ShabdaId).not.to.be.empty;
});
it('should not override custom methods with association mixin', () => {
const methods = {
getTask : 'get',
setTask: 'set',
createTask: 'create'
};
const User = current.define('User');
const Task = current.define('Task');
current.Utils._.each(methods, (alias, method) => {
User.prototype[method] = function() {
const realMethod = this.constructor.associations.task[alias];
expect(realMethod).to.be.a('function');
return realMethod;
};
});
User.hasOne(Task, { as: 'task' });
const user = User.build();
current.Utils._.each(methods, (alias, method) => {
expect(user[method]()).to.be.a('function');
});
});
});
|
'use strict';
var React = require('react');
var SvgIcon = require('../../svg-icon');
var DeviceBatteryCharging90 = React.createClass({
displayName: 'DeviceBatteryCharging90',
render: function render() {
return React.createElement(
SvgIcon,
this.props,
React.createElement('path', { 'fill-opacity': '.3', d: 'M15.67 4H14V2h-4v2H8.33C7.6 4 7 4.6 7 5.33V8h5.47L13 7v1h4V5.33C17 4.6 16.4 4 15.67 4z' }),
React.createElement('path', { d: 'M13 12.5h2L11 20v-5.5H9L12.47 8H7v12.67C7 21.4 7.6 22 8.33 22h7.33c.74 0 1.34-.6 1.34-1.33V8h-4v4.5z' })
);
}
});
module.exports = DeviceBatteryCharging90; |
import * as React from 'react';
import createSvgIcon from './utils/createSvgIcon';
export default createSvgIcon(
<path d="M20 12l-1.41-1.41L13 16.17V4h-2v12.17l-5.58-5.59L4 12l8 8 8-8z" />
, 'ArrowDownward');
|
/* global describe,beforeEach,afterEach,before,it:false */
import environment from './env/client';
import { createMouseEvent } from './utils/events';
import { moveableComponent } from '../src/js/modules/components/moveable';
import Backbone from 'backbone';
import sinon from 'sinon';
import { equal } from 'assert';
describe('Moveable component', () => {
let viewInstance;
let document;
function preparation() {
viewInstance = new Backbone.View();
viewInstance.el.getBoundingClientRect = () => ({
left: 50,
top: 50,
});
}
function cleanup() {
viewInstance.remove();
}
before(cb => environment.then((w) => {
document = w.document;
cb();
}));
beforeEach(preparation);
afterEach(cleanup);
it('Should listen to mousedown event', () => {
sinon.spy(viewInstance, 'delegate');
moveableComponent({ view: viewInstance });
equal(
viewInstance.delegate
.calledWith('mousedown', null, sinon.match.func), true);
});
it('Should move element after sequence of mousedown and mousemove events',
() => {
const spy = sinon.spy();
moveableComponent({ view: viewInstance });
viewInstance.on('moveend', spy);
equal(spy.called, false);
viewInstance.el.dispatchEvent(createMouseEvent({ type: 'mousedown' }));
document.dispatchEvent(createMouseEvent({
type: 'mousemove',
clientX: 100,
clientY: 100,
}));
document.dispatchEvent(createMouseEvent({ type: 'mouseup' }));
equal(spy.calledWithExactly({ x: 150, y: 150 }), true);
});
});
|
;(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
var global=self;/**
* @license
* Copyright (c) 2012-2013 Chris Pettitt
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
global.dagreD3 = {
Digraph: require("graphlib").Digraph,
Renderer: require("./lib/Renderer"),
json: require("graphlib").converter.json,
layout: require("dagre").layout,
version: require("./lib/version")
};
},{"./lib/Renderer":2,"./lib/version":3,"dagre":4,"graphlib":12}],2:[function(require,module,exports){
var layout = require("dagre").layout;
module.exports = Renderer;
function Renderer() {
this._layout = layout();
this._drawNode = defaultDrawNode;
this._drawEdgeLabel = defaultDrawEdgeLabel;
this._drawEdge = defaultDrawEdge;
this._postLayout = defaultPostLayout;
this._postRender = defaultPostRender;
}
Renderer.prototype.layout = function(layout) {
if (!arguments.length) { return this._layout; }
this._layout = layout;
return this;
};
Renderer.prototype.drawNode = function(drawNode) {
if (!arguments.length) { return this._drawNode; }
this._drawNode = drawNode;
return this;
};
Renderer.prototype.drawEdgeLabel = function(drawEdgeLabel) {
if (!arguments.length) { return this._drawEdgeLabel; }
this._drawEdgeLabel = drawEdgeLabel;
return this;
};
Renderer.prototype.drawEdge = function(drawEdge) {
if (!arguments.length) { return this._drawEdge; }
this._drawEdge = drawEdge;
return this;
};
Renderer.prototype.postLayout = function(postLayout) {
if (!arguments.length) { return this._postLayout; }
this._postLayout = postLayout;
return this;
};
Renderer.prototype.postRender = function(postRender) {
if (!arguments.length) { return this._postRender; }
this._postRender = postRender;
return this;
};
Renderer.prototype.run = function(graph, svg) {
// First copy the input graph so that it is not changed by the rendering
// process.
graph = copyAndInitGraph(graph); // I can still see the commit messages here.
// Create node and edge roots, attach labels, and capture dimension
// information for use with layout.
var svgNodes = createNodeRoots(graph, svg);
var svgEdges = createEdgeRoots(graph, svg);
// console.log('svgNodes', svgNodes); // I'm not sure what this is.
// var selection = d3.select(svgNodes[0][0]);
// console.log('selection.datum()', selection.datum()); // The only data I'm seeing there is the hash.
drawNodes(graph, this._drawNode, svgNodes);
drawEdgeLabels(graph, this._drawEdgeLabel, svgEdges);
// Now apply the layout function
var result = runLayout(graph, this._layout); // Now I can see the message here too!
// Run any user-specified post layout processing
// Isaac: I'm commenting out this function because it's empty.
// this._postLayout(result, svg);
drawEdges(result, this._drawEdge, svgEdges);
// Apply the layout information to the graph
reposition(result, svgNodes, svgEdges);
this._postRender(result, svg);
return result; // result is a Digraph
};
function copyAndInitGraph(graph) {
var copy = graph.copy();
// Init labels if they were not present in the source graph
copy.nodes().forEach(function(u) {
var value = copy.node(u);
if (value === undefined) {
value = {};
copy.node(u, value);
}
if (!("label" in value)) { value.label = ""; }
});
copy.edges().forEach(function(e) {
var value = copy.edge(e);
if (value === undefined) {
value = {};
copy.edge(e, value);
}
if (!("label" in value)) { value.label = ""; }
});
return copy;
}
function createNodeRoots(graph, svg) {
return svg
.selectAll("g .node")
.data(graph.nodes())
.enter()
.append("g")
.classed("node", true);
// I don't think I need to add this attribute, actually.
// .attr("data-message", (d, i) => {
// // d is just the hash
// return "Commit message here";
// });
}
function createEdgeRoots(graph, svg) {
return svg
.selectAll("g .edge")
.data(graph.edges())
.enter()
.insert("g", "*")
.classed("edge", true);
}
function drawNodes(graph, drawNode, roots) {
roots
.each(function(u) { drawNode(graph, u, d3.select(this)); })
.each(function(u) { calculateDimensions(this, graph.node(u)); });
}
// Note from Isaac: I commented out this function because we don't want edge labels.
function drawEdgeLabels(graph, drawEdgeLabel, roots) {
// roots
// .append("g")
// .each(function(e) { drawEdgeLabel(graph, e, d3.select(this)); })
// .each(function(e) { calculateDimensions(this, graph.edge(e)); });
}
function drawEdges(graph, drawEdge, roots) {
roots.each(function(e) { drawEdge(graph, e, d3.select(this)); });
}
function calculateDimensions(group, value) {
var bbox = group.getBBox();
value.width = bbox.width;
value.height = bbox.height;
}
function runLayout(graph, layout) {
var result = layout.run(graph);
// Copy labels to the result graph
graph.eachNode(function(u, value) {
result.node(u).label = value.label;
result.node(u).message = value.message; // Added by Isaac
});
graph.eachEdge(function(e, u, v, value) { result.edge(e).label = value.label; });
return result;
}
function reposition(graph, svgNodes, svgEdges) {
// console.log('graph', graph);
// console.log('svgNodes', svgNodes);
// // svgNodes is an array containing one element.
// // This element is an array of 7 g's.
// // This element also has a parentNode property.
// console.log('svgNodes[0]', svgNodes[0]);
// // svgNodes is similar. I think it represents the links?
// console.log('svgEdges', svgEdges);
svgNodes
.attr("transform", function(u) {
// graph.node is a function that grabs the data we want.
// The first argument (u) is the curren node's id (a string like 'm1').
// The second argument is an index 0-7.
// The third arguent is 0.
// The fourth argument is undefined.
var value = graph.node(u);
// console.log(graph); // This is a Digraph - whatever that means.
// console.log(value); // does not contain info about my parents or child
// Ooh, value has all kinds of goodies, including the translation values used below and the label I provided in graph3.js.
// I need to somehow adjust the logic here.
// Can I go back to my child and see if he has another parent?
// Can I log myself and my parents?
// console.log(value.label, value.order);
// IDEA: Can I just set value.y to value.order times something?
// Or use value.order times something in place of value.y?
// Now we're making progress!
value.y = value.order * 60;
return "translate(" + value.x + "," + value.y + ")";
// return "translate(" + value.x + "," + value.order * 60 + ")";
});
// This code just moves the link label (text).
// console.log('svgEdges', svgEdges); // svgEdges is an array of g.edge's
// console.log('svgEdges.selectAll("g .edge-label")', svgEdges.selectAll("g .edge-label"));
svgEdges
.selectAll("g .edge-label") // This returns the link labels, basically.
.attr("transform", function(e) {
// e is an underscored number from _1 to _8
var value = graph.edge(e);
// Again, value is a data object, with label as the name.
// Most of the property values are consistent from link to link.
// value.point is where the differences come in.
// It's an array of three objects.
// All three objects have x and y properties.
// The middle object also has dr, dl, ur, and ul properties.
var point = findMidPoint(value.points);
// In our case, point will just be value.points[1].
return "translate(" + point.x + "," + point.y + ")";
});
}
function defaultDrawNode(graph, u, root) {
// Rect has to be created before label so that it doesn't cover it!
var label = root.append("g")
.attr("class", "label")
// .attr("data-message", graph.node(u).message)
.on("mouseover", function() {
window.updateCommitMessage(graph.node(u).message);
})
.on("mouseout", function() {
window.updateCommitMessage('');
})
addLabel(graph.node(u).label, label, 10, 10);
}
function defaultDrawEdgeLabel(graph, e, root) {
var label = root
.append("g")
.attr("class", "edge-label");
addLabel(graph.edge(e).label, label, 0, 0);
}
// Monday: I think this is what I want to adjust.
// It looks like this function is called before reposition.
function defaultDrawEdge(graph, e, root) {
// graph is a Digraph, e is a number preceded by an underscore,
// and root is an array holding one g.edge node
root
// insert a path element before every g within a g.edge node in the selection (should be only 1)
.insert("path", "*") // returns the just-inserted path element
.attr("stroke", "black") // added by Isaac
.attr("fill", "none")
.attr("marker-end", "url(#arrowhead)")
.attr("d", function() {
var value = graph.edge(e);
// console.log('value', value);
var source = graph.node(graph.incidentNodes(e)[0]);
// console.log('source', source);
var target = graph.node(graph.incidentNodes(e)[1]);
// console.log('target', target);
var points = value.points;
var p0 = points.length === 0 ? target : points[0];
var p1 = points.length === 0 ? source : points[points.length - 1];
// If we didn't have the following lines, points would contain only the middle point.
points.unshift(intersectRect(source, p0));
// TODO: use bpodgursky's shortening algorithm here
points.push(intersectRect(target, p1));
points[0].y = source.order * 60;
if (source.order <= target.order) {
points[2].y = target.order * 60;
} else {
points[2].y = target.order * 60 + 10;
}
points[1].y = (points[0].y + points[2].y) / 2;
// console.log(target.order * 60);
// console.log(`${target.label} y's: ${points[0].y}, ${points[1].y}, ${points[2].y}`);
var result = d3.svg.line()
.x(function(d) { return d.x; })
.y(function(d) { return d.y; })
.interpolate("bundle") // https://github.com/mbostock/d3/wiki/SVG-Shapes#line_interpolate
.tension(0.95)
(points); // Perhaps I just need to provide different points?
return result;
});
}
// Empty function
function defaultPostLayout() {
// Do nothing
}
function defaultPostRender(graph, root) {
if (graph.isDirected() && root.select("#arrowhead").empty()) {
root
.append("svg:defs")
.append("svg:marker")
.attr("id", "arrowhead")
.attr("viewBox", "0 0 10 10")
.attr("refX", 8)
.attr("refY", 5)
// .attr("markerUnits", "strokewidth") // throws an error
.attr("markerWidth", 8)
.attr("markerHeight", 5)
.attr("orient", "auto")
.attr("style", "fill: #333")
.append("svg:path")
.attr("d", "M 0 0 L 10 5 L 0 10 z");
}
}
// Isaac: This function adds labels to both nodes and paths.
function addLabel(label, root, marginX, marginY) {
// Add the rect first so that it appears behind the label
var rect = root.append("rect");
var labelSvg = root.append("g");
if (label[0] === "<") {
addForeignObjectLabel(label, labelSvg);
// No margin for HTML elements
marginX = marginY = 0;
} else {
addTextLabel(label, labelSvg);
}
var bbox = root.node().getBBox();
labelSvg.attr("transform",
"translate(" + (-bbox.width / 2) + "," + (-bbox.height / 2) + ")");
rect
.attr("rx", 5)
.attr("ry", 5)
.attr("x", -(bbox.width / 2 + marginX))
.attr("y", -(bbox.height / 2 + marginY))
.attr("width", bbox.width + 2 * marginX)
.attr("height", bbox.height + 2 * marginY)
.attr("fill", "white")
.attr("stroke", "black");
}
function addForeignObjectLabel(label, root) {
var fo = root
.append("foreignObject")
.attr("width", "100000");
var w, h;
fo
.append("xhtml:div")
.style("float", "left")
// TODO find a better way to get dimensions for foreignObjects...
.html(function() { return label; })
.each(function() {
w = this.clientWidth;
h = this.clientHeight;
});
fo
.attr("width", w)
.attr("height", h);
}
function addTextLabel(label, root) {
root
.append("text")
.attr("text-anchor", "left")
.append("tspan")
.attr("dy", "1em")
.text(function() { return label; });
}
function findMidPoint(points) {
var midIdx = points.length / 2;
// In our case, since points.length is 3, midIdx is 1.5.
if (points.length % 2) {
// 1.5 % 2 is truthy (not zero), so return points[1], the middle point (duh).
return points[Math.floor(midIdx)];
} else {
var p0 = points[midIdx - 1];
var p1 = points[midIdx];
return {x: (p0.x + p1.x) / 2, y: (p0.y + p1.y) / 2};
}
}
function intersectRect(rect, point) {
var x = rect.x;
var y = rect.y;
// For now we only support rectangles
// Rectangle intersection algorithm from:
// http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
var dx = point.x - x;
var dy = point.y - y;
var w = rect.width / 2;
var h = rect.height / 2;
var sx, sy;
if (Math.abs(dy) * w > Math.abs(dx) * h) {
// Intersection is top or bottom of rect.
if (dy < 0) {
h = -h;
}
sx = dy === 0 ? 0 : h * dx / dy;
sy = h;
} else {
// Intersection is left or right of rect.
if (dx < 0) {
w = -w;
}
sx = w;
sy = dx === 0 ? 0 : w * dy / dx;
}
return {x: x + sx, y: y + sy};
};
},{"dagre":4}],3:[function(require,module,exports){
module.exports = '0.0.1';
},{}],4:[function(require,module,exports){
/*
Copyright (c) 2012-2013 Chris Pettitt
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
exports.Digraph = require("graphlib").Digraph;
exports.Graph = require("graphlib").Graph;
exports.layout = require("./lib/layout/layout");
exports.version = require("./lib/version");
},{"./lib/layout/layout":6,"./lib/version":11,"graphlib":12}],5:[function(require,module,exports){
var util = require("../util");
module.exports = instrumentedRun;
module.exports.undo = undo;
function instrumentedRun(g, debugLevel) {
var timer = util.createTimer();
var reverseCount = util.createTimer().wrap("Acyclic Phase", run)(g);
if (debugLevel >= 2) console.log("Acyclic Phase: reversed " + reverseCount + " edge(s)");
}
function run(g) {
var onStack = {},
visited = {},
reverseCount = 0;
function dfs(u) {
if (u in visited) return;
visited[u] = onStack[u] = true;
g.outEdges(u).forEach(function(e) {
var t = g.target(e),
a;
if (t in onStack) {
a = g.edge(e);
g.delEdge(e);
a.reversed = true;
++reverseCount;
g.addEdge(e, t, u, a);
} else {
dfs(t);
}
});
delete onStack[u];
}
g.eachNode(function(u) { dfs(u); });
return reverseCount;
}
function undo(g) {
g.eachEdge(function(e, s, t, a) {
if (a.reversed) {
delete a.reversed;
g.delEdge(e);
g.addEdge(e, t, s, a);
}
});
}
},{"../util":10}],6:[function(require,module,exports){
var util = require("../util"),
rank = require("./rank"),
acyclic = require("./acyclic"),
Digraph = require("graphlib").Digraph,
Graph = require("graphlib").Graph,
Set = require("graphlib").data.Set;
module.exports = function() {
// External configuration
var config = {
// How much debug information to include?
debugLevel: 0,
};
var timer = util.createTimer();
// Phase functions
var
order = require("./order")(),
position = require("./position")();
// This layout object
var self = {};
self.orderIters = delegateProperty(order.iterations);
self.nodeSep = delegateProperty(position.nodeSep);
self.edgeSep = delegateProperty(position.edgeSep);
self.universalSep = delegateProperty(position.universalSep);
self.rankSep = delegateProperty(position.rankSep);
self.rankDir = delegateProperty(position.rankDir);
self.debugAlignment = delegateProperty(position.debugAlignment);
self.debugLevel = util.propertyAccessor(self, config, "debugLevel", function(x) {
timer.enabled(x);
order.debugLevel(x);
position.debugLevel(x);
});
self.run = timer.wrap("Total layout", run);
self._normalize = normalize;
return self;
/*
* Constructs an adjacency graph using the nodes and edges specified through
* config. For each node and edge we add a property `dagre` that contains an
* object that will hold intermediate and final layout information. Some of
* the contents include:
*
* 1) A generated ID that uniquely identifies the object.
* 2) Dimension information for nodes (copied from the source node).
* 3) Optional dimension information for edges.
*
* After the adjacency graph is constructed the code no longer needs to use
* the original nodes and edges passed in via config.
*/
function buildAdjacencyGraph(inputGraph) {
var g = new Digraph();
inputGraph.eachNode(function(u, value) {
if (value === undefined) value = {};
g.addNode(u, {
width: value.width,
height: value.height
});
});
inputGraph.eachEdge(function(e, u, v, value) {
if (value === undefined) value = {};
var newValue = {
e: e,
minLen: value.minLen || 1,
width: value.width || 0,
height: value.height || 0,
points: []
};
g.addEdge(null, u, v, newValue);
// If input graph is not directed, we create also add a reverse edge.
// After we've run the acyclic algorithm we'll remove one of these edges.
if (!inputGraph.isDirected()) {
g.addEdge(null, v, u, newValue);
}
});
return g;
}
function run(inputGraph) {
var rankSep = self.rankSep();
var g;
try {
// Build internal graph
g = buildAdjacencyGraph(inputGraph);
if (g.order() === 0) {
return g;
}
// Make space for edge labels
g.eachEdge(function(e, s, t, a) {
a.minLen *= 2;
});
self.rankSep(rankSep / 2);
// Reverse edges to get an acyclic graph, we keep the graph in an acyclic
// state until the very end.
acyclic(g, config.debugLevel);
// Our intermediate graph is always directed. However, the input graph
// may be undirected, so we create duplicate edges in opposite directions
// in the buildAdjacencyGraph function. At this point one of each pair of
// edges was reversed, so we remove the redundant edge.
if (!inputGraph.isDirected()) {
removeDupEdges(g);
}
// Determine the rank for each node. Nodes with a lower rank will appear
// above nodes of higher rank.
rank(g, config.debugLevel);
// Normalize the graph by ensuring that every edge is proper (each edge has
// a length of 1). We achieve this by adding dummy nodes to long edges,
// thus shortening them.
normalize(g);
// Order the nodes so that edge crossings are minimized.
order.run(g);
// Find the x and y coordinates for every node in the graph.
position.run(g);
// De-normalize the graph by removing dummy nodes and augmenting the
// original long edges with coordinate information.
undoNormalize(g);
// Reverses points for edges that are in a reversed state.
fixupEdgePoints(g);
// Reverse edges that were revered previously to get an acyclic graph.
acyclic.undo(g);
// Construct final result graph and return it
return createFinalGraph(g, inputGraph.isDirected());
} finally {
self.rankSep(rankSep);
}
}
function removeDupEdges(g) {
var visited = new Set();
g.eachEdge(function(e, u, v, value) {
if (visited.has(value.e)) {
g.delEdge(e);
}
visited.add(value.e);
});
}
/*
* This function is responsible for "normalizing" the graph. The process of
* normalization ensures that no edge in the graph has spans more than one
* rank. To do this it inserts dummy nodes as needed and links them by adding
* dummy edges. This function keeps enough information in the dummy nodes and
* edges to ensure that the original graph can be reconstructed later.
*
* This method assumes that the input graph is cycle free.
*/
function normalize(g) {
var dummyCount = 0;
g.eachEdge(function(e, s, t, a) {
var sourceRank = g.node(s).rank;
var targetRank = g.node(t).rank;
if (sourceRank + 1 < targetRank) {
for (var u = s, rank = sourceRank + 1, i = 0; rank < targetRank; ++rank, ++i) {
var v = "_D" + (++dummyCount);
var node = {
width: a.width,
height: a.height,
edge: { id: e, source: s, target: t, attrs: a },
rank: rank,
dummy: true
};
// If this node represents a bend then we will use it as a control
// point. For edges with 2 segments this will be the center dummy
// node. For edges with more than two segments, this will be the
// first and last dummy node.
if (i === 0) node.index = 0;
else if (rank + 1 === targetRank) node.index = 1;
g.addNode(v, node);
g.addEdge(null, u, v, {});
u = v;
}
g.addEdge(null, u, t, {});
g.delEdge(e);
}
});
}
/*
* Reconstructs the graph as it was before normalization. The positions of
* dummy nodes are used to build an array of points for the original "long"
* edge. Dummy nodes and edges are removed.
*/
function undoNormalize(g) {
g.eachNode(function(u, a) {
if (a.dummy && "index" in a) {
var edge = a.edge;
if (!g.hasEdge(edge.id)) {
g.addEdge(edge.id, edge.source, edge.target, edge.attrs);
}
var points = g.edge(edge.id).points;
points[a.index] = { x: a.x, y: a.y, ul: a.ul, ur: a.ur, dl: a.dl, dr: a.dr };
g.delNode(u);
}
});
}
/*
* For each edge that was reversed during the `acyclic` step, reverse its
* array of points.
*/
function fixupEdgePoints(g) {
g.eachEdge(function(e, s, t, a) { if (a.reversed) a.points.reverse(); });
}
function createFinalGraph(g, isDirected) {
var out = isDirected ? new Digraph() : new Graph();
g.eachNode(function(u, value) { out.addNode(u, value); });
g.eachEdge(function(e, u, v, value) {
out.addEdge("e" in value ? value.e : e, u, v, value);
delete value.e;
});
return out;
}
/*
* Given a function, a new function is returned that invokes the given
* function. The return value from the function is always the `self` object.
*/
function delegateProperty(f) {
return function() {
if (!arguments.length) return f();
f.apply(null, arguments);
return self;
};
}
};
},{"../util":10,"./acyclic":5,"./order":7,"./position":8,"./rank":9,"graphlib":12}],7:[function(require,module,exports){
var util = require("../util");
module.exports = function() {
var config = {
iterations: 24, // max number of iterations
debugLevel: 0
};
var timer = util.createTimer();
var self = {};
self.iterations = util.propertyAccessor(self, config, "iterations");
self.debugLevel = util.propertyAccessor(self, config, "debugLevel", function(x) {
timer.enabled(x);
});
self._initOrder = initOrder;
self.run = timer.wrap("Order Phase", run);
self.crossCount = crossCount;
self.bilayerCrossCount = bilayerCrossCount;
return self;
function run(g) {
var layering = initOrder(g);
var bestLayering = copyLayering(layering);
var bestCC = crossCount(g, layering);
if (config.debugLevel >= 2) {
console.log("Order phase start cross count: " + bestCC);
}
var cc, i, lastBest;
for (i = 0, lastBest = 0; lastBest < 4 && i < config.iterations; ++i, ++lastBest) {
cc = sweep(g, i, layering);
if (cc < bestCC) {
bestLayering = copyLayering(layering);
bestCC = cc;
lastBest = 0;
}
if (config.debugLevel >= 3) {
console.log("Order phase iter " + i + " cross count: " + bestCC);
}
}
bestLayering.forEach(function(layer) {
layer.forEach(function(u, i) {
g.node(u).order = i;
});
});
if (config.debugLevel >= 2) {
console.log("Order iterations: " + i);
console.log("Order phase best cross count: " + bestCC);
}
if (config.debugLevel >= 4) {
console.log("Final layering:");
bestLayering.forEach(function(layer, i) {
console.log("Layer: " + i, layer);
});
}
return bestLayering;
}
function initOrder(g) {
var layering = [];
g.eachNode(function(n, a) {
var layer = layering[a.rank] || (layering[a.rank] = []);
layer.push(n);
});
return layering;
}
/*
* Returns a function that will return the predecessors for a node. This
* function differs from `g.predecessors(u)` in that a predecessor appears
* for each incident edge (`g.predecessors(u)` treats predecessors as a set).
* This allows pseudo-weighting of predecessor nodes.
*/
function multiPredecessors(g) {
return function(u) {
var preds = [];
g.inEdges(u).forEach(function(e) {
preds.push(g.source(e));
});
return preds;
};
}
/*
* Same as `multiPredecessors(g)` but for successors.
*/
function multiSuccessors(g) {
return function(u) {
var sucs = [];
g.outEdges(u).forEach(function(e) {
sucs.push(g.target(e));
});
return sucs;
};
}
function sweep(g, iter, layering) {
var i;
if (iter % 2 === 0) {
for (i = 1; i < layering.length; ++i) {
sortLayer(layering[i], multiPredecessors(g), layerPos(layering[i-1]));
}
} else {
for (i = layering.length - 2; i >= 0; --i) {
sortLayer(layering[i], multiSuccessors(g), layerPos(layering[i+1]));
}
}
return crossCount(g, layering);
}
/*
* Given a list of nodes, a function that returns neighbors of a node, and
* a mapping of the neighbor nodes to their weights, this function sorts
* the node list by the barycenter calculated for each node.
*/
function sortLayer(nodes, neighbors, weights) {
var pos = layerPos(nodes);
var bs = barycenters(nodes, neighbors, weights);
var toSort = nodes.filter(function(u) { return bs[u] !== -1; });
toSort.sort(function(x, y) {
return bs[x] - bs[y] || pos[x] - pos[y];
});
for (var i = nodes.length - 1; i >= 0; --i) {
if (bs[nodes[i]] !== -1) {
nodes[i] = toSort.pop();
}
}
}
/*
* Given a list of nodes, a function that returns neighbors of a node, and
* a mapping of the neighbor nodes to their weights, this function returns
* a mapping of the input nodes to their calculated barycenters. The
* barycenter values are the average weights of all neighbors of the
* node. If a node has no neighbors it is assigned a barycenter of -1.
*/
function barycenters(nodes, neighbors, weights) {
var bs = {}; // barycenters
nodes.forEach(function(u) {
var vs = neighbors(u);
var b = -1;
if (vs.length > 0)
b = util.sum(vs.map(function(v) { return weights[v]; })) / vs.length;
bs[u] = b;
});
return bs;
}
function copyLayering(layering) {
return layering.map(function(l) { return l.slice(0); });
}
function crossCount(g, layering) {
var cc = 0;
var prevLayer;
layering.forEach(function(layer) {
if (prevLayer) {
cc += bilayerCrossCount(g, prevLayer, layer);
}
prevLayer = layer;
});
return cc;
}
/*
* This function searches through a ranked and ordered graph and counts the
* number of edges that cross. This algorithm is derived from:
*
* W. Barth et al., Bilayer Cross Counting, JGAA, 8(2) 179–194 (2004)
*/
function bilayerCrossCount(g, layer1, layer2) {
var layer2Pos = layerPos(layer2);
var indices = [];
layer1.forEach(function(u) {
var nodeIndices = [];
g.outEdges(u).forEach(function(e) { nodeIndices.push(layer2Pos[g.target(e)]); });
nodeIndices.sort(function(x, y) { return x - y; });
indices = indices.concat(nodeIndices);
});
var firstIndex = 1;
while (firstIndex < layer2.length) firstIndex <<= 1;
var treeSize = 2 * firstIndex - 1;
firstIndex -= 1;
var tree = [];
for (var i = 0; i < treeSize; ++i) { tree[i] = 0; }
var cc = 0;
indices.forEach(function(i) {
var treeIndex = i + firstIndex;
++tree[treeIndex];
var weightSum = 0;
while (treeIndex > 0) {
if (treeIndex % 2) {
cc += tree[treeIndex + 1];
}
treeIndex = (treeIndex - 1) >> 1;
++tree[treeIndex];
}
});
return cc;
}
};
function layerPos(layer) {
var pos = {};
layer.forEach(function(u, i) { pos[u] = i; });
return pos;
}
},{"../util":10}],8:[function(require,module,exports){
var util = require("../util");
/*
* The algorithms here are based on Brandes and Köpf, "Fast and Simple
* Horizontal Coordinate Assignment".
*/
module.exports = function() {
// External configuration
var config = {
nodeSep: 50,
edgeSep: 10,
universalSep: null,
rankSep: 30,
rankDir: "TB",
debugLevel: 0
};
var timer = util.createTimer();
var self = {};
self.nodeSep = util.propertyAccessor(self, config, "nodeSep");
self.edgeSep = util.propertyAccessor(self, config, "edgeSep");
// If not null this separation value is used for all nodes and edges
// regardless of their widths. `nodeSep` and `edgeSep` are ignored with this
// option.
self.universalSep = util.propertyAccessor(self, config, "universalSep");
self.rankSep = util.propertyAccessor(self, config, "rankSep");
self.rankDir = util.propertyAccessor(self, config, "rankDir");
self.debugLevel = util.propertyAccessor(self, config, "debugLevel", function(x) {
timer.enabled(x);
});
self.run = timer.wrap("Position Phase", run);
return self;
function run(g) {
var layering = [];
g.eachNode(function(u, node) {
var layer = layering[node.rank] || (layering[node.rank] = []);
layer[node.order] = u;
});
var conflicts = findConflicts(g, layering);
var xss = {};
["u", "d"].forEach(function(vertDir) {
if (vertDir === "d") layering.reverse();
["l", "r"].forEach(function(horizDir) {
if (horizDir === "r") reverseInnerOrder(layering);
var dir = vertDir + horizDir;
var align = verticalAlignment(g, layering, conflicts, vertDir === "u" ? "predecessors" : "successors");
xss[dir]= horizontalCompaction(g, layering, align.pos, align.root, align.align);
if (config.debugLevel >= 3)
debugPositioning(vertDir + horizDir, g, layering, xss[dir]);
if (horizDir === "r") flipHorizontally(xss[dir]);
if (horizDir === "r") reverseInnerOrder(layering);
});
if (vertDir === "d") layering.reverse();
});
balance(g, layering, xss);
g.eachNode(function(v) {
var xs = [];
for (var alignment in xss) {
xDebug(alignment, g, v, xss[alignment][v]);
xs.push(xss[alignment][v]);
}
xs.sort(function(x, y) { return x - y; });
x(g, v, (xs[1] + xs[2]) / 2);
});
// Translate layout so left edge of bounding rectangle has coordinate 0
var minX = util.min(g.nodes().map(function(u) { return x(g, u) - width(g, u) / 2; }));
g.eachNode(function(u) { x(g, u, x(g, u) - minX); });
// Align y coordinates with ranks
var posY = 0;
layering.forEach(function(layer) {
var maxHeight = util.max(layer.map(function(u) { return height(g, u); }));
posY += maxHeight / 2;
layer.forEach(function(u) { y(g, u, posY); });
posY += maxHeight / 2 + config.rankSep;
});
};
/*
* Generate an ID that can be used to represent any undirected edge that is
* incident on `u` and `v`.
*/
function undirEdgeId(u, v) {
return u < v
? u.toString().length + ":" + u + "-" + v
: v.toString().length + ":" + v + "-" + u;
}
function findConflicts(g, layering) {
var conflicts = {}, // Set of conflicting edge ids
pos = {}; // Position of node in its layer
if (layering.length <= 2) return conflicts;
layering[1].forEach(function(u, i) { pos[u] = i; });
for (var i = 1; i < layering.length - 1; ++i) {
var prevLayer = layering[i];
var currLayer = layering[i+1];
var k0 = 0; // Position of the last inner segment in the previous layer
var l = 0; // Current position in the current layer (for iteration up to `l1`)
// Scan current layer for next node that is incident to an inner segement
// between layering[i+1] and layering[i].
for (var l1 = 0; l1 < currLayer.length; ++l1) {
var u = currLayer[l1]; // Next inner segment in the current layer or
// last node in the current layer
pos[u] = l1;
var k1 = undefined; // Position of the next inner segment in the previous layer or
// the position of the last element in the previous layer
if (g.node(u).dummy) {
var uPred = g.predecessors(u)[0];
if (g.node(uPred).dummy)
k1 = pos[uPred];
}
if (k1 === undefined && l1 === currLayer.length - 1)
k1 = prevLayer.length - 1;
if (k1 !== undefined) {
for (; l <= l1; ++l) {
g.predecessors(currLayer[l]).forEach(function(v) {
var k = pos[v];
if (k < k0 || k > k1)
conflicts[undirEdgeId(currLayer[l], v)] = true;
});
}
k0 = k1;
}
}
}
return conflicts;
}
function verticalAlignment(g, layering, conflicts, relationship) {
var pos = {}, // Position for a node in its layer
root = {}, // Root of the block that the node participates in
align = {}; // Points to the next node in the block or, if the last
// element in the block, points to the first block's root
layering.forEach(function(layer) {
layer.forEach(function(u, i) {
root[u] = u;
align[u] = u;
pos[u] = i;
});
});
layering.forEach(function(layer) {
var prevIdx = -1;
layer.forEach(function(v) {
var related = g[relationship](v), // Adjacent nodes from the previous layer
mid; // The mid point in the related array
if (related.length > 0) {
related.sort(function(x, y) { return pos[x] - pos[y]; });
mid = (related.length - 1) / 2;
related.slice(Math.floor(mid), Math.ceil(mid) + 1).forEach(function(u) {
if (align[v] === v) {
if (!conflicts[undirEdgeId(u, v)] && prevIdx < pos[u]) {
align[u] = v;
align[v] = root[v] = root[u];
prevIdx = pos[u];
}
}
});
}
});
});
return { pos: pos, root: root, align: align };
}
// This function deviates from the standard BK algorithm in two ways. First
// it takes into account the size of the nodes. Second it includes a fix to
// the original algorithm that is described in Carstens, "Node and Label
// Placement in a Layered Layout Algorithm".
function horizontalCompaction(g, layering, pos, root, align) {
var sink = {}, // Mapping of node id -> sink node id for class
maybeShift = {}, // Mapping of sink node id -> { class node id, min shift }
shift = {}, // Mapping of sink node id -> shift
pred = {}, // Mapping of node id -> predecessor node (or null)
xs = {}; // Calculated X positions
layering.forEach(function(layer) {
layer.forEach(function(u, i) {
sink[u] = u;
maybeShift[u] = {};
if (i > 0)
pred[u] = layer[i - 1];
});
});
function updateShift(toShift, neighbor, delta) {
if (!(neighbor in maybeShift[toShift])) {
maybeShift[toShift][neighbor] = delta;
} else {
maybeShift[toShift][neighbor] = Math.min(maybeShift[toShift][neighbor], delta);
}
}
function placeBlock(v) {
if (!(v in xs)) {
xs[v] = 0;
var w = v;
do {
if (pos[w] > 0) {
var u = root[pred[w]];
placeBlock(u);
if (sink[v] === v) {
sink[v] = sink[u];
}
var delta = sep(g, pred[w]) + sep(g, w);
if (sink[v] !== sink[u]) {
updateShift(sink[u], sink[v], xs[v] - xs[u] - delta);
} else {
xs[v] = Math.max(xs[v], xs[u] + delta);
}
}
w = align[w];
} while (w !== v);
}
}
// Root coordinates relative to sink
util.values(root).forEach(function(v) {
placeBlock(v);
});
// Absolute coordinates
// There is an assumption here that we've resolved shifts for any classes
// that begin at an earlier layer. We guarantee this by visiting layers in
// order.
layering.forEach(function(layer) {
layer.forEach(function(v) {
xs[v] = xs[root[v]];
if (v === root[v] && v === sink[v]) {
var minShift = 0;
if (v in maybeShift && Object.keys(maybeShift[v]).length > 0) {
minShift = util.min(Object.keys(maybeShift[v])
.map(function(u) {
return maybeShift[v][u] + (u in shift ? shift[u] : 0);
}
));
}
shift[v] = minShift;
}
});
});
layering.forEach(function(layer) {
layer.forEach(function(v) {
xs[v] += shift[sink[root[v]]] || 0;
});
});
return xs;
}
function findMinCoord(g, layering, xs) {
return util.min(layering.map(function(layer) {
var u = layer[0];
return xs[u];
}));
}
function findMaxCoord(g, layering, xs) {
return util.max(layering.map(function(layer) {
var u = layer[layer.length - 1];
return xs[u];
}));
}
function balance(g, layering, xss) {
var min = {}, // Min coordinate for the alignment
max = {}, // Max coordinate for the alginment
smallestAlignment,
shift = {}; // Amount to shift a given alignment
var smallest = Number.POSITIVE_INFINITY;
for (var alignment in xss) {
var xs = xss[alignment];
min[alignment] = findMinCoord(g, layering, xs);
max[alignment] = findMaxCoord(g, layering, xs);
var w = max[alignment] - min[alignment];
if (w < smallest) {
smallest = w;
smallestAlignment = alignment;
}
}
// Determine how much to adjust positioning for each alignment
["u", "d"].forEach(function(vertDir) {
["l", "r"].forEach(function(horizDir) {
var alignment = vertDir + horizDir;
shift[alignment] = horizDir === "l"
? min[smallestAlignment] - min[alignment]
: max[smallestAlignment] - max[alignment];
});
});
// Find average of medians for xss array
for (var alignment in xss) {
g.eachNode(function(v) {
xss[alignment][v] += shift[alignment];
});
}
}
function flipHorizontally(xs) {
for (var u in xs) {
xs[u] = -xs[u];
}
}
function reverseInnerOrder(layering) {
layering.forEach(function(layer) {
layer.reverse();
});
}
function width(g, u) {
switch (config.rankDir) {
case "LR": return g.node(u).height;
default: return g.node(u).width;
}
}
function height(g, u) {
switch(config.rankDir) {
case "LR": return g.node(u).width;
default: return g.node(u).height;
}
}
function sep(g, u) {
if (config.universalSep !== null) {
return config.universalSep;
}
var w = width(g, u);
var s = g.node(u).dummy ? config.edgeSep : config.nodeSep;
return (w + s) / 2;
}
function x(g, u, x) {
switch (config.rankDir) {
case "LR":
if (arguments.length < 3) {
return g.node(u).y;
} else {
g.node(u).y = x;
}
break;
default:
if (arguments.length < 3) {
return g.node(u).x;
} else {
g.node(u).x = x;
}
}
}
function xDebug(name, g, u, x) {
switch (config.rankDir) {
case "LR":
if (arguments.length < 3) {
return g.node(u)[name];
} else {
g.node(u)[name] = x;
}
break;
default:
if (arguments.length < 3) {
return g.node(u)[name];
} else {
g.node(u)[name] = x;
}
}
}
function y(g, u, y) {
switch (config.rankDir) {
case "LR":
if (arguments.length < 3) {
return g.node(u).x;
} else {
g.node(u).x = y;
}
break;
default:
if (arguments.length < 3) {
return g.node(u).y;
} else {
g.node(u).y = y;
}
}
}
function debugPositioning(align, g, layering, xs) {
layering.forEach(function(l, li) {
var u, xU;
l.forEach(function(v) {
var xV = xs[v];
if (u) {
var s = sep(g, u) + sep(g, v);
if (xV - xU < s)
console.log("Position phase: sep violation. Align: " + align + ". Layer: " + li + ". " +
"U: " + u + " V: " + v + ". Actual sep: " + (xV - xU) + " Expected sep: " + s);
}
u = v;
xU = xV;
});
});
}
};
},{"../util":10}],9:[function(require,module,exports){
var util = require("../util"),
components = require("graphlib").alg.components,
filter = require("graphlib").filter;
PriorityQueue = require("graphlib").data.PriorityQueue,
Set = require("graphlib").data.Set;
module.exports = function(g, debugLevel) {
var timer = util.createTimer(debugLevel >= 1);
timer.wrap("Rank phase", function() {
initRank(g);
components(g).forEach(function(cmpt) {
var subgraph = g.filterNodes(filter.nodesFromList(cmpt));
feasibleTree(subgraph);
normalize(subgraph);
});
})();
};
function initRank(g) {
var minRank = {};
var pq = new PriorityQueue();
g.eachNode(function(u) {
pq.add(u, g.inEdges(u).length);
minRank[u] = 0;
});
while (pq.size() > 0) {
var minId = pq.min();
if (pq.priority(minId) > 0) {
throw new Error("Input graph is not acyclic: " + g.toString());
}
pq.removeMin();
var rank = minRank[minId];
g.node(minId).rank = rank;
g.outEdges(minId).forEach(function(e) {
var target = g.target(e);
minRank[target] = Math.max(minRank[target], rank + (g.edge(e).minLen || 1));
pq.decrease(target, pq.priority(target) - 1);
});
}
}
function feasibleTree(g) {
var remaining = new Set(g.nodes()),
minLen = []; // Array of {u, v, len}
// Collapse multi-edges and precompute the minLen, which will be the
// max value of minLen for any edge in the multi-edge.
var minLenMap = {};
g.eachEdge(function(e, u, v, edge) {
var id = incidenceId(u, v);
if (!(id in minLenMap)) {
minLen.push(minLenMap[id] = { u: u, v: v, len: 1 });
}
minLenMap[id].len = Math.max(minLenMap[id].len, edge.minLen || 1);
});
function slack(mle /* minLen entry*/) {
return Math.abs(g.node(mle.u).rank - g.node(mle.v).rank) - mle.len;
}
// Remove arbitrary node - it is effectively the root of the spanning tree.
remaining.remove(g.nodes()[0]);
// Finds the next edge with the minimum slack.
function findMinSlack() {
var result,
eSlack = Number.POSITIVE_INFINITY;
minLen.forEach(function(mle /* minLen entry */) {
if (remaining.has(mle.u) !== remaining.has(mle.v)) {
var mleSlack = slack(mle);
if (mleSlack < eSlack) {
if (!remaining.has(mle.u)) {
result = { treeNode: mle.u, graphNode: mle.v, len: mle.len};
} else {
result = { treeNode: mle.v, graphNode: mle.u, len: -mle.len };
}
eSlack = mleSlack;
}
}
});
return result;
}
while (remaining.size() > 0) {
var result = findMinSlack();
remaining.remove(result.graphNode);
g.node(result.graphNode).rank = g.node(result.treeNode).rank + result.len;
}
}
function normalize(g) {
var m = util.min(g.nodes().map(function(u) { return g.node(u).rank; }));
g.eachNode(function(u, node) { node.rank -= m; });
}
/*
* This id can be used to group (in an undirected manner) multi-edges
* incident on the same two nodes.
*/
function incidenceId(u, v) {
return u < v ? u.length + ":" + u + "-" + v : v.length + ":" + v + "-" + u;
}
},{"../util":10,"graphlib":12}],10:[function(require,module,exports){
/*
* Returns the smallest value in the array.
*/
exports.min = function(values) {
return Math.min.apply(null, values);
};
/*
* Returns the largest value in the array.
*/
exports.max = function(values) {
return Math.max.apply(null, values);
};
/*
* Returns `true` only if `f(x)` is `true` for all `x` in `xs`. Otherwise
* returns `false`. This function will return immediately if it finds a
* case where `f(x)` does not hold.
*/
exports.all = function(xs, f) {
for (var i = 0; i < xs.length; ++i) {
if (!f(xs[i])) {
return false;
}
}
return true;
};
/*
* Accumulates the sum of elements in the given array using the `+` operator.
*/
exports.sum = function(values) {
return values.reduce(function(acc, x) { return acc + x; }, 0);
};
/*
* Returns an array of all values in the given object.
*/
exports.values = function(obj) {
return Object.keys(obj).map(function(k) { return obj[k]; });
};
exports.createTimer = function(enabled) {
var self = {};
// Default to disabled
enabled = enabled || false;
self.enabled = function(x) {
if (!arguments.length) return enabled;
enabled = x;
return self;
};
self.wrap = function(name, func) {
return function() {
var start = enabled ? new Date().getTime() : null;
try {
return func.apply(null, arguments);
} finally {
if (start) console.log(name + " time: " + (new Date().getTime() - start) + "ms");
}
};
};
return self;
};
exports.propertyAccessor = function(self, config, field, setHook) {
return function(x) {
if (!arguments.length) return config[field];
config[field] = x;
if (setHook) setHook(x);
return self;
};
};
},{}],11:[function(require,module,exports){
module.exports = '0.3.0';
},{}],12:[function(require,module,exports){
exports.Graph = require("./lib/Graph");
exports.Digraph = require("./lib/Digraph");
exports.CGraph = require("./lib/CGraph");
exports.CDigraph = require("./lib/CDigraph");
require("./lib/graph-converters");
exports.alg = {
isAcyclic: require("./lib/alg/isAcyclic"),
components: require("./lib/alg/components"),
dijkstra: require("./lib/alg/dijkstra"),
dijkstraAll: require("./lib/alg/dijkstraAll"),
findCycles: require("./lib/alg/findCycles"),
floydWarshall: require("./lib/alg/floydWarshall"),
prim: require("./lib/alg/prim"),
tarjan: require("./lib/alg/tarjan"),
topsort: require("./lib/alg/topsort")
};
exports.converter = {
json: require("./lib/converter/json.js")
};
exports.data = {
PriorityQueue: require("./lib/data/PriorityQueue"),
Set: require("./lib/data/Set")
};
var filter = require("./lib/filter");
exports.filter = {
all: filter.all,
nodesFromList: filter.nodesFromList
};
exports.version = require("./lib/version");
},{"./lib/CDigraph":14,"./lib/CGraph":15,"./lib/Digraph":16,"./lib/Graph":17,"./lib/alg/components":18,"./lib/alg/dijkstra":19,"./lib/alg/dijkstraAll":20,"./lib/alg/findCycles":21,"./lib/alg/floydWarshall":22,"./lib/alg/isAcyclic":23,"./lib/alg/prim":24,"./lib/alg/tarjan":25,"./lib/alg/topsort":26,"./lib/converter/json.js":28,"./lib/data/PriorityQueue":29,"./lib/data/Set":30,"./lib/filter":31,"./lib/graph-converters":32,"./lib/version":34}],13:[function(require,module,exports){
var filter = require("./filter"),
/* jshint -W079 */
Set = require("./data/Set");
module.exports = BaseGraph;
function BaseGraph() {
// The value assigned to the graph itself.
this._value = undefined;
// Map of node id -> { id, value }
this._nodes = {};
// Map of edge id -> { id, u, v, value }
this._edges = {};
// Used to generate a unique id in the graph
this._nextId = 0;
}
// Number of nodes
BaseGraph.prototype.order = function() {
return Object.keys(this._nodes).length;
};
// Number of edges
BaseGraph.prototype.size = function() {
return Object.keys(this._edges).length;
};
// Accessor for graph level value
BaseGraph.prototype.graph = function(value) {
if (arguments.length === 0) {
return this._value;
}
this._value = value;
};
BaseGraph.prototype.hasNode = function(u) {
return u in this._nodes;
};
BaseGraph.prototype.node = function(u, value) {
var node = this._strictGetNode(u);
if (arguments.length === 1) {
return node.value;
}
node.value = value;
};
BaseGraph.prototype.nodes = function() {
var nodes = [];
this.eachNode(function(id) { nodes.push(id); });
return nodes;
};
BaseGraph.prototype.eachNode = function(func) {
for (var k in this._nodes) {
var node = this._nodes[k];
func(node.id, node.value);
}
};
BaseGraph.prototype.hasEdge = function(e) {
return e in this._edges;
};
BaseGraph.prototype.edge = function(e, value) {
var edge = this._strictGetEdge(e);
if (arguments.length === 1) {
return edge.value;
}
edge.value = value;
};
BaseGraph.prototype.edges = function() {
var es = [];
this.eachEdge(function(id) { es.push(id); });
return es;
};
BaseGraph.prototype.eachEdge = function(func) {
for (var k in this._edges) {
var edge = this._edges[k];
func(edge.id, edge.u, edge.v, edge.value);
}
};
BaseGraph.prototype.incidentNodes = function(e) {
var edge = this._strictGetEdge(e);
return [edge.u, edge.v];
};
BaseGraph.prototype.addNode = function(u, value) {
if (u === undefined || u === null) {
do {
u = "_" + (++this._nextId);
} while (this.hasNode(u));
} else if (this.hasNode(u)) {
throw new Error("Graph already has node '" + u + "':\n" + this.toString());
}
this._nodes[u] = { id: u, value: value };
return u;
};
BaseGraph.prototype.delNode = function(u) {
this._strictGetNode(u);
this.incidentEdges(u).forEach(function(e) { this.delEdge(e); }, this);
delete this._nodes[u];
};
// inMap and outMap are opposite sides of an incidence map. For example, for
// Graph these would both come from the _incidentEdges map, while for Digraph
// they would come from _inEdges and _outEdges.
BaseGraph.prototype._addEdge = function(e, u, v, value, inMap, outMap) {
this._strictGetNode(u);
this._strictGetNode(v);
if (e === undefined || e === null) {
do {
e = "_" + (++this._nextId);
} while (this.hasEdge(e));
}
else if (this.hasEdge(e)) {
throw new Error("Graph already has edge '" + e + "':\n" + this.toString());
}
this._edges[e] = { id: e, u: u, v: v, value: value };
addEdgeToMap(inMap[v], u, e);
addEdgeToMap(outMap[u], v, e);
return e;
};
// See note for _addEdge regarding inMap and outMap.
BaseGraph.prototype._delEdge = function(e, inMap, outMap) {
var edge = this._strictGetEdge(e);
delEdgeFromMap(inMap[edge.v], edge.u, e);
delEdgeFromMap(outMap[edge.u], edge.v, e);
delete this._edges[e];
};
BaseGraph.prototype.copy = function() {
var copy = new this.constructor();
copy.graph(this.graph);
this.eachNode(function(u, value) { copy.addNode(u, value); });
this.eachEdge(function(e, u, v, value) { copy.addEdge(e, u, v, value); });
return copy;
};
BaseGraph.prototype.filterNodes = function(filter) {
var copy = this.copy();
this.nodes().forEach(function(u) {
if (!filter(u)) {
copy.delNode(u);
}
});
return copy;
};
BaseGraph.prototype._strictGetNode = function(u) {
var node = this._nodes[u];
if (node === undefined) {
throw new Error("Node '" + u + "' is not in graph:\n" + this.toString());
}
return node;
};
BaseGraph.prototype._strictGetEdge = function(e) {
var edge = this._edges[e];
if (edge === undefined) {
throw new Error("Edge '" + e + "' is not in graph:\n" + this.toString());
}
return edge;
};
function addEdgeToMap(map, v, e) {
(map[v] || (map[v] = new Set())).add(e);
}
function delEdgeFromMap(map, v, e) {
var vEntry = map[v];
vEntry.remove(e);
if (vEntry.size() === 0) {
delete map[v];
}
}
},{"./data/Set":30,"./filter":31}],14:[function(require,module,exports){
var Digraph = require("./Digraph"),
compoundify = require("./compoundify");
var CDigraph = compoundify(Digraph);
module.exports = CDigraph;
CDigraph.fromDigraph = function(src) {
var g = new CDigraph(),
graphValue = src.graph();
if (graphValue !== undefined) {
g.graph(graphValue);
}
src.eachNode(function(u, value) {
if (value === undefined) {
g.addNode(u);
} else {
g.addNode(u, value);
}
});
src.eachEdge(function(e, u, v, value) {
if (value === undefined) {
g.addEdge(null, u, v);
} else {
g.addEdge(null, u, v, value);
}
});
return g;
};
CDigraph.prototype.toString = function() {
return "CDigraph " + JSON.stringify(this, null, 2);
};
},{"./Digraph":16,"./compoundify":27}],15:[function(require,module,exports){
var Graph = require("./Graph"),
compoundify = require("./compoundify");
var CGraph = compoundify(Graph);
module.exports = CGraph;
CGraph.fromGraph = function(src) {
var g = new CGraph(),
graphValue = src.graph();
if (graphValue !== undefined) {
g.graph(graphValue);
}
src.eachNode(function(u, value) {
if (value === undefined) {
g.addNode(u);
} else {
g.addNode(u, value);
}
});
src.eachEdge(function(e, u, v, value) {
if (value === undefined) {
g.addEdge(null, u, v);
} else {
g.addEdge(null, u, v, value);
}
});
return g;
};
CGraph.prototype.toString = function() {
return "CGraph " + JSON.stringify(this, null, 2);
};
},{"./Graph":17,"./compoundify":27}],16:[function(require,module,exports){
/*
* This file is organized with in the following order:
*
* Exports
* Graph constructors
* Graph queries (e.g. nodes(), edges()
* Graph mutators
* Helper functions
*/
var util = require("./util"),
BaseGraph = require("./BaseGraph"),
/* jshint -W079 */
Set = require("./data/Set");
module.exports = Digraph;
/*
* Constructor to create a new directed multi-graph.
*/
function Digraph() {
BaseGraph.call(this);
/*! Map of sourceId -> {targetId -> Set of edge ids} */
this._inEdges = {};
/*! Map of targetId -> {sourceId -> Set of edge ids} */
this._outEdges = {};
}
Digraph.prototype = new BaseGraph();
Digraph.prototype.constructor = Digraph;
/*
* Always returns `true`.
*/
Digraph.prototype.isDirected = function() {
return true;
};
/*
* Returns all successors of the node with the id `u`. That is, all nodes
* that have the node `u` as their source are returned.
*
* If no node `u` exists in the graph this function throws an Error.
*
* @param {String} u a node id
*/
Digraph.prototype.successors = function(u) {
this._strictGetNode(u);
return Object.keys(this._outEdges[u])
.map(function(v) { return this._nodes[v].id; }, this);
};
/*
* Returns all predecessors of the node with the id `u`. That is, all nodes
* that have the node `u` as their target are returned.
*
* If no node `u` exists in the graph this function throws an Error.
*
* @param {String} u a node id
*/
Digraph.prototype.predecessors = function(u) {
this._strictGetNode(u);
return Object.keys(this._inEdges[u])
.map(function(v) { return this._nodes[v].id; }, this);
};
/*
* Returns all nodes that are adjacent to the node with the id `u`. In other
* words, this function returns the set of all successors and predecessors of
* node `u`.
*
* @param {String} u a node id
*/
Digraph.prototype.neighbors = function(u) {
return Set.unionAll([this.successors(u), this.predecessors(u)]).keys();
};
/*
* Returns all nodes in the graph that have no in-edges.
*/
Digraph.prototype.sources = function() {
var self = this;
return this._filterNodes(function(u) {
// This could have better space characteristics if we had an inDegree function.
return self.inEdges(u).length === 0;
});
};
/*
* Returns all nodes in the graph that have no out-edges.
*/
Digraph.prototype.sinks = function() {
var self = this;
return this._filterNodes(function(u) {
// This could have better space characteristics if we have an outDegree function.
return self.outEdges(u).length === 0;
});
};
/*
* Returns the source node incident on the edge identified by the id `e`. If no
* such edge exists in the graph this function throws an Error.
*
* @param {String} e an edge id
*/
Digraph.prototype.source = function(e) {
return this._strictGetEdge(e).u;
};
/*
* Returns the target node incident on the edge identified by the id `e`. If no
* such edge exists in the graph this function throws an Error.
*
* @param {String} e an edge id
*/
Digraph.prototype.target = function(e) {
return this._strictGetEdge(e).v;
};
/*
* Returns an array of ids for all edges in the graph that have the node
* `target` as their target. If the node `target` is not in the graph this
* function raises an Error.
*
* Optionally a `source` node can also be specified. This causes the results
* to be filtered such that only edges from `source` to `target` are included.
* If the node `source` is specified but is not in the graph then this function
* raises an Error.
*
* @param {String} target the target node id
* @param {String} [source] an optional source node id
*/
Digraph.prototype.inEdges = function(target, source) {
this._strictGetNode(target);
var results = Set.unionAll(util.values(this._inEdges[target])).keys();
if (arguments.length > 1) {
this._strictGetNode(source);
results = results.filter(function(e) { return this.source(e) === source; }, this);
}
return results;
};
/*
* Returns an array of ids for all edges in the graph that have the node
* `source` as their source. If the node `source` is not in the graph this
* function raises an Error.
*
* Optionally a `target` node may also be specified. This causes the results
* to be filtered such that only edges from `source` to `target` are included.
* If the node `target` is specified but is not in the graph then this function
* raises an Error.
*
* @param {String} source the source node id
* @param {String} [target] an optional target node id
*/
Digraph.prototype.outEdges = function(source, target) {
this._strictGetNode(source);
var results = Set.unionAll(util.values(this._outEdges[source])).keys();
if (arguments.length > 1) {
this._strictGetNode(target);
results = results.filter(function(e) { return this.target(e) === target; }, this);
}
return results;
};
/*
* Returns an array of ids for all edges in the graph that have the `u` as
* their source or their target. If the node `u` is not in the graph this
* function raises an Error.
*
* Optionally a `v` node may also be specified. This causes the results to be
* filtered such that only edges between `u` and `v` - in either direction -
* are included. IF the node `v` is specified but not in the graph then this
* function raises an Error.
*
* @param {String} u the node for which to find incident edges
* @param {String} [v] option node that must be adjacent to `u`
*/
Digraph.prototype.incidentEdges = function(u, v) {
if (arguments.length > 1) {
return Set.unionAll([this.outEdges(u, v), this.outEdges(v, u)]).keys();
} else {
return Set.unionAll([this.inEdges(u), this.outEdges(u)]).keys();
}
};
/*
* Returns a string representation of this graph.
*/
Digraph.prototype.toString = function() {
return "Digraph " + JSON.stringify(this, null, 2);
};
/*
* Adds a new node with the id `u` to the graph and assigns it the value
* `value`. If a node with the id is already a part of the graph this function
* throws an Error.
*
* @param {String} u a node id
* @param {Object} [value] an optional value to attach to the node
*/
Digraph.prototype.addNode = function(u, value) {
u = BaseGraph.prototype.addNode.call(this, u, value);
this._inEdges[u] = {};
this._outEdges[u] = {};
return u;
};
/*
* Removes a node from the graph that has the id `u`. Any edges incident on the
* node are also removed. If the graph does not contain a node with the id this
* function will throw an Error.
*
* @param {String} u a node id
*/
Digraph.prototype.delNode = function(u) {
BaseGraph.prototype.delNode.call(this, u);
delete this._inEdges[u];
delete this._outEdges[u];
};
/*
* Adds a new edge to the graph with the id `e` from a node with the id `source`
* to a node with an id `target` and assigns it the value `value`. This graph
* allows more than one edge from `source` to `target` as long as the id `e`
* is unique in the set of edges. If `e` is `null` the graph will assign a
* unique identifier to the edge.
*
* If `source` or `target` are not present in the graph this function will
* throw an Error.
*
* @param {String} [e] an edge id
* @param {String} source the source node id
* @param {String} target the target node id
* @param {Object} [value] an optional value to attach to the edge
*/
Digraph.prototype.addEdge = function(e, source, target, value) {
return BaseGraph.prototype._addEdge.call(this, e, source, target, value,
this._inEdges, this._outEdges);
};
/*
* Removes an edge in the graph with the id `e`. If no edge in the graph has
* the id `e` this function will throw an Error.
*
* @param {String} e an edge id
*/
Digraph.prototype.delEdge = function(e) {
BaseGraph.prototype._delEdge.call(this, e, this._inEdges, this._outEdges);
};
// Unlike BaseGraph.filterNodes, this helper just returns nodes that
// satisfy a predicate.
Digraph.prototype._filterNodes = function(pred) {
var filtered = [];
this.eachNode(function(u) {
if (pred(u)) {
filtered.push(u);
}
});
return filtered;
};
},{"./BaseGraph":13,"./data/Set":30,"./util":33}],17:[function(require,module,exports){
/*
* This file is organized with in the following order:
*
* Exports
* Graph constructors
* Graph queries (e.g. nodes(), edges()
* Graph mutators
* Helper functions
*/
var util = require("./util"),
BaseGraph = require("./BaseGraph"),
/* jshint -W079 */
Set = require("./data/Set");
module.exports = Graph;
/*
* Constructor to create a new undirected multi-graph.
*/
function Graph() {
BaseGraph.call(this);
/*! Map of nodeId -> { otherNodeId -> Set of edge ids } */
this._incidentEdges = {};
}
Graph.prototype = new BaseGraph();
Graph.prototype.constructor = Graph;
/*
* Always returns `false`.
*/
Graph.prototype.isDirected = function() {
return false;
};
/*
* Returns all nodes that are adjacent to the node with the id `u`.
*
* @param {String} u a node id
*/
Graph.prototype.neighbors = function(u) {
this._strictGetNode(u);
return Object.keys(this._incidentEdges[u])
.map(function(v) { return this._nodes[v].id; }, this);
};
/*
* Returns an array of ids for all edges in the graph that are incident on `u`.
* If the node `u` is not in the graph this function raises an Error.
*
* Optionally a `v` node may also be specified. This causes the results to be
* filtered such that only edges between `u` and `v` are included. If the node
* `v` is specified but not in the graph then this function raises an Error.
*
* @param {String} u the node for which to find incident edges
* @param {String} [v] option node that must be adjacent to `u`
*/
Graph.prototype.incidentEdges = function(u, v) {
this._strictGetNode(u);
if (arguments.length > 1) {
this._strictGetNode(v);
return v in this._incidentEdges[u] ? this._incidentEdges[u][v].keys() : [];
} else {
return Set.unionAll(util.values(this._incidentEdges[u])).keys();
}
};
/*
* Returns a string representation of this graph.
*/
Graph.prototype.toString = function() {
return "Graph " + JSON.stringify(this, null, 2);
};
/*
* Adds a new node with the id `u` to the graph and assigns it the value
* `value`. If a node with the id is already a part of the graph this function
* throws an Error.
*
* @param {String} u a node id
* @param {Object} [value] an optional value to attach to the node
*/
Graph.prototype.addNode = function(u, value) {
u = BaseGraph.prototype.addNode.call(this, u, value);
this._incidentEdges[u] = {};
return u;
};
/*
* Removes a node from the graph that has the id `u`. Any edges incident on the
* node are also removed. If the graph does not contain a node with the id this
* function will throw an Error.
*
* @param {String} u a node id
*/
Graph.prototype.delNode = function(u) {
BaseGraph.prototype.delNode.call(this, u);
delete this._incidentEdges[u];
};
/*
* Adds a new edge to the graph with the id `e` between a node with the id `u`
* and a node with an id `v` and assigns it the value `value`. This graph
* allows more than one edge between `u` and `v` as long as the id `e`
* is unique in the set of edges. If `e` is `null` the graph will assign a
* unique identifier to the edge.
*
* If `u` or `v` are not present in the graph this function will throw an
* Error.
*
* @param {String} [e] an edge id
* @param {String} u the node id of one of the adjacent nodes
* @param {String} v the node id of the other adjacent node
* @param {Object} [value] an optional value to attach to the edge
*/
Graph.prototype.addEdge = function(e, u, v, value) {
return BaseGraph.prototype._addEdge.call(this, e, u, v, value,
this._incidentEdges, this._incidentEdges);
};
/*
* Removes an edge in the graph with the id `e`. If no edge in the graph has
* the id `e` this function will throw an Error.
*
* @param {String} e an edge id
*/
Graph.prototype.delEdge = function(e) {
BaseGraph.prototype._delEdge.call(this, e, this._incidentEdges, this._incidentEdges);
};
},{"./BaseGraph":13,"./data/Set":30,"./util":33}],18:[function(require,module,exports){
var Set = require("../data/Set");
module.exports = components;
/**
* Finds all [connected components][] in a graph and returns an array of these
* components. Each component is itself an array that contains the ids of nodes
* in the component.
*
* This function only works with undirected Graphs.
*
* [connected components]: http://en.wikipedia.org/wiki/Connected_component_(graph_theory)
*
* @param {Graph} g the graph to search for components
*/
function components(g) {
var results = [];
var visited = new Set();
function dfs(v, component) {
if (!visited.has(v)) {
visited.add(v);
component.push(v);
g.neighbors(v).forEach(function(w) {
dfs(w, component);
});
}
}
g.nodes().forEach(function(v) {
var component = [];
dfs(v, component);
if (component.length > 0) {
results.push(component);
}
});
return results;
}
},{"../data/Set":30}],19:[function(require,module,exports){
var PriorityQueue = require("../data/PriorityQueue"),
Digraph = require("../Digraph");
module.exports = dijkstra;
/**
* This function is an implementation of [Dijkstra's algorithm][] which finds
* the shortest path from **source** to all other nodes in **g**. This
* function returns a map of `u -> { distance, predecessor }`. The distance
* property holds the sum of the weights from **source** to `u` along the
* shortest path or `Number.POSITIVE_INFINITY` if there is no path from
* **source**. The predecessor property can be used to walk the individual
* elements of the path from **source** to **u** in reverse order.
*
* This function takes an optional `weightFunc(e)` which returns the
* weight of the edge `e`. If no weightFunc is supplied then each edge is
* assumed to have a weight of 1. This function throws an Error if any of
* the traversed edges have a negative edge weight.
*
* This function takes an optional `incidentFunc(u)` which returns the ids of
* all edges incident to the node `u` for the purposes of shortest path
* traversal. By default this function uses the `g.outEdges` for Digraphs and
* `g.incidentEdges` for Graphs.
*
* This function takes `O((|E| + |V|) * log |V|)` time.
*
* [Dijkstra's algorithm]: http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
*
* @param {Graph} g the graph to search for shortest paths from **source**
* @param {Object} source the source from which to start the search
* @param {Function} [weightFunc] optional weight function
* @param {Function} [incidentFunc] optional incident function
*/
function dijkstra(g, source, weightFunc, incidentFunc) {
var results = {},
pq = new PriorityQueue();
weightFunc = weightFunc || function() { return 1; };
incidentFunc = incidentFunc || (g.isDirected()
? function(u) { return g.outEdges(u); }
: function(u) { return g.incidentEdges(u); });
g.nodes().forEach(function(u) {
var distance = u === source ? 0 : Number.POSITIVE_INFINITY;
results[u] = { distance: distance };
pq.add(u, distance);
});
var u, uEntry;
while (pq.size() > 0) {
u = pq.removeMin();
uEntry = results[u];
if (uEntry.distance === Number.POSITIVE_INFINITY) {
break;
}
incidentFunc(u).forEach(function(e) {
var incidentNodes = g.incidentNodes(e),
v = incidentNodes[0] !== u ? incidentNodes[0] : incidentNodes[1],
vEntry = results[v],
weight = weightFunc(e),
distance = uEntry.distance + weight;
if (weight < 0) {
throw new Error("dijkstra does not allow negative edge weights. Bad edge: " + e + " Weight: " + weight);
}
if (distance < vEntry.distance) {
vEntry.distance = distance;
vEntry.predecessor = u;
pq.decrease(v, distance);
}
});
}
return results;
}
},{"../Digraph":16,"../data/PriorityQueue":29}],20:[function(require,module,exports){
var dijkstra = require("./dijkstra");
module.exports = dijkstraAll;
/**
* This function finds the shortest path from each node to every other
* reachable node in the graph. It is similar to [alg.dijkstra][], but
* instead of returning a single-source array, it returns a mapping of
* of `source -> alg.dijksta(g, source, weightFunc, incidentFunc)`.
*
* This function takes an optional `weightFunc(e)` which returns the
* weight of the edge `e`. If no weightFunc is supplied then each edge is
* assumed to have a weight of 1. This function throws an Error if any of
* the traversed edges have a negative edge weight.
*
* This function takes an optional `incidentFunc(u)` which returns the ids of
* all edges incident to the node `u` for the purposes of shortest path
* traversal. By default this function uses the `outEdges` function on the
* supplied graph.
*
* This function takes `O(|V| * (|E| + |V|) * log |V|)` time.
*
* [alg.dijkstra]: dijkstra.js.html#dijkstra
*
* @param {Graph} g the graph to search for shortest paths from **source**
* @param {Function} [weightFunc] optional weight function
* @param {Function} [incidentFunc] optional incident function
*/
function dijkstraAll(g, weightFunc, incidentFunc) {
var results = {};
g.nodes().forEach(function(u) {
results[u] = dijkstra(g, u, weightFunc, incidentFunc);
});
return results;
}
},{"./dijkstra":19}],21:[function(require,module,exports){
var tarjan = require("./tarjan");
module.exports = findCycles;
/*
* Given a Digraph **g** this function returns all nodes that are part of a
* cycle. Since there may be more than one cycle in a graph this function
* returns an array of these cycles, where each cycle is itself represented
* by an array of ids for each node involved in that cycle.
*
* [alg.isAcyclic][] is more efficient if you only need to determine whether
* a graph has a cycle or not.
*
* [alg.isAcyclic]: isAcyclic.js.html#isAcyclic
*
* @param {Digraph} g the graph to search for cycles.
*/
function findCycles(g) {
return tarjan(g).filter(function(cmpt) { return cmpt.length > 1; });
}
},{"./tarjan":25}],22:[function(require,module,exports){
var Digraph = require("../Digraph");
module.exports = floydWarshall;
/**
* This function is an implementation of the [Floyd-Warshall algorithm][],
* which finds the shortest path from each node to every other reachable node
* in the graph. It is similar to [alg.dijkstraAll][], but it handles negative
* edge weights and is more efficient for some types of graphs. This function
* returns a map of `source -> { target -> { distance, predecessor }`. The
* distance property holds the sum of the weights from `source` to `target`
* along the shortest path of `Number.POSITIVE_INFINITY` if there is no path
* from `source`. The predecessor property can be used to walk the individual
* elements of the path from `source` to `target` in reverse order.
*
* This function takes an optional `weightFunc(e)` which returns the
* weight of the edge `e`. If no weightFunc is supplied then each edge is
* assumed to have a weight of 1.
*
* This function takes an optional `incidentFunc(u)` which returns the ids of
* all edges incident to the node `u` for the purposes of shortest path
* traversal. By default this function uses the `outEdges` function on the
* supplied graph.
*
* This algorithm takes O(|V|^3) time.
*
* [Floyd-Warshall algorithm]: https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm
* [alg.dijkstraAll]: dijkstraAll.js.html#dijkstraAll
*
* @param {Graph} g the graph to search for shortest paths from **source**
* @param {Function} [weightFunc] optional weight function
* @param {Function} [incidentFunc] optional incident function
*/
function floydWarshall(g, weightFunc, incidentFunc) {
var results = {},
nodes = g.nodes();
weightFunc = weightFunc || function() { return 1; };
incidentFunc = incidentFunc || (g.isDirected()
? function(u) { return g.outEdges(u); }
: function(u) { return g.incidentEdges(u); });
nodes.forEach(function(u) {
results[u] = {};
results[u][u] = { distance: 0 };
nodes.forEach(function(v) {
if (u !== v) {
results[u][v] = { distance: Number.POSITIVE_INFINITY };
}
});
incidentFunc(u).forEach(function(e) {
var incidentNodes = g.incidentNodes(e),
v = incidentNodes[0] !== u ? incidentNodes[0] : incidentNodes[1],
d = weightFunc(e);
if (d < results[u][v].distance) {
results[u][v] = { distance: d, predecessor: u };
}
});
});
nodes.forEach(function(k) {
var rowK = results[k];
nodes.forEach(function(i) {
var rowI = results[i];
nodes.forEach(function(j) {
var ik = rowI[k];
var kj = rowK[j];
var ij = rowI[j];
var altDistance = ik.distance + kj.distance;
if (altDistance < ij.distance) {
ij.distance = altDistance;
ij.predecessor = kj.predecessor;
}
});
});
});
return results;
}
},{"../Digraph":16}],23:[function(require,module,exports){
var topsort = require("./topsort");
module.exports = isAcyclic;
/*
* Given a Digraph **g** this function returns `true` if the graph has no
* cycles and returns `false` if it does. This algorithm returns as soon as it
* detects the first cycle.
*
* Use [alg.findCycles][] if you need the actual list of cycles in a graph.
*
* [alg.findCycles]: findCycles.js.html#findCycles
*
* @param {Digraph} g the graph to test for cycles
*/
function isAcyclic(g) {
try {
topsort(g);
} catch (e) {
if (e instanceof topsort.CycleException) return false;
throw e;
}
return true;
}
},{"./topsort":26}],24:[function(require,module,exports){
var Graph = require("../Graph"),
PriorityQueue = require("../data/PriorityQueue");
module.exports = prim;
/**
* [Prim's algorithm][] takes a connected undirected graph and generates a
* [minimum spanning tree][]. This function returns the minimum spanning
* tree as an undirected graph. This algorithm is derived from the description
* in "Introduction to Algorithms", Third Edition, Cormen, et al., Pg 634.
*
* This function takes a `weightFunc(e)` which returns the weight of the edge
* `e`. It throws an Error if the graph is not connected.
*
* This function takes `O(|E| log |V|)` time.
*
* [Prim's algorithm]: https://en.wikipedia.org/wiki/Prim's_algorithm
* [minimum spanning tree]: https://en.wikipedia.org/wiki/Minimum_spanning_tree
*
* @param {Graph} g the graph used to generate the minimum spanning tree
* @param {Function} weightFunc the weight function to use
*/
function prim(g, weightFunc) {
var result = new Graph(),
parents = {},
pq = new PriorityQueue();
if (g.order() === 0) {
return result;
}
g.eachNode(function(u) {
pq.add(u, Number.POSITIVE_INFINITY);
result.addNode(u);
});
// Start from an arbitrary node
pq.decrease(g.nodes()[0], 0);
var init = false;
while (pq.size() > 0) {
var u = pq.removeMin();
if (u in parents) {
result.addEdge(null, u, parents[u]);
} else if (init) {
throw new Error("Input graph is not connected: " + g);
} else {
init = true;
}
g.incidentEdges(u).forEach(function(e) {
var incidentNodes = g.incidentNodes(e),
v = incidentNodes[0] !== u ? incidentNodes[0] : incidentNodes[1],
pri = pq.priority(v);
if (pri !== undefined) {
var edgeWeight = weightFunc(e);
if (edgeWeight < pri) {
parents[v] = u;
pq.decrease(v, edgeWeight);
}
}
});
}
return result;
}
},{"../Graph":17,"../data/PriorityQueue":29}],25:[function(require,module,exports){
var Digraph = require("../Digraph");
module.exports = tarjan;
/**
* This function is an implementation of [Tarjan's algorithm][] which finds
* all [strongly connected components][] in the directed graph **g**. Each
* strongly connected component is composed of nodes that can reach all other
* nodes in the component via directed edges. A strongly connected component
* can consist of a single node if that node cannot both reach and be reached
* by any other specific node in the graph. Components of more than one node
* are guaranteed to have at least one cycle.
*
* This function returns an array of components. Each component is itself an
* array that contains the ids of all nodes in the component.
*
* [Tarjan's algorithm]: http://en.wikipedia.org/wiki/Tarjan's_strongly_connected_components_algorithm
* [strongly connected components]: http://en.wikipedia.org/wiki/Strongly_connected_component
*
* @param {Digraph} g the graph to search for strongly connected components
*/
function tarjan(g) {
if (!g.isDirected()) {
throw new Error("tarjan can only be applied to a directed graph. Bad input: " + g);
}
var index = 0,
stack = [],
visited = {}, // node id -> { onStack, lowlink, index }
results = [];
function dfs(u) {
var entry = visited[u] = {
onStack: true,
lowlink: index,
index: index++
};
stack.push(u);
g.successors(u).forEach(function(v) {
if (!(v in visited)) {
dfs(v);
entry.lowlink = Math.min(entry.lowlink, visited[v].lowlink);
} else if (visited[v].onStack) {
entry.lowlink = Math.min(entry.lowlink, visited[v].index);
}
});
if (entry.lowlink === entry.index) {
var cmpt = [],
v;
do {
v = stack.pop();
visited[v].onStack = false;
cmpt.push(v);
} while (u !== v);
results.push(cmpt);
}
}
g.nodes().forEach(function(u) {
if (!(u in visited)) {
dfs(u);
}
});
return results;
}
},{"../Digraph":16}],26:[function(require,module,exports){
var Digraph = require("../Digraph");
module.exports = topsort;
topsort.CycleException = CycleException;
/*
* Given a graph **g**, this function returns an ordered list of nodes such
* that for each edge `u -> v`, `u` appears before `v` in the list. If the
* graph has a cycle it is impossible to generate such a list and
* **CycleException** is thrown.
*
* See [topological sorting](https://en.wikipedia.org/wiki/Topological_sorting)
* for more details about how this algorithm works.
*
* @param {Digraph} g the graph to sort
*/
function topsort(g) {
if (!g.isDirected()) {
throw new Error("topsort can only be applied to a directed graph. Bad input: " + g);
}
var visited = {};
var stack = {};
var results = [];
function visit(node) {
if (node in stack) {
throw new CycleException();
}
if (!(node in visited)) {
stack[node] = true;
visited[node] = true;
g.predecessors(node).forEach(function(pred) {
visit(pred);
});
delete stack[node];
results.push(node);
}
}
var sinks = g.sinks();
if (g.order() !== 0 && sinks.length === 0) {
throw new CycleException();
}
g.sinks().forEach(function(sink) {
visit(sink);
});
return results;
}
function CycleException() {}
CycleException.prototype.toString = function() {
return "Graph has at least one cycle";
};
},{"../Digraph":16}],27:[function(require,module,exports){
// This file provides a helper function that mixes-in Dot behavior to an
// existing graph prototype.
var /* jshint -W079 */
Set = require("./data/Set");
module.exports = compoundify;
// Extends the given SuperConstructor with the ability for nodes to contain
// other nodes. A special node id `null` is used to indicate the root graph.
function compoundify(SuperConstructor) {
function Constructor() {
SuperConstructor.call(this);
// Map of object id -> parent id (or null for root graph)
this._parents = {};
// Map of id (or null) -> children set
this._children = { null: new Set() };
}
Constructor.prototype = new SuperConstructor();
Constructor.prototype.constructor = Constructor;
Constructor.prototype.parent = function(u, parent) {
this._strictGetNode(u);
if (arguments.length < 2) {
return this._parents[u];
}
if (u === parent) {
throw new Error("Cannot make " + u + " a parent of itself");
}
if (parent !== null) {
this._strictGetNode(parent);
}
this._children[this._parents[u]].remove(u);
this._parents[u] = parent;
this._children[parent].add(u);
};
Constructor.prototype.children = function(u) {
if (u !== null) {
this._strictGetNode(u);
}
return this._children[u].keys();
};
Constructor.prototype.addNode = function(u, value) {
u = SuperConstructor.prototype.addNode.call(this, u, value);
this._parents[u] = null;
this._children[u] = new Set();
this._children[null].add(u);
return u;
};
Constructor.prototype.delNode = function(u) {
// Promote all children to the parent of the subgraph
var parent = this.parent(u);
this._children[u].keys().forEach(function(child) {
this.parent(child, parent);
}, this);
this._children[parent].remove(u);
delete this._parents[u];
delete this._children[u];
return SuperConstructor.prototype.delNode.call(this, u);
};
Constructor.prototype.copy = function() {
var copy = SuperConstructor.prototype.copy.call(this);
this.nodes().forEach(function(u) {
copy.parent(u, this.parent(u));
}, this);
return copy;
};
return Constructor;
}
},{"./data/Set":30}],28:[function(require,module,exports){
var Graph = require("../Graph"),
Digraph = require("../Digraph"),
CGraph = require("../CGraph"),
CDigraph = require("../CDigraph");
exports.decode = function(nodes, edges, Ctor) {
Ctor = Ctor || Digraph;
if (typeOf(nodes) !== "Array") {
throw new Error("nodes is not an Array");
}
if (typeOf(edges) !== "Array") {
throw new Error("edges is not an Array");
}
if (typeof Ctor === "string") {
switch(Ctor) {
case "graph": Ctor = Graph; break;
case "digraph": Ctor = Digraph; break;
case "cgraph": Ctor = CGraph; break;
case "cdigraph": Ctor = CDigraph; break;
default: throw new Error("Unrecognized graph type: " + Ctor);
}
}
var graph = new Ctor();
nodes.forEach(function(u) {
graph.addNode(u.id, u.value);
});
// If the graph is compound, set up children...
if (graph.parent) {
nodes.forEach(function(u) {
if (u.children) {
u.children.forEach(function(v) {
graph.parent(v, u.id);
});
}
});
}
edges.forEach(function(e) {
graph.addEdge(e.id, e.u, e.v, e.value);
});
return graph;
};
exports.encode = function(graph) {
var nodes = [];
var edges = [];
graph.eachNode(function(u, value) {
var node = {id: u, value: value};
if (graph.children) {
var children = graph.children(u);
if (children.length) {
node.children = children;
}
}
nodes.push(node);
});
graph.eachEdge(function(e, u, v, value) {
edges.push({id: e, u: u, v: v, value: value});
});
var type;
if (graph instanceof CDigraph) {
type = "cdigraph";
} else if (graph instanceof CGraph) {
type = "cgraph";
} else if (graph instanceof Digraph) {
type = "digraph";
} else if (graph instanceof Graph) {
type = "graph";
} else {
throw new Error("Couldn't determine type of graph: " + graph);
}
return { nodes: nodes, edges: edges, type: type };
};
function typeOf(obj) {
return Object.prototype.toString.call(obj).slice(8, -1);
}
},{"../CDigraph":14,"../CGraph":15,"../Digraph":16,"../Graph":17}],29:[function(require,module,exports){
module.exports = PriorityQueue;
/**
* A min-priority queue data structure. This algorithm is derived from Cormen,
* et al., "Introduction to Algorithms". The basic idea of a min-priority
* queue is that you can efficiently (in O(1) time) get the smallest key in
* the queue. Adding and removing elements takes O(log n) time. A key can
* have its priority decreased in O(log n) time.
*/
function PriorityQueue() {
this._arr = [];
this._keyIndices = {};
}
/**
* Returns the number of elements in the queue. Takes `O(1)` time.
*/
PriorityQueue.prototype.size = function() {
return this._arr.length;
};
/**
* Returns the keys that are in the queue. Takes `O(n)` time.
*/
PriorityQueue.prototype.keys = function() {
return this._arr.map(function(x) { return x.key; });
};
/**
* Returns `true` if **key** is in the queue and `false` if not.
*/
PriorityQueue.prototype.has = function(key) {
return key in this._keyIndices;
};
/**
* Returns the priority for **key**. If **key** is not present in the queue
* then this function returns `undefined`. Takes `O(1)` time.
*
* @param {Object} key
*/
PriorityQueue.prototype.priority = function(key) {
var index = this._keyIndices[key];
if (index !== undefined) {
return this._arr[index].priority;
}
};
/**
* Returns the key for the minimum element in this queue. If the queue is
* empty this function throws an Error. Takes `O(1)` time.
*/
PriorityQueue.prototype.min = function() {
if (this.size() === 0) {
throw new Error("Queue underflow");
}
return this._arr[0].key;
};
/**
* Inserts a new key into the priority queue. If the key already exists in
* the queue this function returns `false`; otherwise it will return `true`.
* Takes `O(n)` time.
*
* @param {Object} key the key to add
* @param {Number} priority the initial priority for the key
*/
PriorityQueue.prototype.add = function(key, priority) {
if (!(key in this._keyIndices)) {
var entry = {key: key, priority: priority};
var index = this._arr.length;
this._keyIndices[key] = index;
this._arr.push(entry);
this._decrease(index);
return true;
}
return false;
};
/**
* Removes and returns the smallest key in the queue. Takes `O(log n)` time.
*/
PriorityQueue.prototype.removeMin = function() {
this._swap(0, this._arr.length - 1);
var min = this._arr.pop();
delete this._keyIndices[min.key];
this._heapify(0);
return min.key;
};
/**
* Decreases the priority for **key** to **priority**. If the new priority is
* greater than the previous priority, this function will throw an Error.
*
* @param {Object} key the key for which to raise priority
* @param {Number} priority the new priority for the key
*/
PriorityQueue.prototype.decrease = function(key, priority) {
var index = this._keyIndices[key];
if (priority > this._arr[index].priority) {
throw new Error("New priority is greater than current priority. " +
"Key: " + key + " Old: " + this._arr[index].priority + " New: " + priority);
}
this._arr[index].priority = priority;
this._decrease(index);
};
PriorityQueue.prototype._heapify = function(i) {
var arr = this._arr;
var l = 2 * i,
r = l + 1,
largest = i;
if (l < arr.length) {
largest = arr[l].priority < arr[largest].priority ? l : largest;
if (r < arr.length) {
largest = arr[r].priority < arr[largest].priority ? r : largest;
}
if (largest !== i) {
this._swap(i, largest);
this._heapify(largest);
}
}
};
PriorityQueue.prototype._decrease = function(index) {
var arr = this._arr;
var priority = arr[index].priority;
var parent;
while (index > 0) {
parent = index >> 1;
if (arr[parent].priority < priority) {
break;
}
this._swap(index, parent);
index = parent;
}
};
PriorityQueue.prototype._swap = function(i, j) {
var arr = this._arr;
var keyIndices = this._keyIndices;
var tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
keyIndices[arr[i].key] = i;
keyIndices[arr[j].key] = j;
};
},{}],30:[function(require,module,exports){
var util = require("../util");
module.exports = Set;
/**
* Constructs a new Set with an optional set of `initialKeys`.
*
* It is important to note that keys are coerced to String for most purposes
* with this object, similar to the behavior of JavaScript's Object. For
* example, the following will add only one key:
*
* var s = new Set();
* s.add(1);
* s.add("1");
*
* However, the type of the key is preserved internally so that `keys` returns
* the original key set uncoerced. For the above example, `keys` would return
* `[1]`.
*/
function Set(initialKeys) {
this._size = 0;
this._keys = {};
if (initialKeys) {
initialKeys.forEach(function(key) { this.add(key); }, this);
}
}
/**
* Applies the [intersect](#intersect) function to all sets in the given array
* and returns the result as a new Set.
*
* @param {Set[]} sets the sets to intersect
*/
Set.intersectAll = function(sets) {
if (sets.length === 0) {
return new Set();
}
var result = new Set(sets[0].keys());
sets.forEach(function(set) {
result = result.intersect(set);
});
return result;
};
/**
* Applies the [union](#union) function to all sets in the given array and
* returns the result as a new Set.
*
* @param {Set[]} sets the sets to union
*/
Set.unionAll = function(sets) {
var result = new Set();
sets.forEach(function(set) {
result = result.union(set);
});
return result;
};
/**
* Returns the size of this set in `O(1)` time.
*/
Set.prototype.size = function() {
return this._size;
};
/**
* Returns the keys in this set. Takes `O(n)` time.
*/
Set.prototype.keys = function() {
return util.values(this._keys);
};
/**
* Tests if a key is present in this Set. Returns `true` if it is and `false`
* if not. Takes `O(1)` time.
*/
Set.prototype.has = function(key) {
return key in this._keys;
};
/**
* Adds a new key to this Set if it is not already present. Returns `true` if
* the key was added and `false` if it was already present. Takes `O(1)` time.
*/
Set.prototype.add = function(key) {
if (!(key in this._keys)) {
this._keys[key] = key;
++this._size;
return true;
}
return false;
};
/**
* Removes a key from this Set. If the key was removed this function returns
* `true`. If not, it returns `false`. Takes `O(1)` time.
*/
Set.prototype.remove = function(key) {
if (key in this._keys) {
delete this._keys[key];
--this._size;
return true;
}
return false;
};
/**
* Returns a new Set that only contains elements in both this set and the
* `other` set. They keys come from this set.
*
* If `other` is not a Set it is treated as an Array.
*
* @param {Set} other the other set with which to perform an intersection
*/
Set.prototype.intersect = function(other) {
// If the other Set does not look like a Set...
if (!other.keys) {
other = new Set(other);
}
var result = new Set();
this.keys().forEach(function(k) {
if (other.has(k)) {
result.add(k);
}
});
return result;
};
/**
* Returns a new Set that contains all of the keys in `this` set and `other`
* set. If a key is in `this` set, it is used in preference to the `other` set.
*
* If `other` is not a Set it is treated as an Array.
*
* @param {Set} other the other set with which to perform a union
*/
Set.prototype.union = function(other) {
if (!(other instanceof Set)) {
other = new Set(other);
}
var result = new Set(this.keys());
other.keys().forEach(function(k) {
result.add(k);
});
return result;
};
},{"../util":33}],31:[function(require,module,exports){
/* jshint -W079 */
var Set = require("./data/Set");
exports.all = function() {
return function() { return true; };
};
exports.nodesFromList = function(nodes) {
var set = new Set(nodes);
return function(u) {
return set.has(u);
};
};
},{"./data/Set":30}],32:[function(require,module,exports){
var Graph = require("./Graph"),
Digraph = require("./Digraph");
// Side-effect based changes are lousy, but node doesn't seem to resolve the
// requires cycle.
/**
* Returns a new directed graph using the nodes and edges from this graph. The
* new graph will have the same nodes, but will have twice the number of edges:
* each edge is split into two edges with opposite directions. Edge ids,
* consequently, are not preserved by this transformation.
*/
Graph.prototype.toDigraph =
Graph.prototype.asDirected = function() {
var g = new Digraph();
this.eachNode(function(u, value) { g.addNode(u, value); });
this.eachEdge(function(e, u, v, value) {
g.addEdge(null, u, v, value);
g.addEdge(null, v, u, value);
});
return g;
};
/**
* Returns a new undirected graph using the nodes and edges from this graph.
* The new graph will have the same nodes, but the edges will be made
* undirected. Edge ids are preserved in this transformation.
*/
Digraph.prototype.toGraph =
Digraph.prototype.asUndirected = function() {
var g = new Graph();
this.eachNode(function(u, value) { g.addNode(u, value); });
this.eachEdge(function(e, u, v, value) {
g.addEdge(e, u, v, value);
});
return g;
};
},{"./Digraph":16,"./Graph":17}],33:[function(require,module,exports){
// Returns an array of all values for properties of **o**.
exports.values = function(o) {
return Object.keys(o).map(function(k) { return o[k]; });
};
},{}],34:[function(require,module,exports){
module.exports = '0.5.7';
},{}]},{},[1])
;
|
/**
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @flow
*/
import * as React from 'react';
import {Fragment} from 'react';
import styles from './EditableValue.css';
import {useEditableValue} from '../hooks';
type OverrideValueFn = (path: Array<string | number>, value: any) => void;
type EditableValueProps = {|
className?: string,
overrideValue: OverrideValueFn,
path: Array<string | number>,
value: any,
|};
export default function EditableValue({
className = '',
overrideValue,
path,
value,
}: EditableValueProps) {
const [state, dispatch] = useEditableValue(value);
const {editableValue, hasPendingChanges, isValid, parsedValue} = state;
const reset = () =>
dispatch({
type: 'RESET',
externalValue: value,
});
const handleChange = ({target}) =>
dispatch({
type: 'UPDATE',
editableValue: target.value,
externalValue: value,
});
const handleCheckBoxToggle = ({target}) => {
dispatch({
type: 'UPDATE',
editableValue: target.checked,
externalValue: value,
});
// Unlike <input type="text"> which has both an onChange and an onBlur,
// <input type="checkbox"> updates state *and* applies changes in a single event.
// So we read from target.checked rather than parsedValue (which has not yet updated).
// We also don't check isValid (because that hasn't changed yet either);
// we don't need to check it anyway, since target.checked is always a boolean.
overrideValue(path, target.checked);
};
const handleKeyDown = event => {
// Prevent keydown events from e.g. change selected element in the tree
event.stopPropagation();
switch (event.key) {
case 'Enter':
applyChanges();
break;
case 'Escape':
reset();
break;
default:
break;
}
};
const applyChanges = () => {
if (isValid && hasPendingChanges) {
overrideValue(path, parsedValue);
}
};
let placeholder = '';
if (editableValue === undefined) {
placeholder = '(undefined)';
} else {
placeholder = 'Enter valid JSON';
}
const isBool = parsedValue === true || parsedValue === false;
return (
<Fragment>
<input
autoComplete="new-password"
className={`${isValid ? styles.Input : styles.Invalid} ${className}`}
data-testname="EditableValue"
onBlur={applyChanges}
onChange={handleChange}
onKeyDown={handleKeyDown}
placeholder={placeholder}
type="text"
value={editableValue}
/>
{isBool && (
<input
className={styles.Checkbox}
checked={parsedValue}
type="checkbox"
onChange={handleCheckBoxToggle}
/>
)}
</Fragment>
);
}
|
/**
* Movement Class
* Support Hammer and custom horizontal sliding
*/
class Movement {
constructor(event) {
this.initiated = false;
if (event) { this.push(event); }
}
/**
* Save initX and lastX
* @param event
*/
push(event) {
this.speedX = event.velocityX;
if (!this.initiated) {
this.initX = event.changedPointers[0].pageX;
this.initiated = true;
return;
}
this.lastX = event.changedPointers[0].pageX;
}
}
export default Movement;
|
(function() {
module.exports = {
Request: require('./Request'),
Response: require('./Response'),
ResponseCode: require('./ResponseCode')
};
}).call(this);
//# sourceMappingURL=index.js.map
|
// Copyright 2009 the Sputnik authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
/**
* @name: S15.10.7.4_A8;
* @section: 15.10.7.4;
* @assertion: The RegExp instance multiline property has the attribute DontEnum;
* @description: Checking if enumerating the multiline property of RegExp instance fails;
*/
__re = new RegExp("[\u0041-\u0049]");
//CHECK#0
if (__re.hasOwnProperty('multiline') !== true) {
$FAIL('#0: __re = new RegExp("[\\u0041-\\u0049]"); __re.hasOwnProperty(\'multiline\') === true');
}
//CHECK#1
if (__re.propertyIsEnumerable('multiline') !== false) {
$ERROR('#1: __re = new RegExp("[\\u0041-\\u0049]"); __re.propertyIsEnumerable(\'multiline\') === false');
}
//CHECK#2
count = 0
for (p in __re){
if (p==="multiline") count++
}
if (count !== 0) {
$ERROR('#2: count = 0; __re = new RegExp("[\\u0041-\\u0049]"); for (p in __re){ if (p==="multiline") count++; } count === 0. Actual: ' + (count));
}
|
// warning: This file is auto generated by `npm run build:tests`
// Do not edit by hand!
process.env.TZ = 'UTC'
var expect = require('chai').expect
var ini_set = require('../../../../src/php/info/ini_set') // eslint-disable-line no-unused-vars,camelcase
var ini_get = require('../../../../src/php/info/ini_get') // eslint-disable-line no-unused-vars,camelcase
var log1p = require('../../../../src/php/math/log1p.js') // eslint-disable-line no-unused-vars,camelcase
describe('src/php/math/log1p.js (tested in test/languages/php/math/test-log1p.js)', function () {
it('should pass example 1', function (done) {
var expected = 9.999999999999995e-16
var result = log1p(1e-15)
expect(result).to.deep.equal(expected)
done()
})
})
|
'use strict';
angular.module('PowwowNinjaApp')
.controller('MeetingCtrl', function () {
});
|
/*
* jQuery Mobile v1.4.2
* http://jquerymobile.com
*
* Copyright 2010, 2014 jQuery Foundation, Inc. and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
*/
(function ( root, doc, factory ) {
if ( typeof define === "function" && define.amd ) {
// AMD. Register as an anonymous module.
define( [ "jquery" ], function ( $ ) {
factory( $, root, doc );
return $.mobile;
});
} else {
// Browser globals
factory( root.jQuery, root, doc );
}
}( this, document, function ( jQuery, window, document, undefined ) {
/*!
* jQuery hashchange event - v1.3 - 7/21/2010
* http://benalman.com/projects/jquery-hashchange-plugin/
*
* Copyright (c) 2010 "Cowboy" Ben Alman
* Dual licensed under the MIT and GPL licenses.
* http://benalman.com/about/license/
*/
// Script: jQuery hashchange event
//
// *Version: 1.3, Last updated: 7/21/2010*
//
// Project Home - http://benalman.com/projects/jquery-hashchange-plugin/
// GitHub - http://github.com/cowboy/jquery-hashchange/
// Source - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.js
// (Minified) - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.min.js (0.8kb gzipped)
//
// About: License
//
// Copyright (c) 2010 "Cowboy" Ben Alman,
// Dual licensed under the MIT and GPL licenses.
// http://benalman.com/about/license/
//
// About: Examples
//
// These working examples, complete with fully commented code, illustrate a few
// ways in which this plugin can be used.
//
// hashchange event - http://benalman.com/code/projects/jquery-hashchange/examples/hashchange/
// document.domain - http://benalman.com/code/projects/jquery-hashchange/examples/document_domain/
//
// About: Support and Testing
//
// Information about what version or versions of jQuery this plugin has been
// tested with, what browsers it has been tested in, and where the unit tests
// reside (so you can test it yourself).
//
// jQuery Versions - 1.2.6, 1.3.2, 1.4.1, 1.4.2
// Browsers Tested - Internet Explorer 6-8, Firefox 2-4, Chrome 5-6, Safari 3.2-5,
// Opera 9.6-10.60, iPhone 3.1, Android 1.6-2.2, BlackBerry 4.6-5.
// Unit Tests - http://benalman.com/code/projects/jquery-hashchange/unit/
//
// About: Known issues
//
// While this jQuery hashchange event implementation is quite stable and
// robust, there are a few unfortunate browser bugs surrounding expected
// hashchange event-based behaviors, independent of any JavaScript
// window.onhashchange abstraction. See the following examples for more
// information:
//
// Chrome: Back Button - http://benalman.com/code/projects/jquery-hashchange/examples/bug-chrome-back-button/
// Firefox: Remote XMLHttpRequest - http://benalman.com/code/projects/jquery-hashchange/examples/bug-firefox-remote-xhr/
// WebKit: Back Button in an Iframe - http://benalman.com/code/projects/jquery-hashchange/examples/bug-webkit-hash-iframe/
// Safari: Back Button from a different domain - http://benalman.com/code/projects/jquery-hashchange/examples/bug-safari-back-from-diff-domain/
//
// Also note that should a browser natively support the window.onhashchange
// event, but not report that it does, the fallback polling loop will be used.
//
// About: Release History
//
// 1.3 - (7/21/2010) Reorganized IE6/7 Iframe code to make it more
// "removable" for mobile-only development. Added IE6/7 document.title
// support. Attempted to make Iframe as hidden as possible by using
// techniques from http://www.paciellogroup.com/blog/?p=604. Added
// support for the "shortcut" format $(window).hashchange( fn ) and
// $(window).hashchange() like jQuery provides for built-in events.
// Renamed jQuery.hashchangeDelay to <jQuery.fn.hashchange.delay> and
// lowered its default value to 50. Added <jQuery.fn.hashchange.domain>
// and <jQuery.fn.hashchange.src> properties plus document-domain.html
// file to address access denied issues when setting document.domain in
// IE6/7.
// 1.2 - (2/11/2010) Fixed a bug where coming back to a page using this plugin
// from a page on another domain would cause an error in Safari 4. Also,
// IE6/7 Iframe is now inserted after the body (this actually works),
// which prevents the page from scrolling when the event is first bound.
// Event can also now be bound before DOM ready, but it won't be usable
// before then in IE6/7.
// 1.1 - (1/21/2010) Incorporated document.documentMode test to fix IE8 bug
// where browser version is incorrectly reported as 8.0, despite
// inclusion of the X-UA-Compatible IE=EmulateIE7 meta tag.
// 1.0 - (1/9/2010) Initial Release. Broke out the jQuery BBQ event.special
// window.onhashchange functionality into a separate plugin for users
// who want just the basic event & back button support, without all the
// extra awesomeness that BBQ provides. This plugin will be included as
// part of jQuery BBQ, but also be available separately.
(function($,window,undefined){
'$:nomunge'; // Used by YUI compressor.
// Reused string.
var str_hashchange = 'hashchange',
// Method / object references.
doc = document,
fake_onhashchange,
special = $.event.special,
// Does the browser support window.onhashchange? Note that IE8 running in
// IE7 compatibility mode reports true for 'onhashchange' in window, even
// though the event isn't supported, so also test document.documentMode.
doc_mode = doc.documentMode,
supports_onhashchange = 'on' + str_hashchange in window && ( doc_mode === undefined || doc_mode > 7 );
// Get location.hash (or what you'd expect location.hash to be) sans any
// leading #. Thanks for making this necessary, Firefox!
function get_fragment( url ) {
url = url || location.href;
return '#' + url.replace( /^[^#]*#?(.*)$/, '$1' );
};
// Method: jQuery.fn.hashchange
//
// Bind a handler to the window.onhashchange event or trigger all bound
// window.onhashchange event handlers. This behavior is consistent with
// jQuery's built-in event handlers.
//
// Usage:
//
// > jQuery(window).hashchange( [ handler ] );
//
// Arguments:
//
// handler - (Function) Optional handler to be bound to the hashchange
// event. This is a "shortcut" for the more verbose form:
// jQuery(window).bind( 'hashchange', handler ). If handler is omitted,
// all bound window.onhashchange event handlers will be triggered. This
// is a shortcut for the more verbose
// jQuery(window).trigger( 'hashchange' ). These forms are described in
// the <hashchange event> section.
//
// Returns:
//
// (jQuery) The initial jQuery collection of elements.
// Allow the "shortcut" format $(elem).hashchange( fn ) for binding and
// $(elem).hashchange() for triggering, like jQuery does for built-in events.
$.fn[ str_hashchange ] = function( fn ) {
return fn ? this.bind( str_hashchange, fn ) : this.trigger( str_hashchange );
};
// Property: jQuery.fn.hashchange.delay
//
// The numeric interval (in milliseconds) at which the <hashchange event>
// polling loop executes. Defaults to 50.
// Property: jQuery.fn.hashchange.domain
//
// If you're setting document.domain in your JavaScript, and you want hash
// history to work in IE6/7, not only must this property be set, but you must
// also set document.domain BEFORE jQuery is loaded into the page. This
// property is only applicable if you are supporting IE6/7 (or IE8 operating
// in "IE7 compatibility" mode).
//
// In addition, the <jQuery.fn.hashchange.src> property must be set to the
// path of the included "document-domain.html" file, which can be renamed or
// modified if necessary (note that the document.domain specified must be the
// same in both your main JavaScript as well as in this file).
//
// Usage:
//
// jQuery.fn.hashchange.domain = document.domain;
// Property: jQuery.fn.hashchange.src
//
// If, for some reason, you need to specify an Iframe src file (for example,
// when setting document.domain as in <jQuery.fn.hashchange.domain>), you can
// do so using this property. Note that when using this property, history
// won't be recorded in IE6/7 until the Iframe src file loads. This property
// is only applicable if you are supporting IE6/7 (or IE8 operating in "IE7
// compatibility" mode).
//
// Usage:
//
// jQuery.fn.hashchange.src = 'path/to/file.html';
$.fn[ str_hashchange ].delay = 50;
/*
$.fn[ str_hashchange ].domain = null;
$.fn[ str_hashchange ].src = null;
*/
// Event: hashchange event
//
// Fired when location.hash changes. In browsers that support it, the native
// HTML5 window.onhashchange event is used, otherwise a polling loop is
// initialized, running every <jQuery.fn.hashchange.delay> milliseconds to
// see if the hash has changed. In IE6/7 (and IE8 operating in "IE7
// compatibility" mode), a hidden Iframe is created to allow the back button
// and hash-based history to work.
//
// Usage as described in <jQuery.fn.hashchange>:
//
// > // Bind an event handler.
// > jQuery(window).hashchange( function(e) {
// > var hash = location.hash;
// > ...
// > });
// >
// > // Manually trigger the event handler.
// > jQuery(window).hashchange();
//
// A more verbose usage that allows for event namespacing:
//
// > // Bind an event handler.
// > jQuery(window).bind( 'hashchange', function(e) {
// > var hash = location.hash;
// > ...
// > });
// >
// > // Manually trigger the event handler.
// > jQuery(window).trigger( 'hashchange' );
//
// Additional Notes:
//
// * The polling loop and Iframe are not created until at least one handler
// is actually bound to the 'hashchange' event.
// * If you need the bound handler(s) to execute immediately, in cases where
// a location.hash exists on page load, via bookmark or page refresh for
// example, use jQuery(window).hashchange() or the more verbose
// jQuery(window).trigger( 'hashchange' ).
// * The event can be bound before DOM ready, but since it won't be usable
// before then in IE6/7 (due to the necessary Iframe), recommended usage is
// to bind it inside a DOM ready handler.
// Override existing $.event.special.hashchange methods (allowing this plugin
// to be defined after jQuery BBQ in BBQ's source code).
special[ str_hashchange ] = $.extend( special[ str_hashchange ], {
// Called only when the first 'hashchange' event is bound to window.
setup: function() {
// If window.onhashchange is supported natively, there's nothing to do..
if ( supports_onhashchange ) { return false; }
// Otherwise, we need to create our own. And we don't want to call this
// until the user binds to the event, just in case they never do, since it
// will create a polling loop and possibly even a hidden Iframe.
$( fake_onhashchange.start );
},
// Called only when the last 'hashchange' event is unbound from window.
teardown: function() {
// If window.onhashchange is supported natively, there's nothing to do..
if ( supports_onhashchange ) { return false; }
// Otherwise, we need to stop ours (if possible).
$( fake_onhashchange.stop );
}
});
// fake_onhashchange does all the work of triggering the window.onhashchange
// event for browsers that don't natively support it, including creating a
// polling loop to watch for hash changes and in IE 6/7 creating a hidden
// Iframe to enable back and forward.
fake_onhashchange = (function(){
var self = {},
timeout_id,
// Remember the initial hash so it doesn't get triggered immediately.
last_hash = get_fragment(),
fn_retval = function(val){ return val; },
history_set = fn_retval,
history_get = fn_retval;
// Start the polling loop.
self.start = function() {
timeout_id || poll();
};
// Stop the polling loop.
self.stop = function() {
timeout_id && clearTimeout( timeout_id );
timeout_id = undefined;
};
// This polling loop checks every $.fn.hashchange.delay milliseconds to see
// if location.hash has changed, and triggers the 'hashchange' event on
// window when necessary.
function poll() {
var hash = get_fragment(),
history_hash = history_get( last_hash );
if ( hash !== last_hash ) {
history_set( last_hash = hash, history_hash );
$(window).trigger( str_hashchange );
} else if ( history_hash !== last_hash ) {
location.href = location.href.replace( /#.*/, '' ) + history_hash;
}
timeout_id = setTimeout( poll, $.fn[ str_hashchange ].delay );
};
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
// vvvvvvvvvvvvvvvvvvv REMOVE IF NOT SUPPORTING IE6/7/8 vvvvvvvvvvvvvvvvvvv
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
window.attachEvent && !window.addEventListener && !supports_onhashchange && (function(){
// Not only do IE6/7 need the "magical" Iframe treatment, but so does IE8
// when running in "IE7 compatibility" mode.
var iframe,
iframe_src;
// When the event is bound and polling starts in IE 6/7, create a hidden
// Iframe for history handling.
self.start = function(){
if ( !iframe ) {
iframe_src = $.fn[ str_hashchange ].src;
iframe_src = iframe_src && iframe_src + get_fragment();
// Create hidden Iframe. Attempt to make Iframe as hidden as possible
// by using techniques from http://www.paciellogroup.com/blog/?p=604.
iframe = $('<iframe tabindex="-1" title="empty"/>').hide()
// When Iframe has completely loaded, initialize the history and
// start polling.
.one( 'load', function(){
iframe_src || history_set( get_fragment() );
poll();
})
// Load Iframe src if specified, otherwise nothing.
.attr( 'src', iframe_src || 'javascript:0' )
// Append Iframe after the end of the body to prevent unnecessary
// initial page scrolling (yes, this works).
.insertAfter( 'body' )[0].contentWindow;
// Whenever `document.title` changes, update the Iframe's title to
// prettify the back/next history menu entries. Since IE sometimes
// errors with "Unspecified error" the very first time this is set
// (yes, very useful) wrap this with a try/catch block.
doc.onpropertychange = function(){
try {
if ( event.propertyName === 'title' ) {
iframe.document.title = doc.title;
}
} catch(e) {}
};
}
};
// Override the "stop" method since an IE6/7 Iframe was created. Even
// if there are no longer any bound event handlers, the polling loop
// is still necessary for back/next to work at all!
self.stop = fn_retval;
// Get history by looking at the hidden Iframe's location.hash.
history_get = function() {
return get_fragment( iframe.location.href );
};
// Set a new history item by opening and then closing the Iframe
// document, *then* setting its location.hash. If document.domain has
// been set, update that as well.
history_set = function( hash, history_hash ) {
var iframe_doc = iframe.document,
domain = $.fn[ str_hashchange ].domain;
if ( hash !== history_hash ) {
// Update Iframe with any initial `document.title` that might be set.
iframe_doc.title = doc.title;
// Opening the Iframe's document after it has been closed is what
// actually adds a history entry.
iframe_doc.open();
// Set document.domain for the Iframe document as well, if necessary.
domain && iframe_doc.write( '<script>document.domain="' + domain + '"</script>' );
iframe_doc.close();
// Update the Iframe's hash, for great justice.
iframe.location.hash = hash;
}
};
})();
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^ REMOVE IF NOT SUPPORTING IE6/7/8 ^^^^^^^^^^^^^^^^^^^
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
return self;
})();
})(jQuery,this);
(function( $ ) {
$.mobile = {};
}( jQuery ));
(function( $, window, undefined ) {
$.extend( $.mobile, {
// Version of the jQuery Mobile Framework
version: "1.4.2",
// Deprecated and no longer used in 1.4 remove in 1.5
// Define the url parameter used for referencing widget-generated sub-pages.
// Translates to example.html&ui-page=subpageIdentifier
// hash segment before &ui-page= is used to make Ajax request
subPageUrlKey: "ui-page",
hideUrlBar: true,
// Keepnative Selector
keepNative: ":jqmData(role='none'), :jqmData(role='nojs')",
// Deprecated in 1.4 remove in 1.5
// Class assigned to page currently in view, and during transitions
activePageClass: "ui-page-active",
// Deprecated in 1.4 remove in 1.5
// Class used for "active" button state, from CSS framework
activeBtnClass: "ui-btn-active",
// Deprecated in 1.4 remove in 1.5
// Class used for "focus" form element state, from CSS framework
focusClass: "ui-focus",
// Automatically handle clicks and form submissions through Ajax, when same-domain
ajaxEnabled: true,
// Automatically load and show pages based on location.hash
hashListeningEnabled: true,
// disable to prevent jquery from bothering with links
linkBindingEnabled: true,
// Set default page transition - 'none' for no transitions
defaultPageTransition: "fade",
// Set maximum window width for transitions to apply - 'false' for no limit
maxTransitionWidth: false,
// Minimum scroll distance that will be remembered when returning to a page
// Deprecated remove in 1.5
minScrollBack: 0,
// Set default dialog transition - 'none' for no transitions
defaultDialogTransition: "pop",
// Error response message - appears when an Ajax page request fails
pageLoadErrorMessage: "Error Loading Page",
// For error messages, which theme does the box uses?
pageLoadErrorMessageTheme: "a",
// replace calls to window.history.back with phonegaps navigation helper
// where it is provided on the window object
phonegapNavigationEnabled: false,
//automatically initialize the DOM when it's ready
autoInitializePage: true,
pushStateEnabled: true,
// allows users to opt in to ignoring content by marking a parent element as
// data-ignored
ignoreContentEnabled: false,
buttonMarkup: {
hoverDelay: 200
},
// disable the alteration of the dynamic base tag or links in the case
// that a dynamic base tag isn't supported
dynamicBaseEnabled: true,
// default the property to remove dependency on assignment in init module
pageContainer: $(),
//enable cross-domain page support
allowCrossDomainPages: false,
dialogHashKey: "&ui-state=dialog"
});
})( jQuery, this );
(function( $, window, undefined ) {
var nsNormalizeDict = {},
oldFind = $.find,
rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
jqmDataRE = /:jqmData\(([^)]*)\)/g;
$.extend( $.mobile, {
// Namespace used framework-wide for data-attrs. Default is no namespace
ns: "",
// Retrieve an attribute from an element and perform some massaging of the value
getAttribute: function( element, key ) {
var data;
element = element.jquery ? element[0] : element;
if ( element && element.getAttribute ) {
data = element.getAttribute( "data-" + $.mobile.ns + key );
}
// Copied from core's src/data.js:dataAttr()
// Convert from a string to a proper data type
try {
data = data === "true" ? true :
data === "false" ? false :
data === "null" ? null :
// Only convert to a number if it doesn't change the string
+data + "" === data ? +data :
rbrace.test( data ) ? JSON.parse( data ) :
data;
} catch( err ) {}
return data;
},
// Expose our cache for testing purposes.
nsNormalizeDict: nsNormalizeDict,
// Take a data attribute property, prepend the namespace
// and then camel case the attribute string. Add the result
// to our nsNormalizeDict so we don't have to do this again.
nsNormalize: function( prop ) {
return nsNormalizeDict[ prop ] ||
( nsNormalizeDict[ prop ] = $.camelCase( $.mobile.ns + prop ) );
},
// Find the closest javascript page element to gather settings data jsperf test
// http://jsperf.com/single-complex-selector-vs-many-complex-selectors/edit
// possibly naive, but it shows that the parsing overhead for *just* the page selector vs
// the page and dialog selector is negligable. This could probably be speed up by
// doing a similar parent node traversal to the one found in the inherited theme code above
closestPageData: function( $target ) {
return $target
.closest( ":jqmData(role='page'), :jqmData(role='dialog')" )
.data( "mobile-page" );
}
});
// Mobile version of data and removeData and hasData methods
// ensures all data is set and retrieved using jQuery Mobile's data namespace
$.fn.jqmData = function( prop, value ) {
var result;
if ( typeof prop !== "undefined" ) {
if ( prop ) {
prop = $.mobile.nsNormalize( prop );
}
// undefined is permitted as an explicit input for the second param
// in this case it returns the value and does not set it to undefined
if ( arguments.length < 2 || value === undefined ) {
result = this.data( prop );
} else {
result = this.data( prop, value );
}
}
return result;
};
$.jqmData = function( elem, prop, value ) {
var result;
if ( typeof prop !== "undefined" ) {
result = $.data( elem, prop ? $.mobile.nsNormalize( prop ) : prop, value );
}
return result;
};
$.fn.jqmRemoveData = function( prop ) {
return this.removeData( $.mobile.nsNormalize( prop ) );
};
$.jqmRemoveData = function( elem, prop ) {
return $.removeData( elem, $.mobile.nsNormalize( prop ) );
};
$.find = function( selector, context, ret, extra ) {
if ( selector.indexOf( ":jqmData" ) > -1 ) {
selector = selector.replace( jqmDataRE, "[data-" + ( $.mobile.ns || "" ) + "$1]" );
}
return oldFind.call( this, selector, context, ret, extra );
};
$.extend( $.find, oldFind );
})( jQuery, this );
/*!
* jQuery UI Core c0ab71056b936627e8a7821f03c044aec6280a40
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/category/ui-core/
*/
(function( $, undefined ) {
var uuid = 0,
runiqueId = /^ui-id-\d+$/;
// $.ui might exist from components with no dependencies, e.g., $.ui.position
$.ui = $.ui || {};
$.extend( $.ui, {
version: "c0ab71056b936627e8a7821f03c044aec6280a40",
keyCode: {
BACKSPACE: 8,
COMMA: 188,
DELETE: 46,
DOWN: 40,
END: 35,
ENTER: 13,
ESCAPE: 27,
HOME: 36,
LEFT: 37,
PAGE_DOWN: 34,
PAGE_UP: 33,
PERIOD: 190,
RIGHT: 39,
SPACE: 32,
TAB: 9,
UP: 38
}
});
// plugins
$.fn.extend({
focus: (function( orig ) {
return function( delay, fn ) {
return typeof delay === "number" ?
this.each(function() {
var elem = this;
setTimeout(function() {
$( elem ).focus();
if ( fn ) {
fn.call( elem );
}
}, delay );
}) :
orig.apply( this, arguments );
};
})( $.fn.focus ),
scrollParent: function() {
var scrollParent;
if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
scrollParent = this.parents().filter(function() {
return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
}).eq(0);
} else {
scrollParent = this.parents().filter(function() {
return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
}).eq(0);
}
return ( /fixed/ ).test( this.css( "position") ) || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
},
uniqueId: function() {
return this.each(function() {
if ( !this.id ) {
this.id = "ui-id-" + (++uuid);
}
});
},
removeUniqueId: function() {
return this.each(function() {
if ( runiqueId.test( this.id ) ) {
$( this ).removeAttr( "id" );
}
});
}
});
// selectors
function focusable( element, isTabIndexNotNaN ) {
var map, mapName, img,
nodeName = element.nodeName.toLowerCase();
if ( "area" === nodeName ) {
map = element.parentNode;
mapName = map.name;
if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
return false;
}
img = $( "img[usemap=#" + mapName + "]" )[0];
return !!img && visible( img );
}
return ( /input|select|textarea|button|object/.test( nodeName ) ?
!element.disabled :
"a" === nodeName ?
element.href || isTabIndexNotNaN :
isTabIndexNotNaN) &&
// the element and all of its ancestors must be visible
visible( element );
}
function visible( element ) {
return $.expr.filters.visible( element ) &&
!$( element ).parents().addBack().filter(function() {
return $.css( this, "visibility" ) === "hidden";
}).length;
}
$.extend( $.expr[ ":" ], {
data: $.expr.createPseudo ?
$.expr.createPseudo(function( dataName ) {
return function( elem ) {
return !!$.data( elem, dataName );
};
}) :
// support: jQuery <1.8
function( elem, i, match ) {
return !!$.data( elem, match[ 3 ] );
},
focusable: function( element ) {
return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
},
tabbable: function( element ) {
var tabIndex = $.attr( element, "tabindex" ),
isTabIndexNaN = isNaN( tabIndex );
return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
}
});
// support: jQuery <1.8
if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
$.each( [ "Width", "Height" ], function( i, name ) {
var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
type = name.toLowerCase(),
orig = {
innerWidth: $.fn.innerWidth,
innerHeight: $.fn.innerHeight,
outerWidth: $.fn.outerWidth,
outerHeight: $.fn.outerHeight
};
function reduce( elem, size, border, margin ) {
$.each( side, function() {
size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
if ( border ) {
size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
}
if ( margin ) {
size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
}
});
return size;
}
$.fn[ "inner" + name ] = function( size ) {
if ( size === undefined ) {
return orig[ "inner" + name ].call( this );
}
return this.each(function() {
$( this ).css( type, reduce( this, size ) + "px" );
});
};
$.fn[ "outer" + name] = function( size, margin ) {
if ( typeof size !== "number" ) {
return orig[ "outer" + name ].call( this, size );
}
return this.each(function() {
$( this).css( type, reduce( this, size, true, margin ) + "px" );
});
};
});
}
// support: jQuery <1.8
if ( !$.fn.addBack ) {
$.fn.addBack = function( selector ) {
return this.add( selector == null ?
this.prevObject : this.prevObject.filter( selector )
);
};
}
// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
$.fn.removeData = (function( removeData ) {
return function( key ) {
if ( arguments.length ) {
return removeData.call( this, $.camelCase( key ) );
} else {
return removeData.call( this );
}
};
})( $.fn.removeData );
}
// deprecated
$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
$.support.selectstart = "onselectstart" in document.createElement( "div" );
$.fn.extend({
disableSelection: function() {
return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
".ui-disableSelection", function( event ) {
event.preventDefault();
});
},
enableSelection: function() {
return this.unbind( ".ui-disableSelection" );
},
zIndex: function( zIndex ) {
if ( zIndex !== undefined ) {
return this.css( "zIndex", zIndex );
}
if ( this.length ) {
var elem = $( this[ 0 ] ), position, value;
while ( elem.length && elem[ 0 ] !== document ) {
// Ignore z-index if position is set to a value where z-index is ignored by the browser
// This makes behavior of this function consistent across browsers
// WebKit always returns auto if the element is positioned
position = elem.css( "position" );
if ( position === "absolute" || position === "relative" || position === "fixed" ) {
// IE returns 0 when zIndex is not specified
// other browsers return a string
// we ignore the case of nested elements with an explicit value of 0
// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
value = parseInt( elem.css( "zIndex" ), 10 );
if ( !isNaN( value ) && value !== 0 ) {
return value;
}
}
elem = elem.parent();
}
}
return 0;
}
});
// $.ui.plugin is deprecated. Use $.widget() extensions instead.
$.ui.plugin = {
add: function( module, option, set ) {
var i,
proto = $.ui[ module ].prototype;
for ( i in set ) {
proto.plugins[ i ] = proto.plugins[ i ] || [];
proto.plugins[ i ].push( [ option, set[ i ] ] );
}
},
call: function( instance, name, args, allowDisconnected ) {
var i,
set = instance.plugins[ name ];
if ( !set ) {
return;
}
if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
return;
}
for ( i = 0; i < set.length; i++ ) {
if ( instance.options[ set[ i ][ 0 ] ] ) {
set[ i ][ 1 ].apply( instance.element, args );
}
}
}
};
})( jQuery );
(function( $, window, undefined ) {
// Subtract the height of external toolbars from the page height, if the page does not have
// internal toolbars of the same type
var compensateToolbars = function( page, desiredHeight ) {
var pageParent = page.parent(),
toolbarsAffectingHeight = [],
externalHeaders = pageParent.children( ":jqmData(role='header')" ),
internalHeaders = page.children( ":jqmData(role='header')" ),
externalFooters = pageParent.children( ":jqmData(role='footer')" ),
internalFooters = page.children( ":jqmData(role='footer')" );
// If we have no internal headers, but we do have external headers, then their height
// reduces the page height
if ( internalHeaders.length === 0 && externalHeaders.length > 0 ) {
toolbarsAffectingHeight = toolbarsAffectingHeight.concat( externalHeaders.toArray() );
}
// If we have no internal footers, but we do have external footers, then their height
// reduces the page height
if ( internalFooters.length === 0 && externalFooters.length > 0 ) {
toolbarsAffectingHeight = toolbarsAffectingHeight.concat( externalFooters.toArray() );
}
$.each( toolbarsAffectingHeight, function( index, value ) {
desiredHeight -= $( value ).outerHeight();
});
// Height must be at least zero
return Math.max( 0, desiredHeight );
};
$.extend( $.mobile, {
// define the window and the document objects
window: $( window ),
document: $( document ),
// TODO: Remove and use $.ui.keyCode directly
keyCode: $.ui.keyCode,
// Place to store various widget extensions
behaviors: {},
// Scroll page vertically: scroll to 0 to hide iOS address bar, or pass a Y value
silentScroll: function( ypos ) {
if ( $.type( ypos ) !== "number" ) {
ypos = $.mobile.defaultHomeScroll;
}
// prevent scrollstart and scrollstop events
$.event.special.scrollstart.enabled = false;
setTimeout(function() {
window.scrollTo( 0, ypos );
$.mobile.document.trigger( "silentscroll", { x: 0, y: ypos });
}, 20 );
setTimeout(function() {
$.event.special.scrollstart.enabled = true;
}, 150 );
},
getClosestBaseUrl: function( ele ) {
// Find the closest page and extract out its url.
var url = $( ele ).closest( ".ui-page" ).jqmData( "url" ),
base = $.mobile.path.documentBase.hrefNoHash;
if ( !$.mobile.dynamicBaseEnabled || !url || !$.mobile.path.isPath( url ) ) {
url = base;
}
return $.mobile.path.makeUrlAbsolute( url, base );
},
removeActiveLinkClass: function( forceRemoval ) {
if ( !!$.mobile.activeClickedLink &&
( !$.mobile.activeClickedLink.closest( "." + $.mobile.activePageClass ).length ||
forceRemoval ) ) {
$.mobile.activeClickedLink.removeClass( $.mobile.activeBtnClass );
}
$.mobile.activeClickedLink = null;
},
// DEPRECATED in 1.4
// Find the closest parent with a theme class on it. Note that
// we are not using $.fn.closest() on purpose here because this
// method gets called quite a bit and we need it to be as fast
// as possible.
getInheritedTheme: function( el, defaultTheme ) {
var e = el[ 0 ],
ltr = "",
re = /ui-(bar|body|overlay)-([a-z])\b/,
c, m;
while ( e ) {
c = e.className || "";
if ( c && ( m = re.exec( c ) ) && ( ltr = m[ 2 ] ) ) {
// We found a parent with a theme class
// on it so bail from this loop.
break;
}
e = e.parentNode;
}
// Return the theme letter we found, if none, return the
// specified default.
return ltr || defaultTheme || "a";
},
enhanceable: function( elements ) {
return this.haveParents( elements, "enhance" );
},
hijackable: function( elements ) {
return this.haveParents( elements, "ajax" );
},
haveParents: function( elements, attr ) {
if ( !$.mobile.ignoreContentEnabled ) {
return elements;
}
var count = elements.length,
$newSet = $(),
e, $element, excluded,
i, c;
for ( i = 0; i < count; i++ ) {
$element = elements.eq( i );
excluded = false;
e = elements[ i ];
while ( e ) {
c = e.getAttribute ? e.getAttribute( "data-" + $.mobile.ns + attr ) : "";
if ( c === "false" ) {
excluded = true;
break;
}
e = e.parentNode;
}
if ( !excluded ) {
$newSet = $newSet.add( $element );
}
}
return $newSet;
},
getScreenHeight: function() {
// Native innerHeight returns more accurate value for this across platforms,
// jQuery version is here as a normalized fallback for platforms like Symbian
return window.innerHeight || $.mobile.window.height();
},
//simply set the active page's minimum height to screen height, depending on orientation
resetActivePageHeight: function( height ) {
var page = $( "." + $.mobile.activePageClass ),
pageHeight = page.height(),
pageOuterHeight = page.outerHeight( true );
height = compensateToolbars( page,
( typeof height === "number" ) ? height : $.mobile.getScreenHeight() );
page.css( "min-height", height - ( pageOuterHeight - pageHeight ) );
},
loading: function() {
// If this is the first call to this function, instantiate a loader widget
var loader = this.loading._widget || $( $.mobile.loader.prototype.defaultHtml ).loader(),
// Call the appropriate method on the loader
returnValue = loader.loader.apply( loader, arguments );
// Make sure the loader is retained for future calls to this function.
this.loading._widget = loader;
return returnValue;
}
});
$.addDependents = function( elem, newDependents ) {
var $elem = $( elem ),
dependents = $elem.jqmData( "dependents" ) || $();
$elem.jqmData( "dependents", $( dependents ).add( newDependents ) );
};
// plugins
$.fn.extend({
removeWithDependents: function() {
$.removeWithDependents( this );
},
// Enhance child elements
enhanceWithin: function() {
var index,
widgetElements = {},
keepNative = $.mobile.page.prototype.keepNativeSelector(),
that = this;
// Add no js class to elements
if ( $.mobile.nojs ) {
$.mobile.nojs( this );
}
// Bind links for ajax nav
if ( $.mobile.links ) {
$.mobile.links( this );
}
// Degrade inputs for styleing
if ( $.mobile.degradeInputsWithin ) {
$.mobile.degradeInputsWithin( this );
}
// Run buttonmarkup
if ( $.fn.buttonMarkup ) {
this.find( $.fn.buttonMarkup.initSelector ).not( keepNative )
.jqmEnhanceable().buttonMarkup();
}
// Add classes for fieldContain
if ( $.fn.fieldcontain ) {
this.find( ":jqmData(role='fieldcontain')" ).not( keepNative )
.jqmEnhanceable().fieldcontain();
}
// Enhance widgets
$.each( $.mobile.widgets, function( name, constructor ) {
// If initSelector not false find elements
if ( constructor.initSelector ) {
// Filter elements that should not be enhanced based on parents
var elements = $.mobile.enhanceable( that.find( constructor.initSelector ) );
// If any matching elements remain filter ones with keepNativeSelector
if ( elements.length > 0 ) {
// $.mobile.page.prototype.keepNativeSelector is deprecated this is just for backcompat
// Switch to $.mobile.keepNative in 1.5 which is just a value not a function
elements = elements.not( keepNative );
}
// Enhance whatever is left
if ( elements.length > 0 ) {
widgetElements[ constructor.prototype.widgetName ] = elements;
}
}
});
for ( index in widgetElements ) {
widgetElements[ index ][ index ]();
}
return this;
},
addDependents: function( newDependents ) {
$.addDependents( this, newDependents );
},
// note that this helper doesn't attempt to handle the callback
// or setting of an html element's text, its only purpose is
// to return the html encoded version of the text in all cases. (thus the name)
getEncodedText: function() {
return $( "<a>" ).text( this.text() ).html();
},
// fluent helper function for the mobile namespaced equivalent
jqmEnhanceable: function() {
return $.mobile.enhanceable( this );
},
jqmHijackable: function() {
return $.mobile.hijackable( this );
}
});
$.removeWithDependents = function( nativeElement ) {
var element = $( nativeElement );
( element.jqmData( "dependents" ) || $() ).remove();
element.remove();
};
$.addDependents = function( nativeElement, newDependents ) {
var element = $( nativeElement ),
dependents = element.jqmData( "dependents" ) || $();
element.jqmData( "dependents", $( dependents ).add( newDependents ) );
};
$.find.matches = function( expr, set ) {
return $.find( expr, null, null, set );
};
$.find.matchesSelector = function( node, expr ) {
return $.find( expr, null, null, [ node ] ).length > 0;
};
})( jQuery, this );
(function( $, undefined ) {
/*! matchMedia() polyfill - Test a CSS media type/query in JS. Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas. Dual MIT/BSD license */
window.matchMedia = window.matchMedia || (function( doc, undefined ) {
var bool,
docElem = doc.documentElement,
refNode = docElem.firstElementChild || docElem.firstChild,
// fakeBody required for <FF4 when executed in <head>
fakeBody = doc.createElement( "body" ),
div = doc.createElement( "div" );
div.id = "mq-test-1";
div.style.cssText = "position:absolute;top:-100em";
fakeBody.style.background = "none";
fakeBody.appendChild(div);
return function(q){
div.innerHTML = "­<style media=\"" + q + "\"> #mq-test-1 { width: 42px; }</style>";
docElem.insertBefore( fakeBody, refNode );
bool = div.offsetWidth === 42;
docElem.removeChild( fakeBody );
return {
matches: bool,
media: q
};
};
}( document ));
// $.mobile.media uses matchMedia to return a boolean.
$.mobile.media = function( q ) {
return window.matchMedia( q ).matches;
};
})(jQuery);
(function( $, undefined ) {
var support = {
touch: "ontouchend" in document
};
$.mobile.support = $.mobile.support || {};
$.extend( $.support, support );
$.extend( $.mobile.support, support );
}( jQuery ));
(function( $, undefined ) {
$.extend( $.support, {
orientation: "orientation" in window && "onorientationchange" in window
});
}( jQuery ));
(function( $, undefined ) {
// thx Modernizr
function propExists( prop ) {
var uc_prop = prop.charAt( 0 ).toUpperCase() + prop.substr( 1 ),
props = ( prop + " " + vendors.join( uc_prop + " " ) + uc_prop ).split( " " ),
v;
for ( v in props ) {
if ( fbCSS[ props[ v ] ] !== undefined ) {
return true;
}
}
}
var fakeBody = $( "<body>" ).prependTo( "html" ),
fbCSS = fakeBody[ 0 ].style,
vendors = [ "Webkit", "Moz", "O" ],
webos = "palmGetResource" in window, //only used to rule out scrollTop
operamini = window.operamini && ({}).toString.call( window.operamini ) === "[object OperaMini]",
bb = window.blackberry && !propExists( "-webkit-transform" ), //only used to rule out box shadow, as it's filled opaque on BB 5 and lower
nokiaLTE7_3;
// inline SVG support test
function inlineSVG() {
// Thanks Modernizr & Erik Dahlstrom
var w = window,
svg = !!w.document.createElementNS && !!w.document.createElementNS( "http://www.w3.org/2000/svg", "svg" ).createSVGRect && !( w.opera && navigator.userAgent.indexOf( "Chrome" ) === -1 ),
support = function( data ) {
if ( !( data && svg ) ) {
$( "html" ).addClass( "ui-nosvg" );
}
},
img = new w.Image();
img.onerror = function() {
support( false );
};
img.onload = function() {
support( img.width === 1 && img.height === 1 );
};
img.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==";
}
function transform3dTest() {
var mqProp = "transform-3d",
// Because the `translate3d` test below throws false positives in Android:
ret = $.mobile.media( "(-" + vendors.join( "-" + mqProp + "),(-" ) + "-" + mqProp + "),(" + mqProp + ")" ),
el, transforms, t;
if ( ret ) {
return !!ret;
}
el = document.createElement( "div" );
transforms = {
// We’re omitting Opera for the time being; MS uses unprefixed.
"MozTransform": "-moz-transform",
"transform": "transform"
};
fakeBody.append( el );
for ( t in transforms ) {
if ( el.style[ t ] !== undefined ) {
el.style[ t ] = "translate3d( 100px, 1px, 1px )";
ret = window.getComputedStyle( el ).getPropertyValue( transforms[ t ] );
}
}
return ( !!ret && ret !== "none" );
}
// Test for dynamic-updating base tag support ( allows us to avoid href,src attr rewriting )
function baseTagTest() {
var fauxBase = location.protocol + "//" + location.host + location.pathname + "ui-dir/",
base = $( "head base" ),
fauxEle = null,
href = "",
link, rebase;
if ( !base.length ) {
base = fauxEle = $( "<base>", { "href": fauxBase }).appendTo( "head" );
} else {
href = base.attr( "href" );
}
link = $( "<a href='testurl' />" ).prependTo( fakeBody );
rebase = link[ 0 ].href;
base[ 0 ].href = href || location.pathname;
if ( fauxEle ) {
fauxEle.remove();
}
return rebase.indexOf( fauxBase ) === 0;
}
// Thanks Modernizr
function cssPointerEventsTest() {
var element = document.createElement( "x" ),
documentElement = document.documentElement,
getComputedStyle = window.getComputedStyle,
supports;
if ( !( "pointerEvents" in element.style ) ) {
return false;
}
element.style.pointerEvents = "auto";
element.style.pointerEvents = "x";
documentElement.appendChild( element );
supports = getComputedStyle &&
getComputedStyle( element, "" ).pointerEvents === "auto";
documentElement.removeChild( element );
return !!supports;
}
function boundingRect() {
var div = document.createElement( "div" );
return typeof div.getBoundingClientRect !== "undefined";
}
// non-UA-based IE version check by James Padolsey, modified by jdalton - from http://gist.github.com/527683
// allows for inclusion of IE 6+, including Windows Mobile 7
$.extend( $.mobile, { browser: {} } );
$.mobile.browser.oldIE = (function() {
var v = 3,
div = document.createElement( "div" ),
a = div.all || [];
do {
div.innerHTML = "<!--[if gt IE " + ( ++v ) + "]><br><![endif]-->";
} while( a[0] );
return v > 4 ? v : !v;
})();
function fixedPosition() {
var w = window,
ua = navigator.userAgent,
platform = navigator.platform,
// Rendering engine is Webkit, and capture major version
wkmatch = ua.match( /AppleWebKit\/([0-9]+)/ ),
wkversion = !!wkmatch && wkmatch[ 1 ],
ffmatch = ua.match( /Fennec\/([0-9]+)/ ),
ffversion = !!ffmatch && ffmatch[ 1 ],
operammobilematch = ua.match( /Opera Mobi\/([0-9]+)/ ),
omversion = !!operammobilematch && operammobilematch[ 1 ];
if (
// iOS 4.3 and older : Platform is iPhone/Pad/Touch and Webkit version is less than 534 (ios5)
( ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1 || platform.indexOf( "iPod" ) > -1 ) && wkversion && wkversion < 534 ) ||
// Opera Mini
( w.operamini && ({}).toString.call( w.operamini ) === "[object OperaMini]" ) ||
( operammobilematch && omversion < 7458 ) ||
//Android lte 2.1: Platform is Android and Webkit version is less than 533 (Android 2.2)
( ua.indexOf( "Android" ) > -1 && wkversion && wkversion < 533 ) ||
// Firefox Mobile before 6.0 -
( ffversion && ffversion < 6 ) ||
// WebOS less than 3
( "palmGetResource" in window && wkversion && wkversion < 534 ) ||
// MeeGo
( ua.indexOf( "MeeGo" ) > -1 && ua.indexOf( "NokiaBrowser/8.5.0" ) > -1 ) ) {
return false;
}
return true;
}
$.extend( $.support, {
// Note, Chrome for iOS has an extremely quirky implementation of popstate.
// We've chosen to take the shortest path to a bug fix here for issue #5426
// See the following link for information about the regex chosen
// https://developers.google.com/chrome/mobile/docs/user-agent#chrome_for_ios_user-agent
pushState: "pushState" in history &&
"replaceState" in history &&
// When running inside a FF iframe, calling replaceState causes an error
!( window.navigator.userAgent.indexOf( "Firefox" ) >= 0 && window.top !== window ) &&
( window.navigator.userAgent.search(/CriOS/) === -1 ),
mediaquery: $.mobile.media( "only all" ),
cssPseudoElement: !!propExists( "content" ),
touchOverflow: !!propExists( "overflowScrolling" ),
cssTransform3d: transform3dTest(),
boxShadow: !!propExists( "boxShadow" ) && !bb,
fixedPosition: fixedPosition(),
scrollTop: ("pageXOffset" in window ||
"scrollTop" in document.documentElement ||
"scrollTop" in fakeBody[ 0 ]) && !webos && !operamini,
dynamicBaseTag: baseTagTest(),
cssPointerEvents: cssPointerEventsTest(),
boundingRect: boundingRect(),
inlineSVG: inlineSVG
});
fakeBody.remove();
// $.mobile.ajaxBlacklist is used to override ajaxEnabled on platforms that have known conflicts with hash history updates (BB5, Symbian)
// or that generally work better browsing in regular http for full page refreshes (Opera Mini)
// Note: This detection below is used as a last resort.
// We recommend only using these detection methods when all other more reliable/forward-looking approaches are not possible
nokiaLTE7_3 = (function() {
var ua = window.navigator.userAgent;
//The following is an attempt to match Nokia browsers that are running Symbian/s60, with webkit, version 7.3 or older
return ua.indexOf( "Nokia" ) > -1 &&
( ua.indexOf( "Symbian/3" ) > -1 || ua.indexOf( "Series60/5" ) > -1 ) &&
ua.indexOf( "AppleWebKit" ) > -1 &&
ua.match( /(BrowserNG|NokiaBrowser)\/7\.[0-3]/ );
})();
// Support conditions that must be met in order to proceed
// default enhanced qualifications are media query support OR IE 7+
$.mobile.gradeA = function() {
return ( ( $.support.mediaquery && $.support.cssPseudoElement ) || $.mobile.browser.oldIE && $.mobile.browser.oldIE >= 8 ) && ( $.support.boundingRect || $.fn.jquery.match(/1\.[0-7+]\.[0-9+]?/) !== null );
};
$.mobile.ajaxBlacklist =
// BlackBerry browsers, pre-webkit
window.blackberry && !window.WebKitPoint ||
// Opera Mini
operamini ||
// Symbian webkits pre 7.3
nokiaLTE7_3;
// Lastly, this workaround is the only way we've found so far to get pre 7.3 Symbian webkit devices
// to render the stylesheets when they're referenced before this script, as we'd recommend doing.
// This simply reappends the CSS in place, which for some reason makes it apply
if ( nokiaLTE7_3 ) {
$(function() {
$( "head link[rel='stylesheet']" ).attr( "rel", "alternate stylesheet" ).attr( "rel", "stylesheet" );
});
}
// For ruling out shadows via css
if ( !$.support.boxShadow ) {
$( "html" ).addClass( "ui-noboxshadow" );
}
})( jQuery );
(function( $, undefined ) {
var $win = $.mobile.window, self,
dummyFnToInitNavigate = function() {
};
$.event.special.beforenavigate = {
setup: function() {
$win.on( "navigate", dummyFnToInitNavigate );
},
teardown: function() {
$win.off( "navigate", dummyFnToInitNavigate );
}
};
$.event.special.navigate = self = {
bound: false,
pushStateEnabled: true,
originalEventName: undefined,
// If pushstate support is present and push state support is defined to
// be true on the mobile namespace.
isPushStateEnabled: function() {
return $.support.pushState &&
$.mobile.pushStateEnabled === true &&
this.isHashChangeEnabled();
},
// !! assumes mobile namespace is present
isHashChangeEnabled: function() {
return $.mobile.hashListeningEnabled === true;
},
// TODO a lot of duplication between popstate and hashchange
popstate: function( event ) {
var newEvent = new $.Event( "navigate" ),
beforeNavigate = new $.Event( "beforenavigate" ),
state = event.originalEvent.state || {};
beforeNavigate.originalEvent = event;
$win.trigger( beforeNavigate );
if ( beforeNavigate.isDefaultPrevented() ) {
return;
}
if ( event.historyState ) {
$.extend(state, event.historyState);
}
// Make sure the original event is tracked for the end
// user to inspect incase they want to do something special
newEvent.originalEvent = event;
// NOTE we let the current stack unwind because any assignment to
// location.hash will stop the world and run this event handler. By
// doing this we create a similar behavior to hashchange on hash
// assignment
setTimeout(function() {
$win.trigger( newEvent, {
state: state
});
}, 0);
},
hashchange: function( event /*, data */ ) {
var newEvent = new $.Event( "navigate" ),
beforeNavigate = new $.Event( "beforenavigate" );
beforeNavigate.originalEvent = event;
$win.trigger( beforeNavigate );
if ( beforeNavigate.isDefaultPrevented() ) {
return;
}
// Make sure the original event is tracked for the end
// user to inspect incase they want to do something special
newEvent.originalEvent = event;
// Trigger the hashchange with state provided by the user
// that altered the hash
$win.trigger( newEvent, {
// Users that want to fully normalize the two events
// will need to do history management down the stack and
// add the state to the event before this binding is fired
// TODO consider allowing for the explicit addition of callbacks
// to be fired before this value is set to avoid event timing issues
state: event.hashchangeState || {}
});
},
// TODO We really only want to set this up once
// but I'm not clear if there's a beter way to achieve
// this with the jQuery special event structure
setup: function( /* data, namespaces */ ) {
if ( self.bound ) {
return;
}
self.bound = true;
if ( self.isPushStateEnabled() ) {
self.originalEventName = "popstate";
$win.bind( "popstate.navigate", self.popstate );
} else if ( self.isHashChangeEnabled() ) {
self.originalEventName = "hashchange";
$win.bind( "hashchange.navigate", self.hashchange );
}
}
};
})( jQuery );
// throttled resize event
(function( $ ) {
$.event.special.throttledresize = {
setup: function() {
$( this ).bind( "resize", handler );
},
teardown: function() {
$( this ).unbind( "resize", handler );
}
};
var throttle = 250,
handler = function() {
curr = ( new Date() ).getTime();
diff = curr - lastCall;
if ( diff >= throttle ) {
lastCall = curr;
$( this ).trigger( "throttledresize" );
} else {
if ( heldCall ) {
clearTimeout( heldCall );
}
// Promise a held call will still execute
heldCall = setTimeout( handler, throttle - diff );
}
},
lastCall = 0,
heldCall,
curr,
diff;
})( jQuery );
(function( $, window ) {
var win = $( window ),
event_name = "orientationchange",
get_orientation,
last_orientation,
initial_orientation_is_landscape,
initial_orientation_is_default,
portrait_map = { "0": true, "180": true },
ww, wh, landscape_threshold;
// It seems that some device/browser vendors use window.orientation values 0 and 180 to
// denote the "default" orientation. For iOS devices, and most other smart-phones tested,
// the default orientation is always "portrait", but in some Android and RIM based tablets,
// the default orientation is "landscape". The following code attempts to use the window
// dimensions to figure out what the current orientation is, and then makes adjustments
// to the to the portrait_map if necessary, so that we can properly decode the
// window.orientation value whenever get_orientation() is called.
//
// Note that we used to use a media query to figure out what the orientation the browser
// thinks it is in:
//
// initial_orientation_is_landscape = $.mobile.media("all and (orientation: landscape)");
//
// but there was an iPhone/iPod Touch bug beginning with iOS 4.2, up through iOS 5.1,
// where the browser *ALWAYS* applied the landscape media query. This bug does not
// happen on iPad.
if ( $.support.orientation ) {
// Check the window width and height to figure out what the current orientation
// of the device is at this moment. Note that we've initialized the portrait map
// values to 0 and 180, *AND* we purposely check for landscape so that if we guess
// wrong, , we default to the assumption that portrait is the default orientation.
// We use a threshold check below because on some platforms like iOS, the iPhone
// form-factor can report a larger width than height if the user turns on the
// developer console. The actual threshold value is somewhat arbitrary, we just
// need to make sure it is large enough to exclude the developer console case.
ww = window.innerWidth || win.width();
wh = window.innerHeight || win.height();
landscape_threshold = 50;
initial_orientation_is_landscape = ww > wh && ( ww - wh ) > landscape_threshold;
// Now check to see if the current window.orientation is 0 or 180.
initial_orientation_is_default = portrait_map[ window.orientation ];
// If the initial orientation is landscape, but window.orientation reports 0 or 180, *OR*
// if the initial orientation is portrait, but window.orientation reports 90 or -90, we
// need to flip our portrait_map values because landscape is the default orientation for
// this device/browser.
if ( ( initial_orientation_is_landscape && initial_orientation_is_default ) || ( !initial_orientation_is_landscape && !initial_orientation_is_default ) ) {
portrait_map = { "-90": true, "90": true };
}
}
$.event.special.orientationchange = $.extend( {}, $.event.special.orientationchange, {
setup: function() {
// If the event is supported natively, return false so that jQuery
// will bind to the event using DOM methods.
if ( $.support.orientation && !$.event.special.orientationchange.disabled ) {
return false;
}
// Get the current orientation to avoid initial double-triggering.
last_orientation = get_orientation();
// Because the orientationchange event doesn't exist, simulate the
// event by testing window dimensions on resize.
win.bind( "throttledresize", handler );
},
teardown: function() {
// If the event is not supported natively, return false so that
// jQuery will unbind the event using DOM methods.
if ( $.support.orientation && !$.event.special.orientationchange.disabled ) {
return false;
}
// Because the orientationchange event doesn't exist, unbind the
// resize event handler.
win.unbind( "throttledresize", handler );
},
add: function( handleObj ) {
// Save a reference to the bound event handler.
var old_handler = handleObj.handler;
handleObj.handler = function( event ) {
// Modify event object, adding the .orientation property.
event.orientation = get_orientation();
// Call the originally-bound event handler and return its result.
return old_handler.apply( this, arguments );
};
}
});
// If the event is not supported natively, this handler will be bound to
// the window resize event to simulate the orientationchange event.
function handler() {
// Get the current orientation.
var orientation = get_orientation();
if ( orientation !== last_orientation ) {
// The orientation has changed, so trigger the orientationchange event.
last_orientation = orientation;
win.trigger( event_name );
}
}
// Get the current page orientation. This method is exposed publicly, should it
// be needed, as jQuery.event.special.orientationchange.orientation()
$.event.special.orientationchange.orientation = get_orientation = function() {
var isPortrait = true, elem = document.documentElement;
// prefer window orientation to the calculation based on screensize as
// the actual screen resize takes place before or after the orientation change event
// has been fired depending on implementation (eg android 2.3 is before, iphone after).
// More testing is required to determine if a more reliable method of determining the new screensize
// is possible when orientationchange is fired. (eg, use media queries + element + opacity)
if ( $.support.orientation ) {
// if the window orientation registers as 0 or 180 degrees report
// portrait, otherwise landscape
isPortrait = portrait_map[ window.orientation ];
} else {
isPortrait = elem && elem.clientWidth / elem.clientHeight < 1.1;
}
return isPortrait ? "portrait" : "landscape";
};
$.fn[ event_name ] = function( fn ) {
return fn ? this.bind( event_name, fn ) : this.trigger( event_name );
};
// jQuery < 1.8
if ( $.attrFn ) {
$.attrFn[ event_name ] = true;
}
}( jQuery, this ));
// This plugin is an experiment for abstracting away the touch and mouse
// events so that developers don't have to worry about which method of input
// the device their document is loaded on supports.
//
// The idea here is to allow the developer to register listeners for the
// basic mouse events, such as mousedown, mousemove, mouseup, and click,
// and the plugin will take care of registering the correct listeners
// behind the scenes to invoke the listener at the fastest possible time
// for that device, while still retaining the order of event firing in
// the traditional mouse environment, should multiple handlers be registered
// on the same element for different events.
//
// The current version exposes the following virtual events to jQuery bind methods:
// "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel"
(function( $, window, document, undefined ) {
var dataPropertyName = "virtualMouseBindings",
touchTargetPropertyName = "virtualTouchID",
virtualEventNames = "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel".split( " " ),
touchEventProps = "clientX clientY pageX pageY screenX screenY".split( " " ),
mouseHookProps = $.event.mouseHooks ? $.event.mouseHooks.props : [],
mouseEventProps = $.event.props.concat( mouseHookProps ),
activeDocHandlers = {},
resetTimerID = 0,
startX = 0,
startY = 0,
didScroll = false,
clickBlockList = [],
blockMouseTriggers = false,
blockTouchTriggers = false,
eventCaptureSupported = "addEventListener" in document,
$document = $( document ),
nextTouchID = 1,
lastTouchID = 0, threshold,
i;
$.vmouse = {
moveDistanceThreshold: 10,
clickDistanceThreshold: 10,
resetTimerDuration: 1500
};
function getNativeEvent( event ) {
while ( event && typeof event.originalEvent !== "undefined" ) {
event = event.originalEvent;
}
return event;
}
function createVirtualEvent( event, eventType ) {
var t = event.type,
oe, props, ne, prop, ct, touch, i, j, len;
event = $.Event( event );
event.type = eventType;
oe = event.originalEvent;
props = $.event.props;
// addresses separation of $.event.props in to $.event.mouseHook.props and Issue 3280
// https://github.com/jquery/jquery-mobile/issues/3280
if ( t.search( /^(mouse|click)/ ) > -1 ) {
props = mouseEventProps;
}
// copy original event properties over to the new event
// this would happen if we could call $.event.fix instead of $.Event
// but we don't have a way to force an event to be fixed multiple times
if ( oe ) {
for ( i = props.length, prop; i; ) {
prop = props[ --i ];
event[ prop ] = oe[ prop ];
}
}
// make sure that if the mouse and click virtual events are generated
// without a .which one is defined
if ( t.search(/mouse(down|up)|click/) > -1 && !event.which ) {
event.which = 1;
}
if ( t.search(/^touch/) !== -1 ) {
ne = getNativeEvent( oe );
t = ne.touches;
ct = ne.changedTouches;
touch = ( t && t.length ) ? t[0] : ( ( ct && ct.length ) ? ct[ 0 ] : undefined );
if ( touch ) {
for ( j = 0, len = touchEventProps.length; j < len; j++) {
prop = touchEventProps[ j ];
event[ prop ] = touch[ prop ];
}
}
}
return event;
}
function getVirtualBindingFlags( element ) {
var flags = {},
b, k;
while ( element ) {
b = $.data( element, dataPropertyName );
for ( k in b ) {
if ( b[ k ] ) {
flags[ k ] = flags.hasVirtualBinding = true;
}
}
element = element.parentNode;
}
return flags;
}
function getClosestElementWithVirtualBinding( element, eventType ) {
var b;
while ( element ) {
b = $.data( element, dataPropertyName );
if ( b && ( !eventType || b[ eventType ] ) ) {
return element;
}
element = element.parentNode;
}
return null;
}
function enableTouchBindings() {
blockTouchTriggers = false;
}
function disableTouchBindings() {
blockTouchTriggers = true;
}
function enableMouseBindings() {
lastTouchID = 0;
clickBlockList.length = 0;
blockMouseTriggers = false;
// When mouse bindings are enabled, our
// touch bindings are disabled.
disableTouchBindings();
}
function disableMouseBindings() {
// When mouse bindings are disabled, our
// touch bindings are enabled.
enableTouchBindings();
}
function startResetTimer() {
clearResetTimer();
resetTimerID = setTimeout( function() {
resetTimerID = 0;
enableMouseBindings();
}, $.vmouse.resetTimerDuration );
}
function clearResetTimer() {
if ( resetTimerID ) {
clearTimeout( resetTimerID );
resetTimerID = 0;
}
}
function triggerVirtualEvent( eventType, event, flags ) {
var ve;
if ( ( flags && flags[ eventType ] ) ||
( !flags && getClosestElementWithVirtualBinding( event.target, eventType ) ) ) {
ve = createVirtualEvent( event, eventType );
$( event.target).trigger( ve );
}
return ve;
}
function mouseEventCallback( event ) {
var touchID = $.data( event.target, touchTargetPropertyName ),
ve;
if ( !blockMouseTriggers && ( !lastTouchID || lastTouchID !== touchID ) ) {
ve = triggerVirtualEvent( "v" + event.type, event );
if ( ve ) {
if ( ve.isDefaultPrevented() ) {
event.preventDefault();
}
if ( ve.isPropagationStopped() ) {
event.stopPropagation();
}
if ( ve.isImmediatePropagationStopped() ) {
event.stopImmediatePropagation();
}
}
}
}
function handleTouchStart( event ) {
var touches = getNativeEvent( event ).touches,
target, flags, t;
if ( touches && touches.length === 1 ) {
target = event.target;
flags = getVirtualBindingFlags( target );
if ( flags.hasVirtualBinding ) {
lastTouchID = nextTouchID++;
$.data( target, touchTargetPropertyName, lastTouchID );
clearResetTimer();
disableMouseBindings();
didScroll = false;
t = getNativeEvent( event ).touches[ 0 ];
startX = t.pageX;
startY = t.pageY;
triggerVirtualEvent( "vmouseover", event, flags );
triggerVirtualEvent( "vmousedown", event, flags );
}
}
}
function handleScroll( event ) {
if ( blockTouchTriggers ) {
return;
}
if ( !didScroll ) {
triggerVirtualEvent( "vmousecancel", event, getVirtualBindingFlags( event.target ) );
}
didScroll = true;
startResetTimer();
}
function handleTouchMove( event ) {
if ( blockTouchTriggers ) {
return;
}
var t = getNativeEvent( event ).touches[ 0 ],
didCancel = didScroll,
moveThreshold = $.vmouse.moveDistanceThreshold,
flags = getVirtualBindingFlags( event.target );
didScroll = didScroll ||
( Math.abs( t.pageX - startX ) > moveThreshold ||
Math.abs( t.pageY - startY ) > moveThreshold );
if ( didScroll && !didCancel ) {
triggerVirtualEvent( "vmousecancel", event, flags );
}
triggerVirtualEvent( "vmousemove", event, flags );
startResetTimer();
}
function handleTouchEnd( event ) {
if ( blockTouchTriggers ) {
return;
}
disableTouchBindings();
var flags = getVirtualBindingFlags( event.target ),
ve, t;
triggerVirtualEvent( "vmouseup", event, flags );
if ( !didScroll ) {
ve = triggerVirtualEvent( "vclick", event, flags );
if ( ve && ve.isDefaultPrevented() ) {
// The target of the mouse events that follow the touchend
// event don't necessarily match the target used during the
// touch. This means we need to rely on coordinates for blocking
// any click that is generated.
t = getNativeEvent( event ).changedTouches[ 0 ];
clickBlockList.push({
touchID: lastTouchID,
x: t.clientX,
y: t.clientY
});
// Prevent any mouse events that follow from triggering
// virtual event notifications.
blockMouseTriggers = true;
}
}
triggerVirtualEvent( "vmouseout", event, flags);
didScroll = false;
startResetTimer();
}
function hasVirtualBindings( ele ) {
var bindings = $.data( ele, dataPropertyName ),
k;
if ( bindings ) {
for ( k in bindings ) {
if ( bindings[ k ] ) {
return true;
}
}
}
return false;
}
function dummyMouseHandler() {}
function getSpecialEventObject( eventType ) {
var realType = eventType.substr( 1 );
return {
setup: function(/* data, namespace */) {
// If this is the first virtual mouse binding for this element,
// add a bindings object to its data.
if ( !hasVirtualBindings( this ) ) {
$.data( this, dataPropertyName, {} );
}
// If setup is called, we know it is the first binding for this
// eventType, so initialize the count for the eventType to zero.
var bindings = $.data( this, dataPropertyName );
bindings[ eventType ] = true;
// If this is the first virtual mouse event for this type,
// register a global handler on the document.
activeDocHandlers[ eventType ] = ( activeDocHandlers[ eventType ] || 0 ) + 1;
if ( activeDocHandlers[ eventType ] === 1 ) {
$document.bind( realType, mouseEventCallback );
}
// Some browsers, like Opera Mini, won't dispatch mouse/click events
// for elements unless they actually have handlers registered on them.
// To get around this, we register dummy handlers on the elements.
$( this ).bind( realType, dummyMouseHandler );
// For now, if event capture is not supported, we rely on mouse handlers.
if ( eventCaptureSupported ) {
// If this is the first virtual mouse binding for the document,
// register our touchstart handler on the document.
activeDocHandlers[ "touchstart" ] = ( activeDocHandlers[ "touchstart" ] || 0) + 1;
if ( activeDocHandlers[ "touchstart" ] === 1 ) {
$document.bind( "touchstart", handleTouchStart )
.bind( "touchend", handleTouchEnd )
// On touch platforms, touching the screen and then dragging your finger
// causes the window content to scroll after some distance threshold is
// exceeded. On these platforms, a scroll prevents a click event from being
// dispatched, and on some platforms, even the touchend is suppressed. To
// mimic the suppression of the click event, we need to watch for a scroll
// event. Unfortunately, some platforms like iOS don't dispatch scroll
// events until *AFTER* the user lifts their finger (touchend). This means
// we need to watch both scroll and touchmove events to figure out whether
// or not a scroll happenens before the touchend event is fired.
.bind( "touchmove", handleTouchMove )
.bind( "scroll", handleScroll );
}
}
},
teardown: function(/* data, namespace */) {
// If this is the last virtual binding for this eventType,
// remove its global handler from the document.
--activeDocHandlers[ eventType ];
if ( !activeDocHandlers[ eventType ] ) {
$document.unbind( realType, mouseEventCallback );
}
if ( eventCaptureSupported ) {
// If this is the last virtual mouse binding in existence,
// remove our document touchstart listener.
--activeDocHandlers[ "touchstart" ];
if ( !activeDocHandlers[ "touchstart" ] ) {
$document.unbind( "touchstart", handleTouchStart )
.unbind( "touchmove", handleTouchMove )
.unbind( "touchend", handleTouchEnd )
.unbind( "scroll", handleScroll );
}
}
var $this = $( this ),
bindings = $.data( this, dataPropertyName );
// teardown may be called when an element was
// removed from the DOM. If this is the case,
// jQuery core may have already stripped the element
// of any data bindings so we need to check it before
// using it.
if ( bindings ) {
bindings[ eventType ] = false;
}
// Unregister the dummy event handler.
$this.unbind( realType, dummyMouseHandler );
// If this is the last virtual mouse binding on the
// element, remove the binding data from the element.
if ( !hasVirtualBindings( this ) ) {
$this.removeData( dataPropertyName );
}
}
};
}
// Expose our custom events to the jQuery bind/unbind mechanism.
for ( i = 0; i < virtualEventNames.length; i++ ) {
$.event.special[ virtualEventNames[ i ] ] = getSpecialEventObject( virtualEventNames[ i ] );
}
// Add a capture click handler to block clicks.
// Note that we require event capture support for this so if the device
// doesn't support it, we punt for now and rely solely on mouse events.
if ( eventCaptureSupported ) {
document.addEventListener( "click", function( e ) {
var cnt = clickBlockList.length,
target = e.target,
x, y, ele, i, o, touchID;
if ( cnt ) {
x = e.clientX;
y = e.clientY;
threshold = $.vmouse.clickDistanceThreshold;
// The idea here is to run through the clickBlockList to see if
// the current click event is in the proximity of one of our
// vclick events that had preventDefault() called on it. If we find
// one, then we block the click.
//
// Why do we have to rely on proximity?
//
// Because the target of the touch event that triggered the vclick
// can be different from the target of the click event synthesized
// by the browser. The target of a mouse/click event that is synthesized
// from a touch event seems to be implementation specific. For example,
// some browsers will fire mouse/click events for a link that is near
// a touch event, even though the target of the touchstart/touchend event
// says the user touched outside the link. Also, it seems that with most
// browsers, the target of the mouse/click event is not calculated until the
// time it is dispatched, so if you replace an element that you touched
// with another element, the target of the mouse/click will be the new
// element underneath that point.
//
// Aside from proximity, we also check to see if the target and any
// of its ancestors were the ones that blocked a click. This is necessary
// because of the strange mouse/click target calculation done in the
// Android 2.1 browser, where if you click on an element, and there is a
// mouse/click handler on one of its ancestors, the target will be the
// innermost child of the touched element, even if that child is no where
// near the point of touch.
ele = target;
while ( ele ) {
for ( i = 0; i < cnt; i++ ) {
o = clickBlockList[ i ];
touchID = 0;
if ( ( ele === target && Math.abs( o.x - x ) < threshold && Math.abs( o.y - y ) < threshold ) ||
$.data( ele, touchTargetPropertyName ) === o.touchID ) {
// XXX: We may want to consider removing matches from the block list
// instead of waiting for the reset timer to fire.
e.preventDefault();
e.stopPropagation();
return;
}
}
ele = ele.parentNode;
}
}
}, true);
}
})( jQuery, window, document );
(function( $, window, undefined ) {
var $document = $( document ),
supportTouch = $.mobile.support.touch,
scrollEvent = "touchmove scroll",
touchStartEvent = supportTouch ? "touchstart" : "mousedown",
touchStopEvent = supportTouch ? "touchend" : "mouseup",
touchMoveEvent = supportTouch ? "touchmove" : "mousemove";
// setup new event shortcuts
$.each( ( "touchstart touchmove touchend " +
"tap taphold " +
"swipe swipeleft swiperight " +
"scrollstart scrollstop" ).split( " " ), function( i, name ) {
$.fn[ name ] = function( fn ) {
return fn ? this.bind( name, fn ) : this.trigger( name );
};
// jQuery < 1.8
if ( $.attrFn ) {
$.attrFn[ name ] = true;
}
});
function triggerCustomEvent( obj, eventType, event, bubble ) {
var originalType = event.type;
event.type = eventType;
if ( bubble ) {
$.event.trigger( event, undefined, obj );
} else {
$.event.dispatch.call( obj, event );
}
event.type = originalType;
}
// also handles scrollstop
$.event.special.scrollstart = {
enabled: true,
setup: function() {
var thisObject = this,
$this = $( thisObject ),
scrolling,
timer;
function trigger( event, state ) {
scrolling = state;
triggerCustomEvent( thisObject, scrolling ? "scrollstart" : "scrollstop", event );
}
// iPhone triggers scroll after a small delay; use touchmove instead
$this.bind( scrollEvent, function( event ) {
if ( !$.event.special.scrollstart.enabled ) {
return;
}
if ( !scrolling ) {
trigger( event, true );
}
clearTimeout( timer );
timer = setTimeout( function() {
trigger( event, false );
}, 50 );
});
},
teardown: function() {
$( this ).unbind( scrollEvent );
}
};
// also handles taphold
$.event.special.tap = {
tapholdThreshold: 750,
emitTapOnTaphold: true,
setup: function() {
var thisObject = this,
$this = $( thisObject ),
isTaphold = false;
$this.bind( "vmousedown", function( event ) {
isTaphold = false;
if ( event.which && event.which !== 1 ) {
return false;
}
var origTarget = event.target,
timer;
function clearTapTimer() {
clearTimeout( timer );
}
function clearTapHandlers() {
clearTapTimer();
$this.unbind( "vclick", clickHandler )
.unbind( "vmouseup", clearTapTimer );
$document.unbind( "vmousecancel", clearTapHandlers );
}
function clickHandler( event ) {
clearTapHandlers();
// ONLY trigger a 'tap' event if the start target is
// the same as the stop target.
if ( !isTaphold && origTarget === event.target ) {
triggerCustomEvent( thisObject, "tap", event );
} else if ( isTaphold ) {
event.stopPropagation();
}
}
$this.bind( "vmouseup", clearTapTimer )
.bind( "vclick", clickHandler );
$document.bind( "vmousecancel", clearTapHandlers );
timer = setTimeout( function() {
if ( !$.event.special.tap.emitTapOnTaphold ) {
isTaphold = true;
}
triggerCustomEvent( thisObject, "taphold", $.Event( "taphold", { target: origTarget } ) );
}, $.event.special.tap.tapholdThreshold );
});
},
teardown: function() {
$( this ).unbind( "vmousedown" ).unbind( "vclick" ).unbind( "vmouseup" );
$document.unbind( "vmousecancel" );
}
};
// Also handles swipeleft, swiperight
$.event.special.swipe = {
// More than this horizontal displacement, and we will suppress scrolling.
scrollSupressionThreshold: 30,
// More time than this, and it isn't a swipe.
durationThreshold: 1000,
// Swipe horizontal displacement must be more than this.
horizontalDistanceThreshold: 30,
// Swipe vertical displacement must be less than this.
verticalDistanceThreshold: 30,
getLocation: function ( event ) {
var winPageX = window.pageXOffset,
winPageY = window.pageYOffset,
x = event.clientX,
y = event.clientY;
if ( event.pageY === 0 && Math.floor( y ) > Math.floor( event.pageY ) ||
event.pageX === 0 && Math.floor( x ) > Math.floor( event.pageX ) ) {
// iOS4 clientX/clientY have the value that should have been
// in pageX/pageY. While pageX/page/ have the value 0
x = x - winPageX;
y = y - winPageY;
} else if ( y < ( event.pageY - winPageY) || x < ( event.pageX - winPageX ) ) {
// Some Android browsers have totally bogus values for clientX/Y
// when scrolling/zooming a page. Detectable since clientX/clientY
// should never be smaller than pageX/pageY minus page scroll
x = event.pageX - winPageX;
y = event.pageY - winPageY;
}
return {
x: x,
y: y
};
},
start: function( event ) {
var data = event.originalEvent.touches ?
event.originalEvent.touches[ 0 ] : event,
location = $.event.special.swipe.getLocation( data );
return {
time: ( new Date() ).getTime(),
coords: [ location.x, location.y ],
origin: $( event.target )
};
},
stop: function( event ) {
var data = event.originalEvent.touches ?
event.originalEvent.touches[ 0 ] : event,
location = $.event.special.swipe.getLocation( data );
return {
time: ( new Date() ).getTime(),
coords: [ location.x, location.y ]
};
},
handleSwipe: function( start, stop, thisObject, origTarget ) {
if ( stop.time - start.time < $.event.special.swipe.durationThreshold &&
Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.horizontalDistanceThreshold &&
Math.abs( start.coords[ 1 ] - stop.coords[ 1 ] ) < $.event.special.swipe.verticalDistanceThreshold ) {
var direction = start.coords[0] > stop.coords[ 0 ] ? "swipeleft" : "swiperight";
triggerCustomEvent( thisObject, "swipe", $.Event( "swipe", { target: origTarget, swipestart: start, swipestop: stop }), true );
triggerCustomEvent( thisObject, direction,$.Event( direction, { target: origTarget, swipestart: start, swipestop: stop } ), true );
return true;
}
return false;
},
// This serves as a flag to ensure that at most one swipe event event is
// in work at any given time
eventInProgress: false,
setup: function() {
var events,
thisObject = this,
$this = $( thisObject ),
context = {};
// Retrieve the events data for this element and add the swipe context
events = $.data( this, "mobile-events" );
if ( !events ) {
events = { length: 0 };
$.data( this, "mobile-events", events );
}
events.length++;
events.swipe = context;
context.start = function( event ) {
// Bail if we're already working on a swipe event
if ( $.event.special.swipe.eventInProgress ) {
return;
}
$.event.special.swipe.eventInProgress = true;
var stop,
start = $.event.special.swipe.start( event ),
origTarget = event.target,
emitted = false;
context.move = function( event ) {
if ( !start ) {
return;
}
stop = $.event.special.swipe.stop( event );
if ( !emitted ) {
emitted = $.event.special.swipe.handleSwipe( start, stop, thisObject, origTarget );
if ( emitted ) {
// Reset the context to make way for the next swipe event
$.event.special.swipe.eventInProgress = false;
}
}
// prevent scrolling
if ( Math.abs( start.coords[ 0 ] - stop.coords[ 0 ] ) > $.event.special.swipe.scrollSupressionThreshold ) {
event.preventDefault();
}
};
context.stop = function() {
emitted = true;
// Reset the context to make way for the next swipe event
$.event.special.swipe.eventInProgress = false;
$document.off( touchMoveEvent, context.move );
context.move = null;
};
$document.on( touchMoveEvent, context.move )
.one( touchStopEvent, context.stop );
};
$this.on( touchStartEvent, context.start );
},
teardown: function() {
var events, context;
events = $.data( this, "mobile-events" );
if ( events ) {
context = events.swipe;
delete events.swipe;
events.length--;
if ( events.length === 0 ) {
$.removeData( this, "mobile-events" );
}
}
if ( context ) {
if ( context.start ) {
$( this ).off( touchStartEvent, context.start );
}
if ( context.move ) {
$document.off( touchMoveEvent, context.move );
}
if ( context.stop ) {
$document.off( touchStopEvent, context.stop );
}
}
}
};
$.each({
scrollstop: "scrollstart",
taphold: "tap",
swipeleft: "swipe",
swiperight: "swipe"
}, function( event, sourceEvent ) {
$.event.special[ event ] = {
setup: function() {
$( this ).bind( sourceEvent, $.noop );
},
teardown: function() {
$( this ).unbind( sourceEvent );
}
};
});
})( jQuery, this );
(function( $, undefined ) {
var props = {
"animation": {},
"transition": {}
},
testElement = document.createElement( "a" ),
vendorPrefixes = [ "", "webkit-", "moz-", "o-" ];
$.each( [ "animation", "transition" ], function( i, test ) {
// Get correct name for test
var testName = ( i === 0 ) ? test + "-" + "name" : test;
$.each( vendorPrefixes, function( j, prefix ) {
if ( testElement.style[ $.camelCase( prefix + testName ) ] !== undefined ) {
props[ test ][ "prefix" ] = prefix;
return false;
}
});
// Set event and duration names for later use
props[ test ][ "duration" ] =
$.camelCase( props[ test ][ "prefix" ] + test + "-" + "duration" );
props[ test ][ "event" ] =
$.camelCase( props[ test ][ "prefix" ] + test + "-" + "end" );
// All lower case if not a vendor prop
if ( props[ test ][ "prefix" ] === "" ) {
props[ test ][ "event" ] = props[ test ][ "event" ].toLowerCase();
}
});
// If a valid prefix was found then the it is supported by the browser
$.support.cssTransitions = ( props[ "transition" ][ "prefix" ] !== undefined );
$.support.cssAnimations = ( props[ "animation" ][ "prefix" ] !== undefined );
// Remove the testElement
$( testElement ).remove();
// Animation complete callback
$.fn.animationComplete = function( callback, type, fallbackTime ) {
var timer, duration,
that = this,
animationType = ( !type || type === "animation" ) ? "animation" : "transition";
// Make sure selected type is supported by browser
if ( ( $.support.cssTransitions && animationType === "transition" ) ||
( $.support.cssAnimations && animationType === "animation" ) ) {
// If a fallback time was not passed set one
if ( fallbackTime === undefined ) {
// Make sure the was not bound to document before checking .css
if ( $( this ).context !== document ) {
// Parse the durration since its in second multiple by 1000 for milliseconds
// Multiply by 3 to make sure we give the animation plenty of time.
duration = parseFloat(
$( this ).css( props[ animationType ].duration )
) * 3000;
}
// If we could not read a duration use the default
if ( duration === 0 || duration === undefined || isNaN( duration ) ) {
duration = $.fn.animationComplete.defaultDuration;
}
}
// Sets up the fallback if event never comes
timer = setTimeout( function() {
$( that ).off( props[ animationType ].event );
callback.apply( that );
}, duration );
// Bind the event
return $( this ).one( props[ animationType ].event, function() {
// Clear the timer so we dont call callback twice
clearTimeout( timer );
callback.call( this, arguments );
});
} else {
// CSS animation / transitions not supported
// Defer execution for consistency between webkit/non webkit
setTimeout( $.proxy( callback, this ), 0 );
return $( this );
}
};
// Allow default callback to be configured on mobileInit
$.fn.animationComplete.defaultDuration = 1000;
})( jQuery );
(function( $, undefined ) {
var path, $base, dialogHashKey = "&ui-state=dialog";
$.mobile.path = path = {
uiStateKey: "&ui-state",
// This scary looking regular expression parses an absolute URL or its relative
// variants (protocol, site, document, query, and hash), into the various
// components (protocol, host, path, query, fragment, etc that make up the
// URL as well as some other commonly used sub-parts. When used with RegExp.exec()
// or String.match, it parses the URL into a results array that looks like this:
//
// [0]: http://jblas:password@mycompany.com:8080/mail/inbox?msg=1234&type=unread#msg-content
// [1]: http://jblas:password@mycompany.com:8080/mail/inbox?msg=1234&type=unread
// [2]: http://jblas:password@mycompany.com:8080/mail/inbox
// [3]: http://jblas:password@mycompany.com:8080
// [4]: http:
// [5]: //
// [6]: jblas:password@mycompany.com:8080
// [7]: jblas:password
// [8]: jblas
// [9]: password
// [10]: mycompany.com:8080
// [11]: mycompany.com
// [12]: 8080
// [13]: /mail/inbox
// [14]: /mail/
// [15]: inbox
// [16]: ?msg=1234&type=unread
// [17]: #msg-content
//
urlParseRE: /^\s*(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/,
// Abstraction to address xss (Issue #4787) by removing the authority in
// browsers that auto decode it. All references to location.href should be
// replaced with a call to this method so that it can be dealt with properly here
getLocation: function( url ) {
var uri = url ? this.parseUrl( url ) : location,
hash = this.parseUrl( url || location.href ).hash;
// mimic the browser with an empty string when the hash is empty
hash = hash === "#" ? "" : hash;
// Make sure to parse the url or the location object for the hash because using location.hash
// is autodecoded in firefox, the rest of the url should be from the object (location unless
// we're testing) to avoid the inclusion of the authority
return uri.protocol + "//" + uri.host + uri.pathname + uri.search + hash;
},
//return the original document url
getDocumentUrl: function( asParsedObject ) {
return asParsedObject ? $.extend( {}, path.documentUrl ) : path.documentUrl.href;
},
parseLocation: function() {
return this.parseUrl( this.getLocation() );
},
//Parse a URL into a structure that allows easy access to
//all of the URL components by name.
parseUrl: function( url ) {
// If we're passed an object, we'll assume that it is
// a parsed url object and just return it back to the caller.
if ( $.type( url ) === "object" ) {
return url;
}
var matches = path.urlParseRE.exec( url || "" ) || [];
// Create an object that allows the caller to access the sub-matches
// by name. Note that IE returns an empty string instead of undefined,
// like all other browsers do, so we normalize everything so its consistent
// no matter what browser we're running on.
return {
href: matches[ 0 ] || "",
hrefNoHash: matches[ 1 ] || "",
hrefNoSearch: matches[ 2 ] || "",
domain: matches[ 3 ] || "",
protocol: matches[ 4 ] || "",
doubleSlash: matches[ 5 ] || "",
authority: matches[ 6 ] || "",
username: matches[ 8 ] || "",
password: matches[ 9 ] || "",
host: matches[ 10 ] || "",
hostname: matches[ 11 ] || "",
port: matches[ 12 ] || "",
pathname: matches[ 13 ] || "",
directory: matches[ 14 ] || "",
filename: matches[ 15 ] || "",
search: matches[ 16 ] || "",
hash: matches[ 17 ] || ""
};
},
//Turn relPath into an asbolute path. absPath is
//an optional absolute path which describes what
//relPath is relative to.
makePathAbsolute: function( relPath, absPath ) {
var absStack,
relStack,
i, d;
if ( relPath && relPath.charAt( 0 ) === "/" ) {
return relPath;
}
relPath = relPath || "";
absPath = absPath ? absPath.replace( /^\/|(\/[^\/]*|[^\/]+)$/g, "" ) : "";
absStack = absPath ? absPath.split( "/" ) : [];
relStack = relPath.split( "/" );
for ( i = 0; i < relStack.length; i++ ) {
d = relStack[ i ];
switch ( d ) {
case ".":
break;
case "..":
if ( absStack.length ) {
absStack.pop();
}
break;
default:
absStack.push( d );
break;
}
}
return "/" + absStack.join( "/" );
},
//Returns true if both urls have the same domain.
isSameDomain: function( absUrl1, absUrl2 ) {
return path.parseUrl( absUrl1 ).domain === path.parseUrl( absUrl2 ).domain;
},
//Returns true for any relative variant.
isRelativeUrl: function( url ) {
// All relative Url variants have one thing in common, no protocol.
return path.parseUrl( url ).protocol === "";
},
//Returns true for an absolute url.
isAbsoluteUrl: function( url ) {
return path.parseUrl( url ).protocol !== "";
},
//Turn the specified realtive URL into an absolute one. This function
//can handle all relative variants (protocol, site, document, query, fragment).
makeUrlAbsolute: function( relUrl, absUrl ) {
if ( !path.isRelativeUrl( relUrl ) ) {
return relUrl;
}
if ( absUrl === undefined ) {
absUrl = this.documentBase;
}
var relObj = path.parseUrl( relUrl ),
absObj = path.parseUrl( absUrl ),
protocol = relObj.protocol || absObj.protocol,
doubleSlash = relObj.protocol ? relObj.doubleSlash : ( relObj.doubleSlash || absObj.doubleSlash ),
authority = relObj.authority || absObj.authority,
hasPath = relObj.pathname !== "",
pathname = path.makePathAbsolute( relObj.pathname || absObj.filename, absObj.pathname ),
search = relObj.search || ( !hasPath && absObj.search ) || "",
hash = relObj.hash;
return protocol + doubleSlash + authority + pathname + search + hash;
},
//Add search (aka query) params to the specified url.
addSearchParams: function( url, params ) {
var u = path.parseUrl( url ),
p = ( typeof params === "object" ) ? $.param( params ) : params,
s = u.search || "?";
return u.hrefNoSearch + s + ( s.charAt( s.length - 1 ) !== "?" ? "&" : "" ) + p + ( u.hash || "" );
},
convertUrlToDataUrl: function( absUrl ) {
var u = path.parseUrl( absUrl );
if ( path.isEmbeddedPage( u ) ) {
// For embedded pages, remove the dialog hash key as in getFilePath(),
// and remove otherwise the Data Url won't match the id of the embedded Page.
return u.hash
.split( dialogHashKey )[0]
.replace( /^#/, "" )
.replace( /\?.*$/, "" );
} else if ( path.isSameDomain( u, this.documentBase ) ) {
return u.hrefNoHash.replace( this.documentBase.domain, "" ).split( dialogHashKey )[0];
}
return window.decodeURIComponent(absUrl);
},
//get path from current hash, or from a file path
get: function( newPath ) {
if ( newPath === undefined ) {
newPath = path.parseLocation().hash;
}
return path.stripHash( newPath ).replace( /[^\/]*\.[^\/*]+$/, "" );
},
//set location hash to path
set: function( path ) {
location.hash = path;
},
//test if a given url (string) is a path
//NOTE might be exceptionally naive
isPath: function( url ) {
return ( /\// ).test( url );
},
//return a url path with the window's location protocol/hostname/pathname removed
clean: function( url ) {
return url.replace( this.documentBase.domain, "" );
},
//just return the url without an initial #
stripHash: function( url ) {
return url.replace( /^#/, "" );
},
stripQueryParams: function( url ) {
return url.replace( /\?.*$/, "" );
},
//remove the preceding hash, any query params, and dialog notations
cleanHash: function( hash ) {
return path.stripHash( hash.replace( /\?.*$/, "" ).replace( dialogHashKey, "" ) );
},
isHashValid: function( hash ) {
return ( /^#[^#]+$/ ).test( hash );
},
//check whether a url is referencing the same domain, or an external domain or different protocol
//could be mailto, etc
isExternal: function( url ) {
var u = path.parseUrl( url );
return u.protocol && u.domain !== this.documentUrl.domain ? true : false;
},
hasProtocol: function( url ) {
return ( /^(:?\w+:)/ ).test( url );
},
isEmbeddedPage: function( url ) {
var u = path.parseUrl( url );
//if the path is absolute, then we need to compare the url against
//both the this.documentUrl and the documentBase. The main reason for this
//is that links embedded within external documents will refer to the
//application document, whereas links embedded within the application
//document will be resolved against the document base.
if ( u.protocol !== "" ) {
return ( !this.isPath(u.hash) && u.hash && ( u.hrefNoHash === this.documentUrl.hrefNoHash || ( this.documentBaseDiffers && u.hrefNoHash === this.documentBase.hrefNoHash ) ) );
}
return ( /^#/ ).test( u.href );
},
squash: function( url, resolutionUrl ) {
var href, cleanedUrl, search, stateIndex,
isPath = this.isPath( url ),
uri = this.parseUrl( url ),
preservedHash = uri.hash,
uiState = "";
// produce a url against which we can resole the provided path
resolutionUrl = resolutionUrl || (path.isPath(url) ? path.getLocation() : path.getDocumentUrl());
// If the url is anything but a simple string, remove any preceding hash
// eg #foo/bar -> foo/bar
// #foo -> #foo
cleanedUrl = isPath ? path.stripHash( url ) : url;
// If the url is a full url with a hash check if the parsed hash is a path
// if it is, strip the #, and use it otherwise continue without change
cleanedUrl = path.isPath( uri.hash ) ? path.stripHash( uri.hash ) : cleanedUrl;
// Split the UI State keys off the href
stateIndex = cleanedUrl.indexOf( this.uiStateKey );
// store the ui state keys for use
if ( stateIndex > -1 ) {
uiState = cleanedUrl.slice( stateIndex );
cleanedUrl = cleanedUrl.slice( 0, stateIndex );
}
// make the cleanedUrl absolute relative to the resolution url
href = path.makeUrlAbsolute( cleanedUrl, resolutionUrl );
// grab the search from the resolved url since parsing from
// the passed url may not yield the correct result
search = this.parseUrl( href ).search;
// TODO all this crap is terrible, clean it up
if ( isPath ) {
// reject the hash if it's a path or it's just a dialog key
if ( path.isPath( preservedHash ) || preservedHash.replace("#", "").indexOf( this.uiStateKey ) === 0) {
preservedHash = "";
}
// Append the UI State keys where it exists and it's been removed
// from the url
if ( uiState && preservedHash.indexOf( this.uiStateKey ) === -1) {
preservedHash += uiState;
}
// make sure that pound is on the front of the hash
if ( preservedHash.indexOf( "#" ) === -1 && preservedHash !== "" ) {
preservedHash = "#" + preservedHash;
}
// reconstruct each of the pieces with the new search string and hash
href = path.parseUrl( href );
href = href.protocol + "//" + href.host + href.pathname + search + preservedHash;
} else {
href += href.indexOf( "#" ) > -1 ? uiState : "#" + uiState;
}
return href;
},
isPreservableHash: function( hash ) {
return hash.replace( "#", "" ).indexOf( this.uiStateKey ) === 0;
},
// Escape weird characters in the hash if it is to be used as a selector
hashToSelector: function( hash ) {
var hasHash = ( hash.substring( 0, 1 ) === "#" );
if ( hasHash ) {
hash = hash.substring( 1 );
}
return ( hasHash ? "#" : "" ) + hash.replace( /([!"#$%&'()*+,./:;<=>?@[\]^`{|}~])/g, "\\$1" );
},
// return the substring of a filepath before the sub-page key, for making
// a server request
getFilePath: function( path ) {
var splitkey = "&" + $.mobile.subPageUrlKey;
return path && path.split( splitkey )[0].split( dialogHashKey )[0];
},
// check if the specified url refers to the first page in the main
// application document.
isFirstPageUrl: function( url ) {
// We only deal with absolute paths.
var u = path.parseUrl( path.makeUrlAbsolute( url, this.documentBase ) ),
// Does the url have the same path as the document?
samePath = u.hrefNoHash === this.documentUrl.hrefNoHash ||
( this.documentBaseDiffers &&
u.hrefNoHash === this.documentBase.hrefNoHash ),
// Get the first page element.
fp = $.mobile.firstPage,
// Get the id of the first page element if it has one.
fpId = fp && fp[0] ? fp[0].id : undefined;
// The url refers to the first page if the path matches the document and
// it either has no hash value, or the hash is exactly equal to the id
// of the first page element.
return samePath &&
( !u.hash ||
u.hash === "#" ||
( fpId && u.hash.replace( /^#/, "" ) === fpId ) );
},
// Some embedded browsers, like the web view in Phone Gap, allow
// cross-domain XHR requests if the document doing the request was loaded
// via the file:// protocol. This is usually to allow the application to
// "phone home" and fetch app specific data. We normally let the browser
// handle external/cross-domain urls, but if the allowCrossDomainPages
// option is true, we will allow cross-domain http/https requests to go
// through our page loading logic.
isPermittedCrossDomainRequest: function( docUrl, reqUrl ) {
return $.mobile.allowCrossDomainPages &&
(docUrl.protocol === "file:" || docUrl.protocol === "content:") &&
reqUrl.search( /^https?:/ ) !== -1;
}
};
path.documentUrl = path.parseLocation();
$base = $( "head" ).find( "base" );
path.documentBase = $base.length ?
path.parseUrl( path.makeUrlAbsolute( $base.attr( "href" ), path.documentUrl.href ) ) :
path.documentUrl;
path.documentBaseDiffers = (path.documentUrl.hrefNoHash !== path.documentBase.hrefNoHash);
//return the original document base url
path.getDocumentBase = function( asParsedObject ) {
return asParsedObject ? $.extend( {}, path.documentBase ) : path.documentBase.href;
};
// DEPRECATED as of 1.4.0 - remove in 1.5.0
$.extend( $.mobile, {
//return the original document url
getDocumentUrl: path.getDocumentUrl,
//return the original document base url
getDocumentBase: path.getDocumentBase
});
})( jQuery );
(function( $, undefined ) {
$.mobile.History = function( stack, index ) {
this.stack = stack || [];
this.activeIndex = index || 0;
};
$.extend($.mobile.History.prototype, {
getActive: function() {
return this.stack[ this.activeIndex ];
},
getLast: function() {
return this.stack[ this.previousIndex ];
},
getNext: function() {
return this.stack[ this.activeIndex + 1 ];
},
getPrev: function() {
return this.stack[ this.activeIndex - 1 ];
},
// addNew is used whenever a new page is added
add: function( url, data ) {
data = data || {};
//if there's forward history, wipe it
if ( this.getNext() ) {
this.clearForward();
}
// if the hash is included in the data make sure the shape
// is consistent for comparison
if ( data.hash && data.hash.indexOf( "#" ) === -1) {
data.hash = "#" + data.hash;
}
data.url = url;
this.stack.push( data );
this.activeIndex = this.stack.length - 1;
},
//wipe urls ahead of active index
clearForward: function() {
this.stack = this.stack.slice( 0, this.activeIndex + 1 );
},
find: function( url, stack, earlyReturn ) {
stack = stack || this.stack;
var entry, i, length = stack.length, index;
for ( i = 0; i < length; i++ ) {
entry = stack[i];
if ( decodeURIComponent(url) === decodeURIComponent(entry.url) ||
decodeURIComponent(url) === decodeURIComponent(entry.hash) ) {
index = i;
if ( earlyReturn ) {
return index;
}
}
}
return index;
},
closest: function( url ) {
var closest, a = this.activeIndex;
// First, take the slice of the history stack before the current index and search
// for a url match. If one is found, we'll avoid avoid looking through forward history
// NOTE the preference for backward history movement is driven by the fact that
// most mobile browsers only have a dedicated back button, and users rarely use
// the forward button in desktop browser anyhow
closest = this.find( url, this.stack.slice(0, a) );
// If nothing was found in backward history check forward. The `true`
// value passed as the third parameter causes the find method to break
// on the first match in the forward history slice. The starting index
// of the slice must then be added to the result to get the element index
// in the original history stack :( :(
//
// TODO this is hyper confusing and should be cleaned up (ugh so bad)
if ( closest === undefined ) {
closest = this.find( url, this.stack.slice(a), true );
closest = closest === undefined ? closest : closest + a;
}
return closest;
},
direct: function( opts ) {
var newActiveIndex = this.closest( opts.url ), a = this.activeIndex;
// save new page index, null check to prevent falsey 0 result
// record the previous index for reference
if ( newActiveIndex !== undefined ) {
this.activeIndex = newActiveIndex;
this.previousIndex = a;
}
// invoke callbacks where appropriate
//
// TODO this is also convoluted and confusing
if ( newActiveIndex < a ) {
( opts.present || opts.back || $.noop )( this.getActive(), "back" );
} else if ( newActiveIndex > a ) {
( opts.present || opts.forward || $.noop )( this.getActive(), "forward" );
} else if ( newActiveIndex === undefined && opts.missing ) {
opts.missing( this.getActive() );
}
}
});
})( jQuery );
(function( $, undefined ) {
var path = $.mobile.path,
initialHref = location.href;
$.mobile.Navigator = function( history ) {
this.history = history;
this.ignoreInitialHashChange = true;
$.mobile.window.bind({
"popstate.history": $.proxy( this.popstate, this ),
"hashchange.history": $.proxy( this.hashchange, this )
});
};
$.extend($.mobile.Navigator.prototype, {
squash: function( url, data ) {
var state, href, hash = path.isPath(url) ? path.stripHash(url) : url;
href = path.squash( url );
// make sure to provide this information when it isn't explicitly set in the
// data object that was passed to the squash method
state = $.extend({
hash: hash,
url: href
}, data);
// replace the current url with the new href and store the state
// Note that in some cases we might be replacing an url with the
// same url. We do this anyways because we need to make sure that
// all of our history entries have a state object associated with
// them. This allows us to work around the case where $.mobile.back()
// is called to transition from an external page to an embedded page.
// In that particular case, a hashchange event is *NOT* generated by the browser.
// Ensuring each history entry has a state object means that onPopState()
// will always trigger our hashchange callback even when a hashchange event
// is not fired.
window.history.replaceState( state, state.title || document.title, href );
return state;
},
hash: function( url, href ) {
var parsed, loc, hash, resolved;
// Grab the hash for recording. If the passed url is a path
// we used the parsed version of the squashed url to reconstruct,
// otherwise we assume it's a hash and store it directly
parsed = path.parseUrl( url );
loc = path.parseLocation();
if ( loc.pathname + loc.search === parsed.pathname + parsed.search ) {
// If the pathname and search of the passed url is identical to the current loc
// then we must use the hash. Otherwise there will be no event
// eg, url = "/foo/bar?baz#bang", location.href = "http://example.com/foo/bar?baz"
hash = parsed.hash ? parsed.hash : parsed.pathname + parsed.search;
} else if ( path.isPath(url) ) {
resolved = path.parseUrl( href );
// If the passed url is a path, make it domain relative and remove any trailing hash
hash = resolved.pathname + resolved.search + (path.isPreservableHash( resolved.hash )? resolved.hash.replace( "#", "" ) : "");
} else {
hash = url;
}
return hash;
},
// TODO reconsider name
go: function( url, data, noEvents ) {
var state, href, hash, popstateEvent,
isPopStateEvent = $.event.special.navigate.isPushStateEnabled();
// Get the url as it would look squashed on to the current resolution url
href = path.squash( url );
// sort out what the hash sould be from the url
hash = this.hash( url, href );
// Here we prevent the next hash change or popstate event from doing any
// history management. In the case of hashchange we don't swallow it
// if there will be no hashchange fired (since that won't reset the value)
// and will swallow the following hashchange
if ( noEvents && hash !== path.stripHash(path.parseLocation().hash) ) {
this.preventNextHashChange = noEvents;
}
// IMPORTANT in the case where popstate is supported the event will be triggered
// directly, stopping further execution - ie, interupting the flow of this
// method call to fire bindings at this expression. Below the navigate method
// there is a binding to catch this event and stop its propagation.
//
// We then trigger a new popstate event on the window with a null state
// so that the navigate events can conclude their work properly
//
// if the url is a path we want to preserve the query params that are available on
// the current url.
this.preventHashAssignPopState = true;
window.location.hash = hash;
// If popstate is enabled and the browser triggers `popstate` events when the hash
// is set (this often happens immediately in browsers like Chrome), then the
// this flag will be set to false already. If it's a browser that does not trigger
// a `popstate` on hash assignement or `replaceState` then we need avoid the branch
// that swallows the event created by the popstate generated by the hash assignment
// At the time of this writing this happens with Opera 12 and some version of IE
this.preventHashAssignPopState = false;
state = $.extend({
url: href,
hash: hash,
title: document.title
}, data);
if ( isPopStateEvent ) {
popstateEvent = new $.Event( "popstate" );
popstateEvent.originalEvent = {
type: "popstate",
state: null
};
this.squash( url, state );
// Trigger a new faux popstate event to replace the one that we
// caught that was triggered by the hash setting above.
if ( !noEvents ) {
this.ignorePopState = true;
$.mobile.window.trigger( popstateEvent );
}
}
// record the history entry so that the information can be included
// in hashchange event driven navigate events in a similar fashion to
// the state that's provided by popstate
this.history.add( state.url, state );
},
// This binding is intended to catch the popstate events that are fired
// when execution of the `$.navigate` method stops at window.location.hash = url;
// and completely prevent them from propagating. The popstate event will then be
// retriggered after execution resumes
//
// TODO grab the original event here and use it for the synthetic event in the
// second half of the navigate execution that will follow this binding
popstate: function( event ) {
var hash, state;
// Partly to support our test suite which manually alters the support
// value to test hashchange. Partly to prevent all around weirdness
if ( !$.event.special.navigate.isPushStateEnabled() ) {
return;
}
// If this is the popstate triggered by the actual alteration of the hash
// prevent it completely. History is tracked manually
if ( this.preventHashAssignPopState ) {
this.preventHashAssignPopState = false;
event.stopImmediatePropagation();
return;
}
// if this is the popstate triggered after the `replaceState` call in the go
// method, then simply ignore it. The history entry has already been captured
if ( this.ignorePopState ) {
this.ignorePopState = false;
return;
}
// If there is no state, and the history stack length is one were
// probably getting the page load popstate fired by browsers like chrome
// avoid it and set the one time flag to false.
// TODO: Do we really need all these conditions? Comparing location hrefs
// should be sufficient.
if ( !event.originalEvent.state &&
this.history.stack.length === 1 &&
this.ignoreInitialHashChange ) {
this.ignoreInitialHashChange = false;
if ( location.href === initialHref ) {
event.preventDefault();
return;
}
}
// account for direct manipulation of the hash. That is, we will receive a popstate
// when the hash is changed by assignment, and it won't have a state associated. We
// then need to squash the hash. See below for handling of hash assignment that
// matches an existing history entry
// TODO it might be better to only add to the history stack
// when the hash is adjacent to the active history entry
hash = path.parseLocation().hash;
if ( !event.originalEvent.state && hash ) {
// squash the hash that's been assigned on the URL with replaceState
// also grab the resulting state object for storage
state = this.squash( hash );
// record the new hash as an additional history entry
// to match the browser's treatment of hash assignment
this.history.add( state.url, state );
// pass the newly created state information
// along with the event
event.historyState = state;
// do not alter history, we've added a new history entry
// so we know where we are
return;
}
// If all else fails this is a popstate that comes from the back or forward buttons
// make sure to set the state of our history stack properly, and record the directionality
this.history.direct({
url: (event.originalEvent.state || {}).url || hash,
// When the url is either forward or backward in history include the entry
// as data on the event object for merging as data in the navigate event
present: function( historyEntry, direction ) {
// make sure to create a new object to pass down as the navigate event data
event.historyState = $.extend({}, historyEntry);
event.historyState.direction = direction;
}
});
},
// NOTE must bind before `navigate` special event hashchange binding otherwise the
// navigation data won't be attached to the hashchange event in time for those
// bindings to attach it to the `navigate` special event
// TODO add a check here that `hashchange.navigate` is bound already otherwise it's
// broken (exception?)
hashchange: function( event ) {
var history, hash;
// If hashchange listening is explicitly disabled or pushstate is supported
// avoid making use of the hashchange handler.
if (!$.event.special.navigate.isHashChangeEnabled() ||
$.event.special.navigate.isPushStateEnabled() ) {
return;
}
// On occasion explicitly want to prevent the next hash from propogating because we only
// with to alter the url to represent the new state do so here
if ( this.preventNextHashChange ) {
this.preventNextHashChange = false;
event.stopImmediatePropagation();
return;
}
history = this.history;
hash = path.parseLocation().hash;
// If this is a hashchange caused by the back or forward button
// make sure to set the state of our history stack properly
this.history.direct({
url: hash,
// When the url is either forward or backward in history include the entry
// as data on the event object for merging as data in the navigate event
present: function( historyEntry, direction ) {
// make sure to create a new object to pass down as the navigate event data
event.hashchangeState = $.extend({}, historyEntry);
event.hashchangeState.direction = direction;
},
// When we don't find a hash in our history clearly we're aiming to go there
// record the entry as new for future traversal
//
// NOTE it's not entirely clear that this is the right thing to do given that we
// can't know the users intention. It might be better to explicitly _not_
// support location.hash assignment in preference to $.navigate calls
// TODO first arg to add should be the href, but it causes issues in identifying
// embeded pages
missing: function() {
history.add( hash, {
hash: hash,
title: document.title
});
}
});
}
});
})( jQuery );
(function( $, undefined ) {
// TODO consider queueing navigation activity until previous activities have completed
// so that end users don't have to think about it. Punting for now
// TODO !! move the event bindings into callbacks on the navigate event
$.mobile.navigate = function( url, data, noEvents ) {
$.mobile.navigate.navigator.go( url, data, noEvents );
};
// expose the history on the navigate method in anticipation of full integration with
// existing navigation functionalty that is tightly coupled to the history information
$.mobile.navigate.history = new $.mobile.History();
// instantiate an instance of the navigator for use within the $.navigate method
$.mobile.navigate.navigator = new $.mobile.Navigator( $.mobile.navigate.history );
var loc = $.mobile.path.parseLocation();
$.mobile.navigate.history.add( loc.href, {hash: loc.hash} );
})( jQuery );
(function( $, undefined ) {
// existing base tag?
var baseElement = $( "head" ).children( "base" ),
// base element management, defined depending on dynamic base tag support
// TODO move to external widget
base = {
// define base element, for use in routing asset urls that are referenced
// in Ajax-requested markup
element: ( baseElement.length ? baseElement :
$( "<base>", { href: $.mobile.path.documentBase.hrefNoHash } ).prependTo( $( "head" ) ) ),
linkSelector: "[src], link[href], a[rel='external'], :jqmData(ajax='false'), a[target]",
// set the generated BASE element's href to a new page's base path
set: function( href ) {
// we should do nothing if the user wants to manage their url base
// manually
if ( !$.mobile.dynamicBaseEnabled ) {
return;
}
// we should use the base tag if we can manipulate it dynamically
if ( $.support.dynamicBaseTag ) {
base.element.attr( "href",
$.mobile.path.makeUrlAbsolute( href, $.mobile.path.documentBase ) );
}
},
rewrite: function( href, page ) {
var newPath = $.mobile.path.get( href );
page.find( base.linkSelector ).each(function( i, link ) {
var thisAttr = $( link ).is( "[href]" ) ? "href" :
$( link ).is( "[src]" ) ? "src" : "action",
thisUrl = $( link ).attr( thisAttr );
// XXX_jblas: We need to fix this so that it removes the document
// base URL, and then prepends with the new page URL.
// if full path exists and is same, chop it - helps IE out
thisUrl = thisUrl.replace( location.protocol + "//" +
location.host + location.pathname, "" );
if ( !/^(\w+:|#|\/)/.test( thisUrl ) ) {
$( link ).attr( thisAttr, newPath + thisUrl );
}
});
},
// set the generated BASE element's href to a new page's base path
reset: function(/* href */) {
base.element.attr( "href", $.mobile.path.documentBase.hrefNoSearch );
}
};
$.mobile.base = base;
})( jQuery );
/*!
* jQuery UI Widget c0ab71056b936627e8a7821f03c044aec6280a40
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/jQuery.widget/
*/
(function( $, undefined ) {
var uuid = 0,
slice = Array.prototype.slice,
_cleanData = $.cleanData;
$.cleanData = function( elems ) {
for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
try {
$( elem ).triggerHandler( "remove" );
// http://bugs.jquery.com/ticket/8235
} catch( e ) {}
}
_cleanData( elems );
};
$.widget = function( name, base, prototype ) {
var fullName, existingConstructor, constructor, basePrototype,
// proxiedPrototype allows the provided prototype to remain unmodified
// so that it can be used as a mixin for multiple widgets (#8876)
proxiedPrototype = {},
namespace = name.split( "." )[ 0 ];
name = name.split( "." )[ 1 ];
fullName = namespace + "-" + name;
if ( !prototype ) {
prototype = base;
base = $.Widget;
}
// create selector for plugin
$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
return !!$.data( elem, fullName );
};
$[ namespace ] = $[ namespace ] || {};
existingConstructor = $[ namespace ][ name ];
constructor = $[ namespace ][ name ] = function( options, element ) {
// allow instantiation without "new" keyword
if ( !this._createWidget ) {
return new constructor( options, element );
}
// allow instantiation without initializing for simple inheritance
// must use "new" keyword (the code above always passes args)
if ( arguments.length ) {
this._createWidget( options, element );
}
};
// extend with the existing constructor to carry over any static properties
$.extend( constructor, existingConstructor, {
version: prototype.version,
// copy the object used to create the prototype in case we need to
// redefine the widget later
_proto: $.extend( {}, prototype ),
// track widgets that inherit from this widget in case this widget is
// redefined after a widget inherits from it
_childConstructors: []
});
basePrototype = new base();
// we need to make the options hash a property directly on the new instance
// otherwise we'll modify the options hash on the prototype that we're
// inheriting from
basePrototype.options = $.widget.extend( {}, basePrototype.options );
$.each( prototype, function( prop, value ) {
if ( !$.isFunction( value ) ) {
proxiedPrototype[ prop ] = value;
return;
}
proxiedPrototype[ prop ] = (function() {
var _super = function() {
return base.prototype[ prop ].apply( this, arguments );
},
_superApply = function( args ) {
return base.prototype[ prop ].apply( this, args );
};
return function() {
var __super = this._super,
__superApply = this._superApply,
returnValue;
this._super = _super;
this._superApply = _superApply;
returnValue = value.apply( this, arguments );
this._super = __super;
this._superApply = __superApply;
return returnValue;
};
})();
});
constructor.prototype = $.widget.extend( basePrototype, {
// TODO: remove support for widgetEventPrefix
// always use the name + a colon as the prefix, e.g., draggable:start
// don't prefix for widgets that aren't DOM-based
widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
}, proxiedPrototype, {
constructor: constructor,
namespace: namespace,
widgetName: name,
widgetFullName: fullName
});
// If this widget is being redefined then we need to find all widgets that
// are inheriting from it and redefine all of them so that they inherit from
// the new version of this widget. We're essentially trying to replace one
// level in the prototype chain.
if ( existingConstructor ) {
$.each( existingConstructor._childConstructors, function( i, child ) {
var childPrototype = child.prototype;
// redefine the child widget using the same prototype that was
// originally used, but inherit from the new version of the base
$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
});
// remove the list of existing child constructors from the old constructor
// so the old child constructors can be garbage collected
delete existingConstructor._childConstructors;
} else {
base._childConstructors.push( constructor );
}
$.widget.bridge( name, constructor );
return constructor;
};
$.widget.extend = function( target ) {
var input = slice.call( arguments, 1 ),
inputIndex = 0,
inputLength = input.length,
key,
value;
for ( ; inputIndex < inputLength; inputIndex++ ) {
for ( key in input[ inputIndex ] ) {
value = input[ inputIndex ][ key ];
if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
// Clone objects
if ( $.isPlainObject( value ) ) {
target[ key ] = $.isPlainObject( target[ key ] ) ?
$.widget.extend( {}, target[ key ], value ) :
// Don't extend strings, arrays, etc. with objects
$.widget.extend( {}, value );
// Copy everything else by reference
} else {
target[ key ] = value;
}
}
}
}
return target;
};
$.widget.bridge = function( name, object ) {
var fullName = object.prototype.widgetFullName || name;
$.fn[ name ] = function( options ) {
var isMethodCall = typeof options === "string",
args = slice.call( arguments, 1 ),
returnValue = this;
// allow multiple hashes to be passed on init
options = !isMethodCall && args.length ?
$.widget.extend.apply( null, [ options ].concat(args) ) :
options;
if ( isMethodCall ) {
this.each(function() {
var methodValue,
instance = $.data( this, fullName );
if ( options === "instance" ) {
returnValue = instance;
return false;
}
if ( !instance ) {
return $.error( "cannot call methods on " + name + " prior to initialization; " +
"attempted to call method '" + options + "'" );
}
if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
return $.error( "no such method '" + options + "' for " + name + " widget instance" );
}
methodValue = instance[ options ].apply( instance, args );
if ( methodValue !== instance && methodValue !== undefined ) {
returnValue = methodValue && methodValue.jquery ?
returnValue.pushStack( methodValue.get() ) :
methodValue;
return false;
}
});
} else {
this.each(function() {
var instance = $.data( this, fullName );
if ( instance ) {
instance.option( options || {} )._init();
} else {
$.data( this, fullName, new object( options, this ) );
}
});
}
return returnValue;
};
};
$.Widget = function( /* options, element */ ) {};
$.Widget._childConstructors = [];
$.Widget.prototype = {
widgetName: "widget",
widgetEventPrefix: "",
defaultElement: "<div>",
options: {
disabled: false,
// callbacks
create: null
},
_createWidget: function( options, element ) {
element = $( element || this.defaultElement || this )[ 0 ];
this.element = $( element );
this.uuid = uuid++;
this.eventNamespace = "." + this.widgetName + this.uuid;
this.options = $.widget.extend( {},
this.options,
this._getCreateOptions(),
options );
this.bindings = $();
this.hoverable = $();
this.focusable = $();
if ( element !== this ) {
$.data( element, this.widgetFullName, this );
this._on( true, this.element, {
remove: function( event ) {
if ( event.target === element ) {
this.destroy();
}
}
});
this.document = $( element.style ?
// element within the document
element.ownerDocument :
// element is window or document
element.document || element );
this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
}
this._create();
this._trigger( "create", null, this._getCreateEventData() );
this._init();
},
_getCreateOptions: $.noop,
_getCreateEventData: $.noop,
_create: $.noop,
_init: $.noop,
destroy: function() {
this._destroy();
// we can probably remove the unbind calls in 2.0
// all event bindings should go through this._on()
this.element
.unbind( this.eventNamespace )
.removeData( this.widgetFullName )
// support: jquery <1.6.3
// http://bugs.jquery.com/ticket/9413
.removeData( $.camelCase( this.widgetFullName ) );
this.widget()
.unbind( this.eventNamespace )
.removeAttr( "aria-disabled" )
.removeClass(
this.widgetFullName + "-disabled " +
"ui-state-disabled" );
// clean up events and states
this.bindings.unbind( this.eventNamespace );
this.hoverable.removeClass( "ui-state-hover" );
this.focusable.removeClass( "ui-state-focus" );
},
_destroy: $.noop,
widget: function() {
return this.element;
},
option: function( key, value ) {
var options = key,
parts,
curOption,
i;
if ( arguments.length === 0 ) {
// don't return a reference to the internal hash
return $.widget.extend( {}, this.options );
}
if ( typeof key === "string" ) {
// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
options = {};
parts = key.split( "." );
key = parts.shift();
if ( parts.length ) {
curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
for ( i = 0; i < parts.length - 1; i++ ) {
curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
curOption = curOption[ parts[ i ] ];
}
key = parts.pop();
if ( value === undefined ) {
return curOption[ key ] === undefined ? null : curOption[ key ];
}
curOption[ key ] = value;
} else {
if ( value === undefined ) {
return this.options[ key ] === undefined ? null : this.options[ key ];
}
options[ key ] = value;
}
}
this._setOptions( options );
return this;
},
_setOptions: function( options ) {
var key;
for ( key in options ) {
this._setOption( key, options[ key ] );
}
return this;
},
_setOption: function( key, value ) {
this.options[ key ] = value;
if ( key === "disabled" ) {
this.widget()
.toggleClass( this.widgetFullName + "-disabled", !!value );
this.hoverable.removeClass( "ui-state-hover" );
this.focusable.removeClass( "ui-state-focus" );
}
return this;
},
enable: function() {
return this._setOptions({ disabled: false });
},
disable: function() {
return this._setOptions({ disabled: true });
},
_on: function( suppressDisabledCheck, element, handlers ) {
var delegateElement,
instance = this;
// no suppressDisabledCheck flag, shuffle arguments
if ( typeof suppressDisabledCheck !== "boolean" ) {
handlers = element;
element = suppressDisabledCheck;
suppressDisabledCheck = false;
}
// no element argument, shuffle and use this.element
if ( !handlers ) {
handlers = element;
element = this.element;
delegateElement = this.widget();
} else {
// accept selectors, DOM elements
element = delegateElement = $( element );
this.bindings = this.bindings.add( element );
}
$.each( handlers, function( event, handler ) {
function handlerProxy() {
// allow widgets to customize the disabled handling
// - disabled as an array instead of boolean
// - disabled class as method for disabling individual parts
if ( !suppressDisabledCheck &&
( instance.options.disabled === true ||
$( this ).hasClass( "ui-state-disabled" ) ) ) {
return;
}
return ( typeof handler === "string" ? instance[ handler ] : handler )
.apply( instance, arguments );
}
// copy the guid so direct unbinding works
if ( typeof handler !== "string" ) {
handlerProxy.guid = handler.guid =
handler.guid || handlerProxy.guid || $.guid++;
}
var match = event.match( /^(\w+)\s*(.*)$/ ),
eventName = match[1] + instance.eventNamespace,
selector = match[2];
if ( selector ) {
delegateElement.delegate( selector, eventName, handlerProxy );
} else {
element.bind( eventName, handlerProxy );
}
});
},
_off: function( element, eventName ) {
eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
element.unbind( eventName ).undelegate( eventName );
},
_delay: function( handler, delay ) {
function handlerProxy() {
return ( typeof handler === "string" ? instance[ handler ] : handler )
.apply( instance, arguments );
}
var instance = this;
return setTimeout( handlerProxy, delay || 0 );
},
_hoverable: function( element ) {
this.hoverable = this.hoverable.add( element );
this._on( element, {
mouseenter: function( event ) {
$( event.currentTarget ).addClass( "ui-state-hover" );
},
mouseleave: function( event ) {
$( event.currentTarget ).removeClass( "ui-state-hover" );
}
});
},
_focusable: function( element ) {
this.focusable = this.focusable.add( element );
this._on( element, {
focusin: function( event ) {
$( event.currentTarget ).addClass( "ui-state-focus" );
},
focusout: function( event ) {
$( event.currentTarget ).removeClass( "ui-state-focus" );
}
});
},
_trigger: function( type, event, data ) {
var prop, orig,
callback = this.options[ type ];
data = data || {};
event = $.Event( event );
event.type = ( type === this.widgetEventPrefix ?
type :
this.widgetEventPrefix + type ).toLowerCase();
// the original event may come from any element
// so we need to reset the target on the new event
event.target = this.element[ 0 ];
// copy original event properties over to the new event
orig = event.originalEvent;
if ( orig ) {
for ( prop in orig ) {
if ( !( prop in event ) ) {
event[ prop ] = orig[ prop ];
}
}
}
this.element.trigger( event, data );
return !( $.isFunction( callback ) &&
callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
event.isDefaultPrevented() );
}
};
$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
if ( typeof options === "string" ) {
options = { effect: options };
}
var hasOptions,
effectName = !options ?
method :
options === true || typeof options === "number" ?
defaultEffect :
options.effect || defaultEffect;
options = options || {};
if ( typeof options === "number" ) {
options = { duration: options };
}
hasOptions = !$.isEmptyObject( options );
options.complete = callback;
if ( options.delay ) {
element.delay( options.delay );
}
if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
element[ method ]( options );
} else if ( effectName !== method && element[ effectName ] ) {
element[ effectName ]( options.duration, options.easing, callback );
} else {
element.queue(function( next ) {
$( this )[ method ]();
if ( callback ) {
callback.call( element[ 0 ] );
}
next();
});
}
};
});
})( jQuery );
(function( $, undefined ) {
var rcapitals = /[A-Z]/g,
replaceFunction = function( c ) {
return "-" + c.toLowerCase();
};
$.extend( $.Widget.prototype, {
_getCreateOptions: function() {
var option, value,
elem = this.element[ 0 ],
options = {};
//
if ( !$.mobile.getAttribute( elem, "defaults" ) ) {
for ( option in this.options ) {
value = $.mobile.getAttribute( elem, option.replace( rcapitals, replaceFunction ) );
if ( value != null ) {
options[ option ] = value;
}
}
}
return options;
}
});
//TODO: Remove in 1.5 for backcompat only
$.mobile.widget = $.Widget;
})( jQuery );
(function( $, undefined ) {
$.mobile.widgets = {};
var originalWidget = $.widget,
// Record the original, non-mobileinit-modified version of $.mobile.keepNative
// so we can later determine whether someone has modified $.mobile.keepNative
keepNativeFactoryDefault = $.mobile.keepNative;
$.widget = (function( orig ) {
return function() {
var constructor = orig.apply( this, arguments ),
name = constructor.prototype.widgetName;
constructor.initSelector = ( ( constructor.prototype.initSelector !== undefined ) ?
constructor.prototype.initSelector : ":jqmData(role='" + name + "')" );
$.mobile.widgets[ name ] = constructor;
return constructor;
};
})( $.widget );
// Make sure $.widget still has bridge and extend methods
$.extend( $.widget, originalWidget );
// For backcompat remove in 1.5
$.mobile.document.on( "create", function( event ) {
$( event.target ).enhanceWithin();
});
$.widget( "mobile.page", {
options: {
theme: "a",
domCache: false,
// Deprecated in 1.4 remove in 1.5
keepNativeDefault: $.mobile.keepNative,
// Deprecated in 1.4 remove in 1.5
contentTheme: null,
enhanced: false
},
// DEPRECATED for > 1.4
// TODO remove at 1.5
_createWidget: function() {
$.Widget.prototype._createWidget.apply( this, arguments );
this._trigger( "init" );
},
_create: function() {
// If false is returned by the callbacks do not create the page
if ( this._trigger( "beforecreate" ) === false ) {
return false;
}
if ( !this.options.enhanced ) {
this._enhance();
}
this._on( this.element, {
pagebeforehide: "removeContainerBackground",
pagebeforeshow: "_handlePageBeforeShow"
});
this.element.enhanceWithin();
// Dialog widget is deprecated in 1.4 remove this in 1.5
if ( $.mobile.getAttribute( this.element[0], "role" ) === "dialog" && $.mobile.dialog ) {
this.element.dialog();
}
},
_enhance: function () {
var attrPrefix = "data-" + $.mobile.ns,
self = this;
if ( this.options.role ) {
this.element.attr( "data-" + $.mobile.ns + "role", this.options.role );
}
this.element
.attr( "tabindex", "0" )
.addClass( "ui-page ui-page-theme-" + this.options.theme );
// Manipulation of content os Deprecated as of 1.4 remove in 1.5
this.element.find( "[" + attrPrefix + "role='content']" ).each( function() {
var $this = $( this ),
theme = this.getAttribute( attrPrefix + "theme" ) || undefined;
self.options.contentTheme = theme || self.options.contentTheme || ( self.options.dialog && self.options.theme ) || ( self.element.jqmData("role") === "dialog" && self.options.theme );
$this.addClass( "ui-content" );
if ( self.options.contentTheme ) {
$this.addClass( "ui-body-" + ( self.options.contentTheme ) );
}
// Add ARIA role
$this.attr( "role", "main" ).addClass( "ui-content" );
});
},
bindRemove: function( callback ) {
var page = this.element;
// when dom caching is not enabled or the page is embedded bind to remove the page on hide
if ( !page.data( "mobile-page" ).options.domCache &&
page.is( ":jqmData(external-page='true')" ) ) {
// TODO use _on - that is, sort out why it doesn't work in this case
page.bind( "pagehide.remove", callback || function( e, data ) {
//check if this is a same page transition and if so don't remove the page
if( !data.samePage ){
var $this = $( this ),
prEvent = new $.Event( "pageremove" );
$this.trigger( prEvent );
if ( !prEvent.isDefaultPrevented() ) {
$this.removeWithDependents();
}
}
});
}
},
_setOptions: function( o ) {
if ( o.theme !== undefined ) {
this.element.removeClass( "ui-page-theme-" + this.options.theme ).addClass( "ui-page-theme-" + o.theme );
}
if ( o.contentTheme !== undefined ) {
this.element.find( "[data-" + $.mobile.ns + "='content']" ).removeClass( "ui-body-" + this.options.contentTheme )
.addClass( "ui-body-" + o.contentTheme );
}
},
_handlePageBeforeShow: function(/* e */) {
this.setContainerBackground();
},
// Deprecated in 1.4 remove in 1.5
removeContainerBackground: function() {
this.element.closest( ":mobile-pagecontainer" ).pagecontainer({ "theme": "none" });
},
// Deprecated in 1.4 remove in 1.5
// set the page container background to the page theme
setContainerBackground: function( theme ) {
this.element.parent().pagecontainer( { "theme": theme || this.options.theme } );
},
// Deprecated in 1.4 remove in 1.5
keepNativeSelector: function() {
var options = this.options,
keepNative = $.trim( options.keepNative || "" ),
globalValue = $.trim( $.mobile.keepNative ),
optionValue = $.trim( options.keepNativeDefault ),
// Check if $.mobile.keepNative has changed from the factory default
newDefault = ( keepNativeFactoryDefault === globalValue ?
"" : globalValue ),
// If $.mobile.keepNative has not changed, use options.keepNativeDefault
oldDefault = ( newDefault === "" ? optionValue : "" );
// Concatenate keepNative selectors from all sources where the value has
// changed or, if nothing has changed, return the default
return ( ( keepNative ? [ keepNative ] : [] )
.concat( newDefault ? [ newDefault ] : [] )
.concat( oldDefault ? [ oldDefault ] : [] )
.join( ", " ) );
}
});
})( jQuery );
(function( $, window, undefined ) {
// TODO remove direct references to $.mobile and properties, we should
// favor injection with params to the constructor
$.mobile.Transition = function() {
this.init.apply( this, arguments );
};
$.extend($.mobile.Transition.prototype, {
toPreClass: " ui-page-pre-in",
init: function( name, reverse, $to, $from ) {
$.extend(this, {
name: name,
reverse: reverse,
$to: $to,
$from: $from,
deferred: new $.Deferred()
});
},
cleanFrom: function() {
this.$from
.removeClass( $.mobile.activePageClass + " out in reverse " + this.name )
.height( "" );
},
// NOTE overridden by child object prototypes, noop'd here as defaults
beforeDoneIn: function() {},
beforeDoneOut: function() {},
beforeStartOut: function() {},
doneIn: function() {
this.beforeDoneIn();
this.$to.removeClass( "out in reverse " + this.name ).height( "" );
this.toggleViewportClass();
// In some browsers (iOS5), 3D transitions block the ability to scroll to the desired location during transition
// This ensures we jump to that spot after the fact, if we aren't there already.
if ( $.mobile.window.scrollTop() !== this.toScroll ) {
this.scrollPage();
}
if ( !this.sequential ) {
this.$to.addClass( $.mobile.activePageClass );
}
this.deferred.resolve( this.name, this.reverse, this.$to, this.$from, true );
},
doneOut: function( screenHeight, reverseClass, none, preventFocus ) {
this.beforeDoneOut();
this.startIn( screenHeight, reverseClass, none, preventFocus );
},
hideIn: function( callback ) {
// Prevent flickering in phonegap container: see comments at #4024 regarding iOS
this.$to.css( "z-index", -10 );
callback.call( this );
this.$to.css( "z-index", "" );
},
scrollPage: function() {
// By using scrollTo instead of silentScroll, we can keep things better in order
// Just to be precautios, disable scrollstart listening like silentScroll would
$.event.special.scrollstart.enabled = false;
//if we are hiding the url bar or the page was previously scrolled scroll to hide or return to position
if ( $.mobile.hideUrlBar || this.toScroll !== $.mobile.defaultHomeScroll ) {
window.scrollTo( 0, this.toScroll );
}
// reenable scrollstart listening like silentScroll would
setTimeout( function() {
$.event.special.scrollstart.enabled = true;
}, 150 );
},
startIn: function( screenHeight, reverseClass, none, preventFocus ) {
this.hideIn(function() {
this.$to.addClass( $.mobile.activePageClass + this.toPreClass );
// Send focus to page as it is now display: block
if ( !preventFocus ) {
$.mobile.focusPage( this.$to );
}
// Set to page height
this.$to.height( screenHeight + this.toScroll );
if ( !none ) {
this.scrollPage();
}
});
this.$to
.removeClass( this.toPreClass )
.addClass( this.name + " in " + reverseClass );
if ( !none ) {
this.$to.animationComplete( $.proxy(function() {
this.doneIn();
}, this ));
} else {
this.doneIn();
}
},
startOut: function( screenHeight, reverseClass, none ) {
this.beforeStartOut( screenHeight, reverseClass, none );
// Set the from page's height and start it transitioning out
// Note: setting an explicit height helps eliminate tiling in the transitions
this.$from
.height( screenHeight + $.mobile.window.scrollTop() )
.addClass( this.name + " out" + reverseClass );
},
toggleViewportClass: function() {
$.mobile.pageContainer.toggleClass( "ui-mobile-viewport-transitioning viewport-" + this.name );
},
transition: function() {
// NOTE many of these could be calculated/recorded in the constructor, it's my
// opinion that binding them as late as possible has value with regards to
// better transitions with fewer bugs. Ie, it's not guaranteed that the
// object will be created and transition will be run immediately after as
// it is today. So we wait until transition is invoked to gather the following
var none,
reverseClass = this.reverse ? " reverse" : "",
screenHeight = $.mobile.getScreenHeight(),
maxTransitionOverride = $.mobile.maxTransitionWidth !== false &&
$.mobile.window.width() > $.mobile.maxTransitionWidth;
this.toScroll = $.mobile.navigate.history.getActive().lastScroll || $.mobile.defaultHomeScroll;
none = !$.support.cssTransitions || !$.support.cssAnimations ||
maxTransitionOverride || !this.name || this.name === "none" ||
Math.max( $.mobile.window.scrollTop(), this.toScroll ) >
$.mobile.getMaxScrollForTransition();
this.toggleViewportClass();
if ( this.$from && !none ) {
this.startOut( screenHeight, reverseClass, none );
} else {
this.doneOut( screenHeight, reverseClass, none, true );
}
return this.deferred.promise();
}
});
})( jQuery, this );
(function( $ ) {
$.mobile.SerialTransition = function() {
this.init.apply(this, arguments);
};
$.extend($.mobile.SerialTransition.prototype, $.mobile.Transition.prototype, {
sequential: true,
beforeDoneOut: function() {
if ( this.$from ) {
this.cleanFrom();
}
},
beforeStartOut: function( screenHeight, reverseClass, none ) {
this.$from.animationComplete($.proxy(function() {
this.doneOut( screenHeight, reverseClass, none );
}, this ));
}
});
})( jQuery );
(function( $ ) {
$.mobile.ConcurrentTransition = function() {
this.init.apply(this, arguments);
};
$.extend($.mobile.ConcurrentTransition.prototype, $.mobile.Transition.prototype, {
sequential: false,
beforeDoneIn: function() {
if ( this.$from ) {
this.cleanFrom();
}
},
beforeStartOut: function( screenHeight, reverseClass, none ) {
this.doneOut( screenHeight, reverseClass, none );
}
});
})( jQuery );
(function( $ ) {
// generate the handlers from the above
var defaultGetMaxScrollForTransition = function() {
return $.mobile.getScreenHeight() * 3;
};
//transition handler dictionary for 3rd party transitions
$.mobile.transitionHandlers = {
"sequential": $.mobile.SerialTransition,
"simultaneous": $.mobile.ConcurrentTransition
};
// Make our transition handler the public default.
$.mobile.defaultTransitionHandler = $.mobile.transitionHandlers.sequential;
$.mobile.transitionFallbacks = {};
// If transition is defined, check if css 3D transforms are supported, and if not, if a fallback is specified
$.mobile._maybeDegradeTransition = function( transition ) {
if ( transition && !$.support.cssTransform3d && $.mobile.transitionFallbacks[ transition ] ) {
transition = $.mobile.transitionFallbacks[ transition ];
}
return transition;
};
// Set the getMaxScrollForTransition to default if no implementation was set by user
$.mobile.getMaxScrollForTransition = $.mobile.getMaxScrollForTransition || defaultGetMaxScrollForTransition;
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.pagecontainer", {
options: {
theme: "a"
},
initSelector: false,
_create: function() {
this.setLastScrollEnabled = true;
this._on( this.window, {
// disable an scroll setting when a hashchange has been fired,
// this only works because the recording of the scroll position
// is delayed for 100ms after the browser might have changed the
// position because of the hashchange
navigate: "_disableRecordScroll",
// bind to scrollstop for the first page, "pagechange" won't be
// fired in that case
scrollstop: "_delayedRecordScroll"
});
// TODO consider moving the navigation handler OUT of widget into
// some other object as glue between the navigate event and the
// content widget load and change methods
this._on( this.window, { navigate: "_filterNavigateEvents" });
// TODO move from page* events to content* events
this._on({ pagechange: "_afterContentChange" });
// handle initial hashchange from chrome :(
this.window.one( "navigate", $.proxy(function() {
this.setLastScrollEnabled = true;
}, this));
},
_setOptions: function( options ) {
if ( options.theme !== undefined && options.theme !== "none" ) {
this.element.removeClass( "ui-overlay-" + this.options.theme )
.addClass( "ui-overlay-" + options.theme );
} else if ( options.theme !== undefined ) {
this.element.removeClass( "ui-overlay-" + this.options.theme );
}
this._super( options );
},
_disableRecordScroll: function() {
this.setLastScrollEnabled = false;
},
_enableRecordScroll: function() {
this.setLastScrollEnabled = true;
},
// TODO consider the name here, since it's purpose specific
_afterContentChange: function() {
// once the page has changed, re-enable the scroll recording
this.setLastScrollEnabled = true;
// remove any binding that previously existed on the get scroll
// which may or may not be different than the scroll element
// determined for this page previously
this._off( this.window, "scrollstop" );
// determine and bind to the current scoll element which may be the
// window or in the case of touch overflow the element touch overflow
this._on( this.window, { scrollstop: "_delayedRecordScroll" });
},
_recordScroll: function() {
// this barrier prevents setting the scroll value based on
// the browser scrolling the window based on a hashchange
if ( !this.setLastScrollEnabled ) {
return;
}
var active = this._getActiveHistory(),
currentScroll, minScroll, defaultScroll;
if ( active ) {
currentScroll = this._getScroll();
minScroll = this._getMinScroll();
defaultScroll = this._getDefaultScroll();
// Set active page's lastScroll prop. If the location we're
// scrolling to is less than minScrollBack, let it go.
active.lastScroll = currentScroll < minScroll ? defaultScroll : currentScroll;
}
},
_delayedRecordScroll: function() {
setTimeout( $.proxy(this, "_recordScroll"), 100 );
},
_getScroll: function() {
return this.window.scrollTop();
},
_getMinScroll: function() {
return $.mobile.minScrollBack;
},
_getDefaultScroll: function() {
return $.mobile.defaultHomeScroll;
},
_filterNavigateEvents: function( e, data ) {
var url;
if ( e.originalEvent && e.originalEvent.isDefaultPrevented() ) {
return;
}
url = e.originalEvent.type.indexOf( "hashchange" ) > -1 ? data.state.hash : data.state.url;
if ( !url ) {
url = this._getHash();
}
if ( !url || url === "#" || url.indexOf( "#" + $.mobile.path.uiStateKey ) === 0 ) {
url = location.href;
}
this._handleNavigate( url, data.state );
},
_getHash: function() {
return $.mobile.path.parseLocation().hash;
},
// TODO active page should be managed by the container (ie, it should be a property)
getActivePage: function() {
return this.activePage;
},
// TODO the first page should be a property set during _create using the logic
// that currently resides in init
_getInitialContent: function() {
return $.mobile.firstPage;
},
// TODO each content container should have a history object
_getHistory: function() {
return $.mobile.navigate.history;
},
// TODO use _getHistory
_getActiveHistory: function() {
return $.mobile.navigate.history.getActive();
},
// TODO the document base should be determined at creation
_getDocumentBase: function() {
return $.mobile.path.documentBase;
},
back: function() {
this.go( -1 );
},
forward: function() {
this.go( 1 );
},
go: function( steps ) {
//if hashlistening is enabled use native history method
if ( $.mobile.hashListeningEnabled ) {
window.history.go( steps );
} else {
//we are not listening to the hash so handle history internally
var activeIndex = $.mobile.navigate.history.activeIndex,
index = activeIndex + parseInt( steps, 10 ),
url = $.mobile.navigate.history.stack[ index ].url,
direction = ( steps >= 1 )? "forward" : "back";
//update the history object
$.mobile.navigate.history.activeIndex = index;
$.mobile.navigate.history.previousIndex = activeIndex;
//change to the new page
this.change( url, { direction: direction, changeHash: false, fromHashChange: true } );
}
},
// TODO rename _handleDestination
_handleDestination: function( to ) {
var history;
// clean the hash for comparison if it's a url
if ( $.type(to) === "string" ) {
to = $.mobile.path.stripHash( to );
}
if ( to ) {
history = this._getHistory();
// At this point, 'to' can be one of 3 things, a cached page
// element from a history stack entry, an id, or site-relative /
// absolute URL. If 'to' is an id, we need to resolve it against
// the documentBase, not the location.href, since the hashchange
// could've been the result of a forward/backward navigation
// that crosses from an external page/dialog to an internal
// page/dialog.
//
// TODO move check to history object or path object?
to = !$.mobile.path.isPath( to ) ? ( $.mobile.path.makeUrlAbsolute( "#" + to, this._getDocumentBase() ) ) : to;
// If we're about to go to an initial URL that contains a
// reference to a non-existent internal page, go to the first
// page instead. We know that the initial hash refers to a
// non-existent page, because the initial hash did not end
// up in the initial history entry
// TODO move check to history object?
if ( to === $.mobile.path.makeUrlAbsolute( "#" + history.initialDst, this._getDocumentBase() ) &&
history.stack.length &&
history.stack[0].url !== history.initialDst.replace( $.mobile.dialogHashKey, "" ) ) {
to = this._getInitialContent();
}
}
return to || this._getInitialContent();
},
_handleDialog: function( changePageOptions, data ) {
var to, active, activeContent = this.getActivePage();
// If current active page is not a dialog skip the dialog and continue
// in the same direction
if ( activeContent && !activeContent.hasClass( "ui-dialog" ) ) {
// determine if we're heading forward or backward and continue
// accordingly past the current dialog
if ( data.direction === "back" ) {
this.back();
} else {
this.forward();
}
// prevent changePage call
return false;
} else {
// if the current active page is a dialog and we're navigating
// to a dialog use the dialog objected saved in the stack
to = data.pageUrl;
active = this._getActiveHistory();
// make sure to set the role, transition and reversal
// as most of this is lost by the domCache cleaning
$.extend( changePageOptions, {
role: active.role,
transition: active.transition,
reverse: data.direction === "back"
});
}
return to;
},
_handleNavigate: function( url, data ) {
//find first page via hash
// TODO stripping the hash twice with handleUrl
var to = $.mobile.path.stripHash( url ), history = this._getHistory(),
// transition is false if it's the first page, undefined
// otherwise (and may be overridden by default)
transition = history.stack.length === 0 ? "none" : undefined,
// default options for the changPage calls made after examining
// the current state of the page and the hash, NOTE that the
// transition is derived from the previous history entry
changePageOptions = {
changeHash: false,
fromHashChange: true,
reverse: data.direction === "back"
};
$.extend( changePageOptions, data, {
transition: ( history.getLast() || {} ).transition || transition
});
// TODO move to _handleDestination ?
// If this isn't the first page, if the current url is a dialog hash
// key, and the initial destination isn't equal to the current target
// page, use the special dialog handling
if ( history.activeIndex > 0 &&
to.indexOf( $.mobile.dialogHashKey ) > -1 &&
history.initialDst !== to ) {
to = this._handleDialog( changePageOptions, data );
if ( to === false ) {
return;
}
}
this._changeContent( this._handleDestination( to ), changePageOptions );
},
_changeContent: function( to, opts ) {
$.mobile.changePage( to, opts );
},
_getBase: function() {
return $.mobile.base;
},
_getNs: function() {
return $.mobile.ns;
},
_enhance: function( content, role ) {
// TODO consider supporting a custom callback, and passing in
// the settings which includes the role
return content.page({ role: role });
},
_include: function( page, settings ) {
// append to page and enhance
page.appendTo( this.element );
// use the page widget to enhance
this._enhance( page, settings.role );
// remove page on hide
page.page( "bindRemove" );
},
_find: function( absUrl ) {
// TODO consider supporting a custom callback
var fileUrl = this._createFileUrl( absUrl ),
dataUrl = this._createDataUrl( absUrl ),
page, initialContent = this._getInitialContent();
// Check to see if the page already exists in the DOM.
// NOTE do _not_ use the :jqmData pseudo selector because parenthesis
// are a valid url char and it breaks on the first occurence
page = this.element
.children( "[data-" + this._getNs() +"url='" + dataUrl + "']" );
// If we failed to find the page, check to see if the url is a
// reference to an embedded page. If so, it may have been dynamically
// injected by a developer, in which case it would be lacking a
// data-url attribute and in need of enhancement.
if ( page.length === 0 && dataUrl && !$.mobile.path.isPath( dataUrl ) ) {
page = this.element.children( $.mobile.path.hashToSelector("#" + dataUrl) )
.attr( "data-" + this._getNs() + "url", dataUrl )
.jqmData( "url", dataUrl );
}
// If we failed to find a page in the DOM, check the URL to see if it
// refers to the first page in the application. Also check to make sure
// our cached-first-page is actually in the DOM. Some user deployed
// apps are pruning the first page from the DOM for various reasons.
// We check for this case here because we don't want a first-page with
// an id falling through to the non-existent embedded page error case.
if ( page.length === 0 &&
$.mobile.path.isFirstPageUrl( fileUrl ) &&
initialContent &&
initialContent.parent().length ) {
page = $( initialContent );
}
return page;
},
_getLoader: function() {
return $.mobile.loading();
},
_showLoading: function( delay, theme, msg, textonly ) {
// This configurable timeout allows cached pages a brief
// delay to load without showing a message
if ( this._loadMsg ) {
return;
}
this._loadMsg = setTimeout($.proxy(function() {
this._getLoader().loader( "show", theme, msg, textonly );
this._loadMsg = 0;
}, this), delay );
},
_hideLoading: function() {
// Stop message show timer
clearTimeout( this._loadMsg );
this._loadMsg = 0;
// Hide loading message
this._getLoader().loader( "hide" );
},
_showError: function() {
// make sure to remove the current loading message
this._hideLoading();
// show the error message
this._showLoading( 0, $.mobile.pageLoadErrorMessageTheme, $.mobile.pageLoadErrorMessage, true );
// hide the error message after a delay
// TODO configuration
setTimeout( $.proxy(this, "_hideLoading"), 1500 );
},
_parse: function( html, fileUrl ) {
// TODO consider allowing customization of this method. It's very JQM specific
var page, all = $( "<div></div>" );
//workaround to allow scripts to execute when included in page divs
all.get( 0 ).innerHTML = html;
page = all.find( ":jqmData(role='page'), :jqmData(role='dialog')" ).first();
//if page elem couldn't be found, create one and insert the body element's contents
if ( !page.length ) {
page = $( "<div data-" + this._getNs() + "role='page'>" +
( html.split( /<\/?body[^>]*>/gmi )[1] || "" ) +
"</div>" );
}
// TODO tagging a page with external to make sure that embedded pages aren't
// removed by the various page handling code is bad. Having page handling code
// in many places is bad. Solutions post 1.0
page.attr( "data-" + this._getNs() + "url", $.mobile.path.convertUrlToDataUrl(fileUrl) )
.attr( "data-" + this._getNs() + "external-page", true );
return page;
},
_setLoadedTitle: function( page, html ) {
//page title regexp
var newPageTitle = html.match( /<title[^>]*>([^<]*)/ ) && RegExp.$1;
if ( newPageTitle && !page.jqmData("title") ) {
newPageTitle = $( "<div>" + newPageTitle + "</div>" ).text();
page.jqmData( "title", newPageTitle );
}
},
_isRewritableBaseTag: function() {
return $.mobile.dynamicBaseEnabled && !$.support.dynamicBaseTag;
},
_createDataUrl: function( absoluteUrl ) {
return $.mobile.path.convertUrlToDataUrl( absoluteUrl );
},
_createFileUrl: function( absoluteUrl ) {
return $.mobile.path.getFilePath( absoluteUrl );
},
_triggerWithDeprecated: function( name, data, page ) {
var deprecatedEvent = $.Event( "page" + name ),
newEvent = $.Event( this.widgetName + name );
// DEPRECATED
// trigger the old deprecated event on the page if it's provided
( page || this.element ).trigger( deprecatedEvent, data );
// use the widget trigger method for the new content* event
this.element.trigger( newEvent, data );
return {
deprecatedEvent: deprecatedEvent,
event: newEvent
};
},
// TODO it would be nice to split this up more but everything appears to be "one off"
// or require ordering such that other bits are sprinkled in between parts that
// could be abstracted out as a group
_loadSuccess: function( absUrl, triggerData, settings, deferred ) {
var fileUrl = this._createFileUrl( absUrl ),
dataUrl = this._createDataUrl( absUrl );
return $.proxy(function( html, textStatus, xhr ) {
//pre-parse html to check for a data-url,
//use it as the new fileUrl, base path, etc
var content,
// TODO handle dialogs again
pageElemRegex = new RegExp( "(<[^>]+\\bdata-" + this._getNs() + "role=[\"']?page[\"']?[^>]*>)" ),
dataUrlRegex = new RegExp( "\\bdata-" + this._getNs() + "url=[\"']?([^\"'>]*)[\"']?" );
// data-url must be provided for the base tag so resource requests
// can be directed to the correct url. loading into a temprorary
// element makes these requests immediately
if ( pageElemRegex.test( html ) &&
RegExp.$1 &&
dataUrlRegex.test( RegExp.$1 ) &&
RegExp.$1 ) {
fileUrl = $.mobile.path.getFilePath( $("<div>" + RegExp.$1 + "</div>").text() );
}
//dont update the base tag if we are prefetching
if ( settings.prefetch === undefined ) {
this._getBase().set( fileUrl );
}
content = this._parse( html, fileUrl );
this._setLoadedTitle( content, html );
// Add the content reference and xhr to our triggerData.
triggerData.xhr = xhr;
triggerData.textStatus = textStatus;
// DEPRECATED
triggerData.page = content;
triggerData.content = content;
// If the default behavior is prevented, stop here!
// Note that it is the responsibility of the listener/handler
// that called preventDefault(), to resolve/reject the
// deferred object within the triggerData.
if ( !this._trigger( "load", undefined, triggerData ) ) {
return;
}
// rewrite src and href attrs to use a base url if the base tag won't work
if ( this._isRewritableBaseTag() && content ) {
this._getBase().rewrite( fileUrl, content );
}
this._include( content, settings );
// Enhancing the content may result in new dialogs/sub content being inserted
// into the DOM. If the original absUrl refers to a sub-content, that is the
// real content we are interested in.
if ( absUrl.indexOf( "&" + $.mobile.subPageUrlKey ) > -1 ) {
content = this.element.children( "[data-" + this._getNs() +"url='" + dataUrl + "']" );
}
// Remove loading message.
if ( settings.showLoadMsg ) {
this._hideLoading();
}
// BEGIN DEPRECATED ---------------------------------------------------
// Let listeners know the content loaded successfully.
this.element.trigger( "pageload" );
// END DEPRECATED -----------------------------------------------------
deferred.resolve( absUrl, settings, content );
}, this);
},
_loadDefaults: {
type: "get",
data: undefined,
// DEPRECATED
reloadPage: false,
reload: false,
// By default we rely on the role defined by the @data-role attribute.
role: undefined,
showLoadMsg: false,
// This delay allows loads that pull from browser cache to
// occur without showing the loading message.
loadMsgDelay: 50
},
load: function( url, options ) {
// This function uses deferred notifications to let callers
// know when the content is done loading, or if an error has occurred.
var deferred = ( options && options.deferred ) || $.Deferred(),
// The default load options with overrides specified by the caller.
settings = $.extend( {}, this._loadDefaults, options ),
// The DOM element for the content after it has been loaded.
content = null,
// The absolute version of the URL passed into the function. This
// version of the URL may contain dialog/subcontent params in it.
absUrl = $.mobile.path.makeUrlAbsolute( url, this._findBaseWithDefault() ),
fileUrl, dataUrl, pblEvent, triggerData;
// DEPRECATED reloadPage
settings.reload = settings.reloadPage;
// If the caller provided data, and we're using "get" request,
// append the data to the URL.
if ( settings.data && settings.type === "get" ) {
absUrl = $.mobile.path.addSearchParams( absUrl, settings.data );
settings.data = undefined;
}
// If the caller is using a "post" request, reload must be true
if ( settings.data && settings.type === "post" ) {
settings.reload = true;
}
// The absolute version of the URL minus any dialog/subcontent params.
// In otherwords the real URL of the content to be loaded.
fileUrl = this._createFileUrl( absUrl );
// The version of the Url actually stored in the data-url attribute of
// the content. For embedded content, it is just the id of the page. For
// content within the same domain as the document base, it is the site
// relative path. For cross-domain content (Phone Gap only) the entire
// absolute Url is used to load the content.
dataUrl = this._createDataUrl( absUrl );
content = this._find( absUrl );
// If it isn't a reference to the first content and refers to missing
// embedded content reject the deferred and return
if ( content.length === 0 &&
$.mobile.path.isEmbeddedPage(fileUrl) &&
!$.mobile.path.isFirstPageUrl(fileUrl) ) {
deferred.reject( absUrl, settings );
return;
}
// Reset base to the default document base
// TODO figure out why we doe this
this._getBase().reset();
// If the content we are interested in is already in the DOM,
// and the caller did not indicate that we should force a
// reload of the file, we are done. Resolve the deferrred so that
// users can bind to .done on the promise
if ( content.length && !settings.reload ) {
this._enhance( content, settings.role );
deferred.resolve( absUrl, settings, content );
//if we are reloading the content make sure we update
// the base if its not a prefetch
if ( !settings.prefetch ) {
this._getBase().set(url);
}
return;
}
triggerData = {
url: url,
absUrl: absUrl,
dataUrl: dataUrl,
deferred: deferred,
options: settings
};
// Let listeners know we're about to load content.
pblEvent = this._triggerWithDeprecated( "beforeload", triggerData );
// If the default behavior is prevented, stop here!
if ( pblEvent.deprecatedEvent.isDefaultPrevented() ||
pblEvent.event.isDefaultPrevented() ) {
return;
}
if ( settings.showLoadMsg ) {
this._showLoading( settings.loadMsgDelay );
}
// Reset base to the default document base.
// only reset if we are not prefetching
if ( settings.prefetch === undefined ) {
this._getBase().reset();
}
if ( !( $.mobile.allowCrossDomainPages ||
$.mobile.path.isSameDomain($.mobile.path.documentUrl, absUrl ) ) ) {
deferred.reject( absUrl, settings );
return;
}
// Load the new content.
$.ajax({
url: fileUrl,
type: settings.type,
data: settings.data,
contentType: settings.contentType,
dataType: "html",
success: this._loadSuccess( absUrl, triggerData, settings, deferred ),
error: this._loadError( absUrl, triggerData, settings, deferred )
});
},
_loadError: function( absUrl, triggerData, settings, deferred ) {
return $.proxy(function( xhr, textStatus, errorThrown ) {
//set base back to current path
this._getBase().set( $.mobile.path.get() );
// Add error info to our triggerData.
triggerData.xhr = xhr;
triggerData.textStatus = textStatus;
triggerData.errorThrown = errorThrown;
// Let listeners know the page load failed.
var plfEvent = this._triggerWithDeprecated( "loadfailed", triggerData );
// If the default behavior is prevented, stop here!
// Note that it is the responsibility of the listener/handler
// that called preventDefault(), to resolve/reject the
// deferred object within the triggerData.
if ( plfEvent.deprecatedEvent.isDefaultPrevented() ||
plfEvent.event.isDefaultPrevented() ) {
return;
}
// Remove loading message.
if ( settings.showLoadMsg ) {
this._showError();
}
deferred.reject( absUrl, settings );
}, this);
},
_getTransitionHandler: function( transition ) {
transition = $.mobile._maybeDegradeTransition( transition );
//find the transition handler for the specified transition. If there
//isn't one in our transitionHandlers dictionary, use the default one.
//call the handler immediately to kick-off the transition.
return $.mobile.transitionHandlers[ transition ] || $.mobile.defaultTransitionHandler;
},
// TODO move into transition handlers?
_triggerCssTransitionEvents: function( to, from, prefix ) {
var samePage = false;
prefix = prefix || "";
// TODO decide if these events should in fact be triggered on the container
if ( from ) {
//Check if this is a same page transition and tell the handler in page
if( to[0] === from[0] ){
samePage = true;
}
//trigger before show/hide events
// TODO deprecate nextPage in favor of next
this._triggerWithDeprecated( prefix + "hide", { nextPage: to, samePage: samePage }, from );
}
// TODO deprecate prevPage in favor of previous
this._triggerWithDeprecated( prefix + "show", { prevPage: from || $( "" ) }, to );
},
// TODO make private once change has been defined in the widget
_cssTransition: function( to, from, options ) {
var transition = options.transition,
reverse = options.reverse,
deferred = options.deferred,
TransitionHandler,
promise;
this._triggerCssTransitionEvents( to, from, "before" );
// TODO put this in a binding to events *outside* the widget
this._hideLoading();
TransitionHandler = this._getTransitionHandler( transition );
promise = ( new TransitionHandler( transition, reverse, to, from ) ).transition();
// TODO temporary accomodation of argument deferred
promise.done(function() {
deferred.resolve.apply( deferred, arguments );
});
promise.done($.proxy(function() {
this._triggerCssTransitionEvents( to, from );
}, this));
},
_releaseTransitionLock: function() {
//release transition lock so navigation is free again
isPageTransitioning = false;
if ( pageTransitionQueue.length > 0 ) {
$.mobile.changePage.apply( null, pageTransitionQueue.pop() );
}
},
_removeActiveLinkClass: function( force ) {
//clear out the active button state
$.mobile.removeActiveLinkClass( force );
},
_loadUrl: function( to, triggerData, settings ) {
// preserve the original target as the dataUrl value will be
// simplified eg, removing ui-state, and removing query params
// from the hash this is so that users who want to use query
// params have access to them in the event bindings for the page
// life cycle See issue #5085
settings.target = to;
settings.deferred = $.Deferred();
this.load( to, settings );
settings.deferred.done($.proxy(function( url, options, content ) {
isPageTransitioning = false;
// store the original absolute url so that it can be provided
// to events in the triggerData of the subsequent changePage call
options.absUrl = triggerData.absUrl;
this.transition( content, triggerData, options );
}, this));
settings.deferred.fail($.proxy(function(/* url, options */) {
this._removeActiveLinkClass( true );
this._releaseTransitionLock();
this._triggerWithDeprecated( "changefailed", triggerData );
}, this));
},
_triggerPageBeforeChange: function( to, triggerData, settings ) {
var pbcEvent = new $.Event( "pagebeforechange" );
$.extend(triggerData, { toPage: to, options: settings });
// NOTE: preserve the original target as the dataUrl value will be
// simplified eg, removing ui-state, and removing query params from
// the hash this is so that users who want to use query params have
// access to them in the event bindings for the page life cycle
// See issue #5085
if ( $.type(to) === "string" ) {
// if the toPage is a string simply convert it
triggerData.absUrl = $.mobile.path.makeUrlAbsolute( to, this._findBaseWithDefault() );
} else {
// if the toPage is a jQuery object grab the absolute url stored
// in the loadPage callback where it exists
triggerData.absUrl = settings.absUrl;
}
// Let listeners know we're about to change the current page.
this.element.trigger( pbcEvent, triggerData );
// If the default behavior is prevented, stop here!
if ( pbcEvent.isDefaultPrevented() ) {
return false;
}
return true;
},
change: function( to, options ) {
// If we are in the midst of a transition, queue the current request.
// We'll call changePage() once we're done with the current transition
// to service the request.
if ( isPageTransitioning ) {
pageTransitionQueue.unshift( arguments );
return;
}
var settings = $.extend( {}, $.mobile.changePage.defaults, options ),
triggerData = {};
// Make sure we have a fromPage.
settings.fromPage = settings.fromPage || this.activePage;
// if the page beforechange default is prevented return early
if ( !this._triggerPageBeforeChange(to, triggerData, settings) ) {
return;
}
// We allow "pagebeforechange" observers to modify the to in
// the trigger data to allow for redirects. Make sure our to is
// updated. We also need to re-evaluate whether it is a string,
// because an object can also be replaced by a string
to = triggerData.toPage;
// If the caller passed us a url, call loadPage()
// to make sure it is loaded into the DOM. We'll listen
// to the promise object it returns so we know when
// it is done loading or if an error ocurred.
if ( $.type(to) === "string" ) {
// Set the isPageTransitioning flag to prevent any requests from
// entering this method while we are in the midst of loading a page
// or transitioning.
isPageTransitioning = true;
this._loadUrl( to, triggerData, settings );
} else {
this.transition( to, triggerData, settings );
}
},
transition: function( toPage, triggerData, settings ) {
var fromPage, url, pageUrl, fileUrl,
active, activeIsInitialPage,
historyDir, pageTitle, isDialog,
alreadyThere, newPageTitle,
params, cssTransitionDeferred,
beforeTransition;
// If we are in the midst of a transition, queue the current request.
// We'll call changePage() once we're done with the current transition
// to service the request.
if ( isPageTransitioning ) {
// make sure to only queue the to and settings values so the arguments
// work with a call to the change method
pageTransitionQueue.unshift( [toPage, settings] );
return;
}
// DEPRECATED - this call only, in favor of the before transition
// if the page beforechange default is prevented return early
if ( !this._triggerPageBeforeChange(toPage, triggerData, settings) ) {
return;
}
// if the (content|page)beforetransition default is prevented return early
// Note, we have to check for both the deprecated and new events
beforeTransition = this._triggerWithDeprecated( "beforetransition", triggerData );
if (beforeTransition.deprecatedEvent.isDefaultPrevented() ||
beforeTransition.event.isDefaultPrevented() ) {
return;
}
// Set the isPageTransitioning flag to prevent any requests from
// entering this method while we are in the midst of loading a page
// or transitioning.
isPageTransitioning = true;
// If we are going to the first-page of the application, we need to make
// sure settings.dataUrl is set to the application document url. This allows
// us to avoid generating a document url with an id hash in the case where the
// first-page of the document has an id attribute specified.
if ( toPage[ 0 ] === $.mobile.firstPage[ 0 ] && !settings.dataUrl ) {
settings.dataUrl = $.mobile.path.documentUrl.hrefNoHash;
}
// The caller passed us a real page DOM element. Update our
// internal state and then trigger a transition to the page.
fromPage = settings.fromPage;
url = ( settings.dataUrl && $.mobile.path.convertUrlToDataUrl(settings.dataUrl) ) ||
toPage.jqmData( "url" );
// The pageUrl var is usually the same as url, except when url is obscured
// as a dialog url. pageUrl always contains the file path
pageUrl = url;
fileUrl = $.mobile.path.getFilePath( url );
active = $.mobile.navigate.history.getActive();
activeIsInitialPage = $.mobile.navigate.history.activeIndex === 0;
historyDir = 0;
pageTitle = document.title;
isDialog = ( settings.role === "dialog" ||
toPage.jqmData( "role" ) === "dialog" ) &&
toPage.jqmData( "dialog" ) !== true;
// By default, we prevent changePage requests when the fromPage and toPage
// are the same element, but folks that generate content
// manually/dynamically and reuse pages want to be able to transition to
// the same page. To allow this, they will need to change the default
// value of allowSamePageTransition to true, *OR*, pass it in as an
// option when they manually call changePage(). It should be noted that
// our default transition animations assume that the formPage and toPage
// are different elements, so they may behave unexpectedly. It is up to
// the developer that turns on the allowSamePageTransitiona option to
// either turn off transition animations, or make sure that an appropriate
// animation transition is used.
if ( fromPage && fromPage[0] === toPage[0] &&
!settings.allowSamePageTransition ) {
isPageTransitioning = false;
this._triggerWithDeprecated( "transition", triggerData );
this.element.trigger( "pagechange", triggerData );
// Even if there is no page change to be done, we should keep the
// urlHistory in sync with the hash changes
if ( settings.fromHashChange ) {
$.mobile.navigate.history.direct({ url: url });
}
return;
}
// We need to make sure the page we are given has already been enhanced.
toPage.page({ role: settings.role });
// If the changePage request was sent from a hashChange event, check to
// see if the page is already within the urlHistory stack. If so, we'll
// assume the user hit the forward/back button and will try to match the
// transition accordingly.
if ( settings.fromHashChange ) {
historyDir = settings.direction === "back" ? -1 : 1;
}
// Kill the keyboard.
// XXX_jblas: We need to stop crawling the entire document to kill focus.
// Instead, we should be tracking focus with a delegate()
// handler so we already have the element in hand at this
// point.
// Wrap this in a try/catch block since IE9 throw "Unspecified error" if
// document.activeElement is undefined when we are in an IFrame.
try {
if ( document.activeElement &&
document.activeElement.nodeName.toLowerCase() !== "body" ) {
$( document.activeElement ).blur();
} else {
$( "input:focus, textarea:focus, select:focus" ).blur();
}
} catch( e ) {}
// Record whether we are at a place in history where a dialog used to be -
// if so, do not add a new history entry and do not change the hash either
alreadyThere = false;
// If we're displaying the page as a dialog, we don't want the url
// for the dialog content to be used in the hash. Instead, we want
// to append the dialogHashKey to the url of the current page.
if ( isDialog && active ) {
// on the initial page load active.url is undefined and in that case
// should be an empty string. Moving the undefined -> empty string back
// into urlHistory.addNew seemed imprudent given undefined better
// represents the url state
// If we are at a place in history that once belonged to a dialog, reuse
// this state without adding to urlHistory and without modifying the
// hash. However, if a dialog is already displayed at this point, and
// we're about to display another dialog, then we must add another hash
// and history entry on top so that one may navigate back to the
// original dialog
if ( active.url &&
active.url.indexOf( $.mobile.dialogHashKey ) > -1 &&
this.activePage &&
!this.activePage.hasClass( "ui-dialog" ) &&
$.mobile.navigate.history.activeIndex > 0 ) {
settings.changeHash = false;
alreadyThere = true;
}
// Normally, we tack on a dialog hash key, but if this is the location
// of a stale dialog, we reuse the URL from the entry
url = ( active.url || "" );
// account for absolute urls instead of just relative urls use as hashes
if ( !alreadyThere && url.indexOf("#") > -1 ) {
url += $.mobile.dialogHashKey;
} else {
url += "#" + $.mobile.dialogHashKey;
}
// tack on another dialogHashKey if this is the same as the initial hash
// this makes sure that a history entry is created for this dialog
if ( $.mobile.navigate.history.activeIndex === 0 && url === $.mobile.navigate.history.initialDst ) {
url += $.mobile.dialogHashKey;
}
}
// if title element wasn't found, try the page div data attr too
// If this is a deep-link or a reload ( active === undefined ) then just
// use pageTitle
newPageTitle = ( !active ) ? pageTitle : toPage.jqmData( "title" ) ||
toPage.children( ":jqmData(role='header')" ).find( ".ui-title" ).text();
if ( !!newPageTitle && pageTitle === document.title ) {
pageTitle = newPageTitle;
}
if ( !toPage.jqmData( "title" ) ) {
toPage.jqmData( "title", pageTitle );
}
// Make sure we have a transition defined.
settings.transition = settings.transition ||
( ( historyDir && !activeIsInitialPage ) ? active.transition : undefined ) ||
( isDialog ? $.mobile.defaultDialogTransition : $.mobile.defaultPageTransition );
//add page to history stack if it's not back or forward
if ( !historyDir && alreadyThere ) {
$.mobile.navigate.history.getActive().pageUrl = pageUrl;
}
// Set the location hash.
if ( url && !settings.fromHashChange ) {
// rebuilding the hash here since we loose it earlier on
// TODO preserve the originally passed in path
if ( !$.mobile.path.isPath( url ) && url.indexOf( "#" ) < 0 ) {
url = "#" + url;
}
// TODO the property names here are just silly
params = {
transition: settings.transition,
title: pageTitle,
pageUrl: pageUrl,
role: settings.role
};
if ( settings.changeHash !== false && $.mobile.hashListeningEnabled ) {
$.mobile.navigate( url, params, true);
} else if ( toPage[ 0 ] !== $.mobile.firstPage[ 0 ] ) {
$.mobile.navigate.history.add( url, params );
}
}
//set page title
document.title = pageTitle;
//set "toPage" as activePage deprecated in 1.4 remove in 1.5
$.mobile.activePage = toPage;
//new way to handle activePage
this.activePage = toPage;
// If we're navigating back in the URL history, set reverse accordingly.
settings.reverse = settings.reverse || historyDir < 0;
cssTransitionDeferred = $.Deferred();
this._cssTransition(toPage, fromPage, {
transition: settings.transition,
reverse: settings.reverse,
deferred: cssTransitionDeferred
});
cssTransitionDeferred.done($.proxy(function( name, reverse, $to, $from, alreadyFocused ) {
$.mobile.removeActiveLinkClass();
//if there's a duplicateCachedPage, remove it from the DOM now that it's hidden
if ( settings.duplicateCachedPage ) {
settings.duplicateCachedPage.remove();
}
// despite visibility: hidden addresses issue #2965
// https://github.com/jquery/jquery-mobile/issues/2965
if ( !alreadyFocused ) {
$.mobile.focusPage( toPage );
}
this._releaseTransitionLock();
this.element.trigger( "pagechange", triggerData );
this._triggerWithDeprecated( "transition", triggerData );
}, this));
},
// determine the current base url
_findBaseWithDefault: function() {
var closestBase = ( this.activePage &&
$.mobile.getClosestBaseUrl( this.activePage ) );
return closestBase || $.mobile.path.documentBase.hrefNoHash;
}
});
// The following handlers should be bound after mobileinit has been triggered
// the following deferred is resolved in the init file
$.mobile.navreadyDeferred = $.Deferred();
//these variables make all page containers use the same queue and only navigate one at a time
// queue to hold simultanious page transitions
var pageTransitionQueue = [],
// indicates whether or not page is in process of transitioning
isPageTransitioning = false;
})( jQuery );
(function( $, undefined ) {
// resolved on domready
var domreadyDeferred = $.Deferred(),
// resolved and nulled on window.load()
loadDeferred = $.Deferred(),
documentUrl = $.mobile.path.documentUrl,
// used to track last vclicked element to make sure its value is added to form data
$lastVClicked = null;
/* Event Bindings - hashchange, submit, and click */
function findClosestLink( ele ) {
while ( ele ) {
// Look for the closest element with a nodeName of "a".
// Note that we are checking if we have a valid nodeName
// before attempting to access it. This is because the
// node we get called with could have originated from within
// an embedded SVG document where some symbol instance elements
// don't have nodeName defined on them, or strings are of type
// SVGAnimatedString.
if ( ( typeof ele.nodeName === "string" ) && ele.nodeName.toLowerCase() === "a" ) {
break;
}
ele = ele.parentNode;
}
return ele;
}
$.mobile.loadPage = function( url, opts ) {
var container;
opts = opts || {};
container = ( opts.pageContainer || $.mobile.pageContainer );
// create the deferred that will be supplied to loadPage callers
// and resolved by the content widget's load method
opts.deferred = $.Deferred();
// Preferring to allow exceptions for uninitialized opts.pageContainer
// widgets so we know if we need to force init here for users
container.pagecontainer( "load", url, opts );
// provide the deferred
return opts.deferred.promise();
};
//define vars for interal use
/* internal utility functions */
// NOTE Issue #4950 Android phonegap doesn't navigate back properly
// when a full page refresh has taken place. It appears that hashchange
// and replacestate history alterations work fine but we need to support
// both forms of history traversal in our code that uses backward history
// movement
$.mobile.back = function() {
var nav = window.navigator;
// if the setting is on and the navigator object is
// available use the phonegap navigation capability
if ( this.phonegapNavigationEnabled &&
nav &&
nav.app &&
nav.app.backHistory ) {
nav.app.backHistory();
} else {
$.mobile.pageContainer.pagecontainer( "back" );
}
};
// Direct focus to the page title, or otherwise first focusable element
$.mobile.focusPage = function ( page ) {
var autofocus = page.find( "[autofocus]" ),
pageTitle = page.find( ".ui-title:eq(0)" );
if ( autofocus.length ) {
autofocus.focus();
return;
}
if ( pageTitle.length ) {
pageTitle.focus();
} else{
page.focus();
}
};
// No-op implementation of transition degradation
$.mobile._maybeDegradeTransition = $.mobile._maybeDegradeTransition || function( transition ) {
return transition;
};
// Exposed $.mobile methods
$.mobile.changePage = function( to, options ) {
$.mobile.pageContainer.pagecontainer( "change", to, options );
};
$.mobile.changePage.defaults = {
transition: undefined,
reverse: false,
changeHash: true,
fromHashChange: false,
role: undefined, // By default we rely on the role defined by the @data-role attribute.
duplicateCachedPage: undefined,
pageContainer: undefined,
showLoadMsg: true, //loading message shows by default when pages are being fetched during changePage
dataUrl: undefined,
fromPage: undefined,
allowSamePageTransition: false
};
$.mobile._registerInternalEvents = function() {
var getAjaxFormData = function( $form, calculateOnly ) {
var url, ret = true, formData, vclickedName, method;
if ( !$.mobile.ajaxEnabled ||
// test that the form is, itself, ajax false
$form.is( ":jqmData(ajax='false')" ) ||
// test that $.mobile.ignoreContentEnabled is set and
// the form or one of it's parents is ajax=false
!$form.jqmHijackable().length ||
$form.attr( "target" ) ) {
return false;
}
url = ( $lastVClicked && $lastVClicked.attr( "formaction" ) ) ||
$form.attr( "action" );
method = ( $form.attr( "method" ) || "get" ).toLowerCase();
// If no action is specified, browsers default to using the
// URL of the document containing the form. Since we dynamically
// pull in pages from external documents, the form should submit
// to the URL for the source document of the page containing
// the form.
if ( !url ) {
// Get the @data-url for the page containing the form.
url = $.mobile.getClosestBaseUrl( $form );
// NOTE: If the method is "get", we need to strip off the query string
// because it will get replaced with the new form data. See issue #5710.
if ( method === "get" ) {
url = $.mobile.path.parseUrl( url ).hrefNoSearch;
}
if ( url === $.mobile.path.documentBase.hrefNoHash ) {
// The url we got back matches the document base,
// which means the page must be an internal/embedded page,
// so default to using the actual document url as a browser
// would.
url = documentUrl.hrefNoSearch;
}
}
url = $.mobile.path.makeUrlAbsolute( url, $.mobile.getClosestBaseUrl( $form ) );
if ( ( $.mobile.path.isExternal( url ) && !$.mobile.path.isPermittedCrossDomainRequest( documentUrl, url ) ) ) {
return false;
}
if ( !calculateOnly ) {
formData = $form.serializeArray();
if ( $lastVClicked && $lastVClicked[ 0 ].form === $form[ 0 ] ) {
vclickedName = $lastVClicked.attr( "name" );
if ( vclickedName ) {
// Make sure the last clicked element is included in the form
$.each( formData, function( key, value ) {
if ( value.name === vclickedName ) {
// Unset vclickedName - we've found it in the serialized data already
vclickedName = "";
return false;
}
});
if ( vclickedName ) {
formData.push( { name: vclickedName, value: $lastVClicked.attr( "value" ) } );
}
}
}
ret = {
url: url,
options: {
type: method,
data: $.param( formData ),
transition: $form.jqmData( "transition" ),
reverse: $form.jqmData( "direction" ) === "reverse",
reloadPage: true
}
};
}
return ret;
};
//bind to form submit events, handle with Ajax
$.mobile.document.delegate( "form", "submit", function( event ) {
var formData;
if ( !event.isDefaultPrevented() ) {
formData = getAjaxFormData( $( this ) );
if ( formData ) {
$.mobile.changePage( formData.url, formData.options );
event.preventDefault();
}
}
});
//add active state on vclick
$.mobile.document.bind( "vclick", function( event ) {
var $btn, btnEls, target = event.target, needClosest = false;
// if this isn't a left click we don't care. Its important to note
// that when the virtual event is generated it will create the which attr
if ( event.which > 1 || !$.mobile.linkBindingEnabled ) {
return;
}
// Record that this element was clicked, in case we need it for correct
// form submission during the "submit" handler above
$lastVClicked = $( target );
// Try to find a target element to which the active class will be applied
if ( $.data( target, "mobile-button" ) ) {
// If the form will not be submitted via AJAX, do not add active class
if ( !getAjaxFormData( $( target ).closest( "form" ), true ) ) {
return;
}
// We will apply the active state to this button widget - the parent
// of the input that was clicked will have the associated data
if ( target.parentNode ) {
target = target.parentNode;
}
} else {
target = findClosestLink( target );
if ( !( target && $.mobile.path.parseUrl( target.getAttribute( "href" ) || "#" ).hash !== "#" ) ) {
return;
}
// TODO teach $.mobile.hijackable to operate on raw dom elements so the
// link wrapping can be avoided
if ( !$( target ).jqmHijackable().length ) {
return;
}
}
// Avoid calling .closest by using the data set during .buttonMarkup()
// List items have the button data in the parent of the element clicked
if ( !!~target.className.indexOf( "ui-link-inherit" ) ) {
if ( target.parentNode ) {
btnEls = $.data( target.parentNode, "buttonElements" );
}
// Otherwise, look for the data on the target itself
} else {
btnEls = $.data( target, "buttonElements" );
}
// If found, grab the button's outer element
if ( btnEls ) {
target = btnEls.outer;
} else {
needClosest = true;
}
$btn = $( target );
// If the outer element wasn't found by the our heuristics, use .closest()
if ( needClosest ) {
$btn = $btn.closest( ".ui-btn" );
}
if ( $btn.length > 0 &&
!( $btn.hasClass( "ui-state-disabled" ||
// DEPRECATED as of 1.4.0 - remove after 1.4.0 release
// only ui-state-disabled should be present thereafter
$btn.hasClass( "ui-disabled" ) ) ) ) {
$.mobile.removeActiveLinkClass( true );
$.mobile.activeClickedLink = $btn;
$.mobile.activeClickedLink.addClass( $.mobile.activeBtnClass );
}
});
// click routing - direct to HTTP or Ajax, accordingly
$.mobile.document.bind( "click", function( event ) {
if ( !$.mobile.linkBindingEnabled || event.isDefaultPrevented() ) {
return;
}
var link = findClosestLink( event.target ),
$link = $( link ),
//remove active link class if external (then it won't be there if you come back)
httpCleanup = function() {
window.setTimeout(function() { $.mobile.removeActiveLinkClass( true ); }, 200 );
},
baseUrl, href,
useDefaultUrlHandling, isExternal,
transition, reverse, role;
// If a button was clicked, clean up the active class added by vclick above
if ( $.mobile.activeClickedLink &&
$.mobile.activeClickedLink[ 0 ] === event.target.parentNode ) {
httpCleanup();
}
// If there is no link associated with the click or its not a left
// click we want to ignore the click
// TODO teach $.mobile.hijackable to operate on raw dom elements so the link wrapping
// can be avoided
if ( !link || event.which > 1 || !$link.jqmHijackable().length ) {
return;
}
//if there's a data-rel=back attr, go back in history
if ( $link.is( ":jqmData(rel='back')" ) ) {
$.mobile.back();
return false;
}
baseUrl = $.mobile.getClosestBaseUrl( $link );
//get href, if defined, otherwise default to empty hash
href = $.mobile.path.makeUrlAbsolute( $link.attr( "href" ) || "#", baseUrl );
//if ajax is disabled, exit early
if ( !$.mobile.ajaxEnabled && !$.mobile.path.isEmbeddedPage( href ) ) {
httpCleanup();
//use default click handling
return;
}
// XXX_jblas: Ideally links to application pages should be specified as
// an url to the application document with a hash that is either
// the site relative path or id to the page. But some of the
// internal code that dynamically generates sub-pages for nested
// lists and select dialogs, just write a hash in the link they
// create. This means the actual URL path is based on whatever
// the current value of the base tag is at the time this code
// is called. For now we are just assuming that any url with a
// hash in it is an application page reference.
if ( href.search( "#" ) !== -1 ) {
href = href.replace( /[^#]*#/, "" );
if ( !href ) {
//link was an empty hash meant purely
//for interaction, so we ignore it.
event.preventDefault();
return;
} else if ( $.mobile.path.isPath( href ) ) {
//we have apath so make it the href we want to load.
href = $.mobile.path.makeUrlAbsolute( href, baseUrl );
} else {
//we have a simple id so use the documentUrl as its base.
href = $.mobile.path.makeUrlAbsolute( "#" + href, documentUrl.hrefNoHash );
}
}
// Should we handle this link, or let the browser deal with it?
useDefaultUrlHandling = $link.is( "[rel='external']" ) || $link.is( ":jqmData(ajax='false')" ) || $link.is( "[target]" );
// Some embedded browsers, like the web view in Phone Gap, allow cross-domain XHR
// requests if the document doing the request was loaded via the file:// protocol.
// This is usually to allow the application to "phone home" and fetch app specific
// data. We normally let the browser handle external/cross-domain urls, but if the
// allowCrossDomainPages option is true, we will allow cross-domain http/https
// requests to go through our page loading logic.
//check for protocol or rel and its not an embedded page
//TODO overlap in logic from isExternal, rel=external check should be
// moved into more comprehensive isExternalLink
isExternal = useDefaultUrlHandling || ( $.mobile.path.isExternal( href ) && !$.mobile.path.isPermittedCrossDomainRequest( documentUrl, href ) );
if ( isExternal ) {
httpCleanup();
//use default click handling
return;
}
//use ajax
transition = $link.jqmData( "transition" );
reverse = $link.jqmData( "direction" ) === "reverse" ||
// deprecated - remove by 1.0
$link.jqmData( "back" );
//this may need to be more specific as we use data-rel more
role = $link.attr( "data-" + $.mobile.ns + "rel" ) || undefined;
$.mobile.changePage( href, { transition: transition, reverse: reverse, role: role, link: $link } );
event.preventDefault();
});
//prefetch pages when anchors with data-prefetch are encountered
$.mobile.document.delegate( ".ui-page", "pageshow.prefetch", function() {
var urls = [];
$( this ).find( "a:jqmData(prefetch)" ).each(function() {
var $link = $( this ),
url = $link.attr( "href" );
if ( url && $.inArray( url, urls ) === -1 ) {
urls.push( url );
$.mobile.loadPage( url, { role: $link.attr( "data-" + $.mobile.ns + "rel" ),prefetch: true } );
}
});
});
// TODO ensure that the navigate binding in the content widget happens at the right time
$.mobile.pageContainer.pagecontainer();
//set page min-heights to be device specific
$.mobile.document.bind( "pageshow", function() {
// We need to wait for window.load to make sure that styles have already been rendered,
// otherwise heights of external toolbars will have the wrong value
if ( loadDeferred ) {
loadDeferred.done( $.mobile.resetActivePageHeight );
} else {
$.mobile.resetActivePageHeight();
}
});
$.mobile.window.bind( "throttledresize", $.mobile.resetActivePageHeight );
};//navreadyDeferred done callback
$( function() { domreadyDeferred.resolve(); } );
$.mobile.window.load( function() {
// Resolve and null the deferred
loadDeferred.resolve();
loadDeferred = null;
});
$.when( domreadyDeferred, $.mobile.navreadyDeferred ).done( function() { $.mobile._registerInternalEvents(); } );
})( jQuery );
(function( $ ) {
var meta = $( "meta[name=viewport]" ),
initialContent = meta.attr( "content" ),
disabledZoom = initialContent + ",maximum-scale=1, user-scalable=no",
enabledZoom = initialContent + ",maximum-scale=10, user-scalable=yes",
disabledInitially = /(user-scalable[\s]*=[\s]*no)|(maximum-scale[\s]*=[\s]*1)[$,\s]/.test( initialContent );
$.mobile.zoom = $.extend( {}, {
enabled: !disabledInitially,
locked: false,
disable: function( lock ) {
if ( !disabledInitially && !$.mobile.zoom.locked ) {
meta.attr( "content", disabledZoom );
$.mobile.zoom.enabled = false;
$.mobile.zoom.locked = lock || false;
}
},
enable: function( unlock ) {
if ( !disabledInitially && ( !$.mobile.zoom.locked || unlock === true ) ) {
meta.attr( "content", enabledZoom );
$.mobile.zoom.enabled = true;
$.mobile.zoom.locked = false;
}
},
restore: function() {
if ( !disabledInitially ) {
meta.attr( "content", initialContent );
$.mobile.zoom.enabled = true;
}
}
});
}( jQuery ));
(function( $, undefined ) {
$.widget( "mobile.toolbar", {
initSelector: ":jqmData(role='footer'), :jqmData(role='header')",
options: {
theme: null,
addBackBtn: false,
backBtnTheme: null,
backBtnText: "Back"
},
_create: function() {
var leftbtn, rightbtn,
role = this.element.is( ":jqmData(role='header')" ) ? "header" : "footer",
page = this.element.closest( ".ui-page" );
if ( page.length === 0 ) {
page = false;
this._on( this.document, {
"pageshow": "refresh"
});
}
$.extend( this, {
role: role,
page: page,
leftbtn: leftbtn,
rightbtn: rightbtn
});
this.element.attr( "role", role === "header" ? "banner" : "contentinfo" ).addClass( "ui-" + role );
this.refresh();
this._setOptions( this.options );
},
_setOptions: function( o ) {
if ( o.addBackBtn !== undefined ) {
if ( this.options.addBackBtn &&
this.role === "header" &&
$( ".ui-page" ).length > 1 &&
this.page[ 0 ].getAttribute( "data-" + $.mobile.ns + "url" ) !== $.mobile.path.stripHash( location.hash ) &&
!this.leftbtn ) {
this._addBackButton();
} else {
this.element.find( ".ui-toolbar-back-btn" ).remove();
}
}
if ( o.backBtnTheme != null ) {
this.element
.find( ".ui-toolbar-back-btn" )
.addClass( "ui-btn ui-btn-" + o.backBtnTheme );
}
if ( o.backBtnText !== undefined ) {
this.element.find( ".ui-toolbar-back-btn .ui-btn-text" ).text( o.backBtnText );
}
if ( o.theme !== undefined ) {
var currentTheme = this.options.theme ? this.options.theme : "inherit",
newTheme = o.theme ? o.theme : "inherit";
this.element.removeClass( "ui-bar-" + currentTheme ).addClass( "ui-bar-" + newTheme );
}
this._super( o );
},
refresh: function() {
if ( this.role === "header" ) {
this._addHeaderButtonClasses();
}
if ( !this.page ) {
this._setRelative();
if ( this.role === "footer" ) {
this.element.appendTo( "body" );
}
}
this._addHeadingClasses();
this._btnMarkup();
},
//we only want this to run on non fixed toolbars so make it easy to override
_setRelative: function() {
$( "[data-"+ $.mobile.ns + "role='page']" ).css({ "position": "relative" });
},
// Deprecated in 1.4. As from 1.5 button classes have to be present in the markup.
_btnMarkup: function() {
this.element
.children( "a" )
.filter( ":not([data-" + $.mobile.ns + "role='none'])" )
.attr( "data-" + $.mobile.ns + "role", "button" );
this.element.trigger( "create" );
},
// Deprecated in 1.4. As from 1.5 ui-btn-left/right classes have to be present in the markup.
_addHeaderButtonClasses: function() {
var $headeranchors = this.element.children( "a, button" );
this.leftbtn = $headeranchors.hasClass( "ui-btn-left" );
this.rightbtn = $headeranchors.hasClass( "ui-btn-right" );
this.leftbtn = this.leftbtn || $headeranchors.eq( 0 ).not( ".ui-btn-right" ).addClass( "ui-btn-left" ).length;
this.rightbtn = this.rightbtn || $headeranchors.eq( 1 ).addClass( "ui-btn-right" ).length;
},
_addBackButton: function() {
var options = this.options,
theme = options.backBtnTheme || options.theme;
$( "<a role='button' href='javascript:void(0);' " +
"class='ui-btn ui-corner-all ui-shadow ui-btn-left " +
( theme ? "ui-btn-" + theme + " " : "" ) +
"ui-toolbar-back-btn ui-icon-carat-l ui-btn-icon-left' " +
"data-" + $.mobile.ns + "rel='back'>" + options.backBtnText + "</a>" )
.prependTo( this.element );
},
_addHeadingClasses: function() {
this.element.children( "h1, h2, h3, h4, h5, h6" )
.addClass( "ui-title" )
// Regardless of h element number in src, it becomes h1 for the enhanced page
.attr({
"role": "heading",
"aria-level": "1"
});
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.toolbar", $.mobile.toolbar, {
options: {
position:null,
visibleOnPageShow: true,
disablePageZoom: true,
transition: "slide", //can be none, fade, slide (slide maps to slideup or slidedown)
fullscreen: false,
tapToggle: true,
tapToggleBlacklist: "a, button, input, select, textarea, .ui-header-fixed, .ui-footer-fixed, .ui-flipswitch, .ui-popup, .ui-panel, .ui-panel-dismiss-open",
hideDuringFocus: "input, textarea, select",
updatePagePadding: true,
trackPersistentToolbars: true,
// Browser detection! Weeee, here we go...
// Unfortunately, position:fixed is costly, not to mention probably impossible, to feature-detect accurately.
// Some tests exist, but they currently return false results in critical devices and browsers, which could lead to a broken experience.
// Testing fixed positioning is also pretty obtrusive to page load, requiring injected elements and scrolling the window
// The following function serves to rule out some popular browsers with known fixed-positioning issues
// This is a plugin option like any other, so feel free to improve or overwrite it
supportBlacklist: function() {
return !$.support.fixedPosition;
}
},
_create: function() {
this._super();
if ( this.options.position === "fixed" && !this.options.supportBlacklist() ) {
this._makeFixed();
}
},
_makeFixed: function() {
this.element.addClass( "ui-"+ this.role +"-fixed" );
this.updatePagePadding();
this._addTransitionClass();
this._bindPageEvents();
this._bindToggleHandlers();
},
_setOptions: function( o ) {
if ( o.position === "fixed" && this.options.position !== "fixed" ) {
this._makeFixed();
}
if ( this.options.position === "fixed" && !this.options.supportBlacklist() ) {
var $page = ( !!this.page )? this.page: ( $(".ui-page-active").length > 0 )? $(".ui-page-active"): $(".ui-page").eq(0);
if ( o.fullscreen !== undefined) {
if ( o.fullscreen ) {
this.element.addClass( "ui-"+ this.role +"-fullscreen" );
$page.addClass( "ui-page-" + this.role + "-fullscreen" );
}
// If not fullscreen, add class to page to set top or bottom padding
else {
this.element.removeClass( "ui-"+ this.role +"-fullscreen" );
$page.removeClass( "ui-page-" + this.role + "-fullscreen" ).addClass( "ui-page-" + this.role+ "-fixed" );
}
}
}
this._super(o);
},
_addTransitionClass: function() {
var tclass = this.options.transition;
if ( tclass && tclass !== "none" ) {
// use appropriate slide for header or footer
if ( tclass === "slide" ) {
tclass = this.element.hasClass( "ui-header" ) ? "slidedown" : "slideup";
}
this.element.addClass( tclass );
}
},
_bindPageEvents: function() {
var page = ( !!this.page )? this.element.closest( ".ui-page" ): this.document;
//page event bindings
// Fixed toolbars require page zoom to be disabled, otherwise usability issues crop up
// This method is meant to disable zoom while a fixed-positioned toolbar page is visible
this._on( page , {
"pagebeforeshow": "_handlePageBeforeShow",
"webkitAnimationStart":"_handleAnimationStart",
"animationstart":"_handleAnimationStart",
"updatelayout": "_handleAnimationStart",
"pageshow": "_handlePageShow",
"pagebeforehide": "_handlePageBeforeHide"
});
},
_handlePageBeforeShow: function( ) {
var o = this.options;
if ( o.disablePageZoom ) {
$.mobile.zoom.disable( true );
}
if ( !o.visibleOnPageShow ) {
this.hide( true );
}
},
_handleAnimationStart: function() {
if ( this.options.updatePagePadding ) {
this.updatePagePadding( ( !!this.page )? this.page: ".ui-page-active" );
}
},
_handlePageShow: function() {
this.updatePagePadding( ( !!this.page )? this.page: ".ui-page-active" );
if ( this.options.updatePagePadding ) {
this._on( this.window, { "throttledresize": "updatePagePadding" } );
}
},
_handlePageBeforeHide: function( e, ui ) {
var o = this.options,
thisFooter, thisHeader, nextFooter, nextHeader;
if ( o.disablePageZoom ) {
$.mobile.zoom.enable( true );
}
if ( o.updatePagePadding ) {
this._off( this.window, "throttledresize" );
}
if ( o.trackPersistentToolbars ) {
thisFooter = $( ".ui-footer-fixed:jqmData(id)", this.page );
thisHeader = $( ".ui-header-fixed:jqmData(id)", this.page );
nextFooter = thisFooter.length && ui.nextPage && $( ".ui-footer-fixed:jqmData(id='" + thisFooter.jqmData( "id" ) + "')", ui.nextPage ) || $();
nextHeader = thisHeader.length && ui.nextPage && $( ".ui-header-fixed:jqmData(id='" + thisHeader.jqmData( "id" ) + "')", ui.nextPage ) || $();
if ( nextFooter.length || nextHeader.length ) {
nextFooter.add( nextHeader ).appendTo( $.mobile.pageContainer );
ui.nextPage.one( "pageshow", function() {
nextHeader.prependTo( this );
nextFooter.appendTo( this );
});
}
}
},
_visible: true,
// This will set the content element's top or bottom padding equal to the toolbar's height
updatePagePadding: function( tbPage ) {
var $el = this.element,
header = ( this.role ==="header" ),
pos = parseFloat( $el.css( header ? "top" : "bottom" ) );
// This behavior only applies to "fixed", not "fullscreen"
if ( this.options.fullscreen ) { return; }
// tbPage argument can be a Page object or an event, if coming from throttled resize.
tbPage = ( tbPage && tbPage.type === undefined && tbPage ) || this.page || $el.closest( ".ui-page" );
tbPage = ( !!this.page )? this.page: ".ui-page-active";
$( tbPage ).css( "padding-" + ( header ? "top" : "bottom" ), $el.outerHeight() + pos );
},
_useTransition: function( notransition ) {
var $win = this.window,
$el = this.element,
scroll = $win.scrollTop(),
elHeight = $el.height(),
pHeight = ( !!this.page )? $el.closest( ".ui-page" ).height():$(".ui-page-active").height(),
viewportHeight = $.mobile.getScreenHeight();
return !notransition &&
( this.options.transition && this.options.transition !== "none" &&
(
( this.role === "header" && !this.options.fullscreen && scroll > elHeight ) ||
( this.role === "footer" && !this.options.fullscreen && scroll + viewportHeight < pHeight - elHeight )
) || this.options.fullscreen
);
},
show: function( notransition ) {
var hideClass = "ui-fixed-hidden",
$el = this.element;
if ( this._useTransition( notransition ) ) {
$el
.removeClass( "out " + hideClass )
.addClass( "in" )
.animationComplete(function () {
$el.removeClass( "in" );
});
}
else {
$el.removeClass( hideClass );
}
this._visible = true;
},
hide: function( notransition ) {
var hideClass = "ui-fixed-hidden",
$el = this.element,
// if it's a slide transition, our new transitions need the reverse class as well to slide outward
outclass = "out" + ( this.options.transition === "slide" ? " reverse" : "" );
if ( this._useTransition( notransition ) ) {
$el
.addClass( outclass )
.removeClass( "in" )
.animationComplete(function() {
$el.addClass( hideClass ).removeClass( outclass );
});
}
else {
$el.addClass( hideClass ).removeClass( outclass );
}
this._visible = false;
},
toggle: function() {
this[ this._visible ? "hide" : "show" ]();
},
_bindToggleHandlers: function() {
var self = this,
o = self.options,
delayShow, delayHide,
isVisible = true,
page = ( !!this.page )? this.page: $(".ui-page");
// tap toggle
page
.bind( "vclick", function( e ) {
if ( o.tapToggle && !$( e.target ).closest( o.tapToggleBlacklist ).length ) {
self.toggle();
}
})
.bind( "focusin focusout", function( e ) {
//this hides the toolbars on a keyboard pop to give more screen room and prevent ios bug which
//positions fixed toolbars in the middle of the screen on pop if the input is near the top or
//bottom of the screen addresses issues #4410 Footer navbar moves up when clicking on a textbox in an Android environment
//and issue #4113 Header and footer change their position after keyboard popup - iOS
//and issue #4410 Footer navbar moves up when clicking on a textbox in an Android environment
if ( screen.width < 1025 && $( e.target ).is( o.hideDuringFocus ) && !$( e.target ).closest( ".ui-header-fixed, .ui-footer-fixed" ).length ) {
//Fix for issue #4724 Moving through form in Mobile Safari with "Next" and "Previous" system
//controls causes fixed position, tap-toggle false Header to reveal itself
// isVisible instead of self._visible because the focusin and focusout events fire twice at the same time
// Also use a delay for hiding the toolbars because on Android native browser focusin is direclty followed
// by a focusout when a native selects opens and the other way around when it closes.
if ( e.type === "focusout" && !isVisible ) {
isVisible = true;
//wait for the stack to unwind and see if we have jumped to another input
clearTimeout( delayHide );
delayShow = setTimeout( function() {
self.show();
}, 0 );
} else if ( e.type === "focusin" && !!isVisible ) {
//if we have jumped to another input clear the time out to cancel the show.
clearTimeout( delayShow );
isVisible = false;
delayHide = setTimeout( function() {
self.hide();
}, 0 );
}
}
});
},
_setRelative: function() {
if( this.options.position !== "fixed" ){
$( "[data-"+ $.mobile.ns + "role='page']" ).css({ "position": "relative" });
}
},
_destroy: function() {
var $el = this.element,
header = $el.hasClass( "ui-header" );
$el.closest( ".ui-page" ).css( "padding-" + ( header ? "top" : "bottom" ), "" );
$el.removeClass( "ui-header-fixed ui-footer-fixed ui-header-fullscreen ui-footer-fullscreen in out fade slidedown slideup ui-fixed-hidden" );
$el.closest( ".ui-page" ).removeClass( "ui-page-header-fixed ui-page-footer-fixed ui-page-header-fullscreen ui-page-footer-fullscreen" );
}
});
})( jQuery );
(function( $, undefined ) {
$.widget( "mobile.toolbar", $.mobile.toolbar, {
_makeFixed: function() {
this._super();
this._workarounds();
},
//check the browser and version and run needed workarounds
_workarounds: function() {
var ua = navigator.userAgent,
platform = navigator.platform,
// Rendering engine is Webkit, and capture major version
wkmatch = ua.match( /AppleWebKit\/([0-9]+)/ ),
wkversion = !!wkmatch && wkmatch[ 1 ],
os = null,
self = this;
//set the os we are working in if it dosent match one with workarounds return
if ( platform.indexOf( "iPhone" ) > -1 || platform.indexOf( "iPad" ) > -1 || platform.indexOf( "iPod" ) > -1 ) {
os = "ios";
} else if ( ua.indexOf( "Android" ) > -1 ) {
os = "android";
} else {
return;
}
//check os version if it dosent match one with workarounds return
if ( os === "ios" ) {
//iOS workarounds
self._bindScrollWorkaround();
} else if ( os === "android" && wkversion && wkversion < 534 ) {
//Android 2.3 run all Android 2.3 workaround
self._bindScrollWorkaround();
self._bindListThumbWorkaround();
} else {
return;
}
},
//Utility class for checking header and footer positions relative to viewport
_viewportOffset: function() {
var $el = this.element,
header = $el.hasClass( "ui-header" ),
offset = Math.abs( $el.offset().top - this.window.scrollTop() );
if ( !header ) {
offset = Math.round( offset - this.window.height() + $el.outerHeight() ) - 60;
}
return offset;
},
//bind events for _triggerRedraw() function
_bindScrollWorkaround: function() {
var self = this;
//bind to scrollstop and check if the toolbars are correctly positioned
this._on( this.window, { scrollstop: function() {
var viewportOffset = self._viewportOffset();
//check if the header is visible and if its in the right place
if ( viewportOffset > 2 && self._visible ) {
self._triggerRedraw();
}
}});
},
//this addresses issue #4250 Persistent footer instability in v1.1 with long select lists in Android 2.3.3
//and issue #3748 Android 2.x: Page transitions broken when fixed toolbars used
//the absolutely positioned thumbnail in a list view causes problems with fixed position buttons above in a nav bar
//setting the li's to -webkit-transform:translate3d(0,0,0); solves this problem to avoide potential issues in other
//platforms we scope this with the class ui-android-2x-fix
_bindListThumbWorkaround: function() {
this.element.closest( ".ui-page" ).addClass( "ui-android-2x-fixed" );
},
//this addresses issues #4337 Fixed header problem after scrolling content on iOS and Android
//and device bugs project issue #1 Form elements can lose click hit area in position: fixed containers.
//this also addresses not on fixed toolbars page in docs
//adding 1px of padding to the bottom then removing it causes a "redraw"
//which positions the toolbars correctly (they will always be visually correct)
_triggerRedraw: function() {
var paddingBottom = parseFloat( $( ".ui-page-active" ).css( "padding-bottom" ) );
//trigger page redraw to fix incorrectly positioned fixed elements
$( ".ui-page-active" ).css( "padding-bottom", ( paddingBottom + 1 ) + "px" );
//if the padding is reset with out a timeout the reposition will not occure.
//this is independant of JQM the browser seems to need the time to react.
setTimeout( function() {
$( ".ui-page-active" ).css( "padding-bottom", paddingBottom + "px" );
}, 0 );
},
destroy: function() {
this._super();
//Remove the class we added to the page previously in android 2.x
this.element.closest( ".ui-page-active" ).removeClass( "ui-android-2x-fix" );
}
});
})( jQuery );
/*!
* jQuery UI Tabs fadf2b312a05040436451c64bbfaf4814bc62c56
* http://jqueryui.com
*
* Copyright 2013 jQuery Foundation and other contributors
* Released under the MIT license.
* http://jquery.org/license
*
* http://api.jqueryui.com/tabs/
*
* Depends:
* jquery.ui.core.js
* jquery.ui.widget.js
*/
(function( $, undefined ) {
var tabId = 0,
rhash = /#.*$/;
function getNextTabId() {
return ++tabId;
}
function isLocal( anchor ) {
return anchor.hash.length > 1 &&
decodeURIComponent( anchor.href.replace( rhash, "" ) ) ===
decodeURIComponent( location.href.replace( rhash, "" ) );
}
$.widget( "ui.tabs", {
version: "fadf2b312a05040436451c64bbfaf4814bc62c56",
delay: 300,
options: {
active: null,
collapsible: false,
event: "click",
heightStyle: "content",
hide: null,
show: null,
// callbacks
activate: null,
beforeActivate: null,
beforeLoad: null,
load: null
},
_create: function() {
var that = this,
options = this.options;
this.running = false;
this.element
.addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
.toggleClass( "ui-tabs-collapsible", options.collapsible )
// Prevent users from focusing disabled tabs via click
.delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
if ( $( this ).is( ".ui-state-disabled" ) ) {
event.preventDefault();
}
})
// support: IE <9
// Preventing the default action in mousedown doesn't prevent IE
// from focusing the element, so if the anchor gets focused, blur.
// We don't have to worry about focusing the previously focused
// element since clicking on a non-focusable element should focus
// the body anyway.
.delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
this.blur();
}
});
this._processTabs();
options.active = this._initialActive();
// Take disabling tabs via class attribute from HTML
// into account and update option properly.
if ( $.isArray( options.disabled ) ) {
options.disabled = $.unique( options.disabled.concat(
$.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
return that.tabs.index( li );
})
) ).sort();
}
// check for length avoids error when initializing empty list
if ( this.options.active !== false && this.anchors.length ) {
this.active = this._findActive( options.active );
} else {
this.active = $();
}
this._refresh();
if ( this.active.length ) {
this.load( options.active );
}
},
_initialActive: function() {
var active = this.options.active,
collapsible = this.options.collapsible,
locationHash = location.hash.substring( 1 );
if ( active === null ) {
// check the fragment identifier in the URL
if ( locationHash ) {
this.tabs.each(function( i, tab ) {
if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
active = i;
return false;
}
});
}
// check for a tab marked active via a class
if ( active === null ) {
active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
}
// no active tab, set to false
if ( active === null || active === -1 ) {
active = this.tabs.length ? 0 : false;
}
}
// handle numbers: negative, out of range
if ( active !== false ) {
active = this.tabs.index( this.tabs.eq( active ) );
if ( active === -1 ) {
active = collapsible ? false : 0;
}
}
// don't allow collapsible: false and active: false
if ( !collapsible && active === false && this.anchors.length ) {
active = 0;
}
return active;
},
_getCreateEventData: function() {
return {
tab: this.active,
panel: !this.active.length ? $() : this._getPanelForTab( this.active )
};
},
_tabKeydown: function( event ) {
var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
selectedIndex = this.tabs.index( focusedTab ),
goingForward = true;
if ( this._handlePageNav( event ) ) {
return;
}
switch ( event.keyCode ) {
case $.ui.keyCode.RIGHT:
case $.ui.keyCode.DOWN:
selectedIndex++;
break;
case $.ui.keyCode.UP:
case $.ui.keyCode.LEFT:
goingForward = false;
selectedIndex--;
break;
case $.ui.keyCode.END:
selectedIndex = this.anchors.length - 1;
break;
case $.ui.keyCode.HOME:
selectedIndex = 0;
break;
case $.ui.keyCode.SPACE:
// Activate only, no collapsing
event.preventDefault();
clearTimeout( this.activating );
this._activate( selectedIndex );
return;
case $.ui.keyCode.ENTER:
// Toggle (cancel delayed activation, allow collapsing)
event.preventDefault();
clearTimeout( this.activating );
// Determine if we should collapse or activate
this._activate( selectedIndex === this.options.active ? false : selectedIndex );
return;
default:
return;
}
// Focus the appropriate tab, based on which key was pressed
event.preventDefault();
clearTimeout( this.activating );
selectedIndex = this._focusNextTab( selectedIndex, goingForward );
// Navigating with control key will prevent automatic activation
if ( !event.ctrlKey ) {
// Update aria-selected immediately so that AT think the tab is already selected.
// Otherwise AT may confuse the user by stating that they need to activate the tab,
// but the tab will already be activated by the time the announcement finishes.
focusedTab.attr( "aria-selected", "false" );
this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
this.activating = this._delay(function() {
this.option( "active", selectedIndex );
}, this.delay );
}
},
_panelKeydown: function( event ) {
if ( this._handlePageNav( event ) ) {
return;
}
// Ctrl+up moves focus to the current tab
if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
event.preventDefault();
this.active.focus();
}
},
// Alt+page up/down moves focus to the previous/next tab (and activates)
_handlePageNav: function( event ) {
if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
this._activate( this._focusNextTab( this.options.active - 1, false ) );
return true;
}
if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
this._activate( this._focusNextTab( this.options.active + 1, true ) );
return true;
}
},
_findNextTab: function( index, goingForward ) {
var lastTabIndex = this.tabs.length - 1;
function constrain() {
if ( index > lastTabIndex ) {
index = 0;
}
if ( index < 0 ) {
index = lastTabIndex;
}
return index;
}
while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
index = goingForward ? index + 1 : index - 1;
}
return index;
},
_focusNextTab: function( index, goingForward ) {
index = this._findNextTab( index, goingForward );
this.tabs.eq( index ).focus();
return index;
},
_setOption: function( key, value ) {
if ( key === "active" ) {
// _activate() will handle invalid values and update this.options
this._activate( value );
return;
}
if ( key === "disabled" ) {
// don't use the widget factory's disabled handling
this._setupDisabled( value );
return;
}
this._super( key, value);
if ( key === "collapsible" ) {
this.element.toggleClass( "ui-tabs-collapsible", value );
// Setting collapsible: false while collapsed; open first panel
if ( !value && this.options.active === false ) {
this._activate( 0 );
}
}
if ( key === "event" ) {
this._setupEvents( value );
}
if ( key === "heightStyle" ) {
this._setupHeightStyle( value );
}
},
_tabId: function( tab ) {
return tab.attr( "aria-controls" ) || "ui-tabs-" + getNextTabId();
},
_sanitizeSelector: function( hash ) {
return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
},
refresh: function() {
var options = this.options,
lis = this.tablist.children( ":has(a[href])" );
// get disabled tabs from class attribute from HTML
// this will get converted to a boolean if needed in _refresh()
options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
return lis.index( tab );
});
this._processTabs();
// was collapsed or no tabs
if ( options.active === false || !this.anchors.length ) {
options.active = false;
this.active = $();
// was active, but active tab is gone
} else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
// all remaining tabs are disabled
if ( this.tabs.length === options.disabled.length ) {
options.active = false;
this.active = $();
// activate previous tab
} else {
this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
}
// was active, active tab still exists
} else {
// make sure active index is correct
options.active = this.tabs.index( this.active );
}
this._refresh();
},
_refresh: function() {
this._setupDisabled( this.options.disabled );
this._setupEvents( this.options.event );
this._setupHeightStyle( this.options.heightStyle );
this.tabs.not( this.active ).attr({
"aria-selected": "false",
tabIndex: -1
});
this.panels.not( this._getPanelForTab( this.active ) )
.hide()
.attr({
"aria-expanded": "false",
"aria-hidden": "true"
});
// Make sure one tab is in the tab order
if ( !this.active.length ) {
this.tabs.eq( 0 ).attr( "tabIndex", 0 );
} else {
this.active
.addClass( "ui-tabs-active ui-state-active" )
.attr({
"aria-selected": "true",
tabIndex: 0
});
this._getPanelForTab( this.active )
.show()
.attr({
"aria-expanded": "true",
"aria-hidden": "false"
});
}
},
_processTabs: function() {
var that = this;
this.tablist = this._getList()
.addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
.attr( "role", "tablist" );
this.tabs = this.tablist.find( "> li:has(a[href])" )
.addClass( "ui-state-default ui-corner-top" )
.attr({
role: "tab",
tabIndex: -1
});
this.anchors = this.tabs.map(function() {
return $( "a", this )[ 0 ];
})
.addClass( "ui-tabs-anchor" )
.attr({
role: "presentation",
tabIndex: -1
});
this.panels = $();
this.anchors.each(function( i, anchor ) {
var selector, panel, panelId,
anchorId = $( anchor ).uniqueId().attr( "id" ),
tab = $( anchor ).closest( "li" ),
originalAriaControls = tab.attr( "aria-controls" );
// inline tab
if ( isLocal( anchor ) ) {
selector = anchor.hash;
panel = that.element.find( that._sanitizeSelector( selector ) );
// remote tab
} else {
panelId = that._tabId( tab );
selector = "#" + panelId;
panel = that.element.find( selector );
if ( !panel.length ) {
panel = that._createPanel( panelId );
panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
}
panel.attr( "aria-live", "polite" );
}
if ( panel.length) {
that.panels = that.panels.add( panel );
}
if ( originalAriaControls ) {
tab.data( "ui-tabs-aria-controls", originalAriaControls );
}
tab.attr({
"aria-controls": selector.substring( 1 ),
"aria-labelledby": anchorId
});
panel.attr( "aria-labelledby", anchorId );
});
this.panels
.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
.attr( "role", "tabpanel" );
},
// allow overriding how to find the list for rare usage scenarios (#7715)
_getList: function() {
return this.element.find( "ol,ul" ).eq( 0 );
},
_createPanel: function( id ) {
return $( "<div>" )
.attr( "id", id )
.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
.data( "ui-tabs-destroy", true );
},
_setupDisabled: function( disabled ) {
if ( $.isArray( disabled ) ) {
if ( !disabled.length ) {
disabled = false;
} else if ( disabled.length === this.anchors.length ) {
disabled = true;
}
}
// disable tabs
for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
$( li )
.addClass( "ui-state-disabled" )
.attr( "aria-disabled", "true" );
} else {
$( li )
.removeClass( "ui-state-disabled" )
.removeAttr( "aria-disabled" );
}
}
this.options.disabled = disabled;
},
_setupEvents: function( event ) {
var events = {
click: function( event ) {
event.preventDefault();
}
};
if ( event ) {
$.each( event.split(" "), function( index, eventName ) {
events[ eventName ] = "_eventHandler";
});
}
this._off( this.anchors.add( this.tabs ).add( this.panels ) );
this._on( this.anchors, events );
this._on( this.tabs, { keydown: "_tabKeydown" } );
this._on( this.panels, { keydown: "_panelKeydown" } );
this._focusable( this.tabs );
this._hoverable( this.tabs );
},
_setupHeightStyle: function( heightStyle ) {
var maxHeight,
parent = this.element.parent();
if ( heightStyle === "fill" ) {
maxHeight = parent.height();
maxHeight -= this.element.outerHeight() - this.element.height();
this.element.siblings( ":visible" ).each(function() {
var elem = $( this ),
position = elem.css( "position" );
if ( position === "absolute" || position === "fixed" ) {
return;
}
maxHeight -= elem.outerHeight( true );
});
this.element.children().not( this.panels ).each(function() {
maxHeight -= $( this ).outerHeight( true );
});
this.panels.each(function() {
$( this ).height( Math.max( 0, maxHeight -
$( this ).innerHeight() + $( this ).height() ) );
})
.css( "overflow", "auto" );
} else if ( heightStyle === "auto" ) {
maxHeight = 0;
this.panels.each(function() {
maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
}).height( maxHeight );
}
},
_eventHandler: function( event ) {
var options = this.options,
active = this.active,
anchor = $( event.currentTarget ),
tab = anchor.closest( "li" ),
clickedIsActive = tab[ 0 ] === active[ 0 ],
collapsing = clickedIsActive && options.collapsible,
toShow = collapsing ? $() : this._getPanelForTab( tab ),
toHide = !active.length ? $() : this._getPanelForTab( active ),
eventData = {
oldTab: active,
oldPanel: toHide,
newTab: collapsing ? $() : tab,
newPanel: toShow
};
event.preventDefault();
if ( tab.hasClass( "ui-state-disabled" ) ||
// tab is already loading
tab.hasClass( "ui-tabs-loading" ) ||
// can't switch durning an animation
this.running ||
// click on active header, but not collapsible
( clickedIsActive && !options.collapsible ) ||
// allow canceling activation
( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
return;
}
options.active = collapsing ? false : this.tabs.index( tab );
this.active = clickedIsActive ? $() : tab;
if ( this.xhr ) {
this.xhr.abort();
}
if ( !toHide.length && !toShow.length ) {
$.error( "jQuery UI Tabs: Mismatching fragment identifier." );
}
if ( toShow.length ) {
this.load( this.tabs.index( tab ), event );
}
this._toggle( event, eventData );
},
// handles show/hide for selecting tabs
_toggle: function( event, eventData ) {
var that = this,
toShow = eventData.newPanel,
toHide = eventData.oldPanel;
this.running = true;
function complete() {
that.running = false;
that._trigger( "activate", event, eventData );
}
function show() {
eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
if ( toShow.length && that.options.show ) {
that._show( toShow, that.options.show, complete );
} else {
toShow.show();
complete();
}
}
// start out by hiding, then showing, then completing
if ( toHide.length && this.options.hide ) {
this._hide( toHide, this.options.hide, function() {
eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
show();
});
} else {
eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
toHide.hide();
show();
}
toHide.attr({
"aria-expanded": "false",
"aria-hidden": "true"
});
eventData.oldTab.attr( "aria-selected", "false" );
// If we're switching tabs, remove the old tab from the tab order.
// If we're opening from collapsed state, remove the previous tab from the tab order.
// If we're collapsing, then keep the collapsing tab in the tab order.
if ( toShow.length && toHide.length ) {
eventData.oldTab.attr( "tabIndex", -1 );
} else if ( toShow.length ) {
this.tabs.filter(function() {
return $( this ).attr( "tabIndex" ) === 0;
})
.attr( "tabIndex", -1 );
}
toShow.attr({
"aria-expanded": "true",
"aria-hidden": "false"
});
eventData.newTab.attr({
"aria-selected": "true",
tabIndex: 0
});
},
_activate: function( index ) {
var anchor,
active = this._findActive( index );
// trying to activate the already active panel
if ( active[ 0 ] === this.active[ 0 ] ) {
return;
}
// trying to collapse, simulate a click on the current active header
if ( !active.length ) {
active = this.active;
}
anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
this._eventHandler({
target: anchor,
currentTarget: anchor,
preventDefault: $.noop
});
},
_findActive: function( index ) {
return index === false ? $() : this.tabs.eq( index );
},
_getIndex: function( index ) {
// meta-function to give users option to provide a href string instead of a numerical index.
if ( typeof index === "string" ) {
index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
}
return index;
},
_destroy: function() {
if ( this.xhr ) {
this.xhr.abort();
}
this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
this.tablist
.removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
.removeAttr( "role" );
this.anchors
.removeClass( "ui-tabs-anchor" )
.removeAttr( "role" )
.removeAttr( "tabIndex" )
.removeUniqueId();
this.tabs.add( this.panels ).each(function() {
if ( $.data( this, "ui-tabs-destroy" ) ) {
$( this ).remove();
} else {
$( this )
.removeClass( "ui-state-default ui-state-active ui-state-disabled " +
"ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
.removeAttr( "tabIndex" )
.removeAttr( "aria-live" )
.removeAttr( "aria-busy" )
.removeAttr( "aria-selected" )
.removeAttr( "aria-labelledby" )
.removeAttr( "aria-hidden" )
.removeAttr( "aria-expanded" )
.removeAttr( "role" );
}
});
this.tabs.each(function() {
var li = $( this ),
prev = li.data( "ui-tabs-aria-controls" );
if ( prev ) {
li
.attr( "aria-controls", prev )
.removeData( "ui-tabs-aria-controls" );
} else {
li.removeAttr( "aria-controls" );
}
});
this.panels.show();
if ( this.options.heightStyle !== "content" ) {
this.panels.css( "height", "" );
}
},
enable: function( index ) {
var disabled = this.options.disabled;
if ( disabled === false ) {
return;
}
if ( index === undefined ) {
disabled = false;
} else {
index = this._getIndex( index );
if ( $.isArray( disabled ) ) {
disabled = $.map( disabled, function( num ) {
return num !== index ? num : null;
});
} else {
disabled = $.map( this.tabs, function( li, num ) {
return num !== index ? num : null;
});
}
}
this._setupDisabled( disabled );
},
disable: function( index ) {
var disabled = this.options.disabled;
if ( disabled === true ) {
return;
}
if ( index === undefined ) {
disabled = true;
} else {
index = this._getIndex( index );
if ( $.inArray( index, disabled ) !== -1 ) {
return;
}
if ( $.isArray( disabled ) ) {
disabled = $.merge( [ index ], disabled ).sort();
} else {
disabled = [ index ];
}
}
this._setupDisabled( disabled );
},
load: function( index, event ) {
index = this._getIndex( index );
var that = this,
tab = this.tabs.eq( index ),
anchor = tab.find( ".ui-tabs-anchor" ),
panel = this._getPanelForTab( tab ),
eventData = {
tab: tab,
panel: panel
};
// not remote
if ( isLocal( anchor[ 0 ] ) ) {
return;
}
this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
// support: jQuery <1.8
// jQuery <1.8 returns false if the request is canceled in beforeSend,
// but as of 1.8, $.ajax() always returns a jqXHR object.
if ( this.xhr && this.xhr.statusText !== "canceled" ) {
tab.addClass( "ui-tabs-loading" );
panel.attr( "aria-busy", "true" );
this.xhr
.success(function( response ) {
// support: jQuery <1.8
// http://bugs.jquery.com/ticket/11778
setTimeout(function() {
panel.html( response );
that._trigger( "load", event, eventData );
}, 1 );
})
.complete(function( jqXHR, status ) {
// support: jQuery <1.8
// http://bugs.jquery.com/ticket/11778
setTimeout(function() {
if ( status === "abort" ) {
that.panels.stop( false, true );
}
tab.removeClass( "ui-tabs-loading" );
panel.removeAttr( "aria-busy" );
if ( jqXHR === that.xhr ) {
delete that.xhr;
}
}, 1 );
});
}
},
_ajaxSettings: function( anchor, event, eventData ) {
var that = this;
return {
url: anchor.attr( "href" ),
beforeSend: function( jqXHR, settings ) {
return that._trigger( "beforeLoad", event,
$.extend( { jqXHR : jqXHR, ajaxSettings: settings }, eventData ) );
}
};
},
_getPanelForTab: function( tab ) {
var id = $( tab ).attr( "aria-controls" );
return this.element.find( this._sanitizeSelector( "#" + id ) );
}
});
})( jQuery );
(function( $, undefined ) {
})( jQuery );
}));
|
angular.module(
"radiobot.module.admin",
[
"radiobot.module.admin.controller.admin"
]
);
|
//>>built
define({add:"Gehitu",addAuthor:"Gehitu egilea",addContributor:"Gehitu kolaboratzailea"}); |
const path = require('path')
require('@technologyadvice/genesis-core')(require('../genesis.config')).build({
out: path.resolve(__dirname, '../dist'),
})
|
var feathers = require('feathers');
var passport = require('passport');
var crypto = require('crypto');
var hooks = require('feathers-hooks');
var memory = require('feathers-memory');
var bodyParser = require('body-parser');
var session = require('express-session');
var feathersPassport = require('../lib/passport');
var LocalStrategy = require('passport-local').Strategy;
// SHA1 hashes a string
var sha1 = function(string) {
var shasum = crypto.createHash('sha1');
shasum.update(string);
return shasum.digest('hex');
};
// A shared session store must be provided.
// This MemoryStore is not recommended for production
var store = new session.MemoryStore();
// Initialize the application
var app = feathers()
.configure(feathers.rest())
.configure(feathers.socketio())
.configure(hooks())
// Needed for parsing bodies (login)
.use(bodyParser.urlencoded({ extended: true }))
// Configure feathers-passport
.configure(feathersPassport({
// Secret must be provided
secret: 'feathers-rocks',
// Also set a store
store: store
}))
// Initialize a user service
.use('/users', memory())
// A simple Todos service that we can use for testing
.use('/todos', {
get: function(id, params, callback) {
callback(null, {
id: id,
text: 'You have to do ' + id + '!',
user: params.user
});
}
})
// Add a login route for the passport login
.post('/login', passport.authenticate('local', {
successRedirect: '/',
failureRedirect: '/login.html',
failureFlash: false
}))
// Host this folder
.use('/', feathers.static(__dirname));
var userService = app.service('users');
// Add a hook to the user service that automatically hashes the
// password before saving it
userService.before({
create: function(hook, next) {
var password = hook.data.password;
// Replace the data with the SHA1 hashed password
hook.data.password = sha1(password);
next();
}
});
// Use the id to serialize the user
passport.serializeUser(function(user, done) {
done(null, user.id);
});
// Deserialize the user retrieving it form the user service
passport.deserializeUser(function(id, done) {
// Get the user service and then retrieve the user id
userService.get(id, {}, done);
});
// Attach the local strategy
passport.use(new LocalStrategy(function(username, password, done) {
var query = {
username: username
};
userService.find({ query: query }, function(error, users) {
if(error) {
return done(error);
}
var user = users[0];
if(!user) {
return done(new Error('User not found'));
}
// Compare the hashed password
if(user.password !== sha1(password)) {
return done(new Error('Password not valid'));
}
done(null, user);
});
}
));
// Create a user that we can use to log in
userService.create({
username: 'feathers',
password: 'secret'
}, {}, function(error, user) {
console.log('Created default user', user);
});
app.listen(4000);
|
/**
* jVectorMap version 2.0.5
*
* Copyright 2011-2014, Kirill Lebedev
*
*/
(function( $ ){
var apiParams = {
set: {
colors: 1,
values: 1,
backgroundColor: 1,
scaleColors: 1,
normalizeFunction: 1,
focus: 1
},
get: {
selectedRegions: 1,
selectedMarkers: 1,
mapObject: 1,
regionName: 1
}
};
$.fn.vectorMap = function(options) {
var map,
methodName,
map = this.children('.jvectormap-container').data('mapObject');
if (options === 'addMap') {
jvm.Map.maps[arguments[1]] = arguments[2];
} else if ((options === 'set' || options === 'get') && apiParams[options][arguments[1]]) {
methodName = arguments[1].charAt(0).toUpperCase()+arguments[1].substr(1);
return map[options+methodName].apply(map, Array.prototype.slice.call(arguments, 2));
} else {
options = options || {};
options.container = this;
map = new jvm.Map(options);
}
return this;
};
})( jQuery );
|
'use strict';
var test = require('tape');
var FixturesFs = require('fixtures-fs');
var path = require('path');
var StaticConfig = require('../index.js');
test('StaticConfig is a function', function t(assert) {
assert.equal(typeof StaticConfig, 'function');
assert.end();
});
test('can create empty config', function t(assert) {
var config = StaticConfig({
files: []
});
config.set('k', 'v');
assert.equal(config.get('k'), 'v');
assert.end();
});
test('can get namespaces', function t(assert) {
var config = StaticConfig({
files: []
});
config.set('a.b.c', 'v');
assert.equal(config.get('a.b.c'), 'v');
assert.end();
});
test('throws for non-existant keys', function t(assert) {
var config = StaticConfig({
files: []
});
assert.throws(function throwIt() {
config.get('a.b.c');
}, /Key not available: a.b.c/);
assert.end();
});
test('supports seedConfig', function t(assert) {
var config = StaticConfig({
files: [],
seedConfig: {
'a.b.c': 'v'
}
});
assert.equal(config.get('a.b.c'), 'v');
assert.end();
});
test('cannot set() existing keys', function t(assert) {
var config = StaticConfig({
files: [],
seedConfig: {
'a.b.c': 'v'
}
});
assert.throws(function throwIt() {
config.set('a.b.c', 'x');
}, /Key already exists: a.b.c/);
assert.end();
});
test('cannot get() from destroyed config', function t(assert) {
var config = StaticConfig({
files: [],
seedConfig: {
'a.b.c': 'v'
}
});
assert.equal(config.get('a.b.c'), 'v');
config.destroy();
assert.throws(function throwIt() {
config.get('a.b.c');
}, /Cannot get\(a.b.c\) because destroyed/);
assert.end();
});
test('cannot set() on frozen config', function t(assert) {
var config = StaticConfig({
files: []
});
config.set('a', 'a');
config.set('b', 'b');
config.freeze();
assert.throws(function throwIt() {
config.set('c', 'c');
}, /Cannot set\(c\) because frozen/);
assert.deepEqual(config.inspect(), {
'a': 'a',
'b': 'b'
});
assert.end();
});
test('can read from file', FixturesFs(__dirname, {
'config': {
'production.json': JSON.stringify({
'a': 'b',
'a.b.c': 'v'
})
}
}, function t(assert) {
var config = StaticConfig({
files: [
path.join(__dirname, 'config', 'production.json')
]
});
assert.equal(config.get('a'), 'b');
assert.equal(config.get('a.b.c'), 'v');
assert.end();
}));
test('seedConfig overwrites files', FixturesFs(__dirname, {
'config': {
'production.json': JSON.stringify({
'a': 'b',
'a.b.c': 'v'
})
}
}, function t(assert) {
var config = StaticConfig({
files: [
path.join(__dirname, 'config', 'production.json')
],
seedConfig: {
'a': 'c'
}
});
assert.equal(config.get('a'), 'c');
assert.equal(config.get('a.b.c'), 'v');
assert.end();
}));
test('later files overwrite earlier files', FixturesFs(__dirname, {
'config': {
'production.json': JSON.stringify({
'a': 'b',
'a.b.c': 'v'
}),
'local.json': JSON.stringify({
'a': 'c'
})
}
}, function t(assert) {
var config = StaticConfig({
files: [
path.join(__dirname, 'config', 'production.json'),
path.join(__dirname, 'config', 'local.json')
]
});
assert.equal(config.get('a'), 'c');
assert.equal(config.get('a.b.c'), 'v');
assert.end();
}));
test('is resilient to non-existant files', function t(assert) {
var config = StaticConfig({
files: [
path.join(__dirname, 'config', 'production.json'),
path.join(__dirname, 'config', 'local.json')
],
seedConfig: {
'a': 'd',
'a.b.c': 'v2'
}
});
assert.equal(config.get('a'), 'd');
assert.equal(config.get('a.b.c'), 'v2');
assert.end();
});
test('throws for invalid json', FixturesFs(__dirname, {
'config': {
'production.json': JSON.stringify({
'a': 'b',
'a.b.c': 'v'
}),
'local.json': '{...}'
}
}, function t(assert) {
assert.throws(function throwIt() {
StaticConfig({
files: [
path.join(__dirname, 'config', 'production.json'),
path.join(__dirname, 'config', 'local.json')
]
});
}, /Unexpected token ./);
assert.end();
}));
|
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const chalk = require("chalk");
const path = require("path");
const cli_utils_1 = require("@ionic/cli-utils");
const modules_1 = require("./lib/modules");
const generate_1 = require("./utils/generate");
function generate(args) {
return __awaiter(this, void 0, void 0, function* () {
if (!args.env.project.directory) {
return [];
}
const appScriptsArgs = cli_utils_1.minimistOptionsToArray(args.options, { useEquals: false, ignoreFalse: true, allowCamelCase: true });
process.argv = ['node', 'appscripts'].concat(appScriptsArgs);
const ionicAngularPackageJsonFilePath = path.resolve(args.env.project.directory, 'node_modules', 'ionic-angular', 'package.json');
try {
const ionicAngularPackageJson = yield cli_utils_1.readPackageJsonFile(ionicAngularPackageJsonFilePath);
if (ionicAngularPackageJson.version && Number(ionicAngularPackageJson.version.charAt(0)) < 3) {
throw new Error(`The generate command is only available for projects that use ionic-angular >= 3.0.0`);
}
}
catch (e) {
args.env.log.error(`Error with ${chalk.bold(cli_utils_1.prettyPath(ionicAngularPackageJsonFilePath))} file: ${e}`);
}
const AppScripts = modules_1.load('@ionic/app-scripts');
const context = AppScripts.generateContext();
const [type, name] = args.inputs;
switch (type) {
case 'page':
return yield AppScripts.processPageRequest(context, name);
case 'component':
const componentData = yield promptQuestions(context);
return yield AppScripts.processComponentRequest(context, name, componentData);
case 'directive':
const directiveData = yield promptQuestions(context);
return yield AppScripts.processDirectiveRequest(context, name, directiveData);
case 'pipe':
const pipeData = yield promptQuestions(context);
return yield AppScripts.processPipeRequest(context, name, pipeData);
case 'provider':
const providerData = yield promptQuestions(context);
return yield AppScripts.processProviderRequest(context, name, providerData);
case 'tabs':
const tabsData = yield generate_1.tabsPrompt(args.env);
yield AppScripts.processTabsRequest(context, name, tabsData);
}
return [];
});
}
exports.generate = generate;
function promptQuestions(context) {
return __awaiter(this, void 0, void 0, function* () {
return yield generate_1.prompt(context);
});
}
|
module.exports = function (grunt) {
grunt.loadNpmTasks("grunt-contrib-jshint");
grunt.initConfig({
jshint:{
options:{
jshintrc: ".jshintrc"
},
files : ["./tasks/**/*.js"]
}
});
grunt.registerTask("default", ["jshint"]);
}; |
module.exports = {
init
}
const { autoUpdater } = require('electron')
const get = require('simple-get')
const config = require('../config')
const log = require('./log')
const windows = require('./windows')
const AUTO_UPDATE_URL = config.AUTO_UPDATE_URL +
'?version=' + config.APP_VERSION +
'&platform=' + process.platform +
'&sysarch=' + config.OS_SYSARCH
function init () {
if (process.platform === 'linux') {
initLinux()
} else {
initDarwinWin32()
}
}
// The Electron auto-updater does not support Linux yet, so manually check for
// updates and show the user a modal notification.
function initLinux () {
get.concat(AUTO_UPDATE_URL, onResponse)
}
function onResponse (err, res, data) {
if (err) return log(`Update error: ${err.message}`)
if (res.statusCode === 200) {
// Update available
try {
data = JSON.parse(data)
} catch (err) {
return log(`Update error: Invalid JSON response: ${err.message}`)
}
windows.main.dispatch('updateAvailable', data.version)
} else if (res.statusCode === 204) {
// No update available
} else {
// Unexpected status code
log(`Update error: Unexpected status code: ${res.statusCode}`)
}
}
function initDarwinWin32 () {
autoUpdater.on(
'error',
(err) => log.error(`Update error: ${err.message}`)
)
autoUpdater.on(
'checking-for-update',
() => log('Checking for update')
)
autoUpdater.on(
'update-available',
() => log('Update available')
)
autoUpdater.on(
'update-not-available',
() => log('No update available')
)
autoUpdater.on(
'update-downloaded',
(e, notes, name, date, url) => log(`Update downloaded: ${name}: ${url}`)
)
autoUpdater.setFeedURL({ url: AUTO_UPDATE_URL })
autoUpdater.checkForUpdates()
}
|
/*
* Ext JS Library 2.1
* Copyright(c) 2006-2008, Ext JS, LLC.
* licensing@extjs.com
*
* http://extjs.com/license
*/
/**
* @class Ext.menu.Item
* @extends Ext.menu.BaseItem
* A base class for all menu items that require menu-related functionality (like sub-menus) and are not static
* display items. Item extends the base functionality of {@link Ext.menu.BaseItem} by adding menu-specific
* activation and click handling.
* @constructor
* Creates a new Item
* @param {Object} config Configuration options
*/
Ext.menu.Item = function(config){
Ext.menu.Item.superclass.constructor.call(this, config);
if(this.menu){
this.menu = Ext.menu.MenuMgr.get(this.menu);
}
};
Ext.extend(Ext.menu.Item, Ext.menu.BaseItem, {
/**
* @cfg {Mixed} menu Either an instance of {@link Ext.menu.Menu} or the config object for an
* {@link Ext.menu.Menu} which acts as the submenu when this item is activated.
*/
/**
* @cfg {String} icon The path to an icon to display in this item (defaults to Ext.BLANK_IMAGE_URL). If
* icon is specified {@link #iconCls} should not be.
*/
/**
* @cfg {String} iconCls A CSS class that specifies a background image that will be used as the icon for
* this item (defaults to ''). If iconCls is specified {@link #icon} should not be.
*/
/**
* @cfg {String} text The text to display in this item (defaults to '').
*/
/**
* @cfg {String} href The href attribute to use for the underlying anchor link (defaults to '#').
*/
/**
* @cfg {String} hrefTarget The target attribute to use for the underlying anchor link (defaults to '').
*/
/**
* @cfg {String} itemCls The default CSS class to use for menu items (defaults to 'x-menu-item')
*/
itemCls : "x-menu-item",
/**
* @cfg {Boolean} canActivate True if this item can be visually activated (defaults to true)
*/
canActivate : true,
/**
* @cfg {Number} showDelay Length of time in milliseconds to wait before showing this item (defaults to 200)
*/
showDelay: 200,
// doc'd in BaseItem
hideDelay: 200,
// private
ctype: "Ext.menu.Item",
// private
onRender : function(container, position){
var el = document.createElement("a");
el.hideFocus = true;
el.unselectable = "on";
el.href = this.href || "#";
if(this.hrefTarget){
el.target = this.hrefTarget;
}
el.className = this.itemCls + (this.menu ? " x-menu-item-arrow" : "") + (this.cls ? " " + this.cls : "");
el.innerHTML = String.format(
'<img src="{0}" class="x-menu-item-icon {2}" />{1}',
this.icon || Ext.BLANK_IMAGE_URL, this.itemText||this.text, this.iconCls || '');
this.el = el;
Ext.menu.Item.superclass.onRender.call(this, container, position);
},
/**
* Sets the text to display in this menu item
* @param {String} text The text to display
*/
setText : function(text){
this.text = text;
if(this.rendered){
this.el.update(String.format(
'<img src="{0}" class="x-menu-item-icon {2}">{1}',
this.icon || Ext.BLANK_IMAGE_URL, this.text, this.iconCls || ''));
this.parentMenu.autoWidth();
}
},
/**
* Sets the CSS class to apply to the item's icon element
* @param {String} cls The CSS class to apply
*/
setIconClass : function(cls){
var oldCls = this.iconCls;
this.iconCls = cls;
if(this.rendered){
this.el.child('img.x-menu-item-icon').replaceClass(oldCls, this.iconCls);
}
},
// private
handleClick : function(e){
if(!this.href){ // if no link defined, stop the event automatically
e.stopEvent();
}
Ext.menu.Item.superclass.handleClick.apply(this, arguments);
},
// private
activate : function(autoExpand){
if(Ext.menu.Item.superclass.activate.apply(this, arguments)){
this.focus();
if(autoExpand){
this.expandMenu();
}
}
return true;
},
// private
shouldDeactivate : function(e){
if(Ext.menu.Item.superclass.shouldDeactivate.call(this, e)){
if(this.menu && this.menu.isVisible()){
return !this.menu.getEl().getRegion().contains(e.getPoint());
}
return true;
}
return false;
},
// private
deactivate : function(){
Ext.menu.Item.superclass.deactivate.apply(this, arguments);
this.hideMenu();
},
// private
expandMenu : function(autoActivate){
if(!this.disabled && this.menu){
clearTimeout(this.hideTimer);
delete this.hideTimer;
if(!this.menu.isVisible() && !this.showTimer){
this.showTimer = this.deferExpand.defer(this.showDelay, this, [autoActivate]);
}else if (this.menu.isVisible() && autoActivate){
this.menu.tryActivate(0, 1);
}
}
},
// private
deferExpand : function(autoActivate){
delete this.showTimer;
this.menu.show(this.container, this.parentMenu.subMenuAlign || "tl-tr?", this.parentMenu);
if(autoActivate){
this.menu.tryActivate(0, 1);
}
},
// private
hideMenu : function(){
clearTimeout(this.showTimer);
delete this.showTimer;
if(!this.hideTimer && this.menu && this.menu.isVisible()){
this.hideTimer = this.deferHide.defer(this.hideDelay, this);
}
},
// private
deferHide : function(){
delete this.hideTimer;
this.menu.hide();
}
}); |
define(
[],
function() {
"use strict";
$.Velocity.Sequences.euiPopcalOpenDefault = function(element, options) {
return $.Velocity.animate(element, {
opacity: [1, 0],
scaleX: [1, 0.7],
scaleY: [1, 0.7]
}, {
duration: options.duration || 100
});
};
}); |
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function createId(instance) {
var constructor = instance.constructor;
var className = constructor.className;
if (!className) {
throw new Error("The " + constructor + " is missing the 'className' property.");
}
return className + '-' + (constructor.id = (constructor.id || 0) + 1);
}
exports.createId = createId;
//# sourceMappingURL=id.js.map |
exports["sample test"] = function(test) {
test.ok(true);
test.done();
};
|
const m = require("../mobx4")
test("cascading active state (form 1)", function () {
const Store = function () {
m.extendObservable(this, { _activeItem: null })
}
Store.prototype.activeItem = function (item) {
const _this = this
if (arguments.length === 0) return this._activeItem
m.transaction(function () {
if (_this._activeItem === item) return
if (_this._activeItem) _this._activeItem.isActive = false
_this._activeItem = item
if (_this._activeItem) _this._activeItem.isActive = true
})
}
const Item = function () {
m.extendObservable(this, { isActive: false })
}
const store = new Store()
const item1 = new Item(),
item2 = new Item()
expect(store.activeItem()).toBe(null)
expect(item1.isActive).toBe(false)
expect(item2.isActive).toBe(false)
store.activeItem(item1)
expect(store.activeItem()).toBe(item1)
expect(item1.isActive).toBe(true)
expect(item2.isActive).toBe(false)
store.activeItem(item2)
expect(store.activeItem()).toBe(item2)
expect(item1.isActive).toBe(false)
expect(item2.isActive).toBe(true)
store.activeItem(null)
expect(store.activeItem()).toBe(null)
expect(item1.isActive).toBe(false)
expect(item2.isActive).toBe(false)
})
test("cascading active state (form 2)", function () {
const Store = function () {
const _this = this
m.extendObservable(this, { activeItem: null })
m.autorun(function () {
if (_this._activeItem === _this.activeItem) return
if (_this._activeItem) _this._activeItem.isActive = false
_this._activeItem = _this.activeItem
if (_this._activeItem) _this._activeItem.isActive = true
})
}
const Item = function () {
m.extendObservable(this, { isActive: false })
}
const store = new Store()
const item1 = new Item(),
item2 = new Item()
expect(store.activeItem).toBe(null)
expect(item1.isActive).toBe(false)
expect(item2.isActive).toBe(false)
store.activeItem = item1
expect(store.activeItem).toBe(item1)
expect(item1.isActive).toBe(true)
expect(item2.isActive).toBe(false)
store.activeItem = item2
expect(store.activeItem).toBe(item2)
expect(item1.isActive).toBe(false)
expect(item2.isActive).toBe(true)
store.activeItem = null
expect(store.activeItem).toBe(null)
expect(item1.isActive).toBe(false)
expect(item2.isActive).toBe(false)
})
test("emulate rendering", function () {
let renderCount = 0
const Component = function (props) {
this.props = props
}
Component.prototype.destroy = function () {
if (this.handler) {
this.handler()
this.handler = null
}
}
Component.prototype.render = function () {
const _this = this
if (this.handler) {
this.handler()
this.handler = null
}
this.handler = m.autorun(function () {
if (!_this.props.data.title) _this.props.data.title = "HELLO"
renderCount++
})
}
const data = {}
m.extendObservable(data, { title: null })
const component = new Component({ data: data })
expect(renderCount).toBe(0)
component.render()
expect(renderCount).toBe(1)
data.title = "WORLD"
expect(renderCount).toBe(2)
data.title = null
// Note that this causes two invalidations
// however, the real mobx-react binding optimizes this as well
// see mobx-react #12, so maybe this ain't the best test
expect(renderCount).toBe(4)
data.title = "WORLD"
expect(renderCount).toBe(5)
component.destroy()
data.title = "HELLO"
expect(renderCount).toBe(5)
})
test("efficient selection", function () {
function Item(value) {
m.extendObservable(this, {
selected: false,
value: value
})
}
function Store() {
this.prevSelection = null
m.extendObservable(this, {
selection: null,
items: [new Item(1), new Item(2), new Item(3)]
})
m.autorun(() => {
if (this.previousSelection === this.selection) return true // converging condition
if (this.previousSelection) this.previousSelection.selected = false
if (this.selection) this.selection.selected = true
this.previousSelection = this.selection
})
}
const store = new Store()
expect(store.selection).toBe(null)
expect(
store.items.filter(function (i) {
return i.selected
}).length
).toBe(0)
store.selection = store.items[1]
expect(
store.items.filter(function (i) {
return i.selected
}).length
).toBe(1)
expect(store.selection).toBe(store.items[1])
expect(store.items[1].selected).toBe(true)
store.selection = store.items[2]
expect(
store.items.filter(function (i) {
return i.selected
}).length
).toBe(1)
expect(store.selection).toBe(store.items[2])
expect(store.items[2].selected).toBe(true)
store.selection = null
expect(
store.items.filter(function (i) {
return i.selected
}).length
).toBe(0)
expect(store.selection).toBe(null)
})
|
this.spawnFunc = function(fundecl) {
return new Scope(
this,
fundecl ?
ST_FN_STMT :
ST_FN_EXPR
);
};
this.spawnLexical = function(loop) {
return new Scope(
this,
!loop ?
ST_LEXICAL :
ST_LEXICAL|ST_LOOP);
};
this.spawnCatch = function() {
return new Scope(
this,
ST_LEXICAL|ST_CATCH);
};
this.mustNotHaveAnyDupeParams = function() {
return this.strict || this.isInComplexArgs;
};
this.hasParam = function(name) {
return HAS.call(this.idNames, name+'%');
};
this.insertID = function(id) {
this.idNames[id.name+'%'] = id;
};
|
(() => {
'use strict';
define(main);
function main() {
return uuid;
}
/**
* Generates RFC4122 compliant UUIDs.
*
* Credit: https://gist.github.com/jcxplorer/823878
*
* @returns {String} The generated UUID.
*/
function uuid() {
var uuid = "",
i, random;
for (i = 0; i < 32; i++) {
random = Math.random() * 16 | 0;
if (i == 8 || i == 12 || i == 16 || i == 20) {
uuid += "-"
}
uuid += (i == 12 ? 4 : (i == 16 ? (random & 3 | 8) : random)).toString(16);
}
return uuid;
}
})(); |
var parseUrl = require('url').parse;
var Q = require('q');
var FormData = require('form-data');
var Utils = require('./utils');
var IonicProject = require('./project');
var Settings = require('./settings');
var log = require('./logging').logger;
var Share = module.exports;
Share.shareApp = function shareApp(appDirectory, jar, email) {
var q = Q.defer();
var project = IonicProject.load(appDirectory);
var url = Settings.IONIC_DASH_API + 'app/' + project.get('app_id') + '/share';
var params = parseUrl(url);
var form = new FormData();
form.append('csrfmiddlewaretoken', Utils.retrieveCsrfToken(jar));
form.append('e', email);
form.submit({
protocol: params.protocol,
hostname: params.hostname,
port: params.port,
path: params.path,
headers: form.getHeaders({
cookie: jar.map(function(c) {
return c.key + '=' + encodeURIComponent(c.value);
}).join('; ')
})
}, function(err, response) {
if (err) {
return q.reject('Error sharing: ' + err);
}
response.on('data', function() {
if (err || parseInt(response.statusCode, 10) !== 200) {
// console.log(data);
return q.reject('Error sharing: ' + err);
}
log.info('An invite to view your app was sent.');
return q.resolve('An invite to view your app was sent.');
});
});
return q.promise;
};
|
import Component from '@ember/component';
export default Component.extend({
classNames: ['user__skills-list']
});
|
/**
* Copyright (c) 2014, 2016, Oracle and/or its affiliates.
* The Universal Permissive License (UPL), Version 1.0
*/
"use strict";
define(['ojs/ojcore', 'jquery', 'hammerjs', 'promise', 'ojs/ojjquery-hammer', 'ojs/ojcomponentcore'],
/*
* @param {Object} oj
* @param {jQuery} $
* @param {Object} Hammer
*/
function(oj, $, Hammer)
{
/**
* Copyright (c) 2015, Oracle and/or its affiliates.
* All rights reserved.
*/
/**
* @class Utility methods for offcanvas.
* @since 1.1.0
* @export
*
* @classdesc
* This class provides functions used for controlling offcanvas regions. Offcanvas regions can be used in either static (simply displaying and hiding in response to user interactions) or responsive (using media queries to dynamically move application content between the main viewport and offcanvas regions) contexts. The open, close and toggle methods can be used to directly control the display of an offcanvas region in both the static and responsive cases. The setupResponsive and tearDownResponsive methods are only needed for responsive usages and are used to add and remove listeners that use the specified media queries to configure the offcanvas in response to changes in browser size.
* The setupPanToReveal and tearDownPanToReveal methods are used to add and remove listeners neccessary to reveal the offcanvas as user pans on the outer wrapper.
*
* <ul>
* <li>open: show the offcanvas by sliding it into the viewport.</li>
* <li>close: hide the offcanvas by sliding it out of the viewport.</li>
* <li>toggle: toggle the offcanvas in or out of the viewport.</li>
* <li>setupResponsive: setup offcanvas for the responsive layout.</li>
* <li>tearDownResponsive: remove listeners that were added in setupResponsive.</li>
* <li>setupPanToReveal: setup offcanvas for pan to reveal.</li>
* <li>tearDownPantoReveal: remove listeners that were added in setupPanToReveal.</li><br>
* </ul>
*
* <h3 id="events-section">
* Events
* <a class="bookmarkable-link" title="Bookmarkable Link" href="#events-section"></a>
* </h3>
*
*
* <table class="generic-table events-table">
* <thead>
* <tr>
* <th>Event</th>
* <th>Description</th>
* <th>Example</th>
* </tr>
* </thead>
* <tbody>
* <tr>
* <td>beforeClose</td>
* <td>Triggered immediately before the offcanvas is closed. It can be canceled to prevent the content from closing by returning a false in the event listener.</td>
* <td>$(".selector").on("ojbeforeclose", function(event, offcanvas) {});</td>
* </tr>
* <tr>
* <td>beforeOpen<br>
* <td>Triggered immediately before the offcanvas is open. It can be canceled to prevent the content from opening by returning a false in the event listener.</td>
* <td>$(".selector").on("ojbeforeopen", function(event, offcanvas) {});</td>
* </tr>
* <tr>
* <td>close<br>
* <td>Triggered after the offcanvas has been closed.</td>
* <td>$(".selector").on("ojclose", function(event, offcanvas) {});</td>
* </tr>
* <tr>
* <td>open<br>
* <td>Triggered after the offcanvas has been open (after animation completes).</td>
* <td>$(".selector").on("ojopen", function(event, offcanvas) {});</td>
* </tr>
* </tbody>
* </table>
*
* <h3 id="styling-section">
* Styling
* <a class="bookmarkable-link" title="Bookmarkable Link" href="#styling-section"></a>
* </h3>
*
* <table class="generic-table styling-table">
* <thead>
* <tr>
* <th>Class(es)</th>
* <th>Description</th>
* </tr>
* </thead>
* <tbody>
* <tr>
* <td>oj-offcanvas-outer-wrapper</td>
* <td>Applied to the outer most element of the offcanvas.</td>
* </tr>
* <tr>
* <td>oj-offcanvas-page</td>
* <td>Applied to the outer wrapper of the page level offcanvas.</td>
* </tr>
* <tr>
* <td>oj-offcanvas-inner-wrapper<br>
* <td>Applied to the inner wrapper of the offcanvas.</td>
* </tr>
* <tr>
* <td>oj-offcanvas-start<br>
* <td>Applied to the offcanvas on the start edge.</td>
* </tr>
* <tr>
* <td>oj-offcanvas-end<br>
* <td>Applied to the offcanvas on the end edge.</td>
* </tr>
* <tr>
* <td>oj-offcanvas-top<br>
* <td>Applied to the offcanvas on the top edge.</td>
* </tr>
* <tr>
* <td>oj-offcanvas-bottom<br>
* <td>Applied to the offcanvas on the bottom edge.</td>
* </tr>
* </tbody>
* </table>
*
* <h3 id="touch-section">
* Touch End User Information
* <a class="bookmarkable-link" title="Bookmarkable Link" href="#touch-section"></a>
* </h3>
*
* <table class="keyboard-table">
* <thead>
* <tr>
* <th>Target</th>
* <th>Gesture</th>
* <th>Action</th>
* </tr>
* </thead>
* <tbody>
* <tr>
* <td>Offcanvas</td>
* <td><kbd>Swipe</kbd></td>
* <td>Close the offcanvas by swiping in the close direction.</td>
* </tr>
* </tbody>
* </table>
*
*/
oj.OffcanvasUtils = {};
oj.OffcanvasUtils._DATA_EDGE_KEY = "oj-offcanvasEdge";
oj.OffcanvasUtils._DATA_OFFCANVAS_KEY = "oj-offcanvas";
oj.OffcanvasUtils._DATA_MEDIA_QUERY_KEY = "oj-mediaQueryListener";
oj.OffcanvasUtils._DATA_HAMMER_KEY = "oj-offcanvasHammer";
oj.OffcanvasUtils._DATA_STYLE_KEY = "oj-offcanvasStyle";
/**
* @private
*/
oj.OffcanvasUtils.SELECTOR_KEY = "selector";
oj.OffcanvasUtils.CONTENT_KEY = "content";
oj.OffcanvasUtils.EDGE_START = "start";
oj.OffcanvasUtils.EDGE_END = "end";
oj.OffcanvasUtils.EDGE_TOP = "top";
oj.OffcanvasUtils.EDGE_BOTTOM = "bottom";
/**
* @private
*/
oj.OffcanvasUtils.DISPLAY_MODE_KEY = "displayMode";
/**
* @private
*/
oj.OffcanvasUtils.DISPLAY_MODE_PUSH = "push";
/**
* @private
*/
oj.OffcanvasUtils.DISPLAY_MODE_OVERLAY = "overlay";
/**
* @private
*/
oj.OffcanvasUtils.DISPLAY_MODE_PIN = "pin";
/**
* @private
*/
oj.OffcanvasUtils.MODALITY_KEY = "modality";
/**
* @private
*/
oj.OffcanvasUtils.MODALITY_NONE = "none";
/**
* @private
*/
oj.OffcanvasUtils.MODALITY_MODAL = "modal";
/**
* @private
*/
oj.OffcanvasUtils.DISMISS_HANDLER_KEY = "_dismissHandler";
/**
* @private
*/
oj.OffcanvasUtils.OPEN_PROMISE_KEY = "_openPromise";
/**
* @private
*/
oj.OffcanvasUtils.CLOSE_PROMISE_KEY = "_closePromise";
/**
* @private
*/
oj.OffcanvasUtils.GLASS_PANE_KEY = "_glassPane";
/**
* @private
*/
oj.OffcanvasUtils.SURROGATE_KEY = "_surrogate";
/**
* @private
*/
oj.OffcanvasUtils.SURROGATE_ATTR = "data-oj-offcanvas-surrogate-id";
/**
* @private
*/
oj.OffcanvasUtils.OUTER_WRAPPER_SELECTOR = "oj-offcanvas-outer-wrapper";
/**
* @private
*/
oj.OffcanvasUtils.OPEN_SELECTOR = "oj-offcanvas-open";
/**
* @private
*/
oj.OffcanvasUtils.TRANSITION_SELECTOR = "oj-offcanvas-transition";
/**
* @private
*/
oj.OffcanvasUtils.PIN_WRAPPER_SELECTOR = "oj-offcanvas-pin";
/**
* @private
*/
oj.OffcanvasUtils.PIN_TRANSITION_SELECTOR = "oj-offcanvas-pin-transition";
/**
* @private
*/
oj.OffcanvasUtils.GLASSPANE_SELECTOR = "oj-offcanvas-glasspane";
/**
* @private
*/
oj.OffcanvasUtils.GLASSPANE_DIM_SELECTOR = "oj-offcanvas-glasspane-dim";
/**
* @private
*/
oj.OffcanvasUtils.VETO_BEFOREOPEN_MSG = "ojbeforeopen veto";
oj.OffcanvasUtils.VETO_BEFORECLOSE_MSG = "ojbeforeclose veto";
oj.OffcanvasUtils._shiftSelector =
{
"start": "oj-offcanvas-shift-start",
"end": "oj-offcanvas-shift-end",
"top": "oj-offcanvas-shift-down",
"bottom": "oj-offcanvas-shift-up"
};
oj.OffcanvasUtils._drawerSelector =
{
"start": "oj-offcanvas-start",
"end": "oj-offcanvas-end",
"top": "oj-offcanvas-top",
"bottom": "oj-offcanvas-bottom"
};
oj.OffcanvasUtils._getDisplayMode = function(offcanvas)
{
var displayMode = offcanvas[oj.OffcanvasUtils.DISPLAY_MODE_KEY];
if (displayMode !== oj.OffcanvasUtils.DISPLAY_MODE_OVERLAY &&
displayMode !== oj.OffcanvasUtils.DISPLAY_MODE_PUSH &&
displayMode !== oj.OffcanvasUtils.DISPLAY_MODE_PIN)
{
//default displayMode in iOS is push and in android and windows are overlay
displayMode = (oj.ThemeUtils.parseJSONFromFontFamily('oj-offcanvas-option-defaults') || {})["displayMode"];
}
return displayMode;
};
oj.OffcanvasUtils._getDrawer = function(offcanvas)
{
return $(offcanvas[oj.OffcanvasUtils.SELECTOR_KEY]);
};
oj.OffcanvasUtils._isModal = function(offcanvas)
{
return offcanvas[oj.OffcanvasUtils.MODALITY_KEY] === oj.OffcanvasUtils.MODALITY_MODAL;
};
//Returns whether the drawer is currently open.
oj.OffcanvasUtils._isOpen = function(drawer)
{
return drawer.hasClass(oj.OffcanvasUtils.OPEN_SELECTOR);
};
oj.OffcanvasUtils._getOuterWrapper = function(drawer)
{
return drawer.closest("." + oj.OffcanvasUtils.OUTER_WRAPPER_SELECTOR);
};
//selector
//displayMode
oj.OffcanvasUtils._getAnimateWrapper = function(offcanvas)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
if (oj.OffcanvasUtils._noInnerWrapper(offcanvas) ||
offcanvas[oj.OffcanvasUtils.DISPLAY_MODE_KEY] === oj.OffcanvasUtils.DISPLAY_MODE_OVERLAY) {
return drawer;
}
else {
return drawer.parent();
}
};
oj.OffcanvasUtils._getShiftSelector = function(edge)
{
var selector = oj.OffcanvasUtils._shiftSelector[edge];
if (! selector)
throw "Invalid edge: " + edge;
return selector;
};
oj.OffcanvasUtils._isRTL = function()
{
return oj.DomUtils.getReadingDirection() === "rtl";
};
oj.OffcanvasUtils._setTransform = function(wrapper, transform)
{
wrapper.css({
"-webkit-transform": transform,
"transform": transform
});
};
oj.OffcanvasUtils._getTranslationX = function(edge, width, negate)
{
var minus = (edge === oj.OffcanvasUtils.EDGE_END);
if (oj.OffcanvasUtils._isRTL() || negate)
minus = ! minus;
return "translate3d(" + (minus? "-" : "") + width + ", 0, 0)";
};
oj.OffcanvasUtils._setTranslationX = function(wrapper, edge, width)
{
oj.OffcanvasUtils._setTransform(wrapper, oj.OffcanvasUtils._getTranslationX(edge, width, false));
};
oj.OffcanvasUtils._getTranslationY = function(edge, height)
{
var minus = (edge === oj.OffcanvasUtils.EDGE_BOTTOM) ? "-" : "";
return "translate3d(0, " + minus + height + ", 0)";
};
oj.OffcanvasUtils._setTranslationY = function(wrapper, edge, height)
{
oj.OffcanvasUtils._setTransform(wrapper, oj.OffcanvasUtils._getTranslationY(edge, height));
};
oj.OffcanvasUtils._getTranslationY2 = function(height, negate)
{
var minus = negate ? "-" : "";
return "translate3d(0, " + minus + height + ", 0)";
};
oj.OffcanvasUtils._setAnimateClass = function(offcanvas, drawer, $main,
dtranslation, mtranslation)
{
drawer.addClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
oj.OffcanvasUtils._setTransform(drawer, dtranslation);
$main.addClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
oj.OffcanvasUtils._setTransform($main, mtranslation);
};
oj.OffcanvasUtils._saveEdge = function(offcanvas)
{
var edge = offcanvas["edge"];
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
if (! edge || ! edge.length)
{
if (drawer.hasClass("oj-offcanvas-start"))
edge = oj.OffcanvasUtils.EDGE_START;
else if (drawer.hasClass("oj-offcanvas-end"))
edge = oj.OffcanvasUtils.EDGE_END;
else if (drawer.hasClass("oj-offcanvas-top"))
edge = oj.OffcanvasUtils.EDGE_TOP;
else if (drawer.hasClass("oj-offcanvas-bottom"))
edge = oj.OffcanvasUtils.EDGE_BOTTOM;
//default to start edge
else
edge = oj.OffcanvasUtils.EDGE_START;
}
$.data(drawer[0], oj.OffcanvasUtils._DATA_EDGE_KEY, edge);
return edge;
};
oj.OffcanvasUtils._getEdge = function(drawer)
{
return $.data(drawer[0], oj.OffcanvasUtils._DATA_EDGE_KEY);
};
//This method is called right before open and after close animation
//selector
//edge
//displayMode
oj.OffcanvasUtils._toggleClass = function(offcanvas, wrapper, isOpen)
{
var displayMode = offcanvas[oj.OffcanvasUtils.DISPLAY_MODE_KEY],
drawer = oj.OffcanvasUtils._getDrawer(offcanvas),
drawerClass = oj.OffcanvasUtils.OPEN_SELECTOR,
wrapperClass = (displayMode === oj.OffcanvasUtils.DISPLAY_MODE_OVERLAY) ?
oj.OffcanvasUtils.TRANSITION_SELECTOR + " oj-offcanvas-overlay" :
oj.OffcanvasUtils.TRANSITION_SELECTOR;
//toggle offcanvas and inner wrapper classes
if (isOpen)
{
drawer.addClass(drawerClass);
wrapper.addClass(wrapperClass);
}
else
{
//remove oj-focus-highlight
if (offcanvas["makeFocusable"]) {
oj.DomUtils.makeFocusable({
'element': drawer,
'remove': true
});
}
//restore the original tabindex
var oTabIndex = offcanvas["tabindex"];
if (oTabIndex === undefined)
drawer.removeAttr("tabindex");
else
drawer.attr("tabindex", oTabIndex);
drawer.removeClass(drawerClass);
wrapper.removeClass(wrapperClass);
}
};
// Focus is automatically moved to the first item that matches the following:
// The first element within the offcanvas with the autofocus attribute
// The first :tabbable element inside the offcanvas
// The offcanvas itself
oj.OffcanvasUtils._setFocus = function(offcanvas)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas),
focusables = drawer.find("[autofocus]"),
focusNode;
if (focusables.length == 0) {
focusables = drawer.find(":tabbable");
}
if (focusables.length == 0) {
var oTabIndex = drawer.attr("tabindex");
if (oTabIndex !== undefined)
{
//save the original tabindex
offcanvas["tabindex"] = oTabIndex;
}
// set tabIndex so the div is focusable
drawer.attr("tabindex", "-1");
focusNode = drawer;
oj.DomUtils.makeFocusable({
'element': drawer,
'applyHighlight': true
});
offcanvas["makeFocusable"] = true;
}
else {
focusNode = focusables[0];
}
oj.FocusUtils.focusElement(focusNode);
};
oj.OffcanvasUtils._isAutoDismiss = function(offcanvas)
{
return offcanvas["autoDismiss"] != "none";
};
oj.OffcanvasUtils._onTransitionEnd = function(target, handler)
{
var endEvents = "transitionend.oc webkitTransitionEnd.oc otransitionend.oc oTransitionEnd.oc";
var listener =
function ()
{
handler(target);
//remove handler
target.off(endEvents, listener);
};
//add transition end listener
target.on(endEvents, listener);
};
oj.OffcanvasUtils._closeWithCatch = function(offcanvas)
{
// - offcanvas: error occurs when you veto the ojbeforeclose event
oj.OffcanvasUtils.close(offcanvas)['catch'](function(reason) {
oj.Logger.warn("Offcancas close failed: " + reason);
});
};
//check offcanvas.autoDismiss
//update offcanvas.dismisHandler
oj.OffcanvasUtils._registerCloseHandler = function(offcanvas)
{
//unregister the old handler if exists
oj.OffcanvasUtils._unregisterCloseHandler(offcanvas);
if (oj.OffcanvasUtils._isAutoDismiss(offcanvas))
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
//save dismisHandler
var dismisHandler = offcanvas[oj.OffcanvasUtils.DISMISS_HANDLER_KEY] =
function(event)
{
var target = event.target;
// Ignore mouse events on the scrollbar. FF and Chrome, raises focus events on the
// scroll container too.
if (oj.DomUtils.isChromeEvent(event) ||
("focus" === event.type && !$(target).is(":focusable")))
return;
var key = $.data(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY);
if (key == null)
{
// offcanvas already destroyed, unregister the handler
oj.OffcanvasUtils._unregisterCloseHandler(offcanvas);
return;
}
// if event target is not the offcanvas dom subtrees, dismiss it
if (! oj.DomUtils.isLogicalAncestorOrSelf(drawer[0], target))
{
oj.OffcanvasUtils._closeWithCatch(offcanvas);
}
};
var documentElement = document.documentElement;
if (oj.DomUtils.isTouchSupported())
documentElement.addEventListener("touchstart", dismisHandler, true);
documentElement.addEventListener("mousedown", dismisHandler, true);
documentElement.addEventListener("focus", dismisHandler, true);
}
//register swipe handler
oj.OffcanvasUtils._registerSwipeHandler(offcanvas);
};
//check offcanvas.autoDismiss
//update offcanvas.dismisHandler
oj.OffcanvasUtils._unregisterCloseHandler = function(offcanvas)
{
var dismisHandler = offcanvas[oj.OffcanvasUtils.DISMISS_HANDLER_KEY];
if (dismisHandler) {
var documentElement = document.documentElement;
if (oj.DomUtils.isTouchSupported())
documentElement.removeEventListener("touchstart", dismisHandler, true);
documentElement.removeEventListener("mousedown", dismisHandler, true);
documentElement.removeEventListener("focus", dismisHandler, true);
delete offcanvas[oj.OffcanvasUtils.DISMISS_HANDLER_KEY];
offcanvas[oj.OffcanvasUtils.DISMISS_HANDLER_KEY] = null;
}
//unregister swipe handler
oj.OffcanvasUtils._unregisterSwipeHandler(offcanvas);
};
oj.OffcanvasUtils._registerSwipeHandler = function(offcanvas)
{
if (oj.DomUtils.isTouchSupported())
{
var selector = offcanvas[oj.OffcanvasUtils.SELECTOR_KEY],
drawer = $(selector),
edge = oj.OffcanvasUtils._getEdge(drawer),
swipeEvent,
options,
drawerHammer;
if ((edge === oj.OffcanvasUtils.EDGE_START && ! oj.OffcanvasUtils._isRTL()) ||
(edge === oj.OffcanvasUtils.EDGE_END && oj.OffcanvasUtils._isRTL()))
{
options = {
"recognizers": [
[Hammer.Swipe, {"direction": Hammer["DIRECTION_LEFT"]}]
]};
swipeEvent = "swipeleft";
}
else if ((edge === oj.OffcanvasUtils.EDGE_START && oj.OffcanvasUtils._isRTL()) ||
(edge === oj.OffcanvasUtils.EDGE_END && ! oj.OffcanvasUtils._isRTL()))
{
options = {
"recognizers": [
[Hammer.Swipe, {"direction": Hammer["DIRECTION_RIGHT"]}]
]};
swipeEvent = "swiperight";
}
else if (edge === oj.OffcanvasUtils.EDGE_TOP)
{
options = {
"recognizers": [
[Hammer.Swipe, {"direction": Hammer["DIRECTION_UP"]}]
]};
swipeEvent = "swipeup";
}
else if (edge === oj.OffcanvasUtils.EDGE_BOTTOM)
{
options = {
"recognizers": [
[Hammer.Swipe, {"direction": Hammer["DIRECTION_DOWN"]}]
]};
swipeEvent = "swipedown";
}
drawerHammer = drawer
.ojHammer(options)
.on(swipeEvent, function(event)
{
if (event.target === drawer[0]) {
event.preventDefault();
oj.OffcanvasUtils._closeWithCatch(offcanvas);
}
});
//keep the hammer in the offcanvas jquery data
$.data($(selector)[0], oj.OffcanvasUtils._DATA_HAMMER_KEY,
{"event": swipeEvent,
"hammer": drawerHammer
});
}
};
oj.OffcanvasUtils._unregisterSwipeHandler = function(offcanvas)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
if (drawer.length > 0)
{
var dHammer = $.data(drawer[0], oj.OffcanvasUtils._DATA_HAMMER_KEY);
if (dHammer)
{
dHammer["hammer"].off(dHammer["event"]);
}
}
};
oj.OffcanvasUtils._isFixed = function(drawer)
{
return oj.OffcanvasUtils._getOuterWrapper(drawer).hasClass("oj-offcanvas-page");
};
oj.OffcanvasUtils._isPin = function(offcanvas)
{
return (offcanvas[oj.OffcanvasUtils.DISPLAY_MODE_KEY] === oj.OffcanvasUtils.DISPLAY_MODE_PIN);
};
oj.OffcanvasUtils._noInnerWrapper = function(offcanvas)
{
return (offcanvas[oj.OffcanvasUtils.CONTENT_KEY] ||
oj.OffcanvasUtils._isFixed(oj.OffcanvasUtils._getDrawer(offcanvas)) ||
oj.OffcanvasUtils._isPin(offcanvas))
};
oj.OffcanvasUtils._saveStyles = function(drawer)
{
var style = drawer.attr("style");
if (style !== undefined)
$.data(drawer[0], oj.OffcanvasUtils._DATA_STYLE_KEY, style);
};
oj.OffcanvasUtils._restoreStyles = function(drawer)
{
var style = $.data(drawer[0], oj.OffcanvasUtils._DATA_STYLE_KEY);
if (style)
drawer.attr("style", style);
else
drawer.removeAttr("style");
};
oj.OffcanvasUtils._toggleOuterWrapper = function(offcanvas, drawer, test)
{
var edge = oj.OffcanvasUtils._getEdge(drawer),
shiftSelector = oj.OffcanvasUtils._getShiftSelector(edge),
outerWrapper = oj.OffcanvasUtils._getOuterWrapper(drawer);
oj.Assert.assertPrototype(outerWrapper, jQuery);
var isOpen = outerWrapper.hasClass(shiftSelector);
if (! test) {
outerWrapper.toggleClass(shiftSelector, ! isOpen);
}
return isOpen;
};
oj.OffcanvasUtils._detachDetector = function(target, endHandler)
{
var rafId = 0;
//request animation frame in case the transition end get lost.
//for example: if offcanvas is hidden before transition end
var checkDetachedHandler = function()
{
var offsetParent = ($(target).css("position") === "fixed") ?
target.parentNode.offsetParent : target.offsetParent;
//if offcanvas is detached, ex: parent display:none
if (offsetParent == null)
endHandler();
else
rafId = window.requestAnimationFrame(checkDetachedHandler);
};
rafId = window.requestAnimationFrame(checkDetachedHandler);
return function()
{
if (rafId !== 0)
window.cancelAnimationFrame(rafId);
};
};
oj.OffcanvasUtils._afterCloseHandler = function(offcanvas)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
var isPin = oj.OffcanvasUtils._isPin(offcanvas);
//validate offcanvas
var curOffcanvas = $.data(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY);
if (curOffcanvas !== offcanvas)
return;
var edge = oj.OffcanvasUtils._getEdge(drawer),
wrapper = oj.OffcanvasUtils._getAnimateWrapper(offcanvas);
//After animation, set display:none and remove transition class
if (isPin) {
drawer.removeClass(oj.OffcanvasUtils.OPEN_SELECTOR + " " +
oj.OffcanvasUtils.PIN_TRANSITION_SELECTOR);
}
else {
oj.OffcanvasUtils._toggleClass(offcanvas, wrapper, false);
}
//Remove the glassPane if offcanvas is modal
oj.OffcanvasUtils._removeModality(offcanvas, drawer);
//unregister dismiss handler
oj.OffcanvasUtils._unregisterCloseHandler(offcanvas);
if (isPin) {
oj.OffcanvasUtils._getOuterWrapper(drawer).removeClass(oj.OffcanvasUtils.PIN_WRAPPER_SELECTOR);
oj.OffcanvasUtils._restoreStyles(drawer);
}
//fire after close event
drawer.trigger("ojclose", offcanvas);
//remove data associate with the offcanvas
$.removeData(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY);
};
//Set whether the offcanvas is fixed inside the viewport
oj.OffcanvasUtils._setVisible = function(selector, visible, edge)
{
var drawer = $(selector);
visible = !! visible;
//close the offcanvas without animation if it's open
if (visible && oj.OffcanvasUtils._isOpen(drawer)) {
//hide offcanvas without animation
oj.OffcanvasUtils._close(selector, false);
}
//toggle "oj-offcanvas-" + edge class
drawer.toggleClass(oj.OffcanvasUtils._drawerSelector[edge], ! visible);
};
/**
* Setup offcanvas for the responsive layout.
* This method adds a listener based on the media query specified in offcanvas.query.
* When the media query matches the listener is called and offcanvas behavior is removed.
* When the media query does not match the listener is called and off canvas behavior is added.
*
* @export
* @param {Object} offcanvas An Object contains the properties in the following table.
* @property {string} offcanvas.selector JQ selector identifying the offcanvas
* @property {string} offcanvas.edge the edge of the offcanvas, valid values are start, end, top, bottom. This property is optional if the offcanvas element has a "oj-offcanvas-" + <edge> class specified.
* @property {string} offcanvas.query the media query determine when the offcanvas is fixed inside the viewport.
*
* @see #tearDownResponsive
*
* @example <caption>Setup the offcanvas:</caption>
* var offcanvas = {
* "selector": "#startDrawer",
* "edge": "start",
* "query": oj.ResponsiveUtils.getFrameworkQuery(oj.ResponsiveUtils.FRAMEWORK_QUERY_KEY.LG_UP)
* };
*
* oj.OffcanvasUtils.setupResponsive(offcanvas);
*
*/
oj.OffcanvasUtils.setupResponsive = function(offcanvas)
{
var mqs = offcanvas["query"];
if (mqs !== null)
{
var selector = offcanvas[oj.OffcanvasUtils.SELECTOR_KEY],
query = window.matchMedia(mqs);
//save the edge
var edge = oj.OffcanvasUtils._saveEdge(offcanvas);
var mqListener = function(event)
{
//when event.matches=true fix the offcanvas inside the visible viewport.
oj.OffcanvasUtils._setVisible(selector, event.matches, edge);
}
query.addListener(mqListener);
oj.OffcanvasUtils._setVisible(selector, query.matches, edge);
//keep the listener in the offcanvas jquery data
$.data($(selector)[0], oj.OffcanvasUtils._DATA_MEDIA_QUERY_KEY,
{"mqList": query,
"mqListener": mqListener
});
}
};
/**
* Removes the listener that was added in setupResponsive. Page authors should call tearDownResponsive when the offcanvas is no longer needed.
*
* @export
* @param {Object} offcanvas An Object contains the properties in the following table.
* @property {string} offcanvas.selector JQ selector identifying the offcanvas
* @see #setupResponsive
*
* @example <caption>TearDown the offcanvas:</caption>
* var offcanvas = {
* "selector": "#startDrawer"
* };
*
* oj.OffcanvasUtils.tearDownResponsive(offcanvas);
*
*/
oj.OffcanvasUtils.tearDownResponsive = function(offcanvas)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
var mql = $.data(drawer[0], oj.OffcanvasUtils._DATA_MEDIA_QUERY_KEY);
if (mql)
{
mql["mqList"].removeListener(mql["mqListener"]);
$.removeData(drawer[0], oj.OffcanvasUtils._DATA_MEDIA_QUERY_KEY);
}
};
oj.OffcanvasUtils._openPush = function(offcanvas, resolve, reject, edge)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
var $main = $(offcanvas[oj.OffcanvasUtils.CONTENT_KEY]);
oj.Assert.assertPrototype($main, jQuery);
//since drawer and main are animated seperately,
//only resolve true when both transitions are ended
var pending = true;
var size = offcanvas["size"];
var translation;
//set display block to get size of offcanvas
drawer.addClass(oj.OffcanvasUtils.OPEN_SELECTOR);
//set translationX or Y
window.setTimeout(function () {
//if size is not specified, outerWidth/outerHeight is used
if (edge === oj.OffcanvasUtils.EDGE_START || edge === oj.OffcanvasUtils.EDGE_END) {
if (size === undefined)
size = drawer.outerWidth(true) + "px";
oj.OffcanvasUtils._setTransform(drawer,
oj.OffcanvasUtils._getTranslationX(edge, size, true));
translation = oj.OffcanvasUtils._getTranslationX(edge, size, false);
}
else {
if (size === undefined)
size = drawer.outerHeight(true) + "px";
oj.OffcanvasUtils._setTransform(drawer,
oj.OffcanvasUtils._getTranslationY2(size, edge === oj.OffcanvasUtils.EDGE_TOP));
translation = oj.OffcanvasUtils._getTranslationY2(size, edge !== oj.OffcanvasUtils.EDGE_TOP);
}
//before animation
window.setTimeout(function () {
//add transition class
oj.OffcanvasUtils._setAnimateClass(offcanvas, drawer, $main,
"translate3d(0, 0, 0)", translation);
oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, false);
}, 0); //before animation
}, 0); //set translationX or Y
//insert a glassPane if offcanvas is modal
oj.OffcanvasUtils._applyModality(offcanvas, drawer);
//transition end handler
var endHandler = function ($elem)
{
//After animation, remove transition class
$elem.removeClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
if (pending) {
pending = false;
}
else {
// - opening offcanvas automatically scrolls to the top
oj.OffcanvasUtils._setFocus(offcanvas);
//fire after open event
drawer.trigger("ojopen", offcanvas);
// - push and overlay demos don't work in ie11
//register dismiss handler as late as possible because IE raises focus event
//on the launcher that will close the offcanvas if autoDismiss is true
oj.OffcanvasUtils._registerCloseHandler(offcanvas);
resolve(true);
}
};
//add transition end listener
oj.OffcanvasUtils._onTransitionEnd($main, endHandler);
oj.OffcanvasUtils._onTransitionEnd(drawer, endHandler);
};
oj.OffcanvasUtils._openOverlay = function(offcanvas, resolve, reject, edge)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
//Before animation, remove display:none and add transition class
oj.OffcanvasUtils._toggleClass(offcanvas, drawer, true);
var size = offcanvas["size"];
if (size) {
if (edge === oj.OffcanvasUtils.EDGE_START || edge === oj.OffcanvasUtils.EDGE_END) {
oj.OffcanvasUtils._setTransform(drawer,
oj.OffcanvasUtils._getTranslationX(edge, size, true));
}
else {
oj.OffcanvasUtils._setTransform(drawer,
oj.OffcanvasUtils._getTranslationY(edge, size));
}
}
//show the drawer
window.setTimeout(function ()
{
oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, false);
}, 10); //chrome is fine with 0ms but FF needs ~10ms or it wont animate
//insert a glassPane if offcanvas is modal
oj.OffcanvasUtils._applyModality(offcanvas, drawer);
//add transition end listener
oj.OffcanvasUtils._onTransitionEnd(drawer,
function () {
//After animation, remove transition class
drawer.removeClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
// - opening offcanvas automatically scrolls to the top
oj.OffcanvasUtils._setFocus(offcanvas);
//fire after open event
drawer.trigger("ojopen", offcanvas);
// - push and overlay demos don't work in ie11
//register dismiss handler as late as possible because IE raises focus event
//on the launcher that will close the offcanvas if autoDismiss is true
oj.OffcanvasUtils._registerCloseHandler(offcanvas);
resolve(true);
});
};
oj.OffcanvasUtils._openPin = function(offcanvas, resolve, reject, edge)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
var $main = $(offcanvas[oj.OffcanvasUtils.CONTENT_KEY]);
oj.Assert.assertPrototype($main, jQuery);
var size = offcanvas["size"];
//set display block to get size of offcanvas
drawer.addClass(oj.OffcanvasUtils.OPEN_SELECTOR);
//set translationX
window.setTimeout(function () {
//if size is not specified, outerWidth is used
if (size === undefined)
size = drawer.outerWidth(true) + "px";
drawer.addClass(oj.OffcanvasUtils.PIN_TRANSITION_SELECTOR);
//make the outer wrapper a flex layout
oj.OffcanvasUtils._getOuterWrapper(drawer).addClass(oj.OffcanvasUtils.PIN_WRAPPER_SELECTOR);
oj.OffcanvasUtils._saveStyles(drawer);
//clear transform only work if set style
oj.OffcanvasUtils._setTransform(drawer, "none");
//animate on min-width
window.setTimeout(function () {
drawer.css("min-width", size);
oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, false);
}, 10);
}, 0); //set translationX
//insert a glassPane if offcanvas is modal
oj.OffcanvasUtils._applyModality(offcanvas, drawer);
//add transition end listener
oj.OffcanvasUtils._onTransitionEnd(drawer,
function () {
//After animation, remove transition class
// drawer.removeClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
// - opening offcanvas automatically scrolls to the top
oj.OffcanvasUtils._setFocus(offcanvas);
//fire after open event
drawer.trigger("ojopen", offcanvas);
// - push and overlay demos don't work in ie11
//register dismiss handler as late as possible because IE raises focus event
//on the launcher that will close the offcanvas if autoDismiss is true
oj.OffcanvasUtils._registerCloseHandler(offcanvas);
resolve(true);
});
};
oj.OffcanvasUtils._closePush = function(offcanvas, resolve, reject, drawer, animation)
{
var $main = $(offcanvas[oj.OffcanvasUtils.CONTENT_KEY]);
var pending = true;
// - issue in ojoffcanvas when used inside ojtabs
var cancelDetector;
var endHandler = function ($target)
{
//If this is called from the detach detector, dont check for pending
if (pending && $target) {
pending = false;
}
else {
//clear transform translation on $main
$main.removeClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
oj.OffcanvasUtils._setTransform($main, "");
oj.OffcanvasUtils._afterCloseHandler(offcanvas);
if (cancelDetector)
cancelDetector();
resolve(true);
}
};
if (animation)
{
//add transition end listener
oj.OffcanvasUtils._onTransitionEnd(drawer, endHandler);
oj.OffcanvasUtils._onTransitionEnd($main, endHandler);
//add detach detector
cancelDetector = oj.OffcanvasUtils._detachDetector(drawer[0], endHandler);
}
//clear transform
oj.OffcanvasUtils._setTransform(drawer, "");
oj.OffcanvasUtils._setTransform($main, "");
oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, false);
//dim glassPane
if (oj.OffcanvasUtils._isModal(offcanvas))
offcanvas[oj.OffcanvasUtils.GLASS_PANE_KEY].removeClass(oj.OffcanvasUtils.GLASSPANE_DIM_SELECTOR);
if (animation) {
//Before animation, add transition class
$main.addClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
drawer.addClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
}
else {
oj.OffcanvasUtils._afterCloseHandler(offcanvas);
resolve(true);
}
};
oj.OffcanvasUtils._closeOverlay = function(offcanvas, resolve, reject, drawer, animation)
{
var cancelDetector;
var endHandler = function ()
{
oj.OffcanvasUtils._afterCloseHandler(offcanvas);
if (cancelDetector)
cancelDetector();
resolve(true);
};
if (animation)
{
//add transition end listener
oj.OffcanvasUtils._onTransitionEnd(drawer, endHandler);
//add detach detector
cancelDetector = oj.OffcanvasUtils._detachDetector(drawer[0], endHandler);
}
//clear transform
oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, false);
//dim glassPane
if (oj.OffcanvasUtils._isModal(offcanvas))
offcanvas[oj.OffcanvasUtils.GLASS_PANE_KEY].removeClass(oj.OffcanvasUtils.GLASSPANE_DIM_SELECTOR);
if (animation) {
drawer.addClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
}
else {
oj.OffcanvasUtils._afterCloseHandler(offcanvas);
resolve(true);
}
};
oj.OffcanvasUtils._openOldDrawer = function(offcanvas, resolve, reject, edge, displayMode)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
var wrapper = oj.OffcanvasUtils._getAnimateWrapper(offcanvas);
oj.Assert.assertPrototype(wrapper, jQuery);
//Before animation, remove display:none and add transition class
oj.OffcanvasUtils._toggleClass(offcanvas, wrapper, true);
var size;
if (edge === oj.OffcanvasUtils.EDGE_START || edge === oj.OffcanvasUtils.EDGE_END)
{
//if size is missing, outerWidth is used
size = (size === undefined) ? (drawer.outerWidth(true) + "px") : size;
//don't set transform for oj.OffcanvasUtils.DISPLAY_MODE_OVERLAY
if (displayMode === oj.OffcanvasUtils.DISPLAY_MODE_PUSH)
oj.OffcanvasUtils._setTranslationX(wrapper, edge, size);
}
else
{
//if size is missing, outerHeight is used
size = (size === undefined) ? (drawer.outerHeight(true) + "px") : size;
//don't set transform for oj.OffcanvasUtils.DISPLAY_MODE_OVERLAY
if (displayMode === oj.OffcanvasUtils.DISPLAY_MODE_PUSH)
oj.OffcanvasUtils._setTranslationY(wrapper, edge, size);
}
//show the drawer
window.setTimeout(function ()
{
oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, false);
}, 10); //chrome is fine with 0ms but FF needs ~10ms or it wont animate
//insert a glassPane if offcanvas is modal
oj.OffcanvasUtils._applyModality(offcanvas, drawer);
//add transition end listener
oj.OffcanvasUtils._onTransitionEnd(wrapper,
function () {
//After animation, remove transition class
wrapper.removeClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
// - opening offcanvas automatically scrolls to the top
oj.OffcanvasUtils._setFocus(offcanvas);
//fire after open event
drawer.trigger("ojopen", offcanvas);
// - push and overlay demos don't work in ie11
//register dismiss handler as late as possible because IE raises focus event
//on the launcher that will close the offcanvas if autoDismiss is true
oj.OffcanvasUtils._registerCloseHandler(offcanvas);
resolve(true);
});
};
oj.OffcanvasUtils._closePin = function(offcanvas, resolve, reject, drawer, animation)
{
var cancelDetector;
var endHandler = function ()
{
oj.OffcanvasUtils._afterCloseHandler(offcanvas);
if (cancelDetector)
cancelDetector();
resolve(true);
};
if (animation)
{
//add transition end listener
oj.OffcanvasUtils._onTransitionEnd(drawer, endHandler);
//add detach detector
cancelDetector = oj.OffcanvasUtils._detachDetector(drawer[0], endHandler);
}
//clear transform
oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, false);
//dim glassPane
if (oj.OffcanvasUtils._isModal(offcanvas))
offcanvas[oj.OffcanvasUtils.GLASS_PANE_KEY].removeClass(oj.OffcanvasUtils.GLASSPANE_DIM_SELECTOR);
if (animation) {
//Before animation, add transition class
drawer.css("min-width", "0");
}
else {
oj.OffcanvasUtils._afterCloseHandler(offcanvas);
resolve(true);
}
};
oj.OffcanvasUtils._closeOldDrawer = function(offcanvas, resolve, reject, drawer, animation)
{
var displayMode = offcanvas[oj.OffcanvasUtils.DISPLAY_MODE_KEY],
wrapper = oj.OffcanvasUtils._getAnimateWrapper(offcanvas);
var cancelDetector;
var endHandler = function ()
{
oj.OffcanvasUtils._afterCloseHandler(offcanvas);
if (cancelDetector)
cancelDetector();
resolve(true);
};
if (animation)
{
//add transition end listener
oj.OffcanvasUtils._onTransitionEnd(wrapper, endHandler);
//add detach detector
cancelDetector = oj.OffcanvasUtils._detachDetector(drawer[0], endHandler);
}
//clear transform
if (displayMode === oj.OffcanvasUtils.DISPLAY_MODE_PUSH) {
oj.OffcanvasUtils._setTransform(wrapper, "");
}
oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, false);
//dim glassPane
if (oj.OffcanvasUtils._isModal(offcanvas))
offcanvas[oj.OffcanvasUtils.GLASS_PANE_KEY].removeClass(oj.OffcanvasUtils.GLASSPANE_DIM_SELECTOR);
if (animation) {
//Before animation, add transition class
wrapper.addClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
}
else {
oj.OffcanvasUtils._afterCloseHandler(offcanvas);
resolve(true);
}
};
/**
* Shows the offcanvas by sliding it into the viewport. This method fire an ojbeforeopen event which can be vetoed by attaching a listener and returning false. If the open is not vetoed, this method will fire an ojopen event once animation has completed.
*
*<p>Upon opening a offcanvas, focus is automatically moved to the first item that matches the following:</p>
*<ol>
* <li>The first element within the offcanvas with the <code>autofocus</code> attribute</li>
* <li>The first <code>:tabbable</code> element inside the offcanvas</li>
* <li>The offcanvas itself</li>
*</ol>
*
* @export
* @param {Object} offcanvas An Object contains the properties in the following table.
* @property {string} offcanvas.selector JQ selector identifying the offcanvas.
* @property {string} offcanvas.content JQ selector identifying the main content.
* @property {string} offcanvas.edge the edge of the offcanvas, valid values are start, end, top, bottom. This property is optional if the offcanvas element has a "oj-offcanvas-" + <edge> class specified.
* @property {string} offcanvas.displayMode how to show the offcanvas, valid values are push or overlay. Default: defined by theme.
* @property {string} offcanvas.autoDismiss close behavior, valid values are focusLoss and none. If autoDismiss is default(focusLoss) then any click outside the offcanvas will close it.
* @property {string} offcanvas.size size width or height of the offcanvas: width if edge is start or end and height if edge is to and bottom. Default to the computed width or height of the offcanvas.
* @property {string} offcanvas.modality The modality of the offcanvas. Valid values are modal and modeless. Default: modeless. If the offcanvas is modal, interaction with the main content area is disabled like in a modal dialog.
* @returns {Promise} A promise that is resolved when all transitions have completed. The promise is rejected if the ojbeforeopen event is vetoed.
* @see #close
* @see #toggle
*
* @example <caption>Slide the offcanvas into the viewport:</caption>
* var offcanvas = {
* "selector": "#startDrawer",
* "content": "#mainContent",
* "edge": "start",
* "displayMode": "push",
* "size": "200px"
* };
*
* oj.OffcanvasUtils.open(offcanvas);
*
*/
oj.OffcanvasUtils.open = function(offcanvas)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
var oldOffcanvas = $.data(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY);
if (oldOffcanvas) {
//if we are in the middle of closing, then return the previous saved promise
if (oldOffcanvas[oj.OffcanvasUtils.CLOSE_PROMISE_KEY])
return oldOffcanvas[oj.OffcanvasUtils.CLOSE_PROMISE_KEY];
//if we are in the middle of opening, then return the previous saved promise
if (oldOffcanvas[oj.OffcanvasUtils.OPEN_PROMISE_KEY])
return oldOffcanvas[oj.OffcanvasUtils.OPEN_PROMISE_KEY];
}
var veto = false;
var promise = new Promise(function(resolve, reject)
{
oj.Assert.assertPrototype(drawer, jQuery);
//save the edge
var edge = oj.OffcanvasUtils._saveEdge(offcanvas);
//fire before open event
var event = $.Event("ojbeforeopen");
drawer.trigger(event, offcanvas);
if (event.result === false)
{
reject(oj.OffcanvasUtils.VETO_BEFOREOPEN_MSG);
veto = true;
return promise;
}
var displayMode = oj.OffcanvasUtils._getDisplayMode(offcanvas);
var isPin = oj.OffcanvasUtils._isPin(offcanvas);
//only support horizontal offcanvas for pin
if (isPin && (edge === oj.OffcanvasUtils.EDGE_TOP || edge === oj.OffcanvasUtils.EDGE_BOTTOM))
displayMode = oj.OffcanvasUtils.DISPLAY_MODE_PUSH;
//save a copy of offcanvas object in offcanvas jquery data
var myOffcanvas = $.extend({}, offcanvas);
myOffcanvas[oj.OffcanvasUtils.DISPLAY_MODE_KEY] = displayMode;
$.data(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY, myOffcanvas);
//throw an error if CONTENT_KEY is specified and the html markup contains an inner wrapper.
if (offcanvas[oj.OffcanvasUtils.CONTENT_KEY]) {
if (! oj.OffcanvasUtils._noInnerWrapper(offcanvas))
throw "Error: Both main content selector and the inner wrapper <div class='oj-offcanvas-inner-wrapper'> are provided. Please remove the inner wrapper.";
if (isPin) {
oj.OffcanvasUtils._openPin(myOffcanvas, resolve, reject, edge);
}
else if (displayMode === oj.OffcanvasUtils.DISPLAY_MODE_PUSH) {
oj.OffcanvasUtils._openPush(myOffcanvas, resolve, reject, edge);
}
else {
oj.OffcanvasUtils._openOverlay(myOffcanvas, resolve, reject, edge);
}
}
else {
oj.OffcanvasUtils._openOldDrawer(myOffcanvas, resolve, reject, edge, displayMode);
}
});
//save away the current promise
if (! veto) {
var nOffcanvas = $.data(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY);
if (nOffcanvas) {
nOffcanvas[oj.OffcanvasUtils.OPEN_PROMISE_KEY] = promise;
}
}
return promise;
};
/**
* Hides the offcanvas by sliding it out of the viewport. This method fires an ojbeforeclose event which can be vetoed by attaching a listener and returning false. If the close is not vetoed, this method will fire an ojclose event once animation has completed.
*
* @export
* @param {Object} offcanvas An Object contains the properties in the following table.
* @property {string} offcanvas.selector JQ selector identifying the offcanvas
*
* @returns {Promise} A promise that is resolved when all transitions have completed. The promise is rejected if the ojbeforeclose event is vetoed.
* @see #open
* @see #toggle
*
* @example <caption>Slide the offcanvas out of the viewport:</caption>
* var offcanvas = {
* "selector": "#startDrawer"
* };
*
* oj.OffcanvasUtils.close(offcanvas);
*
*/
oj.OffcanvasUtils.close = function(offcanvas)
{
return oj.OffcanvasUtils._close(offcanvas[oj.OffcanvasUtils.SELECTOR_KEY], true);
};
oj.OffcanvasUtils._close = function(selector, animation)
{
var drawer = $(selector);
oj.Assert.assertPrototype(drawer, jQuery);
var offcanvas = $.data(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY);
//if we are in the middle of closing, then return the previous saved promise
if (offcanvas && offcanvas[oj.OffcanvasUtils.CLOSE_PROMISE_KEY]) {
return offcanvas[oj.OffcanvasUtils.CLOSE_PROMISE_KEY];
}
var veto = false;
var promise = new Promise(function(resolve, reject)
{
if (oj.OffcanvasUtils._isOpen(drawer))
{
if (selector != offcanvas[oj.OffcanvasUtils.SELECTOR_KEY])
resolve(true);
//if the outer wrapper doesn't have the correct shift selector, we are done
if (! oj.OffcanvasUtils._toggleOuterWrapper(offcanvas, drawer, true))
resolve(true);
//fire before close event
var event = $.Event("ojbeforeclose");
drawer.trigger(event, offcanvas);
if (event.result === false)
{
reject(oj.OffcanvasUtils.VETO_BEFORECLOSE_MSG);
veto = true;
return promise;
}
var isPin = oj.OffcanvasUtils._isPin(offcanvas);
var displayMode = offcanvas[oj.OffcanvasUtils.DISPLAY_MODE_KEY];
if (offcanvas[oj.OffcanvasUtils.CONTENT_KEY]) {
if (displayMode === oj.OffcanvasUtils.DISPLAY_MODE_PUSH) {
oj.OffcanvasUtils._closePush(offcanvas, resolve, reject, drawer, animation);
}
else if (isPin) {
oj.OffcanvasUtils._closePin(offcanvas, resolve, reject, drawer, animation);
}
else {
oj.OffcanvasUtils._closeOverlay(offcanvas, resolve, reject, drawer, animation);
}
}
else {
oj.OffcanvasUtils._closeOldDrawer(offcanvas, resolve, reject, drawer, animation);
}
}
else {
resolve(true);
}
});
//save away the current promise
if (! veto) {
offcanvas = $.data(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY);
if (offcanvas) {
offcanvas[oj.OffcanvasUtils.CLOSE_PROMISE_KEY] = promise;
}
}
return promise;
};
/**
* Toggles the offcanvas in or out of the viewport. This method simply delegates to the open or close methods as appropriate.
*
* @export
* @param {Object} offcanvas An Object contains the properties in the following table.
* @property {string} offcanvas.selector JQ selector identifying the offcanvas.
* @property {string} offcanvas.content JQ selector identifying the main content.
* @property {string} offcanvas.edge the edge of the offcanvas, valid values are start, end, top, bottom. This property is optional if the offcanvas element has a "oj-offcanvas-" + <edge> class specified.
* @property {string} offcanvas.displayMode how to show the offcanvas, valid values are push or overlay. Default: defined by theme.
* @property {string} offcanvas.autoDismiss close behavior, valid values are focusLoss and none. If autoDismiss is default(focusLoss) then any click outside the offcanvas will close it.
* @property {string} offcanvas.size size width or height of the offcanvas: width if edge is start or end and height if edge is to and bottom. Default to the computed width or height of the offcanvas.
* @property {string} offcanvas.modality The modality of the offcanvas. Valid values are modal and modeless. Default: modeless. If the offcanvas is modal, interaction with the main content area is disabled like in a modal dialog.
* @returns {Promise} A promise that is resolved when all transitions have completed
* @see #open
* @see #close
*
* @example <caption>Toggle the offcanvas in or out of the viewport:</caption>
* var offcanvas = {
* "selector": "#startDrawer",
* "edge": "start",
* "displayMode": "overlay"
* };
*
* oj.OffcanvasUtils.toggle(offcanvas);
*
*/
oj.OffcanvasUtils.toggle = function(offcanvas)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
oj.Assert.assertPrototype(drawer, jQuery);
if (oj.OffcanvasUtils._isOpen(drawer)) {
return oj.OffcanvasUtils.close(offcanvas);
}
else {
return oj.OffcanvasUtils.open(offcanvas);
}
};
/**
* Creates an overlay div with the oj-offcanvas-glasspane selector
* append to the end of the drawer's container
* @param {!jQuery} drawer the drawer
* @return {jQuery} the overlay div
* @private
*/
oj.OffcanvasUtils._addGlassPane = function (drawer)
{
var overlay = $("<div>");
overlay.addClass(oj.OffcanvasUtils.GLASSPANE_SELECTOR);
overlay.attr("role", "presentation");
overlay.attr("aria-hidden", "true");
//append glassPane at the end
overlay.appendTo(drawer.parent()); // @HTMLUpdateOK
overlay.on("keydown keyup keypress mousedown mouseup mouseover mouseout click focusin focus",
function(event)
{
event.stopPropagation();
event.preventDefault();
});
return overlay;
};
/**
* Creates a script element before the target layer bound to the simple jquery UI
* surrogate component.
*
* @param {!jQuery} layer stacking context
* @return {jQuery}
* @private
*/
oj.OffcanvasUtils._createSurrogate = function (layer)
{
var surrogate = $("<script>");
var layerId = layer.attr("id");
var surrogateId;
if (layerId)
{
surrogateId = [layerId, "surrogate"].join("_");
surrogate.attr("id", surrogateId);
}
else
{
surrogateId = surrogate.uniqueId();
}
surrogate.insertBefore(layer); // @HTMLUpdateOK
// loosely associate the popup to the surrogate element
layer.attr(oj.OffcanvasUtils.SURROGATE_ATTR, surrogateId);
return surrogate;
};
/**
* bring the drawer to the front to keep this order: mainContent, glassPane, drawer
* so we don't need to use z-index
* @private
*/
oj.OffcanvasUtils._swapOrder = function (offcanvas, drawer)
{
//create a surrogate in front of the mainContent to be used in _restoreOrder
offcanvas[oj.OffcanvasUtils.SURROGATE_KEY] = oj.OffcanvasUtils._createSurrogate(drawer);
drawer.appendTo(drawer.parent()); // @HTMLUpdateOK
};
/**
* restore the order before _swapOrder
* @private
*/
oj.OffcanvasUtils._restoreOrder = function (offcanvas)
{
var drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
var surrogate = offcanvas[oj.OffcanvasUtils.SURROGATE_KEY];
if (drawer && surrogate &&
drawer.attr(oj.OffcanvasUtils.SURROGATE_ATTR) === surrogate.attr("id"))
{
drawer.insertAfter(surrogate); // @HTMLUpdateOK
// remove link to the surrogate element
drawer.removeAttr(oj.OffcanvasUtils.SURROGATE_ATTR);
surrogate.remove(); // @HTMLUpdateOK
}
};
/**
* Apply modality
* If offcanvas is modal, add a glasspane and keep the dom structure in the following order:
* mainContent, glassPane and drawer so we don't need to apply z-index
* @private
*/
oj.OffcanvasUtils._applyModality = function (offcanvas, drawer)
{
if (oj.OffcanvasUtils._isModal(offcanvas))
{
// insert glassPane in front of the mainContent
offcanvas[oj.OffcanvasUtils.GLASS_PANE_KEY] = oj.OffcanvasUtils._addGlassPane(drawer);
// bring the drawer <div> to the front
// to keep this order: mainContent, glassPane, drawer
oj.OffcanvasUtils._swapOrder(offcanvas, drawer);
window.setTimeout(function ()
{
offcanvas[oj.OffcanvasUtils.GLASS_PANE_KEY].addClass(oj.OffcanvasUtils.GLASSPANE_DIM_SELECTOR);
}, 0);
}
};
/**
* Remove modality
* If offcanvas is modal, remove glasspane and restore the dom element orders
* @private
*/
oj.OffcanvasUtils._removeModality = function (offcanvas, drawer)
{
if (oj.OffcanvasUtils._isModal(offcanvas))
{
offcanvas[oj.OffcanvasUtils.GLASS_PANE_KEY].remove();
// restore the order
oj.OffcanvasUtils._restoreOrder(offcanvas);
}
};
/**
* Setup offcanvas for pan to reveal.
* This method adds a touch listener to handle revealing the offcanvas as user pans on the outer wrapper. The following events are fired by this method:
* ojpanstart - fired when pan to reveal gesture initiated by the user. The event includes the direction and distance of the pan. If it is vetoed
* then pan to reveal is terminated
* ojpanmove - fired as user continues the pan gesture. The event includes the direction and distance of the pan.
* ojpanend - fired when pan to reveal gesture ends. The event includes the direction and distance of the pan. If it is vetoed then the offcanvas
* will be closed.
*
* @export
* @param {Object} offcanvas An Object contains the properties in the following table.
* @property {string} offcanvas.selector JQ selector identifying the offcanvas
* @property {string=} offcanvas.edge the edge of the offcanvas, valid values are start, end. This property is optional if the offcanvas element has a "oj-offcanvas-" + <edge> class specified.
* @property {string=} offcanvas.size size width of the offcanvas. Default to the computed width of the offcanvas.
*
* @see #tearDownPanToReveal
*
* @example <caption>Setup the offcanvas:</caption>
* var offcanvas = {
* "selector": "#startDrawer"
* };
*
* oj.OffcanvasUtils.setupPanToReveal(offcanvas);
*
*/
oj.OffcanvasUtils.setupPanToReveal = function(offcanvas)
{
var drawer, size, outerWrapper, wrapper, mOptions, proceed, direction, ui, evt, delta, edge, endEvents, listener;
if ($(offcanvas).attr("oj-data-pansetup") != null)
{
// already setup
return;
}
// mark as setup
$(offcanvas).attr("oj-data-pansetup", "true");
// pan to reveal only works for push display mode, so enforce it
offcanvas["displayMode"] = "push";
drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
// need the size to display the canvas when release
size = offcanvas["size"];
if (size == null)
{
size = drawer.outerWidth();
}
outerWrapper = oj.OffcanvasUtils._getOuterWrapper(drawer);
wrapper = oj.OffcanvasUtils._getAnimateWrapper(offcanvas);
//use hammer for swipe
mOptions = {
"recognizers": [
[Hammer.Pan, { "direction": Hammer["DIRECTION_HORIZONTAL"] }]
]};
// flag to signal whether pan to reveal should proceed
proceed = false;
$(outerWrapper)
.ojHammer(mOptions)
.on("panstart", function(event)
{
direction = null;
switch (event['gesture']['direction'])
{
case Hammer["DIRECTION_LEFT"]:
// diagonal case
if (Math.abs(event['gesture']['deltaY']) < Math.abs(event['gesture']['deltaX']))
{
direction = oj.OffcanvasUtils._isRTL() ? "end" : "start";
}
break;
case Hammer["DIRECTION_RIGHT"]:
// diagonal case
if (Math.abs(event['gesture']['deltaY']) < Math.abs(event['gesture']['deltaX']))
{
direction = oj.OffcanvasUtils._isRTL() ? "start" : "end";
}
break;
}
if (direction == null)
{
return;
}
ui = {"direction": direction, "distance": Math.abs(event['gesture']['deltaX'])};
evt = $.Event("ojpanstart");
drawer.trigger(evt, ui);
if (!evt.isDefaultPrevented())
{
// make sure it's in closed state
offcanvas["_closePromise"] = null;
// cancel any close animation transition handler
wrapper.off(".oc");
// sets the appropriate offcanvas class
oj.OffcanvasUtils._toggleClass(offcanvas, wrapper, true);
proceed = true;
// stop touch event from bubbling to prevent for example pull to refresh from happening
event['gesture']['srcEvent'].stopPropagation();
// stop bubbling
event.stopPropagation();
}
})
.on("panmove", function(event)
{
// don't do anything if start is vetoed
if (!proceed)
{
return;
}
delta = event['gesture']['deltaX'];
if ((direction == "start" && delta > 0) || (direction == "end" && delta < 0))
{
oj.OffcanvasUtils._setTranslationX(wrapper, "start", "0px");
return;
}
drawer.css("width", Math.abs(delta));
// don't do css transition animation while panning
wrapper.removeClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
oj.OffcanvasUtils._setTranslationX(wrapper, "start", delta+"px");
ui = {"direction": direction, "distance": Math.abs(delta)};
evt = $.Event("ojpanmove");
drawer.trigger(evt, ui);
// stop touch event from bubbling to prevent for example pull to refresh from happening
event['gesture']['srcEvent'].stopPropagation();
// stop bubbling
event.stopPropagation();
})
.on("panend", function(event)
{
// don't do anything if start is vetoed
if (!proceed)
{
return;
}
// reset flag
proceed = false;
delta = Math.abs(event['gesture']['deltaX']);
ui = {"distance": delta};
evt = $.Event("ojpanend");
drawer.trigger(evt, ui);
// stop bubbling
event.stopPropagation();
if (!evt.isDefaultPrevented())
{
edge = offcanvas["edge"];
if (edge == null)
{
if (drawer.hasClass("oj-offcanvas-start"))
{
edge = "start";
}
else
{
edge = "end";
}
}
oj.OffcanvasUtils._animateWrapperAndDrawer(wrapper, drawer, edge, size);
$.data(drawer[0], oj.OffcanvasUtils._DATA_OFFCANVAS_KEY, offcanvas);
$.data(drawer[0], oj.OffcanvasUtils._DATA_EDGE_KEY, edge);
oj.OffcanvasUtils._registerCloseHandler(offcanvas);
return;
}
// close the toolbar
endEvents = "transitionend webkitTransitionEnd otransitionend oTransitionEnd";
listener = function ()
{
// reset offcanvas class
oj.OffcanvasUtils._toggleClass(offcanvas, wrapper, false);
wrapper.removeClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
//remove handler
wrapper.off(endEvents, listener);
};
// add transition end listener
wrapper.on(endEvents, listener);
// restore item position
wrapper.addClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
oj.OffcanvasUtils._setTranslationX(wrapper, "start", "0px");
});
};
// animate both the wrapper and drawer at the same time
oj.OffcanvasUtils._animateWrapperAndDrawer = function(wrapper, drawer, edge, size)
{
var tt = 400, fps = 60, ifps, matrix, values, current, final, reqId, inc, lastFrame, func, currentFrame, adjInc;
// since we can't synchronize two css transitions, we'll have to do the animation ourselves using
// requestAnimationFrame
// make sure wrapper animation is off
wrapper.removeClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
// ideal ms per frame
ifps = Math.round(1000/fps);
matrix = wrapper.css("transform");
values = matrix.split('(')[1].split(')')[0].split(',');
// this is the translateX
current = parseInt(values[4], 10);
// the final size/destination
final = edge == "end" ? 0-size : size;
// calculate the increment needed to complete transition in 400ms with 60fps
inc = Math.max(1, Math.abs(final - current) / (tt / ifps));
lastFrame = (new Date()).getTime();
func = function()
{
currentFrame = (new Date()).getTime();
// see how much we'll need to compensate if fps drops below ideal
adjInc = Math.max(inc, inc * Math.max((currentFrame - lastFrame) / ifps));
lastFrame = currentFrame;
if (current < final)
{
current = Math.min(final, current+adjInc);
}
else if (current > final)
{
current = Math.max(final, current-adjInc);
}
oj.OffcanvasUtils._setTranslationX(wrapper, edge, Math.abs(current)+"px");
drawer.css("width", Math.abs(current)+"px");
// make sure to cancel the animation frame if we are done
if (current == final)
{
window.cancelAnimationFrame(reqId);
wrapper.addClass(oj.OffcanvasUtils.TRANSITION_SELECTOR);
}
else
{
reqId = window.requestAnimationFrame(func);
}
};
reqId = window.requestAnimationFrame(func);
};
/**
* Removes the listener that was added in setupPanToReveal. Page authors should call tearDownPanToReveal when the offcanvas is no longer needed.
*
* @export
* @param {Object} offcanvas An Object contains the properties in the following table.
* @property {string} offcanvas.selector JQ selector identifying the offcanvas
* @see #setupPanToReveal
*
* @example <caption>TearDown the offcanvas:</caption>
* var offcanvas = {
* "selector": "#startDrawer"
* };
*
* oj.OffcanvasUtils.tearDownPanToReveal(offcanvas);
*
*/
oj.OffcanvasUtils.tearDownPanToReveal = function(offcanvas)
{
var drawer, outerWrapper;
drawer = oj.OffcanvasUtils._getDrawer(offcanvas);
outerWrapper = oj.OffcanvasUtils._getOuterWrapper(drawer);
// remove all listeners
$(outerWrapper).off("panstart panmove panend");
};
});
|
import React from 'react';
import './footer.scss';
const Footer = () => (
<div className="Footer">
<hr />
<div className="container">
<div className="col-md-2 offset-md-1 ">
<a className="Footer__Column" href="/terms-of-use">Terms of Use</a>
</div>
<div className="col-md-2">
<a className="Footer__Column" href="/privacy">Privacy Policy</a>
</div>
<div className="col-md-2" />
<div className="col-md-2">
<a className="Footer__Column" href="/">Help</a>
</div>
<div className="col-md-2">
<a className="Footer__Column" href="mailto:papernet@bobi.space">Contact us</a>
</div>
</div>
</div>
);
export default Footer;
|
/**
* Copyright 2015 Telerik AD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
(function(f, define){
define([], f);
})(function(){
(function( window, undefined ) {
var kendo = window.kendo || (window.kendo = { cultures: {} });
kendo.cultures["hu-HU"] = {
name: "hu-HU",
numberFormat: {
pattern: ["-n"],
decimals: 2,
",": " ",
".": ",",
groupSize: [3],
percent: {
pattern: ["-n%","n%"],
decimals: 2,
",": " ",
".": ",",
groupSize: [3],
symbol: "%"
},
currency: {
pattern: ["-n $","n $"],
decimals: 2,
",": " ",
".": ",",
groupSize: [3],
symbol: "Ft"
}
},
calendars: {
standard: {
days: {
names: ["vasárnap","hétfő","kedd","szerda","csütörtök","péntek","szombat"],
namesAbbr: ["V","H","K","Sze","Cs","P","Szo"],
namesShort: ["V","H","K","Sze","Cs","P","Szo"]
},
months: {
names: ["január","február","március","április","május","június","július","augusztus","szeptember","október","november","december",""],
namesAbbr: ["jan.","febr.","márc.","ápr.","máj.","jún.","júl.","aug.","szept.","okt.","nov.","dec.",""]
},
AM: ["de.","de.","DE."],
PM: ["du.","du.","DU."],
patterns: {
d: "yyyy.MM.dd.",
D: "yyyy. MMMM d.",
F: "yyyy. MMMM d. H:mm:ss",
g: "yyyy.MM.dd. H:mm",
G: "yyyy.MM.dd. H:mm:ss",
m: "MMMM d.",
M: "MMMM d.",
s: "yyyy'-'MM'-'dd'T'HH':'mm':'ss",
t: "H:mm",
T: "H:mm:ss",
u: "yyyy'-'MM'-'dd HH':'mm':'ss'Z'",
y: "yyyy. MMMM",
Y: "yyyy. MMMM"
},
"/": ".",
":": ":",
firstDay: 1
}
}
}
})(this);
return window.kendo;
}, typeof define == 'function' && define.amd ? define : function(_, f){ f(); }); |
'use strict';
function UnauthorizedAccessError(code, error) {
Error.call(this, error.message);
Error.captureStackTrace(this, this.constructor);
this.name = 'UnauthorizedAccessError';
this.message = error.message;
this.code = code;
this.status = 401;
this.inner = error;
}
UnauthorizedAccessError.prototype = Object.create(Error.prototype);
UnauthorizedAccessError.prototype.constructor = UnauthorizedAccessError;
module.exports = UnauthorizedAccessError;
|
import redis from 'redis'
import { Promise } from 'bluebird'
import { config } from './config'
Promise.promisifyAll(redis.RedisClient.prototype)
Promise.promisifyAll(redis.Multi.prototype)
export default redis.createClient(config('/modules/redis/client'))
|
import { moduleForComponent, test } from 'ember-qunit';
import hbs from 'htmlbars-inline-precompile';
moduleForComponent('f-account', 'Integration | Component | f account', {
integration: true
});
const accountStub = Ember.Object.create({
name: 'name',
email: 'email',
phone: 'phone'
});
test('it can be submitted', function(assert) {
this.on('submit', () => { assert.ok(true); })
this.render(hbs`{{f-account submit=(action 'submit')}}`);
this.$('button').click()
});
test('it bound to account model', function(assert) {
this.set('account', accountStub);
this.on('submit', () => {});
this.render(hbs`{{f-account account=account submit=(action 'submit')}}`);
this.$('input').val('new name');
this.$('input').change();
this.$('button').click();
assert.ok(this.get('account.name') == 'new name');
});
|
/**
* Auth.js
*
* @description :: TODO: You might write a short summary of how this model works and what it represents here.
* @docs :: http://sailsjs.org/documentation/concepts/models-and-orm/models
*/
module.exports = {
attributes: {
}
};
|
"use strict";
/***
* Copyright (c) 2017 [Arthur Xie]
* <https://github.com/kite-js/kite>
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.ErrorService = void 0;
const util = require("util");
class ErrorService {
/**
*
* @param code error code
* @param extra error extra message
*/
getError(code, extra) {
let msg = this.errors[code];
if (extra && typeof extra === 'string') {
extra = [extra];
}
if (msg && extra) {
msg = util.format(msg, ...extra);
}
return { code, msg };
}
}
exports.ErrorService = ErrorService;
|
// TRANSFORMATION MAP
//
// url route => object => executable command
//
// /cal/2015/1 => {year: 2015,month: 1} => ./app.js 1 2015
// /cal/1/2015 => {year: 2015,month: 1} => ./app.js 1 2015
// /cal/2015 => {year: 2015} => ./app.js 2015
// /cal => {} => ./app.js
module.exports = function(route) { // e.g., route = '/cal/1/2015'
var cmd;
route = route.split('/').slice(1); // /cal/1/2015 => ['cal','1','2015']
if (route[0] === 'cal') {
cmd = './cal.js';
route = route.slice(1); // route = ['1','2015']
}
var json = route.reduce(function(obj,arg) {
if(isNaN(+arg)) cmd = null; // return null if any input argument is NaN
else if(arg<13) obj.month = arg; // iteration 1 => { month : 1 }
else obj.year = arg; // iteration 2 => { month : 1 , year : 2015 }
return obj;
},{});
cmd += json.month ? ' ' + json.month : ''; // ./app.js 1
cmd += json.year ? ' ' + json.year : ''; // ./app.js 1 2015
return cmd.slice(0,4) === 'null' ? null : cmd;
}
|
import {
Map,
MapWithDefault,
OrderedSet
} from 'ember-metal/map';
var object, number, string, map, variety;
var varieties = [['Map', Map], ['MapWithDefault', MapWithDefault]];
function testMap(nameAndFunc) {
variety = nameAndFunc[0];
QUnit.module('Ember.' + variety + ' (forEach and get are implicitly tested)', {
setup() {
object = {};
number = 42;
string = 'foo';
map = nameAndFunc[1].create();
}
});
var mapHasLength = function(expected, theMap) {
theMap = theMap || map;
var length = 0;
theMap.forEach(function() {
length++;
});
equal(length, expected, 'map should contain ' + expected + ' items');
};
var mapHasEntries = function(entries, theMap) {
theMap = theMap || map;
for (var i = 0, l = entries.length; i < l; i++) {
equal(theMap.get(entries[i][0]), entries[i][1]);
equal(theMap.has(entries[i][0]), true);
}
mapHasLength(entries.length, theMap);
};
var unboundThis;
(function() {
unboundThis = this;
}());
QUnit.test('set', function() {
map.set(object, 'winning');
map.set(number, 'winning');
map.set(string, 'winning');
mapHasEntries([
[object, 'winning'],
[number, 'winning'],
[string, 'winning']
]);
map.set(object, 'losing');
map.set(number, 'losing');
map.set(string, 'losing');
mapHasEntries([
[object, 'losing'],
[number, 'losing'],
[string, 'losing']
]);
equal(map.has('nope'), false, 'expected the key `nope` to not be present');
equal(map.has({}), false, 'expected they key `{}` to not be present');
});
QUnit.test('set chaining', function() {
map.set(object, 'winning').
set(number, 'winning').
set(string, 'winning');
mapHasEntries([
[object, 'winning'],
[number, 'winning'],
[string, 'winning']
]);
map.set(object, 'losing').
set(number, 'losing').
set(string, 'losing');
mapHasEntries([
[object, 'losing'],
[number, 'losing'],
[string, 'losing']
]);
equal(map.has('nope'), false, 'expected the key `nope` to not be present');
equal(map.has({}), false, 'expected they key `{}` to not be present');
});
QUnit.test('with key with undefined value', function() {
map.set('foo', undefined);
map.forEach(function(value, key) {
equal(value, undefined);
equal(key, 'foo');
});
ok(map.has('foo'), 'has key foo, even with undefined value');
equal(map.size, 1);
});
QUnit.test('arity of forEach is 1 – es6 23.1.3.5', function() {
equal(map.forEach.length, 1, 'expected arity for map.forEach is 1');
});
QUnit.test('forEach throws without a callback as the first argument', function() {
equal(map.forEach.length, 1, 'expected arity for map.forEach is 1');
});
QUnit.test('has empty collection', function() {
equal(map.has('foo'), false);
equal(map.has(), false);
});
QUnit.test('delete', function() {
expectNoDeprecation();
map.set(object, 'winning');
map.set(number, 'winning');
map.set(string, 'winning');
map.delete(object);
map.delete(number);
map.delete(string);
// doesn't explode
map.delete({});
mapHasEntries([]);
});
QUnit.test('copy and then update', function() {
map.set(object, 'winning');
map.set(number, 'winning');
map.set(string, 'winning');
var map2 = map.copy();
map2.set(object, 'losing');
map2.set(number, 'losing');
map2.set(string, 'losing');
mapHasEntries([
[object, 'winning'],
[number, 'winning'],
[string, 'winning']
]);
mapHasEntries([
[object, 'losing'],
[number, 'losing'],
[string, 'losing']
], map2);
});
QUnit.test('copy and then delete', function() {
map.set(object, 'winning');
map.set(number, 'winning');
map.set(string, 'winning');
var map2 = map.copy();
map2.delete(object);
map2.delete(number);
map2.delete(string);
mapHasEntries([
[object, 'winning'],
[number, 'winning'],
[string, 'winning']
]);
mapHasEntries([], map2);
});
QUnit.test('length', function() {
expectDeprecation('Usage of `length` is deprecated, use `size` instead.');
//Add a key twice
equal(map.length, 0);
map.set(string, 'a string');
equal(map.length, 1);
map.set(string, 'the same string');
equal(map.length, 1);
//Add another
map.set(number, 'a number');
equal(map.length, 2);
//Remove one that doesn't exist
map.delete('does not exist');
equal(map.length, 2);
//Check copy
var copy = map.copy();
equal(copy.length, 2);
//Remove a key twice
map.delete(number);
equal(map.length, 1);
map.delete(number);
equal(map.length, 1);
//Remove the last key
map.delete(string);
equal(map.length, 0);
map.delete(string);
equal(map.length, 0);
});
QUnit.test('size', function() {
//Add a key twice
equal(map.size, 0);
map.set(string, 'a string');
equal(map.size, 1);
map.set(string, 'the same string');
equal(map.size, 1);
//Add another
map.set(number, 'a number');
equal(map.size, 2);
//Remove one that doesn't exist
map.delete('does not exist');
equal(map.size, 2);
//Check copy
var copy = map.copy();
equal(copy.size, 2);
//Remove a key twice
map.delete(number);
equal(map.size, 1);
map.delete(number);
equal(map.size, 1);
//Remove the last key
map.delete(string);
equal(map.size, 0);
map.delete(string);
equal(map.size, 0);
});
QUnit.test('forEach without proper callback', function() {
QUnit.throws(function() {
map.forEach();
}, '[object Undefined] is not a function');
QUnit.throws(function() {
map.forEach(undefined);
}, '[object Undefined] is not a function');
QUnit.throws(function() {
map.forEach(1);
}, '[object Number] is not a function');
QUnit.throws(function() {
map.forEach({});
}, '[object Object] is not a function');
map.forEach(function(value, key) {
map.delete(key);
});
// ensure the error happens even if no data is present
equal(map.size, 0);
QUnit.throws(function() {
map.forEach({});
}, '[object Object] is not a function');
});
QUnit.test('forEach basic', function() {
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
var iteration = 0;
var expectations = [
{ value: 1, key: 'a', context: unboundThis },
{ value: 2, key: 'b', context: unboundThis },
{ value: 3, key: 'c', context: unboundThis }
];
map.forEach(function(value, key, theMap) {
var expectation = expectations[iteration];
equal(value, expectation.value, 'value should be correct');
equal(key, expectation.key, 'key should be correct');
equal(this, expectation.context, 'context should be as if it was unbound');
equal(map, theMap, 'map being iterated over should be passed in');
iteration++;
});
equal(iteration, 3, 'expected 3 iterations');
});
QUnit.test('forEach basic /w context', function() {
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
var iteration = 0;
var context = {};
var expectations = [
{ value: 1, key: 'a', context: context },
{ value: 2, key: 'b', context: context },
{ value: 3, key: 'c', context: context }
];
map.forEach(function(value, key, theMap) {
var expectation = expectations[iteration];
equal(value, expectation.value, 'value should be correct');
equal(key, expectation.key, 'key should be correct');
equal(this, expectation.context, 'context should be as if it was unbound');
equal(map, theMap, 'map being iterated over should be passed in');
iteration++;
}, context);
equal(iteration, 3, 'expected 3 iterations');
});
QUnit.test('forEach basic /w deletion while enumerating', function() {
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
var iteration = 0;
var expectations = [
{ value: 1, key: 'a', context: unboundThis },
{ value: 2, key: 'b', context: unboundThis }
];
map.forEach(function(value, key, theMap) {
if (iteration === 0) {
map.delete('c');
}
var expectation = expectations[iteration];
equal(value, expectation.value, 'value should be correct');
equal(key, expectation.key, 'key should be correct');
equal(this, expectation.context, 'context should be as if it was unbound');
equal(map, theMap, 'map being iterated over should be passed in');
iteration++;
});
equal(iteration, 2, 'expected 3 iterations');
});
QUnit.test('forEach basic /w addition while enumerating', function() {
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
var iteration = 0;
var expectations = [
{ value: 1, key: 'a', context: unboundThis },
{ value: 2, key: 'b', context: unboundThis },
{ value: 3, key: 'c', context: unboundThis },
{ value: 4, key: 'd', context: unboundThis }
];
map.forEach(function(value, key, theMap) {
if (iteration === 0) {
map.set('d', 4);
}
var expectation = expectations[iteration];
equal(value, expectation.value, 'value should be correct');
equal(key, expectation.key, 'key should be correct');
equal(this, expectation.context, 'context should be as if it was unbound');
equal(map, theMap, 'map being iterated over should be passed in');
iteration++;
});
equal(iteration, 4, 'expected 3 iterations');
});
QUnit.test('clear', function() {
var iterations = 0;
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
map.set('d', 4);
equal(map.size, 4);
map.forEach(function() {
iterations++;
});
equal(iterations, 4);
map.clear();
equal(map.size, 0);
iterations = 0;
map.forEach(function() {
iterations++;
});
equal(iterations, 0);
});
QUnit.test('-0', function() {
equal(map.has(-0), false);
equal(map.has(0), false);
map.set(-0, 'zero');
equal(map.has(-0), true);
equal(map.has(0), true);
equal(map.get(0), 'zero');
equal(map.get(-0), 'zero');
map.forEach(function(value, key) {
equal(1 / key, Infinity, 'spec says key should be positive zero');
});
});
QUnit.test('NaN', function() {
equal(map.has(NaN), false);
map.set(NaN, 'not-a-number');
equal(map.has(NaN), true);
equal(map.get(NaN), 'not-a-number');
});
QUnit.test('NaN Boxed', function() {
//jshint -W053
var boxed = new Number(NaN);
equal(map.has(boxed), false);
map.set(boxed, 'not-a-number');
equal(map.has(boxed), true);
equal(map.has(NaN), false);
equal(map.get(NaN), undefined);
equal(map.get(boxed), 'not-a-number');
});
QUnit.test('0 value', function() {
var obj = {};
equal(map.has(obj), false);
equal(map.size, 0);
map.set(obj, 0);
equal(map.size, 1);
equal(map.has(obj), true);
equal(map.get(obj), 0);
map.delete(obj);
equal(map.has(obj), false);
equal(map.get(obj), undefined);
equal(map.size, 0);
});
}
for (var i = 0; i < varieties.length; i++) {
testMap(varieties[i]);
}
QUnit.module('MapWithDefault - default values');
QUnit.test('Retrieving a value that has not been set returns and sets a default value', function() {
var map = MapWithDefault.create({
defaultValue(key) {
return [key];
}
});
var value = map.get('ohai');
deepEqual(value, ['ohai']);
strictEqual(value, map.get('ohai'));
});
QUnit.test('Map.prototype.constructor', function() {
var map = new Map();
equal(map.constructor, Map);
});
QUnit.test('MapWithDefault.prototype.constructor', function() {
var map = new MapWithDefault({
defaultValue(key) { return key; }
});
equal(map.constructor, MapWithDefault);
});
QUnit.test('Copying a MapWithDefault copies the default value', function() {
var map = MapWithDefault.create({
defaultValue(key) {
return [key];
}
});
map.set('ohai', 1);
map.get('bai');
var map2 = map.copy();
equal(map2.get('ohai'), 1);
deepEqual(map2.get('bai'), ['bai']);
map2.set('kthx', 3);
deepEqual(map.get('kthx'), ['kthx']);
equal(map2.get('kthx'), 3);
deepEqual(map2.get('default'), ['default']);
map2.defaultValue = function(key) {
return ['tom is on', key];
};
deepEqual(map2.get('drugs'), ['tom is on', 'drugs']);
});
QUnit.module('OrderedSet', {
setup() {
object = {};
number = 42;
string = 'foo';
map = OrderedSet.create();
}
});
QUnit.test('add returns the set', function() {
var obj = {};
equal(map.add(obj), map);
equal(map.add(obj), map, 'when it is already in the set');
});
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.