From 383fc211066683329e06bb187ee0493f8d242e04 Mon Sep 17 00:00:00 2001 From: Benjamin Matuszewski Date: Wed, 13 Dec 2017 17:43:44 +0100 Subject: [PATCH] added BarChartDisplay sink --- examples/sink-bar-chart-display/.babelrc | 5 + examples/sink-bar-chart-display/.gitignore | 5 + examples/sink-bar-chart-display/README.md | 34 + .../sink-bar-chart-display/assets/favicon.ico | Bin 0 -> 318 bytes .../sink-bar-chart-display/bin/javascripts | 132 + examples/sink-bar-chart-display/bin/log | 81 + examples/sink-bar-chart-display/bin/runner | 188 + examples/sink-bar-chart-display/bin/server | 42 + examples/sink-bar-chart-display/bundle.js | 13694 ++++++++++++++++ .../sink-bar-chart-display/css/styles.css | 20 + examples/sink-bar-chart-display/index.html | 15 + examples/sink-bar-chart-display/package.json | 36 + examples/sink-bar-chart-display/src/index.js | 28 + jsdoc.json | 6 + src/client/sink/BarChartDisplay.js | 126 + src/client/sink/_namespace.js | 2 + src/client/utils/display-utils.js | 3 + 17 files changed, 14417 insertions(+) create mode 100644 examples/sink-bar-chart-display/.babelrc create mode 100644 examples/sink-bar-chart-display/.gitignore create mode 100644 examples/sink-bar-chart-display/README.md create mode 100644 examples/sink-bar-chart-display/assets/favicon.ico create mode 100755 examples/sink-bar-chart-display/bin/javascripts create mode 100755 examples/sink-bar-chart-display/bin/log create mode 100755 examples/sink-bar-chart-display/bin/runner create mode 100755 examples/sink-bar-chart-display/bin/server create mode 100644 examples/sink-bar-chart-display/bundle.js create mode 100644 examples/sink-bar-chart-display/css/styles.css create mode 100644 examples/sink-bar-chart-display/index.html create mode 100644 examples/sink-bar-chart-display/package.json create mode 100644 examples/sink-bar-chart-display/src/index.js create mode 100644 src/client/sink/BarChartDisplay.js diff --git a/examples/sink-bar-chart-display/.babelrc b/examples/sink-bar-chart-display/.babelrc new file mode 100644 index 0000000..dda73e8 --- /dev/null +++ b/examples/sink-bar-chart-display/.babelrc @@ -0,0 +1,5 @@ +{ + "sourceMap": "inline", + "presets": ["latest"], + "plugins": ["transform-runtime", "transform-es2015-modules-commonjs"] +} \ No newline at end of file diff --git a/examples/sink-bar-chart-display/.gitignore b/examples/sink-bar-chart-display/.gitignore new file mode 100644 index 0000000..16e7e87 --- /dev/null +++ b/examples/sink-bar-chart-display/.gitignore @@ -0,0 +1,5 @@ +node_modules/ +dist/ + +.DS_Store +npm-debug.log diff --git a/examples/sink-bar-chart-display/README.md b/examples/sink-bar-chart-display/README.md new file mode 100644 index 0000000..3db48bb --- /dev/null +++ b/examples/sink-bar-chart-display/README.md @@ -0,0 +1,34 @@ +ES6 Prototyping Boilerplate +======================================================= + +> A client-side boilerplate for rapid prototyping with latest EcmaScript features (using [babel-latest](https://babeljs.io/docs/plugins/preset-latest/) preset) + +## Available Commands + +``` +npm run [command] +``` + +- `transpile` + * transpile all files from `src` folder to `dist` folder +- `bundle` + * run `transpile` command + * create the browserified bundle +- `watch` + * create a static file server + * transpile files in `src` folder when changed + * rebundle application on page load +- `serve` + * run the static file server only _(presentation mode)_ + +## Usage + +```sh +git clone --depth=1 https://github.com/Ircam-RnD/es6-prototyping-boilerplate.git dest_directory +cd dest_directory +rm -rf .git # remove git history +npm install +``` + +This boilerplate uses [https://babeljs.io/](https://babeljs.io/) and [http://browserify.org/](http://browserify.org/). + diff --git a/examples/sink-bar-chart-display/assets/favicon.ico b/examples/sink-bar-chart-display/assets/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..aad99fba9e97e6ca1e4863f604f4aeaa02b8e711 GIT binary patch literal 318 zcmZQzU<5(|0RbS%!l1#(z#zuJz@P!d0zj+)#2|4HXaJKC0wf0mYCr$LnAD*K1tI3( LqN!sGRZIZ@_WuM2 literal 0 HcmV?d00001 diff --git a/examples/sink-bar-chart-display/bin/javascripts b/examples/sink-bar-chart-display/bin/javascripts new file mode 100755 index 0000000..aae8330 --- /dev/null +++ b/examples/sink-bar-chart-display/bin/javascripts @@ -0,0 +1,132 @@ +#!/usr/bin/env node +var babel = require('babel-core'); +var browserify = require('browserify'); +var fse = require('fs-extra'); +var log = require('./log'); +var path = require('path'); + +'use strict'; + +/** + * Create a transpiler object binded to a `srcDirectory` and a `distDirectory` + */ +function getTranspiler(srcDirectory, distDirectory, isAllowed, babelOptions, browserifyOptions) { + + /** + * Returns the name of the target transpiled file + */ + function getTarget(filename) { + var relFilename = path.relative(srcDirectory, filename); + var outFilename = path.join(distDirectory, relFilename); + return outFilename; + } + + /** + * returns the transpiler to be consumed. + */ + var transpiler = { + /** + * Transpile the given file from es6 to es5. If the given stack is not empty + * call the method recursively till its empty. When the stack is empty, + * execute the callback. + */ + transpile: function(filename, stack, callback) { + /** + * If stack is not empty transpile the next entry, else execute the + * callback if any. + */ + function next() { + if (stack && stack.length > 0) + transpiler.transpile(stack.shift(), stack, callback); + else if (stack.length === 0 && callback) + callback(); + } + + if (filename === undefined || !isAllowed(filename)) + return next(); + + var outFilename = getTarget(filename); + var startTime = new Date().getTime(); + + babel.transformFile(filename, babelOptions, function(err, result) { + if (err) + return log.transpileError(err); + + fse.outputFile(outFilename, result.code, function(err) { + if (err) + return console.error(err.message); + + log.transpileSuccess(filename, outFilename, startTime); + next(); + }); + }); + }, + + /** + * Transform a given file to it's browserified version, client only. + * Only clients have their browserified counterparts, each folder in `src/client` + * is considered has a separate browserified client file. The `index.js` in each + * folder defines the entry point of the particular client. The browserified + * file is name after the name of the folder. + */ + bundle: function(entryPoint, outFilename, callback) { + if (entryPoint === undefined || !isAllowed(entryPoint)) + return; + + var bundler = browserify(entryPoint, browserifyOptions); + var startTime = new Date().getTime(); + + log.bundleStart(outFilename); + fse.ensureFileSync(outFilename); // ensure file exists + + var writeStream = fse.createWriteStream(outFilename); + + bundler + .bundle() + .on('error', function(err) { + log.bundleError(outFilename, err); + }) + .on('end', function() { + log.bundleSuccess(outFilename, startTime); + }) + .pipe(writeStream); + + writeStream.on('finish', function() { + if (callback) + callback(); + }); + }, + + /** + * Delete the transpiled file. + */ + delete: function(filename, callback) { + var outFilename = getTarget(filename); + + fse.stat(outFilename, function(err, stats) { + if (err) + return console.log(err.message); + + if (stats.isFile()) { + fse.remove(outFilename, function(err) { + if (err) + return console.log(err.message); + + log.deleteFile(outFilename); + + if (callback) + callback(); + }); + } else { + callback(); + } + }); + }, + }; + + return transpiler; +} + +module.exports = { + getTranspiler: getTranspiler +}; diff --git a/examples/sink-bar-chart-display/bin/log b/examples/sink-bar-chart-display/bin/log new file mode 100755 index 0000000..0914226 --- /dev/null +++ b/examples/sink-bar-chart-display/bin/log @@ -0,0 +1,81 @@ +#!/usr/bin/env node +var pkg = require('../package.json'); +var colors = require('colors'); +var ora = require('ora'); +var path = require('path'); + +'use strict'; + +var prefix = '[' + pkg.name + ']\t'; +var cwd = process.cwd(); + +function toRel(target) { + return path.relative(cwd, target); +} + +function getDeltaTime(time) { + return new Date().getTime() - time; +} + +var spinners = {}; + +var log = { + bundleStart: function(dest) { + var msg = prefix + (toRel(dest) + ': bundle start').yellow; + var spinner = ora({ color: 'white', text: msg }); + spinner.start(); + + spinners[dest] = spinner; + }, + + bundleSuccess: function(dest, startTime) { + var spinner = spinners[dest]; + var time = getDeltaTime(startTime); + var msg = prefix + '%s: successfully created (%sms)'.green; + + spinner.stop(); + console.log(msg, toRel(dest), time); + }, + + bundleError: function(dest, err) { + var spinner = spinners[dest]; + var msg = prefix + '%s: bundle error'.red; + + spinner.stop(); + console.log(msg, toRel(dest)); + console.log('> ' + err.message); + }, + + transpileSuccess: function(src, dest, startTime) { + var time = getDeltaTime(startTime); + var msg = prefix + '%s: successfully transpiled to "%s" (%sms)'.green; + + console.log(msg, toRel(src), toRel(dest), time); + }, + + transpileError: function(err) { + var parts = err.message.split(':'); + var msg = prefix + '%s'.red; + + console.log(msg, toRel(err.message)); + console.log(err.codeFrame); + }, + + uglifySuccess: function(src, dest, startTime) { + var time = getDeltaTime(startTime); + var msg = prefix + '%s: successfully uglified to "%s" (%sms)'.green; + console.log(msg, toRel(src), toRel(dest), time); + }, + + deleteFile: function(filename) { + var msg = prefix + '%s: successfully removed'.yellow; + console.log(msg, toRel(filename)); + }, + + serverStart: function(port) { + var msg = prefix + 'server listen on http://127.0.0.1:%s'.blue; + console.log(msg, port); + } +}; + +module.exports = log; diff --git a/examples/sink-bar-chart-display/bin/runner b/examples/sink-bar-chart-display/bin/runner new file mode 100755 index 0000000..4e9f202 --- /dev/null +++ b/examples/sink-bar-chart-display/bin/runner @@ -0,0 +1,188 @@ +#!/usr/bin/env node +var fse = require('fs-extra'); +var watch = require('watch'); +var path = require('path'); +var pkg = require('../package.json'); +var util = require('util'); + +var javascripts = require('./javascripts'); +var server = require('./server'); +var cwd = process.cwd(); + +'use strict'; + +/** + * Options for babel transpiling. + */ +var babelrc = fse.readFileSync(path.join(cwd, '.babelrc')); +var babelOptions = JSON.parse(babelrc.toString()); + +/** + * Options for watch. + */ +var watchOptions = { + ignoreDotFiles: true, + ignoreUnreadableDir: true, + ignoreNotPermitted: true, + interval: 2000, // watch internally use `fs.watchFile` +}; + +/** + * Options for browserify. + */ +var browserifyOptions = { + debug: true, + fullPaths: false, + standalone: pkg.standalone, +}; + +/** + * Watched directories + */ +var srcDirectory = path.join(cwd, 'src'); +var distDirectory = path.join(cwd, 'dist'); + +var bundlePath = path.join(cwd, 'bundle.js'); + +/** + * Define which file should be ignored by every command. + */ +var allowedExtentions = /\.ejs$|\.scss$|\.js$/; +var excludeFiles = /^\./; // exclude hidden files + +/** + * Test the given filename, to ensure it can be processed by any command / tranpsiler + * @param {String} filename - The filename to be checked. + * @param {Boolean} [ensureFile=true] - If set to false, don't test if the file exists. + */ +function isAllowed(filename, ensureFile) { + ensureFile = ensureFile === undefined ? true : ensureFile; + + var basename = path.basename(filename); + var isFile = true; + + if (ensureFile) { + try { + isFile = fse.lstatSync(filename).isFile() && !fse.lstatSync(filename).isSymbolicLink(); + } catch(e) { + console.log(e.message); + isFile = false; + } + } + + var hasAllowedExt = allowedExtentions.test(basename); + var notExcludeFile = !excludeFiles.test(basename); + + return isFile && hasAllowedExt && notExcludeFile; +} + +/** + * Returns a list of the file in a given folder recursively. + */ +function _getFileList(folder, callback) { + var files = []; + + fse.walk(folder) + .on('data', function(item) { + if (item.stats.isFile() && isAllowed(item.path)) + files.push(item.path); + }) + .on('end', function() { + callback(files); + }); +} + +/** + * Watch javascript source files. + */ +function watchFiles(srcDirectory, distDirectory) { + var transpiler = javascripts.getTranspiler(srcDirectory, distDirectory, isAllowed, babelOptions, browserifyOptions); + + watch.createMonitor(srcDirectory, watchOptions, function(monitor) { + monitor.on('created', function(filename, stats) { + if (isAllowed(filename)) + transpiler.transpile(filename, []); + }); + + monitor.on('changed', function(filename, stats) { + if (isAllowed(filename)) + transpiler.transpile(filename, []); + }); + + monitor.on('removed', function(filename, stats) { + if (isAllowed(filename, false)) + transpiler.delete(filename); + }); + }); + + // start a server which bundles sources on `bundle.js` request + var entryPoint = path.join(distDirectory, 'index.js'); + var middleware = server.bundleMiddleware(transpiler, entryPoint, bundlePath); + server.start(middleware); +} + + +function transpileFiles(srcDirectory, distDirectory, callback) { + _getFileList(srcDirectory, function(files) { + var transpiler = javascripts.getTranspiler(srcDirectory, distDirectory, isAllowed, babelOptions); + transpiler.transpile(undefined, files, callback); + }); +} + +function bundle(distDirectory) { + var entryPoint = path.join(distDirectory, 'index.js'); + var transpiler = javascripts.getTranspiler(srcDirectory, distDirectory, isAllowed, babelOptions, browserifyOptions); + + transpileFiles(srcDirectory, distDirectory, function() { + transpiler.bundle(entryPoint, bundlePath); + }); +} + +function serve() { + server.start(); +} + +/* -------------------------------------------------------------------------- + * Process and execute the given command. + * -------------------------------------------------------------------------- */ + +var command = process.argv[2]; +var args = process.argv.slice(3); +var argv = {}; +for (var i = 0; i < args.length; i += 2) { + argv[args[i]] = args[i + 1]; +} + +switch (command) { + /** + * Watch the file system and transpile from es6 to es5. + */ + case '--watch': + watchFiles(srcDirectory, distDirectory); + break; + + /** + * Transpile all files in `src` from es6 to es5. + */ + case '--transpile': + transpileFiles(srcDirectory, distDirectory); + break; + + /** + * Transpile all files in `src` from es6 to es5 and browserify all the things. + */ + case '--bundle': + bundle(distDirectory); + break; + + /** + * Run a static server. + */ + case '--serve': + serve(); + break; +} + +/* -------------------------------------------------------------------------- + * -------------------------------------------------------------------------- */ + diff --git a/examples/sink-bar-chart-display/bin/server b/examples/sink-bar-chart-display/bin/server new file mode 100755 index 0000000..ccf0786 --- /dev/null +++ b/examples/sink-bar-chart-display/bin/server @@ -0,0 +1,42 @@ +#!/usr/bin/env node +var connect = require('connect'); +var log = require('./log'); +var path = require('path'); +var portfinder = require('portfinder'); +var serveStatic = require('serve-static'); +var serveFavicon = require('serve-favicon'); + +'use strict'; + +portfinder.basePort = 3000; + + +const server = { + start: function(middleware) { + var app = connect(); + + if (middleware) + app.use(middleware); + + app.use(serveFavicon('./assets/favicon.ico')); + app.use(serveStatic('.', { index: ['index.html'] })); + + portfinder.getPort(function(err, port) { + if (err) + console.log(err.message); + + app.listen(port, function() { log.serverStart(port); }); + }); + }, + + bundleMiddleware: function(transpiler, entryPoint, outFilename) { + return function(req, res, next) { + if (req.url === '/' + path.basename(outFilename)) + transpiler.bundle(entryPoint, outFilename, next); // rebundle + else + next(); + } + } +} + +module.exports = server; diff --git a/examples/sink-bar-chart-display/bundle.js b/examples/sink-bar-chart-display/bundle.js new file mode 100644 index 0000000..fb5b8c7 --- /dev/null +++ b/examples/sink-bar-chart-display/bundle.js @@ -0,0 +1,13694 @@ +(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);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, BarChartDisplay); + return (0, _possibleConstructorReturn3.default)(this, (BarChartDisplay.__proto__ || (0, _getPrototypeOf2.default)(BarChartDisplay)).call(this, definitions, options, false)); + } + + /** @private */ + + + (0, _createClass3.default)(BarChartDisplay, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + var frameSize = this.streamParams.frameSize; + var width = this.canvasWidth; + var height = this.canvasHeight; + var colors = this.params.get('colors'); + var data = frame.data; + + var barWidth = width / frameSize; + var ctx = this.ctx; + + // error handling needs review... + var error = 0; + + for (var i = 0; i < frameSize; i++) { + var x1Float = i * barWidth + error; + var x1Int = Math.round(x1Float); + var x2Float = x1Float + (barWidth - error); + var x2Int = Math.round(x2Float); + + error = x2Int - x2Float; + + if (x1Int !== x2Int) { + var _width = x2Int - x1Int; + var y = this.getYPosition(data[i]); + + ctx.fillStyle = colors[i % colors.length]; + ctx.fillRect(x1Int, y, _width, height - y); + } else { + error -= barWidth; + } + } + } + }]); + return BarChartDisplay; +}(_BaseDisplay3.default); + +exports.default = BarChartDisplay; + +},{"../../common/operator/Fft":24,"../utils/display-utils":19,"./BaseDisplay":3,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],3:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _assign = require('babel-runtime/core-js/object/assign'); + +var _assign2 = _interopRequireDefault(_assign); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var commonDefinitions = { + min: { + type: 'float', + default: -1, + metas: { kind: 'dynamic' } + }, + max: { + type: 'float', + default: 1, + metas: { kind: 'dynamic' } + }, + width: { + type: 'integer', + default: 300, + metas: { kind: 'dynamic' } + }, + height: { + type: 'integer', + default: 150, + metas: { kind: 'dynamic' } + }, + container: { + type: 'any', + default: null, + constant: true + }, + canvas: { + type: 'any', + default: null, + constant: true + } +}; + +var hasDurationDefinitions = { + duration: { + type: 'float', + min: 0, + max: +Infinity, + default: 1, + metas: { kind: 'dynamic' } + }, + referenceTime: { + type: 'float', + default: 0, + constant: true + } +}; + +/** + * Base class to extend in order to create graphic sinks. + * + * _This class should be considered abstract and only + * be used to be extended._ + * + * @todo - fix float rounding errors (produce decays in sync draws) + * + * @memberof module:client.sink + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.min=-1] - Minimum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.max=1] - Maximum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.width=300] - Width of the canvas. + * _dynamic parameter_ + * @param {Number} [options.height=150] - Height of the canvas. + * _dynamic parameter_ + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. _constant parameter_ + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. _constant parameter_ + * @param {Number} [options.duration=1] - Duration (in seconds) represented in + * the canvas. This parameter only exists for operators that display several + * consecutive frames on the canvas. _dynamic parameter_ + * @param {Number} [options.referenceTime=null] - Optionnal reference time the + * display should considerer as the origin. Is only usefull when synchronizing + * several display using the `DisplaySync` class. This parameter only exists + * for operators that display several consecutive frames on the canvas. + */ + +var BaseDisplay = function (_BaseLfo) { + (0, _inherits3.default)(BaseDisplay, _BaseLfo); + + function BaseDisplay(defs) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var hasDuration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + (0, _classCallCheck3.default)(this, BaseDisplay); + + var commonDefs = void 0; + + if (hasDuration) commonDefs = (0, _assign2.default)({}, commonDefinitions, hasDurationDefinitions);else commonDefs = commonDefinitions; + + var definitions = (0, _assign2.default)({}, commonDefs, defs); + + var _this = (0, _possibleConstructorReturn3.default)(this, (BaseDisplay.__proto__ || (0, _getPrototypeOf2.default)(BaseDisplay)).call(this, definitions, options)); + + if (_this.params.get('canvas') === null && _this.params.get('container') === null) throw new Error('Invalid parameter: `canvas` or `container` not defined'); + + var canvasParam = _this.params.get('canvas'); + var containerParam = _this.params.get('container'); + + // prepare canvas + if (canvasParam) { + if (typeof canvasParam === 'string') _this.canvas = document.querySelector(canvasParam);else _this.canvas = canvasParam; + } else if (containerParam) { + var container = void 0; + + if (typeof containerParam === 'string') container = document.querySelector(containerParam);else container = containerParam; + + _this.canvas = document.createElement('canvas'); + container.appendChild(_this.canvas); + } + + _this.ctx = _this.canvas.getContext('2d'); + _this.cachedCanvas = document.createElement('canvas'); + _this.cachedCtx = _this.cachedCanvas.getContext('2d'); + + _this.hasDuration = hasDuration; + _this.previousFrame = null; + _this.currentTime = hasDuration ? _this.params.get('referenceTime') : null; + + /** + * Instance of the `DisplaySync` used to synchronize the different displays + * @private + */ + _this.displaySync = false; + + _this._stack = []; + _this._rafId = null; + + _this.renderStack = _this.renderStack.bind(_this); + _this.shiftError = 0; + + // initialize canvas size and y scale transfert function + _this._resize(); + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(BaseDisplay, [{ + key: '_resize', + value: function _resize() { + var width = this.params.get('width'); + var height = this.params.get('height'); + + var ctx = this.ctx; + var cachedCtx = this.cachedCtx; + + var dPR = window.devicePixelRatio || 1; + var bPR = ctx.webkitBackingStorePixelRatio || ctx.mozBackingStorePixelRatio || ctx.msBackingStorePixelRatio || ctx.oBackingStorePixelRatio || ctx.backingStorePixelRatio || 1; + + this.pixelRatio = dPR / bPR; + + var lastWidth = this.canvasWidth; + var lastHeight = this.canvasHeight; + this.canvasWidth = width * this.pixelRatio; + this.canvasHeight = height * this.pixelRatio; + + cachedCtx.canvas.width = this.canvasWidth; + cachedCtx.canvas.height = this.canvasHeight; + + // copy current image from ctx (resize) + if (lastWidth && lastHeight) { + cachedCtx.drawImage(ctx.canvas, 0, 0, lastWidth, lastHeight, 0, 0, this.canvasWidth, this.canvasHeight); + } + + ctx.canvas.width = this.canvasWidth; + ctx.canvas.height = this.canvasHeight; + ctx.canvas.style.width = width + 'px'; + ctx.canvas.style.height = height + 'px'; + + // update scale + this._setYScale(); + } + + /** + * Create the transfert function used to map values to pixel in the y axis + * @private + */ + + }, { + key: '_setYScale', + value: function _setYScale() { + var min = this.params.get('min'); + var max = this.params.get('max'); + var height = this.canvasHeight; + + var a = (0 - height) / (max - min); + var b = height - a * min; + + this.getYPosition = function (x) { + return a * x + b; + }; + } + + /** + * Returns the width in pixel a `vector` frame needs to be drawn. + * @private + */ + + }, { + key: 'getMinimumFrameWidth', + value: function getMinimumFrameWidth() { + return 1; // need one pixel to draw the line + } + + /** + * Callback function executed when a parameter is updated. + * + * @param {String} name - Parameter name. + * @param {Mixed} value - Parameter value. + * @param {Object} metas - Metadatas of the parameter. + * @private + */ + + }, { + key: 'onParamUpdate', + value: function onParamUpdate(name, value, metas) { + (0, _get3.default)(BaseDisplay.prototype.__proto__ || (0, _getPrototypeOf2.default)(BaseDisplay.prototype), 'onParamUpdate', this).call(this, name, value, metas); + + switch (name) { + case 'min': + case 'max': + // @todo - make sure that min and max are different + this._setYScale(); + break; + case 'width': + case 'height': + this._resize(); + } + } + + /** @private */ + + }, { + key: 'propagateStreamParams', + value: function propagateStreamParams() { + (0, _get3.default)(BaseDisplay.prototype.__proto__ || (0, _getPrototypeOf2.default)(BaseDisplay.prototype), 'propagateStreamParams', this).call(this); + } + + /** @private */ + + }, { + key: 'resetStream', + value: function resetStream() { + (0, _get3.default)(BaseDisplay.prototype.__proto__ || (0, _getPrototypeOf2.default)(BaseDisplay.prototype), 'resetStream', this).call(this); + + var width = this.canvasWidth; + var height = this.canvasHeight; + + this.previousFrame = null; + this.currentTime = this.hasDuration ? this.params.get('referenceTime') : null; + + this.ctx.clearRect(0, 0, width, height); + this.cachedCtx.clearRect(0, 0, width, height); + } + + /** @private */ + + }, { + key: 'finalizeStream', + value: function finalizeStream(endTime) { + this.currentTime = null; + (0, _get3.default)(BaseDisplay.prototype.__proto__ || (0, _getPrototypeOf2.default)(BaseDisplay.prototype), 'finalizeStream', this).call(this, endTime); + + this._rafId = null; + + // clear the stack if not empty + if (this._stack.length > 0) this.renderStack(); + } + + /** + * Add the current frame to the frames to draw. Should not be overriden. + * @private + */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + var frameSize = this.streamParams.frameSize; + var copy = new Float32Array(frameSize); + var data = frame.data; + + // copy values of the input frame as they might be updated + // in reference before being consumed in the draw function + for (var i = 0; i < frameSize; i++) { + copy[i] = data[i]; + }this._stack.push({ + time: frame.time, + data: copy, + metadata: frame.metadata + }); + + if (this._rafId === null) this._rafId = window.requestAnimationFrame(this.renderStack); + } + + /** + * Render the accumulated frames. Method called in `requestAnimationFrame`. + * @private + */ + + }, { + key: 'renderStack', + value: function renderStack() { + if (this.params.has('duration')) { + // render all frame since last `renderStack` call + for (var i = 0, l = this._stack.length; i < l; i++) { + this.scrollModeDraw(this._stack[i]); + } + } else { + // only render last received frame if any + if (this._stack.length > 0) { + var frame = this._stack[this._stack.length - 1]; + this.ctx.clearRect(0, 0, this.canvasWidth, this.canvasHeight); + this.processFunction(frame); + } + } + + this._stack.length = 0; // reinit stack for next call + this._rafId = null; + } + + /** + * Draw data from right to left with scrolling + * @private + * @todo - check possibility of maintaining all values from one place to + * minimize float error tracking. + */ + + }, { + key: 'scrollModeDraw', + value: function scrollModeDraw(frame) { + var frameType = this.streamParams.frameType; + var frameRate = this.streamParams.frameRate; + var frameSize = this.streamParams.frameSize; + var sourceSampleRate = this.streamParams.sourceSampleRate; + + var canvasDuration = this.params.get('duration'); + var ctx = this.ctx; + var canvasWidth = this.canvasWidth; + var canvasHeight = this.canvasHeight; + + var previousFrame = this.previousFrame; + + // current time at the left of the canvas + var currentTime = this.currentTime !== null ? this.currentTime : frame.time; + var frameStartTime = frame.time; + var lastFrameTime = previousFrame ? previousFrame.time : 0; + var lastFrameDuration = this.lastFrameDuration ? this.lastFrameDuration : 0; + + var frameDuration = void 0; + + if (frameType === 'scalar' || frameType === 'vector') { + var pixelDuration = canvasDuration / canvasWidth; + frameDuration = this.getMinimumFrameWidth() * pixelDuration; + } else if (this.streamParams.frameType === 'signal') { + frameDuration = frameSize / sourceSampleRate; + } + + var frameEndTime = frameStartTime + frameDuration; + // define if we need to shift the canvas + var shiftTime = frameEndTime - currentTime; + + // if the canvas is not synced, should never go to `else` + if (shiftTime > 0) { + // shift the canvas of shiftTime in pixels + var fShift = shiftTime / canvasDuration * canvasWidth - this.shiftError; + var iShift = Math.floor(fShift + 0.5); + this.shiftError = fShift - iShift; + + var _currentTime = frameStartTime + frameDuration; + this.shiftCanvas(iShift, _currentTime); + + // if siblings, share the information + if (this.displaySync) this.displaySync.shiftSiblings(iShift, _currentTime, this); + } + + // width of the frame in pixels + var floatFrameWidth = frameDuration / canvasDuration * canvasWidth; + var frameWidth = Math.floor(floatFrameWidth + 0.5); + + // define position of the head in the canvas + var canvasStartTime = this.currentTime - canvasDuration; + var startTimeRatio = (frameStartTime - canvasStartTime) / canvasDuration; + var startTimePosition = startTimeRatio * canvasWidth; + + // number of pixels since last frame + var pixelsSinceLastFrame = this.lastFrameWidth; + + if ((frameType === 'scalar' || frameType === 'vector') && previousFrame) { + var frameInterval = frame.time - previousFrame.time; + pixelsSinceLastFrame = frameInterval / canvasDuration * canvasWidth; + } + + // draw current frame + ctx.save(); + ctx.translate(startTimePosition, 0); + this.processFunction(frame, frameWidth, pixelsSinceLastFrame); + ctx.restore(); + + // save current canvas state into cached canvas + this.cachedCtx.clearRect(0, 0, canvasWidth, canvasHeight); + this.cachedCtx.drawImage(this.canvas, 0, 0, canvasWidth, canvasHeight); + + // update lastFrameDuration, lastFrameWidth + this.lastFrameDuration = frameDuration; + this.lastFrameWidth = frameWidth; + this.previousFrame = frame; + } + + /** + * Shift canvas, also called from `DisplaySync` + * @private + */ + + }, { + key: 'shiftCanvas', + value: function shiftCanvas(iShift, time) { + var ctx = this.ctx; + var cache = this.cachedCanvas; + var cachedCtx = this.cachedCtx; + var width = this.canvasWidth; + var height = this.canvasHeight; + var croppedWidth = width - iShift; + this.currentTime = time; + + ctx.clearRect(0, 0, width, height); + ctx.drawImage(cache, iShift, 0, croppedWidth, height, 0, 0, croppedWidth, height); + // save current canvas state into cached canvas + cachedCtx.clearRect(0, 0, width, height); + cachedCtx.drawImage(this.canvas, 0, 0, width, height); + } + + // @todo - Fix trigger mode + // allow to witch easily between the 2 modes + // setTrigger(bool) { + // this.params.trigger = bool; + // // clear canvas and cache + // this.ctx.clearRect(0, 0, this.params.width, this.params.height); + // this.cachedCtx.clearRect(0, 0, this.params.width, this.params.height); + // // reset _currentXPosition + // this._currentXPosition = 0; + // this.lastShiftError = 0; + // } + + // /** + // * Alternative drawing mode. + // * Draw from left to right, go back to left when > width + // */ + // triggerModeDraw(time, frame) { + // const width = this.params.width; + // const height = this.params.height; + // const duration = this.params.duration; + // const ctx = this.ctx; + + // const dt = time - this.previousTime; + // const fShift = (dt / duration) * width - this.lastShiftError; // px + // const iShift = Math.round(fShift); + // this.lastShiftError = iShift - fShift; + + // this.currentXPosition += iShift; + + // // draw the right part + // ctx.save(); + // ctx.translate(this.currentXPosition, 0); + // ctx.clearRect(-iShift, 0, iShift, height); + // this.drawCurve(frame, iShift); + // ctx.restore(); + + // // go back to the left of the canvas and redraw the same thing + // if (this.currentXPosition > width) { + // // go back to start + // this.currentXPosition -= width; + + // ctx.save(); + // ctx.translate(this.currentXPosition, 0); + // ctx.clearRect(-iShift, 0, iShift, height); + // this.drawCurve(frame, this.previousFrame, iShift); + // ctx.restore(); + // } + // } + + }]); + return BaseDisplay; +}(_BaseLfo3.default); + +exports.default = BaseDisplay; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/assign":60,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],4:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseDisplay2 = require('./BaseDisplay'); + +var _BaseDisplay3 = _interopRequireDefault(_BaseDisplay2); + +var _displayUtils = require('../utils/display-utils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + radius: { + type: 'float', + min: 0, + default: 0, + metas: { kind: 'dynamic' } + }, + line: { + type: 'boolean', + default: true, + metas: { kind: 'dynamic' } + }, + colors: { + type: 'any', + default: null + } + + /** + * Breakpoint Function, display a stream of type `vector`. + * + * @memberof module:client.sink + * + * @param {Object} options - Override default parameters. + * @param {String} [options.colors=null] - Array of colors for each index of the + * vector. _dynamic parameter_ + * @param {String} [options.radius=0] - Radius of the dot at each value. + * _dynamic parameter_ + * @param {String} [options.line=true] - Display a line between each consecutive + * values of the vector. _dynamic parameter_ + * @param {Number} [options.min=-1] - Minimum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.max=1] - Maximum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.width=300] - Width of the canvas. + * _dynamic parameter_ + * @param {Number} [options.height=150] - Height of the canvas. + * _dynamic parameter_ + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. _constant parameter_ + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. _constant parameter_ + * @param {Number} [options.duration=1] - Duration (in seconds) represented in + * the canvas. _dynamic parameter_ + * @param {Number} [options.referenceTime=null] - Optionnal reference time the + * display should considerer as the origin. Is only usefull when synchronizing + * several display using the `DisplaySync` class. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const eventIn = new lfo.source.EventIn({ + * frameSize: 2, + * frameRate: 0.1, + * frameType: 'vector' + * }); + * + * const bpf = new lfo.sink.BpfDisplay({ + * canvas: '#bpf', + * duration: 10, + * }); + * + * eventIn.connect(bpf); + * eventIn.start(); + * + * let time = 0; + * const dt = 0.1; + * + * (function generateData() { + * eventIn.process(time, [Math.random() * 2 - 1, Math.random() * 2 - 1]); + * time += dt; + * + * setTimeout(generateData, dt * 1000); + * }()); + */ +}; +var BpfDisplay = function (_BaseDisplay) { + (0, _inherits3.default)(BpfDisplay, _BaseDisplay); + + function BpfDisplay(options) { + (0, _classCallCheck3.default)(this, BpfDisplay); + + var _this = (0, _possibleConstructorReturn3.default)(this, (BpfDisplay.__proto__ || (0, _getPrototypeOf2.default)(BpfDisplay)).call(this, definitions, options)); + + _this.prevFrame = null; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(BpfDisplay, [{ + key: 'getMinimumFrameWidth', + value: function getMinimumFrameWidth() { + return this.params.get('radius'); + } + }, { + key: 'resetStream', + value: function resetStream() { + (0, _get3.default)(BpfDisplay.prototype.__proto__ || (0, _getPrototypeOf2.default)(BpfDisplay.prototype), 'resetStream', this).call(this); + + this.prevFrame = null; + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + if (this.params.get('colors') === null) this.params.set('colors', (0, _displayUtils.getColors)('bpf', this.streamParams.frameSize)); + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame, frameWidth, pixelsSinceLastFrame) { + var colors = this.params.get('colors'); + var radius = this.params.get('radius'); + var drawLine = this.params.get('line'); + var frameSize = this.streamParams.frameSize; + var ctx = this.ctx; + var data = frame.data; + var prevData = this.prevFrame ? this.prevFrame.data : null; + + ctx.save(); + + for (var i = 0, l = frameSize; i < l; i++) { + var posY = this.getYPosition(data[i]); + var color = colors[i]; + + ctx.strokeStyle = color; + ctx.fillStyle = color; + + if (prevData && drawLine) { + var lastPosY = this.getYPosition(prevData[i]); + ctx.beginPath(); + ctx.moveTo(-pixelsSinceLastFrame, lastPosY); + ctx.lineTo(0, posY); + ctx.stroke(); + ctx.closePath(); + } + + if (radius > 0) { + ctx.beginPath(); + ctx.arc(0, posY, radius, 0, Math.PI * 2, false); + ctx.fill(); + ctx.closePath(); + } + } + + ctx.restore(); + + this.prevFrame = frame; + } + }]); + return BpfDisplay; +}(_BaseDisplay3.default); + +exports.default = BpfDisplay; + +},{"../utils/display-utils":19,"./BaseDisplay":3,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],5:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseDisplay2 = require('./BaseDisplay'); + +var _BaseDisplay3 = _interopRequireDefault(_BaseDisplay2); + +var _displayUtils = require('../utils/display-utils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + threshold: { + type: 'float', + default: null, + nullable: true, + metas: { kind: 'dynamic' } + }, + thresholdIndex: { + type: 'integer', + default: 0, + metas: { kind: 'dynamic' } + }, + color: { + type: 'string', + default: (0, _displayUtils.getColors)('marker'), + nullable: true, + metas: { kind: 'dynamic' } + } +}; + +/** + * Display a marker according to a `vector` input frame. + * + * @memberof module:client.sink + * + * @param {Object} options - Override default parameters. + * @param {String} options.color - Color of the marker. + * @param {Number} [options.thresholdIndex=0] - Index of the incomming frame + * data to compare against the threshold. _Should be used in conjonction with + * `threshold`_. + * @param {Number} [options.threshold=null] - Minimum value the incomming value + * must have to trigger the display of a marker. If null each incomming event + * triggers a marker. _Should be used in conjonction with `thresholdIndex`_. + * @param {Number} [options.width=300] - Width of the canvas. + * _dynamic parameter_ + * @param {Number} [options.height=150] - Height of the canvas. + * _dynamic parameter_ + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. _constant parameter_ + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. _constant parameter_ + * @param {Number} [options.duration=1] - Duration (in seconds) represented in + * the canvas. This parameter only exists for operators that display several + * consecutive frames on the canvas. _dynamic parameter_ + * @param {Number} [options.referenceTime=null] - Optionnal reference time the + * display should considerer as the origin. Is only usefull when synchronizing + * several display using the `DisplaySync` class. This parameter only exists + * for operators that display several consecutive frames on the canvas. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const eventIn = new lfo.source.EventIn({ + * frameType: 'scalar', + * }); + * + * const marker = new lfo.sink.MarkerDisplay({ + * canvas: '#marker', + * threshold: 0.5, + * }); + * + * eventIn.connect(marker); + * eventIn.start(); + * + * let time = 0; + * const period = 1; + * + * (function generateData() { + * eventIn.process(time, Math.random()); + * + * time += period; + * setTimeout(generateData, period * 1000); + * }()); + */ + +var MarkerDisplay = function (_BaseDisplay) { + (0, _inherits3.default)(MarkerDisplay, _BaseDisplay); + + function MarkerDisplay() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, MarkerDisplay); + return (0, _possibleConstructorReturn3.default)(this, (MarkerDisplay.__proto__ || (0, _getPrototypeOf2.default)(MarkerDisplay)).call(this, definitions, options)); + } + + /** @private */ + + + (0, _createClass3.default)(MarkerDisplay, [{ + key: 'processVector', + value: function processVector(frame, frameWidth, pixelsSinceLastFrame) { + var color = this.params.get('color'); + var threshold = this.params.get('threshold'); + var thresholdIndex = this.params.get('thresholdIndex'); + var ctx = this.ctx; + var height = ctx.height; + var value = frame.data[thresholdIndex]; + + if (threshold === null || value >= threshold) { + var yMin = this.getYPosition(this.params.get('min')); + var yMax = this.getYPosition(this.params.get('max')); + + if (yMin > yMax) { + var v = yMax; + yMax = yMin; + yMin = v; + } + + ctx.save(); + ctx.fillStyle = color; + ctx.fillRect(0, yMin, 1, yMax); + ctx.restore(); + } + } + }]); + return MarkerDisplay; +}(_BaseDisplay3.default); + +exports.default = MarkerDisplay; + +},{"../utils/display-utils":19,"./BaseDisplay":3,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],6:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseDisplay2 = require('./BaseDisplay'); + +var _BaseDisplay3 = _interopRequireDefault(_BaseDisplay2); + +var _displayUtils = require('../utils/display-utils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var floor = Math.floor; +var ceil = Math.ceil; + +function downSample(data, targetLength) { + var length = data.length; + var hop = length / targetLength; + var target = new Float32Array(targetLength); + var counter = 0; + + for (var i = 0; i < targetLength; i++) { + var index = floor(counter); + var phase = counter - index; + var prev = data[index]; + var next = data[index + 1]; + + target[i] = (next - prev) * phase + prev; + counter += hop; + } + + return target; +} + +var definitions = { + color: { + type: 'string', + default: (0, _displayUtils.getColors)('signal'), + nullable: true + } +}; + +/** + * Display a stream of type `signal` on a canvas. + * + * @param {Object} options - Override default parameters. + * @param {String} [options.color='#00e600'] - Color of the signal. + * @param {Number} [options.min=-1] - Minimum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.max=1] - Maximum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.width=300] - Width of the canvas. + * _dynamic parameter_ + * @param {Number} [options.height=150] - Height of the canvas. + * _dynamic parameter_ + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. _constant parameter_ + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. _constant parameter_ + * @param {Number} [options.duration=1] - Duration (in seconds) represented in + * the canvas. This parameter only exists for operators that display several + * consecutive frames on the canvas. _dynamic parameter_ + * @param {Number} [options.referenceTime=null] - Optionnal reference time the + * display should considerer as the origin. Is only usefull when synchronizing + * several display using the `DisplaySync` class. This parameter only exists + * for operators that display several consecutive frames on the canvas. + * + * @memberof module:client.sink + * + * @example + * const eventIn = new lfo.source.EventIn({ + * frameType: 'signal', + * sampleRate: 8, + * frameSize: 4, + * }); + * + * const signalDisplay = new lfo.sink.SignalDisplay({ + * canvas: '#signal-canvas', + * }); + * + * eventIn.connect(signalDisplay); + * eventIn.start(); + * + * // push triangle signal in the graph + * eventIn.process(0, [0, 0.5, 1, 0.5]); + * eventIn.process(0.5, [0, -0.5, -1, -0.5]); + * // ... + */ + +var SignalDisplay = function (_BaseDisplay) { + (0, _inherits3.default)(SignalDisplay, _BaseDisplay); + + function SignalDisplay(options) { + (0, _classCallCheck3.default)(this, SignalDisplay); + + var _this = (0, _possibleConstructorReturn3.default)(this, (SignalDisplay.__proto__ || (0, _getPrototypeOf2.default)(SignalDisplay)).call(this, definitions, options, true)); + + _this.lastPosY = null; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(SignalDisplay, [{ + key: 'processSignal', + value: function processSignal(frame, frameWidth, pixelsSinceLastFrame) { + var color = this.params.get('color'); + var frameSize = this.streamParams.frameSize; + var ctx = this.ctx; + var data = frame.data; + + if (frameWidth < frameSize) data = downSample(data, frameWidth); + + var length = data.length; + var hopX = frameWidth / length; + var posX = 0; + var lastY = this.lastPosY; + + ctx.strokeStyle = color; + ctx.beginPath(); + + for (var i = 0; i < data.length; i++) { + var posY = this.getYPosition(data[i]); + + if (lastY === null) { + ctx.moveTo(posX, posY); + } else { + if (i === 0) ctx.moveTo(-hopX, lastY); + + ctx.lineTo(posX, posY); + } + + posX += hopX; + lastY = posY; + } + + ctx.stroke(); + ctx.closePath(); + + this.lastPosY = lastY; + } + }]); + return SignalDisplay; +}(_BaseDisplay3.default); + +exports.default = SignalDisplay; + +},{"../utils/display-utils":19,"./BaseDisplay":3,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],7:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _promise = require('babel-runtime/core-js/promise'); + +var _promise2 = _interopRequireDefault(_promise); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +var _wsUtils = require('../../common/utils/wsUtils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var parameters = { + port: { + type: 'integer', + default: 8000, + nullable: true, + constant: true + }, + url: { + type: 'string', + default: null, + nullable: true, + constant: true + } + + /** + * Send an lfo frame as a socket message to a `node.source.SocketReceive` + * instance. + * + *

Experimental

+ * + * @memberof module:client.sink + * + * @example + * const eventIn = new lfo.source.EventIn({ + * frameType: 'vector', + * frameSize: 2, + * frameRate: 1, + * }); + * + * const socketSend = new lfo.sink.SocketSend({ + * port: 3000 + * }); + * + * eventIn.connect(socketSend); + * + * eventIn.init().then(() => { + * eventIn.start(); + * + * let time = 0; + * + * (function createFrame() { + * eventIn.process(time, [Math.random(), Math.random()], { test: true }); + * time += 1; + * + * setTimeout(createFrame, 1000); + * }()); + * }); + */ +}; +var SocketSend = function (_BaseLfo) { + (0, _inherits3.default)(SocketSend, _BaseLfo); + + function SocketSend() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, SocketSend); + + var _this = (0, _possibleConstructorReturn3.default)(this, (SocketSend.__proto__ || (0, _getPrototypeOf2.default)(SocketSend)).call(this, parameters, options)); + + var protocol = window.location.protocol.replace(/^http/, 'ws'); + var address = _this.params.get('url') || window.location.hostname; + var port = _this.params.get('port') || ''; // everything falsy becomes '' + var socketAddress = protocol + '//' + address + ':' + port; + + _this.socket = new WebSocket(socketAddress); + _this.socket.binaryType = 'arraybuffer'; + + _this.openedPromise = new _promise2.default(function (resolve, reject) { + _this.socket.onopen = resolve; + }); + + _this.socket.onerror = function (err) { + return console.error(err.stack); + }; + return _this; + } + + (0, _createClass3.default)(SocketSend, [{ + key: 'initModule', + value: function initModule() { + var _this2 = this; + + // send a INIT_MODULE_REQ and wait for INIT_MODULE_ACK + // no need to get children promises as we are in a leef + return this.openedPromise.then(function () { + return new _promise2.default(function (resolve, reject) { + _this2.socket.onmessage = function (e) { + var opcode = _wsUtils.decoders.opcode(e.data); + + if (opcode === _wsUtils.opcodes.INIT_MODULE_ACK) resolve(); + }; + + var buffer = _wsUtils.encoders.initModuleReq(); + _this2.socket.send(buffer); + }); + }); + } + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + (0, _get3.default)(SocketSend.prototype.__proto__ || (0, _getPrototypeOf2.default)(SocketSend.prototype), 'processStreamParams', this).call(this, prevStreamParams); + + var buffer = _wsUtils.encoders.streamParams(this.streamParams); + this.socket.send(buffer); + } + }, { + key: 'resetStream', + value: function resetStream() { + (0, _get3.default)(SocketSend.prototype.__proto__ || (0, _getPrototypeOf2.default)(SocketSend.prototype), 'resetStream', this).call(this); + + var buffer = _wsUtils.encoders.resetStream(); + this.socket.send(buffer); + } + + /** @private */ + + }, { + key: 'finalizeStream', + value: function finalizeStream(endTime) { + (0, _get3.default)(SocketSend.prototype.__proto__ || (0, _getPrototypeOf2.default)(SocketSend.prototype), 'finalizeStream', this).call(this, endTime); + + var buffer = _wsUtils.encoders.finalizeStream(endTime); + this.socket.send(buffer); + } + + // process any type + /** @private */ + + }, { + key: 'processScalar', + value: function processScalar() {} + /** @private */ + + }, { + key: 'processVector', + value: function processVector() {} + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal() {} + }, { + key: 'processFrame', + value: function processFrame(frame) { + var frameSize = this.streamParams.frameSize; + this.frame.time = frame.time; + this.frame.data.set(frame.data, 0); + this.frame.metadata = frame.metadata; + + var buffer = _wsUtils.encoders.processFrame(this.frame, frameSize); + this.socket.send(buffer); + } + }]); + return SocketSend; +}(_BaseLfo3.default); + +exports.default = SocketSend; + +},{"../../common/utils/wsUtils":49,"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/core-js/promise":66,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],8:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _log = require('babel-runtime/core-js/math/log10'); + +var _log2 = _interopRequireDefault(_log); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseDisplay2 = require('./BaseDisplay'); + +var _BaseDisplay3 = _interopRequireDefault(_BaseDisplay2); + +var _Fft = require('../../common/operator/Fft'); + +var _Fft2 = _interopRequireDefault(_Fft); + +var _displayUtils = require('../utils/display-utils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + scale: { + type: 'float', + default: 1, + metas: { kind: 'dynamic' } + }, + color: { + type: 'string', + default: (0, _displayUtils.getColors)('spectrum'), + nullable: true, + metas: { kind: 'dynamic' } + }, + min: { + type: 'float', + default: -80, + metas: { kind: 'dynamic' } + }, + max: { + type: 'float', + default: 6, + metas: { kind: 'dynamic' } + } +}; + +/** + * Display the spectrum of the incomming `signal` input. + * + * @memberof module:client.sink + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.scale=1] - Scale display of the spectrogram. + * @param {String} [options.color=null] - Color of the spectrogram. + * @param {Number} [options.min=-80] - Minimum displayed value (in dB). + * @param {Number} [options.max=6] - Maximum displayed value (in dB). + * @param {Number} [options.width=300] - Width of the canvas. + * _dynamic parameter_ + * @param {Number} [options.height=150] - Height of the canvas. + * _dynamic parameter_ + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. _constant parameter_ + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. _constant parameter_ + * + * @todo - expose more `fft` config options + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const audioContext = new AudioContext(); + * + * navigator.mediaDevices + * .getUserMedia({ audio: true }) + * .then(init) + * .catch((err) => console.error(err.stack)); + * + * function init(stream) { + * const source = audioContext.createMediaStreamSource(stream); + * + * const audioInNode = new lfo.source.AudioInNode({ + * audioContext: audioContext, + * sourceNode: source, + * }); + * + * const spectrum = new lfo.sink.SpectrumDisplay({ + * canvas: '#spectrum', + * }); + * + * audioInNode.connect(spectrum); + * audioInNode.start(); + * } + */ + +var SpectrumDisplay = function (_BaseDisplay) { + (0, _inherits3.default)(SpectrumDisplay, _BaseDisplay); + + function SpectrumDisplay() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, SpectrumDisplay); + return (0, _possibleConstructorReturn3.default)(this, (SpectrumDisplay.__proto__ || (0, _getPrototypeOf2.default)(SpectrumDisplay)).call(this, definitions, options, false)); + } + + /** @private */ + + + (0, _createClass3.default)(SpectrumDisplay, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + this.fft = new _Fft2.default({ + size: this.streamParams.frameSize, + window: 'hann', + norm: 'linear' + }); + + this.fft.initStream(this.streamParams); + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + var bins = this.fft.inputSignal(frame.data); + var nbrBins = bins.length; + + var width = this.canvasWidth; + var height = this.canvasHeight; + var scale = this.params.get('scale'); + + var binWidth = width / nbrBins; + var ctx = this.ctx; + + ctx.fillStyle = this.params.get('color'); + + // error handling needs review... + var error = 0; + + for (var i = 0; i < nbrBins; i++) { + var x1Float = i * binWidth + error; + var x1Int = Math.round(x1Float); + var x2Float = x1Float + (binWidth - error); + var x2Int = Math.round(x2Float); + + error = x2Int - x2Float; + + if (x1Int !== x2Int) { + var _width = x2Int - x1Int; + var db = 20 * (0, _log2.default)(bins[i]); + var y = this.getYPosition(db * scale); + ctx.fillRect(x1Int, y, _width, height - y); + } else { + error -= binWidth; + } + } + } + }]); + return SpectrumDisplay; +}(_BaseDisplay3.default); + +exports.default = SpectrumDisplay; + +},{"../../common/operator/Fft":24,"../utils/display-utils":19,"./BaseDisplay":3,"babel-runtime/core-js/math/log10":58,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],9:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseDisplay2 = require('./BaseDisplay'); + +var _BaseDisplay3 = _interopRequireDefault(_BaseDisplay2); + +var _displayUtils = require('../utils/display-utils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + color: { + type: 'string', + default: (0, _displayUtils.getColors)('trace'), + metas: { kind: 'dynamic' } + }, + colorScheme: { + type: 'enum', + default: 'none', + list: ['none', 'hue', 'opacity'] + } +}; + +/** + * Display a range value around a mean value (for example mean + * and standart deviation). + * + * This sink can handle input of type `vector` of frameSize >= 2. + * + * @param {Object} options - Override default parameters. + * @param {String} [options.color='orange'] - Color. + * @param {String} [options.colorScheme='none'] - If a third value is available + * in the input, can be used to control the opacity or the hue. If input frame + * size is 2, this param is automatically set to `none` + * @param {Number} [options.min=-1] - Minimum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.max=1] - Maximum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.width=300] - Width of the canvas. + * _dynamic parameter_ + * @param {Number} [options.height=150] - Height of the canvas. + * _dynamic parameter_ + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. _constant parameter_ + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. _constant parameter_ + * @param {Number} [options.duration=1] - Duration (in seconds) represented in + * the canvas. _dynamic parameter_ + * @param {Number} [options.referenceTime=null] - Optionnal reference time the + * display should considerer as the origin. Is only usefull when synchronizing + * several display using the `DisplaySync` class. + * + * @memberof module:client.sink + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const AudioContext = (window.AudioContext || window.webkitAudioContext); + * const audioContext = new AudioContext(); + * + * navigator.mediaDevices + * .getUserMedia({ audio: true }) + * .then(init) + * .catch((err) => console.error(err.stack)); + * + * function init(stream) { + * const source = audioContext.createMediaStreamSource(stream); + * + * const audioInNode = new lfo.source.AudioInNode({ + * sourceNode: source, + * audioContext: audioContext, + * }); + * + * // not sure it make sens but... + * const meanStddev = new lfo.operator.MeanStddev(); + * + * const traceDisplay = new lfo.sink.TraceDisplay({ + * canvas: '#trace', + * }); + * + * const logger = new lfo.sink.Logger({ data: true }); + * + * audioInNode.connect(meanStddev); + * meanStddev.connect(traceDisplay); + * + * audioInNode.start(); + * } + */ + +var TraceDisplay = function (_BaseDisplay) { + (0, _inherits3.default)(TraceDisplay, _BaseDisplay); + + function TraceDisplay() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, TraceDisplay); + + var _this = (0, _possibleConstructorReturn3.default)(this, (TraceDisplay.__proto__ || (0, _getPrototypeOf2.default)(TraceDisplay)).call(this, definitions, options)); + + _this.prevFrame = null; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(TraceDisplay, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + if (this.streamParams.frameSize === 2) this.params.set('colorScheme', 'none'); + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame, frameWidth, pixelsSinceLastFrame) { + var colorScheme = this.params.get('colorScheme'); + var ctx = this.ctx; + var prevData = this.prevFrame ? this.prevFrame.data : null; + var data = frame.data; + + var halfRange = data[1] / 2; + var mean = this.getYPosition(data[0]); + var min = this.getYPosition(data[0] - halfRange); + var max = this.getYPosition(data[0] + halfRange); + + var prevHalfRange = void 0; + var prevMean = void 0; + var prevMin = void 0; + var prevMax = void 0; + + if (prevData !== null) { + prevHalfRange = prevData[1] / 2; + prevMean = this.getYPosition(prevData[0]); + prevMin = this.getYPosition(prevData[0] - prevHalfRange); + prevMax = this.getYPosition(prevData[0] + prevHalfRange); + } + + var color = this.params.get('color'); + var gradient = void 0; + var rgb = void 0; + + switch (colorScheme) { + case 'none': + rgb = (0, _displayUtils.hexToRGB)(color); + ctx.fillStyle = 'rgba(' + rgb.join(',') + ', 0.7)'; + ctx.strokeStyle = color; + break; + case 'hue': + gradient = ctx.createLinearGradient(-pixelsSinceLastFrame, 0, 0, 0); + + if (prevData) gradient.addColorStop(0, 'hsl(' + (0, _displayUtils.getHue)(prevData[2]) + ', 100%, 50%)');else gradient.addColorStop(0, 'hsl(' + (0, _displayUtils.getHue)(data[2]) + ', 100%, 50%)'); + + gradient.addColorStop(1, 'hsl(' + (0, _displayUtils.getHue)(data[2]) + ', 100%, 50%)'); + ctx.fillStyle = gradient; + break; + case 'opacity': + rgb = (0, _displayUtils.hexToRGB)(this.params.get('color')); + gradient = ctx.createLinearGradient(-pixelsSinceLastFrame, 0, 0, 0); + + if (prevData) gradient.addColorStop(0, 'rgba(' + rgb.join(',') + ', ' + prevData[2] + ')');else gradient.addColorStop(0, 'rgba(' + rgb.join(',') + ', ' + data[2] + ')'); + + gradient.addColorStop(1, 'rgba(' + rgb.join(',') + ', ' + data[2] + ')'); + ctx.fillStyle = gradient; + break; + } + + ctx.save(); + // draw range + ctx.beginPath(); + ctx.moveTo(0, mean); + ctx.lineTo(0, max); + + if (prevData !== null) { + ctx.lineTo(-pixelsSinceLastFrame, prevMax); + ctx.lineTo(-pixelsSinceLastFrame, prevMin); + } + + ctx.lineTo(0, min); + ctx.closePath(); + + ctx.fill(); + + // draw mean + if (colorScheme === 'none' && prevMean) { + ctx.beginPath(); + ctx.moveTo(-pixelsSinceLastFrame, prevMean); + ctx.lineTo(0, mean); + ctx.closePath(); + ctx.stroke(); + } + + ctx.restore(); + + this.prevFrame = frame; + } + }]); + return TraceDisplay; +}(_BaseDisplay3.default); + +; + +exports.default = TraceDisplay; + +},{"../utils/display-utils":19,"./BaseDisplay":3,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],10:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _log = require('babel-runtime/core-js/math/log10'); + +var _log2 = _interopRequireDefault(_log); + +var _BaseDisplay2 = require('./BaseDisplay'); + +var _BaseDisplay3 = _interopRequireDefault(_BaseDisplay2); + +var _Rms = require('../../common/operator/Rms'); + +var _Rms2 = _interopRequireDefault(_Rms); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var log10 = _log2.default; + +var definitions = { + offset: { + type: 'float', + default: -14, + metas: { kind: 'dyanmic' } + }, + min: { + type: 'float', + default: -80, + metas: { kind: 'dynamic' } + }, + max: { + type: 'float', + default: 6, + metas: { kind: 'dynamic' } + }, + width: { + type: 'integer', + default: 6, + metas: { kind: 'dynamic' } + } + + /** + * Simple VU-Meter to used on a `signal` stream. + * + * @memberof module:client.sink + * + * @param {Object} options - Override defaults parameters. + * @param {Number} [options.offset=-14] - dB offset applied to the signal. + * @param {Number} [options.min=-80] - Minimum displayed value (in dB). + * @param {Number} [options.max=6] - Maximum displayed value (in dB). + * @param {Number} [options.width=6] - Width of the display (in pixels). + * @param {Number} [options.height=150] - Height of the canvas. + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const audioContext = new window.AudioContext(); + * + * navigator.mediaDevices + * .getUserMedia({ audio: true }) + * .then(init) + * .catch((err) => console.error(err.stack)); + * + * function init(stream) { + * const source = audioContext.createMediaStreamSource(stream); + * + * const audioInNode = new lfo.source.AudioInNode({ + * audioContext: audioContext, + * sourceNode: source, + * }); + * + * const vuMeter = new lfo.sink.VuMeterDisplay({ + * canvas: '#vu-meter', + * }); + * + * audioInNode.connect(vuMeter); + * audioInNode.start(); + * } + */ +}; +var VuMeterDisplay = function (_BaseDisplay) { + (0, _inherits3.default)(VuMeterDisplay, _BaseDisplay); + + function VuMeterDisplay() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, VuMeterDisplay); + + var _this = (0, _possibleConstructorReturn3.default)(this, (VuMeterDisplay.__proto__ || (0, _getPrototypeOf2.default)(VuMeterDisplay)).call(this, definitions, options, false)); + + _this.rmsOperator = new _Rms2.default(); + + _this.lastDB = 0; + _this.peak = { + value: 0, + time: 0 + }; + + _this.peakLifetime = 1; // sec + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(VuMeterDisplay, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + this.rmsOperator.initStream(this.streamParams); + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + var now = new Date().getTime() / 1000; // sec + var offset = this.params.get('offset'); // offset zero of the vu meter + var height = this.canvasHeight; + var width = this.canvasWidth; + var ctx = this.ctx; + + var lastDB = this.lastDB; + var peak = this.peak; + + var red = '#ff2121'; + var yellow = '#ffff1f'; + var green = '#00ff00'; + + // handle current db value + var rms = this.rmsOperator.inputSignal(frame.data); + var dB = 20 * log10(rms) - offset; + + // slow release (could probably be improved) + if (lastDB > dB) dB = lastDB - 6; + + // handle peak + if (dB > peak.value || now - peak.time > this.peakLifetime) { + peak.value = dB; + peak.time = now; + } + + var y0 = this.getYPosition(0); + var y = this.getYPosition(dB); + var yPeak = this.getYPosition(peak.value); + + ctx.save(); + + ctx.fillStyle = '#000000'; + ctx.fillRect(0, 0, width, height); + + var gradient = ctx.createLinearGradient(0, height, 0, 0); + gradient.addColorStop(0, green); + gradient.addColorStop((height - y0) / height, yellow); + gradient.addColorStop(1, red); + + // dB + ctx.fillStyle = gradient; + ctx.fillRect(0, y, width, height - y); + + // 0 dB marker + ctx.fillStyle = '#dcdcdc'; + ctx.fillRect(0, y0, width, 2); + + // peak + ctx.fillStyle = gradient; + ctx.fillRect(0, yPeak, width, 2); + + ctx.restore(); + + this.lastDB = dB; + } + }]); + return VuMeterDisplay; +}(_BaseDisplay3.default); + +exports.default = VuMeterDisplay; + +},{"../../common/operator/Rms":36,"./BaseDisplay":3,"babel-runtime/core-js/math/log10":58,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],11:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseDisplay2 = require('./BaseDisplay'); + +var _BaseDisplay3 = _interopRequireDefault(_BaseDisplay2); + +var _MinMax = require('../../common/operator/MinMax'); + +var _MinMax2 = _interopRequireDefault(_MinMax); + +var _Rms = require('../../common/operator/Rms'); + +var _Rms2 = _interopRequireDefault(_Rms); + +var _displayUtils = require('../utils/display-utils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + colors: { + type: 'any', + default: (0, _displayUtils.getColors)('waveform'), + metas: { kind: 'dyanmic' } + }, + rms: { + type: 'boolean', + default: false, + metas: { kind: 'dyanmic' } + } +}; + +/** + * Display a waveform (along with optionnal Rms) of a given `signal` input in + * a canvas. + * + * @param {Object} options - Override default parameters. + * @param {Array} [options.colors=['waveform', 'rms']] - Array + * containing the color codes for the waveform (index 0) and rms (index 1). + * _dynamic parameter_ + * @param {Boolean} [options.rms=false] - Set to `true` to display the rms. + * _dynamic parameter_ + * @param {Number} [options.duration=1] - Duration (in seconds) represented in + * the canvas. _dynamic parameter_ + * @param {Number} [options.min=-1] - Minimum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.max=1] - Maximum value represented in the canvas. + * _dynamic parameter_ + * @param {Number} [options.width=300] - Width of the canvas. + * _dynamic parameter_ + * @param {Number} [options.height=150] - Height of the canvas. + * _dynamic parameter_ + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. _constant parameter_ + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. _constant parameter_ + * @param {Number} [options.referenceTime=null] - Optionnal reference time the + * display should considerer as the origin. Is only usefull when synchronizing + * several display using the `DisplaySync` class. + * + * @memberof module:client.sink + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const audioContext = new window.AudioContext(); + * + * navigator.mediaDevices + * .getUserMedia({ audio: true }) + * .then(init) + * .catch((err) => console.error(err.stack)); + * + * function init(stream) { + * const audioIn = audioContext.createMediaStreamSource(stream); + * + * const audioInNode = new lfo.source.AudioInNode({ + * audioContext: audioContext, + * sourceNode: audioIn, + * frameSize: 512, + * }); + * + * const waveformDisplay = new lfo.sink.WaveformDisplay({ + * canvas: '#waveform', + * duration: 3.5, + * rms: true, + * }); + * + * audioInNode.connect(waveformDisplay); + * audioInNode.start(); + * }); + */ + +var WaveformDisplay = function (_BaseDisplay) { + (0, _inherits3.default)(WaveformDisplay, _BaseDisplay); + + function WaveformDisplay(options) { + (0, _classCallCheck3.default)(this, WaveformDisplay); + + var _this = (0, _possibleConstructorReturn3.default)(this, (WaveformDisplay.__proto__ || (0, _getPrototypeOf2.default)(WaveformDisplay)).call(this, definitions, options, true)); + + _this.minMaxOperator = new _MinMax2.default(); + _this.rmsOperator = new _Rms2.default(); + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(WaveformDisplay, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + this.minMaxOperator.initStream(this.streamParams); + this.rmsOperator.initStream(this.streamParams); + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame, frameWidth, pixelsSinceLastFrame) { + // drop frames that cannot be displayed + if (frameWidth < 1) return; + + var colors = this.params.get('colors'); + var showRms = this.params.get('rms'); + var ctx = this.ctx; + var data = frame.data; + var iSamplesPerPixels = Math.floor(data.length / frameWidth); + + for (var index = 0; index < frameWidth; index++) { + var start = index * iSamplesPerPixels; + var end = index === frameWidth - 1 ? undefined : start + iSamplesPerPixels; + var slice = data.subarray(start, end); + + var minMax = this.minMaxOperator.inputSignal(slice); + var minY = this.getYPosition(minMax[0]); + var maxY = this.getYPosition(minMax[1]); + + ctx.strokeStyle = colors[0]; + ctx.beginPath(); + ctx.moveTo(index, minY); + ctx.lineTo(index, maxY); + ctx.closePath(); + ctx.stroke(); + + if (showRms) { + var rms = this.rmsOperator.inputSignal(slice); + var rmsMaxY = this.getYPosition(rms); + var rmsMinY = this.getYPosition(-rms); + + ctx.strokeStyle = colors[1]; + ctx.beginPath(); + ctx.moveTo(index, rmsMinY); + ctx.lineTo(index, rmsMaxY); + ctx.closePath(); + ctx.stroke(); + } + } + } + }]); + return WaveformDisplay; +}(_BaseDisplay3.default); + +exports.default = WaveformDisplay; + +},{"../../common/operator/MinMax":30,"../../common/operator/Rms":36,"../utils/display-utils":19,"./BaseDisplay":3,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],12:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _Bridge = require('../../common/sink/Bridge'); + +var _Bridge2 = _interopRequireDefault(_Bridge); + +var _Logger = require('../../common/sink/Logger'); + +var _Logger2 = _interopRequireDefault(_Logger); + +var _DataRecorder = require('../../common/sink/DataRecorder'); + +var _DataRecorder2 = _interopRequireDefault(_DataRecorder); + +var _SignalRecorder = require('../../common/sink/SignalRecorder'); + +var _SignalRecorder2 = _interopRequireDefault(_SignalRecorder); + +var _BaseDisplay = require('./BaseDisplay'); + +var _BaseDisplay2 = _interopRequireDefault(_BaseDisplay); + +var _BarChartDisplay = require('./BarChartDisplay'); + +var _BarChartDisplay2 = _interopRequireDefault(_BarChartDisplay); + +var _BpfDisplay = require('./BpfDisplay'); + +var _BpfDisplay2 = _interopRequireDefault(_BpfDisplay); + +var _MarkerDisplay = require('./MarkerDisplay'); + +var _MarkerDisplay2 = _interopRequireDefault(_MarkerDisplay); + +var _SignalDisplay = require('./SignalDisplay'); + +var _SignalDisplay2 = _interopRequireDefault(_SignalDisplay); + +var _SocketSend = require('./SocketSend'); + +var _SocketSend2 = _interopRequireDefault(_SocketSend); + +var _SpectrumDisplay = require('./SpectrumDisplay'); + +var _SpectrumDisplay2 = _interopRequireDefault(_SpectrumDisplay); + +var _TraceDisplay = require('./TraceDisplay'); + +var _TraceDisplay2 = _interopRequireDefault(_TraceDisplay); + +var _VuMeterDisplay = require('./VuMeterDisplay'); + +var _VuMeterDisplay2 = _interopRequireDefault(_VuMeterDisplay); + +var _WaveformDisplay = require('./WaveformDisplay'); + +var _WaveformDisplay2 = _interopRequireDefault(_WaveformDisplay); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// client only +// common +exports.default = { + Bridge: _Bridge2.default, + Logger: _Logger2.default, + DataRecorder: _DataRecorder2.default, + SignalRecorder: _SignalRecorder2.default, + + BaseDisplay: _BaseDisplay2.default, + BarChartDisplay: _BarChartDisplay2.default, + BpfDisplay: _BpfDisplay2.default, + MarkerDisplay: _MarkerDisplay2.default, + SignalDisplay: _SignalDisplay2.default, + SocketSend: _SocketSend2.default, + SpectrumDisplay: _SpectrumDisplay2.default, + TraceDisplay: _TraceDisplay2.default, + VuMeterDisplay: _VuMeterDisplay2.default, + WaveformDisplay: _WaveformDisplay2.default +}; + +},{"../../common/sink/Bridge":43,"../../common/sink/DataRecorder":44,"../../common/sink/Logger":45,"../../common/sink/SignalRecorder":46,"./BarChartDisplay":2,"./BaseDisplay":3,"./BpfDisplay":4,"./MarkerDisplay":5,"./SignalDisplay":6,"./SocketSend":7,"./SpectrumDisplay":8,"./TraceDisplay":9,"./VuMeterDisplay":10,"./WaveformDisplay":11}],13:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _defineProperty2 = require('babel-runtime/helpers/defineProperty'); + +var _defineProperty3 = _interopRequireDefault(_defineProperty2); + +var _definitions; + +var _BaseLfo = require('../../core/BaseLfo'); + +var _BaseLfo2 = _interopRequireDefault(_BaseLfo); + +var _SourceMixin2 = require('../../core/SourceMixin'); + +var _SourceMixin3 = _interopRequireDefault(_SourceMixin2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = (_definitions = { + audioBuffer: { + type: 'any', + default: null, + constant: true + }, + frameSize: { + type: 'integer', + default: 512, + constant: true + }, + channel: { + type: 'integer', + default: 0, + constant: true + }, + progressCallback: { + type: 'any', + default: null, + nullable: true, + constant: true + } +}, (0, _defineProperty3.default)(_definitions, 'progressCallback', { + type: 'any', + default: null, + nullable: true, + constant: true +}), (0, _defineProperty3.default)(_definitions, 'async', { + type: 'boolean', + default: false +}), _definitions); + +var noop = function noop() {}; + +/** + * Slice an `AudioBuffer` into signal blocks and propagate the resulting frames + * through the graph. + * + * @param {Object} options - Override parameter' default values. + * @param {AudioBuffer} [options.audioBuffer] - Audio buffer to process. + * @param {Number} [options.frameSize=512] - Size of the output blocks. + * @param {Number} [options.channel=0] - Number of the channel to process. + * @param {Number} [options.progressCallback=null] - Callback to be excuted on each + * frame output, receive as argument the current progress ratio. + * + * @memberof module:client.source + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const audioInBuffer = new lfo.source.AudioInBuffer({ + * audioBuffer: audioBuffer, + * frameSize: 512, + * }); + * + * const waveform = new lfo.sink.Waveform({ + * canvas: '#waveform', + * duration: 1, + * color: 'steelblue', + * rms: true, + * }); + * + * audioInBuffer.connect(waveform); + * audioInBuffer.start(); + */ + +var AudioInBuffer = function (_SourceMixin) { + (0, _inherits3.default)(AudioInBuffer, _SourceMixin); + + function AudioInBuffer() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, AudioInBuffer); + + var _this = (0, _possibleConstructorReturn3.default)(this, (AudioInBuffer.__proto__ || (0, _getPrototypeOf2.default)(AudioInBuffer)).call(this, definitions, options)); + + var audioBuffer = _this.params.get('audioBuffer'); + + if (!audioBuffer) throw new Error('Invalid "audioBuffer" parameter'); + + _this.endTime = 0; + return _this; + } + + /** + * Propagate the `streamParams` in the graph and start propagating frames. + * When called, the slicing of the given `audioBuffer` starts immediately and + * each resulting frame is propagated in graph. + * + * @see {@link module:core.BaseLfo#processStreamParams} + * @see {@link module:core.BaseLfo#resetStream} + * @see {@link module:client.source.AudioInBuffer#stop} + */ + + + (0, _createClass3.default)(AudioInBuffer, [{ + key: 'start', + value: function start() { + if (this.initialized === false) { + if (this.initPromise === null) // init has not yet been called + this.initPromise = this.init(); + + this.initPromise.then(this.start); + return; + } + + var channel = this.params.get('channel'); + var audioBuffer = this.params.get('audioBuffer'); + var buffer = audioBuffer.getChannelData(channel); + this.endTime = 0; + this.started = true; + + this.processFrame(buffer); + } + + /** + * Finalize the stream and stop the whole graph. When called, the slicing of + * the `audioBuffer` stops immediately. + * + * @see {@link module:core.BaseLfo#finalizeStream} + * @see {@link module:client.source.AudioInBuffer#start} + */ + + }, { + key: 'stop', + value: function stop() { + this.finalizeStream(this.endTime); + this.started = false; + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams() { + var audioBuffer = this.params.get('audioBuffer'); + var frameSize = this.params.get('frameSize'); + var sourceSampleRate = audioBuffer.sampleRate; + var frameRate = sourceSampleRate / frameSize; + + this.streamParams.frameSize = frameSize; + this.streamParams.frameRate = frameRate; + this.streamParams.frameType = 'signal'; + this.streamParams.sourceSampleRate = sourceSampleRate; + this.streamParams.sourceSampleCount = frameSize; + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processFrame', + value: function processFrame(buffer) { + var async = this.params.get('async'); + var sampleRate = this.streamParams.sourceSampleRate; + var frameSize = this.streamParams.frameSize; + var progressCallback = this.params.get('progressCallback') || noop; + var length = buffer.length; + var nbrFrames = Math.ceil(buffer.length / frameSize); + var data = this.frame.data; + var that = this; + var i = 0; + + function slice() { + var offset = i * frameSize; + var nbrCopy = Math.min(length - offset, frameSize); + + for (var j = 0; j < frameSize; j++) { + data[j] = j < nbrCopy ? buffer[offset + j] : 0; + }that.frame.time = offset / sampleRate; + that.endTime = that.frame.time + nbrCopy / sampleRate; + that.propagateFrame(); + + i += 1; + progressCallback(i / nbrFrames); + + if (i < nbrFrames) { + if (async) setTimeout(slice, 0);else slice(); + } else { + that.finalizeStream(that.endTime); + } + }; + + // allow the following to do the expected thing: + // audioIn.connect(recorder); + // audioIn.start(); + // recorder.start(); + setTimeout(slice, 0); + } + }]); + return AudioInBuffer; +}((0, _SourceMixin3.default)(_BaseLfo2.default)); + +exports.default = AudioInBuffer; + +},{"../../core/BaseLfo":50,"../../core/SourceMixin":51,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/defineProperty":71,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],14:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo = require('../../core/BaseLfo'); + +var _BaseLfo2 = _interopRequireDefault(_BaseLfo); + +var _SourceMixin2 = require('../../core/SourceMixin'); + +var _SourceMixin3 = _interopRequireDefault(_SourceMixin2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var AudioContext = window.AudioContext || window.webkitAudioContext; + +var definitions = { + frameSize: { + type: 'integer', + default: 512, + constant: true + }, + channel: { + type: 'integer', + default: 0, + constant: true + }, + sourceNode: { + type: 'any', + default: null, + constant: true + }, + audioContext: { + type: 'any', + default: null, + constant: true + } +}; + +/** + * Use a `WebAudio` node as a source for the graph. + * + * @param {Object} options - Override parameter' default values. + * @param {AudioNode} [options.sourceNode=null] - Audio node to process + * (mandatory). + * @param {AudioContext} [options.audioContext=null] - Audio context used to + * create the audio node (mandatory). + * @param {Number} [options.frameSize=512] - Size of the output blocks, define + * the `frameSize` in the `streamParams`. + * @param {Number} [options.channel=0] - Number of the channel to process. + * + * @memberof module:client.source + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const audioContext = new AudioContext(); + * const sine = audioContext.createOscillator(); + * sine.frequency.value = 2; + * + * const audioInNode = new lfo.source.AudioInNode({ + * audioContext: audioContext, + * sourceNode: sine, + * }); + * + * const signalDisplay = new lfo.sink.SignalDisplay({ + * canvas: '#signal', + * duration: 1, + * }); + * + * audioInNode.connect(signalDisplay); + * + * // start the sine oscillator node and the lfo graph + * sine.start(); + * audioInNode.start(); + */ + +var AudioInNode = function (_SourceMixin) { + (0, _inherits3.default)(AudioInNode, _SourceMixin); + + function AudioInNode() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, AudioInNode); + + var _this = (0, _possibleConstructorReturn3.default)(this, (AudioInNode.__proto__ || (0, _getPrototypeOf2.default)(AudioInNode)).call(this, definitions, options)); + + var audioContext = _this.params.get('audioContext'); + var sourceNode = _this.params.get('sourceNode'); + + if (!audioContext || !(audioContext instanceof AudioContext)) throw new Error('Invalid `audioContext` parameter'); + + if (!sourceNode || !(sourceNode instanceof AudioNode)) throw new Error('Invalid `sourceNode` parameter'); + + _this.sourceNode = sourceNode; + _this._channel = _this.params.get('channel'); + _this._blockDuration = null; + + _this.processFrame = _this.processFrame.bind(_this); + return _this; + } + + /** + * Propagate the `streamParams` in the graph and start to propagate signal + * blocks produced by the audio node into the graph. + * + * @see {@link module:core.BaseLfo#processStreamParams} + * @see {@link module:core.BaseLfo#resetStream} + * @see {@link module:client.source.AudioInNode#stop} + */ + + + (0, _createClass3.default)(AudioInNode, [{ + key: 'start', + value: function start() { + if (this.initialized === false) { + if (this.initPromise === null) // init has not yet been called + this.initPromise = this.init(); + + this.initPromise.then(this.start); + return; + } + + var audioContext = this.params.get('audioContext'); + var frameSize = this.params.get('frameSize'); + + this.frame.time = 0; + // @note: recreate each time because of a firefox weird behavior + this.scriptProcessor = audioContext.createScriptProcessor(frameSize, 1, 1); + this.scriptProcessor.onaudioprocess = this.processFrame; + + this.started = true; + this.sourceNode.connect(this.scriptProcessor); + this.scriptProcessor.connect(audioContext.destination); + } + + /** + * Finalize the stream and stop the whole graph. + * + * @see {@link module:core.BaseLfo#finalizeStream} + * @see {@link module:client.source.AudioInNode#start} + */ + + }, { + key: 'stop', + value: function stop() { + this.finalizeStream(this.frame.time); + this.started = false; + this.sourceNode.disconnect(); + this.scriptProcessor.disconnect(); + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams() { + var audioContext = this.params.get('audioContext'); + var frameSize = this.params.get('frameSize'); + var sampleRate = audioContext.sampleRate; + + this.streamParams.frameSize = frameSize; + this.streamParams.frameRate = sampleRate / frameSize; + this.streamParams.frameType = 'signal'; + this.streamParams.sourceSampleRate = sampleRate; + this.streamParams.sourceSampleCount = frameSize; + + this._blockDuration = frameSize / sampleRate; + + this.propagateStreamParams(); + } + + /** + * Basically the `scriptProcessor.onaudioprocess` callback + * @private + */ + + }, { + key: 'processFrame', + value: function processFrame(e) { + if (this.started === false) return; + + this.frame.data = e.inputBuffer.getChannelData(this._channel); + this.propagateFrame(); + + this.frame.time += this._blockDuration; + } + }]); + return AudioInNode; +}((0, _SourceMixin3.default)(_BaseLfo2.default)); + +exports.default = AudioInNode; + +},{"../../core/BaseLfo":50,"../../core/SourceMixin":51,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],15:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _promise = require('babel-runtime/core-js/promise'); + +var _promise2 = _interopRequireDefault(_promise); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +var _wsUtils = require('../../common/utils/wsUtils'); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var parameters = { + port: { + type: 'integer', + default: 8000, + nullable: true, + constant: true + }, + url: { + type: 'string', + default: null, + nullable: true, + constant: true + } + + /** + * Receive an lfo frame as a socket message from a `node.sink.SocketSend` + * instance. + * + *

Experimental

+ * + * @memberof module:client.source + * + * @todo - handle init / start properly. + */ +}; +var SocketReceive = function (_BaseLfo) { + (0, _inherits3.default)(SocketReceive, _BaseLfo); + + function SocketReceive() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, SocketReceive); + + var _this = (0, _possibleConstructorReturn3.default)(this, (SocketReceive.__proto__ || (0, _getPrototypeOf2.default)(SocketReceive)).call(this, parameters, options)); + + var protocol = window.location.protocol.replace(/^http/, 'ws'); + var address = _this.params.get('url') || window.location.hostname; + var port = _this.params.get('port') || ''; // everything falsy becomes '' + var socketAddress = protocol + '//' + address + ':' + port; + + _this._dispatch = _this._dispatch.bind(_this); + + _this.socket = new WebSocket(socketAddress); + _this.socket.binaryType = 'arraybuffer'; + + _this.openedPromise = new _promise2.default(function (resolve, reject) { + _this.socket.onopen = resolve; + }); + + _this.socket.onmessage = _this._dispatch; + _this.socket.onerror = function (err) { + return console.error(err.stack); + }; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(SocketReceive, [{ + key: 'initModule', + value: function initModule() { + var _this2 = this; + + var promises = this.nextModules.map(function (mod) { + return mod.initModule(); + }); + promises.push(this.openedPromise); + // wait for children promises and send INIT_MODULE_ACK + _promise2.default.all(promises).then(function () { + var buffer = _wsUtils.encoders.initModuleAck(); + _this2.socket.send(buffer); + }); + } + + // process any type + /** @private */ + + }, { + key: 'processScalar', + value: function processScalar() {} + /** @private */ + + }, { + key: 'processVector', + value: function processVector() {} + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal() {} + + /** @private */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + this.prepareFrame(); + this.frame = frame; + this.propagateFrame(); + } + + /** + * Decode and dispatch incomming frame according to opcode + * @private + */ + + }, { + key: '_dispatch', + value: function _dispatch(e) { + var arrayBuffer = e.data; + var opcode = _wsUtils.decoders.opcode(arrayBuffer); + + switch (opcode) { + case _wsUtils.opcodes.INIT_MODULE_REQ: + this.initModule(); + break; + case _wsUtils.opcodes.PROCESS_STREAM_PARAMS: + var prevStreamParams = _wsUtils.decoders.streamParams(arrayBuffer); + this.processStreamParams(prevStreamParams); + break; + case _wsUtils.opcodes.RESET_STREAM: + this.resetStream(); + break; + case _wsUtils.opcodes.FINALIZE_STREAM: + var endTime = _wsUtils.decoders.finalizeStream(arrayBuffer); + this.finalizeStream(endTime); + break; + case _wsUtils.opcodes.PROCESS_FRAME: + var frameSize = this.streamParams.frameSize; + var frame = _wsUtils.decoders.processFrame(arrayBuffer, frameSize); + this.processFrame(frame); + break; + } + } + }]); + return SocketReceive; +}(_BaseLfo3.default); + +exports.default = SocketReceive; + +},{"../../common/utils/wsUtils":49,"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/core-js/promise":66,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],16:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _EventIn = require('../../common/source/EventIn'); + +var _EventIn2 = _interopRequireDefault(_EventIn); + +var _AudioInBuffer = require('./AudioInBuffer'); + +var _AudioInBuffer2 = _interopRequireDefault(_AudioInBuffer); + +var _AudioInNode = require('./AudioInNode'); + +var _AudioInNode2 = _interopRequireDefault(_AudioInNode); + +var _SocketReceive = require('./SocketReceive'); + +var _SocketReceive2 = _interopRequireDefault(_SocketReceive); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// common +exports.default = { + EventIn: _EventIn2.default, + + AudioInBuffer: _AudioInBuffer2.default, + AudioInNode: _AudioInNode2.default, + SocketReceive: _SocketReceive2.default +}; +// client only + +},{"../../common/source/EventIn":47,"./AudioInBuffer":13,"./AudioInNode":14,"./SocketReceive":15}],17:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck"); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require("babel-runtime/helpers/createClass"); + +var _createClass3 = _interopRequireDefault(_createClass2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Synchronize several display sinks to a common time. + * + * @param {...BaseDisplay} views - List of the display to synchronize. + * + * @memberof module:client.utils + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const eventIn1 = new lfo.source.EventIn({ + * frameType: 'scalar', + * frameSize: 1, + * }); + * + * const bpf1 = new lfo.sink.BpfDisplay({ + * canvas: '#bpf-1', + * duration: 2, + * startTime: 0, + * min: 0, + * colors: ['steelblue'], + * }); + * + * eventIn1.connect(bpf1); + * + * const eventIn2 = new lfo.source.EventIn({ + * frameType: 'scalar', + * frameSize: 1, + * }); + * + * const bpf2 = new lfo.sink.BpfDisplay({ + * canvas: '#bpf-2', + * duration: 2, + * startTime: 7, + * min: 0, + * colors: ['orange'], + * }); + * + * const displaySync = new lfo.utils.DisplaySync(bpf1, bpf2); + * + * eventIn2.connect(bpf2); + * + * eventIn1.start(); + * eventIn2.start(); + * + * let time = 0; + * const period = 0.4; + * const offset = 7.2; + * + * (function generateData() { + * const v = Math.random(); + * + * eventIn1.process(time, v); + * eventIn2.process(time + offset, v); + * + * time += period; + * + * setTimeout(generateData, period * 1000); + * }()); + */ +var DisplaySync = function () { + function DisplaySync() { + (0, _classCallCheck3.default)(this, DisplaySync); + + this.views = []; + + this.add.apply(this, arguments); + } + + /** @private */ + + + (0, _createClass3.default)(DisplaySync, [{ + key: "add", + value: function add() { + var _this = this; + + for (var _len = arguments.length, views = Array(_len), _key = 0; _key < _len; _key++) { + views[_key] = arguments[_key]; + } + + views.forEach(function (view) { + return _this.install(view); + }); + } + + /** @private */ + + }, { + key: "install", + value: function install(view) { + this.views.push(view); + + view.displaySync = this; + } + + /** @private */ + + }, { + key: "shiftSiblings", + value: function shiftSiblings(iShift, time, view) { + this.views.forEach(function (display) { + if (display !== view) display.shiftCanvas(iShift, time); + }); + } + }]); + return DisplaySync; +}(); + +exports.default = DisplaySync; + +},{"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70}],18:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _DisplaySync = require('./DisplaySync'); + +var _DisplaySync2 = _interopRequireDefault(_DisplaySync); + +var _windows = require('../../common/utils/windows'); + +var _windows2 = _interopRequireDefault(_windows); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = { + DisplaySync: _DisplaySync2.default, + initWindows: _windows2.default +}; + +},{"../../common/utils/windows":48,"./DisplaySync":17}],19:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var colors = ['#4682B4', '#ffa500', '#00e600', '#ff0000', '#800080', '#224153']; + +var getColors = exports.getColors = function getColors(type, nbr) { + switch (type) { + case 'signal': + return colors[0]; // steelblue + break; + case 'bpf': + if (nbr <= colors.length) { + return colors.slice(0, nbr); + } else { + var _colors = colors.slice(0); + while (_colors.length < nbr) { + _colors.push(getRandomColor()); + }return _colors; + } + break; + case 'waveform': + return [colors[0], colors[5]]; // steelblue / darkblue + break; + case 'marker': + return colors[3]; // red + break; + case 'spectrum': + return colors[2]; // green + break; + case 'trace': + return colors[1]; // orange + break; + case 'bar-chart': + return colors; + break; + } +}; + +// http://stackoverflow.com/questions/1484506/random-color-generator-in-javascript +var getRandomColor = exports.getRandomColor = function getRandomColor() { + var letters = '0123456789ABCDEF'.split(''); + var color = '#'; + for (var i = 0; i < 6; i++) { + color += letters[Math.floor(Math.random() * 16)]; + } + return color; +}; + +// scale from domain [0, 1] to range [270, 0] to consume in +// hsl(x, 100%, 50%) color scheme +var getHue = exports.getHue = function getHue(x) { + var domainMin = 0; + var domainMax = 1; + var rangeMin = 270; + var rangeMax = 0; + + return (rangeMax - rangeMin) * (x - domainMin) / (domainMax - domainMin) + rangeMin; +}; + +var hexToRGB = exports.hexToRGB = function hexToRGB(hex) { + hex = hex.substring(1, 7); + var r = parseInt(hex.substring(0, 2), 16); + var g = parseInt(hex.substring(2, 4), 16); + var b = parseInt(hex.substring(4, 6), 16); + return [r, g, b]; +}; + +},{}],20:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var sin = Math.sin; +var cos = Math.cos; +var sqrt = Math.sqrt; +var pow = Math.pow; +var _2PI = Math.PI * 2; + +// plot (from http://www.earlevel.com/scripts/widgets/20131013/biquads2.js) +// var len = 512; +// var magPlot = []; +// for (var idx = 0; idx < len; idx++) { +// var w; +// if (plotType == "linear") +// w = idx / (len - 1) * Math.PI; // 0 to pi, linear scale +// else +// w = Math.exp(Math.log(1 / 0.001) * idx / (len - 1)) * 0.001 * Math.PI; // 0.001 to 1, times pi, log scale + +// var phi = Math.pow(Math.sin(w/2), 2); +// var y = Math.log(Math.pow(a0+a1+a2, 2) - 4*(a0*a1 + 4*a0*a2 + a1*a2)*phi + 16*a0*a2*phi*phi) - Math.log(Math.pow(1+b1+b2, 2) - 4*(b1 + 4*b2 + b1*b2)*phi + 16*b2*phi*phi); +// y = y * 10 / Math.LN10 +// if (y == -Infinity) +// y = -200; + +// if (plotType == "linear") +// magPlot.push([idx / (len - 1) * Fs / 2, y]); +// else +// magPlot.push([idx / (len - 1) / 2, y]); + +// if (idx == 0) +// minVal = maxVal = y; +// else if (y < minVal) +// minVal = y; +// else if (y > maxVal) +// maxVal = y; +// } + +var definitions = { + type: { + type: 'enum', + default: 'lowpass', + list: ['lowpass', 'highpass', 'bandpass_constant_skirt', 'bandpass', 'bandpass_constant_peak', 'notch', 'allpass', 'peaking', 'lowshelf', 'highshelf'], + metas: { kind: 'dyanmic' } + }, + f0: { + type: 'float', + default: 1, + metas: { kind: 'dyanmic' } + }, + gain: { + type: 'float', + default: 1, + min: 0, + metas: { kind: 'dyanmic' } + }, + q: { + type: 'float', + default: 1, + min: 0.001, // PIPO_BIQUAD_MIN_Q + // max: 1, + metas: { kind: 'dyanmic' } + } + // bandwidth: { + // type: 'float', + // default: null, + // nullable: true, + // metas: { kind: 'dyanmic' }, + // }, + + + /** + * Biquad filter (Direct form I). If input is of type `vector` the filter is + * applied on each dimension i parallel. + * + * Based on the ["Cookbook formulae for audio EQ biquad filter coefficients"](http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt) + * by Robert Bristow-Johnson. + * + * @memberof module:common.operator + * + * @param {Object} options - Override default values. + * @param {String} [options.type='lowpass'] - Type of the filter. Available + * filters: 'lowpass', 'highpass', 'bandpass_constant_skirt', 'bandpass_constant_peak' + * (alias 'bandpass'), 'notch', 'allpass', 'peaking', 'lowshelf', 'highshelf'. + * @param {Number} [options.f0=1] - Cutoff or center frequency of the filter + * according to its type. + * @param {Number} [options.gain=1] - Gain of the filter (in dB). + * @param {Number} [options.q=1] - Quality factor of the filter. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const audioInBuffer = new lfo.source.AudioInBuffer({ + * audioBuffer: buffer, + * }); + * + * const biquad = new lfo.operator.Biquad({ + * type: 'lowpass', + * f0: 2000, + * gain: 3, + * q: 12, + * }); + * + * const spectrumDisplay = new lfo.sink.SpectrumDisplay({ + * canvas: '#spectrum', + * }); + * + * audioInBuffer.connect(biquad); + * biquad.connect(spectrumDisplay); + * + * audioInBuffer.start(); + */ +}; +var Biquad = function (_BaseLfo) { + (0, _inherits3.default)(Biquad, _BaseLfo); + + function Biquad() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Biquad); + return (0, _possibleConstructorReturn3.default)(this, (Biquad.__proto__ || (0, _getPrototypeOf2.default)(Biquad)).call(this, definitions, options)); + } + + (0, _createClass3.default)(Biquad, [{ + key: 'onParamUpdate', + value: function onParamUpdate(name, value, metas) { + this._calculateCoefs(); + } + }, { + key: '_calculateCoefs', + value: function _calculateCoefs() { + var sampleRate = this.streamParams.sourceSampleRate; + var frameType = this.streamParams.frameType; + var frameSize = this.streamParams.frameSize; + + var type = this.params.get('type'); + var f0 = this.params.get('f0'); + var gain = this.params.get('gain'); + var q = this.params.get('q'); + // const bandwidth = this.params.get('bandwidth'); + var bandwidth = null; + + var b0 = 0, + b1 = 0, + b2 = 0, + a0 = 0, + a1 = 0, + a2 = 0; + + var A = pow(10, gain / 40); + var w0 = _2PI * f0 / sampleRate; + var cosW0 = cos(w0); + var sinW0 = sin(w0); + var alpha = void 0; // depend of the filter type + var _2RootAAlpha = void 0; // intermediate value for lowshelf and highshelf + + switch (type) { + // H(s) = 1 / (s^2 + s/Q + 1) + case 'lowpass': + alpha = sinW0 / (2 * q); + b0 = (1 - cosW0) / 2; + b1 = 1 - cosW0; + b2 = b0; + a0 = 1 + alpha; + a1 = -2 * cosW0; + a2 = 1 - alpha; + break; + // H(s) = s^2 / (s^2 + s/Q + 1) + case 'highpass': + alpha = sinW0 / (2 * q); + b0 = (1 + cosW0) / 2; + b1 = -(1 + cosW0); + b2 = b0; + a0 = 1 + alpha; + a1 = -2 * cosW0; + a2 = 1 - alpha; + break; + // H(s) = s / (s^2 + s/Q + 1) (constant skirt gain, peak gain = Q) + case 'bandpass_constant_skirt': + if (bandwidth) { + // sin(w0)*sinh( ln(2)/2 * BW * w0/sin(w0) ) (case: BW) + } else { + alpha = sinW0 / (2 * q); + } + + b0 = sinW0 / 2; + b1 = 0; + b2 = -b0; + a0 = 1 + alpha; + a1 = -2 * cosW0; + a2 = 1 - alpha; + break; + // H(s) = (s/Q) / (s^2 + s/Q + 1) (constant 0 dB peak gain) + case 'bandpass': // looks like what is gnerally considered as a bandpass + case 'bandpass_constant_peak': + if (bandwidth) { + // sin(w0)*sinh( ln(2)/2 * BW * w0/sin(w0) ) (case: BW) + } else { + alpha = sinW0 / (2 * q); + } + + b0 = alpha; + b1 = 0; + b2 = -alpha; + a0 = 1 + alpha; + a1 = -2 * cosW0; + a2 = 1 - alpha; + break; + // H(s) = (s^2 + 1) / (s^2 + s/Q + 1) + case 'notch': + alpha = sinW0 / (2 * q); + b0 = 1; + b1 = -2 * cosW0; + b2 = 1; + a0 = 1 + alpha; + a1 = b1; + a2 = 1 - alpha; + break; + // H(s) = (s^2 - s/Q + 1) / (s^2 + s/Q + 1) + case 'allpass': + alpha = sinW0 / (2 * q); + b0 = 1 - alpha; + b1 = -2 * cosW0; + b2 = 1 + alpha; + a0 = b2; + a1 = b1; + a2 = b0; + break; + // H(s) = (s^2 + s*(A/Q) + 1) / (s^2 + s/(A*Q) + 1) + case 'peaking': + if (bandwidth) { + // sin(w0)*sinh( ln(2)/2 * BW * w0/sin(w0) ) (case: BW) + } else { + alpha = sinW0 / (2 * q); + } + + b0 = 1 + alpha * A; + b1 = -2 * cosW0; + b2 = 1 - alpha * A; + a0 = 1 + alpha / A; + a1 = b1; + a2 = 1 - alpha / A; + break; + // H(s) = A * (s^2 + (sqrt(A)/Q)*s + A)/(A*s^2 + (sqrt(A)/Q)*s + 1) + case 'lowshelf': + alpha = sinW0 / (2 * q); + _2RootAAlpha = 2 * sqrt(A) * alpha; + + b0 = A * (A + 1 - (A - 1) * cosW0 + _2RootAAlpha); + b1 = 2 * A * (A - 1 - (A + 1) * cosW0); + b2 = A * (A + 1 - (A - 1) * cosW0 - _2RootAAlpha); + a0 = A + 1 + (A - 1) * cosW0 + _2RootAAlpha; + a1 = -2 * (A - 1 + (A + 1) * cosW0); + a2 = A + 1 + (A - 1) * cosW0 - _2RootAAlpha; + break; + // H(s) = A * (A*s^2 + (sqrt(A)/Q)*s + 1)/(s^2 + (sqrt(A)/Q)*s + A) + case 'highshelf': + alpha = sinW0 / (2 * q); + _2RootAAlpha = 2 * sqrt(A) * alpha; + + b0 = A * (A + 1 + (A - 1) * cosW0 + _2RootAAlpha); + b1 = -2 * A * (A - 1 + (A + 1) * cosW0); + b2 = A * (A + 1 + (A - 1) * cosW0 - _2RootAAlpha); + a0 = A + 1 - (A - 1) * cosW0 + _2RootAAlpha; + a1 = 2 * (A - 1 - (A + 1) * cosW0); + a2 = A + 1 - (A - 1) * cosW0 - _2RootAAlpha; + + break; + } + + this.coefs = { + b0: b0 / a0, + b1: b1 / a0, + b2: b2 / a0, + a1: a1 / a0, + a2: a2 / a0 + }; + + // reset state + if (frameType === 'signal') { + this.state = { x1: 0, x2: 0, y1: 0, y2: 0 }; + } else { + this.state = { + x1: new Float32Array(frameSize), + x2: new Float32Array(frameSize), + y1: new Float32Array(frameSize), + y2: new Float32Array(frameSize) + }; + } + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + // if no `sampleRate` or `sampleRate` is 0 we shall halt! + var sampleRate = this.streamParams.sourceSampleRate; + + if (!sampleRate || sampleRate <= 0) throw new Error('Invalid sampleRate value (0) for biquad'); + + this._calculateCoefs(); + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + var frameSize = this.streamParams.frameSize; + var outData = this.frame.data; + var inData = frame.data; + var state = this.state; + var coefs = this.coefs; + + for (var i = 0; i < frameSize; i++) { + var x = inData[i]; + var y = coefs.b0 * x + coefs.b1 * state.x1[i] + coefs.b2 * state.x2[i] - coefs.a1 * state.y1[i] - coefs.a2 * state.y2[i]; + + outData[i] = y; + + // update states + state.x2[i] = state.x1[i]; + state.x1[i] = x; + state.y2[i] = state.y1[i]; + state.y1[i] = y; + } + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + var frameSize = this.streamParams.frameSize; + var outData = this.frame.data; + var inData = frame.data; + var state = this.state; + var coefs = this.coefs; + + for (var i = 0; i < frameSize; i++) { + var x = inData[i]; + var y = coefs.b0 * x + coefs.b1 * state.x1 + coefs.b2 * state.x2 - coefs.a1 * state.y1 - coefs.a2 * state.y2; + + outData[i] = y; + + // update states + state.x2 = state.x1; + state.x1 = x; + state.y2 = state.y1; + state.y1 = y; + } + } + }]); + return Biquad; +}(_BaseLfo3.default); + +exports.default = Biquad; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],21:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + min: { + type: 'float', + default: 0, + min: -Infinity, + max: +Infinity + }, + max: { + type: 'float', + default: 1, + min: -Infinity, + max: +Infinity + } +}; + +/** + * Clip incomming according to given `min` and `max` parameters + * + * @param {Object} options - Override default paramters + * @param {Number} [options.min=0] - Minimum value + * @param {Number} [options.max=1] - Maximum value + */ + +var Clip = function (_BaseLfo) { + (0, _inherits3.default)(Clip, _BaseLfo); + + function Clip(options) { + (0, _classCallCheck3.default)(this, Clip); + return (0, _possibleConstructorReturn3.default)(this, (Clip.__proto__ || (0, _getPrototypeOf2.default)(Clip)).call(this, definitions, options)); + } + + (0, _createClass3.default)(Clip, [{ + key: 'inputVector', + value: function inputVector(data) { + var min = this.params.get('min'); + var max = this.params.get('max'); + var frameSize = this.streamParams.frameSize; + var outData = this.frame.data; + + // @todo - could handle vector as min and max + for (var i = 0; i < frameSize; i++) { + outData[i] = Math.min(max, Math.max(min, data[i])); + }return outData; + } + }, { + key: 'processVector', + value: function processVector(frame) { + this.frame.data = this.inputVector(frame.data); + } + }, { + key: 'inputSignal', + value: function inputSignal(data) { + var min = this.params.get('min'); + var max = this.params.get('max'); + var frameSize = this.streamParams.frameSize; + var outData = this.frame.data; + + for (var i = 0; i < frameSize; i++) { + outData[i] = Math.min(max, Math.max(min, data[i])); + }return outData; + } + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.frame.data = this.inputSignal(frame.data); + } + }]); + return Clip; +}(_BaseLfo3.default); + +exports.default = Clip; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],22:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var sqrt = Math.sqrt; +var cos = Math.cos; +var PI = Math.PI; + +// Dct Type 2 - orthogonal matrix scaling +function getDctWeights(order, N) { + var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'htk'; + + var weights = new Float32Array(N * order); + var piOverN = PI / N; + var scale0 = 1 / sqrt(2); + var scale = sqrt(2 / N); + + for (var k = 0; k < order; k++) { + var s = k === 0 ? scale0 * scale : scale; + // const s = scale; // rta doesn't apply k=0 scaling + + for (var n = 0; n < N; n++) { + weights[k * N + n] = s * cos(k * (n + 0.5) * piOverN); + } + } + + return weights; +} + +var definitions = { + order: { + type: 'integer', + default: 12, + metas: { kind: 'static' } + } +}; + +/** + * Compute the Discrete Cosine Transform of an input `signal` or `vector`. + * (HTK style weighting). + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.order=12] - Number of computed bins. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * // assuming some audio buffer + * const source = new AudioInBuffer({ + * audioBuffer: audioBuffer, + * useWorker: false, + * }); + * + * const slicer = new Slicer({ + * frameSize: 512, + * hopSize: 512, + * }); + * + * const dct = new Dct({ + * order: 12, + * }); + * + * const logger = new lfo.sink.Logger({ data: true }); + * + * source.connect(slicer); + * slicer.connect(dct); + * dct.connect(logger); + * + * source.start(); + */ + +var Dct = function (_BaseLfo) { + (0, _inherits3.default)(Dct, _BaseLfo); + + function Dct() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Dct); + return (0, _possibleConstructorReturn3.default)(this, (Dct.__proto__ || (0, _getPrototypeOf2.default)(Dct)).call(this, definitions, options)); + } + + /** @private */ + + + (0, _createClass3.default)(Dct, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + var order = this.params.get('order'); + var inFrameSize = prevStreamParams.frameSize; + + this.streamParams.frameSize = order; + this.streamParams.frameType = 'vector'; + this.streamParams.description = []; + + this.weightMatrix = getDctWeights(order, inFrameSize); + + this.propagateStreamParams(); + } + + /** + * Use the `Dct` operator in `standalone` mode (i.e. outside of a graph). + * + * @param {Array} values - Input values. + * @return {Array} - Dct of the input array. + * + * @example + * const dct = new lfo.operator.Dct({ order: 12 }); + * // mandatory for use in standalone mode + * dct.initStream({ frameSize: 512, frameType: 'signal' }); + * dct.inputSignal(data); + */ + + }, { + key: 'inputSignal', + value: function inputSignal(values) { + var order = this.params.get('order'); + var frameSize = values.length; + var outFrame = this.frame.data; + var weights = this.weightMatrix; + + for (var k = 0; k < order; k++) { + var offset = k * frameSize; + outFrame[k] = 0; + + for (var n = 0; n < frameSize; n++) { + outFrame[k] += values[n] * weights[offset + n]; + } + } + + return outFrame; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.inputSignal(frame.data); + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.inputSignal(frame.data); + } + }]); + return Dct; +}(_BaseLfo3.default); + +exports.default = Dct; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],23:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function simpleLinearRegression(values, dt) { + // means + var xSum = 0; + var ySum = 0; + var length = values.length; + + for (var i = 0; i < length; i++) { + xSum += i * dt; + ySum += values[i]; + } + + var xMean = xSum / length; + var yMean = ySum / length; + + var sumDiffXMeanSquared = 0; // sum[ pow((x - xMean), 2) ] + var sumDiffYMeanSquared = 0; // sum[ pow((y - yMean), 2) ] + var sumDiffXYMean = 0; // sum[ (x - xMean)(y - yMean) ] + + for (var _i = 0; _i < length; _i++) { + var diffXMean = dt * _i - xMean; + var diffYMean = values[_i] - yMean; + + var diffXMeanSquared = diffXMean * diffXMean; + var diffYMeanSquared = diffYMean * diffYMean; + var diffXYMean = diffXMean * diffYMean; + + sumDiffXMeanSquared += diffXMeanSquared; + sumDiffYMeanSquared += diffYMeanSquared; + sumDiffXYMean += diffXYMean; + } + + // horizontal line, all y on same line + if (sumDiffYMeanSquared === 0) return 0; + + // Pearson correlation coefficient: + // cf. https://www.youtube.com/watch?v=2SCg8Kuh0tE + // + // ∑ [ (x - xMean)(y - yMean) ] + // r = ------------------------------------------------------ + // sqrt( ∑ [ pow((x - xMean), 2), pow((y - yMean), 2) ] ) + // + // + var r = sumDiffXYMean / Math.sqrt(sumDiffXMeanSquared * sumDiffYMeanSquared); + + // then we have: + // cf. https://www.youtube.com/watch?v=GhrxgbQnEEU + // + // y = a + bx + // where: + // Sy + // b = r * -- + // Sx + // + // a = yMean - b * xMean + // + // S for standard deviation + // ∑ [ pow((x - xMean), 2) ] + // Sx = sqrt( ------------------------- ) + // N - 1 + var Sx = Math.sqrt(sumDiffXMeanSquared / (length - 1)); + var Sy = Math.sqrt(sumDiffYMeanSquared / (length - 1)); + var b = r * (Sy / Sx); + + return b; +} + +var definitions = { + size: { + type: 'integer', + min: 2, + max: +Infinity, + default: 3 + }, + useFrameRate: { + type: 'integer', + min: 0, + max: +Infinity, + default: null, + nullable: true + } +}; + +/** + * Returns the simple derivative of successive value using + * simple linear regression. + * The current implementation assumes a fixed `frameRate` (`frame.time` is ignored) + * + * Before the module is filled, it outputs a value of 0. + * + * @param {Object} options - Override default parameters + * @param {Number} [options.size=3] - Size of the window + * @param {Number} [options.useFrameRate=null] - Override stream frame rate for + * the regression + */ + +var Delta = function (_BaseLfo) { + (0, _inherits3.default)(Delta, _BaseLfo); + + function Delta() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Delta); + + var _this = (0, _possibleConstructorReturn3.default)(this, (Delta.__proto__ || (0, _getPrototypeOf2.default)(Delta)).call(this, definitions, options)); + + _this.buffers = null; + _this.ringIndex = 0; + _this.frameRate = null; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(Delta, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + var frameSize = this.streamParams.frameSize; + var size = this.params.get('size'); + var bufferSize = frameSize * size; + + this.buffers = []; + // counter before the operator starts outputing frames + this.ringIndex = 0; + this.frameRate = this.params.get('useFrameRate') === null ? this.streamParams.frameRate : this.params.get('useFrameRate'); + + for (var i = 0; i < frameSize; i++) { + this.buffers[i] = new Float32Array(size); + }this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'resetStream', + value: function resetStream() { + (0, _get3.default)(Delta.prototype.__proto__ || (0, _getPrototypeOf2.default)(Delta.prototype), 'resetStream', this).call(this); + + var frameSize = this.streamParams.frameSize; + var size = this.params.get('size'); + var buffers = this.buffers; + + for (var i = 0; i < frameSize; i++) { + for (var j = 0; j < size; j++) { + buffers[i][j] = 0; + } + } + + this.ringIndex = 0; + } + + /** + * Assume a stream of vector at a fixed `frameRate`. + */ + + }, { + key: 'inputVector', + value: function inputVector(data) { + var size = this.params.get('size'); + var outData = this.frame.data; + var frameSize = this.streamParams.frameSize; + // const frameRate = this.streamParams.frameRate; + var buffers = this.buffers; + var dt = 1 / this.frameRate; + + // console.log(dt); + + if (this.ringIndex < size) this.ringIndex += 1; + + // copy incomming data into buffer + for (var i = 0; i < frameSize; i++) { + var buffer = buffers[i]; + + // we need to keep the order of the incomming frames + // so we have to shift all the values in the buffers + for (var j = 1; j < size; j++) { + buffer[j - 1] = buffer[j]; + }buffer[size - 1] = data[i]; + + if (this.ringIndex >= size) outData[i] = simpleLinearRegression(buffer, dt);else outData[i] = 0; + } + + return outData; + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.frame.data = this.inputVector(frame.data); + // center time according to delta size + var size = this.params.get('size'); + var frameRate = this.streamParams.frameRate; + this.frame.time -= 0.5 * (size - 1) / frameRate; + } + }]); + return Delta; +}(_BaseLfo3.default); + +exports.default = Delta; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],24:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +var _windows = require('../utils/windows'); + +var _windows2 = _interopRequireDefault(_windows); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// https://code.soundsoftware.ac.uk/projects/js-dsp-test/repository/entry/fft/nayuki-obj/fft.js +/* + * Free Fft and convolution (JavaScript) + * + * Copyright (c) 2014 Project Nayuki + * http://www.nayuki.io/page/free-small-fft-in-multiple-languages + * + * (MIT License) + * 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. + * + * Slightly restructured by Chris Cannam, cannam@all-day-breakfast.com + * + * @private + */ +/* + * Construct an object for calculating the discrete Fourier transform (DFT) of + * size n, where n is a power of 2. + * + * @private + */ +function FftNayuki(n) { + + this.n = n; + this.levels = -1; + + for (var i = 0; i < 32; i++) { + if (1 << i == n) { + this.levels = i; // Equal to log2(n) + } + } + + if (this.levels == -1) { + throw "Length is not a power of 2"; + } + + this.cosTable = new Array(n / 2); + this.sinTable = new Array(n / 2); + + for (var i = 0; i < n / 2; i++) { + this.cosTable[i] = Math.cos(2 * Math.PI * i / n); + this.sinTable[i] = Math.sin(2 * Math.PI * i / n); + } + + /* + * Computes the discrete Fourier transform (DFT) of the given complex vector, + * storing the result back into the vector. + * The vector's length must be equal to the size n that was passed to the + * object constructor, and this must be a power of 2. Uses the Cooley-Tukey + * decimation-in-time radix-2 algorithm. + * + * @private + */ + this.forward = function (real, imag) { + var n = this.n; + + // Bit-reversed addressing permutation + for (var i = 0; i < n; i++) { + var j = reverseBits(i, this.levels); + + if (j > i) { + var temp = real[i]; + real[i] = real[j]; + real[j] = temp; + temp = imag[i]; + imag[i] = imag[j]; + imag[j] = temp; + } + } + + // Cooley-Tukey decimation-in-time radix-2 Fft + for (var size = 2; size <= n; size *= 2) { + var halfsize = size / 2; + var tablestep = n / size; + + for (var i = 0; i < n; i += size) { + for (var j = i, k = 0; j < i + halfsize; j++, k += tablestep) { + var tpre = real[j + halfsize] * this.cosTable[k] + imag[j + halfsize] * this.sinTable[k]; + var tpim = -real[j + halfsize] * this.sinTable[k] + imag[j + halfsize] * this.cosTable[k]; + real[j + halfsize] = real[j] - tpre; + imag[j + halfsize] = imag[j] - tpim; + real[j] += tpre; + imag[j] += tpim; + } + } + } + + // Returns the integer whose value is the reverse of the lowest 'bits' + // bits of the integer 'x'. + function reverseBits(x, bits) { + var y = 0; + + for (var i = 0; i < bits; i++) { + y = y << 1 | x & 1; + x >>>= 1; + } + + return y; + } + }; + + /* + * Computes the inverse discrete Fourier transform (IDFT) of the given complex + * vector, storing the result back into the vector. + * The vector's length must be equal to the size n that was passed to the + * object constructor, and this must be a power of 2. This is a wrapper + * function. This transform does not perform scaling, so the inverse is not + * a true inverse. + * + * @private + */ + this.inverse = function (real, imag) { + forward(imag, real); + }; +} + +var sqrt = Math.sqrt; + +var isPowerOfTwo = function isPowerOfTwo(number) { + while (number % 2 === 0 && number > 1) { + number = number / 2; + }return number === 1; +}; + +var definitions = { + size: { + type: 'integer', + default: 1024, + metas: { kind: 'static' } + }, + window: { + type: 'enum', + list: ['none', 'hann', 'hanning', 'hamming', 'blackman', 'blackmanharris', 'sine', 'rectangle'], + default: 'none', + metas: { kind: 'static' } + }, + mode: { + type: 'enum', + list: ['magnitude', 'power'], // add complex output + default: 'magnitude' + }, + norm: { + type: 'enum', + default: 'auto', + list: ['auto', 'none', 'linear', 'power'] + } + + /** + * Compute the Fast Fourier Transform of an incomming `signal`. + * + * Fft implementation by [Nayuki](https://code.soundsoftware.ac.uk/projects/js-dsp-test/repository/entry/fft/nayuki-obj/fft.js). + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.size=1024] - Size of the fft, should be a power of 2. + * If the frame size of the incomming signal is lower than this value, + * it is zero padded to match the fft size. + * @param {String} [options.window='none'] - Name of the window applied on the + * incomming signal. Available windows are: 'none', 'hann', 'hanning', + * 'hamming', 'blackman', 'blackmanharris', 'sine', 'rectangle'. + * @param {String} [options.mode='magnitude'] - Type of the output (`magnitude` + * or `power`) + * @param {String} [options.norm='auto'] - Type of normalization applied on the + * output. Possible values are 'auto', 'none', 'linear', 'power'. When set to + * `auto`, a `linear` normalization is applied on the magnitude spectrum, while + * a `power` normalization is applied on the power spectrum. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * // assuming an `audioBuffer` exists + * const source = new lfo.source.AudioInBuffer({ audioBuffer }); + * + * const slicer = new lfo.operator.Slicer({ + * frameSize: 256, + * }); + * + * const fft = new lfo.operator.Fft({ + * mode: 'power', + * window: 'hann', + * norm: 'power', + * size: 256, + * }); + * + * source.connect(slicer); + * slicer.connect(fft); + * source.start(); + * + * // > outputs 129 bins containing the values of the power spectrum (including + * // > DC and Nyuist frequencies). + * + * @todo - check if 'rectangle' and 'none' windows are not redondant. + * @todo - check default values for all params. + */ +}; +var Fft = function (_BaseLfo) { + (0, _inherits3.default)(Fft, _BaseLfo); + + function Fft() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Fft); + + var _this = (0, _possibleConstructorReturn3.default)(this, (Fft.__proto__ || (0, _getPrototypeOf2.default)(Fft)).call(this, definitions, options)); + + _this.windowSize = null; + _this.normalizeCoefs = null; + _this.window = null; + _this.real = null; + _this.imag = null; + _this.fft = null; + + if (!isPowerOfTwo(_this.params.get('size'))) throw new Error('fftSize must be a power of two'); + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(Fft, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + // set the output frame size + var inFrameSize = prevStreamParams.frameSize; + var fftSize = this.params.get('size'); + var mode = this.params.get('mode'); + var norm = this.params.get('norm'); + var windowName = this.params.get('window'); + // window `none` and `rectangle` are aliases + if (windowName === 'none') windowName = 'rectangle'; + + this.streamParams.frameSize = fftSize / 2 + 1; + this.streamParams.frameType = 'vector'; + this.streamParams.description = []; + // size of the window to apply on the input frame + this.windowSize = inFrameSize < fftSize ? inFrameSize : fftSize; + + // references to populate in the window functions (cf. `initWindow`) + this.normalizeCoefs = { linear: 0, power: 0 }; + this.window = new Float32Array(this.windowSize); + + (0, _windows2.default)(windowName, // name of the window + this.window, // buffer populated with the window signal + this.windowSize, // size of the window + this.normalizeCoefs // object populated with the normalization coefs + ); + + var _normalizeCoefs = this.normalizeCoefs, + linear = _normalizeCoefs.linear, + power = _normalizeCoefs.power; + + + switch (norm) { + case 'none': + this.windowNorm = 1; + break; + + case 'linear': + this.windowNorm = linear; + break; + + case 'power': + this.windowNorm = power; + break; + + case 'auto': + if (mode === 'magnitude') this.windowNorm = linear;else if (mode === 'power') this.windowNorm = power; + break; + } + + this.real = new Float32Array(fftSize); + this.imag = new Float32Array(fftSize); + this.fft = new FftNayuki(fftSize); + + this.propagateStreamParams(); + } + + /** + * Use the `Fft` operator in `standalone` mode (i.e. outside of a graph). + * + * @param {Array} signal - Input values. + * @return {Array} - Fft of the input signal. + * + * @example + * const fft = new lfo.operator.Fft({ size: 512, window: 'hann' }); + * // mandatory for use in standalone mode + * fft.initStream({ frameSize: 256, frameType: 'signal' }); + * fft.inputSignal(signal); + */ + + }, { + key: 'inputSignal', + value: function inputSignal(signal) { + var mode = this.params.get('mode'); + var windowSize = this.windowSize; + var frameSize = this.streamParams.frameSize; + var fftSize = this.params.get('size'); + var outData = this.frame.data; + + // apply window on the input signal and reset imag buffer + for (var i = 0; i < windowSize; i++) { + this.real[i] = signal[i] * this.window[i] * this.windowNorm; + this.imag[i] = 0; + } + + // if real is bigger than input signal, fill with zeros + for (var _i = windowSize; _i < fftSize; _i++) { + this.real[_i] = 0; + this.imag[_i] = 0; + } + + this.fft.forward(this.real, this.imag); + + if (mode === 'magnitude') { + var norm = 1 / fftSize; + + // DC index + var realDc = this.real[0]; + var imagDc = this.imag[0]; + outData[0] = sqrt(realDc * realDc + imagDc * imagDc) * norm; + + // Nquyst index + var realNy = this.real[fftSize / 2]; + var imagNy = this.imag[fftSize / 2]; + outData[fftSize / 2] = sqrt(realNy * realNy + imagNy * imagNy) * norm; + + // power spectrum + for (var _i2 = 1, j = fftSize - 1; _i2 < fftSize / 2; _i2++, j--) { + var real = 0.5 * (this.real[_i2] + this.real[j]); + var imag = 0.5 * (this.imag[_i2] - this.imag[j]); + + outData[_i2] = 2 * sqrt(real * real + imag * imag) * norm; + } + } else if (mode === 'power') { + var _norm = 1 / (fftSize * fftSize); + + // DC index + var _realDc = this.real[0]; + var _imagDc = this.imag[0]; + outData[0] = (_realDc * _realDc + _imagDc * _imagDc) * _norm; + + // Nquyst index + var _realNy = this.real[fftSize / 2]; + var _imagNy = this.imag[fftSize / 2]; + outData[fftSize / 2] = (_realNy * _realNy + _imagNy * _imagNy) * _norm; + + // power spectrum + for (var _i3 = 1, _j = fftSize - 1; _i3 < fftSize / 2; _i3++, _j--) { + var _real = 0.5 * (this.real[_i3] + this.real[_j]); + var _imag = 0.5 * (this.imag[_i3] - this.imag[_j]); + + outData[_i3] = 4 * (_real * _real + _imag * _imag) * _norm; + } + } + + return outData; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.inputSignal(frame.data); + } + }]); + return Fft; +}(_BaseLfo3.default); + +exports.default = Fft; + +},{"../../core/BaseLfo":50,"../utils/windows":48,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],25:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var sqrt = Math.sqrt; + +var definitions = { + normalize: { + type: 'boolean', + default: true, + metas: { kind: 'dynamic' } + }, + power: { + type: 'boolean', + default: false, + metas: { kind: 'dynamic' } + } + + /** + * Compute the magnitude of a `vector` input. + * + * _support `standalone` usage_ + * + * @param {Object} options - Override default parameters. + * @param {Boolean} [options.normalize=true] - Normalize output according to + * the vector size. + * @param {Boolean} [options.power=false] - If true, returns the squared + * magnitude (power). + * + * @memberof module:common.operator + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const eventIn = new lfo.source.EventIn({ frameSize: 2, frameType: 'vector' }); + * const magnitude = new lfo.operator.Magnitude(); + * const logger = new lfo.sink.Logger({ outFrame: true }); + * + * eventIn.connect(magnitude); + * magnitude.connect(logger); + * eventIn.start(); + * + * eventIn.process(null, [1, 1]); + * > [1] + * eventIn.process(null, [2, 2]); + * > [2.82842712475] + * eventIn.process(null, [3, 3]); + * > [4.24264068712] + */ +}; +var Magnitude = function (_BaseLfo) { + (0, _inherits3.default)(Magnitude, _BaseLfo); + + function Magnitude() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Magnitude); + + var _this = (0, _possibleConstructorReturn3.default)(this, (Magnitude.__proto__ || (0, _getPrototypeOf2.default)(Magnitude)).call(this, definitions, options)); + + _this._normalize = _this.params.get('normalize'); + _this._power = _this.params.get('power'); + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(Magnitude, [{ + key: 'onParamUpdate', + value: function onParamUpdate(name, value, metas) { + (0, _get3.default)(Magnitude.prototype.__proto__ || (0, _getPrototypeOf2.default)(Magnitude.prototype), 'onParamUpdate', this).call(this, name, value, metas); + + switch (name) { + case 'normalize': + this._normalize = value; + break; + case 'power': + this._power = value; + break; + } + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + this.streamParams.frameSize = 1; + this.streamParams.frameType = 'scalar'; + this.streamParams.description = ['magnitude']; + this.propagateStreamParams(); + } + + /** + * Use the `Magnitude` operator in `standalone` mode (i.e. outside of a graph). + * + * @param {Array|Float32Array} values - Values to process. + * @return {Number} - Magnitude value. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const magnitude = new lfo.operator.Magnitude({ power: true }); + * magnitude.initStream({ frameType: 'vector', frameSize: 3 }); + * magnitude.inputVector([3, 3]); + * > 4.24264068712 + */ + + }, { + key: 'inputVector', + value: function inputVector(values) { + var length = values.length; + var sum = 0; + + for (var i = 0; i < length; i++) { + sum += values[i] * values[i]; + }var mag = sum; + + if (this._normalize) mag /= length; + + if (!this._power) mag = sqrt(mag); + + return mag; + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.frame.data[0] = this.inputVector(frame.data); + } + }]); + return Magnitude; +}(_BaseLfo3.default); + +exports.default = Magnitude; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],26:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var sqrt = Math.sqrt; + +/** + * Compute mean and standard deviation of a given `signal`. + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const audioContext = new AudioContext(); + * + * navigator.mediaDevices + * .getUserMedia({ audio: true }) + * .then(init) + * .catch((err) => console.error(err.stack)); + * + * function init(stream) { + * const source = audioContext.createMediaStreamSource(stream); + * + * const audioInNode = new lfo.source.AudioInNode({ + * sourceNode: source, + * audioContext: audioContext, + * }); + * + * const meanStddev = new lfo.operator.MeanStddev(); + * + * const traceDisplay = new lfo.sink.TraceDisplay({ + * canvas: '#trace', + * }); + * + * audioInNode.connect(meanStddev); + * meanStddev.connect(traceDisplay); + * audioInNode.start(); + * } + */ + +var MeanStddev = function (_BaseLfo) { + (0, _inherits3.default)(MeanStddev, _BaseLfo); + + function MeanStddev() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, MeanStddev); + + // no options available, just throw an error if some param try to be set. + return (0, _possibleConstructorReturn3.default)(this, (MeanStddev.__proto__ || (0, _getPrototypeOf2.default)(MeanStddev)).call(this, {}, options)); + } + + /** @private */ + + + (0, _createClass3.default)(MeanStddev, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + this.streamParams.frameType = 'vector'; + this.streamParams.frameSize = 2; + this.streamParams.description = ['mean', 'stddev']; + + this.propagateStreamParams(); + } + + /** + * Use the `MeanStddev` operator in `standalone` mode (i.e. outside of a graph). + * + * @param {Array|Float32Array} values - Values to process. + * @return {Array} - Mean and standart deviation of the input values. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const meanStddev = new lfo.operator.MeanStddev(); + * meanStddev.initStream({ frameType: 'vector', frameSize: 1024 }); + * meanStddev.inputVector(someSineSignal); + * > [0, 0.7071] + */ + + }, { + key: 'inputSignal', + value: function inputSignal(values) { + var outData = this.frame.data; + var length = values.length; + + var mean = 0; + var m2 = 0; + + // compute mean and variance with Welford algorithm + // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance + for (var i = 0; i < length; i++) { + var x = values[i]; + var delta = x - mean; + mean += delta / (i + 1); + m2 += delta * (x - mean); + } + + var variance = m2 / (length - 1); + var stddev = sqrt(variance); + + outData[0] = mean; + outData[1] = stddev; + + return outData; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.inputSignal(frame.data); + } + }]); + return MeanStddev; +}(_BaseLfo3.default); + +exports.default = MeanStddev; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],27:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _log = require('babel-runtime/core-js/math/log10'); + +var _log2 = _interopRequireDefault(_log); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var min = Math.min; +var max = Math.max; +var pow = Math.pow; +var log10 = _log2.default; + +function hertzToMelHtk(freqHz) { + return 2595 * (0, _log2.default)(1 + freqHz / 700); +} + +function melToHertzHtk(freqMel) { + return 700 * (Math.pow(10, freqMel / 2595) - 1); +} + +/** + * Returns a description of the weights to apply on the fft bins for each + * Mel band filter. + * @note - adapted from imtr-tools/rta + * + * @param {Number} nbrBins - Number of fft bins. + * @param {Number} nbrFilter - Number of mel filters. + * @param {Number} sampleRate - Sample Rate of the signal. + * @param {Number} minFreq - Minimum Frequency to be considerered. + * @param {Number} maxFreq - Maximum frequency to consider. + * @return {Array} - Description of the weights to apply on the bins for + * each mel filter. Each description has the following structure: + * { startIndex: binIndex, centerFreq: binCenterFrequency, weights: [] } + * + * @private + */ +function getMelBandWeights(nbrBins, nbrBands, sampleRate, minFreq, maxFreq) { + var type = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 'htk'; + + + var hertzToMel = null; + var melToHertz = null; + var minMel = void 0; + var maxMel = void 0; + + if (type === 'htk') { + hertzToMel = hertzToMelHtk; + melToHertz = melToHertzHtk; + minMel = hertzToMel(minFreq); + maxMel = hertzToMel(maxFreq); + } else { + throw new Error('Invalid mel band type: "' + type + '"'); + } + + var melBandDescriptions = new Array(nbrBands); + // center frequencies of Fft bins + var fftFreqs = new Float32Array(nbrBins); + // center frequencies of mel bands - uniformly spaced in mel domain between + // limits, there are 2 more frequencies than the actual number of filters in + // order to calculate the slopes + var filterFreqs = new Float32Array(nbrBands + 2); + + var fftSize = (nbrBins - 1) * 2; + // compute bins center frequencies + for (var i = 0; i < nbrBins; i++) { + fftFreqs[i] = sampleRate * i / fftSize; + }for (var _i = 0; _i < nbrBands + 2; _i++) { + filterFreqs[_i] = melToHertz(minMel + _i / (nbrBands + 1) * (maxMel - minMel)); + } // loop throught filters + for (var _i2 = 0; _i2 < nbrBands; _i2++) { + var minWeightIndexDefined = 0; + + var description = { + startIndex: null, + centerFreq: null, + weights: [] + + // define contribution of each bin for the filter at index (i + 1) + // do not process the last spectrum component (Nyquist) + };for (var j = 0; j < nbrBins - 1; j++) { + var posSlopeContrib = (fftFreqs[j] - filterFreqs[_i2]) / (filterFreqs[_i2 + 1] - filterFreqs[_i2]); + + var negSlopeContrib = (filterFreqs[_i2 + 2] - fftFreqs[j]) / (filterFreqs[_i2 + 2] - filterFreqs[_i2 + 1]); + // lowerSlope and upper slope intersect at zero and with each other + var contribution = max(0, min(posSlopeContrib, negSlopeContrib)); + + if (contribution > 0) { + if (description.startIndex === null) { + description.startIndex = j; + description.centerFreq = filterFreqs[_i2 + 1]; + } + + description.weights.push(contribution); + } + } + + // empty filter + if (description.startIndex === null) { + description.startIndex = 0; + description.centerFreq = 0; + } + + // @todo - do some scaling for Slaney-style mel + melBandDescriptions[_i2] = description; + } + + return melBandDescriptions; +} + +var definitions = { + log: { + type: 'boolean', + default: false, + metas: { kind: 'static' } + }, + nbrBands: { + type: 'integer', + default: 24, + metas: { kind: 'static' } + }, + minFreq: { + type: 'float', + default: 0, + metas: { kind: 'static' } + }, + maxFreq: { + type: 'float', + default: null, + nullable: true, + metas: { kind: 'static' } + }, + power: { + type: 'integer', + default: 1, + metas: { kind: 'dynamic' } + } +}; + +/** + * Compute the mel bands spectrum from a given spectrum (`vector` type). + * _Implement the `htk` mel band style._ + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Boolean} [options.log=false] - Apply a logarithmic scale on the output. + * @param {Number} [options.nbrBands=24] - Number of filters defining the mel + * bands. + * @param {Number} [options.minFreq=0] - Minimum frequency to consider. + * @param {Number} [options.maxFreq=null] - Maximum frequency to consider. + * If `null`, is set to Nyquist frequency. + * @param {Number} [options.power=1] - Apply a power scaling on each mel band. + * + * @todo - implement Slaney style mel bands + * + * @example + * import lfo from 'waves-lfo/node' + * + * // read a file from path (node only source) + * const audioInFile = new lfo.source.AudioInFile({ + * filename: 'path/to/file', + * frameSize: 512, + * }); + * + * const slicer = new lfo.operator.Slicer({ + * frameSize: 256, + * hopSize: 256, + * }); + * + * const fft = new lfo.operator.Fft({ + * size: 1024, + * window: 'hann', + * mode: 'power', + * norm: 'power', + * }); + * + * const mel = new lfo.operator.Mel({ + * log: true, + * nbrBands: 24, + * }); + * + * const logger = new lfo.sink.Logger({ data: true }); + * + * audioInFile.connect(slicer); + * slicer.connect(fft); + * fft.connect(mel); + * mel.connect(logger); + * + * audioInFile.start(); + */ + +var Mel = function (_BaseLfo) { + (0, _inherits3.default)(Mel, _BaseLfo); + + function Mel() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Mel); + return (0, _possibleConstructorReturn3.default)(this, (Mel.__proto__ || (0, _getPrototypeOf2.default)(Mel)).call(this, definitions, options)); + } + + /** @private */ + + + (0, _createClass3.default)(Mel, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + var nbrBins = prevStreamParams.frameSize; + var nbrBands = this.params.get('nbrBands'); + var sampleRate = this.streamParams.sourceSampleRate; + var minFreq = this.params.get('minFreq'); + var maxFreq = this.params.get('maxFreq'); + + // + this.streamParams.frameSize = nbrBands; + this.streamParams.frameType = 'vector'; + this.streamParams.description = []; + + if (maxFreq === null) maxFreq = this.streamParams.sourceSampleRate / 2; + + this.melBandDescriptions = getMelBandWeights(nbrBins, nbrBands, sampleRate, minFreq, maxFreq); + + this.propagateStreamParams(); + } + + /** + * Use the `Mel` operator in `standalone` mode (i.e. outside of a graph). + * + * @param {Array} spectrum - Fft bins. + * @return {Array} - Mel bands. + * + * @example + * const mel = new lfo.operator.Mel({ nbrBands: 24 }); + * // mandatory for use in standalone mode + * mel.initStream({ frameSize: 256, frameType: 'vector', sourceSampleRate: 44100 }); + * mel.inputVector(fftBins); + */ + + }, { + key: 'inputVector', + value: function inputVector(bins) { + + var power = this.params.get('power'); + var log = this.params.get('log'); + var melBands = this.frame.data; + var nbrBands = this.streamParams.frameSize; + var scale = 1; + + var minLogValue = 1e-48; + var minLog = -480; + + if (log) scale *= nbrBands; + + for (var i = 0; i < nbrBands; i++) { + var _melBandDescriptions$ = this.melBandDescriptions[i], + startIndex = _melBandDescriptions$.startIndex, + weights = _melBandDescriptions$.weights; + + var value = 0; + + for (var j = 0; j < weights.length; j++) { + value += weights[j] * bins[startIndex + j]; + } // apply same logic as in PiPoBands + if (scale !== 1) value *= scale; + + if (log) { + if (value > minLogValue) value = 10 * log10(value);else value = minLog; + } + + if (power !== 1) value = pow(value, power); + + melBands[i] = value; + } + + return melBands; + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.inputVector(frame.data); + } + }]); + return Mel; +}(_BaseLfo3.default); + +exports.default = Mel; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/math/log10":58,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],28:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + // array defining the frameSizes of the input streamss + // e.g. if [3, 2, 1], we wait for 3 different sources of respective 3, 2, 1 frameSizes + frameSizes: { + type: 'any', + default: null, + constant: true + } + + /** + * Merge multiple vector frames. The order of execution depends on the + * order the branching was initially made. The first branche is master + * on the time and trigger the output of the frame. + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters + * @param {Array} [options.frameSizes=null] - Array that defines the number + * of values to pick from each incomming vectors. + * + * @example + * import * as lfo from 'waves-lfo/comon' + * + * const eventIn = new lfo.operator.EventIn({ + * type: 'vector', + * frameSize: 4, + * frameRate: 0, + * }); + * + * const minMax = new lfo.operator.MinMax(); + * const magnitude = new lfo.operator.Magnitude(); + * + * // take the first 2 values of the first branch and 1 value from the second branch + * const merge = new lfo.operator.Merger({ frameSizes: [2, 1] }); + * + * // this defines the order in which Merger will be called + * eventIn.connect(minMax); + * eventIn.connect(magnitude); + * + * minMax.connect(merger); + * magnitude.connect(merger); + */ +}; +var Merger = function (_BaseLfo) { + (0, _inherits3.default)(Merger, _BaseLfo); + + function Merger(options) { + (0, _classCallCheck3.default)(this, Merger); + return (0, _possibleConstructorReturn3.default)(this, (Merger.__proto__ || (0, _getPrototypeOf2.default)(Merger)).call(this, definitions, options)); + } + + (0, _createClass3.default)(Merger, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + // ... + var frameSizes = this.params.get('frameSizes'); + var numSources = frameSizes.length; + + var frameSize = 0; + for (var i = 0; i < numSources; i++) { + frameSize += frameSizes[i]; + }this.streamParams.frameSize = frameSize; + this.numSources = numSources; + this.sourceIndex = 0; + + this.propagateStreamParams(); + } + }, { + key: 'processVector', + value: function processVector() {} + // processSignal() {} // makes no sens to merge signals (maybe MUX / DEMUX) + + }, { + key: 'processFrame', + value: function processFrame(frame) { + var currentIndex = this.sourceIndex; + var frameSizes = this.params.get('frameSizes'); + var numSources = frameSizes.length; + var input = frame.data; + var output = this.frame.data; + + // first source define time + if (currentIndex === 0) this.frame.time = frame.time; + + var currentFrameSize = frameSizes[currentIndex]; + var offset = 0; + + for (var i = 0; i < currentIndex; i++) { + offset += frameSizes[i]; + } // copy data + for (var _i = 0; _i < currentFrameSize; _i++) { + output[offset + _i] = input[_i]; + }this.sourceIndex = (this.sourceIndex + 1) % numSources; + + // we just received the last input, output the frame + if (this.sourceIndex === 0) this.propagateFrame(); + } + }]); + return Merger; +}(_BaseLfo3.default); + +exports.default = Merger; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],29:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +var _Fft = require('./Fft'); + +var _Fft2 = _interopRequireDefault(_Fft); + +var _Mel = require('./Mel'); + +var _Mel2 = _interopRequireDefault(_Mel); + +var _Dct = require('./Dct'); + +var _Dct2 = _interopRequireDefault(_Dct); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + nbrBands: { + type: 'integer', + default: 24, + meta: { kind: 'static' } + }, + nbrCoefs: { + type: 'integer', + default: 12, + meta: { kind: 'static' } + }, + minFreq: { + type: 'float', + default: 0, + meta: { kind: 'static' } + }, + maxFreq: { + type: 'float', + default: null, + nullable: true, + meta: { kind: 'static' } + } +}; + +/** + * Compute the Mfcc of the incomming `signal`. Is basically a wrapper around + * [`Fft`]{@link module:common.operator.Fft}, [`Mel`]{@link module:common.operator.Mel} + * and [`Dct`]{@link module:common.operator.Dct}. + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {nbrBands} [options.nbrBands=24] - Number of Mel bands. + * @param {nbrCoefs} [options.nbrCoefs=12] - Number of output coefs. + * + * @see {@link module:common.operator.Fft} + * @see {@link module:common.operator.Mel} + * @see {@link module:common.operator.Dct} + * + * @example + * import lfo from 'waves-lfo/node' + * + * const audioInFile = new lfo.source.AudioInFile({ + * filename: 'path/to/file', + * frameSize: 512, + * }); + * + * const slicer = new lfo.operator.Slicer({ + * frameSize: 256, + * }); + * + * const mfcc = new lfo.operator.Mfcc({ + * nbrBands: 24, + * nbrCoefs: 12, + * }); + * + * const logger = new lfo.sink.Logger({ data: true }); + * + * audioInFile.connect(slicer); + * slicer.connect(mfcc); + * mfcc.connect(logger); + * + * audioInFile.start(); + */ + +var Mfcc = function (_BaseLfo) { + (0, _inherits3.default)(Mfcc, _BaseLfo); + + function Mfcc(options) { + (0, _classCallCheck3.default)(this, Mfcc); + return (0, _possibleConstructorReturn3.default)(this, (Mfcc.__proto__ || (0, _getPrototypeOf2.default)(Mfcc)).call(this, definitions, options)); + } + + /** @private */ + + + (0, _createClass3.default)(Mfcc, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + var nbrBands = this.params.get('nbrBands'); + var nbrCoefs = this.params.get('nbrCoefs'); + var minFreq = this.params.get('minFreq'); + var maxFreq = this.params.get('maxFreq'); + var inputFrameSize = prevStreamParams.frameSize; + var inputFrameRate = prevStreamParams.frameRate; + var inputSampleRate = prevStreamParams.sourceSampleRate; + var nbrBins = inputFrameSize / 2 + 1; + + this.streamParams.frameSize = nbrCoefs; + this.streamParams.frameType = 'vector'; + this.streamParams.description = []; + + this.fft = new _Fft2.default({ + window: 'hann', + mode: 'power', + norm: 'power', + size: inputFrameSize + }); + + this.mel = new _Mel2.default({ + nbrBands: nbrBands, + log: true, + power: 1, + minFreq: minFreq, + maxFreq: maxFreq + }); + + this.dct = new _Dct2.default({ + order: nbrCoefs + }); + + // init streams + this.fft.initStream({ + frameType: 'signal', + frameSize: inputFrameSize, + frameRate: inputFrameRate, + sourceSampleRate: inputSampleRate + }); + + this.mel.initStream({ + frameType: 'vector', + frameSize: nbrBins, + frameRate: inputFrameRate, + sourceSampleRate: inputSampleRate + }); + + this.dct.initStream({ + frameType: 'vector', + frameSize: nbrBands, + frameRate: inputFrameRate, + sourceSampleRate: inputSampleRate + }); + + this.propagateStreamParams(); + } + + /** + * Use the `Mfcc` operator in `standalone` mode (i.e. outside of a graph). + * + * @param {Array} data - Signal chunk to analyse. + * @return {Array} - Mfcc coefficients. + * + * @example + * const mfcc = new lfo.operator.Mfcc(); + * // mandatory for use in standalone mode + * mfcc.initStream({ frameSize: 256, frameType: 'vector' }); + * mfcc.inputSignal(signal); + */ + + }, { + key: 'inputSignal', + value: function inputSignal(data) { + var output = this.frame.data; + var nbrCoefs = this.params.get('nbrCoefs'); + + var bins = this.fft.inputSignal(data); + var melBands = this.mel.inputVector(bins); + // console.log(melBands); + var coefs = this.dct.inputSignal(melBands); + + for (var i = 0; i < nbrCoefs; i++) { + output[i] = coefs[i]; + }return output; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.inputSignal(frame.data); + } + }]); + return Mfcc; +}(_BaseLfo3.default); + +exports.default = Mfcc; + +},{"../../core/BaseLfo":50,"./Dct":22,"./Fft":24,"./Mel":27,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],30:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Find minimun and maximum values of a given `signal`. + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const eventIn = new lfo.source.EventIn({ + * frameSize: 512, + * frameType: 'signal', + * sampleRate: 0, + * }); + * + * const minMax = new lfo.operator.MinMax(); + * + * const logger = new lfo.sink.Logger({ data: true }); + * + * eventIn.connect(minMax); + * minMax.connect(logger); + * eventIn.start() + * + * // create a frame + * const signal = new Float32Array(512); + * for (let i = 0; i < 512; i++) + * signal[i] = i + 1; + * + * eventIn.process(null, signal); + * > [1, 512]; + */ +var MinMax = function (_BaseLfo) { + (0, _inherits3.default)(MinMax, _BaseLfo); + + function MinMax() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, MinMax); + + // throw errors if options are given + return (0, _possibleConstructorReturn3.default)(this, (MinMax.__proto__ || (0, _getPrototypeOf2.default)(MinMax)).call(this, {}, options)); + } + + /** @private */ + + + (0, _createClass3.default)(MinMax, [{ + key: 'processStreamParams', + value: function processStreamParams() { + var prevStreamParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + this.prepareStreamParams(prevStreamParams); + + this.streamParams.frameType = 'vector'; + this.streamParams.frameSize = 2; + this.streamParams.description = ['min', 'max']; + + this.propagateStreamParams(); + } + + /** + * Use the `MinMax` operator in `standalone` mode (i.e. outside of a graph). + * + * @param {Float32Array|Array} data - Input signal. + * @return {Array} - Min and max values. + * + * @example + * const minMax = new MinMax(); + * minMax.initStream({ frameType: 'signal', frameSize: 10 }); + * + * minMax.inputSignal([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + * > [0, 5] + */ + + }, { + key: 'inputSignal', + value: function inputSignal(data) { + var outData = this.frame.data; + var min = +Infinity; + var max = -Infinity; + + for (var i = 0, l = data.length; i < l; i++) { + var value = data[i]; + if (value < min) min = value; + if (value > max) max = value; + } + + outData[0] = min; + outData[1] = max; + + return outData; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.inputSignal(frame.data); + } + }]); + return MinMax; +}(_BaseLfo3.default); + +exports.default = MinMax; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],31:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + order: { + type: 'integer', + min: 1, + max: 1e9, + default: 10, + metas: { kind: 'dynamic' } + }, + fill: { + type: 'float', + min: -Infinity, + max: +Infinity, + default: 0, + metas: { kind: 'dynamic' } + } +}; + +/** + * Compute a moving average operation on the incomming frames (`scalar` or + * `vector` type). If the input is of type vector, the moving average is + * computed for each dimension in parallel. If the source sample rate is defined + * frame time is shifted to the middle of the window defined by the order. + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.order=10] - Number of successive values on which + * the average is computed. + * @param {Number} [options.fill=0] - Value to fill the ring buffer with before + * the first input frame. + * + * @todo - Implement `processSignal` ? + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const eventIn = new lfo.source.EventIn({ + * frameSize: 2, + * frameType: 'vector' + * }); + * + * const movingAverage = new lfo.operator.MovingAverage({ + * order: 5, + * fill: 0 + * }); + * + * const logger = new lfo.sink.Logger({ data: true }); + * + * eventIn.connect(movingAverage); + * movingAverage.connect(logger); + * + * eventIn.start(); + * + * eventIn.process(null, [1, 1]); + * > [0.2, 0.2] + * eventIn.process(null, [1, 1]); + * > [0.4, 0.4] + * eventIn.process(null, [1, 1]); + * > [0.6, 0.6] + * eventIn.process(null, [1, 1]); + * > [0.8, 0.8] + * eventIn.process(null, [1, 1]); + * > [1, 1] + */ + +var MovingAverage = function (_BaseLfo) { + (0, _inherits3.default)(MovingAverage, _BaseLfo); + + function MovingAverage() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, MovingAverage); + + var _this = (0, _possibleConstructorReturn3.default)(this, (MovingAverage.__proto__ || (0, _getPrototypeOf2.default)(MovingAverage)).call(this, definitions, options)); + + _this.sum = null; + _this.ringBuffer = null; + _this.ringIndex = 0; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(MovingAverage, [{ + key: 'onParamUpdate', + value: function onParamUpdate(name, value, metas) { + (0, _get3.default)(MovingAverage.prototype.__proto__ || (0, _getPrototypeOf2.default)(MovingAverage.prototype), 'onParamUpdate', this).call(this, name, value, metas); + + // @todo - should be done lazily in process + switch (name) { + case 'order': + this.processStreamParams(); + this.resetStream(); + break; + case 'fill': + this.resetStream(); + break; + } + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + var frameSize = this.streamParams.frameSize; + var order = this.params.get('order'); + + this.ringBuffer = new Float32Array(order * frameSize); + + if (frameSize > 1) this.sum = new Float32Array(frameSize);else this.sum = 0; + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'resetStream', + value: function resetStream() { + (0, _get3.default)(MovingAverage.prototype.__proto__ || (0, _getPrototypeOf2.default)(MovingAverage.prototype), 'resetStream', this).call(this); + + var order = this.params.get('order'); + var fill = this.params.get('fill'); + var ringBuffer = this.ringBuffer; + var ringLength = ringBuffer.length; + + for (var i = 0; i < ringLength; i++) { + ringBuffer[i] = fill; + }var fillSum = order * fill; + var frameSize = this.streamParams.frameSize; + + if (frameSize > 1) { + for (var _i = 0; _i < frameSize; _i++) { + this.sum[_i] = fillSum; + } + } else { + this.sum = fillSum; + } + + this.ringIndex = 0; + } + + /** @private */ + + }, { + key: 'processScalar', + value: function processScalar(frame) { + this.frame.data[0] = this.inputScalar(frame.data[0]); + } + + /** + * Use the `MovingAverage` operator in `standalone` mode (i.e. outside of a + * graph) with a `scalar` input. + * + * @param {Number} value - Value to feed the moving average with. + * @return {Number} - Average value. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const movingAverage = new lfo.operator.MovingAverage({ order: 5 }); + * movingAverage.initStream({ frameSize: 1, frameType: 'scalar' }); + * + * movingAverage.inputScalar(1); + * > 0.2 + * movingAverage.inputScalar(1); + * > 0.4 + * movingAverage.inputScalar(1); + * > 0.6 + */ + + }, { + key: 'inputScalar', + value: function inputScalar(value) { + var order = this.params.get('order'); + var ringIndex = this.ringIndex; + var ringBuffer = this.ringBuffer; + var sum = this.sum; + + sum -= ringBuffer[ringIndex]; + sum += value; + + this.sum = sum; + this.ringBuffer[ringIndex] = value; + this.ringIndex = (ringIndex + 1) % order; + + return sum / order; + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.inputVector(frame.data); + } + + /** + * Use the `MovingAverage` operator in `standalone` mode (i.e. outside of a + * graph) with a `vector` input. + * + * @param {Array} values - Values to feed the moving average with. + * @return {Float32Array} - Average value for each dimension. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const movingAverage = new lfo.operator.MovingAverage({ order: 5 }); + * movingAverage.initStream({ frameSize: 2, frameType: 'scalar' }); + * + * movingAverage.inputArray([1, 1]); + * > [0.2, 0.2] + * movingAverage.inputArray([1, 1]); + * > [0.4, 0.4] + * movingAverage.inputArray([1, 1]); + * > [0.6, 0.6] + */ + + }, { + key: 'inputVector', + value: function inputVector(values) { + var order = this.params.get('order'); + var outFrame = this.frame.data; + var frameSize = this.streamParams.frameSize; + var ringIndex = this.ringIndex; + var ringOffset = ringIndex * frameSize; + var ringBuffer = this.ringBuffer; + var sum = this.sum; + var scale = 1 / order; + + for (var i = 0; i < frameSize; i++) { + var ringBufferIndex = ringOffset + i; + var value = values[i]; + var localSum = sum[i]; + + localSum -= ringBuffer[ringBufferIndex]; + localSum += value; + + this.sum[i] = localSum; + outFrame[i] = localSum * scale; + ringBuffer[ringBufferIndex] = value; + } + + this.ringIndex = (ringIndex + 1) % order; + + return outFrame; + } + + /** @private */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + this.prepareFrame(); + this.processFunction(frame); + + var order = this.params.get('order'); + var time = frame.time; + // shift time to take account of the added latency + if (this.streamParams.sourceSampleRate) time -= 0.5 * (order - 1) / this.streamParams.sourceSampleRate; + + this.frame.time = time; + this.frame.metadata = frame.metadata; + + this.propagateFrame(); + } + }]); + return MovingAverage; +}(_BaseLfo3.default); + +exports.default = MovingAverage; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],32:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + order: { + type: 'integer', + min: 1, + max: 1e9, + default: 9, + metas: { kind: 'static' } + }, + fill: { + type: 'float', + min: -Infinity, + max: +Infinity, + default: 0, + metas: { kind: 'static' } + } +}; + +/** + * Compute a moving median operation on the incomming frames (`scalar` or + * `vector` type). If the input is of type vector, the moving median is + * computed for each dimension in parallel. If the source sample rate is defined + * frame time is shifted to the middle of the window defined by the order. + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.order=9] - Number of successive values in which + * the median is searched. This value must be odd. _dynamic parameter_ + * @param {Number} [options.fill=0] - Value to fill the ring buffer with before + * the first input frame. _dynamic parameter_ + * + * @todo - Implement `processSignal` + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const eventIn = new lfo.source.EventIn({ + * frameSize: 2, + * frameType: 'vector', + * }); + * + * const movingMedian = new lfo.operator.MovingMedian({ + * order: 5, + * fill: 0, + * }); + * + * const logger = new lfo.sink.Logger({ data: true }); + * + * eventIn.connect(movingMedian); + * movingMedian.connect(logger); + * + * eventIn.start(); + * + * eventIn.processFrame(null, [1, 1]); + * > [0, 0] + * eventIn.processFrame(null, [2, 2]); + * > [0, 0] + * eventIn.processFrame(null, [3, 3]); + * > [1, 1] + * eventIn.processFrame(null, [4, 4]); + * > [2, 2] + * eventIn.processFrame(null, [5, 5]); + * > [3, 3] + */ + +var MovingMedian = function (_BaseLfo) { + (0, _inherits3.default)(MovingMedian, _BaseLfo); + + function MovingMedian() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, MovingMedian); + + var _this = (0, _possibleConstructorReturn3.default)(this, (MovingMedian.__proto__ || (0, _getPrototypeOf2.default)(MovingMedian)).call(this, definitions, options)); + + _this.ringBuffer = null; + _this.sortBuffer = null; + _this.ringIndex = 0; + + _this._ensureOddOrder(); + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(MovingMedian, [{ + key: '_ensureOddOrder', + value: function _ensureOddOrder() { + if (this.params.get('order') % 2 === 0) throw new Error('Invalid value ' + order + ' for param "order" - must be odd'); + } + + /** @private */ + + }, { + key: 'onParamUpdate', + value: function onParamUpdate(name, value, metas) { + (0, _get3.default)(MovingMedian.prototype.__proto__ || (0, _getPrototypeOf2.default)(MovingMedian.prototype), 'onParamUpdate', this).call(this, name, value, metas); + + switch (name) { + case 'order': + this._ensureOddOrder(); + this.processStreamParams(); + this.resetStream(); + break; + case 'fill': + this.resetStream(); + break; + } + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + // outType is similar to input type + + var frameSize = this.streamParams.frameSize; + var order = this.params.get('order'); + + this.ringBuffer = new Float32Array(frameSize * order); + this.sortBuffer = new Float32Array(frameSize * order); + + this.minIndices = new Uint32Array(frameSize); + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'resetStream', + value: function resetStream() { + (0, _get3.default)(MovingMedian.prototype.__proto__ || (0, _getPrototypeOf2.default)(MovingMedian.prototype), 'resetStream', this).call(this); + + var fill = this.params.get('fill'); + var ringBuffer = this.ringBuffer; + var ringLength = ringBuffer.length; + + for (var i = 0; i < ringLength; i++) { + this.ringBuffer[i] = fill; + }this.ringIndex = 0; + } + + /** @private */ + + }, { + key: 'processScalar', + value: function processScalar(frame) { + this.frame.data[0] = this.inputScalar(frame.data[0]); + } + + /** + * Allows for the use of a `MovingMedian` outside a graph (e.g. inside + * another node), in this case `processStreamParams` and `resetStream` + * should be called manually on the node. + * + * @param {Number} value - Value to feed the moving median with. + * @return {Number} - Median value. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const movingMedian = new MovingMedian({ order: 5 }); + * movingMedian.initStream({ frameSize: 1, frameType: 'scalar' }); + * + * movingMedian.inputScalar(1); + * > 0 + * movingMedian.inputScalar(2); + * > 0 + * movingMedian.inputScalar(3); + * > 1 + * movingMedian.inputScalar(4); + * > 2 + */ + + }, { + key: 'inputScalar', + value: function inputScalar(value) { + var ringIndex = this.ringIndex; + var ringBuffer = this.ringBuffer; + var sortBuffer = this.sortBuffer; + var order = this.params.get('order'); + var medianIndex = (order - 1) / 2; + var startIndex = 0; + + ringBuffer[ringIndex] = value; + + for (var i = 0; i <= medianIndex; i++) { + var min = +Infinity; + var minIndex = null; + + for (var j = startIndex; j < order; j++) { + if (i === 0) sortBuffer[j] = ringBuffer[j]; + + if (sortBuffer[j] < min) { + min = sortBuffer[j]; + minIndex = j; + } + } + + // swap minIndex and startIndex + var cache = sortBuffer[startIndex]; + sortBuffer[startIndex] = sortBuffer[minIndex]; + sortBuffer[minIndex] = cache; + + startIndex += 1; + } + + var median = sortBuffer[medianIndex]; + this.ringIndex = (ringIndex + 1) % order; + + return median; + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.inputVector(frame.data); + } + + /** + * Allows for the use of a `MovingMedian` outside a graph (e.g. inside + * another node), in this case `processStreamParams` and `resetStream` + * should be called manually on the node. + * + * @param {Array} values - Values to feed the moving median with. + * @return {Float32Array} - Median values for each dimension. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const movingMedian = new MovingMedian({ order: 3, fill: 0 }); + * movingMedian.initStream({ frameSize: 3, frameType: 'vector' }); + * + * movingMedian.inputArray([1, 1]); + * > [0, 0] + * movingMedian.inputArray([2, 2]); + * > [1, 1] + * movingMedian.inputArray([3, 3]); + * > [2, 2] + */ + + }, { + key: 'inputVector', + value: function inputVector(values) { + var order = this.params.get('order'); + var ringBuffer = this.ringBuffer; + var ringIndex = this.ringIndex; + var sortBuffer = this.sortBuffer; + var outFrame = this.frame.data; + var minIndices = this.minIndices; + var frameSize = this.streamParams.frameSize; + var medianIndex = Math.floor(order / 2); + var startIndex = 0; + + for (var i = 0; i <= medianIndex; i++) { + + for (var j = 0; j < frameSize; j++) { + outFrame[j] = +Infinity; + minIndices[j] = 0; + + for (var k = startIndex; k < order; k++) { + var index = k * frameSize + j; + + // update ring buffer corresponding to current + if (k === ringIndex && i === 0) ringBuffer[index] = values[j]; + + // copy value in sort buffer on first pass + if (i === 0) sortBuffer[index] = ringBuffer[index]; + + // find minium in the remaining array + if (sortBuffer[index] < outFrame[j]) { + outFrame[j] = sortBuffer[index]; + minIndices[j] = index; + } + } + + // swap minimum and curent index + var swapIndex = startIndex * frameSize + j; + var v = sortBuffer[swapIndex]; + sortBuffer[swapIndex] = sortBuffer[minIndices[j]]; + sortBuffer[minIndices[j]] = v; + + // store this minimum value as current result + outFrame[j] = sortBuffer[swapIndex]; + } + + startIndex += 1; + } + + this.ringIndex = (ringIndex + 1) % order; + + return this.frame.data; + } + + /** @private */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + this.preprocessFrame(); + this.processFunction(frame); + + var order = this.params.get('order'); + var time = frame.time; + // shift time to take account of the added latency + if (this.streamParams.sourceSampleRate) time -= 0.5 * (order - 1) / this.streamParams.sourceSampleRate; + + this.frame.time = time; + this.frame.metadata = frame.metadata; + + this.propagateFrame(time, this.outFrame, metadata); + } + }]); + return MovingMedian; +}(_BaseLfo3.default); + +exports.default = MovingMedian; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],33:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + // float or array + factor: { + type: 'any', + default: 1 + } +}; + +/** + * Multiply a given signal or vector by a given factor. On vector + * streams, `factor` can be an array of values to apply on each dimension of the + * vector frames. + * + * _support `standalone` usage_ + * + * @param {Object} options - override default values + * @param {Number|Array} [options.factor=1] - factor or array of factor to + * apply on the incomming frame. Setting an array is only defined in case of + * a vector stream. + * + * @memberof module:common.operator + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const eventIn = new lfo.operator.EventIn({ + * type: 'vector', + * frameSize: 2, + * frameRate: 0, + * }); + * const scaler = new lfo.operator.Multiplier({ factor: 0.1 }); + * + * eventIn.connect(scaler); + * + * eventIn.process(null, [2, 3]); + * > [0.2, 0.3] + */ + +var Multiplier = function (_BaseLfo) { + (0, _inherits3.default)(Multiplier, _BaseLfo); + + function Multiplier(options) { + (0, _classCallCheck3.default)(this, Multiplier); + return (0, _possibleConstructorReturn3.default)(this, (Multiplier.__proto__ || (0, _getPrototypeOf2.default)(Multiplier)).call(this, definitions, options)); + } + + /** + * Use the `Multiplier` operator in standalone mode. + * + * @param {Float32Array|Array} data - Input vector + * @return {Array} - Scaled values + * + * @example + * const scaler = new Multiplier({ factor: [2, 4] }); + * scaler.initStream({ frameType: 'vector', frameSize: 2 }); + * + * scaler.inputVector([3, 2]); + * > [6, 8] + */ + + + (0, _createClass3.default)(Multiplier, [{ + key: 'inputVector', + value: function inputVector(data) { + var output = this.frame.data; + var frameSize = this.streamParams.frameSize; + var factor = this.params.get('factor'); + + if (Array.isArray(factor)) { + for (var i = 0; i < frameSize; i++) { + output[i] = data[i] * factor[i]; + } + } else { + for (var _i = 0; _i < frameSize; _i++) { + output[_i] = data[_i] * factor; + } + } + + return output; + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.frame.data = this.inputVector(frame.data); + } + + /** + * Use the `Multiplier` operator in standalone mode. + * + * @param {Float32Array|Array} data - Input signal. + * @return {Array} - Scaled signal. + * + * @example + * const scaler = new Multiplier({ factor: 0.1 }); + * scaler.initStream({ frameType: 'signal', frameSize: 2 }); + * + * scaler.inputVector([1, 2]); + * > [0.1, 0.2] + */ + + }, { + key: 'inputSignal', + value: function inputSignal(data) { + var output = this.frame.data; + var frameSize = this.streamParams.frameSize; + var factor = this.params.get('factor'); + + for (var i = 0; i < frameSize; i++) { + output[i] = data[i] * factor; + }return output; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.frame.data = this.inputSignal(frame.data); + } + }]); + return Multiplier; +}(_BaseLfo3.default); + +exports.default = Multiplier; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],34:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + state: { + type: 'enum', + default: 'on', + list: ['on', 'off'], + metas: { kind: 'dynamic' } + } +}; + +/** + * The OnOff operator allows to stop the propagation of the stream in a + * subgraph. When "on", frames are propagated, when "off" the propagation is + * stopped. + * + * The `streamParams` propagation is never bypassed so the subsequent subgraph + * is always ready for incomming frames. + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {String} [options.state='on'] - Default state. + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const frames = [ + * { time: 0, data: [1, 2] }, + * { time: 1, data: [3, 4] }, + * { time: 2, data: [5, 6] }, + * ]; + * + * const eventIn = new EventIn({ + * frameSize: 2, + * frameRate: 0, + * frameType: 'vector', + * }); + * + * const onOff = new OnOff(); + * + * const logger = new Logger({ data: true }); + * + * eventIn.connect(onOff); + * onOff.connect(logger); + * + * eventIn.start(); + * + * eventIn.processFrame(frames[0]); + * > [0, 1] + * + * // bypass subgraph + * onOff.setState('off'); + * eventIn.processFrame(frames[1]); + * + * // re-open subgraph + * onOff.setState('on'); + * eventIn.processFrame(frames[2]); + * > [5, 6] + */ + +var OnOff = function (_BaseLfo) { + (0, _inherits3.default)(OnOff, _BaseLfo); + + function OnOff() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, OnOff); + + var _this = (0, _possibleConstructorReturn3.default)(this, (OnOff.__proto__ || (0, _getPrototypeOf2.default)(OnOff)).call(this, definitions, options)); + + _this.state = _this.params.get('state'); + return _this; + } + + /** + * Set the state of the `OnOff`. + * + * @param {String} state - New state of the operator (`on` or `off`) + */ + + + (0, _createClass3.default)(OnOff, [{ + key: 'setState', + value: function setState(state) { + if (definitions.state.list.indexOf(state) === -1) throw new Error('Invalid switch state value "' + state + '" [valid values: "on"/"off"]'); + + this.state = state; + } + + // define all possible stream API + /** @private */ + + }, { + key: 'processScalar', + value: function processScalar() {} + /** @private */ + + }, { + key: 'processVector', + value: function processVector() {} + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal() {} + + /** @private */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + if (this.state === 'on') { + this.prepareFrame(); + + this.frame.time = frame.time; + this.frame.metadata = frame.metadata; + this.frame.data = frame.data; + + this.propagateFrame(); + } + } + }]); + return OnOff; +}(_BaseLfo3.default); + +exports.default = OnOff; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],35:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + exponent: { + type: 'float', + default: 1 + } +}; + +/** + * Apply an exponant power to the stream. + * + * @param {Object} options - Override default parameters + * @param {Number} exponent - Exponent + */ + +var Power = function (_BaseLfo) { + (0, _inherits3.default)(Power, _BaseLfo); + + function Power(options) { + (0, _classCallCheck3.default)(this, Power); + return (0, _possibleConstructorReturn3.default)(this, (Power.__proto__ || (0, _getPrototypeOf2.default)(Power)).call(this, definitions, options)); + } + + (0, _createClass3.default)(Power, [{ + key: 'inputVector', + value: function inputVector(data) { + var outData = this.frame.data; + var frameSize = this.streamParams.frameSize; + var exponent = this.params.get('exponent'); + + for (var i = 0; i < frameSize; i++) { + outData[i] = Math.pow(data[i], exponent); + }return outData; + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.inputVector(frame.data); + } + }, { + key: 'inputSignal', + value: function inputSignal(data) { + var outData = this.frame.data; + var frameSize = this.streamParams.frameSize; + var exponent = this.params.get('exponent'); + + for (var i = 0; i < frameSize; i++) { + outData[i] = Math.pow(data[i], exponent); + }return outData; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.inputSignal(frame.data); + } + }]); + return Power; +}(_BaseLfo3.default); + +exports.default = Power; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],36:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var sqrt = Math.sqrt; + +var definitions = { + power: { + type: 'boolean', + default: false, + metas: { kind: 'dynamic' } + } +}; + +/** + * Compute the Root Mean Square of a `signal`. + * + * _support `standalone` usage_ + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Boolean} [options.power=false] - If `true` remove the "R" of the + * "Rms" and return the squared result (i.e. power). + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * // assuming some `AudioBuffer` + * const audioInBuffer = new lfo.source.AudioInBuffer({ + * audioBuffer: audioBuffer, + * frameSize: 512, + * }); + * + * const rms = new lfo.operator.Rms(); + * const logger = new lfo.sink.Logger({ data: true }); + * + * audioInBuffer.connect(rms); + * rms.connect(logger); + * + * audioInBuffer.start(); + */ + +var Rms = function (_BaseLfo) { + (0, _inherits3.default)(Rms, _BaseLfo); + + function Rms() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Rms); + return (0, _possibleConstructorReturn3.default)(this, (Rms.__proto__ || (0, _getPrototypeOf2.default)(Rms)).call(this, definitions, options)); + } + + /** @private */ + + + (0, _createClass3.default)(Rms, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + this.streamParams.frameSize = 1; + this.streamParams.frameType = 'scalar'; + this.streamParams.description = ['rms']; + + this.propagateStreamParams(); + } + + /** + * Allows for the use of a `Rms` outside a graph (e.g. inside + * another node). Return the rms of the given signal block. + * + * @param {Number} signal - Signal block to be computed. + * @return {Number} - rms of the input signal. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const rms = new lfo.operator.Rms(); + * rms.initStream({ frameType: 'signal', frameSize: 1000 }); + * + * const results = rms.inputSignal([...values]); + */ + + }, { + key: 'inputSignal', + value: function inputSignal(signal) { + var power = this.params.get('power'); + var length = signal.length; + var rms = 0; + + for (var i = 0; i < length; i++) { + rms += signal[i] * signal[i]; + }rms = rms / length; + + if (!power) rms = sqrt(rms); + + return rms; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.frame.data[0] = this.inputSignal(frame.data); + } + }]); + return Rms; +}(_BaseLfo3.default); + +exports.default = Rms; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],37:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + type: { + type: 'enum', + list: ['linear'], + default: 'linear', + metas: { + kind: 'dynamic' + } + }, + inputMin: { + type: 'float', + default: 0, + min: -Infinity, + max: +Infinity, + metas: { + kind: 'dynamic' + } + }, + inputMax: { + type: 'float', + default: 1, + min: -Infinity, + max: +Infinity, + metas: { + kind: 'dynamic' + } + }, + outputMin: { + type: 'float', + default: 1, + min: -Infinity, + max: +Infinity, + metas: { + kind: 'dynamic' + } + }, + outputMax: { + type: 'float', + default: 1, + min: -Infinity, + max: +Infinity, + metas: { + kind: 'dynamic' + } + } + + /** + * Apply a linear scale on the incomming stream. The output is not clipped. + * + * @todo - implement log and exp scale + * + * @param {Object} options - Override default options + * @param {Number} [options.inputMin=0] - Input Minimum + * @param {Number} [options.inputMax=1] - Input Maximum + * @param {Number} [options.outputMin=0] - Output Minimum + * @param {Number} [options.outputMax=1] - Output Maximum + */ +}; +var Scale = function (_BaseLfo) { + (0, _inherits3.default)(Scale, _BaseLfo); + + function Scale(options) { + (0, _classCallCheck3.default)(this, Scale); + + var _this = (0, _possibleConstructorReturn3.default)(this, (Scale.__proto__ || (0, _getPrototypeOf2.default)(Scale)).call(this, definitions, options)); + + _this.scale = null; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(Scale, [{ + key: '_setScaleFunction', + value: function _setScaleFunction() { + var inputMin = this.params.get('inputMin'); + var inputMax = this.params.get('inputMax'); + var outputMin = this.params.get('outputMin'); + var outputMax = this.params.get('outputMax'); + + var a = (outputMax - outputMin) / (inputMax - inputMin); + var b = outputMin - a * inputMin; + + this.scale = function (x) { + return a * x + b; + }; + } + + /** @private */ + + }, { + key: 'onParamUpdate', + value: function onParamUpdate(name, value, metas) { + (0, _get3.default)(Scale.prototype.__proto__ || (0, _getPrototypeOf2.default)(Scale.prototype), 'onParamUpdate', this).call(this, name, value, metas); + + if (name !== 'type') this._setScaleFunction(); + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + this._setScaleFunction(); + + this.propagateStreamParams(); + } + }, { + key: 'inputVector', + value: function inputVector(data) { + var outData = this.frame.data; + var frameSize = this.streamParams.frameSize; + var scale = this.scale; + + for (var i = 0; i < frameSize; i++) { + outData[i] = scale(data[i]); + }return outData; + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + this.frame.data = this.inputVector(frame.data); + } + }, { + key: 'inputSignal', + value: function inputSignal(data) { + var outData = this.frame.data; + var frameSize = this.streamParams.frameSize; + var scale = this.scale; + + for (var i = 0; i < frameSize; i++) { + outData[i] = scale(data[i]); + }return outData; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.frame.data = this.inputVector(frame.data); + } + }]); + return Scale; +}(_BaseLfo3.default); + +exports.default = Scale; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],38:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +var _MovingAverage = require('./MovingAverage'); + +var _MovingAverage2 = _interopRequireDefault(_MovingAverage); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var min = Math.min; +var max = Math.max; + +var definitions = { + logInput: { + type: 'boolean', + default: false, + metas: { kind: 'dyanmic' } + }, + minInput: { + type: 'float', + default: 0.000000000001, + metas: { kind: 'dyanmic' } + }, + filterOrder: { + type: 'integer', + default: 5, + metas: { kind: 'dyanmic' } + }, + threshold: { + type: 'float', + default: 3, + metas: { kind: 'dyanmic' } + }, + offThreshold: { + type: 'float', + default: -Infinity, + metas: { kind: 'dyanmic' } + }, + minInter: { + type: 'float', + default: 0.050, + metas: { kind: 'dyanmic' } + }, + maxDuration: { + type: 'float', + default: Infinity, + metas: { kind: 'dyanmic' } + } + + /** + * Create segments based on attacks. + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Boolean} [options.logInput=false] - Apply log on the input. + * @param {Number} [options.minInput=0.000000000001] - Minimum value to use as + * input. + * @param {Number} [options.filterOrder=5] - Order of the internally used moving + * average. + * @param {Number} [options.threshold=3] - Threshold that triggers a segment + * start. + * @param {Number} [options.offThreshold=-Infinity] - Threshold that triggers + * a segment end. + * @param {Number} [options.minInter=0.050] - Minimum delay between two semgents. + * @param {Number} [options.maxDuration=Infinity] - Maximum duration of a segment. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * // assuming a stream from the microphone + * const source = audioContext.createMediaStreamSource(stream); + * + * const audioInNode = new lfo.source.AudioInNode({ + * sourceNode: source, + * audioContext: audioContext, + * }); + * + * const slicer = new lfo.operator.Slicer({ + * frameSize: frameSize, + * hopSize: hopSize, + * centeredTimeTags: true + * }); + * + * const power = new lfo.operator.RMS({ + * power: true, + * }); + * + * const segmenter = new lfo.operator.Segmenter({ + * logInput: true, + * filterOrder: 5, + * threshold: 3, + * offThreshold: -Infinity, + * minInter: 0.050, + * maxDuration: 0.050, + * }); + * + * const logger = new lfo.sink.Logger({ time: true }); + * + * audioInNode.connect(slicer); + * slicer.connect(power); + * power.connect(segmenter); + * segmenter.connect(logger); + * + * audioInNode.start(); + */ +}; +var Segmenter = function (_BaseLfo) { + (0, _inherits3.default)(Segmenter, _BaseLfo); + + function Segmenter(options) { + (0, _classCallCheck3.default)(this, Segmenter); + + var _this = (0, _possibleConstructorReturn3.default)(this, (Segmenter.__proto__ || (0, _getPrototypeOf2.default)(Segmenter)).call(this, definitions, options)); + + _this.insideSegment = false; + _this.onsetTime = -Infinity; + + // stats + _this.min = Infinity; + _this.max = -Infinity; + _this.sum = 0; + _this.sumOfSquares = 0; + _this.count = 0; + + var minInput = _this.params.get('minInput'); + var fill = minInput; + + if (_this.params.get('logInput') && minInput > 0) fill = Math.log(minInput); + + _this.movingAverage = new _MovingAverage2.default({ + order: _this.params.get('filterOrder'), + fill: fill + }); + + _this.lastMvavrg = fill; + return _this; + } + + (0, _createClass3.default)(Segmenter, [{ + key: 'onParamUpdate', + value: function onParamUpdate(name, value, metas) { + (0, _get3.default)(Segmenter.prototype.__proto__ || (0, _getPrototypeOf2.default)(Segmenter.prototype), 'onParamUpdate', this).call(this, name, value, metas); + + if (name === 'filterOrder') this.movingAverage.params.set('order', value); + } + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + this.streamParams.frameType = 'vector'; + this.streamParams.frameSize = 5; + this.streamParams.frameRate = 0; + this.streamParams.description = ['duration', 'min', 'max', 'mean', 'stddev']; + + this.movingAverage.initStream(prevStreamParams); + + this.propagateStreamParams(); + } + }, { + key: 'resetStream', + value: function resetStream() { + (0, _get3.default)(Segmenter.prototype.__proto__ || (0, _getPrototypeOf2.default)(Segmenter.prototype), 'resetStream', this).call(this); + this.movingAverage.resetStream(); + this.resetSegment(); + } + }, { + key: 'finalizeStream', + value: function finalizeStream(endTime) { + if (this.insideSegment) this.outputSegment(endTime); + + (0, _get3.default)(Segmenter.prototype.__proto__ || (0, _getPrototypeOf2.default)(Segmenter.prototype), 'finalizeStream', this).call(this, endTime); + } + }, { + key: 'resetSegment', + value: function resetSegment() { + this.insideSegment = false; + this.onsetTime = -Infinity; + // stats + this.min = Infinity; + this.max = -Infinity; + this.sum = 0; + this.sumOfSquares = 0; + this.count = 0; + } + }, { + key: 'outputSegment', + value: function outputSegment(endTime) { + var outData = this.frame.data; + outData[0] = endTime - this.onsetTime; + outData[1] = this.min; + outData[2] = this.max; + + var norm = 1 / this.count; + var mean = this.sum * norm; + var meanOfSquare = this.sumOfSquares * norm; + var squareOfmean = mean * mean; + + outData[3] = mean; + outData[4] = 0; + + if (meanOfSquare > squareOfmean) outData[4] = Math.sqrt(meanOfSquare - squareOfmean); + + this.frame.time = this.onsetTime; + + this.propagateFrame(); + } + }, { + key: 'processSignal', + value: function processSignal(frame) { + var logInput = this.params.get('logInput'); + var minInput = this.params.get('minInput'); + var threshold = this.params.get('threshold'); + var minInter = this.params.get('minInter'); + var maxDuration = this.params.get('maxDuration'); + var offThreshold = this.params.get('offThreshold'); + var rawValue = frame.data[0]; + var time = frame.time; + var value = Math.max(rawValue, minInput); + + if (logInput) value = Math.log(value); + + var diff = value - this.lastMvavrg; + this.lastMvavrg = this.movingAverage.inputScalar(value); + + // update frame metadata + this.frame.metadata = frame.metadata; + + if (diff > threshold && time - this.onsetTime > minInter) { + if (this.insideSegment) this.outputSegment(time); + + // start segment + this.insideSegment = true; + this.onsetTime = time; + this.max = -Infinity; + } + + if (this.insideSegment) { + this.min = min(this.min, rawValue); + this.max = max(this.max, rawValue); + this.sum += rawValue; + this.sumOfSquares += rawValue * rawValue; + this.count++; + + if (time - this.onsetTime >= maxDuration || value <= offThreshold) { + this.outputSegment(time); + this.insideSegment = false; + } + } + } + }, { + key: 'processFrame', + value: function processFrame(frame) { + this.prepareFrame(); + this.processFunction(frame); + // do not propagate here as the frameRate is now zero + } + }]); + return Segmenter; +}(_BaseLfo3.default); + +exports.default = Segmenter; + +},{"../../core/BaseLfo":50,"./MovingAverage":31,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],39:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + index: { + type: 'integer', + default: 0, + metas: { kind: 'static' } + }, + indexes: { + type: 'any', + default: null, + nullable: true, + metas: { kind: 'dynamic' } + } +}; + +/** + * Select one or several indexes from a `vector` input. If only one index is + * selected, the output will be of type `scalar`, otherwise the output will + * be a vector containing the selected indexes. + * + * @memberof module:common.operator + * + * @param {Object} options - Override default values. + * @param {Number} options.index - Index to select from the input frame. + * @param {Array} options.indexes - Indices to select from the input + * frame, if defined, take precedance over `option.index`. + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const eventIn = new lfo.source.EventIn({ + * frameType: 'vector', + * frameSize: 3, + * }); + * + * const select = new lfo.operator.Select({ + * indexes: [2, 0], + * }); + * + * eventIn.start(); + * eventIn.process(0, [0, 2, 4]); + * > [4, 0] + * eventIn.process(0, [1, 3, 5]); + * > [5, 1] + */ + +var Select = function (_BaseLfo) { + (0, _inherits3.default)(Select, _BaseLfo); + + function Select() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Select); + return (0, _possibleConstructorReturn3.default)(this, (Select.__proto__ || (0, _getPrototypeOf2.default)(Select)).call(this, definitions, options)); + } + + /** @private */ + + + (0, _createClass3.default)(Select, [{ + key: 'onParamUpdate', + value: function onParamUpdate(name, value) { + var metas = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + (0, _get3.default)(Select.prototype.__proto__ || (0, _getPrototypeOf2.default)(Select.prototype), 'onParamUpdate', this).call(this, name, value, metas); + + var index = this.params.get('index'); + var indexes = this.params.get('indexes'); + + this.select = indexes !== null ? indexes : [index]; + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + var _this2 = this; + + this.prepareStreamParams(prevStreamParams); + + var index = this.params.get('index'); + var indexes = this.params.get('indexes'); + + var max = indexes !== null ? Math.max.apply(null, indexes) : index; + + if (max >= prevStreamParams.frameSize) throw new Error('Invalid select index "' + max + '"'); + + this.streamParams.frameType = indexes !== null ? 'vector' : 'scalar'; + this.streamParams.frameSize = indexes !== null ? indexes.length : 1; + + this.select = indexes !== null ? indexes : [index]; + + // steal description() from parent + if (prevStreamParams.description) { + this.select.forEach(function (val, index) { + _this2.streamParams.description[index] = prevStreamParams.description[val]; + }); + } + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) { + var data = frame.data; + var outData = this.frame.data; + var select = this.select; + + for (var i = 0; i < select.length; i++) { + outData[i] = data[select[i]]; + } + } + }]); + return Select; +}(_BaseLfo3.default); + +exports.default = Select; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],40:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _get2 = require('babel-runtime/helpers/get'); + +var _get3 = _interopRequireDefault(_get2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + frameSize: { + type: 'integer', + default: 512, + metas: { kind: 'static' } + }, + hopSize: { // should be nullable + type: 'integer', + default: null, + nullable: true, + metas: { kind: 'static' } + }, + centeredTimeTags: { + type: 'boolean', + default: false + } + + /** + * Change the `frameSize` and `hopSize` of a `signal` input according to + * the given options. + * This operator updates the stream parameters according to its configuration. + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.frameSize=512] - Frame size of the output signal. + * @param {Number} [options.hopSize=null] - Number of samples between two + * consecutive frames. If null, `hopSize` is set to `frameSize`. + * @param {Boolean} [options.centeredTimeTags] - Move the time tag to the middle + * of the frame. + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const eventIn = new lfo.source.EventIn({ + * frameType: 'signal', + * frameSize: 10, + * sampleRate: 2, + * }); + * + * const slicer = new lfo.operator.Slicer({ + * frameSize: 4, + * hopSize: 2 + * }); + * + * const logger = new lfo.sink.Logger({ time: true, data: true }); + * + * eventIn.connect(slicer); + * slicer.connect(logger); + * eventIn.start(); + * + * eventIn.process(0, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + * > { time: 0, data: [0, 1, 2, 3] } + * > { time: 1, data: [2, 3, 4, 5] } + * > { time: 2, data: [4, 5, 6, 7] } + * > { time: 3, data: [6, 7, 8, 9] } + */ +}; +var Slicer = function (_BaseLfo) { + (0, _inherits3.default)(Slicer, _BaseLfo); + + function Slicer() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Slicer); + + var _this = (0, _possibleConstructorReturn3.default)(this, (Slicer.__proto__ || (0, _getPrototypeOf2.default)(Slicer)).call(this, definitions, options)); + + var hopSize = _this.params.get('hopSize'); + var frameSize = _this.params.get('frameSize'); + + if (!hopSize) _this.params.set('hopSize', frameSize); + + _this.params.addListener(_this.onParamUpdate.bind(_this)); + + _this.frameIndex = 0; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(Slicer, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + var hopSize = this.params.get('hopSize'); + var frameSize = this.params.get('frameSize'); + + this.streamParams.frameSize = frameSize; + this.streamParams.frameRate = prevStreamParams.sourceSampleRate / hopSize; + + if (this.streamParams.frameSize === 1) this.streamParams.frameType = 'scalar';else this.streamParams.frameType = 'signal'; + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'resetStream', + value: function resetStream() { + (0, _get3.default)(Slicer.prototype.__proto__ || (0, _getPrototypeOf2.default)(Slicer.prototype), 'resetStream', this).call(this); + this.frameIndex = 0; + } + + /** @private */ + + }, { + key: 'finalizeStream', + value: function finalizeStream(endTime) { + if (this.frameIndex > 0) { + var frameRate = this.streamParams.frameRate; + var frameSize = this.streamParams.frameSize; + var data = this.frame.data; + // set the time of the last frame + this.frame.time += 1 / frameRate; + + for (var i = this.frameIndex; i < frameSize; i++) { + data[i] = 0; + }this.propagateFrame(); + } + + (0, _get3.default)(Slicer.prototype.__proto__ || (0, _getPrototypeOf2.default)(Slicer.prototype), 'finalizeStream', this).call(this, endTime); + } + + /** @private */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + this.prepareFrame(); + this.processFunction(frame); + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + var time = frame.time; + var block = frame.data; + var metadata = frame.metadata; + + var centeredTimeTags = this.params.get('centeredTimeTags'); + var hopSize = this.params.get('hopSize'); + var outFrame = this.frame.data; + var frameSize = this.streamParams.frameSize; + var sampleRate = this.streamParams.sourceSampleRate; + var samplePeriod = 1 / sampleRate; + var blockSize = block.length; + + var frameIndex = this.frameIndex; + var blockIndex = 0; + + while (blockIndex < blockSize) { + var numSkip = 0; + + // skip block samples for negative frameIndex (frameSize < hopSize) + if (frameIndex < 0) { + numSkip = -frameIndex; + frameIndex = 0; // reset `frameIndex` + } + + if (numSkip < blockSize) { + blockIndex += numSkip; // skip block segment + // can copy all the rest of the incoming block + var numCopy = blockSize - blockIndex; + // connot copy more than what fits into the frame + var maxCopy = frameSize - frameIndex; + + if (numCopy >= maxCopy) numCopy = maxCopy; + + // copy block segment into frame + var copy = block.subarray(blockIndex, blockIndex + numCopy); + outFrame.set(copy, frameIndex); + // advance block and frame index + blockIndex += numCopy; + frameIndex += numCopy; + + // send frame when completed + if (frameIndex === frameSize) { + // define time tag for the outFrame according to configuration + if (centeredTimeTags) this.frame.time = time + (blockIndex - frameSize / 2) * samplePeriod;else this.frame.time = time + (blockIndex - frameSize) * samplePeriod; + + this.frame.metadata = metadata; + // forward to next nodes + this.propagateFrame(); + + // shift frame left + if (hopSize < frameSize) outFrame.set(outFrame.subarray(hopSize, frameSize), 0); + + frameIndex -= hopSize; // hop forward + } + } else { + // skip entire block + var blockRest = blockSize - blockIndex; + frameIndex += blockRest; + blockIndex += blockRest; + } + } + + this.frameIndex = frameIndex; + } + }]); + return Slicer; +}(_BaseLfo3.default); + +exports.default = Slicer; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/get":72,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],41:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var ceil = Math.ceil; + +/** + * paper: http://recherche.ircam.fr/equipes/pcm/cheveign/pss/2002_JASA_YIN.pdf + * implementation based on https://github.com/ashokfernandez/Yin-Pitch-Tracking + * @private + */ + +var definitions = { + threshold: { + type: 'float', + default: 0.1, // default from paper + metas: { kind: 'static' } + }, + downSamplingExp: { // downsampling factor + type: 'integer', + default: 2, + min: 0, + max: 3, + metas: { kind: 'static' } + }, + minFreq: { // + type: 'float', + default: 60, // mean 735 samples + min: 0, + metas: { kind: 'static' } + } + + /** + * Yin fundamental frequency estimator, based on algorithm described in + * [YIN, a fundamental frequency estimator for speech and music](http://recherche.ircam.fr/equipes/pcm/cheveign/pss/2002_JASA_YIN.pdf) + * by Cheveigne and Kawahara. + * On each frame, this operator propagate a vector containing the following + * values: `frequency`, `probability`. + * + * For good results the input frame size should be large (1024 or 2048). + * + * _support `standalone` usage_ + * + * @note - In node for a frame of 2048 samples, average computation time is: + * 0.00016742283339993389 second. + * + * @memberof module:common.operator + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.threshold=0.1] - Absolute threshold to test the + * normalized difference (see paper for more informations). + * @param {Number} [options.downSamplingExp=2] - Down sample the input frame by + * a factor of 2 at the power of `downSamplingExp` (min=0 and max=3) for + * performance improvements. + * @param {Number} [options.minFreq=60] - Minimum frequency the operator can + * search for. This parameter defines the size of the autocorrelation performed + * on the signal, the input frame size should be around 2 time this size for + * good results (i.e. `inputFrameSize ≈ 2 * (samplingRate / minFreq)`). + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * // assuming some AudioBuffer + * const source = new lfo.source.AudioInBuffer({ + * audioBuffer: audioBuffer, + * }); + * + * const slicer = new lfo.operator.Slicer({ + * frameSize: 2048, + * }); + * + * const yin = new lfo.operator.Yin(); + * const logger = new lfo.sink.Logger({ data: true }); + * + * source.connect(slicer); + * slicer.connect(yin); + * yin.connect(logger); + * + * source.start(); + */ +}; +var Yin = function (_BaseLfo) { + (0, _inherits3.default)(Yin, _BaseLfo); + + function Yin(options) { + (0, _classCallCheck3.default)(this, Yin); + + var _this = (0, _possibleConstructorReturn3.default)(this, (Yin.__proto__ || (0, _getPrototypeOf2.default)(Yin)).call(this, definitions, options)); + + _this.probability = 0; + _this.pitch = -1; + + _this.test = 0; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(Yin, [{ + key: '_downsample', + value: function _downsample(input, size, output, downSamplingExp) { + var outputSize = size >> downSamplingExp; + var i = void 0, + j = void 0; + + switch (downSamplingExp) { + case 0: + // no down sampling + for (i = 0; i < size; i++) { + output[i] = input[i]; + }break; + case 1: + for (i = 0, j = 0; i < outputSize; i++, j += 2) { + output[i] = 0.5 * (input[j] + input[j + 1]); + }break; + case 2: + for (i = 0, j = 0; i < outputSize; i++, j += 4) { + output[i] = 0.25 * (input[j] + input[j + 1] + input[j + 2] + input[j + 3]); + }break; + case 3: + for (i = 0, j = 0; i < outputSize; i++, j += 8) { + output[i] = 0.125 * (input[j] + input[j + 1] + input[j + 2] + input[j + 3] + input[j + 4] + input[j + 5] + input[j + 6] + input[j + 7]); + }break; + } + + return outputSize; + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + this.streamParams.frameType = 'vector'; + this.streamParams.frameSize = 2; + this.streamParams.description = ['frequency', 'confidence']; + + this.inputFrameSize = prevStreamParams.frameSize; + // handle params + var sourceSampleRate = this.streamParams.sourceSampleRate; + var downSamplingExp = this.params.get('downSamplingExp'); + var downFactor = 1 << downSamplingExp; // 2^n + var downSR = sourceSampleRate / downFactor; + var downFrameSize = this.inputFrameSize / downFactor; // n_tick_down // 1 / 2^n + + var minFreq = this.params.get('minFreq'); + // limit min freq, cf. paper IV. sensitivity to parameters + var minFreqNbrSamples = downSR / minFreq; + // const bufferSize = prevStreamParams.frameSize; + this.halfBufferSize = downFrameSize / 2; + + // minimum error to not crash but not enought to have results + if (minFreqNbrSamples > this.halfBufferSize) throw new Error('Invalid input frame size, too small for given "minFreq"'); + + this.downSamplingExp = downSamplingExp; + this.downSamplingRate = downSR; + this.downFrameSize = downFrameSize; + this.buffer = new Float32Array(downFrameSize); + // autocorrelation buffer + this.yinBuffer = new Float32Array(this.halfBufferSize); + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: '_downsample', + value: function _downsample(input, size, output, downSamplingExp) { + var outputSize = size >> downSamplingExp; + var i = void 0, + j = void 0; + + switch (downSamplingExp) { + case 0: + // no down sampling + for (i = 0; i < size; i++) { + output[i] = input[i]; + }break; + case 1: + for (i = 0, j = 0; i < outputSize; i++, j += 2) { + output[i] = 0.5 * (input[j] + input[j + 1]); + }break; + case 2: + for (i = 0, j = 0; i < outputSize; i++, j += 4) { + output[i] = 0.25 * (input[j] + input[j + 1] + input[j + 2] + input[j + 3]); + }break; + case 3: + for (i = 0, j = 0; i < outputSize; i++, j += 8) { + output[i] = 0.125 * (input[j] + input[j + 1] + input[j + 2] + input[j + 3] + input[j + 4] + input[j + 5] + input[j + 6] + input[j + 7]); + }break; + } + + return outputSize; + } + + /** + * Step 1, 2 and 3 - Squared difference of the shifted signal with itself. + * cumulative mean normalized difference. + * + * @private + */ + + }, { + key: '_normalizedDifference', + value: function _normalizedDifference(buffer) { + var halfBufferSize = this.halfBufferSize; + var yinBuffer = this.yinBuffer; + var sum = 0; + + // difference for different shift values (tau) + for (var tau = 0; tau < halfBufferSize; tau++) { + var squaredDifference = 0; // reset buffer + + // take difference of the signal with a shifted version of itself then + // sqaure the result + for (var i = 0; i < halfBufferSize; i++) { + var delta = buffer[i] - buffer[i + tau]; + squaredDifference += delta * delta; + } + + // step 3 - normalize yinBuffer + if (tau > 0) { + sum += squaredDifference; + yinBuffer[tau] = squaredDifference * (tau / sum); + } + } + + yinBuffer[0] = 1; + } + + /** + * Step 4 - find first best tau that is under the thresold. + * + * @private + */ + + }, { + key: '_absoluteThreshold', + value: function _absoluteThreshold() { + var threshold = this.params.get('threshold'); + var yinBuffer = this.yinBuffer; + var halfBufferSize = this.halfBufferSize; + var tau = void 0; + + for (tau = 1; tau < halfBufferSize; tau++) { + if (yinBuffer[tau] < threshold) { + // keep increasing tau if next value is better + while (tau + 1 < halfBufferSize && yinBuffer[tau + 1] < yinBuffer[tau]) { + tau += 1; + } // best tau found , yinBuffer[tau] can be seen as an estimation of + // aperiodicity then: periodicity = 1 - aperiodicity + this.probability = 1 - yinBuffer[tau]; + break; + } + } + + // return -1 if not match found + return tau === halfBufferSize ? -1 : tau; + } + + /** + * Step 5 - Find a better fractionnal approximate of tau. + * this can probably be simplified... + * + * @private + */ + + }, { + key: '_parabolicInterpolation', + value: function _parabolicInterpolation(tauEstimate) { + var halfBufferSize = this.halfBufferSize; + var yinBuffer = this.yinBuffer; + var betterTau = void 0; + // @note - tauEstimate cannot be zero as the loop start at 1 in step 4 + var x0 = tauEstimate - 1; + var x2 = tauEstimate < halfBufferSize - 1 ? tauEstimate + 1 : tauEstimate; + + // if `tauEstimate` is last index, we can't interpolate + if (x2 === tauEstimate) { + betterTau = tauEstimate; + } else { + var s0 = yinBuffer[x0]; + var s1 = yinBuffer[tauEstimate]; + var s2 = yinBuffer[x2]; + + // @note - don't fully understand this formula neither... + betterTau = tauEstimate + (s2 - s0) / (2 * (2 * s1 - s2 - s0)); + } + + return betterTau; + } + + /** + * Use the `Yin` operator in `standalone` mode (i.e. outside of a graph). + * + * @param {Array|Float32Array} input - The signal fragment to process. + * @return {Array} - Array containing the `frequency`, `energy`, `periodicity` + * and `AC1` + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const yin = new lfo.operator.Yin(); + * yin.initStream({ + * frameSize: 2048, + * frameType: 'signal', + * sourceSampleRate: 44100 + * }); + * + * const results = yin.inputSignal(signal); + */ + + }, { + key: 'inputSignal', + value: function inputSignal(input) { + this.pitch = -1; + this.probability = 0; + + var buffer = this.buffer; + var inputFrameSize = this.inputFrameSize; + var downSamplingExp = this.downSamplingExp; + var sampleRate = this.downSamplingRate; + var outData = this.frame.data; + var tauEstimate = -1; + + // subsampling + this._downsample(input, inputFrameSize, buffer, downSamplingExp); + // step 1, 2, 3 - normalized squared difference of the signal with a + // shifted version of itself + this._normalizedDifference(buffer); + // step 4 - find first best tau estimate that is over the threshold + tauEstimate = this._absoluteThreshold(); + + if (tauEstimate !== -1) { + // step 5 - so far tau is an integer shift of the signal, check if + // there is a better fractionnal value around + tauEstimate = this._parabolicInterpolation(tauEstimate); + this.pitch = sampleRate / tauEstimate; + } + + outData[0] = this.pitch; + outData[1] = this.probability; + + return outData; + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + this.inputSignal(frame.data); + } + }]); + return Yin; +}(_BaseLfo3.default); + +exports.default = Yin; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],42:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _Biquad = require('./Biquad'); + +var _Biquad2 = _interopRequireDefault(_Biquad); + +var _Clip = require('./Clip'); + +var _Clip2 = _interopRequireDefault(_Clip); + +var _Dct = require('./Dct'); + +var _Dct2 = _interopRequireDefault(_Dct); + +var _Delta = require('./Delta'); + +var _Delta2 = _interopRequireDefault(_Delta); + +var _Fft = require('./Fft'); + +var _Fft2 = _interopRequireDefault(_Fft); + +var _Magnitude = require('./Magnitude'); + +var _Magnitude2 = _interopRequireDefault(_Magnitude); + +var _MeanStddev = require('./MeanStddev'); + +var _MeanStddev2 = _interopRequireDefault(_MeanStddev); + +var _Mel = require('./Mel'); + +var _Mel2 = _interopRequireDefault(_Mel); + +var _Merger = require('./Merger'); + +var _Merger2 = _interopRequireDefault(_Merger); + +var _Mfcc = require('./Mfcc'); + +var _Mfcc2 = _interopRequireDefault(_Mfcc); + +var _MinMax = require('./MinMax'); + +var _MinMax2 = _interopRequireDefault(_MinMax); + +var _MovingAverage = require('./MovingAverage'); + +var _MovingAverage2 = _interopRequireDefault(_MovingAverage); + +var _MovingMedian = require('./MovingMedian'); + +var _MovingMedian2 = _interopRequireDefault(_MovingMedian); + +var _OnOff = require('./OnOff'); + +var _OnOff2 = _interopRequireDefault(_OnOff); + +var _Power = require('./Power'); + +var _Power2 = _interopRequireDefault(_Power); + +var _Rms = require('./Rms'); + +var _Rms2 = _interopRequireDefault(_Rms); + +var _Multiplier = require('./Multiplier'); + +var _Multiplier2 = _interopRequireDefault(_Multiplier); + +var _Scale = require('./Scale'); + +var _Scale2 = _interopRequireDefault(_Scale); + +var _Segmenter = require('./Segmenter'); + +var _Segmenter2 = _interopRequireDefault(_Segmenter); + +var _Select = require('./Select'); + +var _Select2 = _interopRequireDefault(_Select); + +var _Slicer = require('./Slicer'); + +var _Slicer2 = _interopRequireDefault(_Slicer); + +var _Yin = require('./Yin'); + +var _Yin2 = _interopRequireDefault(_Yin); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = { + Biquad: _Biquad2.default, + Clip: _Clip2.default, + Dct: _Dct2.default, + Delta: _Delta2.default, + Fft: _Fft2.default, + Magnitude: _Magnitude2.default, + MeanStddev: _MeanStddev2.default, + Mel: _Mel2.default, + Merger: _Merger2.default, + Mfcc: _Mfcc2.default, + MinMax: _MinMax2.default, + MovingAverage: _MovingAverage2.default, + MovingMedian: _MovingMedian2.default, + OnOff: _OnOff2.default, + Power: _Power2.default, + Rms: _Rms2.default, + Multiplier: _Multiplier2.default, + Scale: _Scale2.default, + Segmenter: _Segmenter2.default, + Select: _Select2.default, + Slicer: _Slicer2.default, + Yin: _Yin2.default +}; + +},{"./Biquad":20,"./Clip":21,"./Dct":22,"./Delta":23,"./Fft":24,"./Magnitude":25,"./MeanStddev":26,"./Mel":27,"./Merger":28,"./Mfcc":29,"./MinMax":30,"./MovingAverage":31,"./MovingMedian":32,"./Multiplier":33,"./OnOff":34,"./Power":35,"./Rms":36,"./Scale":37,"./Segmenter":38,"./Select":39,"./Slicer":40,"./Yin":41}],43:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + processStreamParams: { + type: 'any', + default: null, + nullable: true, + metas: { kind: 'dynamic' } + }, + processFrame: { + type: 'any', + default: null, + nullable: true, + metas: { kind: 'dynamic' } + }, + finalizeStream: { + type: 'any', + default: null, + nullable: true, + metas: { kind: 'dynamic' } + } +}; + +/** + * Create a bridge between the graph and application logic. Handle `push` + * and `pull` paradigms. + * + * This sink can handle any type of input (`signal`, `vector`, `scalar`) + * + * @memberof module:common.sink + * + * @param {Object} options - Override default parameters. + * @param {Function} [options.processFrame=null] - Callback executed on each + * `processFrame` call. + * @param {Function} [options.finalizeStream=null] - Callback executed on each + * `finalizeStream` call. + * + * @see {@link module:core.BaseLfo#processFrame} + * @see {@link module:core.BaseLfo#processStreamParams} + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const frames = [ + * { time: 0, data: [0, 1] }, + * { time: 1, data: [1, 2] }, + * ]; + * + * const eventIn = new EventIn({ + * frameType: 'vector', + * frameSize: 2, + * frameRate: 1, + * }); + * + * const bridge = new Bridge({ + * processFrame: (frame) => console.log(frame), + * }); + * + * eventIn.connect(bridge); + * eventIn.start(); + * + * // callback executed on each frame + * eventIn.processFrame(frame[0]); + * > { time: 0, data: [0, 1] } + * eventIn.processFrame(frame[1]); + * > { time: 1, data: [1, 2] } + * + * // pull current frame when needed + * console.log(bridge.frame); + * > { time: 1, data: [1, 2] } + */ + +var Bridge = function (_BaseLfo) { + (0, _inherits3.default)(Bridge, _BaseLfo); + + function Bridge() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, Bridge); + return (0, _possibleConstructorReturn3.default)(this, (Bridge.__proto__ || (0, _getPrototypeOf2.default)(Bridge)).call(this, definitions, options)); + } + + /** @private */ + + + (0, _createClass3.default)(Bridge, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + var processStreamParamsCallback = this.params.get('processStreamParams'); + + if (processStreamParamsCallback !== null) processStreamParamsCallback(this.streamParams); + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'finalizeStream', + value: function finalizeStream(endTime) { + var finalizeStreamCallback = this.params.get('finalizeStream'); + + if (finalizeStreamCallback !== null) finalizeStreamCallback(endTime); + } + + // process any type + /** @private */ + + }, { + key: 'processScalar', + value: function processScalar() {} + /** @private */ + + }, { + key: 'processVector', + value: function processVector() {} + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal() {} + + /** @private */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + this.prepareFrame(); + + var processFrameCallback = this.params.get('processFrame'); + var output = this.frame; + output.data = new Float32Array(this.streamParams.frameSize); + // pull interface (we copy data since we don't know what could + // be done outside the graph) + for (var i = 0; i < this.streamParams.frameSize; i++) { + output.data[i] = frame.data[i]; + }output.time = frame.time; + output.metadata = frame.metadata; + + // `push` interface + if (processFrameCallback !== null) processFrameCallback(output); + } + }]); + return Bridge; +}(_BaseLfo3.default); + +exports.default = Bridge; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],44:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + separateArrays: { + type: 'boolean', + default: false, + constant: true + }, + callback: { + type: 'any', + default: null, + nullable: true, + metas: { kind: 'dynamic' } + } +}; + +/** + * Record input frames from a graph. This sink can handle `signal`, `vector` + * or `scalar` inputs. + * + * When the recording is stopped (either by calling `stop` on the node or when + * the stream is finalized), the callback given as parameter is executed with + * the recorder data as argument. + * + * + * @param {Object} options - Override default parameters. + * @param {Boolean} [options.separateArrays=false] - Format of the retrieved + * values: + * - when `false`, format is [{ time, data }, { time, data }, ...] + * - when `true`, format is { time: [...], data: [...] } + * @param {Function} [options.callback] - Callback to execute when a new record + * is ended. This can happen when: + * - `stop` is called on the recorder + * - `stop` is called on the source. + * + * @todo - Add auto record param. + * + * @memberof module:common.sink + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const eventIn = new lfo.source.EventIn({ + * frameType: 'vector', + * frameSize: 2, + * frameRate: 0, + * }); + * + * const recorder = new lfo.sink.DataRecorder({ + * callback: (data) => console.log(data), + * }); + * + * eventIn.connect(recorder); + * eventIn.start(); + * recorder.start(); + * + * eventIn.process(0, [0, 1]); + * eventIn.process(1, [1, 2]); + * + * recorder.stop(); + * > [{ time: 0, data: [0, 1] }, { time: 1, data: [1, 2] }]; + */ + +var DataRecorder = function (_BaseLfo) { + (0, _inherits3.default)(DataRecorder, _BaseLfo); + + function DataRecorder() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, DataRecorder); + + /** + * Define if the node is currently recording. + * + * @type {Boolean} + * @name isRecording + * @instance + * @memberof module:sink.SignalRecorder + */ + var _this = (0, _possibleConstructorReturn3.default)(this, (DataRecorder.__proto__ || (0, _getPrototypeOf2.default)(DataRecorder)).call(this, definitions, options)); + + _this.isRecording = false; + return _this; + } + + /** @private */ + + + (0, _createClass3.default)(DataRecorder, [{ + key: '_initStore', + value: function _initStore() { + var separateArrays = this.params.get('separateArrays'); + + if (separateArrays) this._store = { time: [], data: [] };else this._store = []; + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + this._initStore(); + this.propagateStreamParams(); + } + + /** + * Start recording. + * + * @see {@link module:client.sink.DataRecorder#stop} + */ + + }, { + key: 'start', + value: function start() { + this.isRecording = true; + } + + /** + * Stop recording and execute the callback defined in parameters. + * + * @see {@link module:client.sink.DataRecorder#start} + */ + + }, { + key: 'stop', + value: function stop() { + if (this.isRecording) { + this.isRecording = false; + var callback = this.params.get('callback'); + + if (callback !== null) callback(this._store); + + this._initStore(); + } + } + + /** @private */ + + }, { + key: 'finalizeStream', + value: function finalizeStream() { + this.stop(); + } + + // handle any input types + /** @private */ + + }, { + key: 'processScalar', + value: function processScalar(frame) {} + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) {} + /** @private */ + + }, { + key: 'processVector', + value: function processVector(frame) {} + }, { + key: 'processFrame', + value: function processFrame(frame) { + if (this.isRecording) { + this.prepareFrame(frame); + + var separateArrays = this.params.get('separateArrays'); + var entry = { + time: frame.time, + data: new Float32Array(frame.data) + }; + + if (!separateArrays) { + this._store.push(entry); + } else { + this._store.time.push(entry.time); + this._store.data.push(entry.data); + } + } + } + }]); + return DataRecorder; +}(_BaseLfo3.default); + +exports.default = DataRecorder; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],45:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + time: { + type: 'boolean', + default: false, + metas: { kind: 'dynamic' } + }, + data: { + type: 'boolean', + default: false, + metas: { kind: 'dynamic' } + }, + metadata: { + type: 'boolean', + default: false, + metas: { kind: 'dynamic' } + }, + streamParams: { + type: 'boolean', + default: false, + metas: { kind: 'dynamic' } + }, + frameIndex: { + type: 'boolean', + default: false, + metas: { kind: 'dynamic' } + } + + /** + * Log `frame.time`, `frame.data`, `frame.metadata` and/or + * `streamAttributes` of any node in the console. + * + * This sink can handle any type if input (`signal`, `vector`, `scalar`) + * + * @param {Object} options - Override parameters default values. + * @param {Boolean} [options.time=false] - Log incomming `frame.time` if `true`. + * @param {Boolean} [options.data=false] - Log incomming `frame.data` if `true`. + * @param {Boolean} [options.metadata=false] - Log incomming `frame.metadata` + * if `true`. + * @param {Boolean} [options.streamParams=false] - Log `streamParams` of the + * previous node when graph is started. + * @param {Boolean} [options.frameIndex=false] - Log index of the incomming + * `frame`. + * + * @memberof module:common.sink + * + * @example + * import * as lfo from 'waves-lfo/common'; + * + * const logger = new lfo.sink.Logger({ data: true }); + * whateverOperator.connect(logger); + */ +}; +var Logger = function (_BaseLfo) { + (0, _inherits3.default)(Logger, _BaseLfo); + + function Logger(options) { + (0, _classCallCheck3.default)(this, Logger); + return (0, _possibleConstructorReturn3.default)(this, (Logger.__proto__ || (0, _getPrototypeOf2.default)(Logger)).call(this, definitions, options)); + } + + /** @private */ + + + (0, _createClass3.default)(Logger, [{ + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + if (this.params.get('streamParams') === true) console.log(prevStreamParams); + + this.frameIndex = 0; + } + + /** @private */ + + }, { + key: 'processFunction', + value: function processFunction(frame) { + if (this.params.get('frameIndex') === true) console.log(this.frameIndex++); + + if (this.params.get('time') === true) console.log(frame.time); + + if (this.params.get('data') === true) console.log(frame.data); + + if (this.params.get('metadata') === true) console.log(frame.metadata); + } + }]); + return Logger; +}(_BaseLfo3.default); + +exports.default = Logger; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],46:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo2 = require('../../core/BaseLfo'); + +var _BaseLfo3 = _interopRequireDefault(_BaseLfo2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var definitions = { + duration: { + type: 'float', + default: 10, + min: 0, + metas: { kind: 'static' } + }, + callback: { + type: 'any', + default: null, + nullable: true, + metas: { kind: 'dynamic' } + }, + ignoreLeadingZeros: { + type: 'boolean', + default: true, + metas: { kind: 'static' } + }, + retrieveAudioBuffer: { + type: 'boolean', + default: false, + constant: true + }, + audioContext: { + type: 'any', + default: null, + nullable: true + } +}; + +/** + * Record an `signal` input stream of arbitrary duration and retrieve it + * when done. + * + * When recording is stopped (either when the `stop` method is called, the + * defined duration has been recorded, or the source of the graph finalized + * the stream), the callback given as parameter is executed with the + * `AudioBuffer` or `Float32Array` containing the recorded signal as argument. + * + * @todo - add option to return only the Float32Array and not an audio buffer + * (node compliant) `retrieveAudioBuffer: false` + * + * @param {Object} options - Override default parameters. + * @param {Number} [options.duration=10] - Maximum duration of the recording. + * @param {Number} [options.callback] - Callback to execute when a new record is + * ended. This can happen: `stop` is called on the recorder, `stop` is called + * on the source or when the buffer is full according to the given `duration`. + * @param {Object} [options.ignoreLeadingZeros=true] - Start the effective + * recording on the first non-zero value. + * @param {Boolean} [options.retrieveAudioBuffer=false] - Define if an `AudioBuffer` + * should be retrieved or only the raw Float32Array of data. + * (works only in browser) + * @param {AudioContext} [options.audioContext=null] - If + * `retrieveAudioBuffer` is set to `true`, audio context to be used + * in order to create the final audio buffer. + * (works only in browser) + * + * @memberof module:common.sink + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const audioContext = new AudioContext(); + * + * navigator.mediaDevices + * .getUserMedia({ audio: true }) + * .then(init) + * .catch((err) => console.error(err.stack)); + * + * function init(stream) { + * const source = audioContext.createMediaStreamSource(stream); + * + * const audioInNode = new lfo.source.AudioInNode({ + * sourceNode: source, + * audioContext: audioContext, + * }); + * + * const signalRecorder = new lfo.sink.SignalRecorder({ + * duration: 6, + * retrieveAudioBuffer: true, + * audioContext: audioContext, + * callback: (buffer) => { + * const bufferSource = audioContext.createBufferSource(); + * bufferSource.buffer = buffer; + * bufferSource.connect(audioContext.destination); + * bufferSource.start(); + * } + * }); + * + * audioInNode.connect(signalRecorder); + * audioInNode.start(); + * signalRecorder.start(); + * }); + */ + +var SignalRecorder = function (_BaseLfo) { + (0, _inherits3.default)(SignalRecorder, _BaseLfo); + + function SignalRecorder() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, SignalRecorder); + + /** + * Define is the node is currently recording or not. + * + * @type {Boolean} + * @name isRecording + * @instance + * @memberof module:client.sink.SignalRecorder + */ + var _this = (0, _possibleConstructorReturn3.default)(this, (SignalRecorder.__proto__ || (0, _getPrototypeOf2.default)(SignalRecorder)).call(this, definitions, options)); + + _this.isRecording = false; + + var retrieveAudioBuffer = _this.params.get('retrieveAudioBuffer'); + var audioContext = _this.params.get('audioContext'); + // needed to retrieve an AudioBuffer + if (retrieveAudioBuffer && audioContext === null) throw new Error('Invalid parameter "audioContext": an AudioContext must be provided when `retrieveAudioBuffer` is set to `true`'); + + _this._audioContext = audioContext; + _this._ignoreZeros = false; + _this._isInfiniteBuffer = false; + _this._stack = []; + _this._buffer = null; + _this._bufferLength = null; + _this._currentIndex = null; + return _this; + } + + (0, _createClass3.default)(SignalRecorder, [{ + key: '_initBuffer', + value: function _initBuffer() { + this._buffer = new Float32Array(this._bufferLength); + this._stack.length = 0; + this._currentIndex = 0; + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + + var duration = this.params.get('duration'); + var sampleRate = this.streamParams.sourceSampleRate; + + if (isFinite(duration)) { + this._isInfiniteBuffer = false; + this._bufferLength = sampleRate * duration; + } else { + this._isInfiniteBuffer = true; + this._bufferLength = sampleRate * 10; + } + + this._initBuffer(); + this.propagateStreamParams(); + } + + /** + * Start recording. + */ + + }, { + key: 'start', + value: function start() { + this.isRecording = true; + this._ignoreZeros = this.params.get('ignoreLeadingZeros'); + } + + /** + * Stop recording and execute the callback defined in parameters. + */ + + }, { + key: 'stop', + value: function stop() { + if (this.isRecording) { + // ignore next incomming frame + this.isRecording = false; + + var retrieveAudioBuffer = this.params.get('retrieveAudioBuffer'); + var callback = this.params.get('callback'); + var currentIndex = this._currentIndex; + var buffer = this._buffer; + var output = void 0; + + if (!this._isInfiniteBuffer) { + output = new Float32Array(currentIndex); + output.set(buffer.subarray(0, currentIndex), 0); + } else { + var bufferLength = this._bufferLength; + var stack = this._stack; + + output = new Float32Array(stack.length * bufferLength + currentIndex); + + // copy all stacked buffers + for (var i = 0; i < stack.length; i++) { + var stackedBuffer = stack[i]; + output.set(stackedBuffer, bufferLength * i); + }; + // copy data contained in current buffer + output.set(buffer.subarray(0, currentIndex), stack.length * bufferLength); + } + + if (retrieveAudioBuffer && this._audioContext) { + var length = output.length; + var sampleRate = this.streamParams.sourceSampleRate; + var audioBuffer = this._audioContext.createBuffer(1, length, sampleRate); + var channelData = audioBuffer.getChannelData(0); + channelData.set(output, 0); + + callback(audioBuffer); + } else { + callback(output); + } + + // reinit buffer, stack, and currentIndex + this._initBuffer(); + } + } + + /** @private */ + + }, { + key: 'finalizeStream', + value: function finalizeStream(endTime) { + this.stop(); + } + + /** @private */ + + }, { + key: 'processSignal', + value: function processSignal(frame) { + if (!this.isRecording) return; + + var block = null; + var input = frame.data; + var bufferLength = this._bufferLength; + var buffer = this._buffer; + + if (this._ignoreZeros === false) { + block = new Float32Array(input); + } else if (input[input.length - 1] !== 0) { + // find first index where value !== 0 + var i = void 0; + + for (i = 0; i < input.length; i++) { + if (input[i] !== 0) break; + } // copy non zero segment + block = new Float32Array(input.subarray(i)); + // don't repeat this logic once a non-zero value has been found + this._ignoreZeros = false; + } + + if (block !== null) { + var availableSpace = bufferLength - this._currentIndex; + var currentBlock = void 0; + + if (availableSpace < block.length) currentBlock = block.subarray(0, availableSpace);else currentBlock = block; + + buffer.set(currentBlock, this._currentIndex); + this._currentIndex += currentBlock.length; + + if (this._isInfiniteBuffer && this._currentIndex === bufferLength) { + this._stack.push(buffer); + + currentBlock = block.subarray(availableSpace); + this._buffer = new Float32Array(bufferLength); + this._buffer.set(currentBlock, 0); + this._currentIndex = currentBlock.length; + } + + // stop if the buffer is finite and full + if (!this._isInfiniteBuffer && this._currentIndex === bufferLength) this.stop(); + } + } + }]); + return SignalRecorder; +}(_BaseLfo3.default); + +exports.default = SignalRecorder; + +},{"../../core/BaseLfo":50,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],47:[function(require,module,exports){ +(function (process){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _isFinite = require('babel-runtime/core-js/number/is-finite'); + +var _isFinite2 = _interopRequireDefault(_isFinite); + +var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of'); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn'); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require('babel-runtime/helpers/inherits'); + +var _inherits3 = _interopRequireDefault(_inherits2); + +var _BaseLfo = require('../../core/BaseLfo'); + +var _BaseLfo2 = _interopRequireDefault(_BaseLfo); + +var _SourceMixin2 = require('../../core/SourceMixin'); + +var _SourceMixin3 = _interopRequireDefault(_SourceMixin2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser +var isNode = new Function('try { return this === global; } catch(e) { return false }'); + +/** + * Create a function that returns time in seconds according to the current + * environnement (node or browser). + * If running in node the time rely on `process.hrtime`, while if in the browser + * it is provided by the `currentTime` of an `AudioContext`, this context can + * optionnaly be provided to keep time consistency between several `EventIn` + * nodes. + * + * @param {AudioContext} [audioContext=null] - Optionnal audio context. + * @return {Function} + * @private + */ +function getTimeFunction() { + var audioContext = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (isNode()) { + return function () { + var t = process.hrtime(); + return t[0] + t[1] * 1e-9; + }; + } else { + return function () { + return performance.now() / 1000; + }; + } +} + +var definitions = { + absoluteTime: { + type: 'boolean', + default: false, + constant: true + }, + audioContext: { + type: 'any', + default: null, + constant: true, + nullable: true + }, + frameType: { + type: 'enum', + list: ['signal', 'vector', 'scalar'], + default: 'signal', + constant: true + }, + frameSize: { + type: 'integer', + default: 1, + min: 1, + max: +Infinity, // not recommended... + metas: { kind: 'static' } + }, + sampleRate: { + type: 'float', + default: null, + min: 0, + max: +Infinity, // same here + nullable: true, + metas: { kind: 'static' } + }, + frameRate: { + type: 'float', + default: null, + min: 0, + max: +Infinity, // same here + nullable: true, + metas: { kind: 'static' } + }, + description: { + type: 'any', + default: null, + constant: true + } +}; + +/** + * The `EventIn` operator allows to manually create a stream of data or to feed + * a stream from another source (e.g. sensors) into a processing graph. + * + * @param {Object} options - Override parameters' default values. + * @param {String} [options.frameType='signal'] - Type of the input - allowed + * values: `signal`, `vector` or `scalar`. + * @param {Number} [options.frameSize=1] - Size of the output frame. + * @param {Number} [options.sampleRate=null] - Sample rate of the source stream, + * if of type `signal`. + * @param {Number} [options.frameRate=null] - Rate of the source stream, if of + * type `vector`. + * @param {Array|String} [options.description] - Optionnal description + * describing the dimensions of the output frame + * @param {Boolean} [options.absoluteTime=false] - Define if time should be used + * as forwarded as given in the process method, or relatively to the time of + * the first `process` call after start. + * + * @memberof module:common.source + * + * @todo - Add a `logicalTime` parameter to tag frame according to frame rate. + * + * @example + * import * as lfo from 'waves-lfo/client'; + * + * const eventIn = new lfo.source.EventIn({ + * frameType: 'vector', + * frameSize: 3, + * frameRate: 1 / 50, + * description: ['alpha', 'beta', 'gamma'], + * }); + * + * // connect source to operators and sink(s) + * + * // initialize and start the graph + * eventIn.start(); + * + * // feed `deviceorientation` data into the graph + * window.addEventListener('deviceorientation', (e) => { + * const frame = { + * time: window.performace.now() / 1000, + * data: [e.alpha, e.beta, e.gamma], + * }; + * + * eventIn.processFrame(frame); + * }, false); + */ + +var EventIn = function (_SourceMixin) { + (0, _inherits3.default)(EventIn, _SourceMixin); + + function EventIn() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + (0, _classCallCheck3.default)(this, EventIn); + + var _this = (0, _possibleConstructorReturn3.default)(this, (EventIn.__proto__ || (0, _getPrototypeOf2.default)(EventIn)).call(this, definitions, options)); + + var audioContext = _this.params.get('audioContext'); + _this._getTime = getTimeFunction(audioContext); + _this._startTime = null; + _this._systemTime = null; + _this._absoluteTime = _this.params.get('absoluteTime'); + return _this; + } + + /** + * Propagate the `streamParams` in the graph and allow to push frames into + * the graph. Any call to `process` or `processFrame` before `start` will be + * ignored. + * + * @see {@link module:core.BaseLfo#processStreamParams} + * @see {@link module:core.BaseLfo#resetStream} + * @see {@link module:common.source.EventIn#stop} + */ + + + (0, _createClass3.default)(EventIn, [{ + key: 'start', + value: function start() { + var _this2 = this; + + var startTime = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (this.initialized === false) { + if (this.initPromise === null) // init has not yet been called + this.initPromise = this.init(); + + return this.initPromise.then(function () { + return _this2.start(startTime); + }); + } + + this._startTime = startTime; + this._systemTime = null; // value set in the first `process` call + + this.started = true; + } + + /** + * Finalize the stream and stop the whole graph. Any call to `process` or + * `processFrame` after `stop` will be ignored. + * + * @see {@link module:core.BaseLfo#finalizeStream} + * @see {@link module:common.source.EventIn#start} + */ + + }, { + key: 'stop', + value: function stop() { + if (this.started && this._startTime !== null) { + var currentTime = this._getTime(); + var endTime = this.frame.time + (currentTime - this._systemTime); + + this.finalizeStream(endTime); + this.started = false; + } + } + + /** @private */ + + }, { + key: 'processStreamParams', + value: function processStreamParams() { + var frameSize = this.params.get('frameSize'); + var frameType = this.params.get('frameType'); + var sampleRate = this.params.get('sampleRate'); + var frameRate = this.params.get('frameRate'); + var description = this.params.get('description'); + + // init operator's stream params + this.streamParams.frameSize = frameType === 'scalar' ? 1 : frameSize; + this.streamParams.frameType = frameType; + this.streamParams.description = description; + + if (frameType === 'signal') { + if (sampleRate === null) throw new Error('Undefined "sampleRate" for "signal" stream'); + + this.streamParams.sourceSampleRate = sampleRate; + this.streamParams.frameRate = sampleRate / frameSize; + this.streamParams.sourceSampleCount = frameSize; + } else if (frameType === 'vector' || frameType === 'scalar') { + if (frameRate === null) throw new Error('Undefined "frameRate" for "' + frameType + '" stream'); + + this.streamParams.frameRate = frameRate; + this.streamParams.sourceSampleRate = frameRate; + this.streamParams.sourceSampleCount = 1; + } + + this.propagateStreamParams(); + } + + /** @private */ + + }, { + key: 'processFunction', + value: function processFunction(frame) { + var currentTime = this._getTime(); + var inData = frame.data.length ? frame.data : [frame.data]; + var outData = this.frame.data; + // if no time provided, use system time + var time = (0, _isFinite2.default)(frame.time) ? frame.time : currentTime; + + if (this._startTime === null) this._startTime = time; + + if (this._absoluteTime === false) time = time - this._startTime; + + for (var i = 0, l = this.streamParams.frameSize; i < l; i++) { + outData[i] = inData[i]; + }this.frame.time = time; + this.frame.metadata = frame.metadata; + // store current time to compute `endTime` on stop + this._systemTime = currentTime; + } + + /** + * Alternative interface to propagate a frame in the graph. Pack `time`, + * `data` and `metadata` in a frame object. + * + * @param {Number} time - Frame time. + * @param {Float32Array|Array} data - Frame data. + * @param {Object} metadata - Optionnal frame metadata. + * + * @example + * eventIn.process(1, [0, 1, 2]); + * // is equivalent to + * eventIn.processFrame({ time: 1, data: [0, 1, 2] }); + */ + + }, { + key: 'process', + value: function process(time, data) { + var metadata = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + + this.processFrame({ time: time, data: data, metadata: metadata }); + } + + /** + * Propagate a frame object in the graph. + * + * @param {Object} frame - Input frame. + * @param {Number} frame.time - Frame time. + * @param {Float32Array|Array} frame.data - Frame data. + * @param {Object} [frame.metadata=undefined] - Optionnal frame metadata. + * + * @example + * eventIn.processFrame({ time: 1, data: [0, 1, 2] }); + */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + if (!this.started) return; + + this.prepareFrame(); + this.processFunction(frame); + this.propagateFrame(); + } + }]); + return EventIn; +}((0, _SourceMixin3.default)(_BaseLfo2.default)); + +exports.default = EventIn; + +}).call(this,require('_process')) + +},{"../../core/BaseLfo":50,"../../core/SourceMixin":51,"_process":54,"babel-runtime/core-js/number/is-finite":59,"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],48:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +// shortcuts / helpers +var PI = Math.PI; +var cos = Math.cos; +var sin = Math.sin; +var sqrt = Math.sqrt; + +// window creation functions +function initHannWindow(buffer, size, normCoefs) { + var linSum = 0; + var powSum = 0; + var step = 2 * PI / size; + + for (var i = 0; i < size; i++) { + var phi = i * step; + var value = 0.5 - 0.5 * cos(phi); + + buffer[i] = value; + + linSum += value; + powSum += value * value; + } + + normCoefs.linear = size / linSum; + normCoefs.power = sqrt(size / powSum); +} + +function initHammingWindow(buffer, size, normCoefs) { + var linSum = 0; + var powSum = 0; + var step = 2 * PI / size; + + for (var i = 0; i < size; i++) { + var phi = i * step; + var value = 0.54 - 0.46 * cos(phi); + + buffer[i] = value; + + linSum += value; + powSum += value * value; + } + + normCoefs.linear = size / linSum; + normCoefs.power = sqrt(size / powSum); +} + +function initBlackmanWindow(buffer, size, normCoefs) { + var linSum = 0; + var powSum = 0; + var step = 2 * PI / size; + + for (var i = 0; i < size; i++) { + var phi = i * step; + var value = 0.42 - 0.5 * cos(phi) + 0.08 * cos(2 * phi); + + buffer[i] = value; + + linSum += value; + powSum += value * value; + } + + normCoefs.linear = size / linSum; + normCoefs.power = sqrt(size / powSum); +} + +function initBlackmanHarrisWindow(buffer, size, normCoefs) { + var linSum = 0; + var powSum = 0; + var a0 = 0.35875; + var a1 = 0.48829; + var a2 = 0.14128; + var a3 = 0.01168; + var step = 2 * PI / size; + + for (var i = 0; i < size; i++) { + var phi = i * step; + var value = a0 - a1 * cos(phi) + a2 * cos(2 * phi);-a3 * cos(3 * phi); + + buffer[i] = value; + + linSum += value; + powSum += value * value; + } + + normCoefs.linear = size / linSum; + normCoefs.power = sqrt(size / powSum); +} + +function initSineWindow(buffer, size, normCoefs) { + var linSum = 0; + var powSum = 0; + var step = PI / size; + + for (var i = 0; i < size; i++) { + var phi = i * step; + var value = sin(phi); + + buffer[i] = value; + + linSum += value; + powSum += value * value; + } + + normCoefs.linear = size / linSum; + normCoefs.power = sqrt(size / powSum); +} + +function initRectangleWindow(buffer, size, normCoefs) { + for (var i = 0; i < size; i++) { + buffer[i] = 1; + } // @todo - check if these are proper values + normCoefs.linear = 1; + normCoefs.power = 1; +} + +/** + * Create a buffer with window signal. + * + * @memberof module:common.utils + * + * @param {String} name - Name of the window. + * @param {Float32Array} buffer - Buffer to be populated with the window signal. + * @param {Number} size - Size of the buffer. + * @param {Object} normCoefs - Object to be populated with the normailzation + * coefficients. + */ +function initWindow(name, buffer, size, normCoefs) { + name = name.toLowerCase(); + + switch (name) { + case 'hann': + case 'hanning': + initHannWindow(buffer, size, normCoefs); + break; + case 'hamming': + initHammingWindow(buffer, size, normCoefs); + break; + case 'blackman': + initBlackmanWindow(buffer, size, normCoefs); + break; + case 'blackmanharris': + initBlackmanHarrisWindow(buffer, size, normCoefs); + break; + case 'sine': + initSineWindow(buffer, size, normCoefs); + break; + case 'rectangle': + initRectangleWindow(buffer, size, normCoefs); + break; + } +} + +exports.default = initWindow; + +},{}],49:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.decoders = exports.encoders = exports.opcodes = undefined; + +var _stringify = require('babel-runtime/core-js/json/stringify'); + +var _stringify2 = _interopRequireDefault(_stringify); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +//http://stackoverflow.com/questions/8609289/convert-a-binary-nodejs-buffer-to-javascript-arraybuffer +// converts a nodejs Buffer to ArrayBuffer +// export function bufferToArrayBuffer(buffer) { +// const ab = new ArrayBuffer(buffer.length); +// const view = new Uint8Array(ab); + +// for (let i = 0; i < buffer.length; ++i) +// view[i] = buffer[i]; + +// return ab; +// } + +// export function arrayBufferToBuffer(arrayBuffer) { +// const buffer = new Buffer(arrayBuffer.byteLength); +// const view = new Uint8Array(arrayBuffer); + +// for (let i = 0; i < buffer.length; ++i) +// buffer[i] = view[i]; + +// return buffer; +// } + +// http://updates.html5rocks.com/2012/06/How-to-convert-ArrayBuffer-to-and-from-String +function Uint16Array2json(arr) { + var str = String.fromCharCode.apply(null, arr); + return JSON.parse(str.replace(/\u0000/g, '')); +} + +function json2Uint16Array(json) { + var str = (0, _stringify2.default)(json); + var buffer = new ArrayBuffer(str.length * 2); // 2 bytes for each char + var bufferView = new Uint16Array(buffer); + + for (var i = 0, l = str.length; i < l; i++) { + bufferView[i] = str.charCodeAt(i); + }return bufferView; +} + +var opcodes = exports.opcodes = { + INIT_MODULE_REQ: 10, + INIT_MODULE_ACK: 11, + PROCESS_STREAM_PARAMS: 12, + RESET_STREAM: 13, + FINALIZE_STREAM: 14, + PROCESS_FRAME: 15 + + // +};var encoders = exports.encoders = { + opcode: function opcode(name) { + var opcode = opcodes[name]; + var buffer = new Uint16Array(1); + buffer[0] = opcode; + + return buffer; + }, + + // `opcode` 2 bytes (Uint16) | + initModuleReq: function initModuleReq() { + var payload = encoders.opcode('INIT_MODULE_REQ'); + return payload.buffer; + }, + // `opcode` 2 bytes (Uint16) | + initModuleAck: function initModuleAck() { + var payload = encoders.opcode('INIT_MODULE_ACK'); + return payload.buffer; + }, + // `opcode` 2 bytes (Uint16) | + // `streamParams` n bytes (Uint16) + streamParams: function streamParams(_streamParams) { + var opcode = encoders.opcode('PROCESS_STREAM_PARAMS'); + var streamParamsBuffer = json2Uint16Array(_streamParams); + + var payload = new Uint16Array(1 + streamParamsBuffer.length); + payload.set(opcode, 0); + payload.set(streamParamsBuffer, 1); + + return payload.buffer; + }, + // `opcode` 2 bytes (Uint16) | + resetStream: function resetStream() { + var payload = encoders.opcode('RESET_STREAM'); + return payload.buffer; + }, + // `opcode` 2 bytes (Uint16) | + // `endTime` 8 bytes (Float64) + finalizeStream: function finalizeStream(endTime) { + var opcode = encoders.opcode('RESET_STREAM'); + + var endTimeBuffer = new Float64Array(1); + endTimeBuffer[0] = endTime; + + var payload = new Uint16Array(1 + 4); + payload.set(opcode, 0); + payload.set(new Uint16Array(endTimeBuffer.buffer), 1); + + return payload.buffer; + }, + // `opcode` 2 bytes (Uint16) | + // `time` 8 bytes (Float64) | + // `data` frameSize * 4 (Float32) | + // `metadata` n bytes (Uint16) + processFrame: function processFrame(frame, frameSize) { + var opcode = encoders.opcode('PROCESS_FRAME'); + + var time = new Float64Array(1); + time[0] = frame.time; + + var data = new Float32Array(frameSize); + for (var i = 0; i < frameSize; i++) { + data[i] = frame.data[i]; + }var metadata = json2Uint16Array(frame.metadata); + + var length = 1 + 4 + 2 * frameSize + metadata.length; + var payload = new Uint16Array(length); + payload.set(opcode, 0); + payload.set(new Uint16Array(time.buffer), 1); + payload.set(new Uint16Array(data.buffer), 1 + 4); + payload.set(metadata, 1 + 4 + 2 * frameSize); + + return payload.buffer; + } +}; + +var decoders = exports.decoders = { + opcode: function opcode(arrayBuffer) { + return new Uint16Array(arrayBuffer)[0]; + }, + + // `opcode` 2 bytes (Uint16) | + // `streamParams` n bytes (Uint16) + streamParams: function streamParams(arrayBuffer) { + var payload = new Uint16Array(arrayBuffer.slice(2)); + var prevStreamParams = Uint16Array2json(payload); + return prevStreamParams; + }, + + // `opcode` 2 bytes (Uint16) | + // `endTime` 8 bytes (Float64) + finalizeStream: function finalizeStream(arrayBuffer) { + return new Float64Array(arrayBuffer.slice(2))[0]; + }, + + // `opcode` 2 bytes (Uint16) | + // `time` 8 bytes (Float64) | + // `data` frameSize * 4 (Float32) | + // `metadata` n bytes (Uint16) + processFrame: function processFrame(arrayBuffer, frameSize) { + // 1 * 8 bytes + var timeStart = 2; + var timeEnd = timeStart + 8; + var time = new Float64Array(arrayBuffer.slice(timeStart, timeEnd))[0]; + // frameSize * 4 bytes + var dataStart = timeEnd; + var dataEnd = dataStart + 4 * frameSize; + var data = new Float32Array(arrayBuffer.slice(dataStart, dataEnd)); + // rest of payload + var metaStart = dataEnd; + var metaBuffer = new Uint16Array(arrayBuffer.slice(metaStart)); + var metadata = Uint16Array2json(metaBuffer); + + return { time: time, data: data, metadata: metadata }; + } +}; + +},{"babel-runtime/core-js/json/stringify":57}],50:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _assign = require('babel-runtime/core-js/object/assign'); + +var _assign2 = _interopRequireDefault(_assign); + +var _promise = require('babel-runtime/core-js/promise'); + +var _promise2 = _interopRequireDefault(_promise); + +var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck'); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require('babel-runtime/helpers/createClass'); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _parameters = require('@ircam/parameters'); + +var _parameters2 = _interopRequireDefault(_parameters); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var id = 0; + +/** + * Base `lfo` class to be extended in order to create new nodes. + * + * Nodes are divided in 3 categories: + * - **`source`** are responsible for acquering a signal and its properties + * (frameRate, frameSize, etc.) + * - **`sink`** are endpoints of the graph, such nodes can be recorders, + * visualizers, etc. + * - **`operator`** are used to make computation on the input signal and + * forward the results below in the graph. + * + * In most cases the methods to override / extend are: + * - the **`constructor`** to define the parameters of the new lfo node. + * - the **`processStreamParams`** method to define how the node modify the + * stream attributes (e.g. by changing the frame size) + * - the **`process{FrameType}`** method to define the operations that the + * node apply on the stream. The type of input a node can handle is defined + * by its implemented interface, if it implements `processSignal`, a stream + * of type `signal` can be processed, `processVector` to handle + * an input of type `vector`. + * + * _This class should be considered abstract and only + * be used as a base class to extend._ + * + * #### overview of the interface + * + * **initModule** + * + * Returns a Promise that resolves when the module is initialized. Is + * especially important for modules that rely on asynchronous underlying APIs. + * + * **processStreamParams(prevStreamParams)** + * + * `base` class (default implementation) + * - call `prepareStreamParams` + * - call `propagateStreamParams` + * + * `child` class + * - override some of the inherited `streamParams` + * - creates the any related logic buffers + * - call `propagateStreamParams` + * + * _should not call `super.processStreamParams`_ + * + * **prepareStreamParams()** + * + * - assign prevStreamParams to this.streamParams + * - check if the class implements the correct `processInput` method + * + * _shouldn't be extended, only consumed in `processStreamParams`_ + * + * **propagateStreamParams()** + * + * - creates the `frameData` buffer + * - propagate `streamParams` to children + * + * _shouldn't be extended, only consumed in `processStreamParams`_ + * + * **processFrame()** + * + * `base` class (default implementation) + * - call `prepareFrame` + * - assign frameTime and frameMetadata to identity + * - call the proper function according to inputType + * - call `propagateFrame` + * + * `child` class + * - call `prepareFrame` + * - do whatever you want with incomming frame + * - call `propagateFrame` + * + * _should not call `super.processFrame`_ + * + * **prepareFrame()** + * + * - if `reinit` and trigger `processStreamParams` if needed + * + * _shouldn't be extended, only consumed in `processFrame`_ + * + * **propagateFrame()** + * + * - propagate frame to children + * + * _shouldn't be extended, only consumed in `processFrame`_ + * + * @memberof module:core + */ + +var BaseLfo = function () { + function BaseLfo() { + var definitions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + (0, _classCallCheck3.default)(this, BaseLfo); + + this.cid = id++; + + /** + * Parameter bag containing parameter instances. + * + * @type {Object} + * @name params + * @instance + * @memberof module:core.BaseLfo + */ + this.params = (0, _parameters2.default)(definitions, options); + // listen for param updates + this.params.addListener(this.onParamUpdate.bind(this)); + + /** + * Description of the stream output of the node. + * Set to `null` when the node is destroyed. + * + * @type {Object} + * @property {Number} frameSize - Frame size at the output of the node. + * @property {Number} frameRate - Frame rate at the output of the node. + * @property {String} frameType - Frame type at the output of the node, + * possible values are `signal`, `vector` or `scalar`. + * @property {Array|String} description - If type is `vector`, describe + * the dimension(s) of output stream. + * @property {Number} sourceSampleRate - Sample rate of the source of the + * graph. _The value should be defined by sources and never modified_. + * @property {Number} sourceSampleCount - Number of consecutive discrete + * time values contained in the data frame output by the source. + * _The value should be defined by sources and never modified_. + * + * @name streamParams + * @instance + * @memberof module:core.BaseLfo + */ + this.streamParams = { + frameType: null, + frameSize: 1, + frameRate: 0, + description: null, + sourceSampleRate: 0, + sourceSampleCount: null + }; + + /** + * Current frame. This object and its data are updated at each incomming + * frame without reallocating memory. + * + * @type {Object} + * @name frame + * @property {Number} time - Time of the current frame. + * @property {Float32Array} data - Data of the current frame. + * @property {Object} metadata - Metadata associted to the current frame. + * @instance + * @memberof module:core.BaseLfo + */ + this.frame = { + time: 0, + data: null, + metadata: {} + }; + + /** + * List of nodes connected to the ouput of the node (lower in the graph). + * At each frame, the node forward its `frame` to to all its `nextModules`. + * + * @type {Array} + * @name nextModules + * @instance + * @memberof module:core.BaseLfo + * @see {@link module:core.BaseLfo#connect} + * @see {@link module:core.BaseLfo#disconnect} + */ + this.nextModules = []; + + /** + * The node from which the node receive the frames (upper in the graph). + * + * @type {BaseLfo} + * @name prevModule + * @instance + * @memberof module:core.BaseLfo + * @see {@link module:core.BaseLfo#connect} + * @see {@link module:core.BaseLfo#disconnect} + */ + this.prevModule = null; + + /** + * Is set to true when a static parameter is updated. On the next input + * frame all the subgraph streamParams starting from this node will be + * updated. + * + * @type {Boolean} + * @name _reinit + * @instance + * @memberof module:core.BaseLfo + * @private + */ + this._reinit = false; + } + + /** + * Returns an object describing each available parameter of the node. + * + * @return {Object} + */ + + + (0, _createClass3.default)(BaseLfo, [{ + key: 'getParamsDescription', + value: function getParamsDescription() { + return this.params.getDefinitions(); + } + + /** + * Reset all parameters to their initial value (as defined on instantication) + * + * @see {@link module:core.BaseLfo#streamParams} + */ + + }, { + key: 'resetParams', + value: function resetParams() { + this.params.reset(); + } + + /** + * Function called when a param is updated. By default set the `_reinit` + * flag to `true` if the param is `static` one. This method should be + * extended to handle particular logic bound to a specific parameter. + * + * @param {String} name - Name of the parameter. + * @param {Mixed} value - Value of the parameter. + * @param {Object} metas - Metadata associated to the parameter. + */ + + }, { + key: 'onParamUpdate', + value: function onParamUpdate(name, value) { + var metas = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + if (metas.kind === 'static') this._reinit = true; + } + + /** + * Connect the current node (`prevModule`) to another node (`nextOp`). + * A given node can be connected to several operators and propagate frames + * to each of them. + * + * @param {BaseLfo} next - Next operator in the graph. + * @see {@link module:core.BaseLfo#processFrame} + * @see {@link module:core.BaseLfo#disconnect} + */ + + }, { + key: 'connect', + value: function connect(next) { + var _this = this; + + if (this.streamParams === null || next.streamParams === null) throw new Error('Invalid connection: cannot connect a dead node'); + + if (this.streamParams.frameType !== null) { + // graph has already been started + // next.processStreamParams(this.streamParams); + next.initModule().then(function () { + next.processStreamParams(_this.streamParams); + // we can forward frame from now + _this.nextModules.push(next); + next.prevModule = _this; + }); + } else { + this.nextModules.push(next); + next.prevModule = this; + } + } + + /** + * Remove the given operator from its previous operators' `nextModules`. + * + * @param {BaseLfo} [next=null] - The operator to disconnect from the current + * operator. If `null` disconnect all the next operators. + */ + + }, { + key: 'disconnect', + value: function disconnect() { + var _this2 = this; + + var next = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (next === null) { + this.nextModules.forEach(function (next) { + return _this2.disconnect(next); + }); + } else { + var index = this.nextModules.indexOf(this); + this.nextModules.splice(index, 1); + next.prevModule = null; + } + } + + /** + * Destroy all the nodes in the sub-graph starting from the current node. + * When detroyed, the `streamParams` of the node are set to `null`, the + * operator is then considered as `dead` and cannot be reconnected. + * + * @see {@link module:core.BaseLfo#connect} + */ + + }, { + key: 'destroy', + value: function destroy() { + // destroy all chidren + var index = this.nextModules.length; + + while (index--) { + this.nextModules[index].destroy(); + } // disconnect itself from the previous operator + if (this.prevModule) this.prevModule.disconnect(this); + + // mark the object as dead + this.streamParams = null; + } + + /** + * Return a `Promise` that resolve when the module is ready to be consumed. + * Some modules relies on asynchronous APIs at initialization and thus could + * be not ready to be consumed when the graph starts. + * A module should be consider as initialized when all next modules (children) + * are themselves initialized. The event bubbles up from sinks to sources. + * When all its next operators are ready, a source can consider the whole graph + * as ready and then start to produce frames. + * The default implementation resolves when all next operators are resolved + * themselves. + * An operator relying on external async API must override this method to + * resolve only when its dependecy is ready. + * + * @return Promise + * @todo - Handle dynamic connections + */ + + }, { + key: 'initModule', + value: function initModule() { + var nextPromises = this.nextModules.map(function (module) { + return module.initModule(); + }); + + return _promise2.default.all(nextPromises); + } + + /** + * Helper to initialize the stream in standalone mode. + * + * @param {Object} [streamParams={}] - Parameters of the stream. + * + * @see {@link module:core.BaseLfo#processStreamParams} + * @see {@link module:core.BaseLfo#resetStream} + */ + + }, { + key: 'initStream', + value: function initStream() { + var streamParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + this.processStreamParams(streamParams); + this.resetStream(); + } + + /** + * Reset the `frame.data` buffer by setting all its values to 0. + * A source operator should call `processStreamParams` and `resetStream` when + * started, each of these method propagate through the graph automaticaly. + * + * @see {@link module:core.BaseLfo#processStreamParams} + */ + + }, { + key: 'resetStream', + value: function resetStream() { + // buttom up + for (var i = 0, l = this.nextModules.length; i < l; i++) { + this.nextModules[i].resetStream(); + } // no buffer for `scalar` type or sink node + // @note - this should be reviewed + if (this.streamParams.frameType !== 'scalar' && this.frame.data !== null) { + var frameSize = this.streamParams.frameSize; + var data = this.frame.data; + + for (var _i = 0; _i < frameSize; _i++) { + data[_i] = 0; + } + } + } + + /** + * Finalize the stream. A source node should call this method when stopped, + * `finalizeStream` is automatically propagated throught the graph. + * + * @param {Number} endTime - Logical time at which the graph is stopped. + */ + + }, { + key: 'finalizeStream', + value: function finalizeStream(endTime) { + for (var i = 0, l = this.nextModules.length; i < l; i++) { + this.nextModules[i].finalizeStream(endTime); + } + } + + /** + * Initialize or update the operator's `streamParams` according to the + * previous operators `streamParams` values. + * + * When implementing a new operator this method should: + * 1. call `this.prepareStreamParams` with the given `prevStreamParams` + * 2. optionnally change values to `this.streamParams` according to the + * logic performed by the operator. + * 3. optionnally allocate memory for ring buffers, etc. + * 4. call `this.propagateStreamParams` to trigger the method on the next + * operators in the graph. + * + * @param {Object} prevStreamParams - `streamParams` of the previous operator. + * + * @see {@link module:core.BaseLfo#prepareStreamParams} + * @see {@link module:core.BaseLfo#propagateStreamParams} + */ + + }, { + key: 'processStreamParams', + value: function processStreamParams() { + var prevStreamParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + this.prepareStreamParams(prevStreamParams); + this.propagateStreamParams(); + } + + /** + * Common logic to do at the beginning of the `processStreamParam`, must be + * called at the beginning of any `processStreamParam` implementation. + * + * The method mainly check if the current node implement the interface to + * handle the type of frame propagated by it's parent: + * - to handle a `vector` frame type, the class must implement `processVector` + * - to handle a `signal` frame type, the class must implement `processSignal` + * - in case of a 'scalar' frame type, the class can implement any of the + * following by order of preference: `processScalar`, `processVector`, + * `processSignal`. + * + * @param {Object} prevStreamParams - `streamParams` of the previous operator. + * + * @see {@link module:core.BaseLfo#processStreamParams} + * @see {@link module:core.BaseLfo#propagateStreamParams} + */ + + }, { + key: 'prepareStreamParams', + value: function prepareStreamParams() { + var prevStreamParams = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + (0, _assign2.default)(this.streamParams, prevStreamParams); + var prevFrameType = prevStreamParams.frameType; + + switch (prevFrameType) { + case 'scalar': + if (this.processScalar) this.processFunction = this.processScalar;else if (this.processVector) this.processFunction = this.processVector;else if (this.processSignal) this.processFunction = this.processSignal;else throw new Error(this.constructor.name + ' - no "process" function found'); + break; + case 'vector': + if (!('processVector' in this)) throw new Error(this.constructor.name + ' - "processVector" is not defined'); + + this.processFunction = this.processVector; + break; + case 'signal': + if (!('processSignal' in this)) throw new Error(this.constructor.name + ' - "processSignal" is not defined'); + + this.processFunction = this.processSignal; + break; + default: + // defaults to processFunction + break; + } + } + + /** + * Create the `this.frame.data` buffer and forward the operator's `streamParam` + * to all its next operators, must be called at the end of any + * `processStreamParams` implementation. + * + * @see {@link module:core.BaseLfo#processStreamParams} + * @see {@link module:core.BaseLfo#prepareStreamParams} + */ + + }, { + key: 'propagateStreamParams', + value: function propagateStreamParams() { + this.frame.data = new Float32Array(this.streamParams.frameSize); + + for (var i = 0, l = this.nextModules.length; i < l; i++) { + this.nextModules[i].processStreamParams(this.streamParams); + } + } + + /** + * Define the particular logic the operator applies to the stream. + * According to the frame type of the previous node, the method calls one + * of the following method `processVector`, `processSignal` or `processScalar` + * + * @param {Object} frame - Frame (time, data, and metadata) as given by the + * previous operator. The incomming frame should never be modified by + * the operator. + * + * @see {@link module:core.BaseLfo#prepareFrame} + * @see {@link module:core.BaseLfo#propagateFrame} + * @see {@link module:core.BaseLfo#processStreamParams} + */ + + }, { + key: 'processFrame', + value: function processFrame(frame) { + this.prepareFrame(); + + // frameTime and frameMetadata defaults to identity + this.frame.time = frame.time; + this.frame.metadata = frame.metadata; + + this.processFunction(frame); + this.propagateFrame(); + } + + /** + * Pointer to the method called in `processFrame` according to the + * frame type of the previous operator. Is dynamically assigned in + * `prepareStreamParams`. + * + * @see {@link module:core.BaseLfo#prepareStreamParams} + * @see {@link module:core.BaseLfo#processFrame} + */ + + }, { + key: 'processFunction', + value: function processFunction(frame) { + this.frame = frame; + } + + /** + * Common logic to perform at the beginning of the `processFrame`. + * + * @see {@link module:core.BaseLfo#processFrame} + */ + + }, { + key: 'prepareFrame', + value: function prepareFrame() { + if (this._reinit === true) { + var streamParams = this.prevModule !== null ? this.prevModule.streamParams : {}; + this.initStream(streamParams); + this._reinit = false; + } + } + + /** + * Forward the current `frame` to the next operators, is called at the end of + * `processFrame`. + * + * @see {@link module:core.BaseLfo#processFrame} + */ + + }, { + key: 'propagateFrame', + value: function propagateFrame() { + for (var i = 0, l = this.nextModules.length; i < l; i++) { + this.nextModules[i].processFrame(this.frame); + } + } + }]); + return BaseLfo; +}(); + +exports.default = BaseLfo; + +},{"@ircam/parameters":56,"babel-runtime/core-js/object/assign":60,"babel-runtime/core-js/promise":66,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70}],51:[function(require,module,exports){ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _promise = require("babel-runtime/core-js/promise"); + +var _promise2 = _interopRequireDefault(_promise); + +var _getPrototypeOf = require("babel-runtime/core-js/object/get-prototype-of"); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck"); + +var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + +var _createClass2 = require("babel-runtime/helpers/createClass"); + +var _createClass3 = _interopRequireDefault(_createClass2); + +var _possibleConstructorReturn2 = require("babel-runtime/helpers/possibleConstructorReturn"); + +var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2); + +var _inherits2 = require("babel-runtime/helpers/inherits"); + +var _inherits3 = _interopRequireDefault(_inherits2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +/** + * Interface added to `LfoCore to implement source + * + * Source have some responsability on graph as they mostly control its whole + * lifecycle. They must implement the start and stop method in order to + * make sure the graph is initialized and set `started` to true. + * A source should never accept and propagate incomming frames until `started` + * is set to `true`. + * + * @name SourceMixin + * @memberof module:core + * @mixin + * + * @example + * class MySource extends SourceMixin(BaseLfo) {} + */ +var SourceMixin = function SourceMixin(superclass) { + return function (_superclass) { + (0, _inherits3.default)(_class, _superclass); + + function _class() { + var _ref; + + (0, _classCallCheck3.default)(this, _class); + + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + var _this = (0, _possibleConstructorReturn3.default)(this, (_ref = _class.__proto__ || (0, _getPrototypeOf2.default)(_class)).call.apply(_ref, [this].concat(args))); + + _this.initialized = false; + _this.initPromise = null; + _this.started = false; + + _this.start = _this.start.bind(_this); + _this.stop = _this.stop.bind(_this); + return _this; + } + + /** + * Initialize the graph by calling `initModule`. When the returned `Promise` + * fulfills, the graph can be considered as initialized and `start` can be + * called safely. If `start` is called whithout explicit `init`, `init` is + * made internally, actual start of the graph is then not garanteed to be + * synchronous. + * + * @memberof module:core.SourceMixin + * @instance + * @name init + * + * @return Promise + * + * @example + * // safe initialization and start + * source.init().then(() => source.start()) + * // safe initialization and start + * source.start(); + */ + + + (0, _createClass3.default)(_class, [{ + key: "init", + value: function init() { + var _this2 = this; + + this.initPromise = this.initModule().then(function () { + _this2.initStream(); // this is synchronous + _this2.initialized = true; + return _promise2.default.resolve(true); + }); + + return this.initPromise; + } + + /** + * Interface method to implement that starts the graph. + * + * The method main purpose is to make sure take verify initialization step and + * set `started` to `true` when done. + * Should behave synchronously when called inside `init().then()` and async + * if called without init step. + * + * @memberof module:core.SourceMixin + * @instance + * @name start + * + * @example + * // basic `start` implementation + * start() { + * if (this.initialized === false) { + * if (this.initPromise === null) // init has not yet been called + * this.initPromise = this.init(); + * + * this.initPromise.then(this.start); + * return; + * } + * + * this.started = true; + * } + */ + + }, { + key: "start", + value: function start() {} + + /** + * Interface method to implement that stops the graph. + * + * @memberof module:core.SourceMixin + * @instance + * @name stop + * + * @example + * // basic `stop` implementation + * stop() { + * this.started = false; + * } + */ + + }, { + key: "stop", + value: function stop() {} + + /** + * The implementation should never allow incomming frames + * if `this.started` is not `true`. + * + * @memberof module:core.SourceMixin + * @instance + * @name processFrame + * + * @param {Object} frame + * + * @example + * // basic `processFrame` implementation + * processFrame(frame) { + * if (this.started === true) { + * this.prepareFrame(); + * this.processFunction(frame); + * this.propagateFrame(); + * } + * } + */ + + }, { + key: "processFrame", + value: function processFrame(frame) {} + }]); + return _class; + }(superclass); +}; + +exports.default = SourceMixin; + +},{"babel-runtime/core-js/object/get-prototype-of":64,"babel-runtime/core-js/promise":66,"babel-runtime/helpers/classCallCheck":69,"babel-runtime/helpers/createClass":70,"babel-runtime/helpers/inherits":73,"babel-runtime/helpers/possibleConstructorReturn":74}],52:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _BaseLfo = require('./BaseLfo'); + +Object.defineProperty(exports, 'BaseLfo', { + enumerable: true, + get: function get() { + return _interopRequireDefault(_BaseLfo).default; + } +}); + +var _SourceMixin = require('./SourceMixin'); + +Object.defineProperty(exports, 'SourceMixin', { + enumerable: true, + get: function get() { + return _interopRequireDefault(_SourceMixin).default; + } +}); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var version = exports.version = '1.1.1'; + +},{"./BaseLfo":50,"./SourceMixin":51}],53:[function(require,module,exports){ +'use strict'; + +var _client = require('waves-lfo/client'); + +var lfo = _interopRequireWildcard(_client); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } + +var frameSize = 5; +var dt = 0.02; + +var eventIn = new lfo.source.EventIn({ + frameSize: frameSize, + frameRate: 1 / dt, + frameType: 'vector' +}); + +var barChart = new lfo.sink.BarChartDisplay({ + canvas: '#bar-chart' +}); + +eventIn.connect(barChart); +eventIn.start(); + +var data = [0, 0.2, 0.4, 0.6, 0.8]; + +(function generateData() { + for (var i = 0; i < frameSize; i++) { + data[i] = (data[i] + 0.001) % 1; + }eventIn.process(null, data); + + setTimeout(generateData, dt * 1000); +})(); + +},{"waves-lfo/client":1}],54:[function(require,module,exports){ +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + +},{}],55:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +var min = Math.min; +var max = Math.max; + +function clip(value) { + var lower = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -Infinity; + var upper = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : +Infinity; + + return max(lower, min(upper, value)); +} + +/** + * Dictionnary of the available types. Each key correspond to the type of the + * implemented param while the corresponding object value should the + * {@link `paramDefinition`} of the defined type. + * + * typedef {Object} paramTemplates + * @type {Object} + */ + +/** + * Definition of a parameter. The definition should at least contain the entries + * `type` and `default`. Every parameter can also accept optionnal configuration + * entries `constant` and `metas`. + * Available definitions are: + * - {@link booleanDefinition} + * - {@link integerDefinition} + * - {@link floatDefinition} + * - {@link stringDefinition} + * - {@link enumDefinition} + * + * typedef {Object} paramDefinition + * @property {String} type - Type of the parameter. + * @property {Mixed} default - Default value of the parameter if no + * initialization value is provided. + * @property {Boolean} [constant=false] - Define if the parameter can be change + * after its initialization. + * @property {Object} [metas=null] - Any user defined data associated to the + * parameter that couls be usefull in the application. + */ + +exports.default = { + /** + * @typedef {Object} booleanDefinition + * @property {String} [type='boolean'] - Define a boolean parameter. + * @property {Boolean} default - Default value of the parameter. + * @property {Boolean} [constant=false] - Define if the parameter is constant. + * @property {Boolean} [nullable=false] - Define if the parameter is nullable. + * @property {Object} [metas={}] - Optionnal metadata of the parameter. + */ + boolean: { + definitionTemplate: ['default'], + typeCheckFunction: function typeCheckFunction(value, definition, name) { + if (typeof value !== 'boolean') throw new Error('Invalid value for boolean param "' + name + '": ' + value); + + return value; + } + }, + + /** + * @typedef {Object} integerDefinition + * @property {String} [type='integer'] - Define a boolean parameter. + * @property {Mixed} default - Default value of the parameter. + * @property {Number} [min=-Infinity] - Minimum value of the parameter. + * @property {Number} [max=+Infinity] - Maximum value of the parameter. + * @property {Boolean} [constant=false] - Define if the parameter is constant. + * @property {Boolean} [nullable=false] - Define if the parameter is nullable. + * @property {Object} [metas={}] - Optionnal metadata of the parameter. + */ + integer: { + definitionTemplate: ['default'], + typeCheckFunction: function typeCheckFunction(value, definition, name) { + if (!(typeof value === 'number' && Math.floor(value) === value)) throw new Error('Invalid value for integer param "' + name + '": ' + value); + + return clip(value, definition.min, definition.max); + } + }, + + /** + * @typedef {Object} floatDefinition + * @property {String} [type='float'] - Define a boolean parameter. + * @property {Mixed} default - Default value of the parameter. + * @property {Number} [min=-Infinity] - Minimum value of the parameter. + * @property {Number} [max=+Infinity] - Maximum value of the parameter. + * @property {Boolean} [constant=false] - Define if the parameter is constant. + * @property {Boolean} [nullable=false] - Define if the parameter is nullable. + * @property {Object} [metas={}] - Optionnal metadata of the parameter. + */ + float: { + definitionTemplate: ['default'], + typeCheckFunction: function typeCheckFunction(value, definition, name) { + if (typeof value !== 'number' || value !== value) // reject NaN + throw new Error('Invalid value for float param "' + name + '": ' + value); + + return clip(value, definition.min, definition.max); + } + }, + + /** + * @typedef {Object} stringDefinition + * @property {String} [type='string'] - Define a boolean parameter. + * @property {Mixed} default - Default value of the parameter. + * @property {Boolean} [constant=false] - Define if the parameter is constant. + * @property {Boolean} [nullable=false] - Define if the parameter is nullable. + * @property {Object} [metas={}] - Optionnal metadata of the parameter. + */ + string: { + definitionTemplate: ['default'], + typeCheckFunction: function typeCheckFunction(value, definition, name) { + if (typeof value !== 'string') throw new Error('Invalid value for string param "' + name + '": ' + value); + + return value; + } + }, + + /** + * @typedef {Object} enumDefinition + * @property {String} [type='enum'] - Define a boolean parameter. + * @property {Mixed} default - Default value of the parameter. + * @property {Array} list - Possible values of the parameter. + * @property {Boolean} [constant=false] - Define if the parameter is constant. + * @property {Boolean} [nullable=false] - Define if the parameter is nullable. + * @property {Object} [metas={}] - Optionnal metadata of the parameter. + */ + enum: { + definitionTemplate: ['default', 'list'], + typeCheckFunction: function typeCheckFunction(value, definition, name) { + if (definition.list.indexOf(value) === -1) throw new Error('Invalid value for enum param "' + name + '": ' + value); + + return value; + } + }, + + /** + * @typedef {Object} anyDefinition + * @property {String} [type='enum'] - Define a parameter of any type. + * @property {Mixed} default - Default value of the parameter. + * @property {Boolean} [constant=false] - Define if the parameter is constant. + * @property {Boolean} [nullable=false] - Define if the parameter is nullable. + * @property {Object} [metas={}] - Optionnal metadata of the parameter. + */ + any: { + definitionTemplate: ['default'], + typeCheckFunction: function typeCheckFunction(value, definition, name) { + // no check as it can have any type... + return value; + } + } +}; + +},{}],56:[function(require,module,exports){ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _createClass = function () { 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); + +var _paramTemplates = require('./paramTemplates'); + +var _paramTemplates2 = _interopRequireDefault(_paramTemplates); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +/** + * Generic class for typed parameters. + * + * @param {String} name - Name of the parameter. + * @param {Array} definitionTemplate - List of mandatory keys in the param + * definition. + * @param {Function} typeCheckFunction - Function to be used in order to check + * the value against the param definition. + * @param {Object} definition - Definition of the parameter. + * @param {Mixed} value - Value of the parameter. + * @private + */ +var Param = function () { + function Param(name, definitionTemplate, typeCheckFunction, definition, value) { + _classCallCheck(this, Param); + + definitionTemplate.forEach(function (key) { + if (definition.hasOwnProperty(key) === false) throw new Error('Invalid definition for param "' + name + '", ' + key + ' is not defined'); + }); + + this.name = name; + this.type = definition.type; + this.definition = definition; + + if (this.definition.nullable === true && value === null) this.value = null;else this.value = typeCheckFunction(value, definition, name); + this._typeCheckFunction = typeCheckFunction; + } + + /** + * Returns the current value. + * @return {Mixed} + */ + + + _createClass(Param, [{ + key: 'getValue', + value: function getValue() { + return this.value; + } + + /** + * Update the current value. + * @param {Mixed} value - New value of the parameter. + * @return {Boolean} - `true` if the param has been updated, false otherwise + * (e.g. if the parameter already had this value). + */ + + }, { + key: 'setValue', + value: function setValue(value) { + if (this.definition.constant === true) throw new Error('Invalid assignement to constant param "' + this.name + '"'); + + if (!(this.definition.nullable === true && value === null)) value = this._typeCheckFunction(value, this.definition, this.name); + + if (this.value !== value) { + this.value = value; + return true; + } + + return false; + } + }]); + + return Param; +}(); + +/** + * Bag of parameters. Main interface of the library + */ + + +var ParameterBag = function () { + function ParameterBag(params, definitions) { + _classCallCheck(this, ParameterBag); + + /** + * List of parameters. + * + * @type {Object} + * @name _params + * @memberof ParameterBag + * @instance + * @private + */ + this._params = params; + + /** + * List of definitions with init values. + * + * @type {Object} + * @name _definitions + * @memberof ParameterBag + * @instance + * @private + */ + this._definitions = definitions; + + /** + * List of global listeners. + * + * @type {Set} + * @name _globalListeners + * @memberof ParameterBag + * @instance + * @private + */ + this._globalListeners = new Set(); + + /** + * List of params listeners. + * + * @type {Object} + * @name _paramsListeners + * @memberof ParameterBag + * @instance + * @private + */ + this._paramsListeners = {}; + + // initialize empty Set for each param + for (var name in params) { + this._paramsListeners[name] = new Set(); + } + } + + /** + * Return the given definitions along with the initialization values. + * + * @return {Object} + */ + + + _createClass(ParameterBag, [{ + key: 'getDefinitions', + value: function getDefinitions() { + var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (name !== null) return this._definitions[name];else return this._definitions; + } + + /** + * Return the value of the given parameter. + * + * @param {String} name - Name of the parameter. + * @return {Mixed} - Value of the parameter. + */ + + }, { + key: 'get', + value: function get(name) { + if (!this._params[name]) throw new Error('Cannot read property value of undefined parameter "' + name + '"'); + + return this._params[name].value; + } + + /** + * Set the value of a parameter. If the value of the parameter is updated + * (aka if previous value is different from new value) all registered + * callbacks are registered. + * + * @param {String} name - Name of the parameter. + * @param {Mixed} value - Value of the parameter. + * @return {Mixed} - New value of the parameter. + */ + + }, { + key: 'set', + value: function set(name, value) { + var param = this._params[name]; + var updated = param.setValue(value); + value = param.getValue(); + + if (updated) { + var metas = param.definition.metas; + // trigger global listeners + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = this._globalListeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var listener = _step.value; + + listener(name, value, metas); + } // trigger param listeners + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = undefined; + + try { + for (var _iterator2 = this._paramsListeners[name][Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var _listener = _step2.value; + + _listener(value, metas); + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + } + + return value; + } + + /** + * Define if the `name` parameter exists or not. + * + * @param {String} name - Name of the parameter. + * @return {Boolean} + */ + + }, { + key: 'has', + value: function has(name) { + return this._params[name] ? true : false; + } + + /** + * Reset a parameter to its init value. Reset all parameters if no argument. + * + * @param {String} [name=null] - Name of the parameter to reset. + */ + + }, { + key: 'reset', + value: function reset() { + var _this = this; + + var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (name !== null) this.set(name, param.definition.initValue);else Object.keys(this._params).forEach(function (name) { + return _this.reset(name); + }); + } + + /** + * @callback ParameterBag~listenerCallback + * @param {String} name - Parameter name. + * @param {Mixed} value - Updated value of the parameter. + * @param {Object} [meta=] - Given meta data of the parameter. + */ + + /** + * Add listener to all param updates. + * + * @param {ParameterBag~listenerCallack} callback - Listener to register. + */ + + }, { + key: 'addListener', + value: function addListener(callback) { + this._globalListeners.add(callback); + } + + /** + * Remove listener from all param changes. + * + * @param {ParameterBag~listenerCallack} callback - Listener to remove. If + * `null` remove all listeners. + */ + + }, { + key: 'removeListener', + value: function removeListener() { + var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + + if (callback === null) this._globalListeners.clear();else this._globalListeners.delete(callback); + } + + /** + * @callback ParameterBag~paramListenerCallack + * @param {Mixed} value - Updated value of the parameter. + * @param {Object} [meta=] - Given meta data of the parameter. + */ + + /** + * Add listener to a given param updates. + * + * @param {String} name - Parameter name. + * @param {ParameterBag~paramListenerCallack} callback - Function to apply + * when the value of the parameter changes. + * @param {Boolean} [trigger=false] - Execute the callback immediately with + * current parameter value. + */ + + }, { + key: 'addParamListener', + value: function addParamListener(name, callback) { + var trigger = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + + this._paramsListeners[name].add(callback); + + if (trigger) { + var _param = this._params[name]; + var value = _param.getValue(); + var metas = _param.definition.metas; + callback(value, metas); + } + } + + /** + * Remove listener from a given param updates. + * + * @param {String} name - Parameter name. + * @param {ParameterBag~paramListenerCallack} callback - Listener to remove. + * If `null` remove all listeners. + */ + + }, { + key: 'removeParamListener', + value: function removeParamListener(name) { + var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + if (callback === null) this._paramsListeners[name].clear();else this._paramsListeners[name].delete(callback); + } + }]); + + return ParameterBag; +}(); + +/** + * Factory for the `ParameterBag` class. + * + * @param {Object} definitions - Object describing the + * parameters. + * @param {Object} values - Initialization values for the + * parameters. + * @return {ParameterBag} + */ + + +function parameters(definitions) { + var values = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var params = {}; + + for (var name in values) { + if (definitions.hasOwnProperty(name) === false) throw new Error('Unknown param "' + name + '"'); + } + + for (var _name in definitions) { + if (params.hasOwnProperty(_name) === true) throw new Error('Parameter "' + _name + '" already defined'); + + var definition = definitions[_name]; + + if (!_paramTemplates2.default[definition.type]) throw new Error('Unknown param type "' + definition.type + '"'); + + var _paramTemplates$defin = _paramTemplates2.default[definition.type], + definitionTemplate = _paramTemplates$defin.definitionTemplate, + typeCheckFunction = _paramTemplates$defin.typeCheckFunction; + + + var value = void 0; + + if (values.hasOwnProperty(_name) === true) value = values[_name];else value = definition.default; + + // store init value in definition + definition.initValue = value; + + if (!typeCheckFunction || !definitionTemplate) throw new Error('Invalid param type definition "' + definition.type + '"'); + + params[_name] = new Param(_name, definitionTemplate, typeCheckFunction, definition, value); + } + + return new ParameterBag(params, definitions); +} + +/** + * Register a new type for the `parameters` factory. + * @param {String} typeName - Value that will be available as the `type` of a + * param definition. + * @param {parameterDefinition} parameterDefinition - Object describing the + * parameter. + */ +parameters.defineType = function (typeName, parameterDefinition) { + _paramTemplates2.default[typeName] = parameterDefinition; +}; + +exports.default = parameters; + +},{"./paramTemplates":55}],57:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/json/stringify"), __esModule: true }; +},{"core-js/library/fn/json/stringify":76}],58:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/math/log10"), __esModule: true }; +},{"core-js/library/fn/math/log10":77}],59:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/number/is-finite"), __esModule: true }; +},{"core-js/library/fn/number/is-finite":78}],60:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/object/assign"), __esModule: true }; +},{"core-js/library/fn/object/assign":79}],61:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/object/create"), __esModule: true }; +},{"core-js/library/fn/object/create":80}],62:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/object/define-property"), __esModule: true }; +},{"core-js/library/fn/object/define-property":81}],63:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/object/get-own-property-descriptor"), __esModule: true }; +},{"core-js/library/fn/object/get-own-property-descriptor":82}],64:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/object/get-prototype-of"), __esModule: true }; +},{"core-js/library/fn/object/get-prototype-of":83}],65:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/object/set-prototype-of"), __esModule: true }; +},{"core-js/library/fn/object/set-prototype-of":84}],66:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/promise"), __esModule: true }; +},{"core-js/library/fn/promise":85}],67:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/symbol"), __esModule: true }; +},{"core-js/library/fn/symbol":86}],68:[function(require,module,exports){ +module.exports = { "default": require("core-js/library/fn/symbol/iterator"), __esModule: true }; +},{"core-js/library/fn/symbol/iterator":87}],69:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +exports.default = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +}; +},{}],70:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _defineProperty = require("../core-js/object/define-property"); + +var _defineProperty2 = _interopRequireDefault(_defineProperty); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = function () { + 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; + (0, _defineProperty2.default)(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; +}(); +},{"../core-js/object/define-property":62}],71:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _defineProperty = require("../core-js/object/define-property"); + +var _defineProperty2 = _interopRequireDefault(_defineProperty); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = function (obj, key, value) { + if (key in obj) { + (0, _defineProperty2.default)(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +}; +},{"../core-js/object/define-property":62}],72:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _getPrototypeOf = require("../core-js/object/get-prototype-of"); + +var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf); + +var _getOwnPropertyDescriptor = require("../core-js/object/get-own-property-descriptor"); + +var _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = function get(object, property, receiver) { + if (object === null) object = Function.prototype; + var desc = (0, _getOwnPropertyDescriptor2.default)(object, property); + + if (desc === undefined) { + var parent = (0, _getPrototypeOf2.default)(object); + + if (parent === null) { + return undefined; + } else { + return get(parent, property, receiver); + } + } else if ("value" in desc) { + return desc.value; + } else { + var getter = desc.get; + + if (getter === undefined) { + return undefined; + } + + return getter.call(receiver); + } +}; +},{"../core-js/object/get-own-property-descriptor":63,"../core-js/object/get-prototype-of":64}],73:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _setPrototypeOf = require("../core-js/object/set-prototype-of"); + +var _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf); + +var _create = require("../core-js/object/create"); + +var _create2 = _interopRequireDefault(_create); + +var _typeof2 = require("../helpers/typeof"); + +var _typeof3 = _interopRequireDefault(_typeof2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = function (subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : (0, _typeof3.default)(superClass))); + } + + subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass; +}; +},{"../core-js/object/create":61,"../core-js/object/set-prototype-of":65,"../helpers/typeof":75}],74:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _typeof2 = require("../helpers/typeof"); + +var _typeof3 = _interopRequireDefault(_typeof2); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = function (self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && ((typeof call === "undefined" ? "undefined" : (0, _typeof3.default)(call)) === "object" || typeof call === "function") ? call : self; +}; +},{"../helpers/typeof":75}],75:[function(require,module,exports){ +"use strict"; + +exports.__esModule = true; + +var _iterator = require("../core-js/symbol/iterator"); + +var _iterator2 = _interopRequireDefault(_iterator); + +var _symbol = require("../core-js/symbol"); + +var _symbol2 = _interopRequireDefault(_symbol); + +var _typeof = typeof _symbol2.default === "function" && typeof _iterator2.default === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj; }; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = typeof _symbol2.default === "function" && _typeof(_iterator2.default) === "symbol" ? function (obj) { + return typeof obj === "undefined" ? "undefined" : _typeof(obj); +} : function (obj) { + return obj && typeof _symbol2.default === "function" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj); +}; +},{"../core-js/symbol":67,"../core-js/symbol/iterator":68}],76:[function(require,module,exports){ +var core = require('../../modules/_core'); +var $JSON = core.JSON || (core.JSON = { stringify: JSON.stringify }); +module.exports = function stringify(it) { // eslint-disable-line no-unused-vars + return $JSON.stringify.apply($JSON, arguments); +}; + +},{"../../modules/_core":95}],77:[function(require,module,exports){ +require('../../modules/es6.math.log10'); +module.exports = require('../../modules/_core').Math.log10; + +},{"../../modules/_core":95,"../../modules/es6.math.log10":163}],78:[function(require,module,exports){ +require('../../modules/es6.number.is-finite'); +module.exports = require('../../modules/_core').Number.isFinite; + +},{"../../modules/_core":95,"../../modules/es6.number.is-finite":164}],79:[function(require,module,exports){ +require('../../modules/es6.object.assign'); +module.exports = require('../../modules/_core').Object.assign; + +},{"../../modules/_core":95,"../../modules/es6.object.assign":165}],80:[function(require,module,exports){ +require('../../modules/es6.object.create'); +var $Object = require('../../modules/_core').Object; +module.exports = function create(P, D) { + return $Object.create(P, D); +}; + +},{"../../modules/_core":95,"../../modules/es6.object.create":166}],81:[function(require,module,exports){ +require('../../modules/es6.object.define-property'); +var $Object = require('../../modules/_core').Object; +module.exports = function defineProperty(it, key, desc) { + return $Object.defineProperty(it, key, desc); +}; + +},{"../../modules/_core":95,"../../modules/es6.object.define-property":167}],82:[function(require,module,exports){ +require('../../modules/es6.object.get-own-property-descriptor'); +var $Object = require('../../modules/_core').Object; +module.exports = function getOwnPropertyDescriptor(it, key) { + return $Object.getOwnPropertyDescriptor(it, key); +}; + +},{"../../modules/_core":95,"../../modules/es6.object.get-own-property-descriptor":168}],83:[function(require,module,exports){ +require('../../modules/es6.object.get-prototype-of'); +module.exports = require('../../modules/_core').Object.getPrototypeOf; + +},{"../../modules/_core":95,"../../modules/es6.object.get-prototype-of":169}],84:[function(require,module,exports){ +require('../../modules/es6.object.set-prototype-of'); +module.exports = require('../../modules/_core').Object.setPrototypeOf; + +},{"../../modules/_core":95,"../../modules/es6.object.set-prototype-of":170}],85:[function(require,module,exports){ +require('../modules/es6.object.to-string'); +require('../modules/es6.string.iterator'); +require('../modules/web.dom.iterable'); +require('../modules/es6.promise'); +require('../modules/es7.promise.finally'); +require('../modules/es7.promise.try'); +module.exports = require('../modules/_core').Promise; + +},{"../modules/_core":95,"../modules/es6.object.to-string":171,"../modules/es6.promise":172,"../modules/es6.string.iterator":173,"../modules/es7.promise.finally":175,"../modules/es7.promise.try":176,"../modules/web.dom.iterable":179}],86:[function(require,module,exports){ +require('../../modules/es6.symbol'); +require('../../modules/es6.object.to-string'); +require('../../modules/es7.symbol.async-iterator'); +require('../../modules/es7.symbol.observable'); +module.exports = require('../../modules/_core').Symbol; + +},{"../../modules/_core":95,"../../modules/es6.object.to-string":171,"../../modules/es6.symbol":174,"../../modules/es7.symbol.async-iterator":177,"../../modules/es7.symbol.observable":178}],87:[function(require,module,exports){ +require('../../modules/es6.string.iterator'); +require('../../modules/web.dom.iterable'); +module.exports = require('../../modules/_wks-ext').f('iterator'); + +},{"../../modules/_wks-ext":159,"../../modules/es6.string.iterator":173,"../../modules/web.dom.iterable":179}],88:[function(require,module,exports){ +module.exports = function (it) { + if (typeof it != 'function') throw TypeError(it + ' is not a function!'); + return it; +}; + +},{}],89:[function(require,module,exports){ +module.exports = function () { /* empty */ }; + +},{}],90:[function(require,module,exports){ +module.exports = function (it, Constructor, name, forbiddenField) { + if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) { + throw TypeError(name + ': incorrect invocation!'); + } return it; +}; + +},{}],91:[function(require,module,exports){ +var isObject = require('./_is-object'); +module.exports = function (it) { + if (!isObject(it)) throw TypeError(it + ' is not an object!'); + return it; +}; + +},{"./_is-object":114}],92:[function(require,module,exports){ +// false -> Array#indexOf +// true -> Array#includes +var toIObject = require('./_to-iobject'); +var toLength = require('./_to-length'); +var toAbsoluteIndex = require('./_to-absolute-index'); +module.exports = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare + if (IS_INCLUDES && el != el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare + if (value != value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) if (IS_INCLUDES || index in O) { + if (O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +},{"./_to-absolute-index":151,"./_to-iobject":153,"./_to-length":154}],93:[function(require,module,exports){ +// getting tag from 19.1.3.6 Object.prototype.toString() +var cof = require('./_cof'); +var TAG = require('./_wks')('toStringTag'); +// ES3 wrong here +var ARG = cof(function () { return arguments; }()) == 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (e) { /* empty */ } +}; + +module.exports = function (it) { + var O, T, B; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T + // builtinTag case + : ARG ? cof(O) + // ES3 arguments fallback + : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B; +}; + +},{"./_cof":94,"./_wks":160}],94:[function(require,module,exports){ +var toString = {}.toString; + +module.exports = function (it) { + return toString.call(it).slice(8, -1); +}; + +},{}],95:[function(require,module,exports){ +var core = module.exports = { version: '2.5.2' }; +if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef + +},{}],96:[function(require,module,exports){ +// optional / simple context binding +var aFunction = require('./_a-function'); +module.exports = function (fn, that, length) { + aFunction(fn); + if (that === undefined) return fn; + switch (length) { + case 1: return function (a) { + return fn.call(that, a); + }; + case 2: return function (a, b) { + return fn.call(that, a, b); + }; + case 3: return function (a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + +},{"./_a-function":88}],97:[function(require,module,exports){ +// 7.2.1 RequireObjectCoercible(argument) +module.exports = function (it) { + if (it == undefined) throw TypeError("Can't call method on " + it); + return it; +}; + +},{}],98:[function(require,module,exports){ +// Thank's IE8 for his funny defineProperty +module.exports = !require('./_fails')(function () { + return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7; +}); + +},{"./_fails":103}],99:[function(require,module,exports){ +var isObject = require('./_is-object'); +var document = require('./_global').document; +// typeof document.createElement is 'object' in old IE +var is = isObject(document) && isObject(document.createElement); +module.exports = function (it) { + return is ? document.createElement(it) : {}; +}; + +},{"./_global":105,"./_is-object":114}],100:[function(require,module,exports){ +// IE 8- don't enum bug keys +module.exports = ( + 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf' +).split(','); + +},{}],101:[function(require,module,exports){ +// all enumerable object keys, includes symbols +var getKeys = require('./_object-keys'); +var gOPS = require('./_object-gops'); +var pIE = require('./_object-pie'); +module.exports = function (it) { + var result = getKeys(it); + var getSymbols = gOPS.f; + if (getSymbols) { + var symbols = getSymbols(it); + var isEnum = pIE.f; + var i = 0; + var key; + while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key); + } return result; +}; + +},{"./_object-gops":132,"./_object-keys":135,"./_object-pie":136}],102:[function(require,module,exports){ +var global = require('./_global'); +var core = require('./_core'); +var ctx = require('./_ctx'); +var hide = require('./_hide'); +var PROTOTYPE = 'prototype'; + +var $export = function (type, name, source) { + var IS_FORCED = type & $export.F; + var IS_GLOBAL = type & $export.G; + var IS_STATIC = type & $export.S; + var IS_PROTO = type & $export.P; + var IS_BIND = type & $export.B; + var IS_WRAP = type & $export.W; + var exports = IS_GLOBAL ? core : core[name] || (core[name] = {}); + var expProto = exports[PROTOTYPE]; + var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]; + var key, own, out; + if (IS_GLOBAL) source = name; + for (key in source) { + // contains in native + own = !IS_FORCED && target && target[key] !== undefined; + if (own && key in exports) continue; + // export native or passed + out = own ? target[key] : source[key]; + // prevent global pollution for namespaces + exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key] + // bind timers to global for call from export context + : IS_BIND && own ? ctx(out, global) + // wrap global constructors for prevent change them in library + : IS_WRAP && target[key] == out ? (function (C) { + var F = function (a, b, c) { + if (this instanceof C) { + switch (arguments.length) { + case 0: return new C(); + case 1: return new C(a); + case 2: return new C(a, b); + } return new C(a, b, c); + } return C.apply(this, arguments); + }; + F[PROTOTYPE] = C[PROTOTYPE]; + return F; + // make static versions for prototype methods + })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; + // export proto methods to core.%CONSTRUCTOR%.methods.%NAME% + if (IS_PROTO) { + (exports.virtual || (exports.virtual = {}))[key] = out; + // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME% + if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out); + } + } +}; +// type bitmap +$export.F = 1; // forced +$export.G = 2; // global +$export.S = 4; // static +$export.P = 8; // proto +$export.B = 16; // bind +$export.W = 32; // wrap +$export.U = 64; // safe +$export.R = 128; // real proto method for `library` +module.exports = $export; + +},{"./_core":95,"./_ctx":96,"./_global":105,"./_hide":107}],103:[function(require,module,exports){ +module.exports = function (exec) { + try { + return !!exec(); + } catch (e) { + return true; + } +}; + +},{}],104:[function(require,module,exports){ +var ctx = require('./_ctx'); +var call = require('./_iter-call'); +var isArrayIter = require('./_is-array-iter'); +var anObject = require('./_an-object'); +var toLength = require('./_to-length'); +var getIterFn = require('./core.get-iterator-method'); +var BREAK = {}; +var RETURN = {}; +var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) { + var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable); + var f = ctx(fn, that, entries ? 2 : 1); + var index = 0; + var length, step, iterator, result; + if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!'); + // fast case for arrays with default iterator + if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) { + result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]); + if (result === BREAK || result === RETURN) return result; + } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) { + result = call(iterator, f, step.value, entries); + if (result === BREAK || result === RETURN) return result; + } +}; +exports.BREAK = BREAK; +exports.RETURN = RETURN; + +},{"./_an-object":91,"./_ctx":96,"./_is-array-iter":112,"./_iter-call":115,"./_to-length":154,"./core.get-iterator-method":161}],105:[function(require,module,exports){ +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self + // eslint-disable-next-line no-new-func + : Function('return this')(); +if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef + +},{}],106:[function(require,module,exports){ +var hasOwnProperty = {}.hasOwnProperty; +module.exports = function (it, key) { + return hasOwnProperty.call(it, key); +}; + +},{}],107:[function(require,module,exports){ +var dP = require('./_object-dp'); +var createDesc = require('./_property-desc'); +module.exports = require('./_descriptors') ? function (object, key, value) { + return dP.f(object, key, createDesc(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +},{"./_descriptors":98,"./_object-dp":127,"./_property-desc":140}],108:[function(require,module,exports){ +var document = require('./_global').document; +module.exports = document && document.documentElement; + +},{"./_global":105}],109:[function(require,module,exports){ +module.exports = !require('./_descriptors') && !require('./_fails')(function () { + return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function () { return 7; } }).a != 7; +}); + +},{"./_descriptors":98,"./_dom-create":99,"./_fails":103}],110:[function(require,module,exports){ +// fast apply, http://jsperf.lnkit.com/fast-apply/5 +module.exports = function (fn, args, that) { + var un = that === undefined; + switch (args.length) { + case 0: return un ? fn() + : fn.call(that); + case 1: return un ? fn(args[0]) + : fn.call(that, args[0]); + case 2: return un ? fn(args[0], args[1]) + : fn.call(that, args[0], args[1]); + case 3: return un ? fn(args[0], args[1], args[2]) + : fn.call(that, args[0], args[1], args[2]); + case 4: return un ? fn(args[0], args[1], args[2], args[3]) + : fn.call(that, args[0], args[1], args[2], args[3]); + } return fn.apply(that, args); +}; + +},{}],111:[function(require,module,exports){ +// fallback for non-array-like ES3 and non-enumerable old V8 strings +var cof = require('./_cof'); +// eslint-disable-next-line no-prototype-builtins +module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) { + return cof(it) == 'String' ? it.split('') : Object(it); +}; + +},{"./_cof":94}],112:[function(require,module,exports){ +// check on default Array iterator +var Iterators = require('./_iterators'); +var ITERATOR = require('./_wks')('iterator'); +var ArrayProto = Array.prototype; + +module.exports = function (it) { + return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it); +}; + +},{"./_iterators":120,"./_wks":160}],113:[function(require,module,exports){ +// 7.2.2 IsArray(argument) +var cof = require('./_cof'); +module.exports = Array.isArray || function isArray(arg) { + return cof(arg) == 'Array'; +}; + +},{"./_cof":94}],114:[function(require,module,exports){ +module.exports = function (it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; +}; + +},{}],115:[function(require,module,exports){ +// call something on iterator step with safe closing on error +var anObject = require('./_an-object'); +module.exports = function (iterator, fn, value, entries) { + try { + return entries ? fn(anObject(value)[0], value[1]) : fn(value); + // 7.4.6 IteratorClose(iterator, completion) + } catch (e) { + var ret = iterator['return']; + if (ret !== undefined) anObject(ret.call(iterator)); + throw e; + } +}; + +},{"./_an-object":91}],116:[function(require,module,exports){ +'use strict'; +var create = require('./_object-create'); +var descriptor = require('./_property-desc'); +var setToStringTag = require('./_set-to-string-tag'); +var IteratorPrototype = {}; + +// 25.1.2.1.1 %IteratorPrototype%[@@iterator]() +require('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function () { return this; }); + +module.exports = function (Constructor, NAME, next) { + Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) }); + setToStringTag(Constructor, NAME + ' Iterator'); +}; + +},{"./_hide":107,"./_object-create":126,"./_property-desc":140,"./_set-to-string-tag":145,"./_wks":160}],117:[function(require,module,exports){ +'use strict'; +var LIBRARY = require('./_library'); +var $export = require('./_export'); +var redefine = require('./_redefine'); +var hide = require('./_hide'); +var has = require('./_has'); +var Iterators = require('./_iterators'); +var $iterCreate = require('./_iter-create'); +var setToStringTag = require('./_set-to-string-tag'); +var getPrototypeOf = require('./_object-gpo'); +var ITERATOR = require('./_wks')('iterator'); +var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next` +var FF_ITERATOR = '@@iterator'; +var KEYS = 'keys'; +var VALUES = 'values'; + +var returnThis = function () { return this; }; + +module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) { + $iterCreate(Constructor, NAME, next); + var getMethod = function (kind) { + if (!BUGGY && kind in proto) return proto[kind]; + switch (kind) { + case KEYS: return function keys() { return new Constructor(this, kind); }; + case VALUES: return function values() { return new Constructor(this, kind); }; + } return function entries() { return new Constructor(this, kind); }; + }; + var TAG = NAME + ' Iterator'; + var DEF_VALUES = DEFAULT == VALUES; + var VALUES_BUG = false; + var proto = Base.prototype; + var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]; + var $default = $native || getMethod(DEFAULT); + var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined; + var $anyNative = NAME == 'Array' ? proto.entries || $native : $native; + var methods, key, IteratorPrototype; + // Fix native + if ($anyNative) { + IteratorPrototype = getPrototypeOf($anyNative.call(new Base())); + if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) { + // Set @@toStringTag to native iterators + setToStringTag(IteratorPrototype, TAG, true); + // fix for some old engines + if (!LIBRARY && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis); + } + } + // fix Array#{values, @@iterator}.name in V8 / FF + if (DEF_VALUES && $native && $native.name !== VALUES) { + VALUES_BUG = true; + $default = function values() { return $native.call(this); }; + } + // Define iterator + if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) { + hide(proto, ITERATOR, $default); + } + // Plug for library + Iterators[NAME] = $default; + Iterators[TAG] = returnThis; + if (DEFAULT) { + methods = { + values: DEF_VALUES ? $default : getMethod(VALUES), + keys: IS_SET ? $default : getMethod(KEYS), + entries: $entries + }; + if (FORCED) for (key in methods) { + if (!(key in proto)) redefine(proto, key, methods[key]); + } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods); + } + return methods; +}; + +},{"./_export":102,"./_has":106,"./_hide":107,"./_iter-create":116,"./_iterators":120,"./_library":121,"./_object-gpo":133,"./_redefine":142,"./_set-to-string-tag":145,"./_wks":160}],118:[function(require,module,exports){ +var ITERATOR = require('./_wks')('iterator'); +var SAFE_CLOSING = false; + +try { + var riter = [7][ITERATOR](); + riter['return'] = function () { SAFE_CLOSING = true; }; + // eslint-disable-next-line no-throw-literal + Array.from(riter, function () { throw 2; }); +} catch (e) { /* empty */ } + +module.exports = function (exec, skipClosing) { + if (!skipClosing && !SAFE_CLOSING) return false; + var safe = false; + try { + var arr = [7]; + var iter = arr[ITERATOR](); + iter.next = function () { return { done: safe = true }; }; + arr[ITERATOR] = function () { return iter; }; + exec(arr); + } catch (e) { /* empty */ } + return safe; +}; + +},{"./_wks":160}],119:[function(require,module,exports){ +module.exports = function (done, value) { + return { value: value, done: !!done }; +}; + +},{}],120:[function(require,module,exports){ +module.exports = {}; + +},{}],121:[function(require,module,exports){ +module.exports = true; + +},{}],122:[function(require,module,exports){ +var META = require('./_uid')('meta'); +var isObject = require('./_is-object'); +var has = require('./_has'); +var setDesc = require('./_object-dp').f; +var id = 0; +var isExtensible = Object.isExtensible || function () { + return true; +}; +var FREEZE = !require('./_fails')(function () { + return isExtensible(Object.preventExtensions({})); +}); +var setMeta = function (it) { + setDesc(it, META, { value: { + i: 'O' + ++id, // object ID + w: {} // weak collections IDs + } }); +}; +var fastKey = function (it, create) { + // return primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!has(it, META)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMeta(it); + // return object ID + } return it[META].i; +}; +var getWeak = function (it, create) { + if (!has(it, META)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMeta(it); + // return hash weak collections IDs + } return it[META].w; +}; +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it); + return it; +}; +var meta = module.exports = { + KEY: META, + NEED: false, + fastKey: fastKey, + getWeak: getWeak, + onFreeze: onFreeze +}; + +},{"./_fails":103,"./_has":106,"./_is-object":114,"./_object-dp":127,"./_uid":157}],123:[function(require,module,exports){ +var global = require('./_global'); +var macrotask = require('./_task').set; +var Observer = global.MutationObserver || global.WebKitMutationObserver; +var process = global.process; +var Promise = global.Promise; +var isNode = require('./_cof')(process) == 'process'; + +module.exports = function () { + var head, last, notify; + + var flush = function () { + var parent, fn; + if (isNode && (parent = process.domain)) parent.exit(); + while (head) { + fn = head.fn; + head = head.next; + try { + fn(); + } catch (e) { + if (head) notify(); + else last = undefined; + throw e; + } + } last = undefined; + if (parent) parent.enter(); + }; + + // Node.js + if (isNode) { + notify = function () { + process.nextTick(flush); + }; + // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339 + } else if (Observer && !(global.navigator && global.navigator.standalone)) { + var toggle = true; + var node = document.createTextNode(''); + new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new + notify = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (Promise && Promise.resolve) { + var promise = Promise.resolve(); + notify = function () { + promise.then(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessag + // - onreadystatechange + // - setTimeout + } else { + notify = function () { + // strange IE + webpack dev server bug - use .call(global) + macrotask.call(global, flush); + }; + } + + return function (fn) { + var task = { fn: fn, next: undefined }; + if (last) last.next = task; + if (!head) { + head = task; + notify(); + } last = task; + }; +}; + +},{"./_cof":94,"./_global":105,"./_task":150}],124:[function(require,module,exports){ +'use strict'; +// 25.4.1.5 NewPromiseCapability(C) +var aFunction = require('./_a-function'); + +function PromiseCapability(C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aFunction(resolve); + this.reject = aFunction(reject); +} + +module.exports.f = function (C) { + return new PromiseCapability(C); +}; + +},{"./_a-function":88}],125:[function(require,module,exports){ +'use strict'; +// 19.1.2.1 Object.assign(target, source, ...) +var getKeys = require('./_object-keys'); +var gOPS = require('./_object-gops'); +var pIE = require('./_object-pie'); +var toObject = require('./_to-object'); +var IObject = require('./_iobject'); +var $assign = Object.assign; + +// should work with symbols and should have deterministic property order (V8 bug) +module.exports = !$assign || require('./_fails')(function () { + var A = {}; + var B = {}; + // eslint-disable-next-line no-undef + var S = Symbol(); + var K = 'abcdefghijklmnopqrst'; + A[S] = 7; + K.split('').forEach(function (k) { B[k] = k; }); + return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars + var T = toObject(target); + var aLen = arguments.length; + var index = 1; + var getSymbols = gOPS.f; + var isEnum = pIE.f; + while (aLen > index) { + var S = IObject(arguments[index++]); + var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key]; + } return T; +} : $assign; + +},{"./_fails":103,"./_iobject":111,"./_object-gops":132,"./_object-keys":135,"./_object-pie":136,"./_to-object":155}],126:[function(require,module,exports){ +// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) +var anObject = require('./_an-object'); +var dPs = require('./_object-dps'); +var enumBugKeys = require('./_enum-bug-keys'); +var IE_PROTO = require('./_shared-key')('IE_PROTO'); +var Empty = function () { /* empty */ }; +var PROTOTYPE = 'prototype'; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var createDict = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = require('./_dom-create')('iframe'); + var i = enumBugKeys.length; + var lt = '<'; + var gt = '>'; + var iframeDocument; + iframe.style.display = 'none'; + require('./_html').appendChild(iframe); + iframe.src = 'javascript:'; // eslint-disable-line no-script-url + // createDict = iframe.contentWindow.Object; + // html.removeChild(iframe); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt); + iframeDocument.close(); + createDict = iframeDocument.F; + while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]]; + return createDict(); +}; + +module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + Empty[PROTOTYPE] = anObject(O); + result = new Empty(); + Empty[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = createDict(); + return Properties === undefined ? result : dPs(result, Properties); +}; + +},{"./_an-object":91,"./_dom-create":99,"./_enum-bug-keys":100,"./_html":108,"./_object-dps":128,"./_shared-key":146}],127:[function(require,module,exports){ +var anObject = require('./_an-object'); +var IE8_DOM_DEFINE = require('./_ie8-dom-define'); +var toPrimitive = require('./_to-primitive'); +var dP = Object.defineProperty; + +exports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return dP(O, P, Attributes); + } catch (e) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +},{"./_an-object":91,"./_descriptors":98,"./_ie8-dom-define":109,"./_to-primitive":156}],128:[function(require,module,exports){ +var dP = require('./_object-dp'); +var anObject = require('./_an-object'); +var getKeys = require('./_object-keys'); + +module.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var keys = getKeys(Properties); + var length = keys.length; + var i = 0; + var P; + while (length > i) dP.f(O, P = keys[i++], Properties[P]); + return O; +}; + +},{"./_an-object":91,"./_descriptors":98,"./_object-dp":127,"./_object-keys":135}],129:[function(require,module,exports){ +var pIE = require('./_object-pie'); +var createDesc = require('./_property-desc'); +var toIObject = require('./_to-iobject'); +var toPrimitive = require('./_to-primitive'); +var has = require('./_has'); +var IE8_DOM_DEFINE = require('./_ie8-dom-define'); +var gOPD = Object.getOwnPropertyDescriptor; + +exports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P) { + O = toIObject(O); + P = toPrimitive(P, true); + if (IE8_DOM_DEFINE) try { + return gOPD(O, P); + } catch (e) { /* empty */ } + if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]); +}; + +},{"./_descriptors":98,"./_has":106,"./_ie8-dom-define":109,"./_object-pie":136,"./_property-desc":140,"./_to-iobject":153,"./_to-primitive":156}],130:[function(require,module,exports){ +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +var toIObject = require('./_to-iobject'); +var gOPN = require('./_object-gopn').f; +var toString = {}.toString; + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return gOPN(it); + } catch (e) { + return windowNames.slice(); + } +}; + +module.exports.f = function getOwnPropertyNames(it) { + return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it)); +}; + +},{"./_object-gopn":131,"./_to-iobject":153}],131:[function(require,module,exports){ +// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O) +var $keys = require('./_object-keys-internal'); +var hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype'); + +exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return $keys(O, hiddenKeys); +}; + +},{"./_enum-bug-keys":100,"./_object-keys-internal":134}],132:[function(require,module,exports){ +exports.f = Object.getOwnPropertySymbols; + +},{}],133:[function(require,module,exports){ +// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O) +var has = require('./_has'); +var toObject = require('./_to-object'); +var IE_PROTO = require('./_shared-key')('IE_PROTO'); +var ObjectProto = Object.prototype; + +module.exports = Object.getPrototypeOf || function (O) { + O = toObject(O); + if (has(O, IE_PROTO)) return O[IE_PROTO]; + if (typeof O.constructor == 'function' && O instanceof O.constructor) { + return O.constructor.prototype; + } return O instanceof Object ? ObjectProto : null; +}; + +},{"./_has":106,"./_shared-key":146,"./_to-object":155}],134:[function(require,module,exports){ +var has = require('./_has'); +var toIObject = require('./_to-iobject'); +var arrayIndexOf = require('./_array-includes')(false); +var IE_PROTO = require('./_shared-key')('IE_PROTO'); + +module.exports = function (object, names) { + var O = toIObject(object); + var i = 0; + var result = []; + var key; + for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while (names.length > i) if (has(O, key = names[i++])) { + ~arrayIndexOf(result, key) || result.push(key); + } + return result; +}; + +},{"./_array-includes":92,"./_has":106,"./_shared-key":146,"./_to-iobject":153}],135:[function(require,module,exports){ +// 19.1.2.14 / 15.2.3.14 Object.keys(O) +var $keys = require('./_object-keys-internal'); +var enumBugKeys = require('./_enum-bug-keys'); + +module.exports = Object.keys || function keys(O) { + return $keys(O, enumBugKeys); +}; + +},{"./_enum-bug-keys":100,"./_object-keys-internal":134}],136:[function(require,module,exports){ +exports.f = {}.propertyIsEnumerable; + +},{}],137:[function(require,module,exports){ +// most Object methods by ES6 should accept primitives +var $export = require('./_export'); +var core = require('./_core'); +var fails = require('./_fails'); +module.exports = function (KEY, exec) { + var fn = (core.Object || {})[KEY] || Object[KEY]; + var exp = {}; + exp[KEY] = exec(fn); + $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp); +}; + +},{"./_core":95,"./_export":102,"./_fails":103}],138:[function(require,module,exports){ +module.exports = function (exec) { + try { + return { e: false, v: exec() }; + } catch (e) { + return { e: true, v: e }; + } +}; + +},{}],139:[function(require,module,exports){ +var anObject = require('./_an-object'); +var isObject = require('./_is-object'); +var newPromiseCapability = require('./_new-promise-capability'); + +module.exports = function (C, x) { + anObject(C); + if (isObject(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +},{"./_an-object":91,"./_is-object":114,"./_new-promise-capability":124}],140:[function(require,module,exports){ +module.exports = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +},{}],141:[function(require,module,exports){ +var hide = require('./_hide'); +module.exports = function (target, src, safe) { + for (var key in src) { + if (safe && target[key]) target[key] = src[key]; + else hide(target, key, src[key]); + } return target; +}; + +},{"./_hide":107}],142:[function(require,module,exports){ +module.exports = require('./_hide'); + +},{"./_hide":107}],143:[function(require,module,exports){ +// Works with __proto__ only. Old v8 can't work with null proto objects. +/* eslint-disable no-proto */ +var isObject = require('./_is-object'); +var anObject = require('./_an-object'); +var check = function (O, proto) { + anObject(O); + if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!"); +}; +module.exports = { + set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line + function (test, buggy, set) { + try { + set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2); + set(test, []); + buggy = !(test instanceof Array); + } catch (e) { buggy = true; } + return function setPrototypeOf(O, proto) { + check(O, proto); + if (buggy) O.__proto__ = proto; + else set(O, proto); + return O; + }; + }({}, false) : undefined), + check: check +}; + +},{"./_an-object":91,"./_ctx":96,"./_is-object":114,"./_object-gopd":129}],144:[function(require,module,exports){ +'use strict'; +var global = require('./_global'); +var core = require('./_core'); +var dP = require('./_object-dp'); +var DESCRIPTORS = require('./_descriptors'); +var SPECIES = require('./_wks')('species'); + +module.exports = function (KEY) { + var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY]; + if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, { + configurable: true, + get: function () { return this; } + }); +}; + +},{"./_core":95,"./_descriptors":98,"./_global":105,"./_object-dp":127,"./_wks":160}],145:[function(require,module,exports){ +var def = require('./_object-dp').f; +var has = require('./_has'); +var TAG = require('./_wks')('toStringTag'); + +module.exports = function (it, tag, stat) { + if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag }); +}; + +},{"./_has":106,"./_object-dp":127,"./_wks":160}],146:[function(require,module,exports){ +var shared = require('./_shared')('keys'); +var uid = require('./_uid'); +module.exports = function (key) { + return shared[key] || (shared[key] = uid(key)); +}; + +},{"./_shared":147,"./_uid":157}],147:[function(require,module,exports){ +var global = require('./_global'); +var SHARED = '__core-js_shared__'; +var store = global[SHARED] || (global[SHARED] = {}); +module.exports = function (key) { + return store[key] || (store[key] = {}); +}; + +},{"./_global":105}],148:[function(require,module,exports){ +// 7.3.20 SpeciesConstructor(O, defaultConstructor) +var anObject = require('./_an-object'); +var aFunction = require('./_a-function'); +var SPECIES = require('./_wks')('species'); +module.exports = function (O, D) { + var C = anObject(O).constructor; + var S; + return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S); +}; + +},{"./_a-function":88,"./_an-object":91,"./_wks":160}],149:[function(require,module,exports){ +var toInteger = require('./_to-integer'); +var defined = require('./_defined'); +// true -> String#at +// false -> String#codePointAt +module.exports = function (TO_STRING) { + return function (that, pos) { + var s = String(defined(that)); + var i = toInteger(pos); + var l = s.length; + var a, b; + if (i < 0 || i >= l) return TO_STRING ? '' : undefined; + a = s.charCodeAt(i); + return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff + ? TO_STRING ? s.charAt(i) : a + : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000; + }; +}; + +},{"./_defined":97,"./_to-integer":152}],150:[function(require,module,exports){ +var ctx = require('./_ctx'); +var invoke = require('./_invoke'); +var html = require('./_html'); +var cel = require('./_dom-create'); +var global = require('./_global'); +var process = global.process; +var setTask = global.setImmediate; +var clearTask = global.clearImmediate; +var MessageChannel = global.MessageChannel; +var Dispatch = global.Dispatch; +var counter = 0; +var queue = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var defer, channel, port; +var run = function () { + var id = +this; + // eslint-disable-next-line no-prototype-builtins + if (queue.hasOwnProperty(id)) { + var fn = queue[id]; + delete queue[id]; + fn(); + } +}; +var listener = function (event) { + run.call(event.data); +}; +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!setTask || !clearTask) { + setTask = function setImmediate(fn) { + var args = []; + var i = 1; + while (arguments.length > i) args.push(arguments[i++]); + queue[++counter] = function () { + // eslint-disable-next-line no-new-func + invoke(typeof fn == 'function' ? fn : Function(fn), args); + }; + defer(counter); + return counter; + }; + clearTask = function clearImmediate(id) { + delete queue[id]; + }; + // Node.js 0.8- + if (require('./_cof')(process) == 'process') { + defer = function (id) { + process.nextTick(ctx(run, id, 1)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(ctx(run, id, 1)); + }; + // Browsers with MessageChannel, includes WebWorkers + } else if (MessageChannel) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = listener; + defer = ctx(port.postMessage, port, 1); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) { + defer = function (id) { + global.postMessage(id + '', '*'); + }; + global.addEventListener('message', listener, false); + // IE8- + } else if (ONREADYSTATECHANGE in cel('script')) { + defer = function (id) { + html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run.call(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(ctx(run, id, 1), 0); + }; + } +} +module.exports = { + set: setTask, + clear: clearTask +}; + +},{"./_cof":94,"./_ctx":96,"./_dom-create":99,"./_global":105,"./_html":108,"./_invoke":110}],151:[function(require,module,exports){ +var toInteger = require('./_to-integer'); +var max = Math.max; +var min = Math.min; +module.exports = function (index, length) { + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); +}; + +},{"./_to-integer":152}],152:[function(require,module,exports){ +// 7.1.4 ToInteger +var ceil = Math.ceil; +var floor = Math.floor; +module.exports = function (it) { + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); +}; + +},{}],153:[function(require,module,exports){ +// to indexed object, toObject with fallback for non-array-like ES3 strings +var IObject = require('./_iobject'); +var defined = require('./_defined'); +module.exports = function (it) { + return IObject(defined(it)); +}; + +},{"./_defined":97,"./_iobject":111}],154:[function(require,module,exports){ +// 7.1.15 ToLength +var toInteger = require('./_to-integer'); +var min = Math.min; +module.exports = function (it) { + return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 +}; + +},{"./_to-integer":152}],155:[function(require,module,exports){ +// 7.1.13 ToObject(argument) +var defined = require('./_defined'); +module.exports = function (it) { + return Object(defined(it)); +}; + +},{"./_defined":97}],156:[function(require,module,exports){ +// 7.1.1 ToPrimitive(input [, PreferredType]) +var isObject = require('./_is-object'); +// instead of the ES6 spec version, we didn't implement @@toPrimitive case +// and the second argument - flag - preferred type is a string +module.exports = function (it, S) { + if (!isObject(it)) return it; + var fn, val; + if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; + if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val; + if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; + throw TypeError("Can't convert object to primitive value"); +}; + +},{"./_is-object":114}],157:[function(require,module,exports){ +var id = 0; +var px = Math.random(); +module.exports = function (key) { + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); +}; + +},{}],158:[function(require,module,exports){ +var global = require('./_global'); +var core = require('./_core'); +var LIBRARY = require('./_library'); +var wksExt = require('./_wks-ext'); +var defineProperty = require('./_object-dp').f; +module.exports = function (name) { + var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {}); + if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) }); +}; + +},{"./_core":95,"./_global":105,"./_library":121,"./_object-dp":127,"./_wks-ext":159}],159:[function(require,module,exports){ +exports.f = require('./_wks'); + +},{"./_wks":160}],160:[function(require,module,exports){ +var store = require('./_shared')('wks'); +var uid = require('./_uid'); +var Symbol = require('./_global').Symbol; +var USE_SYMBOL = typeof Symbol == 'function'; + +var $exports = module.exports = function (name) { + return store[name] || (store[name] = + USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name)); +}; + +$exports.store = store; + +},{"./_global":105,"./_shared":147,"./_uid":157}],161:[function(require,module,exports){ +var classof = require('./_classof'); +var ITERATOR = require('./_wks')('iterator'); +var Iterators = require('./_iterators'); +module.exports = require('./_core').getIteratorMethod = function (it) { + if (it != undefined) return it[ITERATOR] + || it['@@iterator'] + || Iterators[classof(it)]; +}; + +},{"./_classof":93,"./_core":95,"./_iterators":120,"./_wks":160}],162:[function(require,module,exports){ +'use strict'; +var addToUnscopables = require('./_add-to-unscopables'); +var step = require('./_iter-step'); +var Iterators = require('./_iterators'); +var toIObject = require('./_to-iobject'); + +// 22.1.3.4 Array.prototype.entries() +// 22.1.3.13 Array.prototype.keys() +// 22.1.3.29 Array.prototype.values() +// 22.1.3.30 Array.prototype[@@iterator]() +module.exports = require('./_iter-define')(Array, 'Array', function (iterated, kind) { + this._t = toIObject(iterated); // target + this._i = 0; // next index + this._k = kind; // kind +// 22.1.5.2.1 %ArrayIteratorPrototype%.next() +}, function () { + var O = this._t; + var kind = this._k; + var index = this._i++; + if (!O || index >= O.length) { + this._t = undefined; + return step(1); + } + if (kind == 'keys') return step(0, index); + if (kind == 'values') return step(0, O[index]); + return step(0, [index, O[index]]); +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7) +Iterators.Arguments = Iterators.Array; + +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + +},{"./_add-to-unscopables":89,"./_iter-define":117,"./_iter-step":119,"./_iterators":120,"./_to-iobject":153}],163:[function(require,module,exports){ +// 20.2.2.21 Math.log10(x) +var $export = require('./_export'); + +$export($export.S, 'Math', { + log10: function log10(x) { + return Math.log(x) * Math.LOG10E; + } +}); + +},{"./_export":102}],164:[function(require,module,exports){ +// 20.1.2.2 Number.isFinite(number) +var $export = require('./_export'); +var _isFinite = require('./_global').isFinite; + +$export($export.S, 'Number', { + isFinite: function isFinite(it) { + return typeof it == 'number' && _isFinite(it); + } +}); + +},{"./_export":102,"./_global":105}],165:[function(require,module,exports){ +// 19.1.3.1 Object.assign(target, source) +var $export = require('./_export'); + +$export($export.S + $export.F, 'Object', { assign: require('./_object-assign') }); + +},{"./_export":102,"./_object-assign":125}],166:[function(require,module,exports){ +var $export = require('./_export'); +// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties]) +$export($export.S, 'Object', { create: require('./_object-create') }); + +},{"./_export":102,"./_object-create":126}],167:[function(require,module,exports){ +var $export = require('./_export'); +// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes) +$export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperty: require('./_object-dp').f }); + +},{"./_descriptors":98,"./_export":102,"./_object-dp":127}],168:[function(require,module,exports){ +// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) +var toIObject = require('./_to-iobject'); +var $getOwnPropertyDescriptor = require('./_object-gopd').f; + +require('./_object-sap')('getOwnPropertyDescriptor', function () { + return function getOwnPropertyDescriptor(it, key) { + return $getOwnPropertyDescriptor(toIObject(it), key); + }; +}); + +},{"./_object-gopd":129,"./_object-sap":137,"./_to-iobject":153}],169:[function(require,module,exports){ +// 19.1.2.9 Object.getPrototypeOf(O) +var toObject = require('./_to-object'); +var $getPrototypeOf = require('./_object-gpo'); + +require('./_object-sap')('getPrototypeOf', function () { + return function getPrototypeOf(it) { + return $getPrototypeOf(toObject(it)); + }; +}); + +},{"./_object-gpo":133,"./_object-sap":137,"./_to-object":155}],170:[function(require,module,exports){ +// 19.1.3.19 Object.setPrototypeOf(O, proto) +var $export = require('./_export'); +$export($export.S, 'Object', { setPrototypeOf: require('./_set-proto').set }); + +},{"./_export":102,"./_set-proto":143}],171:[function(require,module,exports){ + +},{}],172:[function(require,module,exports){ +'use strict'; +var LIBRARY = require('./_library'); +var global = require('./_global'); +var ctx = require('./_ctx'); +var classof = require('./_classof'); +var $export = require('./_export'); +var isObject = require('./_is-object'); +var aFunction = require('./_a-function'); +var anInstance = require('./_an-instance'); +var forOf = require('./_for-of'); +var speciesConstructor = require('./_species-constructor'); +var task = require('./_task').set; +var microtask = require('./_microtask')(); +var newPromiseCapabilityModule = require('./_new-promise-capability'); +var perform = require('./_perform'); +var promiseResolve = require('./_promise-resolve'); +var PROMISE = 'Promise'; +var TypeError = global.TypeError; +var process = global.process; +var $Promise = global[PROMISE]; +var isNode = classof(process) == 'process'; +var empty = function () { /* empty */ }; +var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper; +var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f; + +var USE_NATIVE = !!function () { + try { + // correct subclassing with @@species support + var promise = $Promise.resolve(1); + var FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function (exec) { + exec(empty, empty); + }; + // unhandled rejections tracking support, NodeJS Promise without it fails @@species test + return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise; + } catch (e) { /* empty */ } +}(); + +// helpers +var isThenable = function (it) { + var then; + return isObject(it) && typeof (then = it.then) == 'function' ? then : false; +}; +var notify = function (promise, isReject) { + if (promise._n) return; + promise._n = true; + var chain = promise._c; + microtask(function () { + var value = promise._v; + var ok = promise._s == 1; + var i = 0; + var run = function (reaction) { + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then; + try { + if (handler) { + if (!ok) { + if (promise._h == 2) onHandleUnhandled(promise); + promise._h = 1; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); + if (domain) domain.exit(); + } + if (result === reaction.promise) { + reject(TypeError('Promise-chain cycle')); + } else if (then = isThenable(result)) { + then.call(result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (e) { + reject(e); + } + }; + while (chain.length > i) run(chain[i++]); // variable length - can't use forEach + promise._c = []; + promise._n = false; + if (isReject && !promise._h) onUnhandled(promise); + }); +}; +var onUnhandled = function (promise) { + task.call(global, function () { + var value = promise._v; + var unhandled = isUnhandled(promise); + var result, handler, console; + if (unhandled) { + result = perform(function () { + if (isNode) { + process.emit('unhandledRejection', value, promise); + } else if (handler = global.onunhandledrejection) { + handler({ promise: promise, reason: value }); + } else if ((console = global.console) && console.error) { + console.error('Unhandled promise rejection', value); + } + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + promise._h = isNode || isUnhandled(promise) ? 2 : 1; + } promise._a = undefined; + if (unhandled && result.e) throw result.v; + }); +}; +var isUnhandled = function (promise) { + if (promise._h == 1) return false; + var chain = promise._a || promise._c; + var i = 0; + var reaction; + while (chain.length > i) { + reaction = chain[i++]; + if (reaction.fail || !isUnhandled(reaction.promise)) return false; + } return true; +}; +var onHandleUnhandled = function (promise) { + task.call(global, function () { + var handler; + if (isNode) { + process.emit('rejectionHandled', promise); + } else if (handler = global.onrejectionhandled) { + handler({ promise: promise, reason: promise._v }); + } + }); +}; +var $reject = function (value) { + var promise = this; + if (promise._d) return; + promise._d = true; + promise = promise._w || promise; // unwrap + promise._v = value; + promise._s = 2; + if (!promise._a) promise._a = promise._c.slice(); + notify(promise, true); +}; +var $resolve = function (value) { + var promise = this; + var then; + if (promise._d) return; + promise._d = true; + promise = promise._w || promise; // unwrap + try { + if (promise === value) throw TypeError("Promise can't be resolved itself"); + if (then = isThenable(value)) { + microtask(function () { + var wrapper = { _w: promise, _d: false }; // wrap + try { + then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1)); + } catch (e) { + $reject.call(wrapper, e); + } + }); + } else { + promise._v = value; + promise._s = 1; + notify(promise, false); + } + } catch (e) { + $reject.call({ _w: promise, _d: false }, e); // wrap + } +}; + +// constructor polyfill +if (!USE_NATIVE) { + // 25.4.3.1 Promise(executor) + $Promise = function Promise(executor) { + anInstance(this, $Promise, PROMISE, '_h'); + aFunction(executor); + Internal.call(this); + try { + executor(ctx($resolve, this, 1), ctx($reject, this, 1)); + } catch (err) { + $reject.call(this, err); + } + }; + // eslint-disable-next-line no-unused-vars + Internal = function Promise(executor) { + this._c = []; // <- awaiting reactions + this._a = undefined; // <- checked in isUnhandled reactions + this._s = 0; // <- state + this._d = false; // <- done + this._v = undefined; // <- value + this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled + this._n = false; // <- notify + }; + Internal.prototype = require('./_redefine-all')($Promise.prototype, { + // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected) + then: function then(onFulfilled, onRejected) { + var reaction = newPromiseCapability(speciesConstructor(this, $Promise)); + reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true; + reaction.fail = typeof onRejected == 'function' && onRejected; + reaction.domain = isNode ? process.domain : undefined; + this._c.push(reaction); + if (this._a) this._a.push(reaction); + if (this._s) notify(this, false); + return reaction.promise; + }, + // 25.4.5.1 Promise.prototype.catch(onRejected) + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + OwnPromiseCapability = function () { + var promise = new Internal(); + this.promise = promise; + this.resolve = ctx($resolve, promise, 1); + this.reject = ctx($reject, promise, 1); + }; + newPromiseCapabilityModule.f = newPromiseCapability = function (C) { + return C === $Promise || C === Wrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; +} + +$export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise }); +require('./_set-to-string-tag')($Promise, PROMISE); +require('./_set-species')(PROMISE); +Wrapper = require('./_core')[PROMISE]; + +// statics +$export($export.S + $export.F * !USE_NATIVE, PROMISE, { + // 25.4.4.5 Promise.reject(r) + reject: function reject(r) { + var capability = newPromiseCapability(this); + var $$reject = capability.reject; + $$reject(r); + return capability.promise; + } +}); +$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, { + // 25.4.4.6 Promise.resolve(x) + resolve: function resolve(x) { + return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x); + } +}); +$export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function (iter) { + $Promise.all(iter)['catch'](empty); +})), PROMISE, { + // 25.4.4.1 Promise.all(iterable) + all: function all(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var values = []; + var index = 0; + var remaining = 1; + forOf(iterable, false, function (promise) { + var $index = index++; + var alreadyCalled = false; + values.push(undefined); + remaining++; + C.resolve(promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[$index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.e) reject(result.v); + return capability.promise; + }, + // 25.4.4.4 Promise.race(iterable) + race: function race(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var reject = capability.reject; + var result = perform(function () { + forOf(iterable, false, function (promise) { + C.resolve(promise).then(capability.resolve, reject); + }); + }); + if (result.e) reject(result.v); + return capability.promise; + } +}); + +},{"./_a-function":88,"./_an-instance":90,"./_classof":93,"./_core":95,"./_ctx":96,"./_export":102,"./_for-of":104,"./_global":105,"./_is-object":114,"./_iter-detect":118,"./_library":121,"./_microtask":123,"./_new-promise-capability":124,"./_perform":138,"./_promise-resolve":139,"./_redefine-all":141,"./_set-species":144,"./_set-to-string-tag":145,"./_species-constructor":148,"./_task":150,"./_wks":160}],173:[function(require,module,exports){ +'use strict'; +var $at = require('./_string-at')(true); + +// 21.1.3.27 String.prototype[@@iterator]() +require('./_iter-define')(String, 'String', function (iterated) { + this._t = String(iterated); // target + this._i = 0; // next index +// 21.1.5.2.1 %StringIteratorPrototype%.next() +}, function () { + var O = this._t; + var index = this._i; + var point; + if (index >= O.length) return { value: undefined, done: true }; + point = $at(O, index); + this._i += point.length; + return { value: point, done: false }; +}); + +},{"./_iter-define":117,"./_string-at":149}],174:[function(require,module,exports){ +'use strict'; +// ECMAScript 6 symbols shim +var global = require('./_global'); +var has = require('./_has'); +var DESCRIPTORS = require('./_descriptors'); +var $export = require('./_export'); +var redefine = require('./_redefine'); +var META = require('./_meta').KEY; +var $fails = require('./_fails'); +var shared = require('./_shared'); +var setToStringTag = require('./_set-to-string-tag'); +var uid = require('./_uid'); +var wks = require('./_wks'); +var wksExt = require('./_wks-ext'); +var wksDefine = require('./_wks-define'); +var enumKeys = require('./_enum-keys'); +var isArray = require('./_is-array'); +var anObject = require('./_an-object'); +var isObject = require('./_is-object'); +var toIObject = require('./_to-iobject'); +var toPrimitive = require('./_to-primitive'); +var createDesc = require('./_property-desc'); +var _create = require('./_object-create'); +var gOPNExt = require('./_object-gopn-ext'); +var $GOPD = require('./_object-gopd'); +var $DP = require('./_object-dp'); +var $keys = require('./_object-keys'); +var gOPD = $GOPD.f; +var dP = $DP.f; +var gOPN = gOPNExt.f; +var $Symbol = global.Symbol; +var $JSON = global.JSON; +var _stringify = $JSON && $JSON.stringify; +var PROTOTYPE = 'prototype'; +var HIDDEN = wks('_hidden'); +var TO_PRIMITIVE = wks('toPrimitive'); +var isEnum = {}.propertyIsEnumerable; +var SymbolRegistry = shared('symbol-registry'); +var AllSymbols = shared('symbols'); +var OPSymbols = shared('op-symbols'); +var ObjectProto = Object[PROTOTYPE]; +var USE_NATIVE = typeof $Symbol == 'function'; +var QObject = global.QObject; +// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173 +var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild; + +// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687 +var setSymbolDesc = DESCRIPTORS && $fails(function () { + return _create(dP({}, 'a', { + get: function () { return dP(this, 'a', { value: 7 }).a; } + })).a != 7; +}) ? function (it, key, D) { + var protoDesc = gOPD(ObjectProto, key); + if (protoDesc) delete ObjectProto[key]; + dP(it, key, D); + if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc); +} : dP; + +var wrap = function (tag) { + var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]); + sym._k = tag; + return sym; +}; + +var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + return it instanceof $Symbol; +}; + +var $defineProperty = function defineProperty(it, key, D) { + if (it === ObjectProto) $defineProperty(OPSymbols, key, D); + anObject(it); + key = toPrimitive(key, true); + anObject(D); + if (has(AllSymbols, key)) { + if (!D.enumerable) { + if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {})); + it[HIDDEN][key] = true; + } else { + if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false; + D = _create(D, { enumerable: createDesc(0, false) }); + } return setSymbolDesc(it, key, D); + } return dP(it, key, D); +}; +var $defineProperties = function defineProperties(it, P) { + anObject(it); + var keys = enumKeys(P = toIObject(P)); + var i = 0; + var l = keys.length; + var key; + while (l > i) $defineProperty(it, key = keys[i++], P[key]); + return it; +}; +var $create = function create(it, P) { + return P === undefined ? _create(it) : $defineProperties(_create(it), P); +}; +var $propertyIsEnumerable = function propertyIsEnumerable(key) { + var E = isEnum.call(this, key = toPrimitive(key, true)); + if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false; + return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true; +}; +var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) { + it = toIObject(it); + key = toPrimitive(key, true); + if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return; + var D = gOPD(it, key); + if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true; + return D; +}; +var $getOwnPropertyNames = function getOwnPropertyNames(it) { + var names = gOPN(toIObject(it)); + var result = []; + var i = 0; + var key; + while (names.length > i) { + if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key); + } return result; +}; +var $getOwnPropertySymbols = function getOwnPropertySymbols(it) { + var IS_OP = it === ObjectProto; + var names = gOPN(IS_OP ? OPSymbols : toIObject(it)); + var result = []; + var i = 0; + var key; + while (names.length > i) { + if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]); + } return result; +}; + +// 19.4.1.1 Symbol([description]) +if (!USE_NATIVE) { + $Symbol = function Symbol() { + if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!'); + var tag = uid(arguments.length > 0 ? arguments[0] : undefined); + var $set = function (value) { + if (this === ObjectProto) $set.call(OPSymbols, value); + if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false; + setSymbolDesc(this, tag, createDesc(1, value)); + }; + if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set }); + return wrap(tag); + }; + redefine($Symbol[PROTOTYPE], 'toString', function toString() { + return this._k; + }); + + $GOPD.f = $getOwnPropertyDescriptor; + $DP.f = $defineProperty; + require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames; + require('./_object-pie').f = $propertyIsEnumerable; + require('./_object-gops').f = $getOwnPropertySymbols; + + if (DESCRIPTORS && !require('./_library')) { + redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true); + } + + wksExt.f = function (name) { + return wrap(wks(name)); + }; +} + +$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol }); + +for (var es6Symbols = ( + // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14 + 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables' +).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]); + +for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]); + +$export($export.S + $export.F * !USE_NATIVE, 'Symbol', { + // 19.4.2.1 Symbol.for(key) + 'for': function (key) { + return has(SymbolRegistry, key += '') + ? SymbolRegistry[key] + : SymbolRegistry[key] = $Symbol(key); + }, + // 19.4.2.5 Symbol.keyFor(sym) + keyFor: function keyFor(sym) { + if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!'); + for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key; + }, + useSetter: function () { setter = true; }, + useSimple: function () { setter = false; } +}); + +$export($export.S + $export.F * !USE_NATIVE, 'Object', { + // 19.1.2.2 Object.create(O [, Properties]) + create: $create, + // 19.1.2.4 Object.defineProperty(O, P, Attributes) + defineProperty: $defineProperty, + // 19.1.2.3 Object.defineProperties(O, Properties) + defineProperties: $defineProperties, + // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P) + getOwnPropertyDescriptor: $getOwnPropertyDescriptor, + // 19.1.2.7 Object.getOwnPropertyNames(O) + getOwnPropertyNames: $getOwnPropertyNames, + // 19.1.2.8 Object.getOwnPropertySymbols(O) + getOwnPropertySymbols: $getOwnPropertySymbols +}); + +// 24.3.2 JSON.stringify(value [, replacer [, space]]) +$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () { + var S = $Symbol(); + // MS Edge converts symbol values to JSON as {} + // WebKit converts symbol values to JSON as null + // V8 throws on boxed symbols + return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}'; +})), 'JSON', { + stringify: function stringify(it) { + var args = [it]; + var i = 1; + var replacer, $replacer; + while (arguments.length > i) args.push(arguments[i++]); + $replacer = replacer = args[1]; + if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined + if (!isArray(replacer)) replacer = function (key, value) { + if ($replacer) value = $replacer.call(this, key, value); + if (!isSymbol(value)) return value; + }; + args[1] = replacer; + return _stringify.apply($JSON, args); + } +}); + +// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint) +$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf); +// 19.4.3.5 Symbol.prototype[@@toStringTag] +setToStringTag($Symbol, 'Symbol'); +// 20.2.1.9 Math[@@toStringTag] +setToStringTag(Math, 'Math', true); +// 24.3.3 JSON[@@toStringTag] +setToStringTag(global.JSON, 'JSON', true); + +},{"./_an-object":91,"./_descriptors":98,"./_enum-keys":101,"./_export":102,"./_fails":103,"./_global":105,"./_has":106,"./_hide":107,"./_is-array":113,"./_is-object":114,"./_library":121,"./_meta":122,"./_object-create":126,"./_object-dp":127,"./_object-gopd":129,"./_object-gopn":131,"./_object-gopn-ext":130,"./_object-gops":132,"./_object-keys":135,"./_object-pie":136,"./_property-desc":140,"./_redefine":142,"./_set-to-string-tag":145,"./_shared":147,"./_to-iobject":153,"./_to-primitive":156,"./_uid":157,"./_wks":160,"./_wks-define":158,"./_wks-ext":159}],175:[function(require,module,exports){ +// https://github.com/tc39/proposal-promise-finally +'use strict'; +var $export = require('./_export'); +var core = require('./_core'); +var global = require('./_global'); +var speciesConstructor = require('./_species-constructor'); +var promiseResolve = require('./_promise-resolve'); + +$export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) { + var C = speciesConstructor(this, core.Promise || global.Promise); + var isFunction = typeof onFinally == 'function'; + return this.then( + isFunction ? function (x) { + return promiseResolve(C, onFinally()).then(function () { return x; }); + } : onFinally, + isFunction ? function (e) { + return promiseResolve(C, onFinally()).then(function () { throw e; }); + } : onFinally + ); +} }); + +},{"./_core":95,"./_export":102,"./_global":105,"./_promise-resolve":139,"./_species-constructor":148}],176:[function(require,module,exports){ +'use strict'; +// https://github.com/tc39/proposal-promise-try +var $export = require('./_export'); +var newPromiseCapability = require('./_new-promise-capability'); +var perform = require('./_perform'); + +$export($export.S, 'Promise', { 'try': function (callbackfn) { + var promiseCapability = newPromiseCapability.f(this); + var result = perform(callbackfn); + (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v); + return promiseCapability.promise; +} }); + +},{"./_export":102,"./_new-promise-capability":124,"./_perform":138}],177:[function(require,module,exports){ +require('./_wks-define')('asyncIterator'); + +},{"./_wks-define":158}],178:[function(require,module,exports){ +require('./_wks-define')('observable'); + +},{"./_wks-define":158}],179:[function(require,module,exports){ +require('./es6.array.iterator'); +var global = require('./_global'); +var hide = require('./_hide'); +var Iterators = require('./_iterators'); +var TO_STRING_TAG = require('./_wks')('toStringTag'); + +var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' + + 'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' + + 'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' + + 'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' + + 'TextTrackList,TouchList').split(','); + +for (var i = 0; i < DOMIterables.length; i++) { + var NAME = DOMIterables[i]; + var Collection = global[NAME]; + var proto = Collection && Collection.prototype; + if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME); + Iterators[NAME] = Iterators.Array; +} + +},{"./_global":105,"./_hide":107,"./_iterators":120,"./_wks":160,"./es6.array.iterator":162}]},{},[53]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","../../client/index.js","../../client/sink/BarChartDisplay.js","../../client/sink/BaseDisplay.js","../../client/sink/BpfDisplay.js","../../client/sink/MarkerDisplay.js","../../client/sink/SignalDisplay.js","../../client/sink/SocketSend.js","../../client/sink/SpectrumDisplay.js","../../client/sink/TraceDisplay.js","../../client/sink/VuMeterDisplay.js","../../client/sink/WaveformDisplay.js","../../client/sink/_namespace.js","../../client/source/AudioInBuffer.js","../../client/source/AudioInNode.js","../../client/source/SocketReceive.js","../../client/source/_namespace.js","../../client/utils/DisplaySync.js","../../client/utils/_namespace.js","../../client/utils/display-utils.js","../../common/operator/Biquad.js","../../common/operator/Clip.js","../../common/operator/Dct.js","../../common/operator/Delta.js","../../common/operator/Fft.js","../../common/operator/Magnitude.js","../../common/operator/MeanStddev.js","../../common/operator/Mel.js","../../common/operator/Merger.js","../../common/operator/Mfcc.js","../../common/operator/MinMax.js","../../common/operator/MovingAverage.js","../../common/operator/MovingMedian.js","../../common/operator/Multiplier.js","../../common/operator/OnOff.js","../../common/operator/Power.js","../../common/operator/Rms.js","../../common/operator/Scale.js","../../common/operator/Segmenter.js","../../common/operator/Select.js","../../common/operator/Slicer.js","../../common/operator/Yin.js","../../common/operator/_namespace.js","../../common/sink/Bridge.js","../../common/sink/DataRecorder.js","../../common/sink/Logger.js","../../common/sink/SignalRecorder.js","../../common/source/EventIn.js","../../common/utils/windows.js","../../common/utils/wsUtils.js","../../core/BaseLfo.js","../../core/SourceMixin.js","../../core/index.js","dist/index.js","node_modules/process/browser.js","../../node_modules/@ircam/parameters/dist/paramTemplates.js","../../node_modules/@ircam/parameters/dist/parameters.js","../../node_modules/babel-runtime/core-js/json/stringify.js","../../node_modules/babel-runtime/core-js/math/log10.js","../../node_modules/babel-runtime/core-js/number/is-finite.js","../../node_modules/babel-runtime/core-js/object/assign.js","../../node_modules/babel-runtime/core-js/object/create.js","../../node_modules/babel-runtime/core-js/object/define-property.js","../../node_modules/babel-runtime/core-js/object/get-own-property-descriptor.js","../../node_modules/babel-runtime/core-js/object/get-prototype-of.js","../../node_modules/babel-runtime/core-js/object/set-prototype-of.js","../../node_modules/babel-runtime/core-js/promise.js","../../node_modules/babel-runtime/core-js/symbol.js","../../node_modules/babel-runtime/core-js/symbol/iterator.js","../../node_modules/babel-runtime/helpers/classCallCheck.js","../../node_modules/babel-runtime/helpers/createClass.js","../../node_modules/babel-runtime/helpers/defineProperty.js","../../node_modules/babel-runtime/helpers/get.js","../../node_modules/babel-runtime/helpers/inherits.js","../../node_modules/babel-runtime/helpers/possibleConstructorReturn.js","../../node_modules/babel-runtime/helpers/typeof.js","../../node_modules/core-js/library/fn/json/stringify.js","../../node_modules/core-js/library/fn/math/log10.js","../../node_modules/core-js/library/fn/number/is-finite.js","../../node_modules/core-js/library/fn/object/assign.js","../../node_modules/core-js/library/fn/object/create.js","../../node_modules/core-js/library/fn/object/define-property.js","../../node_modules/core-js/library/fn/object/get-own-property-descriptor.js","../../node_modules/core-js/library/fn/object/get-prototype-of.js","../../node_modules/core-js/library/fn/object/set-prototype-of.js","../../node_modules/core-js/library/fn/promise.js","../../node_modules/core-js/library/fn/symbol/index.js","../../node_modules/core-js/library/fn/symbol/iterator.js","../../node_modules/core-js/library/modules/_a-function.js","../../node_modules/core-js/library/modules/_add-to-unscopables.js","../../node_modules/core-js/library/modules/_an-instance.js","../../node_modules/core-js/library/modules/_an-object.js","../../node_modules/core-js/library/modules/_array-includes.js","../../node_modules/core-js/library/modules/_classof.js","../../node_modules/core-js/library/modules/_cof.js","../../node_modules/core-js/library/modules/_core.js","../../node_modules/core-js/library/modules/_ctx.js","../../node_modules/core-js/library/modules/_defined.js","../../node_modules/core-js/library/modules/_descriptors.js","../../node_modules/core-js/library/modules/_dom-create.js","../../node_modules/core-js/library/modules/_enum-bug-keys.js","../../node_modules/core-js/library/modules/_enum-keys.js","../../node_modules/core-js/library/modules/_export.js","../../node_modules/core-js/library/modules/_fails.js","../../node_modules/core-js/library/modules/_for-of.js","../../node_modules/core-js/library/modules/_global.js","../../node_modules/core-js/library/modules/_has.js","../../node_modules/core-js/library/modules/_hide.js","../../node_modules/core-js/library/modules/_html.js","../../node_modules/core-js/library/modules/_ie8-dom-define.js","../../node_modules/core-js/library/modules/_invoke.js","../../node_modules/core-js/library/modules/_iobject.js","../../node_modules/core-js/library/modules/_is-array-iter.js","../../node_modules/core-js/library/modules/_is-array.js","../../node_modules/core-js/library/modules/_is-object.js","../../node_modules/core-js/library/modules/_iter-call.js","../../node_modules/core-js/library/modules/_iter-create.js","../../node_modules/core-js/library/modules/_iter-define.js","../../node_modules/core-js/library/modules/_iter-detect.js","../../node_modules/core-js/library/modules/_iter-step.js","../../node_modules/core-js/library/modules/_iterators.js","../../node_modules/core-js/library/modules/_library.js","../../node_modules/core-js/library/modules/_meta.js","../../node_modules/core-js/library/modules/_microtask.js","../../node_modules/core-js/library/modules/_new-promise-capability.js","../../node_modules/core-js/library/modules/_object-assign.js","../../node_modules/core-js/library/modules/_object-create.js","../../node_modules/core-js/library/modules/_object-dp.js","../../node_modules/core-js/library/modules/_object-dps.js","../../node_modules/core-js/library/modules/_object-gopd.js","../../node_modules/core-js/library/modules/_object-gopn-ext.js","../../node_modules/core-js/library/modules/_object-gopn.js","../../node_modules/core-js/library/modules/_object-gops.js","../../node_modules/core-js/library/modules/_object-gpo.js","../../node_modules/core-js/library/modules/_object-keys-internal.js","../../node_modules/core-js/library/modules/_object-keys.js","../../node_modules/core-js/library/modules/_object-pie.js","../../node_modules/core-js/library/modules/_object-sap.js","../../node_modules/core-js/library/modules/_perform.js","../../node_modules/core-js/library/modules/_promise-resolve.js","../../node_modules/core-js/library/modules/_property-desc.js","../../node_modules/core-js/library/modules/_redefine-all.js","../../node_modules/core-js/library/modules/_redefine.js","../../node_modules/core-js/library/modules/_set-proto.js","../../node_modules/core-js/library/modules/_set-species.js","../../node_modules/core-js/library/modules/_set-to-string-tag.js","../../node_modules/core-js/library/modules/_shared-key.js","../../node_modules/core-js/library/modules/_shared.js","../../node_modules/core-js/library/modules/_species-constructor.js","../../node_modules/core-js/library/modules/_string-at.js","../../node_modules/core-js/library/modules/_task.js","../../node_modules/core-js/library/modules/_to-absolute-index.js","../../node_modules/core-js/library/modules/_to-integer.js","../../node_modules/core-js/library/modules/_to-iobject.js","../../node_modules/core-js/library/modules/_to-length.js","../../node_modules/core-js/library/modules/_to-object.js","../../node_modules/core-js/library/modules/_to-primitive.js","../../node_modules/core-js/library/modules/_uid.js","../../node_modules/core-js/library/modules/_wks-define.js","../../node_modules/core-js/library/modules/_wks-ext.js","../../node_modules/core-js/library/modules/_wks.js","../../node_modules/core-js/library/modules/core.get-iterator-method.js","../../node_modules/core-js/library/modules/es6.array.iterator.js","../../node_modules/core-js/library/modules/es6.math.log10.js","../../node_modules/core-js/library/modules/es6.number.is-finite.js","../../node_modules/core-js/library/modules/es6.object.assign.js","../../node_modules/core-js/library/modules/es6.object.create.js","../../node_modules/core-js/library/modules/es6.object.define-property.js","../../node_modules/core-js/library/modules/es6.object.get-own-property-descriptor.js","../../node_modules/core-js/library/modules/es6.object.get-prototype-of.js","../../node_modules/core-js/library/modules/es6.object.set-prototype-of.js","../../node_modules/core-js/library/modules/es6.object.to-string.js","../../node_modules/core-js/library/modules/es6.promise.js","../../node_modules/core-js/library/modules/es6.string.iterator.js","../../node_modules/core-js/library/modules/es6.symbol.js","../../node_modules/core-js/library/modules/es7.promise.finally.js","../../node_modules/core-js/library/modules/es7.promise.try.js","../../node_modules/core-js/library/modules/es7.symbol.async-iterator.js","../../node_modules/core-js/library/modules/es7.symbol.observable.js","../../node_modules/core-js/library/modules/web.dom.iterable.js"],"names":[],"mappings":"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W;AAH0B,CAAvB,CAAhB;;AAMA,IAAM,WAAW,IAAI,IAAI,IAAJ,CAAS,eAAb,CAA6B;AAC5C,UAAQ;AADoC,CAA7B,CAAjB;;AAIA,QAAQ,OAAR,CAAgB,QAAhB;AACA,QAAQ,KAAR;;AAEA,IAAM,OAAO,CAAC,CAAD,EAAI,GAAJ,EAAS,GAAT,EAAc,GAAd,EAAmB,GAAnB,CAAb;;AAEC,UAAS,YAAT,GAAwB;AACvB,OAAK,IAAI,IAAI,CAAb,EAAgB,IAAI,SAApB,EAA+B,GAA/B;AACE,SAAK,CAAL,IAAU,CAAC,KAAK,CAAL,IAAU,KAAX,IAAoB,CAA9B;AADF,GAGA,QAAQ,OAAR,CAAgB,IAAhB,EAAsB,IAAtB;;AAEA,aAAW,YAAX,EAAyB,KAAK,IAA9B;AACD,CAPA,GAAD;;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA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AAiB,MAAjB,EAAyB,WAAzB,CAAP;AACD;;AAED;;;;;;;AAOA,WAAW,UAAX,GAAwB,UAAS,QAAT,EAAmB,mBAAnB,EAAwC;AAC9D,2BAAe,QAAf,IAA2B,mBAA3B;AACD,CAFD;;kBAIe,U;;;ACnUf;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;;ACFA;AACA;AACA;;ACFA;AACA;AACA;;ACFA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;;ACFA;AACA;AACA;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;;ACJA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;;ACFA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;;ACHA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACbA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;;ACJA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;;ACHA;;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1OA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;;ACDA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(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);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.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})","export const version = '%version%';\n\nimport * as _core from '../core';\nexport const core = _core;\n\nexport { default as operator } from '../common/operator/_namespace';\nexport { default as utils } from './utils/_namespace';\nexport { default as source } from './source/_namespace';\nexport { default as sink } from './sink/_namespace';\n","import BaseDisplay from './BaseDisplay';\nimport Fft from '../../common/operator/Fft';\nimport { getColors } from '../utils/display-utils';\n\n\nconst definitions = {\n  scale: {\n    type: 'float',\n    default: 1,\n    metas: { kind: 'dynamic' },\n  },\n  colors: {\n    type: 'any',\n    default: getColors('bar-chart'),\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  },\n  min: {\n    type: 'float',\n    default: 0,\n    metas: { kind: 'dynamic' },\n  },\n  max: {\n    type: 'float',\n    default: 1,\n    metas: { kind: 'dynamic' },\n  }\n};\n\n\n/**\n * Display a bar chart from an incomming `vector` input.\n *\n * @memberof module:client.sink\n *\n * @param {Object} options - Override default parameters.\n * @param {String} [options.colors=null] - Colors of the bars.\n * @param {Number} [options.min=-80] - Minimum displayed value.\n * @param {Number} [options.max=6] - Maximum displayed value.\n * @param {Number} [options.width=300] - Width of the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.height=150] - Height of the canvas.\n *  _dynamic parameter_\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas. _constant parameter_\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw. _constant parameter_\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n * import * as lfo from 'waves-lfo/client';\n *\n * const frameSize = 5;\n * const dt = 0.02;\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameSize: frameSize,\n *   frameRate: 1 / dt,\n *   frameType: 'vector',\n * });\n *\n * const barChart = new lfo.sink.BarChartDisplay({\n *   canvas: '#bar-chart',\n * });\n *\n * eventIn.connect(barChart);\n * eventIn.start();\n *\n * const data = [0, 0.2, 0.4, 0.6, 0.8];\n *\n * (function generateData() {\n *   for (let i = 0; i < frameSize; i++)\n *     data[i] = (data[i] + 0.001) % 1;\n *\n *   eventIn.process(null, data);\n *\n *   setTimeout(generateData, dt * 1000);\n * }());\n */\nclass BarChartDisplay extends BaseDisplay {\n  constructor(options = {}) {\n    super(definitions, options, false);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processVector(frame) {\n    const frameSize = this.streamParams.frameSize;\n    const width = this.canvasWidth;\n    const height = this.canvasHeight;\n    const colors = this.params.get('colors');\n    const data = frame.data;\n\n    const barWidth = width / frameSize;\n    const ctx = this.ctx;\n\n    // error handling needs review...\n    let error = 0;\n\n    for (let i = 0; i < frameSize; i++) {\n      const x1Float = i * barWidth + error;\n      const x1Int = Math.round(x1Float);\n      const x2Float = x1Float + (barWidth - error);\n      const x2Int = Math.round(x2Float);\n\n      error = x2Int - x2Float;\n\n      if (x1Int !== x2Int) {\n        const width = x2Int - x1Int;\n        const y = this.getYPosition(data[i]);\n\n        ctx.fillStyle = colors[i % colors.length];\n        ctx.fillRect(x1Int, y, width, height - y);\n      } else {\n        error -= barWidth;\n      }\n    }\n  }\n}\n\nexport default BarChartDisplay;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst commonDefinitions = {\n  min: {\n    type: 'float',\n    default: -1,\n    metas: { kind: 'dynamic' },\n  },\n  max: {\n    type: 'float',\n    default: 1,\n    metas: { kind: 'dynamic' },\n  },\n  width: {\n    type: 'integer',\n    default: 300,\n    metas: { kind: 'dynamic' },\n  },\n  height: {\n    type: 'integer',\n    default: 150,\n    metas: { kind: 'dynamic' },\n  },\n  container: {\n    type: 'any',\n    default: null,\n    constant: true,\n  },\n  canvas: {\n    type: 'any',\n    default: null,\n    constant: true,\n  },\n};\n\nconst hasDurationDefinitions = {\n  duration: {\n    type: 'float',\n    min: 0,\n    max: +Infinity,\n    default: 1,\n    metas: { kind: 'dynamic' },\n  },\n  referenceTime: {\n    type: 'float',\n    default: 0,\n    constant: true,\n  },\n};\n\n/**\n * Base class to extend in order to create graphic sinks.\n *\n * <span class=\"warning\">_This class should be considered abstract and only\n * be used to be extended._</span>\n *\n * @todo - fix float rounding errors (produce decays in sync draws)\n *\n * @memberof module:client.sink\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.min=-1] - Minimum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.max=1] - Maximum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.width=300] - Width of the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.height=150] - Height of the canvas.\n *  _dynamic parameter_\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas. _constant parameter_\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw. _constant parameter_\n * @param {Number} [options.duration=1] - Duration (in seconds) represented in\n *  the canvas. This parameter only exists for operators that display several\n *  consecutive frames on the canvas. _dynamic parameter_\n * @param {Number} [options.referenceTime=null] - Optionnal reference time the\n *  display should considerer as the origin. Is only usefull when synchronizing\n *  several display using the `DisplaySync` class. This parameter only exists\n *  for operators that display several consecutive frames on the canvas.\n */\nclass BaseDisplay extends BaseLfo {\n  constructor(defs, options = {}, hasDuration = true) {\n    let commonDefs;\n\n    if (hasDuration)\n      commonDefs = Object.assign({}, commonDefinitions, hasDurationDefinitions);\n    else\n      commonDefs = commonDefinitions\n\n    const definitions = Object.assign({}, commonDefs, defs);\n\n    super(definitions, options);\n\n    if (this.params.get('canvas') === null && this.params.get('container') === null)\n      throw new Error('Invalid parameter: `canvas` or `container` not defined');\n\n    const canvasParam = this.params.get('canvas');\n    const containerParam = this.params.get('container');\n\n    // prepare canvas\n    if (canvasParam) {\n      if (typeof canvasParam === 'string')\n        this.canvas = document.querySelector(canvasParam);\n      else\n        this.canvas = canvasParam;\n    } else if (containerParam) {\n      let container;\n\n      if (typeof containerParam === 'string')\n        container = document.querySelector(containerParam);\n      else\n        container = containerParam;\n\n      this.canvas = document.createElement('canvas');\n      container.appendChild(this.canvas);\n    }\n\n    this.ctx = this.canvas.getContext('2d');\n    this.cachedCanvas = document.createElement('canvas');\n    this.cachedCtx = this.cachedCanvas.getContext('2d');\n\n    this.hasDuration = hasDuration;\n    this.previousFrame = null;\n    this.currentTime = hasDuration ? this.params.get('referenceTime') : null;\n\n    /**\n     * Instance of the `DisplaySync` used to synchronize the different displays\n     * @private\n     */\n    this.displaySync = false;\n\n    this._stack = [];\n    this._rafId = null;\n\n    this.renderStack = this.renderStack.bind(this);\n    this.shiftError = 0;\n\n    // initialize canvas size and y scale transfert function\n    this._resize();\n  }\n\n  /** @private */\n  _resize() {\n    const width = this.params.get('width');\n    const height = this.params.get('height');\n\n    const ctx = this.ctx;\n    const cachedCtx = this.cachedCtx;\n\n    const dPR = window.devicePixelRatio || 1;\n    const bPR = ctx.webkitBackingStorePixelRatio ||\n      ctx.mozBackingStorePixelRatio ||\n      ctx.msBackingStorePixelRatio ||\n      ctx.oBackingStorePixelRatio ||\n      ctx.backingStorePixelRatio || 1;\n\n    this.pixelRatio = dPR / bPR;\n\n    const lastWidth = this.canvasWidth;\n    const lastHeight = this.canvasHeight;\n    this.canvasWidth = width * this.pixelRatio;\n    this.canvasHeight = height * this.pixelRatio;\n\n    cachedCtx.canvas.width = this.canvasWidth;\n    cachedCtx.canvas.height = this.canvasHeight;\n\n    // copy current image from ctx (resize)\n    if (lastWidth && lastHeight) {\n      cachedCtx.drawImage(ctx.canvas,\n        0, 0, lastWidth, lastHeight,\n        0, 0, this.canvasWidth, this.canvasHeight\n      );\n    }\n\n    ctx.canvas.width = this.canvasWidth;\n    ctx.canvas.height = this.canvasHeight;\n    ctx.canvas.style.width = `${width}px`;\n    ctx.canvas.style.height = `${height}px`;\n\n    // update scale\n    this._setYScale();\n  }\n\n  /**\n   * Create the transfert function used to map values to pixel in the y axis\n   * @private\n   */\n  _setYScale() {\n    const min = this.params.get('min');\n    const max = this.params.get('max');\n    const height = this.canvasHeight;\n\n    const a = (0 - height) / (max - min);\n    const b = height - (a * min);\n\n    this.getYPosition = (x) => a * x + b;\n  }\n\n  /**\n   * Returns the width in pixel a `vector` frame needs to be drawn.\n   * @private\n   */\n  getMinimumFrameWidth() {\n    return 1; // need one pixel to draw the line\n  }\n\n  /**\n   * Callback function executed when a parameter is updated.\n   *\n   * @param {String} name - Parameter name.\n   * @param {Mixed} value - Parameter value.\n   * @param {Object} metas - Metadatas of the parameter.\n   * @private\n   */\n  onParamUpdate(name, value, metas) {\n    super.onParamUpdate(name, value, metas);\n\n    switch (name) {\n      case 'min':\n      case 'max':\n        // @todo - make sure that min and max are different\n        this._setYScale();\n        break;\n      case 'width':\n      case 'height':\n        this._resize();\n    }\n  }\n\n  /** @private */\n  propagateStreamParams() {\n    super.propagateStreamParams();\n  }\n\n  /** @private */\n  resetStream() {\n    super.resetStream();\n\n    const width = this.canvasWidth;\n    const height = this.canvasHeight;\n\n    this.previousFrame = null;\n    this.currentTime = this.hasDuration ? this.params.get('referenceTime') : null;\n\n    this.ctx.clearRect(0, 0, width, height);\n    this.cachedCtx.clearRect(0, 0, width, height);\n  }\n\n  /** @private */\n  finalizeStream(endTime) {\n    this.currentTime = null;\n    super.finalizeStream(endTime);\n\n    this._rafId = null;\n\n    // clear the stack if not empty\n    if (this._stack.length > 0)\n      this.renderStack();\n  }\n\n  /**\n   * Add the current frame to the frames to draw. Should not be overriden.\n   * @private\n   */\n  processFrame(frame) {\n    const frameSize = this.streamParams.frameSize;\n    const copy = new Float32Array(frameSize);\n    const data = frame.data;\n\n    // copy values of the input frame as they might be updated\n    // in reference before being consumed in the draw function\n    for (let i = 0; i < frameSize; i++)\n      copy[i] = data[i];\n\n    this._stack.push({\n      time: frame.time,\n      data: copy,\n      metadata: frame.metadata,\n    });\n\n    if (this._rafId === null)\n      this._rafId = window.requestAnimationFrame(this.renderStack);\n  }\n\n  /**\n   * Render the accumulated frames. Method called in `requestAnimationFrame`.\n   * @private\n   */\n  renderStack() {\n    if (this.params.has('duration')) {\n      // render all frame since last `renderStack` call\n      for (let i = 0, l = this._stack.length; i < l; i++)\n        this.scrollModeDraw(this._stack[i]);\n    } else {\n      // only render last received frame if any\n      if (this._stack.length > 0) {\n        const frame = this._stack[this._stack.length - 1];\n        this.ctx.clearRect(0, 0, this.canvasWidth, this.canvasHeight);\n        this.processFunction(frame);\n      }\n    }\n\n    this._stack.length = 0; // reinit stack for next call\n    this._rafId = null;\n  }\n\n  /**\n   * Draw data from right to left with scrolling\n   * @private\n   * @todo - check possibility of maintaining all values from one place to\n   *         minimize float error tracking.\n   */\n  scrollModeDraw(frame) {\n    const frameType = this.streamParams.frameType;\n    const frameRate = this.streamParams.frameRate;\n    const frameSize = this.streamParams.frameSize;\n    const sourceSampleRate = this.streamParams.sourceSampleRate;\n\n    const canvasDuration = this.params.get('duration');\n    const ctx = this.ctx;\n    const canvasWidth = this.canvasWidth;\n    const canvasHeight = this.canvasHeight;\n\n    const previousFrame = this.previousFrame;\n\n    // current time at the left of the canvas\n    const currentTime = (this.currentTime !== null) ? this.currentTime : frame.time;\n    const frameStartTime = frame.time;\n    const lastFrameTime = previousFrame ? previousFrame.time : 0;\n    const lastFrameDuration = this.lastFrameDuration ? this.lastFrameDuration : 0;\n\n    let frameDuration;\n\n    if (frameType === 'scalar' || frameType === 'vector') {\n      const pixelDuration = canvasDuration / canvasWidth;\n      frameDuration = this.getMinimumFrameWidth() * pixelDuration;\n    } else if (this.streamParams.frameType === 'signal') {\n      frameDuration = frameSize / sourceSampleRate;\n    }\n\n    const frameEndTime = frameStartTime + frameDuration;\n    // define if we need to shift the canvas\n    const shiftTime = frameEndTime - currentTime;\n\n    // if the canvas is not synced, should never go to `else`\n    if (shiftTime > 0) {\n      // shift the canvas of shiftTime in pixels\n      const fShift = (shiftTime / canvasDuration) * canvasWidth - this.shiftError;\n      const iShift = Math.floor(fShift + 0.5);\n      this.shiftError = fShift - iShift;\n\n      const currentTime = frameStartTime + frameDuration;\n      this.shiftCanvas(iShift, currentTime);\n\n      // if siblings, share the information\n      if (this.displaySync)\n        this.displaySync.shiftSiblings(iShift, currentTime, this);\n    }\n\n    // width of the frame in pixels\n    const floatFrameWidth = (frameDuration / canvasDuration) * canvasWidth;\n    const frameWidth = Math.floor(floatFrameWidth + 0.5);\n\n    // define position of the head in the canvas\n    const canvasStartTime = this.currentTime - canvasDuration;\n    const startTimeRatio = (frameStartTime - canvasStartTime) / canvasDuration;\n    const startTimePosition = startTimeRatio * canvasWidth;\n\n    // number of pixels since last frame\n    let pixelsSinceLastFrame = this.lastFrameWidth;\n\n    if ((frameType === 'scalar' || frameType === 'vector') && previousFrame) {\n      const frameInterval = frame.time - previousFrame.time;\n      pixelsSinceLastFrame = (frameInterval / canvasDuration) * canvasWidth;\n    }\n\n    // draw current frame\n    ctx.save();\n    ctx.translate(startTimePosition, 0);\n    this.processFunction(frame, frameWidth, pixelsSinceLastFrame);\n    ctx.restore();\n\n    // save current canvas state into cached canvas\n    this.cachedCtx.clearRect(0, 0, canvasWidth, canvasHeight);\n    this.cachedCtx.drawImage(this.canvas, 0, 0, canvasWidth, canvasHeight);\n\n    // update lastFrameDuration, lastFrameWidth\n    this.lastFrameDuration = frameDuration;\n    this.lastFrameWidth = frameWidth;\n    this.previousFrame = frame;\n  }\n\n  /**\n   * Shift canvas, also called from `DisplaySync`\n   * @private\n   */\n  shiftCanvas(iShift, time) {\n    const ctx = this.ctx;\n    const cache = this.cachedCanvas;\n    const cachedCtx = this.cachedCtx;\n    const width = this.canvasWidth;\n    const height = this.canvasHeight;\n    const croppedWidth = width - iShift;\n    this.currentTime = time;\n\n    ctx.clearRect(0, 0, width, height);\n    ctx.drawImage(cache, iShift, 0, croppedWidth, height, 0, 0, croppedWidth, height);\n    // save current canvas state into cached canvas\n    cachedCtx.clearRect(0, 0, width, height);\n    cachedCtx.drawImage(this.canvas, 0, 0, width, height);\n  }\n\n  // @todo - Fix trigger mode\n  // allow to witch easily between the 2 modes\n  // setTrigger(bool) {\n  //   this.params.trigger = bool;\n  //   // clear canvas and cache\n  //   this.ctx.clearRect(0, 0, this.params.width, this.params.height);\n  //   this.cachedCtx.clearRect(0, 0, this.params.width, this.params.height);\n  //   // reset _currentXPosition\n  //   this._currentXPosition = 0;\n  //   this.lastShiftError = 0;\n  // }\n\n  // /**\n  //  * Alternative drawing mode.\n  //  * Draw from left to right, go back to left when > width\n  //  */\n  // triggerModeDraw(time, frame) {\n  //   const width  = this.params.width;\n  //   const height = this.params.height;\n  //   const duration = this.params.duration;\n  //   const ctx = this.ctx;\n\n  //   const dt = time - this.previousTime;\n  //   const fShift = (dt / duration) * width - this.lastShiftError; // px\n  //   const iShift = Math.round(fShift);\n  //   this.lastShiftError = iShift - fShift;\n\n  //   this.currentXPosition += iShift;\n\n  //   // draw the right part\n  //   ctx.save();\n  //   ctx.translate(this.currentXPosition, 0);\n  //   ctx.clearRect(-iShift, 0, iShift, height);\n  //   this.drawCurve(frame, iShift);\n  //   ctx.restore();\n\n  //   // go back to the left of the canvas and redraw the same thing\n  //   if (this.currentXPosition > width) {\n  //     // go back to start\n  //     this.currentXPosition -= width;\n\n  //     ctx.save();\n  //     ctx.translate(this.currentXPosition, 0);\n  //     ctx.clearRect(-iShift, 0, iShift, height);\n  //     this.drawCurve(frame, this.previousFrame, iShift);\n  //     ctx.restore();\n  //   }\n  // }\n\n}\n\nexport default BaseDisplay;\n","import BaseDisplay from './BaseDisplay';\nimport { getColors } from '../utils/display-utils';\n\nconst definitions = {\n  radius: {\n    type: 'float',\n    min: 0,\n    default: 0,\n    metas: { kind: 'dynamic' }\n  },\n  line: {\n    type: 'boolean',\n    default: true,\n    metas: { kind: 'dynamic' },\n  },\n  colors: {\n    type: 'any',\n    default: null,\n  }\n}\n\n\n/**\n * Breakpoint Function, display a stream of type `vector`.\n *\n * @memberof module:client.sink\n *\n * @param {Object} options - Override default parameters.\n * @param {String} [options.colors=null] - Array of colors for each index of the\n *  vector. _dynamic parameter_\n * @param {String} [options.radius=0] - Radius of the dot at each value.\n *  _dynamic parameter_\n * @param {String} [options.line=true] - Display a line between each consecutive\n *  values of the vector. _dynamic parameter_\n * @param {Number} [options.min=-1] - Minimum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.max=1] - Maximum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.width=300] - Width of the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.height=150] - Height of the canvas.\n *  _dynamic parameter_\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas. _constant parameter_\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw. _constant parameter_\n * @param {Number} [options.duration=1] - Duration (in seconds) represented in\n *  the canvas. _dynamic parameter_\n * @param {Number} [options.referenceTime=null] - Optionnal reference time the\n *  display should considerer as the origin. Is only usefull when synchronizing\n *  several display using the `DisplaySync` class.\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameSize: 2,\n *   frameRate: 0.1,\n *   frameType: 'vector'\n * });\n *\n * const bpf = new lfo.sink.BpfDisplay({\n *   canvas: '#bpf',\n *   duration: 10,\n * });\n *\n * eventIn.connect(bpf);\n * eventIn.start();\n *\n * let time = 0;\n * const dt = 0.1;\n *\n * (function generateData() {\n *   eventIn.process(time, [Math.random() * 2 - 1, Math.random() * 2 - 1]);\n *   time += dt;\n *\n *   setTimeout(generateData, dt * 1000);\n * }());\n */\nclass BpfDisplay extends BaseDisplay {\n  constructor(options) {\n    super(definitions, options);\n\n    this.prevFrame = null;\n  }\n\n  /** @private */\n  getMinimumFrameWidth() {\n    return this.params.get('radius');\n  }\n\n  resetStream() {\n    super.resetStream();\n\n    this.prevFrame = null;\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    if (this.params.get('colors') === null)\n      this.params.set('colors', getColors('bpf', this.streamParams.frameSize));\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processVector(frame, frameWidth, pixelsSinceLastFrame) {\n    const colors = this.params.get('colors');\n    const radius = this.params.get('radius');\n    const drawLine = this.params.get('line');\n    const frameSize = this.streamParams.frameSize;\n    const ctx = this.ctx;\n    const data = frame.data;\n    const prevData = this.prevFrame ? this.prevFrame.data : null;\n\n    ctx.save();\n\n    for (let i = 0, l = frameSize; i < l; i++) {\n      const posY = this.getYPosition(data[i]);\n      const color = colors[i];\n\n      ctx.strokeStyle = color;\n      ctx.fillStyle = color;\n\n      if (prevData && drawLine) {\n        const lastPosY = this.getYPosition(prevData[i]);\n        ctx.beginPath();\n        ctx.moveTo(-pixelsSinceLastFrame, lastPosY);\n        ctx.lineTo(0, posY);\n        ctx.stroke();\n        ctx.closePath();\n      }\n\n      if (radius > 0) {\n        ctx.beginPath();\n        ctx.arc(0, posY, radius, 0, Math.PI * 2, false);\n        ctx.fill();\n        ctx.closePath();\n      }\n\n    }\n\n    ctx.restore();\n\n    this.prevFrame = frame;\n  }\n}\n\nexport default BpfDisplay;\n","import BaseDisplay from './BaseDisplay';\nimport { getColors } from '../utils/display-utils';\n\nconst definitions = {\n  threshold: {\n    type: 'float',\n    default: null,\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  },\n  thresholdIndex: {\n    type: 'integer',\n    default: 0,\n    metas: { kind: 'dynamic' },\n  },\n  color: {\n    type: 'string',\n    default: getColors('marker'),\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  }\n};\n\n/**\n * Display a marker according to a `vector` input frame.\n *\n * @memberof module:client.sink\n *\n * @param {Object} options - Override default parameters.\n * @param {String} options.color - Color of the marker.\n * @param {Number} [options.thresholdIndex=0] - Index of the incomming frame\n *  data to compare against the threshold. _Should be used in conjonction with\n *  `threshold`_.\n * @param {Number} [options.threshold=null] - Minimum value the incomming value\n *  must have to trigger the display of a marker. If null each incomming event\n *  triggers a marker. _Should be used in conjonction with `thresholdIndex`_.\n * @param {Number} [options.width=300] - Width of the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.height=150] - Height of the canvas.\n *  _dynamic parameter_\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas. _constant parameter_\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw. _constant parameter_\n * @param {Number} [options.duration=1] - Duration (in seconds) represented in\n *  the canvas. This parameter only exists for operators that display several\n *  consecutive frames on the canvas. _dynamic parameter_\n * @param {Number} [options.referenceTime=null] - Optionnal reference time the\n *  display should considerer as the origin. Is only usefull when synchronizing\n *  several display using the `DisplaySync` class. This parameter only exists\n *  for operators that display several consecutive frames on the canvas.\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameType: 'scalar',\n * });\n *\n * const marker = new lfo.sink.MarkerDisplay({\n *   canvas: '#marker',\n *   threshold: 0.5,\n * });\n *\n * eventIn.connect(marker);\n * eventIn.start();\n *\n * let time = 0;\n * const period = 1;\n *\n * (function generateData() {\n *   eventIn.process(time, Math.random());\n *\n *   time += period;\n *   setTimeout(generateData, period * 1000);\n * }());\n */\nclass MarkerDisplay extends BaseDisplay {\n  constructor(options = {}) {\n    super(definitions, options);\n  }\n\n  /** @private */\n  processVector(frame, frameWidth, pixelsSinceLastFrame) {\n    const color = this.params.get('color');\n    const threshold = this.params.get('threshold');\n    const thresholdIndex = this.params.get('thresholdIndex');\n    const ctx = this.ctx;\n    const height = ctx.height;\n    const value = frame.data[thresholdIndex];\n\n    if (threshold === null || value >= threshold) {\n      let yMin = this.getYPosition(this.params.get('min'));\n      let yMax = this.getYPosition(this.params.get('max'));\n\n      if (yMin > yMax) {\n        const v = yMax;\n        yMax = yMin;\n        yMin = v;\n      }\n\n      ctx.save();\n      ctx.fillStyle = color;\n      ctx.fillRect(0, yMin, 1, yMax);\n      ctx.restore();\n    }\n  }\n}\n\nexport default MarkerDisplay;\n","import BaseDisplay from './BaseDisplay';\nimport { getColors } from '../utils/display-utils';\n\nconst floor = Math.floor;\nconst ceil = Math.ceil;\n\nfunction downSample(data, targetLength) {\n  const length = data.length;\n  const hop = length / targetLength;\n  const target = new Float32Array(targetLength);\n  let counter = 0;\n\n  for (let i = 0; i < targetLength; i++) {\n    const index = floor(counter);\n    const phase = counter - index;\n    const prev = data[index];\n    const next = data[index + 1];\n\n    target[i] = (next - prev) * phase + prev;\n    counter += hop;\n  }\n\n  return target;\n}\n\nconst definitions = {\n  color: {\n    type: 'string',\n    default: getColors('signal'),\n    nullable: true,\n  },\n};\n\n/**\n * Display a stream of type `signal` on a canvas.\n *\n * @param {Object} options - Override default parameters.\n * @param {String} [options.color='#00e600'] - Color of the signal.\n * @param {Number} [options.min=-1] - Minimum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.max=1] - Maximum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.width=300] - Width of the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.height=150] - Height of the canvas.\n *  _dynamic parameter_\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas. _constant parameter_\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw. _constant parameter_\n * @param {Number} [options.duration=1] - Duration (in seconds) represented in\n *  the canvas. This parameter only exists for operators that display several\n *  consecutive frames on the canvas. _dynamic parameter_\n * @param {Number} [options.referenceTime=null] - Optionnal reference time the\n *  display should considerer as the origin. Is only usefull when synchronizing\n *  several display using the `DisplaySync` class. This parameter only exists\n *  for operators that display several consecutive frames on the canvas.\n *\n * @memberof module:client.sink\n *\n * @example\n * const eventIn = new lfo.source.EventIn({\n *   frameType: 'signal',\n *   sampleRate: 8,\n *   frameSize: 4,\n * });\n *\n * const signalDisplay = new lfo.sink.SignalDisplay({\n *   canvas: '#signal-canvas',\n * });\n *\n * eventIn.connect(signalDisplay);\n * eventIn.start();\n *\n * // push triangle signal in the graph\n * eventIn.process(0, [0, 0.5, 1, 0.5]);\n * eventIn.process(0.5, [0, -0.5, -1, -0.5]);\n * // ...\n */\nclass SignalDisplay extends BaseDisplay {\n  constructor(options) {\n    super(definitions, options, true);\n\n    this.lastPosY = null;\n  }\n\n  /** @private */\n  processSignal(frame, frameWidth, pixelsSinceLastFrame) {\n    const color = this.params.get('color');\n    const frameSize = this.streamParams.frameSize;\n    const ctx = this.ctx;\n    let data = frame.data;\n\n    if (frameWidth < frameSize)\n      data = downSample(data, frameWidth);\n\n    const length = data.length;\n    const hopX = frameWidth / length;\n    let posX = 0;\n    let lastY = this.lastPosY;\n\n    ctx.strokeStyle = color;\n    ctx.beginPath();\n\n    for (let i = 0; i < data.length; i++) {\n      const posY = this.getYPosition(data[i]);\n\n      if (lastY === null) {\n        ctx.moveTo(posX, posY);\n      } else {\n        if (i === 0)\n          ctx.moveTo(-hopX, lastY);\n\n        ctx.lineTo(posX, posY);\n      }\n\n      posX += hopX;\n      lastY = posY;\n    }\n\n    ctx.stroke();\n    ctx.closePath();\n\n    this.lastPosY = lastY;\n  }\n}\n\nexport default SignalDisplay;\n","import BaseLfo from '../../core/BaseLfo';\nimport { opcodes, encoders, decoders } from '../../common/utils/wsUtils';\n\nconst parameters = {\n  port: {\n    type: 'integer',\n    default: 8000,\n    nullable: true,\n    constant: true,\n  },\n  url: {\n    type: 'string',\n    default: null,\n    nullable: true,\n    constant: true,\n  }\n}\n\n/**\n * Send an lfo frame as a socket message to a `node.source.SocketReceive`\n * instance.\n *\n * <p class=\"warning\">Experimental</p>\n *\n * @memberof module:client.sink\n *\n * @example\n * const eventIn = new lfo.source.EventIn({\n *   frameType: 'vector',\n *   frameSize: 2,\n *   frameRate: 1,\n * });\n *\n * const socketSend = new lfo.sink.SocketSend({\n *   port: 3000\n * });\n *\n * eventIn.connect(socketSend);\n *\n * eventIn.init().then(() => {\n *   eventIn.start();\n *\n *   let time = 0;\n *\n *   (function createFrame() {\n *     eventIn.process(time, [Math.random(), Math.random()], { test: true });\n *     time += 1;\n *\n *     setTimeout(createFrame, 1000);\n *   }());\n * });\n */\nclass SocketSend extends BaseLfo {\n  constructor(options = {}) {\n    super(parameters, options);\n\n    const protocol = window.location.protocol.replace(/^http/, 'ws');\n    const address = this.params.get('url') || window.location.hostname;\n    const port = this.params.get('port') || ''; // everything falsy becomes ''\n    const socketAddress = `${protocol}//${address}:${port}`;\n\n    this.socket = new WebSocket(socketAddress);\n    this.socket.binaryType = 'arraybuffer';\n\n    this.openedPromise = new Promise((resolve, reject) => {\n      this.socket.onopen = resolve;\n    });\n\n    this.socket.onerror = (err) => console.error(err.stack);\n  }\n\n  initModule() {\n    // send a INIT_MODULE_REQ and wait for INIT_MODULE_ACK\n    // no need to get children promises as we are in a leef\n    return this.openedPromise.then(() => {\n      return new Promise((resolve, reject) => {\n        this.socket.onmessage = (e) => {\n          const opcode = decoders.opcode(e.data);\n\n          if (opcode === opcodes.INIT_MODULE_ACK)\n            resolve();\n        }\n\n        const buffer = encoders.initModuleReq();\n        this.socket.send(buffer);\n      });\n    });\n  }\n\n  processStreamParams(prevStreamParams) {\n    super.processStreamParams(prevStreamParams);\n\n    const buffer = encoders.streamParams(this.streamParams);\n    this.socket.send(buffer);\n  }\n\n  resetStream() {\n    super.resetStream();\n\n    const buffer = encoders.resetStream();\n    this.socket.send(buffer);\n  }\n\n    /** @private */\n  finalizeStream(endTime) {\n    super.finalizeStream(endTime);\n\n    const buffer = encoders.finalizeStream(endTime);\n    this.socket.send(buffer);\n  }\n\n  // process any type\n  /** @private */\n  processScalar() {}\n  /** @private */\n  processVector() {}\n  /** @private */\n  processSignal() {}\n\n  processFrame(frame) {\n    const frameSize = this.streamParams.frameSize;\n    this.frame.time = frame.time;\n    this.frame.data.set(frame.data, 0);\n    this.frame.metadata = frame.metadata;\n\n    const buffer = encoders.processFrame(this.frame, frameSize);\n    this.socket.send(buffer);\n  }\n}\n\nexport default SocketSend;\n","import BaseDisplay from './BaseDisplay';\nimport Fft from '../../common/operator/Fft';\nimport { getColors } from '../utils/display-utils';\n\n\nconst definitions = {\n  scale: {\n    type: 'float',\n    default: 1,\n    metas: { kind: 'dynamic' },\n  },\n  color: {\n    type: 'string',\n    default: getColors('spectrum'),\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  },\n  min: {\n    type: 'float',\n    default: -80,\n    metas: { kind: 'dynamic' },\n  },\n  max: {\n    type: 'float',\n    default: 6,\n    metas: { kind: 'dynamic' },\n  }\n};\n\n\n/**\n * Display the spectrum of the incomming `signal` input.\n *\n * @memberof module:client.sink\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.scale=1] - Scale display of the spectrogram.\n * @param {String} [options.color=null] - Color of the spectrogram.\n * @param {Number} [options.min=-80] - Minimum displayed value (in dB).\n * @param {Number} [options.max=6] - Maximum displayed value (in dB).\n * @param {Number} [options.width=300] - Width of the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.height=150] - Height of the canvas.\n *  _dynamic parameter_\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas. _constant parameter_\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw. _constant parameter_\n *\n * @todo - expose more `fft` config options\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const audioContext = new AudioContext();\n *\n * navigator.mediaDevices\n *   .getUserMedia({ audio: true })\n *   .then(init)\n *   .catch((err) => console.error(err.stack));\n *\n * function init(stream) {\n *   const source = audioContext.createMediaStreamSource(stream);\n *\n *   const audioInNode = new lfo.source.AudioInNode({\n *     audioContext: audioContext,\n *     sourceNode: source,\n *   });\n *\n *   const spectrum = new lfo.sink.SpectrumDisplay({\n *     canvas: '#spectrum',\n *   });\n *\n *   audioInNode.connect(spectrum);\n *   audioInNode.start();\n * }\n */\nclass SpectrumDisplay extends BaseDisplay {\n  constructor(options = {}) {\n    super(definitions, options, false);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this.fft = new Fft({\n      size: this.streamParams.frameSize,\n      window: 'hann',\n      norm: 'linear',\n    });\n\n    this.fft.initStream(this.streamParams);\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processSignal(frame) {\n    const bins = this.fft.inputSignal(frame.data);\n    const nbrBins = bins.length;\n\n    const width = this.canvasWidth;\n    const height = this.canvasHeight;\n    const scale = this.params.get('scale');\n\n    const binWidth = width / nbrBins;\n    const ctx = this.ctx;\n\n    ctx.fillStyle = this.params.get('color');\n\n    // error handling needs review...\n    let error = 0;\n\n    for (let i = 0; i < nbrBins; i++) {\n      const x1Float = i * binWidth + error;\n      const x1Int = Math.round(x1Float);\n      const x2Float = x1Float + (binWidth - error);\n      const x2Int = Math.round(x2Float);\n\n      error = x2Int - x2Float;\n\n      if (x1Int !== x2Int) {\n        const width = x2Int - x1Int;\n        const db = 20 * Math.log10(bins[i]);\n        const y = this.getYPosition(db * scale);\n        ctx.fillRect(x1Int, y, width, height - y);\n      } else {\n        error -= binWidth;\n      }\n    }\n  }\n}\n\nexport default SpectrumDisplay;\n","import BaseDisplay from './BaseDisplay';\nimport { getColors, getHue, hexToRGB } from '../utils/display-utils';\n\n\nconst definitions = {\n  color: {\n    type: 'string',\n    default: getColors('trace'),\n    metas: { kind: 'dynamic' },\n  },\n  colorScheme: {\n    type: 'enum',\n    default: 'none',\n    list: ['none', 'hue', 'opacity'],\n  },\n};\n\n/**\n * Display a range value around a mean value (for example mean\n * and standart deviation).\n *\n * This sink can handle input of type `vector` of frameSize >= 2.\n *\n * @param {Object} options - Override default parameters.\n * @param {String} [options.color='orange'] - Color.\n * @param {String} [options.colorScheme='none'] - If a third value is available\n *  in the input, can be used to control the opacity or the hue. If input frame\n *  size is 2, this param is automatically set to `none`\n * @param {Number} [options.min=-1] - Minimum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.max=1] - Maximum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.width=300] - Width of the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.height=150] - Height of the canvas.\n *  _dynamic parameter_\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas. _constant parameter_\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw. _constant parameter_\n * @param {Number} [options.duration=1] - Duration (in seconds) represented in\n *  the canvas. _dynamic parameter_\n * @param {Number} [options.referenceTime=null] - Optionnal reference time the\n *  display should considerer as the origin. Is only usefull when synchronizing\n *  several display using the `DisplaySync` class.\n *\n * @memberof module:client.sink\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const AudioContext = (window.AudioContext || window.webkitAudioContext);\n * const audioContext = new AudioContext();\n *\n * navigator.mediaDevices\n *   .getUserMedia({ audio: true })\n *   .then(init)\n *   .catch((err) => console.error(err.stack));\n *\n * function init(stream) {\n *   const source = audioContext.createMediaStreamSource(stream);\n *\n *   const audioInNode = new lfo.source.AudioInNode({\n *     sourceNode: source,\n *     audioContext: audioContext,\n *   });\n *\n *   // not sure it make sens but...\n *   const meanStddev = new lfo.operator.MeanStddev();\n *\n *   const traceDisplay = new lfo.sink.TraceDisplay({\n *     canvas: '#trace',\n *   });\n *\n *   const logger = new lfo.sink.Logger({ data: true });\n *\n *   audioInNode.connect(meanStddev);\n *   meanStddev.connect(traceDisplay);\n *\n *   audioInNode.start();\n * }\n */\nclass TraceDisplay extends BaseDisplay {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    this.prevFrame = null;\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    if (this.streamParams.frameSize === 2)\n      this.params.set('colorScheme', 'none');\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processVector(frame, frameWidth, pixelsSinceLastFrame) {\n    const colorScheme = this.params.get('colorScheme');\n    const ctx = this.ctx;\n    const prevData = this.prevFrame ? this.prevFrame.data : null;\n    const data = frame.data;\n\n    const halfRange = data[1] / 2;\n    const mean = this.getYPosition(data[0]);\n    const min = this.getYPosition(data[0] - halfRange);\n    const max = this.getYPosition(data[0] + halfRange);\n\n    let prevHalfRange;\n    let prevMean;\n    let prevMin;\n    let prevMax;\n\n    if (prevData !== null) {\n      prevHalfRange = prevData[1] / 2;\n      prevMean = this.getYPosition(prevData[0]);\n      prevMin = this.getYPosition(prevData[0] - prevHalfRange);\n      prevMax = this.getYPosition(prevData[0] + prevHalfRange);\n    }\n\n    const color = this.params.get('color');\n    let gradient;\n    let rgb;\n\n    switch (colorScheme) {\n      case 'none':\n        rgb = hexToRGB(color);\n        ctx.fillStyle = `rgba(${rgb.join(',')}, 0.7)`;\n        ctx.strokeStyle = color;\n      break;\n      case 'hue':\n        gradient = ctx.createLinearGradient(-pixelsSinceLastFrame, 0, 0, 0);\n\n        if (prevData)\n          gradient.addColorStop(0, `hsl(${getHue(prevData[2])}, 100%, 50%)`);\n        else\n          gradient.addColorStop(0, `hsl(${getHue(data[2])}, 100%, 50%)`);\n\n        gradient.addColorStop(1, `hsl(${getHue(data[2])}, 100%, 50%)`);\n        ctx.fillStyle = gradient;\n      break;\n      case 'opacity':\n        rgb = hexToRGB(this.params.get('color'));\n        gradient = ctx.createLinearGradient(-pixelsSinceLastFrame, 0, 0, 0);\n\n        if (prevData)\n          gradient.addColorStop(0, `rgba(${rgb.join(',')}, ${prevData[2]})`);\n        else\n          gradient.addColorStop(0, `rgba(${rgb.join(',')}, ${data[2]})`);\n\n        gradient.addColorStop(1, `rgba(${rgb.join(',')}, ${data[2]})`);\n        ctx.fillStyle = gradient;\n      break;\n    }\n\n    ctx.save();\n    // draw range\n    ctx.beginPath();\n    ctx.moveTo(0, mean);\n    ctx.lineTo(0, max);\n\n    if (prevData !== null) {\n      ctx.lineTo(-pixelsSinceLastFrame, prevMax);\n      ctx.lineTo(-pixelsSinceLastFrame, prevMin);\n    }\n\n    ctx.lineTo(0, min);\n    ctx.closePath();\n\n    ctx.fill();\n\n    // draw mean\n    if (colorScheme === 'none' && prevMean) {\n      ctx.beginPath();\n      ctx.moveTo(-pixelsSinceLastFrame, prevMean);\n      ctx.lineTo(0, mean);\n      ctx.closePath();\n      ctx.stroke();\n    }\n\n\n    ctx.restore();\n\n    this.prevFrame = frame;\n  }\n};\n\nexport default TraceDisplay;\n","import BaseDisplay from './BaseDisplay';\nimport Rms from '../../common/operator/Rms';\n\nconst log10 = Math.log10;\n\nconst definitions = {\n  offset: {\n    type: 'float',\n    default: -14,\n    metas: { kind: 'dyanmic' },\n  },\n  min: {\n    type: 'float',\n    default: -80,\n    metas: { kind: 'dynamic' },\n  },\n  max: {\n    type: 'float',\n    default: 6,\n    metas: { kind: 'dynamic' },\n  },\n  width: {\n    type: 'integer',\n    default: 6,\n    metas: { kind: 'dynamic' },\n  }\n}\n\n/**\n * Simple VU-Meter to used on a `signal` stream.\n *\n * @memberof module:client.sink\n *\n * @param {Object} options - Override defaults parameters.\n * @param {Number} [options.offset=-14] - dB offset applied to the signal.\n * @param {Number} [options.min=-80] - Minimum displayed value (in dB).\n * @param {Number} [options.max=6] - Maximum displayed value (in dB).\n * @param {Number} [options.width=6] - Width of the display (in pixels).\n * @param {Number} [options.height=150] - Height of the canvas.\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas.\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw.\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const audioContext = new window.AudioContext();\n *\n * navigator.mediaDevices\n *   .getUserMedia({ audio: true })\n *   .then(init)\n *   .catch((err) => console.error(err.stack));\n *\n * function init(stream) {\n *   const source = audioContext.createMediaStreamSource(stream);\n *\n *   const audioInNode = new lfo.source.AudioInNode({\n *     audioContext: audioContext,\n *     sourceNode: source,\n *   });\n *\n *   const vuMeter = new lfo.sink.VuMeterDisplay({\n *     canvas: '#vu-meter',\n *   });\n *\n *   audioInNode.connect(vuMeter);\n *   audioInNode.start();\n * }\n */\nclass VuMeterDisplay extends BaseDisplay {\n  constructor(options = {}) {\n    super(definitions, options, false);\n\n    this.rmsOperator = new Rms();\n\n    this.lastDB = 0;\n    this.peak = {\n      value: 0,\n      time: 0,\n    }\n\n    this.peakLifetime = 1; // sec\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this.rmsOperator.initStream(this.streamParams);\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processSignal(frame) {\n    const now = new Date().getTime() / 1000; // sec\n    const offset = this.params.get('offset'); // offset zero of the vu meter\n    const height = this.canvasHeight;\n    const width = this.canvasWidth;\n    const ctx = this.ctx;\n\n    const lastDB = this.lastDB;\n    const peak = this.peak;\n\n    const red = '#ff2121';\n    const yellow = '#ffff1f';\n    const green = '#00ff00';\n\n    // handle current db value\n    const rms = this.rmsOperator.inputSignal(frame.data);\n    let dB = 20 * log10(rms) - offset;\n\n    // slow release (could probably be improved)\n    if (lastDB > dB)\n      dB = lastDB - 6;\n\n    // handle peak\n    if (dB > peak.value || (now - peak.time) > this.peakLifetime) {\n      peak.value = dB;\n      peak.time = now;\n    }\n\n    const y0 = this.getYPosition(0);\n    const y = this.getYPosition(dB);\n    const yPeak = this.getYPosition(peak.value);\n\n    ctx.save();\n\n    ctx.fillStyle = '#000000';\n    ctx.fillRect(0, 0, width, height);\n\n    const gradient = ctx.createLinearGradient(0, height, 0, 0);\n    gradient.addColorStop(0, green);\n    gradient.addColorStop((height - y0) / height, yellow);\n    gradient.addColorStop(1, red);\n\n    // dB\n    ctx.fillStyle = gradient;\n    ctx.fillRect(0, y, width, height - y);\n\n    // 0 dB marker\n    ctx.fillStyle = '#dcdcdc';\n    ctx.fillRect(0, y0, width, 2);\n\n    // peak\n    ctx.fillStyle = gradient;\n    ctx.fillRect(0, yPeak, width, 2);\n\n    ctx.restore();\n\n    this.lastDB = dB;\n  }\n}\n\nexport default VuMeterDisplay;\n","import BaseDisplay from './BaseDisplay';\nimport MinMax from '../../common/operator/MinMax';\nimport Rms from '../../common/operator/Rms';\nimport { getColors } from '../utils/display-utils';\n\n\nconst definitions = {\n  colors: {\n    type: 'any',\n    default: getColors('waveform'),\n    metas: { kind: 'dyanmic' },\n  },\n  rms: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dyanmic' },\n  }\n};\n\n/**\n * Display a waveform (along with optionnal Rms) of a given `signal` input in\n * a canvas.\n *\n * @param {Object} options - Override default parameters.\n * @param {Array<String>} [options.colors=['waveform', 'rms']] - Array\n *  containing the color codes for the waveform (index 0) and rms (index 1).\n *  _dynamic parameter_\n * @param {Boolean} [options.rms=false] - Set to `true` to display the rms.\n *  _dynamic parameter_\n * @param {Number} [options.duration=1] - Duration (in seconds) represented in\n *  the canvas. _dynamic parameter_\n * @param {Number} [options.min=-1] - Minimum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.max=1] - Maximum value represented in the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.width=300] - Width of the canvas.\n *  _dynamic parameter_\n * @param {Number} [options.height=150] - Height of the canvas.\n *  _dynamic parameter_\n * @param {Element|CSSSelector} [options.container=null] - Container element\n *  in which to insert the canvas. _constant parameter_\n * @param {Element|CSSSelector} [options.canvas=null] - Canvas element\n *  in which to draw. _constant parameter_\n * @param {Number} [options.referenceTime=null] - Optionnal reference time the\n *  display should considerer as the origin. Is only usefull when synchronizing\n *  several display using the `DisplaySync` class.\n *\n * @memberof module:client.sink\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const audioContext = new window.AudioContext();\n *\n * navigator.mediaDevices\n *   .getUserMedia({ audio: true })\n *   .then(init)\n *   .catch((err) => console.error(err.stack));\n *\n * function init(stream) {\n *   const audioIn = audioContext.createMediaStreamSource(stream);\n *\n *   const audioInNode = new lfo.source.AudioInNode({\n *     audioContext: audioContext,\n *     sourceNode: audioIn,\n *     frameSize: 512,\n *   });\n *\n *   const waveformDisplay = new lfo.sink.WaveformDisplay({\n *     canvas: '#waveform',\n *     duration: 3.5,\n *     rms: true,\n *   });\n *\n *   audioInNode.connect(waveformDisplay);\n *   audioInNode.start();\n * });\n */\nclass WaveformDisplay extends BaseDisplay {\n  constructor(options) {\n    super(definitions, options, true);\n\n    this.minMaxOperator = new MinMax();\n    this.rmsOperator = new Rms();\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this.minMaxOperator.initStream(this.streamParams);\n    this.rmsOperator.initStream(this.streamParams);\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processSignal(frame, frameWidth, pixelsSinceLastFrame) {\n    // drop frames that cannot be displayed\n    if (frameWidth < 1) return;\n\n    const colors = this.params.get('colors');\n    const showRms = this.params.get('rms');\n    const ctx = this.ctx;\n    const data = frame.data;\n    const iSamplesPerPixels = Math.floor(data.length / frameWidth);\n\n    for (let index = 0; index < frameWidth; index++) {\n      const start = index * iSamplesPerPixels;\n      const end = index === frameWidth - 1 ? undefined : start + iSamplesPerPixels;\n      const slice = data.subarray(start, end);\n\n      const minMax = this.minMaxOperator.inputSignal(slice);\n      const minY = this.getYPosition(minMax[0]);\n      const maxY = this.getYPosition(minMax[1]);\n\n      ctx.strokeStyle = colors[0];\n      ctx.beginPath();\n      ctx.moveTo(index, minY);\n      ctx.lineTo(index, maxY);\n      ctx.closePath();\n      ctx.stroke();\n\n      if (showRms) {\n        const rms = this.rmsOperator.inputSignal(slice);\n        const rmsMaxY = this.getYPosition(rms);\n        const rmsMinY = this.getYPosition(-rms);\n\n        ctx.strokeStyle = colors[1];\n        ctx.beginPath();\n        ctx.moveTo(index, rmsMinY);\n        ctx.lineTo(index, rmsMaxY);\n        ctx.closePath();\n        ctx.stroke();\n      }\n    }\n  }\n}\n\nexport default WaveformDisplay;\n","// common\nimport Bridge from '../../common/sink/Bridge';\nimport Logger from '../../common/sink/Logger';\nimport DataRecorder from '../../common/sink/DataRecorder';\nimport SignalRecorder from '../../common/sink/SignalRecorder';\n\n// client only\nimport BaseDisplay from './BaseDisplay';\nimport BarChartDisplay from './BarChartDisplay';\nimport BpfDisplay from './BpfDisplay';\nimport MarkerDisplay from './MarkerDisplay';\nimport SignalDisplay from './SignalDisplay';\nimport SocketSend from './SocketSend';\nimport SpectrumDisplay from './SpectrumDisplay';\nimport TraceDisplay from './TraceDisplay';\nimport VuMeterDisplay from './VuMeterDisplay';\nimport WaveformDisplay from './WaveformDisplay';\n\nexport default {\n  Bridge,\n  Logger,\n  DataRecorder,\n  SignalRecorder,\n\n  BaseDisplay,\n  BarChartDisplay,\n  BpfDisplay,\n  MarkerDisplay,\n  SignalDisplay,\n  SocketSend,\n  SpectrumDisplay,\n  TraceDisplay,\n  VuMeterDisplay,\n  WaveformDisplay,\n};\n","import BaseLfo from '../../core/BaseLfo';\nimport SourceMixin from '../../core/SourceMixin';\n\n\nconst definitions = {\n  audioBuffer: {\n    type: 'any',\n    default: null,\n    constant: true,\n  },\n  frameSize: {\n    type: 'integer',\n    default: 512,\n    constant: true,\n  },\n  channel: {\n    type: 'integer',\n    default: 0,\n    constant: true,\n  },\n  progressCallback: {\n    type: 'any',\n    default: null,\n    nullable: true,\n    constant: true,\n  },\n  progressCallback: {\n    type: 'any',\n    default: null,\n    nullable: true,\n    constant: true,\n  },\n  async: {\n    type: 'boolean',\n    default: false,\n  },\n};\n\nconst noop = function() {};\n\n/**\n * Slice an `AudioBuffer` into signal blocks and propagate the resulting frames\n * through the graph.\n *\n * @param {Object} options - Override parameter' default values.\n * @param {AudioBuffer} [options.audioBuffer] - Audio buffer to process.\n * @param {Number} [options.frameSize=512] - Size of the output blocks.\n * @param {Number} [options.channel=0] - Number of the channel to process.\n * @param {Number} [options.progressCallback=null] - Callback to be excuted on each\n *  frame output, receive as argument the current progress ratio.\n *\n * @memberof module:client.source\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const audioInBuffer = new lfo.source.AudioInBuffer({\n *   audioBuffer: audioBuffer,\n *   frameSize: 512,\n * });\n *\n * const waveform = new lfo.sink.Waveform({\n *   canvas: '#waveform',\n *   duration: 1,\n *   color: 'steelblue',\n *   rms: true,\n * });\n *\n * audioInBuffer.connect(waveform);\n * audioInBuffer.start();\n */\nclass AudioInBuffer extends SourceMixin(BaseLfo) {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    const audioBuffer = this.params.get('audioBuffer');\n\n    if (!audioBuffer)\n      throw new Error('Invalid \"audioBuffer\" parameter');\n\n    this.endTime = 0;\n  }\n\n  /**\n   * Propagate the `streamParams` in the graph and start propagating frames.\n   * When called, the slicing of the given `audioBuffer` starts immediately and\n   * each resulting frame is propagated in graph.\n   *\n   * @see {@link module:core.BaseLfo#processStreamParams}\n   * @see {@link module:core.BaseLfo#resetStream}\n   * @see {@link module:client.source.AudioInBuffer#stop}\n   */\n  start() {\n    if (this.initialized === false) {\n      if (this.initPromise === null) // init has not yet been called\n        this.initPromise = this.init();\n\n      this.initPromise.then(this.start);\n      return;\n    }\n\n    const channel = this.params.get('channel');\n    const audioBuffer = this.params.get('audioBuffer');\n    const buffer = audioBuffer.getChannelData(channel);\n    this.endTime = 0;\n    this.started = true;\n\n    this.processFrame(buffer);\n  }\n\n  /**\n   * Finalize the stream and stop the whole graph. When called, the slicing of\n   * the `audioBuffer` stops immediately.\n   *\n   * @see {@link module:core.BaseLfo#finalizeStream}\n   * @see {@link module:client.source.AudioInBuffer#start}\n   */\n  stop() {\n    this.finalizeStream(this.endTime);\n    this.started = false;\n  }\n\n  /** @private */\n  processStreamParams() {\n    const audioBuffer = this.params.get('audioBuffer');\n    const frameSize = this.params.get('frameSize');\n    const sourceSampleRate = audioBuffer.sampleRate;\n    const frameRate = sourceSampleRate / frameSize;\n\n    this.streamParams.frameSize = frameSize;\n    this.streamParams.frameRate = frameRate;\n    this.streamParams.frameType = 'signal';\n    this.streamParams.sourceSampleRate = sourceSampleRate;\n    this.streamParams.sourceSampleCount = frameSize;\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processFrame(buffer) {\n    const async = this.params.get('async');\n    const sampleRate = this.streamParams.sourceSampleRate;\n    const frameSize = this.streamParams.frameSize;\n    const progressCallback = this.params.get('progressCallback') || noop;\n    const length = buffer.length;\n    const nbrFrames = Math.ceil(buffer.length / frameSize);\n    const data = this.frame.data;\n    const that = this;\n    let i = 0;\n\n    function slice() {\n      const offset = i * frameSize;\n      const nbrCopy = Math.min(length - offset, frameSize);\n\n      for (let j = 0; j < frameSize; j++)\n        data[j] = j < nbrCopy ? buffer[offset + j] : 0;\n\n      that.frame.time = offset / sampleRate;\n      that.endTime = that.frame.time + nbrCopy / sampleRate;\n      that.propagateFrame();\n\n      i += 1;\n      progressCallback(i / nbrFrames);\n\n      if (i < nbrFrames) {\n        if (async)\n          setTimeout(slice, 0);\n        else\n          slice();\n      } else {\n        that.finalizeStream(that.endTime);\n      }\n    };\n\n    // allow the following to do the expected thing:\n    // audioIn.connect(recorder);\n    // audioIn.start();\n    // recorder.start();\n    setTimeout(slice, 0);\n  }\n}\n\nexport default AudioInBuffer;\n","import BaseLfo from '../../core/BaseLfo';\nimport SourceMixin from '../../core/SourceMixin';\n\nconst AudioContext = window.AudioContext || window.webkitAudioContext;\n\nconst definitions = {\n  frameSize: {\n    type: 'integer',\n    default: 512,\n    constant: true,\n  },\n  channel: {\n    type: 'integer',\n    default: 0,\n    constant: true,\n  },\n  sourceNode: {\n    type: 'any',\n    default: null,\n    constant: true,\n  },\n  audioContext: {\n    type: 'any',\n    default: null,\n    constant: true,\n  },\n};\n\n/**\n * Use a `WebAudio` node as a source for the graph.\n *\n * @param {Object} options - Override parameter' default values.\n * @param {AudioNode} [options.sourceNode=null] - Audio node to process\n *  (mandatory).\n * @param {AudioContext} [options.audioContext=null] - Audio context used to\n *  create the audio node (mandatory).\n * @param {Number} [options.frameSize=512] - Size of the output blocks, define\n *  the `frameSize` in the `streamParams`.\n * @param {Number} [options.channel=0] - Number of the channel to process.\n *\n * @memberof module:client.source\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const audioContext = new AudioContext();\n * const sine = audioContext.createOscillator();\n * sine.frequency.value = 2;\n *\n * const audioInNode = new lfo.source.AudioInNode({\n *   audioContext: audioContext,\n *   sourceNode: sine,\n * });\n *\n * const signalDisplay = new lfo.sink.SignalDisplay({\n *   canvas: '#signal',\n *   duration: 1,\n * });\n *\n * audioInNode.connect(signalDisplay);\n *\n * // start the sine oscillator node and the lfo graph\n * sine.start();\n * audioInNode.start();\n */\nclass AudioInNode extends SourceMixin(BaseLfo) {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    const audioContext = this.params.get('audioContext');\n    const sourceNode = this.params.get('sourceNode');\n\n    if (!audioContext || !(audioContext instanceof AudioContext))\n      throw new Error('Invalid `audioContext` parameter');\n\n    if (!sourceNode || !(sourceNode instanceof AudioNode))\n      throw new Error('Invalid `sourceNode` parameter');\n\n    this.sourceNode = sourceNode;\n    this._channel = this.params.get('channel');\n    this._blockDuration = null;\n\n    this.processFrame = this.processFrame.bind(this);\n  }\n\n  /**\n   * Propagate the `streamParams` in the graph and start to propagate signal\n   * blocks produced by the audio node into the graph.\n   *\n   * @see {@link module:core.BaseLfo#processStreamParams}\n   * @see {@link module:core.BaseLfo#resetStream}\n   * @see {@link module:client.source.AudioInNode#stop}\n   */\n  start() {\n    if (this.initialized === false) {\n      if (this.initPromise === null) // init has not yet been called\n        this.initPromise = this.init();\n\n      this.initPromise.then(this.start);\n      return;\n    }\n\n    const audioContext = this.params.get('audioContext');\n    const frameSize = this.params.get('frameSize');\n\n    this.frame.time = 0;\n    // @note: recreate each time because of a firefox weird behavior\n    this.scriptProcessor = audioContext.createScriptProcessor(frameSize, 1, 1);\n    this.scriptProcessor.onaudioprocess = this.processFrame;\n\n    this.started = true;\n    this.sourceNode.connect(this.scriptProcessor);\n    this.scriptProcessor.connect(audioContext.destination);\n  }\n\n  /**\n   * Finalize the stream and stop the whole graph.\n   *\n   * @see {@link module:core.BaseLfo#finalizeStream}\n   * @see {@link module:client.source.AudioInNode#start}\n   */\n  stop() {\n    this.finalizeStream(this.frame.time);\n    this.started = false;\n    this.sourceNode.disconnect();\n    this.scriptProcessor.disconnect();\n  }\n\n  /** @private */\n  processStreamParams() {\n    const audioContext = this.params.get('audioContext');\n    const frameSize = this.params.get('frameSize');\n    const sampleRate = audioContext.sampleRate;\n\n    this.streamParams.frameSize = frameSize;\n    this.streamParams.frameRate = sampleRate / frameSize;\n    this.streamParams.frameType = 'signal';\n    this.streamParams.sourceSampleRate = sampleRate;\n    this.streamParams.sourceSampleCount = frameSize;\n\n    this._blockDuration = frameSize / sampleRate;\n\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Basically the `scriptProcessor.onaudioprocess` callback\n   * @private\n   */\n  processFrame(e) {\n    if (this.started === false)\n      return;\n\n    this.frame.data = e.inputBuffer.getChannelData(this._channel);\n    this.propagateFrame();\n\n    this.frame.time += this._blockDuration;\n  }\n}\n\nexport default AudioInNode;\n","import BaseLfo from '../../core/BaseLfo';\nimport { opcodes, encoders, decoders } from '../../common/utils/wsUtils';\n\nconst parameters = {\n  port: {\n    type: 'integer',\n    default: 8000,\n    nullable: true,\n    constant: true,\n  },\n  url: {\n    type: 'string',\n    default: null,\n    nullable: true,\n    constant: true,\n  }\n}\n\n/**\n * Receive an lfo frame as a socket message from a `node.sink.SocketSend`\n * instance.\n *\n * <p class=\"warning\">Experimental</p>\n *\n * @memberof module:client.source\n *\n * @todo - handle init / start properly.\n */\nclass SocketReceive extends BaseLfo {\n  constructor(options = {}) {\n    super(parameters, options);\n\n    const protocol = window.location.protocol.replace(/^http/, 'ws');\n    const address = this.params.get('url') || window.location.hostname;\n    const port = this.params.get('port') || ''; // everything falsy becomes ''\n    const socketAddress = `${protocol}//${address}:${port}`;\n\n    this._dispatch = this._dispatch.bind(this);\n\n    this.socket = new WebSocket(socketAddress);\n    this.socket.binaryType = 'arraybuffer';\n\n    this.openedPromise = new Promise((resolve, reject) => {\n      this.socket.onopen = resolve;\n    });\n\n    this.socket.onmessage = this._dispatch;\n    this.socket.onerror = (err) => console.error(err.stack);\n  }\n\n  /** @private */\n  initModule() {\n    const promises = this.nextModules.map((mod) => mod.initModule());\n    promises.push(this.openedPromise);\n    // wait for children promises and send INIT_MODULE_ACK\n    Promise.all(promises).then(() => {\n      const buffer = encoders.initModuleAck();\n      this.socket.send(buffer);\n    });\n  }\n\n  // process any type\n  /** @private */\n  processScalar() {}\n  /** @private */\n  processVector() {}\n  /** @private */\n  processSignal() {}\n\n  /** @private */\n  processFrame(frame) {\n    this.prepareFrame();\n    this.frame = frame;\n    this.propagateFrame();\n  }\n\n  /**\n   * Decode and dispatch incomming frame according to opcode\n   * @private\n   */\n  _dispatch(e) {\n    const arrayBuffer = e.data;\n    const opcode = decoders.opcode(arrayBuffer);\n\n    switch (opcode) {\n      case opcodes.INIT_MODULE_REQ:\n        this.initModule();\n        break;\n      case opcodes.PROCESS_STREAM_PARAMS:\n        const prevStreamParams = decoders.streamParams(arrayBuffer);\n        this.processStreamParams(prevStreamParams);\n        break;\n      case opcodes.RESET_STREAM:\n        this.resetStream();\n        break;\n      case opcodes.FINALIZE_STREAM:\n        const endTime = decoders.finalizeStream(arrayBuffer);\n        this.finalizeStream(endTime);\n        break;\n      case opcodes.PROCESS_FRAME:\n        const frameSize = this.streamParams.frameSize;\n        const frame = decoders.processFrame(arrayBuffer, frameSize);\n        this.processFrame(frame);\n        break;\n    }\n  }\n}\n\nexport default SocketReceive;\n","// common\nimport EventIn from '../../common/source/EventIn';\n// client only\nimport AudioInBuffer from './AudioInBuffer';\nimport AudioInNode from './AudioInNode';\nimport SocketReceive from './SocketReceive';\n\nexport default {\n  EventIn,\n\n  AudioInBuffer,\n  AudioInNode,\n  SocketReceive,\n};\n","/**\n * Synchronize several display sinks to a common time.\n *\n * @param {...BaseDisplay} views - List of the display to synchronize.\n *\n * @memberof module:client.utils\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const eventIn1 = new lfo.source.EventIn({\n *   frameType: 'scalar',\n *   frameSize: 1,\n * });\n *\n * const bpf1 = new lfo.sink.BpfDisplay({\n *   canvas: '#bpf-1',\n *   duration: 2,\n *   startTime: 0,\n *   min: 0,\n *   colors: ['steelblue'],\n * });\n *\n * eventIn1.connect(bpf1);\n *\n * const eventIn2 = new lfo.source.EventIn({\n *   frameType: 'scalar',\n *   frameSize: 1,\n * });\n *\n * const bpf2 = new lfo.sink.BpfDisplay({\n *   canvas: '#bpf-2',\n *   duration: 2,\n *   startTime: 7,\n *   min: 0,\n *   colors: ['orange'],\n * });\n *\n * const displaySync = new lfo.utils.DisplaySync(bpf1, bpf2);\n *\n * eventIn2.connect(bpf2);\n *\n * eventIn1.start();\n * eventIn2.start();\n *\n * let time = 0;\n * const period = 0.4;\n * const offset = 7.2;\n *\n * (function generateData() {\n *   const v = Math.random();\n *\n *   eventIn1.process(time, v);\n *   eventIn2.process(time + offset, v);\n *\n *   time += period;\n *\n *   setTimeout(generateData, period * 1000);\n * }());\n */\nclass DisplaySync {\n  constructor(...views) {\n    this.views = [];\n\n    this.add(...views);\n  }\n\n  /** @private */\n  add(...views) {\n    views.forEach(view => this.install(view));\n  }\n\n  /** @private */\n  install(view) {\n    this.views.push(view);\n\n    view.displaySync = this;\n  }\n\n  /** @private */\n  shiftSiblings(iShift, time, view) {\n    this.views.forEach(function(display) {\n      if (display !== view)\n        display.shiftCanvas(iShift, time);\n    });\n  }\n}\n\nexport default DisplaySync;\n","import DisplaySync from './DisplaySync';\nimport initWindows from '../../common/utils/windows';\n\nexport default {\n  DisplaySync,\n  initWindows,\n};\n","const colors = ['#4682B4', '#ffa500', '#00e600', '#ff0000', '#800080', '#224153'];\n\nexport const getColors = function(type, nbr) {\n  switch (type) {\n    case 'signal':\n      return colors[0]; // steelblue\n      break;\n    case 'bpf':\n      if (nbr <= colors.length) {\n        return colors.slice(0, nbr);\n      } else {\n        const _colors = colors.slice(0);\n        while (_colors.length < nbr)\n          _colors.push(getRandomColor());\n\n        return _colors;\n      }\n      break;\n    case 'waveform':\n      return [colors[0], colors[5]]; // steelblue / darkblue\n      break;\n    case 'marker':\n      return colors[3]; // red\n      break;\n    case 'spectrum':\n      return colors[2]; // green\n      break;\n    case 'trace':\n      return colors[1]; // orange\n      break;\n    case 'bar-chart':\n      return colors;\n      break;\n  }\n};\n\n// http://stackoverflow.com/questions/1484506/random-color-generator-in-javascript\nexport const getRandomColor = function() {\n  var letters = '0123456789ABCDEF'.split('');\n  var color = '#';\n  for (var i = 0; i < 6; i++ ) {\n    color += letters[Math.floor(Math.random() * 16)];\n  }\n  return color;\n};\n\n// scale from domain [0, 1] to range [270, 0] to consume in\n// hsl(x, 100%, 50%) color scheme\nexport const getHue = function(x) {\n  var domainMin = 0;\n  var domainMax = 1;\n  var rangeMin = 270;\n  var rangeMax = 0;\n\n  return (((rangeMax - rangeMin) * (x - domainMin)) / (domainMax - domainMin)) + rangeMin;\n};\n\nexport const hexToRGB = function(hex) {\n  hex = hex.substring(1, 7);\n  var r = parseInt(hex.substring(0, 2), 16);\n  var g = parseInt(hex.substring(2, 4), 16);\n  var b = parseInt(hex.substring(4, 6), 16);\n  return [r, g, b];\n};\n","import BaseLfo from '../../core/BaseLfo';\n\nconst sin = Math.sin;\nconst cos = Math.cos;\nconst sqrt = Math.sqrt;\nconst pow = Math.pow;\nconst _2PI = Math.PI * 2;\n\n// plot (from http://www.earlevel.com/scripts/widgets/20131013/biquads2.js)\n// var len = 512;\n// var magPlot = [];\n// for (var idx = 0; idx < len; idx++) {\n//   var w;\n//   if (plotType == \"linear\")\n//     w = idx / (len - 1) * Math.PI;  // 0 to pi, linear scale\n//   else\n//     w = Math.exp(Math.log(1 / 0.001) * idx / (len - 1)) * 0.001 * Math.PI;  // 0.001 to 1, times pi, log scale\n\n//   var phi = Math.pow(Math.sin(w/2), 2);\n//   var y = Math.log(Math.pow(a0+a1+a2, 2) - 4*(a0*a1 + 4*a0*a2 + a1*a2)*phi + 16*a0*a2*phi*phi) - Math.log(Math.pow(1+b1+b2, 2) - 4*(b1 + 4*b2 + b1*b2)*phi + 16*b2*phi*phi);\n//   y = y * 10 / Math.LN10\n//   if (y == -Infinity)\n//     y = -200;\n\n//   if (plotType == \"linear\")\n//     magPlot.push([idx / (len - 1) * Fs / 2, y]);\n//   else\n//     magPlot.push([idx / (len - 1) / 2, y]);\n\n//   if (idx == 0)\n//     minVal = maxVal = y;\n//   else if (y < minVal)\n//     minVal = y;\n//   else if (y > maxVal)\n//     maxVal = y;\n// }\n\nconst definitions = {\n  type: {\n    type: 'enum',\n    default: 'lowpass',\n    list: [\n      'lowpass',\n      'highpass',\n      'bandpass_constant_skirt',\n      'bandpass',\n      'bandpass_constant_peak',\n      'notch',\n      'allpass',\n      'peaking',\n      'lowshelf',\n      'highshelf',\n    ],\n    metas: { kind: 'dyanmic' },\n  },\n  f0: {\n    type: 'float',\n    default: 1,\n    metas: { kind: 'dyanmic' },\n  },\n  gain: {\n    type: 'float',\n    default: 1,\n    min: 0,\n    metas: { kind: 'dyanmic' },\n  },\n  q: {\n    type: 'float',\n    default: 1,\n    min: 0.001, // PIPO_BIQUAD_MIN_Q\n    // max: 1,\n    metas: { kind: 'dyanmic' },\n  },\n  // bandwidth: {\n  //   type: 'float',\n  //   default: null,\n  //   nullable: true,\n  //   metas: { kind: 'dyanmic' },\n  // },\n}\n\n\n/**\n * Biquad filter (Direct form I). If input is of type `vector` the filter is\n * applied on each dimension i parallel.\n *\n * Based on the [\"Cookbook formulae for audio EQ biquad filter coefficients\"](http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt)\n * by Robert Bristow-Johnson.\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default values.\n * @param {String} [options.type='lowpass'] - Type of the filter. Available\n *  filters: 'lowpass', 'highpass', 'bandpass_constant_skirt', 'bandpass_constant_peak'\n *  (alias 'bandpass'), 'notch', 'allpass', 'peaking', 'lowshelf', 'highshelf'.\n * @param {Number} [options.f0=1] - Cutoff or center frequency of the filter\n *  according to its type.\n * @param {Number} [options.gain=1] - Gain of the filter (in dB).\n * @param {Number} [options.q=1] - Quality factor of the filter.\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const audioInBuffer = new lfo.source.AudioInBuffer({\n *   audioBuffer: buffer,\n * });\n *\n * const biquad = new lfo.operator.Biquad({\n *   type: 'lowpass',\n *   f0: 2000,\n *   gain: 3,\n *   q: 12,\n * });\n *\n * const spectrumDisplay = new lfo.sink.SpectrumDisplay({\n *   canvas: '#spectrum',\n * });\n *\n * audioInBuffer.connect(biquad);\n * biquad.connect(spectrumDisplay);\n *\n * audioInBuffer.start();\n */\nclass Biquad extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n  }\n\n  onParamUpdate(name, value, metas) {\n    this._calculateCoefs();\n  }\n\n  _calculateCoefs() {\n    const sampleRate = this.streamParams.sourceSampleRate;\n    const frameType = this.streamParams.frameType;\n    const frameSize = this.streamParams.frameSize;\n\n    const type = this.params.get('type');\n    const f0 = this.params.get('f0');\n    const gain = this.params.get('gain');\n    const q = this.params.get('q');\n    // const bandwidth = this.params.get('bandwidth');\n    const bandwidth = null;\n\n    let b0 = 0, b1 = 0, b2 = 0, a0 = 0, a1 = 0, a2 = 0;\n\n    const A = pow(10, gain / 40);\n    const w0 = _2PI * f0 / sampleRate;\n    const cosW0 = cos(w0);\n    const sinW0 = sin(w0);\n    let alpha; // depend of the filter type\n    let _2RootAAlpha; // intermediate value for lowshelf and highshelf\n\n    switch (type) {\n      // H(s) = 1 / (s^2 + s/Q + 1)\n      case 'lowpass':\n        alpha = sinW0 / (2 * q);\n        b0 = (1 - cosW0) / 2;\n        b1 = 1 - cosW0;\n        b2 = b0;\n        a0 = 1 + alpha;\n        a1 = -2 * cosW0;\n        a2 = 1 -alpha;\n        break;\n      // H(s) = s^2 / (s^2 + s/Q + 1)\n      case 'highpass':\n        alpha = sinW0 / (2 * q);\n        b0 = (1 + cosW0) / 2;\n        b1 = - (1 + cosW0)\n        b2 = b0;\n        a0 = 1 + alpha;\n        a1 = -2 * cosW0;\n        a2 = 1 - alpha;\n        break;\n      // H(s) = s / (s^2 + s/Q + 1)  (constant skirt gain, peak gain = Q)\n      case 'bandpass_constant_skirt':\n        if (bandwidth) {\n          // sin(w0)*sinh( ln(2)/2 * BW * w0/sin(w0) )           (case: BW)\n        } else {\n          alpha = sinW0 / (2 * q);\n        }\n\n        b0 = sinW0 / 2;\n        b1 = 0;\n        b2 = -b0;\n        a0 = 1 + alpha;\n        a1 = -2 * cosW0;\n        a2 = 1 - alpha;\n        break;\n      // H(s) = (s/Q) / (s^2 + s/Q + 1)      (constant 0 dB peak gain)\n      case 'bandpass': // looks like what is gnerally considered as a bandpass\n      case 'bandpass_constant_peak':\n        if (bandwidth) {\n          // sin(w0)*sinh( ln(2)/2 * BW * w0/sin(w0) )           (case: BW)\n        } else {\n          alpha = sinW0 / (2 * q);\n        }\n\n        b0 = alpha;\n        b1 = 0;\n        b2 = -alpha;\n        a0 = 1 + alpha;\n        a1 = -2 * cosW0;\n        a2 = 1 - alpha;\n        break;\n      // H(s) = (s^2 + 1) / (s^2 + s/Q + 1)\n      case 'notch':\n        alpha = sinW0 / (2 * q);\n        b0 = 1;\n        b1 = -2 * cosW0;\n        b2 = 1;\n        a0 = 1 + alpha;\n        a1 = b1;\n        a2 = 1 - alpha;\n        break;\n      // H(s) = (s^2 - s/Q + 1) / (s^2 + s/Q + 1)\n      case 'allpass':\n        alpha = sinW0 / (2 * q);\n        b0 = 1 - alpha;\n        b1 = -2 * cosW0;\n        b2 = 1 + alpha;\n        a0 = b2;\n        a1 = b1;\n        a2 = b0;\n        break;\n      // H(s) = (s^2 + s*(A/Q) + 1) / (s^2 + s/(A*Q) + 1)\n      case 'peaking':\n        if (bandwidth) {\n          // sin(w0)*sinh( ln(2)/2 * BW * w0/sin(w0) )           (case: BW)\n        } else {\n          alpha = sinW0 / (2 * q);\n        }\n\n        b0 = 1 + alpha * A;\n        b1 = -2 * cosW0;\n        b2 = 1 - alpha * A;\n        a0 = 1 + alpha / A;\n        a1 = b1;\n        a2 = 1 - alpha / A;\n        break;\n      // H(s) = A * (s^2 + (sqrt(A)/Q)*s + A)/(A*s^2 + (sqrt(A)/Q)*s + 1)\n      case 'lowshelf':\n        alpha = sinW0 / (2 * q);\n        _2RootAAlpha = 2 * sqrt(A) * alpha;\n\n        b0 =     A * ((A + 1) - (A - 1) * cosW0 + _2RootAAlpha);\n        b1 = 2 * A * ((A - 1) - (A + 1) * cosW0);\n        b2 =     A * ((A + 1) - (A - 1) * cosW0 - _2RootAAlpha);\n        a0 =          (A + 1) + (A - 1) * cosW0 + _2RootAAlpha;\n        a1 =    -2 * ((A - 1) + (A + 1) * cosW0);\n        a2 =          (A + 1) + (A - 1) * cosW0 - _2RootAAlpha;\n        break;\n      // H(s) = A * (A*s^2 + (sqrt(A)/Q)*s + 1)/(s^2 + (sqrt(A)/Q)*s + A)\n      case 'highshelf':\n        alpha = sinW0 / (2 * q);\n        _2RootAAlpha = 2 * sqrt(A) * alpha;\n\n        b0 =      A * ((A + 1) + (A - 1) * cosW0 + _2RootAAlpha);\n        b1 = -2 * A * ((A - 1) + (A + 1) * cosW0);\n        b2 =      A * ((A + 1) + (A - 1) * cosW0 - _2RootAAlpha);\n        a0 =           (A + 1) - (A - 1) * cosW0 + _2RootAAlpha;\n        a1 =      2 * ((A - 1) - (A + 1) * cosW0);\n        a2 =           (A + 1) - (A - 1) * cosW0 - _2RootAAlpha;\n\n        break;\n    }\n\n    this.coefs = {\n      b0: b0 / a0,\n      b1: b1 / a0,\n      b2: b2 / a0,\n      a1: a1 / a0,\n      a2: a2 / a0,\n    };\n\n    // reset state\n    if (frameType === 'signal') {\n      this.state = { x1: 0, x2: 0, y1: 0, y2: 0 };\n    } else {\n      this.state = {\n        x1: new Float32Array(frameSize),\n        x2: new Float32Array(frameSize),\n        y1: new Float32Array(frameSize),\n        y2: new Float32Array(frameSize),\n      };\n    }\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    // if no `sampleRate` or `sampleRate` is 0 we shall halt!\n    const sampleRate = this.streamParams.sourceSampleRate;\n\n    if (!sampleRate || sampleRate <= 0)\n      throw new Error('Invalid sampleRate value (0) for biquad');\n\n    this._calculateCoefs();\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processVector(frame) {\n    const frameSize = this.streamParams.frameSize;\n    const outData = this.frame.data;\n    const inData = frame.data;\n    const state = this.state;\n    const coefs = this.coefs;\n\n    for (let i = 0; i < frameSize; i++) {\n      const x = inData[i];\n      const y = coefs.b0 * x\n              + coefs.b1 * state.x1[i] + coefs.b2 * state.x2[i]\n              - coefs.a1 * state.y1[i] - coefs.a2 * state.y2[i];\n\n      outData[i] = y;\n\n      // update states\n      state.x2[i] = state.x1[i];\n      state.x1[i] = x;\n      state.y2[i] = state.y1[i];\n      state.y1[i] = y;\n    }\n  }\n\n  /** @private */\n  processSignal(frame) {\n    const frameSize = this.streamParams.frameSize;\n    const outData = this.frame.data;\n    const inData = frame.data;\n    const state = this.state;\n    const coefs = this.coefs;\n\n    for (let i = 0; i < frameSize; i++) {\n      const x = inData[i];\n      const y = coefs.b0 * x\n              + coefs.b1 * state.x1 + coefs.b2 * state.x2\n              - coefs.a1 * state.y1 - coefs.a2 * state.y2;\n\n      outData[i] = y;\n\n      // update states\n      state.x2 = state.x1;\n      state.x1 = x;\n      state.y2 = state.y1;\n      state.y1 = y;\n    }\n  }\n}\n\nexport default Biquad;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  min: {\n    type: 'float',\n    default: 0,\n    min: -Infinity,\n    max: +Infinity,\n  },\n  max: {\n    type: 'float',\n    default: 1,\n    min: -Infinity,\n    max: +Infinity,\n  },\n};\n\n/**\n * Clip incomming according to given `min` and `max` parameters\n *\n * @param {Object} options - Override default paramters\n * @param {Number} [options.min=0] - Minimum value\n * @param {Number} [options.max=1] - Maximum value\n */\nclass Clip extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n  }\n\n  inputVector(data) {\n    const min = this.params.get('min');\n    const max = this.params.get('max');\n    const frameSize = this.streamParams.frameSize;\n    const outData = this.frame.data;\n\n    // @todo - could handle vector as min and max\n    for (let i = 0; i < frameSize; i++)\n      outData[i] = Math.min(max, Math.max(min, data[i]));\n\n    return outData;\n  }\n\n  processVector(frame) {\n    this.frame.data = this.inputVector(frame.data);\n  }\n\n  inputSignal(data) {\n    const min = this.params.get('min');\n    const max = this.params.get('max');\n    const frameSize = this.streamParams.frameSize;\n    const outData = this.frame.data;\n\n    for (let i = 0; i < frameSize; i++)\n      outData[i] = Math.min(max, Math.max(min, data[i]));\n\n    return outData;\n  }\n\n  processSignal(frame) {\n    this.frame.data = this.inputSignal(frame.data);\n  }\n}\n\nexport default Clip;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst sqrt = Math.sqrt;\nconst cos = Math.cos;\nconst PI = Math.PI;\n\n// Dct Type 2 - orthogonal matrix scaling\nfunction getDctWeights(order, N, type = 'htk') {\n  const weights = new Float32Array(N * order);\n  const piOverN = PI / N;\n  const scale0 = 1 / sqrt(2);\n  const scale = sqrt(2 / N);\n\n  for (let k = 0; k < order; k++) {\n    const s = (k === 0) ? (scale0 * scale) : scale;\n    // const s = scale; // rta doesn't apply k=0 scaling\n\n    for (let n = 0; n < N; n++)\n      weights[k * N + n] = s * cos(k * (n + 0.5) * piOverN);\n  }\n\n  return weights;\n}\n\nconst definitions = {\n  order: {\n    type: 'integer',\n    default: 12,\n    metas: { kind: 'static' },\n  },\n};\n\n/**\n * Compute the Discrete Cosine Transform of an input `signal` or `vector`.\n * (HTK style weighting).\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.order=12] - Number of computed bins.\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * // assuming some audio buffer\n * const source = new AudioInBuffer({\n *   audioBuffer: audioBuffer,\n *   useWorker: false,\n * });\n *\n * const slicer = new Slicer({\n *   frameSize: 512,\n *   hopSize: 512,\n * });\n *\n * const dct = new Dct({\n *   order: 12,\n * });\n *\n * const logger = new lfo.sink.Logger({ data: true });\n *\n * source.connect(slicer);\n * slicer.connect(dct);\n * dct.connect(logger);\n *\n * source.start();\n */\nclass Dct extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const order = this.params.get('order');\n    const inFrameSize = prevStreamParams.frameSize;\n\n    this.streamParams.frameSize = order;\n    this.streamParams.frameType = 'vector';\n    this.streamParams.description = [];\n\n    this.weightMatrix = getDctWeights(order, inFrameSize);\n\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Use the `Dct` operator in `standalone` mode (i.e. outside of a graph).\n   *\n   * @param {Array} values - Input values.\n   * @return {Array} - Dct of the input array.\n   *\n   * @example\n   * const dct = new lfo.operator.Dct({ order: 12 });\n   * // mandatory for use in standalone mode\n   * dct.initStream({ frameSize: 512, frameType: 'signal' });\n   * dct.inputSignal(data);\n   */\n  inputSignal(values) {\n    const order = this.params.get('order');\n    const frameSize = values.length;\n    const outFrame = this.frame.data;\n    const weights = this.weightMatrix;\n\n    for (let k = 0; k < order; k++) {\n      const offset = k * frameSize;\n      outFrame[k] = 0;\n\n      for (let n = 0; n < frameSize; n++)\n        outFrame[k] += values[n] * weights[offset + n];\n    }\n\n    return outFrame;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.inputSignal(frame.data);\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.inputSignal(frame.data);\n  }\n}\n\nexport default Dct;\n","import BaseLfo from '../../core/BaseLfo';\n\n\nfunction simpleLinearRegression(values, dt) {\n  // means\n  let xSum = 0;\n  let ySum = 0;\n  const length = values.length;\n\n  for (let i = 0; i < length; i++) {\n    xSum += i * dt;\n    ySum += values[i];\n  }\n\n  const xMean = xSum / length;\n  const yMean = ySum / length;\n\n  let sumDiffXMeanSquared = 0; // sum[ pow((x - xMean), 2) ]\n  let sumDiffYMeanSquared = 0; // sum[ pow((y - yMean), 2) ]\n  let sumDiffXYMean = 0;       // sum[ (x - xMean)(y - yMean) ]\n\n  for (let i = 0; i < length; i++) {\n    const diffXMean = dt * i - xMean;\n    const diffYMean = values[i] - yMean;\n\n    const diffXMeanSquared = diffXMean * diffXMean;\n    const diffYMeanSquared = diffYMean * diffYMean;\n    const diffXYMean = diffXMean * diffYMean;\n\n    sumDiffXMeanSquared += diffXMeanSquared;\n    sumDiffYMeanSquared += diffYMeanSquared;\n    sumDiffXYMean += diffXYMean;\n  }\n\n  // horizontal line, all y on same line\n  if (sumDiffYMeanSquared === 0)\n    return 0;\n\n  // Pearson correlation coefficient:\n  // cf. https://www.youtube.com/watch?v=2SCg8Kuh0tE\n  //\n  //                 ∑ [ (x - xMean)(y - yMean) ]\n  // r = ------------------------------------------------------\n  //     sqrt( ∑ [ pow((x - xMean), 2), pow((y - yMean), 2) ] )\n  //\n  //\n  const r = sumDiffXYMean / Math.sqrt(sumDiffXMeanSquared * sumDiffYMeanSquared);\n\n  // then we have:\n  // cf. https://www.youtube.com/watch?v=GhrxgbQnEEU\n  //\n  // y = a + bx\n  // where:\n  //         Sy\n  // b = r * --\n  //         Sx\n  //\n  // a = yMean - b * xMean\n  //\n  // S for standard deviation\n  //            ∑ [ pow((x - xMean), 2) ]\n  // Sx = sqrt( -------------------------  )\n  //                      N - 1\n  const Sx = Math.sqrt(sumDiffXMeanSquared / (length - 1));\n  const Sy = Math.sqrt(sumDiffYMeanSquared / (length - 1));\n  const b = r * (Sy / Sx);\n\n  return b;\n}\n\nconst definitions = {\n  size: {\n    type: 'integer',\n    min: 2,\n    max: +Infinity,\n    default: 3,\n  },\n  useFrameRate: {\n    type: 'integer',\n    min: 0,\n    max: +Infinity,\n    default: null,\n    nullable: true,\n  },\n};\n\n/**\n * Returns the simple derivative of successive value using\n * simple linear regression.\n * The current implementation assumes a fixed `frameRate` (`frame.time` is ignored)\n *\n * Before the module is filled, it outputs a value of 0.\n *\n * @param {Object} options - Override default parameters\n * @param {Number} [options.size=3] - Size of the window\n * @param {Number} [options.useFrameRate=null] - Override stream frame rate for\n *  the regression\n */\nclass Delta extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    this.buffers = null;\n    this.ringIndex = 0;\n    this.frameRate = null;\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const frameSize = this.streamParams.frameSize;\n    const size = this.params.get('size');\n    const bufferSize = frameSize * size;\n\n    this.buffers = [];\n    // counter before the operator starts outputing frames\n    this.ringIndex = 0;\n    this.frameRate = this.params.get('useFrameRate') === null ?\n      this.streamParams.frameRate :\n      this.params.get('useFrameRate');\n\n    for (let i = 0; i < frameSize; i++)\n      this.buffers[i] = new Float32Array(size);\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  resetStream() {\n    super.resetStream();\n\n    const frameSize = this.streamParams.frameSize;\n    const size = this.params.get('size');\n    const buffers = this.buffers;\n\n    for (let i = 0; i < frameSize; i++) {\n      for (let j = 0; j < size; j++)\n        buffers[i][j] = 0;\n    }\n\n    this.ringIndex = 0;\n  }\n\n  /**\n   * Assume a stream of vector at a fixed `frameRate`.\n   */\n  inputVector(data) {\n    const size = this.params.get('size');\n    const outData = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    // const frameRate = this.streamParams.frameRate;\n    const buffers = this.buffers;\n    const dt = 1 / this.frameRate;\n\n    // console.log(dt);\n\n    if (this.ringIndex < size)\n      this.ringIndex += 1;\n\n    // copy incomming data into buffer\n    for (let i = 0; i < frameSize; i++) {\n      const buffer = buffers[i];\n\n      // we need to keep the order of the incomming frames\n      // so we have to shift all the values in the buffers\n      for (let j = 1; j < size; j++)\n        buffer[j - 1] = buffer[j];\n\n      buffer[size - 1] = data[i];\n\n      if (this.ringIndex >= size)\n        outData[i] = simpleLinearRegression(buffer, dt);\n      else\n        outData[i] = 0;\n    }\n\n    return outData;\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.frame.data = this.inputVector(frame.data);\n    // center time according to delta size\n    const size = this.params.get('size');\n    const frameRate = this.streamParams.frameRate;\n    this.frame.time -= 0.5 * (size - 1) / frameRate;\n  }\n}\n\nexport default Delta;\n\n\n\n\n\n","import BaseLfo from '../../core/BaseLfo';\nimport initWindow from '../utils/windows';\n\n// https://code.soundsoftware.ac.uk/projects/js-dsp-test/repository/entry/fft/nayuki-obj/fft.js\n/*\n * Free Fft and convolution (JavaScript)\n *\n * Copyright (c) 2014 Project Nayuki\n * http://www.nayuki.io/page/free-small-fft-in-multiple-languages\n *\n * (MIT License)\n * Permission is hereby granted, free of charge, to any person obtaining a copy of\n * this software and associated documentation files (the \"Software\"), to deal in\n * the Software without restriction, including without limitation the rights to\n * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n * the Software, and to permit persons to whom the Software is furnished to do so,\n * subject to the following conditions:\n * - The above copyright notice and this permission notice shall be included in\n *   all copies or substantial portions of the Software.\n * - The Software is provided \"as is\", without warranty of any kind, express or\n *   implied, including but not limited to the warranties of merchantability,\n *   fitness for a particular purpose and noninfringement. In no event shall the\n *   authors or copyright holders be liable for any claim, damages or other\n *   liability, whether in an action of contract, tort or otherwise, arising from,\n *   out of or in connection with the Software or the use or other dealings in the\n *   Software.\n *\n * Slightly restructured by Chris Cannam, cannam@all-day-breakfast.com\n *\n * @private\n */\n/*\n * Construct an object for calculating the discrete Fourier transform (DFT) of\n * size n, where n is a power of 2.\n *\n * @private\n */\nfunction FftNayuki(n) {\n\n  this.n = n;\n  this.levels = -1;\n\n  for (var i = 0; i < 32; i++) {\n    if (1 << i == n) {\n      this.levels = i;  // Equal to log2(n)\n    }\n  }\n\n  if (this.levels == -1) {\n    throw \"Length is not a power of 2\";\n  }\n\n  this.cosTable = new Array(n / 2);\n  this.sinTable = new Array(n / 2);\n\n  for (var i = 0; i < n / 2; i++) {\n    this.cosTable[i] = Math.cos(2 * Math.PI * i / n);\n    this.sinTable[i] = Math.sin(2 * Math.PI * i / n);\n  }\n\n  /*\n   * Computes the discrete Fourier transform (DFT) of the given complex vector,\n   * storing the result back into the vector.\n   * The vector's length must be equal to the size n that was passed to the\n   * object constructor, and this must be a power of 2. Uses the Cooley-Tukey\n   * decimation-in-time radix-2 algorithm.\n   *\n   * @private\n   */\n  this.forward = function(real, imag) {\n    var n = this.n;\n\n    // Bit-reversed addressing permutation\n    for (var i = 0; i < n; i++) {\n      var j = reverseBits(i, this.levels);\n\n      if (j > i) {\n        var temp = real[i];\n        real[i] = real[j];\n        real[j] = temp;\n        temp = imag[i];\n        imag[i] = imag[j];\n        imag[j] = temp;\n      }\n    }\n\n    // Cooley-Tukey decimation-in-time radix-2 Fft\n    for (var size = 2; size <= n; size *= 2) {\n      var halfsize = size / 2;\n      var tablestep = n / size;\n\n      for (var i = 0; i < n; i += size) {\n        for (var j = i, k = 0; j < i + halfsize; j++, k += tablestep) {\n          var tpre =  real[j+halfsize] * this.cosTable[k] +\n                      imag[j+halfsize] * this.sinTable[k];\n          var tpim = -real[j+halfsize] * this.sinTable[k] +\n                      imag[j+halfsize] * this.cosTable[k];\n          real[j + halfsize] = real[j] - tpre;\n          imag[j + halfsize] = imag[j] - tpim;\n          real[j] += tpre;\n          imag[j] += tpim;\n        }\n      }\n    }\n\n    // Returns the integer whose value is the reverse of the lowest 'bits'\n    // bits of the integer 'x'.\n    function reverseBits(x, bits) {\n      var y = 0;\n\n      for (var i = 0; i < bits; i++) {\n        y = (y << 1) | (x & 1);\n        x >>>= 1;\n      }\n\n      return y;\n    }\n  }\n\n  /*\n   * Computes the inverse discrete Fourier transform (IDFT) of the given complex\n   * vector, storing the result back into the vector.\n   * The vector's length must be equal to the size n that was passed to the\n   * object constructor, and this must be a power of 2. This is a wrapper\n   * function. This transform does not perform scaling, so the inverse is not\n   * a true inverse.\n   *\n   * @private\n   */\n  this.inverse = function(real, imag) {\n    forward(imag, real);\n  }\n}\n\n\nconst sqrt = Math.sqrt;\n\nconst isPowerOfTwo = function(number) {\n  while ((number % 2 === 0) && number > 1)\n    number = number / 2;\n\n  return number === 1;\n}\n\nconst definitions = {\n  size: {\n    type: 'integer',\n    default: 1024,\n    metas: { kind: 'static' },\n  },\n  window: {\n    type: 'enum',\n    list: ['none', 'hann', 'hanning', 'hamming', 'blackman', 'blackmanharris', 'sine', 'rectangle'],\n    default: 'none',\n    metas: { kind: 'static' },\n  },\n  mode: {\n    type: 'enum',\n    list: ['magnitude', 'power'], // add complex output\n    default: 'magnitude',\n  },\n  norm: {\n    type: 'enum',\n    default: 'auto',\n    list: ['auto', 'none', 'linear', 'power'],\n  },\n}\n\n/**\n * Compute the Fast Fourier Transform of an incomming `signal`.\n *\n * Fft implementation by [Nayuki](https://code.soundsoftware.ac.uk/projects/js-dsp-test/repository/entry/fft/nayuki-obj/fft.js).\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.size=1024] - Size of the fft, should be a power of 2.\n *  If the frame size of the incomming signal is lower than this value,\n *  it is zero padded to match the fft size.\n * @param {String} [options.window='none'] - Name of the window applied on the\n *  incomming signal. Available windows are: 'none', 'hann', 'hanning',\n *  'hamming', 'blackman', 'blackmanharris', 'sine', 'rectangle'.\n * @param {String} [options.mode='magnitude'] - Type of the output (`magnitude`\n *  or `power`)\n * @param {String} [options.norm='auto'] - Type of normalization applied on the\n *  output. Possible values are 'auto', 'none', 'linear', 'power'. When set to\n *  `auto`, a `linear` normalization is applied on the magnitude spectrum, while\n *  a `power` normalization is applied on the power spectrum.\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * // assuming an `audioBuffer` exists\n * const source = new lfo.source.AudioInBuffer({ audioBuffer });\n *\n * const slicer = new lfo.operator.Slicer({\n *   frameSize: 256,\n * });\n *\n * const fft = new lfo.operator.Fft({\n *   mode: 'power',\n *   window: 'hann',\n *   norm: 'power',\n *   size: 256,\n * });\n *\n * source.connect(slicer);\n * slicer.connect(fft);\n * source.start();\n *\n * // > outputs 129 bins containing the values of the power spectrum (including\n * // > DC and Nyuist frequencies).\n *\n * @todo - check if 'rectangle' and 'none' windows are not redondant.\n * @todo - check default values for all params.\n */\nclass Fft extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    this.windowSize = null;\n    this.normalizeCoefs = null;\n    this.window = null;\n    this.real = null;\n    this.imag = null;\n    this.fft = null;\n\n    if (!isPowerOfTwo(this.params.get('size')))\n      throw new Error('fftSize must be a power of two');\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n    // set the output frame size\n    const inFrameSize = prevStreamParams.frameSize;\n    const fftSize = this.params.get('size');\n    const mode = this.params.get('mode');\n    const norm = this.params.get('norm');\n    let windowName = this.params.get('window');\n    // window `none` and `rectangle` are aliases\n    if (windowName === 'none')\n      windowName = 'rectangle';\n\n    this.streamParams.frameSize = fftSize / 2 + 1;\n    this.streamParams.frameType = 'vector';\n    this.streamParams.description = [];\n    // size of the window to apply on the input frame\n    this.windowSize = (inFrameSize < fftSize) ? inFrameSize : fftSize;\n\n    // references to populate in the window functions (cf. `initWindow`)\n    this.normalizeCoefs = { linear: 0, power: 0 };\n    this.window = new Float32Array(this.windowSize);\n\n    initWindow(\n      windowName,         // name of the window\n      this.window,        // buffer populated with the window signal\n      this.windowSize,    // size of the window\n      this.normalizeCoefs // object populated with the normalization coefs\n    );\n\n    const { linear, power } = this.normalizeCoefs;\n\n    switch (norm) {\n      case 'none':\n        this.windowNorm = 1;\n        break;\n\n      case 'linear':\n        this.windowNorm = linear;\n        break;\n\n      case 'power':\n        this.windowNorm = power;\n        break;\n\n      case 'auto':\n        if (mode === 'magnitude')\n          this.windowNorm = linear;\n        else if (mode === 'power')\n          this.windowNorm = power;\n        break;\n    }\n\n    this.real = new Float32Array(fftSize);\n    this.imag = new Float32Array(fftSize);\n    this.fft = new FftNayuki(fftSize);\n\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Use the `Fft` operator in `standalone` mode (i.e. outside of a graph).\n   *\n   * @param {Array} signal - Input values.\n   * @return {Array} - Fft of the input signal.\n   *\n   * @example\n   * const fft = new lfo.operator.Fft({ size: 512, window: 'hann' });\n   * // mandatory for use in standalone mode\n   * fft.initStream({ frameSize: 256, frameType: 'signal' });\n   * fft.inputSignal(signal);\n   */\n  inputSignal(signal) {\n    const mode = this.params.get('mode');\n    const windowSize = this.windowSize;\n    const frameSize = this.streamParams.frameSize;\n    const fftSize = this.params.get('size');\n    const outData = this.frame.data;\n\n    // apply window on the input signal and reset imag buffer\n    for (let i = 0; i < windowSize; i++) {\n      this.real[i] = signal[i] * this.window[i] * this.windowNorm;\n      this.imag[i] = 0;\n    }\n\n    // if real is bigger than input signal, fill with zeros\n    for (let i = windowSize; i < fftSize; i++) {\n      this.real[i] = 0;\n      this.imag[i] = 0;\n    }\n\n    this.fft.forward(this.real, this.imag);\n\n    if (mode === 'magnitude') {\n      const norm = 1 / fftSize;\n\n      // DC index\n      const realDc = this.real[0];\n      const imagDc = this.imag[0];\n      outData[0] = sqrt(realDc * realDc + imagDc * imagDc) * norm;\n\n      // Nquyst index\n      const realNy = this.real[fftSize / 2];\n      const imagNy = this.imag[fftSize / 2];\n      outData[fftSize / 2] = sqrt(realNy * realNy + imagNy * imagNy) * norm;\n\n      // power spectrum\n      for (let i = 1, j = fftSize - 1; i < fftSize / 2; i++, j--) {\n        const real = 0.5 * (this.real[i] + this.real[j]);\n        const imag = 0.5 * (this.imag[i] - this.imag[j]);\n\n        outData[i] = 2 * sqrt(real * real + imag * imag) * norm;\n      }\n\n    } else if (mode === 'power') {\n      const norm = 1 / (fftSize * fftSize);\n\n      // DC index\n      const realDc = this.real[0];\n      const imagDc = this.imag[0];\n      outData[0] = (realDc * realDc + imagDc * imagDc) * norm;\n\n      // Nquyst index\n      const realNy = this.real[fftSize / 2];\n      const imagNy = this.imag[fftSize / 2];\n      outData[fftSize / 2] = (realNy * realNy + imagNy * imagNy) * norm;\n\n      // power spectrum\n      for (let i = 1, j = fftSize - 1; i < fftSize / 2; i++, j--) {\n        const real = 0.5 * (this.real[i] + this.real[j]);\n        const imag = 0.5 * (this.imag[i] - this.imag[j]);\n\n        outData[i] = 4 * (real * real + imag * imag) * norm;\n      }\n    }\n\n    return outData;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.inputSignal(frame.data);\n  }\n}\n\nexport default Fft;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst sqrt = Math.sqrt;\n\nconst definitions = {\n  normalize: {\n    type: 'boolean',\n    default: true,\n    metas: { kind: 'dynamic' },\n  },\n  power: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dynamic' },\n  }\n}\n\n/**\n * Compute the magnitude of a `vector` input.\n *\n * _support `standalone` usage_\n *\n * @param {Object} options - Override default parameters.\n * @param {Boolean} [options.normalize=true] - Normalize output according to\n *  the vector size.\n * @param {Boolean} [options.power=false] - If true, returns the squared\n *  magnitude (power).\n *\n * @memberof module:common.operator\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const eventIn = new lfo.source.EventIn({ frameSize: 2, frameType: 'vector' });\n * const magnitude = new lfo.operator.Magnitude();\n * const logger = new lfo.sink.Logger({ outFrame: true });\n *\n * eventIn.connect(magnitude);\n * magnitude.connect(logger);\n * eventIn.start();\n *\n * eventIn.process(null, [1, 1]);\n * > [1]\n * eventIn.process(null, [2, 2]);\n * > [2.82842712475]\n * eventIn.process(null, [3, 3]);\n * > [4.24264068712]\n */\nclass Magnitude extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    this._normalize = this.params.get('normalize');\n    this._power = this.params.get('power');\n  }\n\n  /** @private */\n  onParamUpdate(name, value, metas) {\n    super.onParamUpdate(name, value, metas);\n\n    switch (name) {\n      case 'normalize':\n        this._normalize = value;\n        break;\n      case 'power':\n        this._power = value;\n        break;\n    }\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n    this.streamParams.frameSize = 1;\n    this.streamParams.frameType = 'scalar';\n    this.streamParams.description = ['magnitude'];\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Use the `Magnitude` operator in `standalone` mode (i.e. outside of a graph).\n   *\n   * @param {Array|Float32Array} values - Values to process.\n   * @return {Number} - Magnitude value.\n   *\n   * @example\n   * import * as lfo from 'waves-lfo/client';\n   *\n   * const magnitude = new lfo.operator.Magnitude({ power: true });\n   * magnitude.initStream({ frameType: 'vector', frameSize: 3 });\n   * magnitude.inputVector([3, 3]);\n   * > 4.24264068712\n   */\n  inputVector(values) {\n    const length = values.length;\n    let sum = 0;\n\n    for (let i = 0; i < length; i++)\n      sum += (values[i] * values[i]);\n\n    let mag = sum;\n\n    if (this._normalize)\n      mag /= length;\n\n    if (!this._power)\n      mag = sqrt(mag);\n\n    return mag;\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.frame.data[0] = this.inputVector(frame.data);\n  }\n}\n\nexport default Magnitude;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst sqrt = Math.sqrt;\n\n/**\n * Compute mean and standard deviation of a given `signal`.\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const audioContext = new AudioContext();\n *\n * navigator.mediaDevices\n *   .getUserMedia({ audio: true })\n *   .then(init)\n *   .catch((err) => console.error(err.stack));\n *\n * function init(stream) {\n *   const source = audioContext.createMediaStreamSource(stream);\n *\n *   const audioInNode = new lfo.source.AudioInNode({\n *     sourceNode: source,\n *     audioContext: audioContext,\n *   });\n *\n *   const meanStddev = new lfo.operator.MeanStddev();\n *\n *   const traceDisplay = new lfo.sink.TraceDisplay({\n *     canvas: '#trace',\n *   });\n *\n *   audioInNode.connect(meanStddev);\n *   meanStddev.connect(traceDisplay);\n *   audioInNode.start();\n * }\n */\nclass MeanStddev extends BaseLfo {\n  constructor(options = {}) {\n    // no options available, just throw an error if some param try to be set.\n    super({}, options);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this.streamParams.frameType = 'vector';\n    this.streamParams.frameSize = 2;\n    this.streamParams.description = ['mean', 'stddev'];\n\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Use the `MeanStddev` operator in `standalone` mode (i.e. outside of a graph).\n   *\n   * @param {Array|Float32Array} values - Values to process.\n   * @return {Array} - Mean and standart deviation of the input values.\n   *\n   * @example\n   * import * as lfo from 'waves-lfo/client';\n   *\n   * const meanStddev = new lfo.operator.MeanStddev();\n   * meanStddev.initStream({ frameType: 'vector', frameSize: 1024 });\n   * meanStddev.inputVector(someSineSignal);\n   * > [0, 0.7071]\n   */\n  inputSignal(values) {\n    const outData = this.frame.data;\n    const length = values.length;\n\n    let mean = 0;\n    let m2 = 0;\n\n    // compute mean and variance with Welford algorithm\n    // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance\n    for (let i = 0; i < length; i++) {\n      const x = values[i];\n      const delta = x - mean;\n      mean += delta / (i + 1);\n      m2 += delta * (x - mean);\n    }\n\n    const variance = m2 / (length - 1);\n    const stddev = sqrt(variance);\n\n    outData[0] = mean;\n    outData[1] = stddev;\n\n    return outData;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.inputSignal(frame.data);\n  }\n}\n\nexport default MeanStddev;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst min = Math.min;\nconst max = Math.max;\nconst pow = Math.pow;\nconst log10 = Math.log10;\n\nfunction hertzToMelHtk(freqHz) {\n  return 2595 * Math.log10(1 + (freqHz / 700));\n}\n\nfunction melToHertzHtk(freqMel) {\n  return 700 * (Math.pow(10, freqMel / 2595) - 1);\n}\n\n/**\n * Returns a description of the weights to apply on the fft bins for each\n * Mel band filter.\n * @note - adapted from imtr-tools/rta\n *\n * @param {Number} nbrBins - Number of fft bins.\n * @param {Number} nbrFilter - Number of mel filters.\n * @param {Number} sampleRate - Sample Rate of the signal.\n * @param {Number} minFreq - Minimum Frequency to be considerered.\n * @param {Number} maxFreq - Maximum frequency to consider.\n * @return {Array<Object>} - Description of the weights to apply on the bins for\n *  each mel filter. Each description has the following structure:\n *  { startIndex: binIndex, centerFreq: binCenterFrequency, weights: [] }\n *\n * @private\n */\nfunction getMelBandWeights(nbrBins, nbrBands, sampleRate, minFreq, maxFreq, type = 'htk') {\n\n  let hertzToMel = null;\n  let melToHertz = null;\n  let minMel;\n  let maxMel;\n\n  if (type === 'htk') {\n    hertzToMel = hertzToMelHtk;\n    melToHertz = melToHertzHtk;\n    minMel = hertzToMel(minFreq);\n    maxMel = hertzToMel(maxFreq);\n  } else {\n    throw new Error(`Invalid mel band type: \"${type}\"`);\n  }\n\n  const melBandDescriptions = new Array(nbrBands);\n  // center frequencies of Fft bins\n  const fftFreqs = new Float32Array(nbrBins);\n  // center frequencies of mel bands - uniformly spaced in mel domain between\n  // limits, there are 2 more frequencies than the actual number of filters in\n  // order to calculate the slopes\n  const filterFreqs = new Float32Array(nbrBands + 2);\n\n  const fftSize = (nbrBins - 1) * 2;\n  // compute bins center frequencies\n  for (let i = 0; i < nbrBins; i++)\n    fftFreqs[i] = sampleRate * i / fftSize;\n\n  for (let i = 0; i < nbrBands + 2; i++)\n    filterFreqs[i] = melToHertz(minMel + i / (nbrBands + 1) * (maxMel - minMel));\n\n  // loop throught filters\n  for (let i = 0; i < nbrBands; i++) {\n    let minWeightIndexDefined = 0;\n\n    const description = {\n      startIndex: null,\n      centerFreq: null,\n      weights: [],\n    }\n\n    // define contribution of each bin for the filter at index (i + 1)\n    // do not process the last spectrum component (Nyquist)\n    for (let j = 0; j < nbrBins - 1; j++) {\n      const posSlopeContrib = (fftFreqs[j] - filterFreqs[i]) /\n                              (filterFreqs[i+1] - filterFreqs[i]);\n\n      const negSlopeContrib = (filterFreqs[i+2] - fftFreqs[j]) /\n                              (filterFreqs[i+2] - filterFreqs[i+1]);\n      // lowerSlope and upper slope intersect at zero and with each other\n      const contribution = max(0, min(posSlopeContrib, negSlopeContrib));\n\n      if (contribution > 0) {\n        if (description.startIndex === null) {\n          description.startIndex = j;\n          description.centerFreq = filterFreqs[i+1];\n        }\n\n        description.weights.push(contribution);\n      }\n    }\n\n    // empty filter\n    if (description.startIndex === null) {\n      description.startIndex = 0;\n      description.centerFreq = 0;\n    }\n\n    // @todo - do some scaling for Slaney-style mel\n    melBandDescriptions[i] = description;\n  }\n\n  return melBandDescriptions;\n}\n\n\nconst definitions = {\n  log: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'static' },\n  },\n  nbrBands: {\n    type: 'integer',\n    default: 24,\n    metas: { kind: 'static' },\n  },\n  minFreq: {\n    type: 'float',\n    default: 0,\n    metas: { kind: 'static' },\n  },\n  maxFreq: {\n    type: 'float',\n    default: null,\n    nullable: true,\n    metas: { kind: 'static' },\n  },\n  power: {\n    type: 'integer',\n    default: 1,\n    metas: { kind: 'dynamic' },\n  },\n};\n\n\n/**\n * Compute the mel bands spectrum from a given spectrum (`vector` type).\n * _Implement the `htk` mel band style._\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Boolean} [options.log=false] - Apply a logarithmic scale on the output.\n * @param {Number} [options.nbrBands=24] - Number of filters defining the mel\n *  bands.\n * @param {Number} [options.minFreq=0] - Minimum frequency to consider.\n * @param {Number} [options.maxFreq=null] - Maximum frequency to consider.\n *  If `null`, is set to Nyquist frequency.\n * @param {Number} [options.power=1] - Apply a power scaling on each mel band.\n *\n * @todo - implement Slaney style mel bands\n *\n * @example\n * import lfo from 'waves-lfo/node'\n *\n * // read a file from path (node only source)\n * const audioInFile = new lfo.source.AudioInFile({\n *   filename: 'path/to/file',\n *   frameSize: 512,\n * });\n *\n * const slicer = new lfo.operator.Slicer({\n *   frameSize: 256,\n *   hopSize: 256,\n * });\n *\n * const fft = new lfo.operator.Fft({\n *   size: 1024,\n *   window: 'hann',\n *   mode: 'power',\n *   norm: 'power',\n * });\n *\n * const mel = new lfo.operator.Mel({\n *   log: true,\n *   nbrBands: 24,\n * });\n *\n * const logger = new lfo.sink.Logger({ data: true });\n *\n * audioInFile.connect(slicer);\n * slicer.connect(fft);\n * fft.connect(mel);\n * mel.connect(logger);\n *\n * audioInFile.start();\n */\nclass Mel extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const nbrBins = prevStreamParams.frameSize;\n    const nbrBands = this.params.get('nbrBands');\n    const sampleRate = this.streamParams.sourceSampleRate;\n    const minFreq = this.params.get('minFreq');\n    let maxFreq = this.params.get('maxFreq');\n\n    //\n    this.streamParams.frameSize = nbrBands;\n    this.streamParams.frameType = 'vector';\n    this.streamParams.description = [];\n\n    if (maxFreq === null)\n      maxFreq = this.streamParams.sourceSampleRate / 2;\n\n    this.melBandDescriptions = getMelBandWeights(nbrBins, nbrBands, sampleRate, minFreq, maxFreq);\n\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Use the `Mel` operator in `standalone` mode (i.e. outside of a graph).\n   *\n   * @param {Array} spectrum - Fft bins.\n   * @return {Array} - Mel bands.\n   *\n   * @example\n   * const mel = new lfo.operator.Mel({ nbrBands: 24 });\n   * // mandatory for use in standalone mode\n   * mel.initStream({ frameSize: 256, frameType: 'vector', sourceSampleRate: 44100 });\n   * mel.inputVector(fftBins);\n   */\n  inputVector(bins) {\n\n    const power = this.params.get('power');\n    const log = this.params.get('log');\n    const melBands = this.frame.data;\n    const nbrBands = this.streamParams.frameSize;\n    let scale = 1;\n\n    const minLogValue = 1e-48;\n    const minLog = -480;\n\n    if (log)\n      scale *= nbrBands;\n\n    for (let i = 0; i < nbrBands; i++) {\n      const { startIndex, weights } = this.melBandDescriptions[i];\n      let value = 0;\n\n      for (let j = 0; j < weights.length; j++)\n        value += weights[j] * bins[startIndex + j];\n\n      // apply same logic as in PiPoBands\n      if (scale !== 1)\n        value *= scale;\n\n      if (log) {\n        if (value > minLogValue)\n          value = 10 * log10(value);\n        else\n          value = minLog;\n      }\n\n      if (power !== 1)\n        value = pow(value, power);\n\n      melBands[i] = value;\n    }\n\n    return melBands;\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.inputVector(frame.data);\n  }\n}\n\nexport default Mel;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  // array defining the frameSizes of the input streamss\n  // e.g. if [3, 2, 1], we wait for 3 different sources of respective 3, 2, 1 frameSizes\n  frameSizes: {\n    type: 'any',\n    default: null,\n    constant: true,\n  }\n}\n\n/**\n * Merge multiple vector frames. The order of execution depends on the\n * order the branching was initially made. The first branche is master\n * on the time and trigger the output of the frame.\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters\n * @param {Array} [options.frameSizes=null] - Array that defines the number\n *  of values to pick from each incomming vectors.\n *\n * @example\n * import * as lfo from 'waves-lfo/comon'\n *\n * const eventIn = new lfo.operator.EventIn({\n *   type: 'vector',\n *   frameSize: 4,\n *   frameRate: 0,\n * });\n *\n * const minMax = new lfo.operator.MinMax();\n * const magnitude = new lfo.operator.Magnitude();\n *\n * // take the first 2 values of the first branch and 1 value from the second branch\n * const merge = new lfo.operator.Merger({ frameSizes: [2, 1] });\n *\n * // this defines the order in which Merger will be called\n * eventIn.connect(minMax);\n * eventIn.connect(magnitude);\n *\n * minMax.connect(merger);\n * magnitude.connect(merger);\n */\nclass Merger extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n  }\n\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    // ...\n    const frameSizes = this.params.get('frameSizes');\n    const numSources = frameSizes.length;\n\n    let frameSize = 0;\n    for (let i = 0; i < numSources; i++)\n      frameSize += frameSizes[i];\n\n\n    this.streamParams.frameSize = frameSize;\n    this.numSources = numSources;\n    this.sourceIndex = 0;\n\n    this.propagateStreamParams();\n  }\n\n  processVector() {}\n  // processSignal() {} // makes no sens to merge signals (maybe MUX / DEMUX)\n\n  processFrame(frame) {\n    const currentIndex = this.sourceIndex;\n    const frameSizes = this.params.get('frameSizes');\n    const numSources = frameSizes.length;\n    const input = frame.data;\n    const output = this.frame.data;\n\n    // first source define time\n    if (currentIndex === 0)\n      this.frame.time = frame.time;\n\n    const currentFrameSize = frameSizes[currentIndex];\n    let offset = 0;\n\n    for (let i = 0; i < currentIndex; i++)\n      offset += frameSizes[i];\n\n    // copy data\n    for (let i = 0; i < currentFrameSize; i++)\n      output[offset + i] = input[i];\n\n    this.sourceIndex = (this.sourceIndex + 1) % numSources;\n\n    // we just received the last input, output the frame\n    if (this.sourceIndex === 0)\n      this.propagateFrame();\n  }\n}\n\nexport default Merger;\n","import BaseLfo from '../../core/BaseLfo';\nimport Fft from './Fft';\nimport Mel from './Mel';\nimport Dct from './Dct';\n\n\nconst definitions = {\n  nbrBands: {\n    type: 'integer',\n    default: 24,\n    meta: { kind: 'static' },\n  },\n  nbrCoefs: {\n    type: 'integer',\n    default: 12,\n    meta: { kind: 'static' },\n  },\n  minFreq: {\n    type: 'float',\n    default: 0,\n    meta: { kind: 'static' },\n  },\n  maxFreq: {\n    type: 'float',\n    default: null,\n    nullable: true,\n    meta: { kind: 'static' },\n  }\n};\n\n\n/**\n * Compute the Mfcc of the incomming `signal`. Is basically a wrapper around\n * [`Fft`]{@link module:common.operator.Fft}, [`Mel`]{@link module:common.operator.Mel}\n * and [`Dct`]{@link module:common.operator.Dct}.\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {nbrBands} [options.nbrBands=24] - Number of Mel bands.\n * @param {nbrCoefs} [options.nbrCoefs=12] - Number of output coefs.\n *\n * @see {@link module:common.operator.Fft}\n * @see {@link module:common.operator.Mel}\n * @see {@link module:common.operator.Dct}\n *\n * @example\n * import lfo from 'waves-lfo/node'\n *\n * const audioInFile = new lfo.source.AudioInFile({\n *   filename: 'path/to/file',\n *   frameSize: 512,\n * });\n *\n * const slicer = new lfo.operator.Slicer({\n *   frameSize: 256,\n * });\n *\n * const mfcc = new lfo.operator.Mfcc({\n *   nbrBands: 24,\n *   nbrCoefs: 12,\n * });\n *\n * const logger = new lfo.sink.Logger({ data: true });\n *\n * audioInFile.connect(slicer);\n * slicer.connect(mfcc);\n * mfcc.connect(logger);\n *\n * audioInFile.start();\n */\nclass Mfcc extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const nbrBands = this.params.get('nbrBands');\n    const nbrCoefs = this.params.get('nbrCoefs');\n    const minFreq = this.params.get('minFreq');\n    const maxFreq = this.params.get('maxFreq');\n    const inputFrameSize = prevStreamParams.frameSize;\n    const inputFrameRate = prevStreamParams.frameRate;\n    const inputSampleRate = prevStreamParams.sourceSampleRate;\n    const nbrBins = inputFrameSize / 2 + 1;\n\n    this.streamParams.frameSize = nbrCoefs;\n    this.streamParams.frameType = 'vector';\n    this.streamParams.description = [];\n\n    this.fft = new Fft({\n      window: 'hann',\n      mode: 'power',\n      norm: 'power',\n      size: inputFrameSize,\n    });\n\n    this.mel = new Mel({\n      nbrBands: nbrBands,\n      log: true,\n      power: 1,\n      minFreq: minFreq,\n      maxFreq: maxFreq,\n    });\n\n    this.dct = new Dct({\n      order: nbrCoefs,\n    });\n\n    // init streams\n    this.fft.initStream({\n      frameType: 'signal',\n      frameSize: inputFrameSize,\n      frameRate: inputFrameRate,\n      sourceSampleRate: inputSampleRate,\n    });\n\n    this.mel.initStream({\n      frameType: 'vector',\n      frameSize: nbrBins,\n      frameRate: inputFrameRate,\n      sourceSampleRate: inputSampleRate,\n    });\n\n    this.dct.initStream({\n      frameType: 'vector',\n      frameSize: nbrBands,\n      frameRate: inputFrameRate,\n      sourceSampleRate: inputSampleRate,\n    });\n\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Use the `Mfcc` operator in `standalone` mode (i.e. outside of a graph).\n   *\n   * @param {Array} data - Signal chunk to analyse.\n   * @return {Array} - Mfcc coefficients.\n   *\n   * @example\n   * const mfcc = new lfo.operator.Mfcc();\n   * // mandatory for use in standalone mode\n   * mfcc.initStream({ frameSize: 256, frameType: 'vector' });\n   * mfcc.inputSignal(signal);\n   */\n  inputSignal(data) {\n    const output = this.frame.data;\n    const nbrCoefs = this.params.get('nbrCoefs');\n\n    const bins = this.fft.inputSignal(data);\n    const melBands = this.mel.inputVector(bins);\n    // console.log(melBands);\n    const coefs = this.dct.inputSignal(melBands);\n\n    for (let i = 0; i < nbrCoefs; i++)\n      output[i] = coefs[i];\n\n    return output;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.inputSignal(frame.data);\n  }\n}\n\nexport default Mfcc;\n","import BaseLfo from '../../core/BaseLfo';\n\n/**\n * Find minimun and maximum values of a given `signal`.\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameSize: 512,\n *   frameType: 'signal',\n *   sampleRate: 0,\n * });\n *\n * const minMax = new lfo.operator.MinMax();\n *\n * const logger = new lfo.sink.Logger({ data: true });\n *\n * eventIn.connect(minMax);\n * minMax.connect(logger);\n * eventIn.start()\n *\n * // create a frame\n * const signal = new Float32Array(512);\n * for (let i = 0; i < 512; i++)\n *   signal[i] = i + 1;\n *\n * eventIn.process(null, signal);\n * > [1, 512];\n */\nclass MinMax extends BaseLfo {\n  constructor(options = {}) {\n    // throw errors if options are given\n    super({}, options);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams = {}) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this.streamParams.frameType = 'vector';\n    this.streamParams.frameSize = 2;\n    this.streamParams.description = ['min', 'max'];\n\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Use the `MinMax` operator in `standalone` mode (i.e. outside of a graph).\n   *\n   * @param {Float32Array|Array} data - Input signal.\n   * @return {Array} - Min and max values.\n   *\n   * @example\n   * const minMax = new MinMax();\n   * minMax.initStream({ frameType: 'signal', frameSize: 10 });\n   *\n   * minMax.inputSignal([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);\n   * > [0, 5]\n   */\n  inputSignal(data) {\n    const outData = this.frame.data;\n    let min = +Infinity;\n    let max = -Infinity;\n\n    for (let i = 0, l = data.length; i < l; i++) {\n      const value = data[i];\n      if (value < min) min = value;\n      if (value > max) max = value;\n    }\n\n    outData[0] = min;\n    outData[1] = max;\n\n    return outData;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.inputSignal(frame.data);\n  }\n}\n\nexport default MinMax;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  order: {\n    type: 'integer',\n    min: 1,\n    max: 1e9,\n    default: 10,\n    metas: { kind: 'dynamic' }\n  },\n  fill: {\n    type: 'float',\n    min: -Infinity,\n    max: +Infinity,\n    default: 0,\n    metas: { kind: 'dynamic' },\n  },\n};\n\n/**\n * Compute a moving average operation on the incomming frames (`scalar` or\n * `vector` type). If the input is of type vector, the moving average is\n * computed for each dimension in parallel. If the source sample rate is defined\n * frame time is shifted to the middle of the window defined by the order.\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.order=10] - Number of successive values on which\n *  the average is computed.\n * @param {Number} [options.fill=0] - Value to fill the ring buffer with before\n *  the first input frame.\n *\n * @todo - Implement `processSignal` ?\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameSize: 2,\n *   frameType: 'vector'\n * });\n *\n * const movingAverage = new lfo.operator.MovingAverage({\n *   order: 5,\n *   fill: 0\n * });\n *\n * const logger = new lfo.sink.Logger({ data: true });\n *\n * eventIn.connect(movingAverage);\n * movingAverage.connect(logger);\n *\n * eventIn.start();\n *\n * eventIn.process(null, [1, 1]);\n * > [0.2, 0.2]\n * eventIn.process(null, [1, 1]);\n * > [0.4, 0.4]\n * eventIn.process(null, [1, 1]);\n * > [0.6, 0.6]\n * eventIn.process(null, [1, 1]);\n * > [0.8, 0.8]\n * eventIn.process(null, [1, 1]);\n * > [1, 1]\n */\nclass MovingAverage extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    this.sum = null;\n    this.ringBuffer = null;\n    this.ringIndex = 0;\n  }\n\n  /** @private */\n  onParamUpdate(name, value, metas) {\n    super.onParamUpdate(name, value, metas);\n\n    // @todo - should be done lazily in process\n    switch (name) {\n      case 'order':\n        this.processStreamParams();\n        this.resetStream();\n        break;\n      case 'fill':\n        this.resetStream();\n        break;\n    }\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const frameSize = this.streamParams.frameSize;\n    const order = this.params.get('order');\n\n    this.ringBuffer = new Float32Array(order * frameSize);\n\n    if (frameSize > 1)\n      this.sum = new Float32Array(frameSize);\n    else\n      this.sum = 0;\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  resetStream() {\n    super.resetStream();\n\n    const order = this.params.get('order');\n    const fill = this.params.get('fill');\n    const ringBuffer = this.ringBuffer;\n    const ringLength = ringBuffer.length;\n\n    for (let i = 0; i < ringLength; i++)\n      ringBuffer[i] = fill;\n\n    const fillSum = order * fill;\n    const frameSize = this.streamParams.frameSize;\n\n    if (frameSize > 1) {\n      for (let i = 0; i < frameSize; i++)\n        this.sum[i] = fillSum;\n    } else {\n      this.sum = fillSum;\n    }\n\n    this.ringIndex = 0;\n  }\n\n  /** @private */\n  processScalar(frame) {\n    this.frame.data[0] = this.inputScalar(frame.data[0]);\n  }\n\n  /**\n   * Use the `MovingAverage` operator in `standalone` mode (i.e. outside of a\n   * graph) with a `scalar` input.\n   *\n   * @param {Number} value - Value to feed the moving average with.\n   * @return {Number} - Average value.\n   *\n   * @example\n   * import * as lfo from 'waves-lfo/client';\n   *\n   * const movingAverage = new lfo.operator.MovingAverage({ order: 5 });\n   * movingAverage.initStream({ frameSize: 1, frameType: 'scalar' });\n   *\n   * movingAverage.inputScalar(1);\n   * > 0.2\n   * movingAverage.inputScalar(1);\n   * > 0.4\n   * movingAverage.inputScalar(1);\n   * > 0.6\n   */\n  inputScalar(value) {\n    const order = this.params.get('order');\n    const ringIndex = this.ringIndex;\n    const ringBuffer = this.ringBuffer;\n    let sum = this.sum;\n\n    sum -= ringBuffer[ringIndex];\n    sum += value;\n\n    this.sum = sum;\n    this.ringBuffer[ringIndex] = value;\n    this.ringIndex = (ringIndex + 1) % order;\n\n    return sum / order;\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.inputVector(frame.data);\n  }\n\n  /**\n   * Use the `MovingAverage` operator in `standalone` mode (i.e. outside of a\n   * graph) with a `vector` input.\n   *\n   * @param {Array} values - Values to feed the moving average with.\n   * @return {Float32Array} - Average value for each dimension.\n   *\n   * @example\n   * import * as lfo from 'waves-lfo/client';\n   *\n   * const movingAverage = new lfo.operator.MovingAverage({ order: 5 });\n   * movingAverage.initStream({ frameSize: 2, frameType: 'scalar' });\n   *\n   * movingAverage.inputArray([1, 1]);\n   * > [0.2, 0.2]\n   * movingAverage.inputArray([1, 1]);\n   * > [0.4, 0.4]\n   * movingAverage.inputArray([1, 1]);\n   * > [0.6, 0.6]\n   */\n  inputVector(values) {\n    const order = this.params.get('order');\n    const outFrame = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    const ringIndex = this.ringIndex;\n    const ringOffset = ringIndex * frameSize;\n    const ringBuffer = this.ringBuffer;\n    const sum = this.sum;\n    const scale = 1 / order;\n\n    for (let i = 0; i < frameSize; i++) {\n      const ringBufferIndex = ringOffset + i;\n      const value = values[i];\n      let localSum = sum[i];\n\n      localSum -= ringBuffer[ringBufferIndex];\n      localSum += value;\n\n      this.sum[i] = localSum;\n      outFrame[i] = localSum * scale;\n      ringBuffer[ringBufferIndex] = value;\n    }\n\n    this.ringIndex = (ringIndex + 1) % order;\n\n    return outFrame;\n  }\n\n  /** @private */\n  processFrame(frame) {\n    this.prepareFrame();\n    this.processFunction(frame);\n\n    const order = this.params.get('order');\n    let time = frame.time;\n    // shift time to take account of the added latency\n    if (this.streamParams.sourceSampleRate)\n      time -= (0.5 * (order - 1) / this.streamParams.sourceSampleRate);\n\n    this.frame.time = time;\n    this.frame.metadata = frame.metadata;\n\n    this.propagateFrame();\n  }\n}\n\nexport default MovingAverage;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  order: {\n    type: 'integer',\n    min: 1,\n    max: 1e9,\n    default: 9,\n    metas: { kind: 'static' },\n  },\n  fill: {\n    type: 'float',\n    min: -Infinity,\n    max: +Infinity,\n    default: 0,\n    metas: { kind: 'static' },\n  },\n};\n\n/**\n * Compute a moving median operation on the incomming frames (`scalar` or\n * `vector` type). If the input is of type vector, the moving median is\n * computed for each dimension in parallel. If the source sample rate is defined\n * frame time is shifted to the middle of the window defined by the order.\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.order=9] - Number of successive values in which\n *  the median is searched. This value must be odd. _dynamic parameter_\n * @param {Number} [options.fill=0] - Value to fill the ring buffer with before\n *  the first input frame. _dynamic parameter_\n *\n * @todo - Implement `processSignal`\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameSize: 2,\n *   frameType: 'vector',\n * });\n *\n * const movingMedian = new lfo.operator.MovingMedian({\n *   order: 5,\n *   fill: 0,\n * });\n *\n * const logger = new lfo.sink.Logger({ data: true });\n *\n * eventIn.connect(movingMedian);\n * movingMedian.connect(logger);\n *\n * eventIn.start();\n *\n * eventIn.processFrame(null, [1, 1]);\n * > [0, 0]\n * eventIn.processFrame(null, [2, 2]);\n * > [0, 0]\n * eventIn.processFrame(null, [3, 3]);\n * > [1, 1]\n * eventIn.processFrame(null, [4, 4]);\n * > [2, 2]\n * eventIn.processFrame(null, [5, 5]);\n * > [3, 3]\n */\nclass MovingMedian extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    this.ringBuffer = null;\n    this.sortBuffer = null;\n    this.ringIndex = 0;\n\n    this._ensureOddOrder();\n  }\n\n  /** @private */\n  _ensureOddOrder() {\n    if (this.params.get('order') % 2 === 0)\n      throw new Error(`Invalid value ${order} for param \"order\" - must be odd`);\n  }\n\n  /** @private */\n  onParamUpdate(name, value, metas) {\n    super.onParamUpdate(name, value, metas);\n\n    switch (name) {\n      case 'order':\n        this._ensureOddOrder();\n        this.processStreamParams();\n        this.resetStream();\n        break;\n      case 'fill':\n        this.resetStream();\n        break;\n    }\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n    // outType is similar to input type\n\n    const frameSize = this.streamParams.frameSize;\n    const order = this.params.get('order');\n\n    this.ringBuffer = new Float32Array(frameSize * order);\n    this.sortBuffer = new Float32Array(frameSize * order);\n\n    this.minIndices = new Uint32Array(frameSize);\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  resetStream() {\n    super.resetStream();\n\n    const fill = this.params.get('fill');\n    const ringBuffer = this.ringBuffer;\n    const ringLength = ringBuffer.length;\n\n    for (let i = 0; i < ringLength; i++)\n      this.ringBuffer[i] = fill;\n\n    this.ringIndex = 0;\n  }\n\n  /** @private */\n  processScalar(frame) {\n    this.frame.data[0] = this.inputScalar(frame.data[0]);\n  }\n\n  /**\n   * Allows for the use of a `MovingMedian` outside a graph (e.g. inside\n   * another node), in this case `processStreamParams` and `resetStream`\n   * should be called manually on the node.\n   *\n   * @param {Number} value - Value to feed the moving median with.\n   * @return {Number} - Median value.\n   *\n   * @example\n   * import * as lfo from 'waves-lfo/client';\n   *\n   * const movingMedian = new MovingMedian({ order: 5 });\n   * movingMedian.initStream({ frameSize: 1, frameType: 'scalar' });\n   *\n   * movingMedian.inputScalar(1);\n   * > 0\n   * movingMedian.inputScalar(2);\n   * > 0\n   * movingMedian.inputScalar(3);\n   * > 1\n   * movingMedian.inputScalar(4);\n   * > 2\n   */\n  inputScalar(value) {\n    const ringIndex = this.ringIndex;\n    const ringBuffer = this.ringBuffer;\n    const sortBuffer = this.sortBuffer;\n    const order = this.params.get('order');\n    const medianIndex = (order - 1) / 2;\n    let startIndex = 0;\n\n    ringBuffer[ringIndex] = value;\n\n    for (let i = 0; i <= medianIndex; i++) {\n      let min = +Infinity;\n      let minIndex = null;\n\n      for (let j = startIndex; j < order; j++) {\n        if (i === 0)\n          sortBuffer[j] = ringBuffer[j];\n\n        if (sortBuffer[j] < min) {\n          min = sortBuffer[j];\n          minIndex = j;\n        }\n      }\n\n      // swap minIndex and startIndex\n      const cache = sortBuffer[startIndex];\n      sortBuffer[startIndex] = sortBuffer[minIndex];\n      sortBuffer[minIndex] = cache;\n\n      startIndex += 1;\n    }\n\n    const median = sortBuffer[medianIndex];\n    this.ringIndex = (ringIndex + 1) % order;\n\n    return median;\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.inputVector(frame.data);\n  }\n\n  /**\n   * Allows for the use of a `MovingMedian` outside a graph (e.g. inside\n   * another node), in this case `processStreamParams` and `resetStream`\n   * should be called manually on the node.\n   *\n   * @param {Array} values - Values to feed the moving median with.\n   * @return {Float32Array} - Median values for each dimension.\n   *\n   * @example\n   * import * as lfo from 'waves-lfo/client';\n   *\n   * const movingMedian = new MovingMedian({ order: 3, fill: 0 });\n   * movingMedian.initStream({ frameSize: 3, frameType: 'vector' });\n   *\n   * movingMedian.inputArray([1, 1]);\n   * > [0, 0]\n   * movingMedian.inputArray([2, 2]);\n   * > [1, 1]\n   * movingMedian.inputArray([3, 3]);\n   * > [2, 2]\n   */\n  inputVector(values) {\n    const order = this.params.get('order');\n    const ringBuffer = this.ringBuffer;\n    const ringIndex = this.ringIndex;\n    const sortBuffer = this.sortBuffer;\n    const outFrame = this.frame.data;\n    const minIndices = this.minIndices;\n    const frameSize = this.streamParams.frameSize;\n    const medianIndex = Math.floor(order / 2);\n    let startIndex = 0;\n\n    for (let i = 0; i <= medianIndex; i++) {\n\n      for (let j = 0; j < frameSize; j++) {\n        outFrame[j] = +Infinity;\n        minIndices[j] = 0;\n\n        for (let k = startIndex; k < order; k++) {\n          const index = k * frameSize + j;\n\n          // update ring buffer corresponding to current\n          if (k === ringIndex && i === 0)\n            ringBuffer[index] = values[j];\n\n          // copy value in sort buffer on first pass\n          if (i === 0) \n            sortBuffer[index] = ringBuffer[index];\n\n          // find minium in the remaining array\n          if (sortBuffer[index] < outFrame[j]) {\n            outFrame[j] = sortBuffer[index];\n            minIndices[j] = index;\n          }\n        }\n\n        // swap minimum and curent index\n        const swapIndex = startIndex * frameSize + j;\n        const v = sortBuffer[swapIndex];\n        sortBuffer[swapIndex] = sortBuffer[minIndices[j]];\n        sortBuffer[minIndices[j]] = v;\n\n        // store this minimum value as current result\n        outFrame[j] = sortBuffer[swapIndex];\n      }\n\n      startIndex += 1;\n    }\n\n    this.ringIndex = (ringIndex + 1) % order;\n\n    return this.frame.data;\n  }\n\n  /** @private */\n  processFrame(frame) {\n    this.preprocessFrame();\n    this.processFunction(frame);\n\n    const order = this.params.get('order');\n    let time = frame.time;\n    // shift time to take account of the added latency\n    if (this.streamParams.sourceSampleRate)\n      time -= (0.5 * (order - 1) / this.streamParams.sourceSampleRate);\n\n    this.frame.time = time;\n    this.frame.metadata = frame.metadata;\n\n    this.propagateFrame(time, this.outFrame, metadata);\n  }\n}\n\nexport default MovingMedian;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  // float or array\n  factor: {\n    type: 'any',\n    default: 1,\n  }\n};\n\n/**\n * Multiply a given signal or vector by a given factor. On vector\n * streams, `factor` can be an array of values to apply on each dimension of the\n * vector frames.\n *\n * _support `standalone` usage_\n *\n * @param {Object} options - override default values\n * @param {Number|Array} [options.factor=1] - factor or array of factor to\n *  apply on the incomming frame. Setting an array is only defined in case of\n *  a vector stream.\n *\n * @memberof module:common.operator\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const eventIn = new lfo.operator.EventIn({\n *   type: 'vector',\n *   frameSize: 2,\n *   frameRate: 0,\n * });\n * const scaler = new lfo.operator.Multiplier({ factor: 0.1 });\n *\n * eventIn.connect(scaler);\n *\n * eventIn.process(null, [2, 3]);\n * > [0.2, 0.3]\n */\nclass Multiplier extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n  }\n\n  /**\n   * Use the `Multiplier` operator in standalone mode.\n   *\n   * @param {Float32Array|Array} data - Input vector\n   * @return {Array} - Scaled values\n   *\n   * @example\n   * const scaler = new Multiplier({ factor: [2, 4] });\n   * scaler.initStream({ frameType: 'vector', frameSize: 2 });\n   *\n   * scaler.inputVector([3, 2]);\n   * > [6, 8]\n   */\n  inputVector(data) {\n    const output = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    const factor = this.params.get('factor');\n\n    if (Array.isArray(factor)) {\n      for (let i = 0; i < frameSize; i++)\n        output[i] = data[i] * factor[i];\n    } else {\n      for (let i = 0; i < frameSize; i++)\n        output[i] = data[i] * factor;\n    }\n\n    return output;\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.frame.data = this.inputVector(frame.data);\n  }\n\n  /**\n   * Use the `Multiplier` operator in standalone mode.\n   *\n   * @param {Float32Array|Array} data - Input signal.\n   * @return {Array} - Scaled signal.\n   *\n   * @example\n   * const scaler = new Multiplier({ factor: 0.1 });\n   * scaler.initStream({ frameType: 'signal', frameSize: 2 });\n   *\n   * scaler.inputVector([1, 2]);\n   * > [0.1, 0.2]\n   */\n  inputSignal(data) {\n    const output = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    const factor = this.params.get('factor');\n\n    for (let i = 0; i < frameSize; i++)\n      output[i] = data[i] * factor;\n\n    return output;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.frame.data = this.inputSignal(frame.data);\n  }\n}\n\nexport default Multiplier;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  state: {\n    type: 'enum',\n    default: 'on',\n    list: ['on', 'off'],\n    metas: { kind: 'dynamic' },\n  },\n};\n\n/**\n * The OnOff operator allows to stop the propagation of the stream in a\n * subgraph. When \"on\", frames are propagated, when \"off\" the propagation is\n * stopped.\n *\n * The `streamParams` propagation is never bypassed so the subsequent subgraph\n * is always ready for incomming frames.\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {String} [options.state='on'] - Default state.\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const frames = [\n *   { time: 0, data: [1, 2] },\n *   { time: 1, data: [3, 4] },\n *   { time: 2, data: [5, 6] },\n * ];\n *\n * const eventIn = new EventIn({\n *   frameSize: 2,\n *   frameRate: 0,\n *   frameType: 'vector',\n * });\n *\n * const onOff = new OnOff();\n *\n * const logger = new Logger({ data: true });\n *\n * eventIn.connect(onOff);\n * onOff.connect(logger);\n *\n * eventIn.start();\n *\n * eventIn.processFrame(frames[0]);\n * > [0, 1]\n *\n * // bypass subgraph\n * onOff.setState('off');\n * eventIn.processFrame(frames[1]);\n *\n * // re-open subgraph\n * onOff.setState('on');\n * eventIn.processFrame(frames[2]);\n * > [5, 6]\n */\nclass OnOff extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    this.state = this.params.get('state');\n  }\n\n  /**\n   * Set the state of the `OnOff`.\n   *\n   * @param {String} state - New state of the operator (`on` or `off`)\n   */\n  setState(state) {\n    if (definitions.state.list.indexOf(state) === -1)\n      throw new Error(`Invalid switch state value \"${state}\" [valid values: \"on\"/\"off\"]`);\n\n    this.state = state;\n  }\n\n  // define all possible stream API\n  /** @private */\n  processScalar() {}\n  /** @private */\n  processVector() {}\n  /** @private */\n  processSignal() {}\n\n  /** @private */\n  processFrame(frame) {\n    if (this.state === 'on') {\n      this.prepareFrame();\n\n      this.frame.time = frame.time;\n      this.frame.metadata = frame.metadata;\n      this.frame.data = frame.data;\n\n      this.propagateFrame();\n    }\n  }\n}\n\nexport default OnOff;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  exponent: {\n    type: 'float',\n    default: 1,\n  },\n};\n\n/**\n * Apply an exponant power to the stream.\n *\n * @param {Object} options - Override default parameters\n * @param {Number} exponent - Exponent\n */\nclass Power extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n  }\n\n  inputVector(data) {\n    const outData = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    const exponent = this.params.get('exponent');\n\n    for (let i = 0; i < frameSize; i++)\n      outData[i] = Math.pow(data[i], exponent);\n\n    return outData;\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.inputVector(frame.data);\n  }\n\n  inputSignal(data) {\n    const outData = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    const exponent = this.params.get('exponent');\n\n    for (let i = 0; i < frameSize; i++)\n      outData[i] = Math.pow(data[i], exponent);\n\n    return outData;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.inputSignal(frame.data);\n  }\n}\n\nexport default Power;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst sqrt = Math.sqrt;\n\nconst definitions = {\n  power: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dynamic' },\n  },\n};\n\n/**\n * Compute the Root Mean Square of a `signal`.\n *\n * _support `standalone` usage_\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Boolean} [options.power=false] - If `true` remove the \"R\" of the\n *  \"Rms\" and return the squared result (i.e. power).\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * // assuming some `AudioBuffer`\n * const audioInBuffer = new lfo.source.AudioInBuffer({\n *   audioBuffer: audioBuffer,\n *   frameSize: 512,\n * });\n *\n * const rms = new lfo.operator.Rms();\n * const logger = new lfo.sink.Logger({ data: true });\n *\n * audioInBuffer.connect(rms);\n * rms.connect(logger);\n *\n * audioInBuffer.start();\n */\nclass Rms extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this.streamParams.frameSize = 1;\n    this.streamParams.frameType = 'scalar';\n    this.streamParams.description = ['rms'];\n\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Allows for the use of a `Rms` outside a graph (e.g. inside\n   * another node). Return the rms of the given signal block.\n   *\n   * @param {Number} signal - Signal block to be computed.\n   * @return {Number} - rms of the input signal.\n   *\n   * @example\n   * import * as lfo from 'waves-lfo/client';\n   *\n   * const rms = new lfo.operator.Rms();\n   * rms.initStream({ frameType: 'signal', frameSize: 1000 });\n   *\n   * const results = rms.inputSignal([...values]);\n   */\n  inputSignal(signal) {\n    const power = this.params.get('power');\n    const length = signal.length;\n    let rms = 0;\n\n    for (let i = 0; i < length; i++)\n      rms += (signal[i] * signal[i]);\n\n    rms = rms / length;\n\n    if (!power)\n      rms = sqrt(rms);\n\n    return rms;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.frame.data[0] = this.inputSignal(frame.data);\n  }\n}\n\nexport default Rms;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  type: {\n    type: 'enum',\n    list: ['linear'],\n    default: 'linear',\n    metas: {\n      kind: 'dynamic',\n    }\n  },\n  inputMin: {\n    type: 'float',\n    default: 0,\n    min: -Infinity,\n    max: +Infinity,\n    metas: {\n      kind: 'dynamic',\n    },\n  },\n  inputMax: {\n    type: 'float',\n    default: 1,\n    min: -Infinity,\n    max: +Infinity,\n    metas: {\n      kind: 'dynamic',\n    },\n  },\n  outputMin: {\n    type: 'float',\n    default: 1,\n    min: -Infinity,\n    max: +Infinity,\n    metas: {\n      kind: 'dynamic',\n    },\n  },\n  outputMax: {\n    type: 'float',\n    default: 1,\n    min: -Infinity,\n    max: +Infinity,\n    metas: {\n      kind: 'dynamic',\n    },\n  },\n}\n\n/**\n * Apply a linear scale on the incomming stream. The output is not clipped.\n *\n * @todo - implement log and exp scale\n *\n * @param {Object} options - Override default options\n * @param {Number} [options.inputMin=0] - Input Minimum\n * @param {Number} [options.inputMax=1] - Input Maximum\n * @param {Number} [options.outputMin=0] - Output Minimum\n * @param {Number} [options.outputMax=1] - Output Maximum\n */\nclass Scale extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n\n    this.scale = null;\n  }\n\n  /** @private */\n  _setScaleFunction() {\n    const inputMin = this.params.get('inputMin');\n    const inputMax = this.params.get('inputMax');\n    const outputMin = this.params.get('outputMin');\n    const outputMax = this.params.get('outputMax');\n\n    const a = (outputMax - outputMin) / (inputMax - inputMin);\n    const b = outputMin - a * inputMin;\n\n    this.scale = (x) => a * x + b;\n  }\n\n  /** @private */\n  onParamUpdate(name, value, metas) {\n    super.onParamUpdate(name, value, metas);\n\n    if (name !== 'type')\n      this._setScaleFunction();\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this._setScaleFunction();\n\n    this.propagateStreamParams();\n  }\n\n  inputVector(data) {\n    const outData = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    const scale = this.scale;\n\n    for (let i = 0; i < frameSize; i++)\n      outData[i] = scale(data[i]);\n\n    return outData;\n  }\n\n  /** @private */\n  processVector(frame) {\n    this.frame.data = this.inputVector(frame.data);\n  }\n\n  inputSignal(data) {\n    const outData = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    const scale = this.scale;\n\n    for (let i = 0; i < frameSize; i++)\n      outData[i] = scale(data[i]);\n\n    return outData;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.frame.data = this.inputVector(frame.data);\n  }\n}\n\nexport default Scale;\n","import BaseLfo from '../../core/BaseLfo';\nimport MovingAverage from './MovingAverage';\n\nconst min = Math.min;\nconst max = Math.max;\n\nconst definitions = {\n  logInput: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dyanmic' },\n  },\n  minInput: {\n    type: 'float',\n    default: 0.000000000001,\n    metas: { kind: 'dyanmic' },\n  },\n  filterOrder: {\n    type: 'integer',\n    default: 5,\n    metas: { kind: 'dyanmic' },\n  },\n  threshold: {\n    type: 'float',\n    default: 3,\n    metas: { kind: 'dyanmic' },\n  },\n  offThreshold: {\n    type: 'float',\n    default: -Infinity,\n    metas: { kind: 'dyanmic' },\n  },\n  minInter: {\n    type: 'float',\n    default: 0.050,\n    metas: { kind: 'dyanmic' },\n  },\n  maxDuration: {\n    type: 'float',\n    default: Infinity,\n    metas: { kind: 'dyanmic' },\n  },\n}\n\n/**\n * Create segments based on attacks.\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Boolean} [options.logInput=false] - Apply log on the input.\n * @param {Number} [options.minInput=0.000000000001] - Minimum value to use as\n *  input.\n * @param {Number} [options.filterOrder=5] - Order of the internally used moving\n *  average.\n * @param {Number} [options.threshold=3] - Threshold that triggers a segment\n *  start.\n * @param {Number} [options.offThreshold=-Infinity] - Threshold that triggers\n *  a segment end.\n * @param {Number} [options.minInter=0.050] - Minimum delay between two semgents.\n * @param {Number} [options.maxDuration=Infinity] - Maximum duration of a segment.\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * // assuming a stream from the microphone\n * const source = audioContext.createMediaStreamSource(stream);\n *\n * const audioInNode = new lfo.source.AudioInNode({\n *   sourceNode: source,\n *   audioContext: audioContext,\n * });\n *\n * const slicer = new lfo.operator.Slicer({\n *   frameSize: frameSize,\n *   hopSize: hopSize,\n *   centeredTimeTags: true\n * });\n *\n * const power = new lfo.operator.RMS({\n *   power: true,\n * });\n *\n * const segmenter = new lfo.operator.Segmenter({\n *   logInput: true,\n *   filterOrder: 5,\n *   threshold: 3,\n *   offThreshold: -Infinity,\n *   minInter: 0.050,\n *   maxDuration: 0.050,\n * });\n *\n * const logger = new lfo.sink.Logger({ time: true });\n *\n * audioInNode.connect(slicer);\n * slicer.connect(power);\n * power.connect(segmenter);\n * segmenter.connect(logger);\n *\n * audioInNode.start();\n */\nclass Segmenter extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n\n    this.insideSegment = false;\n    this.onsetTime = -Infinity;\n\n    // stats\n    this.min = Infinity;\n    this.max = -Infinity;\n    this.sum = 0;\n    this.sumOfSquares = 0;\n    this.count = 0;\n\n    const minInput = this.params.get('minInput');\n    let fill = minInput;\n\n    if (this.params.get('logInput') && minInput > 0)\n      fill = Math.log(minInput);\n\n    this.movingAverage = new MovingAverage({\n      order: this.params.get('filterOrder'),\n      fill: fill,\n    });\n\n    this.lastMvavrg = fill;\n  }\n\n  onParamUpdate(name, value, metas) {\n    super.onParamUpdate(name, value, metas);\n\n    if (name === 'filterOrder')\n      this.movingAverage.params.set('order', value);\n  }\n\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this.streamParams.frameType = 'vector';\n    this.streamParams.frameSize = 5;\n    this.streamParams.frameRate = 0;\n    this.streamParams.description = ['duration', 'min', 'max', 'mean', 'stddev'];\n\n\n    this.movingAverage.initStream(prevStreamParams);\n\n    this.propagateStreamParams();\n  }\n\n  resetStream() {\n    super.resetStream();\n    this.movingAverage.resetStream();\n    this.resetSegment();\n  }\n\n  finalizeStream(endTime) {\n    if (this.insideSegment)\n      this.outputSegment(endTime);\n\n    super.finalizeStream(endTime);\n  }\n\n  resetSegment() {\n    this.insideSegment = false;\n    this.onsetTime = -Infinity;\n    // stats\n    this.min = Infinity;\n    this.max = -Infinity;\n    this.sum = 0;\n    this.sumOfSquares = 0;\n    this.count = 0;\n  }\n\n  outputSegment(endTime) {\n    const outData = this.frame.data;\n    outData[0] = endTime - this.onsetTime;\n    outData[1] = this.min;\n    outData[2] = this.max;\n\n    const norm = 1 / this.count;\n    const mean = this.sum * norm;\n    const meanOfSquare = this.sumOfSquares * norm;\n    const squareOfmean = mean * mean;\n\n    outData[3] = mean;\n    outData[4] = 0;\n\n    if (meanOfSquare > squareOfmean)\n      outData[4] = Math.sqrt(meanOfSquare - squareOfmean);\n\n    this.frame.time = this.onsetTime;\n\n    this.propagateFrame();\n  }\n\n  processSignal(frame) {\n    const logInput = this.params.get('logInput');\n    const minInput = this.params.get('minInput');\n    const threshold = this.params.get('threshold');\n    const minInter = this.params.get('minInter');\n    const maxDuration = this.params.get('maxDuration');\n    const offThreshold = this.params.get('offThreshold');\n    const rawValue = frame.data[0];\n    const time = frame.time;\n    let value = Math.max(rawValue, minInput);\n\n    if (logInput)\n      value = Math.log(value);\n\n    const diff = value - this.lastMvavrg;\n    this.lastMvavrg = this.movingAverage.inputScalar(value);\n\n    // update frame metadata\n    this.frame.metadata = frame.metadata;\n\n    if (diff > threshold && time - this.onsetTime > minInter) {\n      if (this.insideSegment)\n        this.outputSegment(time);\n\n      // start segment\n      this.insideSegment = true;\n      this.onsetTime = time;\n      this.max = -Infinity;\n    }\n\n    if (this.insideSegment) {\n      this.min = min(this.min, rawValue);\n      this.max = max(this.max, rawValue);\n      this.sum += rawValue;\n      this.sumOfSquares += rawValue * rawValue;\n      this.count++;\n\n      if (time - this.onsetTime >= maxDuration || value <= offThreshold) {\n        this.outputSegment(time);\n        this.insideSegment = false;\n      }\n    }\n  }\n\n  processFrame(frame) {\n    this.prepareFrame();\n    this.processFunction(frame);\n    // do not propagate here as the frameRate is now zero\n  }\n}\n\nexport default Segmenter;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  index: {\n    type: 'integer',\n    default: 0,\n    metas: { kind: 'static' },\n  },\n  indexes: {\n    type: 'any',\n    default: null,\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  }\n};\n\n/**\n * Select one or several indexes from a `vector` input. If only one index is\n * selected, the output will be of type `scalar`, otherwise the output will\n * be a vector containing the selected indexes.\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default values.\n * @param {Number} options.index - Index to select from the input frame.\n * @param {Array<Number>} options.indexes - Indices to select from the input\n *  frame, if defined, take precedance over `option.index`.\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameType: 'vector',\n *   frameSize: 3,\n * });\n *\n * const select = new lfo.operator.Select({\n *   indexes: [2, 0],\n * });\n *\n * eventIn.start();\n * eventIn.process(0, [0, 2, 4]);\n * > [4, 0]\n * eventIn.process(0, [1, 3, 5]);\n * > [5, 1]\n */\nclass Select extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n  }\n\n  /** @private */\n  onParamUpdate(name, value, metas = {}) {\n    super.onParamUpdate(name, value, metas);\n\n    const index = this.params.get('index');\n    const indexes = this.params.get('indexes');\n\n    this.select = (indexes !== null) ? indexes : [index];\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const index = this.params.get('index');\n    const indexes = this.params.get('indexes');\n\n    let max = (indexes !== null) ?  Math.max.apply(null, indexes) : index;\n\n    if (max >= prevStreamParams.frameSize)\n      throw new Error(`Invalid select index \"${max}\"`);\n\n    this.streamParams.frameType = (indexes !== null) ? 'vector' : 'scalar';\n    this.streamParams.frameSize = (indexes !== null) ? indexes.length : 1;\n\n    this.select = (indexes !== null) ? indexes : [index];\n\n    // steal description() from parent\n    if (prevStreamParams.description) {\n      this.select.forEach((val, index) => {\n        this.streamParams.description[index] = prevStreamParams.description[val];\n      });\n    }\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processVector(frame) {\n    const data = frame.data;\n    const outData = this.frame.data;\n    const select = this.select;\n\n    for (let i = 0; i < select.length; i++)\n      outData[i] = data[select[i]];\n  }\n}\n\nexport default Select;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  frameSize: {\n    type: 'integer',\n    default: 512,\n    metas: { kind: 'static' },\n  },\n  hopSize: { // should be nullable\n    type: 'integer',\n    default: null,\n    nullable: true,\n    metas: { kind: 'static' },\n  },\n  centeredTimeTags: {\n    type: 'boolean',\n    default: false,\n  }\n}\n\n/**\n * Change the `frameSize` and `hopSize` of a `signal` input according to\n * the given options.\n * This operator updates the stream parameters according to its configuration.\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.frameSize=512] - Frame size of the output signal.\n * @param {Number} [options.hopSize=null] - Number of samples between two\n *  consecutive frames. If null, `hopSize` is set to `frameSize`.\n * @param {Boolean} [options.centeredTimeTags] - Move the time tag to the middle\n *  of the frame.\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameType: 'signal',\n *   frameSize: 10,\n *   sampleRate: 2,\n * });\n *\n * const slicer = new lfo.operator.Slicer({\n *   frameSize: 4,\n *   hopSize: 2\n * });\n *\n * const logger = new lfo.sink.Logger({ time: true, data: true });\n *\n * eventIn.connect(slicer);\n * slicer.connect(logger);\n * eventIn.start();\n *\n * eventIn.process(0, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);\n * > { time: 0, data: [0, 1, 2, 3] }\n * > { time: 1, data: [2, 3, 4, 5] }\n * > { time: 2, data: [4, 5, 6, 7] }\n * > { time: 3, data: [6, 7, 8, 9] }\n */\nclass Slicer extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    const hopSize = this.params.get('hopSize');\n    const frameSize = this.params.get('frameSize');\n\n    if (!hopSize)\n      this.params.set('hopSize', frameSize);\n\n    this.params.addListener(this.onParamUpdate.bind(this));\n\n    this.frameIndex = 0;\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const hopSize = this.params.get('hopSize');\n    const frameSize = this.params.get('frameSize');\n\n    this.streamParams.frameSize = frameSize;\n    this.streamParams.frameRate = prevStreamParams.sourceSampleRate / hopSize;\n\n    if (this.streamParams.frameSize === 1)\n      this.streamParams.frameType = 'scalar';\n    else\n      this.streamParams.frameType = 'signal';\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  resetStream() {\n    super.resetStream();\n    this.frameIndex = 0;\n  }\n\n  /** @private */\n  finalizeStream(endTime) {\n    if (this.frameIndex > 0) {\n      const frameRate = this.streamParams.frameRate;\n      const frameSize = this.streamParams.frameSize;\n      const data = this.frame.data;\n      // set the time of the last frame\n      this.frame.time += (1 / frameRate);\n\n      for (let i = this.frameIndex; i < frameSize; i++)\n        data[i] = 0;\n\n      this.propagateFrame();\n    }\n\n    super.finalizeStream(endTime);\n  }\n\n  /** @private */\n  processFrame(frame) {\n    this.prepareFrame();\n    this.processFunction(frame);\n  }\n\n  /** @private */\n  processSignal(frame) {\n    const time = frame.time;\n    const block = frame.data;\n    const metadata = frame.metadata;\n\n    const centeredTimeTags = this.params.get('centeredTimeTags');\n    const hopSize = this.params.get('hopSize');\n    const outFrame = this.frame.data;\n    const frameSize = this.streamParams.frameSize;\n    const sampleRate = this.streamParams.sourceSampleRate;\n    const samplePeriod = 1 / sampleRate;\n    const blockSize = block.length;\n\n    let frameIndex = this.frameIndex;\n    let blockIndex = 0;\n\n    while (blockIndex < blockSize) {\n      let numSkip = 0;\n\n      // skip block samples for negative frameIndex (frameSize < hopSize)\n      if (frameIndex < 0) {\n        numSkip = -frameIndex;\n        frameIndex = 0; // reset `frameIndex`\n      }\n\n      if (numSkip < blockSize) {\n        blockIndex += numSkip; // skip block segment\n        // can copy all the rest of the incoming block\n        let numCopy = blockSize - blockIndex;\n        // connot copy more than what fits into the frame\n        const maxCopy = frameSize - frameIndex;\n\n        if (numCopy >= maxCopy)\n          numCopy = maxCopy;\n\n        // copy block segment into frame\n        const copy = block.subarray(blockIndex, blockIndex + numCopy);\n        outFrame.set(copy, frameIndex);\n        // advance block and frame index\n        blockIndex += numCopy;\n        frameIndex += numCopy;\n\n        // send frame when completed\n        if (frameIndex === frameSize) {\n          // define time tag for the outFrame according to configuration\n          if (centeredTimeTags)\n            this.frame.time = time + (blockIndex - frameSize / 2) * samplePeriod;\n          else\n            this.frame.time = time + (blockIndex - frameSize) * samplePeriod;\n\n          this.frame.metadata = metadata;\n          // forward to next nodes\n          this.propagateFrame();\n\n          // shift frame left\n          if (hopSize < frameSize)\n            outFrame.set(outFrame.subarray(hopSize, frameSize), 0);\n\n          frameIndex -= hopSize; // hop forward\n        }\n      } else {\n        // skip entire block\n        const blockRest = blockSize - blockIndex;\n        frameIndex += blockRest;\n        blockIndex += blockRest;\n      }\n    }\n\n    this.frameIndex = frameIndex;\n  }\n}\n\nexport default Slicer;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst ceil = Math.ceil;\n\n/**\n * paper: http://recherche.ircam.fr/equipes/pcm/cheveign/pss/2002_JASA_YIN.pdf\n * implementation based on https://github.com/ashokfernandez/Yin-Pitch-Tracking\n * @private\n */\n\nconst definitions = {\n  threshold: {\n    type: 'float',\n    default: 0.1, // default from paper\n    metas: { kind: 'static' },\n  },\n  downSamplingExp: { // downsampling factor\n    type: 'integer',\n    default: 2,\n    min: 0,\n    max: 3,\n    metas: { kind: 'static' },\n  },\n  minFreq: { //\n    type: 'float',\n    default: 60, // mean 735 samples\n    min: 0,\n    metas: { kind: 'static' },\n  },\n}\n\n/**\n * Yin fundamental frequency estimator, based on algorithm described in\n * [YIN, a fundamental frequency estimator for speech and music](http://recherche.ircam.fr/equipes/pcm/cheveign/pss/2002_JASA_YIN.pdf)\n * by Cheveigne and Kawahara.\n * On each frame, this operator propagate a vector containing the following\n * values: `frequency`, `probability`.\n *\n * For good results the input frame size should be large (1024 or 2048).\n *\n * _support `standalone` usage_\n *\n * @note - In node for a frame of 2048 samples, average computation time is:\n *         0.00016742283339993389 second.\n *\n * @memberof module:common.operator\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.threshold=0.1] - Absolute threshold to test the\n *  normalized difference (see paper for more informations).\n * @param {Number} [options.downSamplingExp=2] - Down sample the input frame by\n *  a factor of 2 at the power of `downSamplingExp` (min=0 and max=3) for\n *  performance improvements.\n * @param {Number} [options.minFreq=60] - Minimum frequency the operator can\n *  search for. This parameter defines the size of the autocorrelation performed\n *  on the signal, the input frame size should be around 2 time this size for\n *  good results (i.e. `inputFrameSize ≈ 2 * (samplingRate / minFreq)`).\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * // assuming some AudioBuffer\n * const source = new lfo.source.AudioInBuffer({\n *   audioBuffer: audioBuffer,\n * });\n *\n * const slicer = new lfo.operator.Slicer({\n *   frameSize: 2048,\n * });\n *\n * const yin = new lfo.operator.Yin();\n * const logger = new lfo.sink.Logger({ data: true });\n *\n * source.connect(slicer);\n * slicer.connect(yin);\n * yin.connect(logger);\n *\n * source.start();\n */\nclass Yin extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n\n    this.probability = 0;\n    this.pitch = -1;\n\n    this.test = 0;\n  }\n\n  /** @private */\n  _downsample(input, size, output, downSamplingExp) {\n    const outputSize = size >> downSamplingExp;\n    let i, j;\n\n    switch (downSamplingExp) {\n      case 0: // no down sampling\n        for (i = 0; i < size; i++)\n          output[i] = input[i];\n\n        break;\n      case 1:\n        for (i = 0, j = 0; i < outputSize; i++, j += 2)\n          output[i] = 0.5 * (input[j] + input[j + 1]);\n\n        break\n      case 2:\n        for (i = 0, j = 0; i < outputSize; i++, j += 4)\n          output[i] = 0.25 * (input[j] + input[j + 1] + input[j + 2] + input[j + 3]);\n\n        break;\n      case 3:\n        for (i = 0, j = 0; i < outputSize; i++, j += 8)\n          output[i] = 0.125 * (input[j] + input[j + 1] + input[j + 2] + input[j + 3] + input[j + 4] + input[j + 5] + input[j + 6] + input[j + 7]);\n\n        break;\n    }\n\n    return outputSize;\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    this.streamParams.frameType = 'vector';\n    this.streamParams.frameSize = 2;\n    this.streamParams.description = ['frequency', 'confidence'];\n\n    this.inputFrameSize = prevStreamParams.frameSize;\n    // handle params\n    const sourceSampleRate = this.streamParams.sourceSampleRate;\n    const downSamplingExp = this.params.get('downSamplingExp');\n    const downFactor = 1 << downSamplingExp; // 2^n\n    const downSR = sourceSampleRate / downFactor;\n    const downFrameSize = this.inputFrameSize / downFactor; // n_tick_down // 1 / 2^n\n\n    const minFreq = this.params.get('minFreq');\n    // limit min freq, cf. paper IV. sensitivity to parameters\n    const minFreqNbrSamples = downSR / minFreq;\n    // const bufferSize = prevStreamParams.frameSize;\n    this.halfBufferSize = downFrameSize / 2;\n\n    // minimum error to not crash but not enought to have results\n    if (minFreqNbrSamples > this.halfBufferSize)\n      throw new Error('Invalid input frame size, too small for given \"minFreq\"');\n\n    this.downSamplingExp = downSamplingExp;\n    this.downSamplingRate = downSR;\n    this.downFrameSize = downFrameSize;\n    this.buffer = new Float32Array(downFrameSize);\n    // autocorrelation buffer\n    this.yinBuffer = new Float32Array(this.halfBufferSize);\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  _downsample(input, size, output, downSamplingExp) {\n    const outputSize = size >> downSamplingExp;\n    let i, j;\n\n    switch (downSamplingExp) {\n      case 0: // no down sampling\n        for (i = 0; i < size; i++)\n          output[i] = input[i];\n\n        break;\n      case 1:\n        for (i = 0, j = 0; i < outputSize; i++, j += 2)\n          output[i] = 0.5 * (input[j] + input[j + 1]);\n\n        break\n      case 2:\n        for (i = 0, j = 0; i < outputSize; i++, j += 4)\n          output[i] = 0.25 * (input[j] + input[j + 1] + input[j + 2] + input[j + 3]);\n\n        break;\n      case 3:\n        for (i = 0, j = 0; i < outputSize; i++, j += 8)\n          output[i] = 0.125 * (input[j] + input[j + 1] + input[j + 2] + input[j + 3] + input[j + 4] + input[j + 5] + input[j + 6] + input[j + 7]);\n\n        break;\n    }\n\n    return outputSize;\n  }\n\n  /**\n   * Step 1, 2 and 3 - Squared difference of the shifted signal with itself.\n   * cumulative mean normalized difference.\n   *\n   * @private\n   */\n  _normalizedDifference(buffer) {\n    const halfBufferSize = this.halfBufferSize;\n    const yinBuffer = this.yinBuffer;\n    let sum = 0;\n\n    // difference for different shift values (tau)\n    for (let tau = 0; tau < halfBufferSize; tau++) {\n      let squaredDifference = 0; // reset buffer\n\n      // take difference of the signal with a shifted version of itself then\n      // sqaure the result\n      for (let i = 0; i < halfBufferSize; i++) {\n        const delta = buffer[i] - buffer[i + tau];\n        squaredDifference += delta * delta;\n      }\n\n      // step 3 - normalize yinBuffer\n      if (tau > 0) {\n        sum += squaredDifference;\n        yinBuffer[tau] = squaredDifference * (tau / sum);\n      }\n    }\n\n    yinBuffer[0] = 1;\n  }\n\n  /**\n   * Step 4 - find first best tau that is under the thresold.\n   *\n   * @private\n   */\n  _absoluteThreshold() {\n    const threshold = this.params.get('threshold');\n    const yinBuffer = this.yinBuffer;\n    const halfBufferSize = this.halfBufferSize;\n    let tau;\n\n    for (tau = 1; tau < halfBufferSize; tau++) {\n      if (yinBuffer[tau] < threshold) {\n        // keep increasing tau if next value is better\n        while (tau + 1 < halfBufferSize && yinBuffer[tau + 1] < yinBuffer[tau])\n          tau += 1;\n\n        // best tau found , yinBuffer[tau] can be seen as an estimation of\n        // aperiodicity then: periodicity = 1 - aperiodicity\n        this.probability = 1 - yinBuffer[tau];\n        break;\n      }\n    }\n\n    // return -1 if not match found\n    return (tau === halfBufferSize) ? -1 : tau;\n  }\n\n  /**\n   * Step 5 - Find a better fractionnal approximate of tau.\n   * this can probably be simplified...\n   *\n   * @private\n   */\n  _parabolicInterpolation(tauEstimate) {\n    const halfBufferSize = this.halfBufferSize;\n    const yinBuffer = this.yinBuffer;\n    let betterTau;\n    // @note - tauEstimate cannot be zero as the loop start at 1 in step 4\n    const x0 = tauEstimate - 1;\n    const x2 = (tauEstimate < halfBufferSize - 1) ? tauEstimate + 1 : tauEstimate;\n\n    // if `tauEstimate` is last index, we can't interpolate\n    if (x2 === tauEstimate) {\n        betterTau = tauEstimate;\n    } else {\n      const s0 = yinBuffer[x0];\n      const s1 = yinBuffer[tauEstimate];\n      const s2 = yinBuffer[x2];\n\n      // @note - don't fully understand this formula neither...\n      betterTau = tauEstimate + (s2 - s0) / (2 * (2 * s1 - s2 - s0));\n    }\n\n    return betterTau;\n  }\n\n  /**\n   * Use the `Yin` operator in `standalone` mode (i.e. outside of a graph).\n   *\n   * @param {Array|Float32Array} input - The signal fragment to process.\n   * @return {Array} - Array containing the `frequency`, `energy`, `periodicity`\n   *  and `AC1`\n   *\n   * @example\n   * import * as lfo from 'waves-lfo/client';\n   *\n   * const yin = new lfo.operator.Yin();\n   * yin.initStream({\n   *   frameSize: 2048,\n   *   frameType: 'signal',\n   *   sourceSampleRate: 44100\n   * });\n   *\n   * const results = yin.inputSignal(signal);\n   */\n  inputSignal(input) {\n    this.pitch = -1;\n    this.probability = 0;\n\n    const buffer = this.buffer;\n    const inputFrameSize = this.inputFrameSize;\n    const downSamplingExp = this.downSamplingExp;\n    const sampleRate = this.downSamplingRate;\n    const outData = this.frame.data;\n    let tauEstimate = -1;\n\n    // subsampling\n    this._downsample(input, inputFrameSize, buffer, downSamplingExp);\n    // step 1, 2, 3 - normalized squared difference of the signal with a\n    // shifted version of itself\n    this._normalizedDifference(buffer);\n    // step 4 - find first best tau estimate that is over the threshold\n    tauEstimate = this._absoluteThreshold();\n\n    if (tauEstimate !== -1) {\n      // step 5 - so far tau is an integer shift of the signal, check if\n      // there is a better fractionnal value around\n      tauEstimate = this._parabolicInterpolation(tauEstimate);\n      this.pitch = sampleRate / tauEstimate;\n    }\n\n    outData[0] = this.pitch;\n    outData[1] = this.probability;\n\n    return outData;\n  }\n\n  /** @private */\n  processSignal(frame) {\n    this.inputSignal(frame.data);\n  }\n}\n\nexport default Yin;\n","import Biquad from './Biquad';\nimport Clip from './Clip';\nimport Dct from './Dct';\nimport Delta from './Delta';\nimport Fft from './Fft';\nimport Magnitude from './Magnitude';\nimport MeanStddev from './MeanStddev';\nimport Mel from './Mel';\nimport Merger from './Merger';\nimport Mfcc from './Mfcc';\nimport MinMax from './MinMax';\nimport MovingAverage from './MovingAverage';\nimport MovingMedian from './MovingMedian';\nimport OnOff from './OnOff';\nimport Power from './Power';\nimport Rms from './Rms';\nimport Multiplier from './Multiplier';\nimport Scale from './Scale';\nimport Segmenter from './Segmenter';\nimport Select from './Select';\nimport Slicer from './Slicer';\nimport Yin from './Yin';\n\nexport default {\n  Biquad,\n  Clip,\n  Dct,\n  Delta,\n  Fft,\n  Magnitude,\n  MeanStddev,\n  Mel,\n  Merger,\n  Mfcc,\n  MinMax,\n  MovingAverage,\n  MovingMedian,\n  OnOff,\n  Power,\n  Rms,\n  Multiplier,\n  Scale,\n  Segmenter,\n  Select,\n  Slicer,\n  Yin,\n};\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  processStreamParams: {\n    type: 'any',\n    default: null,\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  },\n  processFrame: {\n    type: 'any',\n    default: null,\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  },\n  finalizeStream: {\n    type: 'any',\n    default: null,\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  },\n};\n\n/**\n * Create a bridge between the graph and application logic. Handle `push`\n * and `pull` paradigms.\n *\n * This sink can handle any type of input (`signal`, `vector`, `scalar`)\n *\n * @memberof module:common.sink\n *\n * @param {Object} options - Override default parameters.\n * @param {Function} [options.processFrame=null] - Callback executed on each\n *  `processFrame` call.\n * @param {Function} [options.finalizeStream=null] - Callback executed on each\n *  `finalizeStream` call.\n *\n * @see {@link module:core.BaseLfo#processFrame}\n * @see {@link module:core.BaseLfo#processStreamParams}\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const frames = [\n *  { time: 0, data: [0, 1] },\n *  { time: 1, data: [1, 2] },\n * ];\n *\n * const eventIn = new EventIn({\n *   frameType: 'vector',\n *   frameSize: 2,\n *   frameRate: 1,\n * });\n *\n * const bridge = new Bridge({\n *   processFrame: (frame) => console.log(frame),\n * });\n *\n * eventIn.connect(bridge);\n * eventIn.start();\n *\n * // callback executed on each frame\n * eventIn.processFrame(frame[0]);\n * > { time: 0, data: [0, 1] }\n * eventIn.processFrame(frame[1]);\n * > { time: 1, data: [1, 2] }\n *\n * // pull current frame when needed\n * console.log(bridge.frame);\n * > { time: 1, data: [1, 2] }\n */\nclass Bridge extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const processStreamParamsCallback = this.params.get('processStreamParams');\n\n    if (processStreamParamsCallback !== null)\n      processStreamParamsCallback(this.streamParams);\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  finalizeStream(endTime) {\n    const finalizeStreamCallback = this.params.get('finalizeStream');\n\n    if (finalizeStreamCallback !== null)\n      finalizeStreamCallback(endTime);\n  }\n\n  // process any type\n  /** @private */\n  processScalar() {}\n  /** @private */\n  processVector() {}\n  /** @private */\n  processSignal() {}\n\n  /** @private */\n  processFrame(frame) {\n    this.prepareFrame();\n\n    const processFrameCallback = this.params.get('processFrame');\n    const output = this.frame;\n    output.data = new Float32Array(this.streamParams.frameSize);\n    // pull interface (we copy data since we don't know what could\n    // be done outside the graph)\n    for (let i = 0; i < this.streamParams.frameSize; i++)\n      output.data[i] = frame.data[i];\n\n    output.time = frame.time;\n    output.metadata = frame.metadata;\n\n    // `push` interface\n    if (processFrameCallback !== null)\n      processFrameCallback(output);\n  }\n}\n\nexport default Bridge;\n","import BaseLfo from '../../core/BaseLfo';\n\n\nconst definitions = {\n  separateArrays: {\n    type: 'boolean',\n    default: false,\n    constant: true,\n  },\n  callback: {\n    type: 'any',\n    default: null,\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  },\n};\n\n/**\n * Record input frames from a graph. This sink can handle `signal`, `vector`\n * or `scalar` inputs.\n *\n * When the recording is stopped (either by calling `stop` on the node or when\n * the stream is finalized), the callback given as parameter is executed with\n * the recorder data as argument.\n *\n *\n * @param {Object} options - Override default parameters.\n * @param {Boolean} [options.separateArrays=false] - Format of the retrieved\n *  values:\n *  - when `false`, format is [{ time, data }, { time, data }, ...]\n *  - when `true`, format is { time: [...], data: [...] }\n * @param {Function} [options.callback] - Callback to execute when a new record\n *  is ended. This can happen when:\n *  - `stop` is called on the recorder\n *  - `stop` is called on the source.\n *\n * @todo - Add auto record param.\n *\n * @memberof module:common.sink\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const eventIn = new lfo.source.EventIn({\n *  frameType: 'vector',\n *  frameSize: 2,\n *  frameRate: 0,\n * });\n *\n * const recorder = new lfo.sink.DataRecorder({\n *   callback: (data) => console.log(data),\n * });\n *\n * eventIn.connect(recorder);\n * eventIn.start();\n * recorder.start();\n *\n * eventIn.process(0, [0, 1]);\n * eventIn.process(1, [1, 2]);\n *\n * recorder.stop();\n * > [{ time: 0, data: [0, 1] }, { time: 1, data: [1, 2] }];\n */\nclass DataRecorder extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    /**\n     * Define if the node is currently recording.\n     *\n     * @type {Boolean}\n     * @name isRecording\n     * @instance\n     * @memberof module:sink.SignalRecorder\n     */\n    this.isRecording = false;\n  }\n\n  /** @private */\n  _initStore() {\n    const separateArrays = this.params.get('separateArrays');\n\n    if (separateArrays)\n      this._store = { time: [], data: [] };\n    else\n      this._store = [];\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n    this._initStore();\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Start recording.\n   *\n   * @see {@link module:client.sink.DataRecorder#stop}\n   */\n  start() {\n    this.isRecording = true;\n  }\n\n  /**\n   * Stop recording and execute the callback defined in parameters.\n   *\n   * @see {@link module:client.sink.DataRecorder#start}\n   */\n  stop() {\n    if (this.isRecording) {\n      this.isRecording = false;\n      const callback = this.params.get('callback');\n\n      if (callback !== null)\n        callback(this._store);\n\n      this._initStore();\n    }\n  }\n\n  /** @private */\n  finalizeStream() {\n    this.stop();\n  }\n\n  // handle any input types\n  /** @private */\n  processScalar(frame) {}\n  /** @private */\n  processSignal(frame) {}\n  /** @private */\n  processVector(frame) {}\n\n  processFrame(frame) {\n    if (this.isRecording) {\n      this.prepareFrame(frame);\n\n      const separateArrays = this.params.get('separateArrays');\n      const entry = {\n        time: frame.time,\n        data: new Float32Array(frame.data),\n      };\n\n      if (!separateArrays) {\n        this._store.push(entry);\n      } else {\n        this._store.time.push(entry.time);\n        this._store.data.push(entry.data);\n      }\n    }\n  }\n}\n\nexport default DataRecorder;\n\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  time: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dynamic' }\n  },\n  data: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dynamic' }\n  },\n  metadata: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dynamic' }\n  },\n  streamParams: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dynamic' }\n  },\n  frameIndex: {\n    type: 'boolean',\n    default: false,\n    metas: { kind: 'dynamic' }\n  },\n}\n\n/**\n * Log `frame.time`, `frame.data`, `frame.metadata` and/or\n * `streamAttributes` of any node in the console.\n *\n * This sink can handle any type if input (`signal`, `vector`, `scalar`)\n *\n * @param {Object} options - Override parameters default values.\n * @param {Boolean} [options.time=false] - Log incomming `frame.time` if `true`.\n * @param {Boolean} [options.data=false] - Log incomming `frame.data` if `true`.\n * @param {Boolean} [options.metadata=false] - Log incomming `frame.metadata`\n *  if `true`.\n * @param {Boolean} [options.streamParams=false] - Log `streamParams` of the\n *  previous node when graph is started.\n * @param {Boolean} [options.frameIndex=false] - Log index of the incomming\n *  `frame`.\n *\n * @memberof module:common.sink\n *\n * @example\n * import * as lfo from 'waves-lfo/common';\n *\n * const logger = new lfo.sink.Logger({ data: true });\n * whateverOperator.connect(logger);\n */\nclass Logger extends BaseLfo {\n  constructor(options) {\n    super(definitions, options);\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    if (this.params.get('streamParams') === true)\n      console.log(prevStreamParams);\n\n    this.frameIndex = 0;\n  }\n\n  /** @private */\n  processFunction(frame) {\n    if (this.params.get('frameIndex') === true)\n      console.log(this.frameIndex++);\n\n    if (this.params.get('time') === true)\n      console.log(frame.time);\n\n    if (this.params.get('data') === true)\n      console.log(frame.data);\n\n    if (this.params.get('metadata') === true)\n      console.log(frame.metadata);\n  }\n}\n\nexport default Logger;\n","import BaseLfo from '../../core/BaseLfo';\n\nconst definitions = {\n  duration: {\n    type: 'float',\n    default: 10,\n    min: 0,\n    metas: { kind: 'static' },\n  },\n  callback: {\n    type: 'any',\n    default: null,\n    nullable: true,\n    metas: { kind: 'dynamic' },\n  },\n  ignoreLeadingZeros: {\n    type: 'boolean',\n    default: true,\n    metas: { kind: 'static' },\n  },\n  retrieveAudioBuffer: {\n    type: 'boolean',\n    default: false,\n    constant: true,\n  },\n  audioContext: {\n    type: 'any',\n    default: null,\n    nullable: true,\n  },\n};\n\n/**\n * Record an `signal` input stream of arbitrary duration and retrieve it\n * when done.\n *\n * When recording is stopped (either when the `stop` method is called, the\n * defined duration has been recorded, or the source of the graph finalized\n * the stream), the callback given as parameter is executed  with the\n * `AudioBuffer` or `Float32Array` containing the recorded signal as argument.\n *\n * @todo - add option to return only the Float32Array and not an audio buffer\n *  (node compliant) `retrieveAudioBuffer: false`\n *\n * @param {Object} options - Override default parameters.\n * @param {Number} [options.duration=10] - Maximum duration of the recording.\n * @param {Number} [options.callback] - Callback to execute when a new record is\n *  ended. This can happen: `stop` is called on the recorder, `stop` is called\n *  on the source or when the buffer is full according to the given `duration`.\n * @param {Object} [options.ignoreLeadingZeros=true] - Start the effective\n *  recording on the first non-zero value.\n * @param {Boolean} [options.retrieveAudioBuffer=false] - Define if an `AudioBuffer`\n *  should be retrieved or only the raw Float32Array of data.\n *  (works only in browser)\n * @param {AudioContext} [options.audioContext=null] - If\n *  `retrieveAudioBuffer` is set to `true`, audio context to be used\n *  in order to create the final audio buffer.\n *  (works only in browser)\n *\n * @memberof module:common.sink\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const audioContext = new AudioContext();\n *\n * navigator.mediaDevices\n *   .getUserMedia({ audio: true })\n *   .then(init)\n *   .catch((err) => console.error(err.stack));\n *\n * function init(stream) {\n *   const source = audioContext.createMediaStreamSource(stream);\n *\n *   const audioInNode = new lfo.source.AudioInNode({\n *     sourceNode: source,\n *     audioContext: audioContext,\n *   });\n *\n *   const signalRecorder = new lfo.sink.SignalRecorder({\n *     duration: 6,\n *     retrieveAudioBuffer: true,\n *     audioContext: audioContext,\n *     callback: (buffer) => {\n *       const bufferSource = audioContext.createBufferSource();\n *       bufferSource.buffer = buffer;\n *       bufferSource.connect(audioContext.destination);\n *       bufferSource.start();\n *     }\n *   });\n *\n *   audioInNode.connect(signalRecorder);\n *   audioInNode.start();\n *   signalRecorder.start();\n * });\n */\nclass SignalRecorder extends BaseLfo {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    /**\n     * Define is the node is currently recording or not.\n     *\n     * @type {Boolean}\n     * @name isRecording\n     * @instance\n     * @memberof module:client.sink.SignalRecorder\n     */\n    this.isRecording = false;\n\n    const retrieveAudioBuffer = this.params.get('retrieveAudioBuffer');\n    const audioContext = this.params.get('audioContext');\n    // needed to retrieve an AudioBuffer\n    if (retrieveAudioBuffer && audioContext === null)\n      throw new Error('Invalid parameter \"audioContext\": an AudioContext must be provided when `retrieveAudioBuffer` is set to `true`')\n\n    this._audioContext = audioContext;\n    this._ignoreZeros = false;\n    this._isInfiniteBuffer = false;\n    this._stack = [];\n    this._buffer = null;\n    this._bufferLength = null;\n    this._currentIndex = null;\n  }\n\n  _initBuffer() {\n    this._buffer = new Float32Array(this._bufferLength);\n    this._stack.length = 0;\n    this._currentIndex = 0;\n  }\n\n  /** @private */\n  processStreamParams(prevStreamParams) {\n    this.prepareStreamParams(prevStreamParams);\n\n    const duration = this.params.get('duration');\n    const sampleRate = this.streamParams.sourceSampleRate;\n\n    if (isFinite(duration)) {\n      this._isInfiniteBuffer = false;\n      this._bufferLength = sampleRate * duration;\n    } else {\n      this._isInfiniteBuffer = true;\n      this._bufferLength = sampleRate * 10;\n    }\n\n    this._initBuffer();\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Start recording.\n   */\n  start() {\n    this.isRecording = true;\n    this._ignoreZeros = this.params.get('ignoreLeadingZeros');\n  }\n\n  /**\n   * Stop recording and execute the callback defined in parameters.\n   */\n  stop() {\n    if (this.isRecording) {\n      // ignore next incomming frame\n      this.isRecording = false;\n\n      const retrieveAudioBuffer = this.params.get('retrieveAudioBuffer');\n      const callback = this.params.get('callback');\n      const currentIndex = this._currentIndex;\n      const buffer = this._buffer;\n      let output;\n\n      if (!this._isInfiniteBuffer) {\n        output = new Float32Array(currentIndex);\n        output.set(buffer.subarray(0, currentIndex), 0);\n      } else {\n        const bufferLength = this._bufferLength;\n        const stack = this._stack;\n\n        output = new Float32Array(stack.length * bufferLength + currentIndex);\n\n        // copy all stacked buffers\n        for (let i = 0; i < stack.length; i++) {\n          const stackedBuffer = stack[i];\n          output.set(stackedBuffer, bufferLength * i);\n        };\n        // copy data contained in current buffer\n        output.set(buffer.subarray(0, currentIndex), stack.length * bufferLength);\n      }\n\n      if (retrieveAudioBuffer && this._audioContext) {\n        const length = output.length;\n        const sampleRate = this.streamParams.sourceSampleRate;\n        const audioBuffer = this._audioContext.createBuffer(1, length, sampleRate);\n        const channelData = audioBuffer.getChannelData(0);\n        channelData.set(output, 0);\n\n        callback(audioBuffer);\n      } else {\n        callback(output);\n      }\n\n      // reinit buffer, stack, and currentIndex\n      this._initBuffer();\n    }\n  }\n\n  /** @private */\n  finalizeStream(endTime) {\n    this.stop();\n  }\n\n  /** @private */\n  processSignal(frame) {\n    if (!this.isRecording)\n      return;\n\n    let block = null;\n    const input = frame.data;\n    const bufferLength = this._bufferLength;\n    const buffer = this._buffer;\n\n    if (this._ignoreZeros === false) {\n      block = new Float32Array(input);\n    } else if (input[input.length - 1] !== 0) {\n      // find first index where value !== 0\n      let i;\n\n      for (i = 0; i < input.length; i++)\n        if (input[i] !== 0) break;\n\n      // copy non zero segment\n      block = new Float32Array(input.subarray(i));\n      // don't repeat this logic once a non-zero value has been found\n      this._ignoreZeros = false;\n    }\n\n    if (block !== null) {\n      const availableSpace = bufferLength - this._currentIndex;\n      let currentBlock;\n\n      if (availableSpace < block.length)\n        currentBlock = block.subarray(0, availableSpace);\n      else\n        currentBlock = block;\n\n      buffer.set(currentBlock, this._currentIndex);\n      this._currentIndex += currentBlock.length;\n\n      if (this._isInfiniteBuffer && this._currentIndex === bufferLength) {\n        this._stack.push(buffer);\n\n        currentBlock = block.subarray(availableSpace);\n        this._buffer = new Float32Array(bufferLength);\n        this._buffer.set(currentBlock, 0);\n        this._currentIndex = currentBlock.length;\n      }\n\n      //  stop if the buffer is finite and full\n      if (!this._isInfiniteBuffer && this._currentIndex === bufferLength)\n        this.stop();\n    }\n  }\n}\n\nexport default SignalRecorder;\n\n","import BaseLfo from '../../core/BaseLfo';\nimport SourceMixin from '../../core/SourceMixin';\n\n// http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser\nconst isNode = new Function('try { return this === global; } catch(e) { return false }');\n\n/**\n * Create a function that returns time in seconds according to the current\n * environnement (node or browser).\n * If running in node the time rely on `process.hrtime`, while if in the browser\n * it is provided by the `currentTime` of an `AudioContext`, this context can\n * optionnaly be provided to keep time consistency between several `EventIn`\n * nodes.\n *\n * @param {AudioContext} [audioContext=null] - Optionnal audio context.\n * @return {Function}\n * @private\n */\nfunction getTimeFunction(audioContext = null) {\n  if (isNode()) {\n    return () => {\n      const t = process.hrtime();\n      return t[0] + t[1] * 1e-9;\n    }\n  } else {\n    return () => performance.now() / 1000;\n  }\n}\n\n\nconst definitions = {\n  absoluteTime: {\n    type: 'boolean',\n    default: false,\n    constant: true,\n  },\n  audioContext: {\n    type: 'any',\n    default: null,\n    constant: true,\n    nullable: true,\n  },\n  frameType: {\n    type: 'enum',\n    list: ['signal', 'vector', 'scalar'],\n    default: 'signal',\n    constant: true,\n  },\n  frameSize: {\n    type: 'integer',\n    default: 1,\n    min: 1,\n    max: +Infinity, // not recommended...\n    metas: { kind: 'static' },\n  },\n  sampleRate: {\n    type: 'float',\n    default: null,\n    min: 0,\n    max: +Infinity, // same here\n    nullable: true,\n    metas: { kind: 'static' },\n  },\n  frameRate: {\n    type: 'float',\n    default: null,\n    min: 0,\n    max: +Infinity, // same here\n    nullable: true,\n    metas: { kind: 'static' },\n  },\n  description: {\n    type: 'any',\n    default: null,\n    constant: true,\n  }\n};\n\n/**\n * The `EventIn` operator allows to manually create a stream of data or to feed\n * a stream from another source (e.g. sensors) into a processing graph.\n *\n * @param {Object} options - Override parameters' default values.\n * @param {String} [options.frameType='signal'] - Type of the input - allowed\n * values: `signal`,  `vector` or `scalar`.\n * @param {Number} [options.frameSize=1] - Size of the output frame.\n * @param {Number} [options.sampleRate=null] - Sample rate of the source stream,\n *  if of type `signal`.\n * @param {Number} [options.frameRate=null] - Rate of the source stream, if of\n *  type `vector`.\n * @param {Array|String} [options.description] - Optionnal description\n *  describing the dimensions of the output frame\n * @param {Boolean} [options.absoluteTime=false] - Define if time should be used\n *  as forwarded as given in the process method, or relatively to the time of\n *  the first `process` call after start.\n *\n * @memberof module:common.source\n *\n * @todo - Add a `logicalTime` parameter to tag frame according to frame rate.\n *\n * @example\n * import * as lfo from 'waves-lfo/client';\n *\n * const eventIn = new lfo.source.EventIn({\n *   frameType: 'vector',\n *   frameSize: 3,\n *   frameRate: 1 / 50,\n *   description: ['alpha', 'beta', 'gamma'],\n * });\n *\n * // connect source to operators and sink(s)\n *\n * // initialize and start the graph\n * eventIn.start();\n *\n * // feed `deviceorientation` data into the graph\n * window.addEventListener('deviceorientation', (e) => {\n *   const frame = {\n *     time: window.performace.now() / 1000,\n *     data: [e.alpha, e.beta, e.gamma],\n *   };\n *\n *   eventIn.processFrame(frame);\n * }, false);\n */\nclass EventIn extends SourceMixin(BaseLfo) {\n  constructor(options = {}) {\n    super(definitions, options);\n\n    const audioContext = this.params.get('audioContext');\n    this._getTime = getTimeFunction(audioContext);\n    this._startTime = null;\n    this._systemTime = null;\n    this._absoluteTime = this.params.get('absoluteTime');\n  }\n\n  /**\n   * Propagate the `streamParams` in the graph and allow to push frames into\n   * the graph. Any call to `process` or `processFrame` before `start` will be\n   * ignored.\n   *\n   * @see {@link module:core.BaseLfo#processStreamParams}\n   * @see {@link module:core.BaseLfo#resetStream}\n   * @see {@link module:common.source.EventIn#stop}\n   */\n  start(startTime = null) {\n    if (this.initialized === false) {\n      if (this.initPromise === null) // init has not yet been called\n        this.initPromise = this.init();\n\n      return this.initPromise.then(() => this.start(startTime));\n    }\n\n    this._startTime = startTime;\n    this._systemTime = null; // value set in the first `process` call\n\n    this.started = true;\n  }\n\n  /**\n   * Finalize the stream and stop the whole graph. Any call to `process` or\n   * `processFrame` after `stop` will be ignored.\n   *\n   * @see {@link module:core.BaseLfo#finalizeStream}\n   * @see {@link module:common.source.EventIn#start}\n   */\n  stop() {\n    if (this.started && this._startTime !== null) {\n      const currentTime = this._getTime();\n      const endTime = this.frame.time + (currentTime - this._systemTime);\n\n      this.finalizeStream(endTime);\n      this.started = false;\n    }\n  }\n\n  /** @private */\n  processStreamParams() {\n    const frameSize = this.params.get('frameSize');\n    const frameType = this.params.get('frameType');\n    const sampleRate = this.params.get('sampleRate');\n    const frameRate = this.params.get('frameRate');\n    const description = this.params.get('description');\n\n    // init operator's stream params\n    this.streamParams.frameSize = frameType === 'scalar' ? 1 : frameSize;\n    this.streamParams.frameType = frameType;\n    this.streamParams.description = description;\n\n    if (frameType === 'signal') {\n      if (sampleRate === null)\n        throw new Error('Undefined \"sampleRate\" for \"signal\" stream');\n\n      this.streamParams.sourceSampleRate = sampleRate;\n      this.streamParams.frameRate = sampleRate / frameSize;\n      this.streamParams.sourceSampleCount = frameSize;\n\n    } else if (frameType === 'vector' || frameType === 'scalar') {\n      if (frameRate === null)\n        throw new Error(`Undefined \"frameRate\" for \"${frameType}\" stream`);\n\n      this.streamParams.frameRate = frameRate;\n      this.streamParams.sourceSampleRate = frameRate;\n      this.streamParams.sourceSampleCount = 1;\n    }\n\n    this.propagateStreamParams();\n  }\n\n  /** @private */\n  processFunction(frame) {\n    const currentTime = this._getTime();\n    const inData = frame.data.length ? frame.data : [frame.data];\n    const outData = this.frame.data;\n    // if no time provided, use system time\n    let time = Number.isFinite(frame.time) ? frame.time : currentTime;\n\n    if (this._startTime === null)\n      this._startTime = time;\n\n    if (this._absoluteTime === false)\n      time = time - this._startTime;\n\n    for (let i = 0, l = this.streamParams.frameSize; i < l; i++)\n      outData[i] = inData[i];\n\n    this.frame.time = time;\n    this.frame.metadata = frame.metadata;\n    // store current time to compute `endTime` on stop\n    this._systemTime = currentTime;\n  }\n\n  /**\n   * Alternative interface to propagate a frame in the graph. Pack `time`,\n   * `data` and `metadata` in a frame object.\n   *\n   * @param {Number} time - Frame time.\n   * @param {Float32Array|Array} data - Frame data.\n   * @param {Object} metadata - Optionnal frame metadata.\n   *\n   * @example\n   * eventIn.process(1, [0, 1, 2]);\n   * // is equivalent to\n   * eventIn.processFrame({ time: 1, data: [0, 1, 2] });\n   */\n  process(time, data, metadata = null) {\n    this.processFrame({ time, data, metadata });\n  }\n\n  /**\n   * Propagate a frame object in the graph.\n   *\n   * @param {Object} frame - Input frame.\n   * @param {Number} frame.time - Frame time.\n   * @param {Float32Array|Array} frame.data - Frame data.\n   * @param {Object} [frame.metadata=undefined] - Optionnal frame metadata.\n   *\n   * @example\n   * eventIn.processFrame({ time: 1, data: [0, 1, 2] });\n   */\n  processFrame(frame) {\n    if (!this.started) return;\n\n    this.prepareFrame();\n    this.processFunction(frame);\n    this.propagateFrame();\n  }\n}\n\nexport default EventIn;\n","\n// shortcuts / helpers\nconst PI   = Math.PI;\nconst cos  = Math.cos;\nconst sin  = Math.sin;\nconst sqrt = Math.sqrt;\n\n// window creation functions\nfunction initHannWindow(buffer, size, normCoefs) {\n  let linSum = 0;\n  let powSum = 0;\n  const step = 2 * PI / size;\n\n  for (let i = 0; i < size; i++) {\n    const phi = i * step;\n    const value = 0.5 - 0.5 * cos(phi);\n\n    buffer[i] = value;\n\n    linSum += value;\n    powSum += value * value;\n  }\n\n  normCoefs.linear = size / linSum;\n  normCoefs.power = sqrt(size / powSum);\n}\n\nfunction initHammingWindow(buffer, size, normCoefs) {\n  let linSum = 0;\n  let powSum = 0;\n  const step = 2 * PI / size;\n\n  for (let i = 0; i < size; i++) {\n    const phi = i * step;\n    const value = 0.54 - 0.46 * cos(phi);\n\n    buffer[i] = value;\n\n    linSum += value;\n    powSum += value * value;\n  }\n\n  normCoefs.linear = size / linSum;\n  normCoefs.power = sqrt(size / powSum);\n}\n\nfunction initBlackmanWindow(buffer, size, normCoefs) {\n  let linSum = 0;\n  let powSum = 0;\n  const step = 2 * PI / size;\n\n  for (let i = 0; i < size; i++) {\n    const phi = i * step;\n    const value = 0.42 - 0.5 * cos(phi) + 0.08 * cos(2 * phi);\n\n    buffer[i] = value;\n\n    linSum += value;\n    powSum += value * value;\n  }\n\n  normCoefs.linear = size / linSum;\n  normCoefs.power = sqrt(size / powSum);\n}\n\nfunction initBlackmanHarrisWindow(buffer, size, normCoefs) {\n  let linSum = 0;\n  let powSum = 0;\n  const a0 = 0.35875;\n  const a1 = 0.48829;\n  const a2 = 0.14128;\n  const a3 = 0.01168;\n  const step = 2 * PI / size;\n\n  for (let i = 0; i < size; i++) {\n    const phi = i * step;\n    const value = a0 - a1 * cos(phi) + a2 * cos(2 * phi); - a3 * cos(3 * phi);\n\n    buffer[i] = value;\n\n    linSum += value;\n    powSum += value * value;\n  }\n\n  normCoefs.linear = size / linSum;\n  normCoefs.power = sqrt(size / powSum);\n}\n\nfunction initSineWindow(buffer, size, normCoefs) {\n  let linSum = 0;\n  let powSum = 0;\n  const step = PI / size;\n\n  for (let i = 0; i < size; i++) {\n    const phi = i * step;\n    const value = sin(phi);\n\n    buffer[i] = value;\n\n    linSum += value;\n    powSum += value * value;\n  }\n\n  normCoefs.linear = size / linSum;\n  normCoefs.power = sqrt(size / powSum);\n}\n\nfunction initRectangleWindow(buffer, size, normCoefs) {\n  for (let i = 0; i < size; i++)\n    buffer[i] = 1;\n\n  // @todo - check if these are proper values\n  normCoefs.linear = 1;\n  normCoefs.power = 1;\n}\n\n/**\n * Create a buffer with window signal.\n *\n * @memberof module:common.utils\n *\n * @param {String} name - Name of the window.\n * @param {Float32Array} buffer - Buffer to be populated with the window signal.\n * @param {Number} size - Size of the buffer.\n * @param {Object} normCoefs - Object to be populated with the normailzation\n *  coefficients.\n */\nfunction initWindow(name, buffer, size, normCoefs) {\n  name = name.toLowerCase();\n\n  switch (name) {\n    case 'hann':\n    case 'hanning':\n      initHannWindow(buffer, size, normCoefs);\n      break;\n    case 'hamming':\n      initHammingWindow(buffer, size, normCoefs);\n      break;\n    case 'blackman':\n      initBlackmanWindow(buffer, size, normCoefs);\n      break;\n    case 'blackmanharris':\n      initBlackmanHarrisWindow(buffer, size, normCoefs);\n      break;\n    case 'sine':\n      initSineWindow(buffer, size, normCoefs);\n      break;\n    case 'rectangle':\n      initRectangleWindow(buffer, size, normCoefs);\n      break;\n  }\n}\n\nexport default initWindow;\n\n\n","//http://stackoverflow.com/questions/8609289/convert-a-binary-nodejs-buffer-to-javascript-arraybuffer\n// converts a nodejs Buffer to ArrayBuffer\n// export function bufferToArrayBuffer(buffer) {\n//   const ab = new ArrayBuffer(buffer.length);\n//   const view = new Uint8Array(ab);\n\n//   for (let i = 0; i < buffer.length; ++i)\n//     view[i] = buffer[i];\n\n//   return ab;\n// }\n\n// export function arrayBufferToBuffer(arrayBuffer) {\n//   const buffer = new Buffer(arrayBuffer.byteLength);\n//   const view = new Uint8Array(arrayBuffer);\n\n//   for (let i = 0; i < buffer.length; ++i)\n//     buffer[i] = view[i];\n\n//   return buffer;\n// }\n\n// http://updates.html5rocks.com/2012/06/How-to-convert-ArrayBuffer-to-and-from-String\nfunction Uint16Array2json(arr) {\n  const str = String.fromCharCode.apply(null, arr);\n  return JSON.parse(str.replace(/\\u0000/g, ''))\n}\n\nfunction json2Uint16Array(json) {\n  const str = JSON.stringify(json);\n  const buffer = new ArrayBuffer(str.length * 2); // 2 bytes for each char\n  const bufferView = new Uint16Array(buffer);\n\n  for (let i = 0, l = str.length; i < l; i++)\n    bufferView[i] = str.charCodeAt(i);\n\n  return bufferView;\n}\n\n\nexport const opcodes = {\n  INIT_MODULE_REQ: 10,\n  INIT_MODULE_ACK: 11,\n  PROCESS_STREAM_PARAMS: 12,\n  RESET_STREAM: 13,\n  FINALIZE_STREAM: 14,\n  PROCESS_FRAME: 15\n}\n\n//\nexport const encoders = {\n  opcode(name) {\n    const opcode = opcodes[name];\n    const buffer = new Uint16Array(1);\n    buffer[0] = opcode;\n\n    return buffer;\n  },\n  // `opcode`    2 bytes (Uint16) |\n  initModuleReq: function() {\n    const payload = encoders.opcode('INIT_MODULE_REQ');\n    return payload.buffer;\n  },\n  // `opcode`    2 bytes (Uint16) |\n  initModuleAck: function() {\n    const payload = encoders.opcode('INIT_MODULE_ACK');\n    return payload.buffer;\n  },\n  // `opcode`    2 bytes (Uint16) |\n  // `streamParams`  n bytes (Uint16)\n  streamParams: function(streamParams) {\n    const opcode = encoders.opcode('PROCESS_STREAM_PARAMS');\n    const streamParamsBuffer = json2Uint16Array(streamParams);\n\n    const payload = new Uint16Array(1 + streamParamsBuffer.length);\n    payload.set(opcode, 0);\n    payload.set(streamParamsBuffer, 1);\n\n    return payload.buffer;\n  },\n  // `opcode`    2 bytes (Uint16) |\n  resetStream: function() {\n    const payload = encoders.opcode('RESET_STREAM');\n    return payload.buffer;\n  },\n  // `opcode`    2 bytes (Uint16) |\n  // `endTime`   8 bytes (Float64)\n  finalizeStream: function(endTime) {\n    const opcode = encoders.opcode('RESET_STREAM');\n\n    const endTimeBuffer = new Float64Array(1);\n    endTimeBuffer[0] = endTime;\n\n    const payload = new Uint16Array(1 + 4);\n    payload.set(opcode, 0);\n    payload.set(new Uint16Array(endTimeBuffer.buffer), 1);\n\n    return payload.buffer;\n  },\n  // `opcode`    2 bytes (Uint16) |\n  // `time`      8 bytes (Float64) |\n  // `data`      frameSize * 4 (Float32) |\n  // `metadata`  n bytes (Uint16)\n  processFrame: function(frame, frameSize) {\n    const opcode = encoders.opcode('PROCESS_FRAME');\n\n    const time = new Float64Array(1);\n    time[0] = frame.time;\n\n    const data = new Float32Array(frameSize);\n    for (let i = 0; i < frameSize; i++)\n      data[i] = frame.data[i];\n\n    const metadata = json2Uint16Array(frame.metadata);\n\n    const length = 1 + 4 + (2 * frameSize) + metadata.length;\n    const payload = new Uint16Array(length);\n    payload.set(opcode, 0);\n    payload.set(new Uint16Array(time.buffer), 1);\n    payload.set(new Uint16Array(data.buffer), 1 + 4);\n    payload.set(metadata, 1 + 4 + (2 * frameSize));\n\n    return payload.buffer;\n  }\n}\n\nexport const decoders = {\n  opcode(arrayBuffer) {\n    return new Uint16Array(arrayBuffer)[0];\n  },\n  // `opcode`    2 bytes (Uint16) |\n  // `streamParams`  n bytes (Uint16)\n  streamParams(arrayBuffer) {\n    const payload = new Uint16Array(arrayBuffer.slice(2));\n    const prevStreamParams = Uint16Array2json(payload);\n    return prevStreamParams;\n  },\n  // `opcode`    2 bytes (Uint16) |\n  // `endTime`   8 bytes (Float64)\n  finalizeStream(arrayBuffer) {\n    return new Float64Array(arrayBuffer.slice(2))[0];\n  },\n  // `opcode`    2 bytes (Uint16) |\n  // `time`      8 bytes (Float64) |\n  // `data`      frameSize * 4 (Float32) |\n  // `metadata`  n bytes (Uint16)\n  processFrame(arrayBuffer, frameSize) {\n      // 1 * 8 bytes\n      const timeStart = 2;\n      const timeEnd = timeStart + 8;\n      const time = new Float64Array(arrayBuffer.slice(timeStart, timeEnd))[0];\n      // frameSize * 4 bytes\n      const dataStart = timeEnd;\n      const dataEnd = dataStart + 4 * frameSize;\n      const data = new Float32Array(arrayBuffer.slice(dataStart, dataEnd));\n      // rest of payload\n      const metaStart = dataEnd;\n      const metaBuffer = new Uint16Array(arrayBuffer.slice(metaStart));\n      const metadata = Uint16Array2json(metaBuffer);\n\n      return { time, data, metadata };\n  }\n}\n","import parameters from '@ircam/parameters';\n\nlet id = 0;\n\n/**\n * Base `lfo` class to be extended in order to create new nodes.\n *\n * Nodes are divided in 3 categories:\n * - **`source`** are responsible for acquering a signal and its properties\n *   (frameRate, frameSize, etc.)\n * - **`sink`** are endpoints of the graph, such nodes can be recorders,\n *   visualizers, etc.\n * - **`operator`** are used to make computation on the input signal and\n *   forward the results below in the graph.\n *\n * In most cases the methods to override / extend are:\n * - the **`constructor`** to define the parameters of the new lfo node.\n * - the **`processStreamParams`** method to define how the node modify the\n *   stream attributes (e.g. by changing the frame size)\n * - the **`process{FrameType}`** method to define the operations that the\n *   node apply on the stream. The type of input a node can handle is defined\n *   by its implemented interface, if it implements `processSignal`, a stream\n *   of type `signal` can be processed, `processVector` to handle\n *   an input of type `vector`.\n *\n * <span class=\"warning\">_This class should be considered abstract and only\n * be used as a base class to extend._</span>\n *\n * #### overview of the interface\n *\n * **initModule**\n *\n * Returns a Promise that resolves when the module is initialized. Is\n * especially important for modules that rely on asynchronous underlying APIs.\n *\n * **processStreamParams(prevStreamParams)**\n *\n * `base` class (default implementation)\n * - call `prepareStreamParams`\n * - call `propagateStreamParams`\n *\n * `child` class\n * - override some of the inherited `streamParams`\n * - creates the any related logic buffers\n * - call `propagateStreamParams`\n *\n * _should not call `super.processStreamParams`_\n *\n * **prepareStreamParams()**\n *\n * - assign prevStreamParams to this.streamParams\n * - check if the class implements the correct `processInput` method\n *\n * _shouldn't be extended, only consumed in `processStreamParams`_\n *\n * **propagateStreamParams()**\n *\n * - creates the `frameData` buffer\n * - propagate `streamParams` to children\n *\n * _shouldn't be extended, only consumed in `processStreamParams`_\n *\n * **processFrame()**\n *\n * `base` class (default implementation)\n * - call `prepareFrame`\n * - assign frameTime and frameMetadata to identity\n * - call the proper function according to inputType\n * - call `propagateFrame`\n *\n * `child` class\n * - call `prepareFrame`\n * - do whatever you want with incomming frame\n * - call `propagateFrame`\n *\n * _should not call `super.processFrame`_\n *\n * **prepareFrame()**\n *\n * - if `reinit` and trigger `processStreamParams` if needed\n *\n * _shouldn't be extended, only consumed in `processFrame`_\n *\n * **propagateFrame()**\n *\n * - propagate frame to children\n *\n * _shouldn't be extended, only consumed in `processFrame`_\n *\n * @memberof module:core\n */\nclass BaseLfo {\n  constructor(definitions = {}, options = {}) {\n    this.cid = id++;\n\n    /**\n     * Parameter bag containing parameter instances.\n     *\n     * @type {Object}\n     * @name params\n     * @instance\n     * @memberof module:core.BaseLfo\n     */\n    this.params = parameters(definitions, options);\n    // listen for param updates\n    this.params.addListener(this.onParamUpdate.bind(this));\n\n    /**\n     * Description of the stream output of the node.\n     * Set to `null` when the node is destroyed.\n     *\n     * @type {Object}\n     * @property {Number} frameSize - Frame size at the output of the node.\n     * @property {Number} frameRate - Frame rate at the output of the node.\n     * @property {String} frameType - Frame type at the output of the node,\n     *  possible values are `signal`, `vector` or `scalar`.\n     * @property {Array|String} description - If type is `vector`, describe\n     *  the dimension(s) of output stream.\n     * @property {Number} sourceSampleRate - Sample rate of the source of the\n     *  graph. _The value should be defined by sources and never modified_.\n     * @property {Number} sourceSampleCount - Number of consecutive discrete\n     *  time values contained in the data frame output by the source.\n     *  _The value should be defined by sources and never modified_.\n     *\n     * @name streamParams\n     * @instance\n     * @memberof module:core.BaseLfo\n     */\n    this.streamParams = {\n      frameType: null,\n      frameSize: 1,\n      frameRate: 0,\n      description: null,\n      sourceSampleRate: 0,\n      sourceSampleCount: null,\n    };\n\n    /**\n     * Current frame. This object and its data are updated at each incomming\n     * frame without reallocating memory.\n     *\n     * @type {Object}\n     * @name frame\n     * @property {Number} time - Time of the current frame.\n     * @property {Float32Array} data - Data of the current frame.\n     * @property {Object} metadata - Metadata associted to the current frame.\n     * @instance\n     * @memberof module:core.BaseLfo\n     */\n    this.frame = {\n      time: 0,\n      data: null,\n      metadata: {},\n    };\n\n    /**\n     * List of nodes connected to the ouput of the node (lower in the graph).\n     * At each frame, the node forward its `frame` to to all its `nextModules`.\n     *\n     * @type {Array<BaseLfo>}\n     * @name nextModules\n     * @instance\n     * @memberof module:core.BaseLfo\n     * @see {@link module:core.BaseLfo#connect}\n     * @see {@link module:core.BaseLfo#disconnect}\n     */\n    this.nextModules = [];\n\n    /**\n     * The node from which the node receive the frames (upper in the graph).\n     *\n     * @type {BaseLfo}\n     * @name prevModule\n     * @instance\n     * @memberof module:core.BaseLfo\n     * @see {@link module:core.BaseLfo#connect}\n     * @see {@link module:core.BaseLfo#disconnect}\n     */\n    this.prevModule = null;\n\n    /**\n     * Is set to true when a static parameter is updated. On the next input\n     * frame all the subgraph streamParams starting from this node will be\n     * updated.\n     *\n     * @type {Boolean}\n     * @name _reinit\n     * @instance\n     * @memberof module:core.BaseLfo\n     * @private\n     */\n    this._reinit = false;\n  }\n\n  /**\n   * Returns an object describing each available parameter of the node.\n   *\n   * @return {Object}\n   */\n  getParamsDescription() {\n    return this.params.getDefinitions();\n  }\n\n  /**\n   * Reset all parameters to their initial value (as defined on instantication)\n   *\n   * @see {@link module:core.BaseLfo#streamParams}\n   */\n  resetParams() {\n    this.params.reset();\n  }\n\n  /**\n   * Function called when a param is updated. By default set the `_reinit`\n   * flag to `true` if the param is `static` one. This method should be\n   * extended to handle particular logic bound to a specific parameter.\n   *\n   * @param {String} name - Name of the parameter.\n   * @param {Mixed} value - Value of the parameter.\n   * @param {Object} metas - Metadata associated to the parameter.\n   */\n  onParamUpdate(name, value, metas = {}) {\n    if (metas.kind === 'static')\n      this._reinit = true;\n  }\n\n  /**\n   * Connect the current node (`prevModule`) to another node (`nextOp`).\n   * A given node can be connected to several operators and propagate frames\n   * to each of them.\n   *\n   * @param {BaseLfo} next - Next operator in the graph.\n   * @see {@link module:core.BaseLfo#processFrame}\n   * @see {@link module:core.BaseLfo#disconnect}\n   */\n  connect(next) {\n    if (this.streamParams === null || next.streamParams === null)\n      throw new Error('Invalid connection: cannot connect a dead node');\n\n    if (this.streamParams.frameType !== null) { // graph has already been started\n      // next.processStreamParams(this.streamParams);\n      next.initModule().then(() => {\n        next.processStreamParams(this.streamParams);\n        // we can forward frame from now\n        this.nextModules.push(next);\n        next.prevModule = this;\n      });\n    } else {\n      this.nextModules.push(next);\n      next.prevModule = this;\n    }\n  }\n\n  /**\n   * Remove the given operator from its previous operators' `nextModules`.\n   *\n   * @param {BaseLfo} [next=null] - The operator to disconnect from the current\n   *  operator. If `null` disconnect all the next operators.\n   */\n  disconnect(next = null) {\n    if (next === null) {\n      this.nextModules.forEach((next) => this.disconnect(next));\n    } else {\n      const index = this.nextModules.indexOf(this);\n      this.nextModules.splice(index, 1);\n      next.prevModule = null;\n    }\n  }\n\n  /**\n   * Destroy all the nodes in the sub-graph starting from the current node.\n   * When detroyed, the `streamParams` of the node are set to `null`, the\n   * operator is then considered as `dead` and cannot be reconnected.\n   *\n   * @see {@link module:core.BaseLfo#connect}\n   */\n  destroy() {\n    // destroy all chidren\n    let index = this.nextModules.length;\n\n    while (index--)\n      this.nextModules[index].destroy();\n\n    // disconnect itself from the previous operator\n    if (this.prevModule)\n      this.prevModule.disconnect(this);\n\n    // mark the object as dead\n    this.streamParams = null;\n  }\n\n  /**\n   * Return a `Promise` that resolve when the module is ready to be consumed.\n   * Some modules relies on asynchronous APIs at initialization and thus could\n   * be not ready to be consumed when the graph starts.\n   * A module should be consider as initialized when all next modules (children)\n   * are themselves initialized. The event bubbles up from sinks to sources.\n   * When all its next operators are ready, a source can consider the whole graph\n   * as ready and then start to produce frames.\n   * The default implementation resolves when all next operators are resolved\n   * themselves.\n   * An operator relying on external async API must override this method to\n   * resolve only when its dependecy is ready.\n   *\n   * @return Promise\n   * @todo - Handle dynamic connections\n   */\n  initModule() {\n    const nextPromises = this.nextModules.map((module) => {\n      return module.initModule();\n    });\n\n    return Promise.all(nextPromises);\n  }\n\n  /**\n   * Helper to initialize the stream in standalone mode.\n   *\n   * @param {Object} [streamParams={}] - Parameters of the stream.\n   *\n   * @see {@link module:core.BaseLfo#processStreamParams}\n   * @see {@link module:core.BaseLfo#resetStream}\n   */\n  initStream(streamParams = {}) {\n    this.processStreamParams(streamParams);\n    this.resetStream();\n  }\n\n  /**\n   * Reset the `frame.data` buffer by setting all its values to 0.\n   * A source operator should call `processStreamParams` and `resetStream` when\n   * started, each of these method propagate through the graph automaticaly.\n   *\n   * @see {@link module:core.BaseLfo#processStreamParams}\n   */\n  resetStream() {\n    // buttom up\n    for (let i = 0, l = this.nextModules.length; i < l; i++)\n      this.nextModules[i].resetStream();\n\n    // no buffer for `scalar` type or sink node\n    // @note - this should be reviewed\n    if (this.streamParams.frameType !== 'scalar' && this.frame.data !== null) {\n      const frameSize = this.streamParams.frameSize;\n      const data = this.frame.data;\n\n      for (let i = 0; i < frameSize; i++)\n        data[i] = 0;\n    }\n  }\n\n  /**\n   * Finalize the stream. A source node should call this method when stopped,\n   * `finalizeStream` is automatically propagated throught the graph.\n   *\n   * @param {Number} endTime - Logical time at which the graph is stopped.\n   */\n  finalizeStream(endTime) {\n    for (let i = 0, l = this.nextModules.length; i < l; i++)\n      this.nextModules[i].finalizeStream(endTime);\n  }\n\n  /**\n   * Initialize or update the operator's `streamParams` according to the\n   * previous operators `streamParams` values.\n   *\n   * When implementing a new operator this method should:\n   * 1. call `this.prepareStreamParams` with the given `prevStreamParams`\n   * 2. optionnally change values to `this.streamParams` according to the\n   *    logic performed by the operator.\n   * 3. optionnally allocate memory for ring buffers, etc.\n   * 4. call `this.propagateStreamParams` to trigger the method on the next\n   *    operators in the graph.\n   *\n   * @param {Object} prevStreamParams - `streamParams` of the previous operator.\n   *\n   * @see {@link module:core.BaseLfo#prepareStreamParams}\n   * @see {@link module:core.BaseLfo#propagateStreamParams}\n   */\n  processStreamParams(prevStreamParams = {}) {\n    this.prepareStreamParams(prevStreamParams);\n    this.propagateStreamParams();\n  }\n\n  /**\n   * Common logic to do at the beginning of the `processStreamParam`, must be\n   * called at the beginning of any `processStreamParam` implementation.\n   *\n   * The method mainly check if the current node implement the interface to\n   * handle the type of frame propagated by it's parent:\n   * - to handle a `vector` frame type, the class must implement `processVector`\n   * - to handle a `signal` frame type, the class must implement `processSignal`\n   * - in case of a 'scalar' frame type, the class can implement any of the\n   * following by order of preference: `processScalar`, `processVector`,\n   * `processSignal`.\n   *\n   * @param {Object} prevStreamParams - `streamParams` of the previous operator.\n   *\n   * @see {@link module:core.BaseLfo#processStreamParams}\n   * @see {@link module:core.BaseLfo#propagateStreamParams}\n   */\n  prepareStreamParams(prevStreamParams = {}) {\n    Object.assign(this.streamParams, prevStreamParams);\n    const prevFrameType = prevStreamParams.frameType;\n\n    switch (prevFrameType) {\n      case 'scalar':\n        if (this.processScalar)\n          this.processFunction = this.processScalar;\n        else if (this.processVector)\n          this.processFunction = this.processVector;\n        else if (this.processSignal)\n          this.processFunction = this.processSignal;\n        else\n          throw new Error(`${this.constructor.name} - no \"process\" function found`);\n        break;\n      case 'vector':\n        if (!('processVector' in this))\n          throw new Error(`${this.constructor.name} - \"processVector\" is not defined`);\n\n        this.processFunction = this.processVector;\n        break;\n      case 'signal':\n        if (!('processSignal' in this))\n          throw new Error(`${this.constructor.name} - \"processSignal\" is not defined`);\n\n        this.processFunction = this.processSignal;\n        break;\n      default:\n        // defaults to processFunction\n        break;\n    }\n  }\n\n  /**\n   * Create the `this.frame.data` buffer and forward the operator's `streamParam`\n   * to all its next operators, must be called at the end of any\n   * `processStreamParams` implementation.\n   *\n   * @see {@link module:core.BaseLfo#processStreamParams}\n   * @see {@link module:core.BaseLfo#prepareStreamParams}\n   */\n  propagateStreamParams() {\n    this.frame.data = new Float32Array(this.streamParams.frameSize);\n\n    for (let i = 0, l = this.nextModules.length; i < l; i++)\n      this.nextModules[i].processStreamParams(this.streamParams);\n  }\n\n  /**\n   * Define the particular logic the operator applies to the stream.\n   * According to the frame type of the previous node, the method calls one\n   * of the following method `processVector`, `processSignal` or `processScalar`\n   *\n   * @param {Object} frame - Frame (time, data, and metadata) as given by the\n   *  previous operator. The incomming frame should never be modified by\n   *  the operator.\n   *\n   * @see {@link module:core.BaseLfo#prepareFrame}\n   * @see {@link module:core.BaseLfo#propagateFrame}\n   * @see {@link module:core.BaseLfo#processStreamParams}\n   */\n  processFrame(frame) {\n    this.prepareFrame();\n\n    // frameTime and frameMetadata defaults to identity\n    this.frame.time = frame.time;\n    this.frame.metadata = frame.metadata;\n\n    this.processFunction(frame);\n    this.propagateFrame();\n  }\n\n  /**\n   * Pointer to the method called in `processFrame` according to the\n   * frame type of the previous operator. Is dynamically assigned in\n   * `prepareStreamParams`.\n   *\n   * @see {@link module:core.BaseLfo#prepareStreamParams}\n   * @see {@link module:core.BaseLfo#processFrame}\n   */\n  processFunction(frame) {\n    this.frame = frame;\n  }\n\n  /**\n   * Common logic to perform at the beginning of the `processFrame`.\n   *\n   * @see {@link module:core.BaseLfo#processFrame}\n   */\n  prepareFrame() {\n    if (this._reinit === true) {\n      const streamParams = this.prevModule !== null ? this.prevModule.streamParams : {};\n      this.initStream(streamParams);\n      this._reinit = false;\n    }\n  }\n\n  /**\n   * Forward the current `frame` to the next operators, is called at the end of\n   * `processFrame`.\n   *\n   * @see {@link module:core.BaseLfo#processFrame}\n   */\n  propagateFrame() {\n    for (let i = 0, l = this.nextModules.length; i < l; i++)\n      this.nextModules[i].processFrame(this.frame);\n  }\n}\n\nexport default BaseLfo;\n","\n/**\n * Interface added to `LfoCore to implement source\n *\n * Source have some responsability on graph as they mostly control its whole\n * lifecycle. They must implement the start and stop method in order to\n * make sure the graph is initialized and set `started` to true.\n * A source should never accept and propagate incomming frames until `started`\n * is set to `true`.\n *\n * @name SourceMixin\n * @memberof module:core\n * @mixin\n *\n * @example\n * class MySource extends SourceMixin(BaseLfo) {}\n */\n const SourceMixin = (superclass) => class extends superclass {\n  constructor(...args) {\n    super(...args);\n\n    this.initialized = false;\n    this.initPromise = null;\n    this.started = false;\n\n    this.start = this.start.bind(this);\n    this.stop = this.stop.bind(this);\n  }\n\n  /**\n   * Initialize the graph by calling `initModule`. When the returned `Promise`\n   * fulfills, the graph can be considered as initialized and `start` can be\n   * called safely. If `start` is called whithout explicit `init`, `init` is\n   * made internally, actual start of the graph is then not garanteed to be\n   * synchronous.\n   *\n   * @memberof module:core.SourceMixin\n   * @instance\n   * @name init\n   *\n   * @return Promise\n   *\n   * @example\n   * // safe initialization and start\n   * source.init().then(() => source.start())\n   * // safe initialization and start\n   * source.start();\n   */\n  init() {\n    this.initPromise = this.initModule().then(() => {\n      this.initStream(); // this is synchronous\n      this.initialized = true;\n      return Promise.resolve(true);\n    });\n\n    return this.initPromise;\n  }\n\n  /**\n   * Interface method to implement that starts the graph.\n   *\n   * The method main purpose is to make sure take verify initialization step and\n   * set `started` to `true` when done.\n   * Should behave synchronously when called inside `init().then()` and async\n   * if called without init step.\n   *\n   * @memberof module:core.SourceMixin\n   * @instance\n   * @name start\n   *\n   * @example\n   * // basic `start` implementation\n   * start() {\n   *   if (this.initialized === false) {\n   *     if (this.initPromise === null) // init has not yet been called\n   *       this.initPromise = this.init();\n   *\n   *     this.initPromise.then(this.start);\n   *     return;\n   *   }\n   *\n   *   this.started = true;\n   * }\n   */\n  start() {}\n\n  /**\n   * Interface method to implement that stops the graph.\n   *\n   * @memberof module:core.SourceMixin\n   * @instance\n   * @name stop\n   *\n   * @example\n   * // basic `stop` implementation\n   * stop() {\n   *   this.started = false;\n   * }\n   */\n  stop() {}\n\n  /**\n   * The implementation should never allow incomming frames\n   * if `this.started` is not `true`.\n   *\n   * @memberof module:core.SourceMixin\n   * @instance\n   * @name processFrame\n   *\n   * @param {Object} frame\n   *\n   * @example\n   * // basic `processFrame` implementation\n   * processFrame(frame) {\n   *   if (this.started === true) {\n   *     this.prepareFrame();\n   *     this.processFunction(frame);\n   *     this.propagateFrame();\n   *   }\n   * }\n   */\n  processFrame(frame) {}\n}\n\nexport default SourceMixin;\n","export const version = '%version%';\n\nexport { default as BaseLfo } from './BaseLfo';\nexport { default as SourceMixin } from './SourceMixin';\n","import * as lfo from 'waves-lfo/client';\n\nconst frameSize = 5;\nconst dt = 0.02;\n\nconst eventIn = new lfo.source.EventIn({\n  frameSize: frameSize,\n  frameRate: 1 / dt,\n  frameType: 'vector',\n});\n\nconst barChart = new lfo.sink.BarChartDisplay({\n  canvas: '#bar-chart',\n});\n\neventIn.connect(barChart);\neventIn.start();\n\nconst data = [0, 0.2, 0.4, 0.6, 0.8];\n\n(function generateData() {\n  for (let i = 0; i < frameSize; i++)\n    data[i] = (data[i] + 0.001) % 1;\n\n  eventIn.process(null, data);\n\n  setTimeout(generateData, dt * 1000);\n}());\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","const min = Math.min;\nconst max = Math.max;\n\nfunction clip(value, lower = -Infinity, upper = +Infinity) {\n  return max(lower, min(upper, value))\n}\n\n/**\n * Dictionnary of the available types. Each key correspond to the type of the\n * implemented param while the corresponding object value should the\n * {@link `paramDefinition`} of the defined type.\n *\n * typedef {Object} paramTemplates\n * @type {Object<String, paramTemplate>}\n */\n\n/**\n * Definition of a parameter. The definition should at least contain the entries\n * `type` and `default`. Every parameter can also accept optionnal configuration\n * entries `constant` and `metas`.\n * Available definitions are:\n * - {@link booleanDefinition}\n * - {@link integerDefinition}\n * - {@link floatDefinition}\n * - {@link stringDefinition}\n * - {@link enumDefinition}\n *\n * typedef {Object} paramDefinition\n * @property {String} type - Type of the parameter.\n * @property {Mixed} default - Default value of the parameter if no\n *  initialization value is provided.\n * @property {Boolean} [constant=false] - Define if the parameter can be change\n *  after its initialization.\n * @property {Object} [metas=null] - Any user defined data associated to the\n *  parameter that couls be usefull in the application.\n */\n\nexport default {\n  /**\n   * @typedef {Object} booleanDefinition\n   * @property {String} [type='boolean'] - Define a boolean parameter.\n   * @property {Boolean} default - Default value of the parameter.\n   * @property {Boolean} [constant=false] - Define if the parameter is constant.\n   * @property {Boolean} [nullable=false] - Define if the parameter is nullable.\n   * @property {Object} [metas={}] - Optionnal metadata of the parameter.\n   */\n  boolean: {\n    definitionTemplate: ['default'],\n    typeCheckFunction(value, definition, name) {\n      if (typeof value !== 'boolean')\n        throw new Error(`Invalid value for boolean param \"${name}\": ${value}`);\n\n      return value;\n    }\n  },\n\n  /**\n   * @typedef {Object} integerDefinition\n   * @property {String} [type='integer'] - Define a boolean parameter.\n   * @property {Mixed} default - Default value of the parameter.\n   * @property {Number} [min=-Infinity] - Minimum value of the parameter.\n   * @property {Number} [max=+Infinity] - Maximum value of the parameter.\n   * @property {Boolean} [constant=false] - Define if the parameter is constant.\n   * @property {Boolean} [nullable=false] - Define if the parameter is nullable.\n   * @property {Object} [metas={}] - Optionnal metadata of the parameter.\n   */\n  integer: {\n    definitionTemplate: ['default'],\n    typeCheckFunction(value, definition, name) {\n      if (!(typeof value === 'number' && Math.floor(value) === value))\n        throw new Error(`Invalid value for integer param \"${name}\": ${value}`);\n\n      return clip(value, definition.min, definition.max);\n    }\n  },\n\n  /**\n   * @typedef {Object} floatDefinition\n   * @property {String} [type='float'] - Define a boolean parameter.\n   * @property {Mixed} default - Default value of the parameter.\n   * @property {Number} [min=-Infinity] - Minimum value of the parameter.\n   * @property {Number} [max=+Infinity] - Maximum value of the parameter.\n   * @property {Boolean} [constant=false] - Define if the parameter is constant.\n   * @property {Boolean} [nullable=false] - Define if the parameter is nullable.\n   * @property {Object} [metas={}] - Optionnal metadata of the parameter.\n   */\n  float: {\n    definitionTemplate: ['default'],\n    typeCheckFunction(value, definition, name) {\n      if (typeof value !== 'number' || value !== value) // reject NaN\n        throw new Error(`Invalid value for float param \"${name}\": ${value}`);\n\n      return clip(value, definition.min, definition.max);\n    }\n  },\n\n  /**\n   * @typedef {Object} stringDefinition\n   * @property {String} [type='string'] - Define a boolean parameter.\n   * @property {Mixed} default - Default value of the parameter.\n   * @property {Boolean} [constant=false] - Define if the parameter is constant.\n   * @property {Boolean} [nullable=false] - Define if the parameter is nullable.\n   * @property {Object} [metas={}] - Optionnal metadata of the parameter.\n   */\n  string: {\n    definitionTemplate: ['default'],\n    typeCheckFunction(value, definition, name) {\n      if (typeof value !== 'string')\n        throw new Error(`Invalid value for string param \"${name}\": ${value}`);\n\n      return value;\n    }\n  },\n\n  /**\n   * @typedef {Object} enumDefinition\n   * @property {String} [type='enum'] - Define a boolean parameter.\n   * @property {Mixed} default - Default value of the parameter.\n   * @property {Array} list - Possible values of the parameter.\n   * @property {Boolean} [constant=false] - Define if the parameter is constant.\n   * @property {Boolean} [nullable=false] - Define if the parameter is nullable.\n   * @property {Object} [metas={}] - Optionnal metadata of the parameter.\n   */\n  enum: {\n    definitionTemplate: ['default', 'list'],\n    typeCheckFunction(value, definition, name) {\n      if (definition.list.indexOf(value) === -1)\n        throw new Error(`Invalid value for enum param \"${name}\": ${value}`);\n\n      return value;\n    }\n  },\n\n  /**\n   * @typedef {Object} anyDefinition\n   * @property {String} [type='enum'] - Define a parameter of any type.\n   * @property {Mixed} default - Default value of the parameter.\n   * @property {Boolean} [constant=false] - Define if the parameter is constant.\n   * @property {Boolean} [nullable=false] - Define if the parameter is nullable.\n   * @property {Object} [metas={}] - Optionnal metadata of the parameter.\n   */\n  any: {\n    definitionTemplate: ['default'],\n    typeCheckFunction(value, definition, name) {\n      // no check as it can have any type...\n      return value;\n    }\n  }\n}\n","import paramTemplates from './paramTemplates';\n\n/**\n * Generic class for typed parameters.\n *\n * @param {String} name - Name of the parameter.\n * @param {Array} definitionTemplate - List of mandatory keys in the param\n *  definition.\n * @param {Function} typeCheckFunction - Function to be used in order to check\n *  the value against the param definition.\n * @param {Object} definition - Definition of the parameter.\n * @param {Mixed} value - Value of the parameter.\n * @private\n */\nclass Param {\n  constructor(name, definitionTemplate, typeCheckFunction, definition, value) {\n    definitionTemplate.forEach(function(key) {\n      if (definition.hasOwnProperty(key) === false)\n        throw new Error(`Invalid definition for param \"${name}\", ${key} is not defined`);\n    });\n\n    this.name = name;\n    this.type = definition.type;\n    this.definition = definition;\n\n    if (this.definition.nullable === true && value === null)\n      this.value = null;\n    else\n      this.value = typeCheckFunction(value, definition, name);\n    this._typeCheckFunction = typeCheckFunction;\n  }\n\n  /**\n   * Returns the current value.\n   * @return {Mixed}\n   */\n  getValue() {\n    return this.value;\n  }\n\n  /**\n   * Update the current value.\n   * @param {Mixed} value - New value of the parameter.\n   * @return {Boolean} - `true` if the param has been updated, false otherwise\n   *  (e.g. if the parameter already had this value).\n   */\n  setValue(value) {\n    if (this.definition.constant === true)\n      throw new Error(`Invalid assignement to constant param \"${this.name}\"`);\n\n    if (!(this.definition.nullable === true && value === null))\n      value = this._typeCheckFunction(value, this.definition, this.name);\n\n    if (this.value !== value) {\n      this.value = value;\n      return true;\n    }\n\n    return false;\n  }\n}\n\n\n/**\n * Bag of parameters. Main interface of the library\n */\nclass ParameterBag {\n  constructor(params, definitions) {\n    /**\n     * List of parameters.\n     *\n     * @type {Object<String, Param>}\n     * @name _params\n     * @memberof ParameterBag\n     * @instance\n     * @private\n     */\n    this._params = params;\n\n    /**\n     * List of definitions with init values.\n     *\n     * @type {Object<String, paramDefinition>}\n     * @name _definitions\n     * @memberof ParameterBag\n     * @instance\n     * @private\n     */\n    this._definitions = definitions;\n\n    /**\n     * List of global listeners.\n     *\n     * @type {Set}\n     * @name _globalListeners\n     * @memberof ParameterBag\n     * @instance\n     * @private\n     */\n    this._globalListeners = new Set();\n\n    /**\n     * List of params listeners.\n     *\n     * @type {Object<String, Set>}\n     * @name _paramsListeners\n     * @memberof ParameterBag\n     * @instance\n     * @private\n     */\n    this._paramsListeners = {};\n\n    // initialize empty Set for each param\n    for (let name in params)\n      this._paramsListeners[name] = new Set();\n  }\n\n  /**\n   * Return the given definitions along with the initialization values.\n   *\n   * @return {Object}\n   */\n  getDefinitions(name = null) {\n    if (name !== null)\n      return this._definitions[name];\n    else\n      return this._definitions;\n  }\n\n  /**\n   * Return the value of the given parameter.\n   *\n   * @param {String} name - Name of the parameter.\n   * @return {Mixed} - Value of the parameter.\n   */\n  get(name) {\n    if (!this._params[name])\n      throw new Error(`Cannot read property value of undefined parameter \"${name}\"`);\n\n    return this._params[name].value;\n  }\n\n  /**\n   * Set the value of a parameter. If the value of the parameter is updated\n   * (aka if previous value is different from new value) all registered\n   * callbacks are registered.\n   *\n   * @param {String} name - Name of the parameter.\n   * @param {Mixed} value - Value of the parameter.\n   * @return {Mixed} - New value of the parameter.\n   */\n  set(name, value) {\n    const param = this._params[name];\n    const updated = param.setValue(value);\n    value = param.getValue();\n\n    if (updated) {\n      const metas = param.definition.metas;\n      // trigger global listeners\n      for (let listener of this._globalListeners)\n        listener(name, value, metas);\n\n      // trigger param listeners\n      for (let listener of this._paramsListeners[name])\n        listener(value, metas);\n    }\n\n    return value;\n  }\n\n  /**\n   * Define if the `name` parameter exists or not.\n   *\n   * @param {String} name - Name of the parameter.\n   * @return {Boolean}\n   */\n  has(name) {\n    return (this._params[name]) ? true : false;\n  }\n\n  /**\n   * Reset a parameter to its init value. Reset all parameters if no argument.\n   *\n   * @param {String} [name=null] - Name of the parameter to reset.\n   */\n  reset(name = null) {\n    if (name !== null)\n      this.set(name, param.definition.initValue);\n    else\n      Object.keys(this._params).forEach((name) => this.reset(name));\n  }\n\n  /**\n   * @callback ParameterBag~listenerCallback\n   * @param {String} name - Parameter name.\n   * @param {Mixed} value - Updated value of the parameter.\n   * @param {Object} [meta=] - Given meta data of the parameter.\n   */\n\n  /**\n   * Add listener to all param updates.\n   *\n   * @param {ParameterBag~listenerCallack} callback - Listener to register.\n   */\n  addListener(callback) {\n    this._globalListeners.add(callback);\n  }\n\n  /**\n   * Remove listener from all param changes.\n   *\n   * @param {ParameterBag~listenerCallack} callback - Listener to remove. If\n   *  `null` remove all listeners.\n   */\n  removeListener(callback = null) {\n    if (callback === null)\n      this._globalListeners.clear();\n    else\n      this._globalListeners.delete(callback);\n  }\n\n  /**\n   * @callback ParameterBag~paramListenerCallack\n   * @param {Mixed} value - Updated value of the parameter.\n   * @param {Object} [meta=] - Given meta data of the parameter.\n   */\n\n  /**\n   * Add listener to a given param updates.\n   *\n   * @param {String} name - Parameter name.\n   * @param {ParameterBag~paramListenerCallack} callback - Function to apply\n   *  when the value of the parameter changes.\n   * @param {Boolean} [trigger=false] - Execute the callback immediately with\n   *  current parameter value.\n   */\n  addParamListener(name, callback, trigger = false) {\n    this._paramsListeners[name].add(callback);\n\n    if (trigger) {\n      const param = this._params[name];\n      const value = param.getValue();\n      const metas = param.definition.metas;\n      callback(value, metas);\n    }\n  }\n\n  /**\n   * Remove listener from a given param updates.\n   *\n   * @param {String} name - Parameter name.\n   * @param {ParameterBag~paramListenerCallack} callback - Listener to remove.\n   *  If `null` remove all listeners.\n   */\n  removeParamListener(name, callback = null) {\n    if (callback === null)\n      this._paramsListeners[name].clear();\n    else\n      this._paramsListeners[name].delete(callback);\n  }\n}\n\n/**\n * Factory for the `ParameterBag` class.\n *\n * @param {Object<String, paramDefinition>} definitions - Object describing the\n *  parameters.\n * @param {Object<String, Mixed>} values - Initialization values for the\n *  parameters.\n * @return {ParameterBag}\n */\nfunction parameters(definitions, values = {}) {\n  const params = {};\n\n  for (let name in values) {\n    if (definitions.hasOwnProperty(name) === false)\n      throw new Error(`Unknown param \"${name}\"`);\n  }\n\n  for (let name in definitions) {\n    if (params.hasOwnProperty(name) === true)\n      throw new Error(`Parameter \"${name}\" already defined`);\n\n    const definition = definitions[name];\n\n    if (!paramTemplates[definition.type])\n      throw new Error(`Unknown param type \"${definition.type}\"`);\n\n    const {\n      definitionTemplate,\n      typeCheckFunction\n    } = paramTemplates[definition.type];\n\n    let value;\n\n    if (values.hasOwnProperty(name) === true)\n      value = values[name];\n    else\n      value = definition.default;\n\n    // store init value in definition\n    definition.initValue = value;\n\n    if (!typeCheckFunction || !definitionTemplate)\n      throw new Error(`Invalid param type definition \"${definition.type}\"`);\n\n    params[name] = new Param(name, definitionTemplate, typeCheckFunction, definition, value);\n  }\n\n  return new ParameterBag(params, definitions);\n}\n\n/**\n * Register a new type for the `parameters` factory.\n * @param {String} typeName - Value that will be available as the `type` of a\n *  param definition.\n * @param {parameterDefinition} parameterDefinition - Object describing the\n *  parameter.\n */\nparameters.defineType = function(typeName, parameterDefinition) {\n  paramTemplates[typeName] = parameterDefinition;\n}\n\nexport default parameters;\n","module.exports = { \"default\": require(\"core-js/library/fn/json/stringify\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/math/log10\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/number/is-finite\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/object/assign\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/object/create\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/object/define-property\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/object/get-own-property-descriptor\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/object/get-prototype-of\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/object/set-prototype-of\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/promise\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/symbol\"), __esModule: true };","module.exports = { \"default\": require(\"core-js/library/fn/symbol/iterator\"), __esModule: true };","\"use strict\";\n\nexports.__esModule = true;\n\nexports.default = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};","\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      (0, _defineProperty2.default)(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();","\"use strict\";\n\nexports.__esModule = true;\n\nvar _defineProperty = require(\"../core-js/object/define-property\");\n\nvar _defineProperty2 = _interopRequireDefault(_defineProperty);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (obj, key, value) {\n  if (key in obj) {\n    (0, _defineProperty2.default)(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};","\"use strict\";\n\nexports.__esModule = true;\n\nvar _getPrototypeOf = require(\"../core-js/object/get-prototype-of\");\n\nvar _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);\n\nvar _getOwnPropertyDescriptor = require(\"../core-js/object/get-own-property-descriptor\");\n\nvar _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function get(object, property, receiver) {\n  if (object === null) object = Function.prototype;\n  var desc = (0, _getOwnPropertyDescriptor2.default)(object, property);\n\n  if (desc === undefined) {\n    var parent = (0, _getPrototypeOf2.default)(object);\n\n    if (parent === null) {\n      return undefined;\n    } else {\n      return get(parent, property, receiver);\n    }\n  } else if (\"value\" in desc) {\n    return desc.value;\n  } else {\n    var getter = desc.get;\n\n    if (getter === undefined) {\n      return undefined;\n    }\n\n    return getter.call(receiver);\n  }\n};","\"use strict\";\n\nexports.__esModule = true;\n\nvar _setPrototypeOf = require(\"../core-js/object/set-prototype-of\");\n\nvar _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);\n\nvar _create = require(\"../core-js/object/create\");\n\nvar _create2 = _interopRequireDefault(_create);\n\nvar _typeof2 = require(\"../helpers/typeof\");\n\nvar _typeof3 = _interopRequireDefault(_typeof2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + (typeof superClass === \"undefined\" ? \"undefined\" : (0, _typeof3.default)(superClass)));\n  }\n\n  subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass;\n};","\"use strict\";\n\nexports.__esModule = true;\n\nvar _typeof2 = require(\"../helpers/typeof\");\n\nvar _typeof3 = _interopRequireDefault(_typeof2);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && ((typeof call === \"undefined\" ? \"undefined\" : (0, _typeof3.default)(call)) === \"object\" || typeof call === \"function\") ? call : self;\n};","\"use strict\";\n\nexports.__esModule = true;\n\nvar _iterator = require(\"../core-js/symbol/iterator\");\n\nvar _iterator2 = _interopRequireDefault(_iterator);\n\nvar _symbol = require(\"../core-js/symbol\");\n\nvar _symbol2 = _interopRequireDefault(_symbol);\n\nvar _typeof = typeof _symbol2.default === \"function\" && typeof _iterator2.default === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? \"symbol\" : typeof obj; };\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nexports.default = typeof _symbol2.default === \"function\" && _typeof(_iterator2.default) === \"symbol\" ? function (obj) {\n  return typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n} : function (obj) {\n  return obj && typeof _symbol2.default === \"function\" && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? \"symbol\" : typeof obj === \"undefined\" ? \"undefined\" : _typeof(obj);\n};","var core = require('../../modules/_core');\nvar $JSON = core.JSON || (core.JSON = { stringify: JSON.stringify });\nmodule.exports = function stringify(it) { // eslint-disable-line no-unused-vars\n  return $JSON.stringify.apply($JSON, arguments);\n};\n","require('../../modules/es6.math.log10');\nmodule.exports = require('../../modules/_core').Math.log10;\n","require('../../modules/es6.number.is-finite');\nmodule.exports = require('../../modules/_core').Number.isFinite;\n","require('../../modules/es6.object.assign');\nmodule.exports = require('../../modules/_core').Object.assign;\n","require('../../modules/es6.object.create');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function create(P, D) {\n  return $Object.create(P, D);\n};\n","require('../../modules/es6.object.define-property');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function defineProperty(it, key, desc) {\n  return $Object.defineProperty(it, key, desc);\n};\n","require('../../modules/es6.object.get-own-property-descriptor');\nvar $Object = require('../../modules/_core').Object;\nmodule.exports = function getOwnPropertyDescriptor(it, key) {\n  return $Object.getOwnPropertyDescriptor(it, key);\n};\n","require('../../modules/es6.object.get-prototype-of');\nmodule.exports = require('../../modules/_core').Object.getPrototypeOf;\n","require('../../modules/es6.object.set-prototype-of');\nmodule.exports = require('../../modules/_core').Object.setPrototypeOf;\n","require('../modules/es6.object.to-string');\nrequire('../modules/es6.string.iterator');\nrequire('../modules/web.dom.iterable');\nrequire('../modules/es6.promise');\nrequire('../modules/es7.promise.finally');\nrequire('../modules/es7.promise.try');\nmodule.exports = require('../modules/_core').Promise;\n","require('../../modules/es6.symbol');\nrequire('../../modules/es6.object.to-string');\nrequire('../../modules/es7.symbol.async-iterator');\nrequire('../../modules/es7.symbol.observable');\nmodule.exports = require('../../modules/_core').Symbol;\n","require('../../modules/es6.string.iterator');\nrequire('../../modules/web.dom.iterable');\nmodule.exports = require('../../modules/_wks-ext').f('iterator');\n","module.exports = function (it) {\n  if (typeof it != 'function') throw TypeError(it + ' is not a function!');\n  return it;\n};\n","module.exports = function () { /* empty */ };\n","module.exports = function (it, Constructor, name, forbiddenField) {\n  if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {\n    throw TypeError(name + ': incorrect invocation!');\n  } return it;\n};\n","var isObject = require('./_is-object');\nmodule.exports = function (it) {\n  if (!isObject(it)) throw TypeError(it + ' is not an object!');\n  return it;\n};\n","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject');\nvar toLength = require('./_to-length');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nmodule.exports = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {\n      if (O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof');\nvar TAG = require('./_wks')('toStringTag');\n// ES3 wrong here\nvar ARG = cof(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (e) { /* empty */ }\n};\n\nmodule.exports = function (it) {\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","var core = module.exports = { version: '2.5.2' };\nif (typeof __e == 'number') __e = core; // eslint-disable-line no-undef\n","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function () {\n  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;\n});\n","var isObject = require('./_is-object');\nvar document = require('./_global').document;\n// typeof document.createElement is 'object' in old IE\nvar is = isObject(document) && isObject(document.createElement);\nmodule.exports = function (it) {\n  return is ? document.createElement(it) : {};\n};\n","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n","// all enumerable object keys, includes symbols\nvar getKeys = require('./_object-keys');\nvar gOPS = require('./_object-gops');\nvar pIE = require('./_object-pie');\nmodule.exports = function (it) {\n  var result = getKeys(it);\n  var getSymbols = gOPS.f;\n  if (getSymbols) {\n    var symbols = getSymbols(it);\n    var isEnum = pIE.f;\n    var i = 0;\n    var key;\n    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);\n  } return result;\n};\n","var global = require('./_global');\nvar core = require('./_core');\nvar ctx = require('./_ctx');\nvar hide = require('./_hide');\nvar PROTOTYPE = 'prototype';\n\nvar $export = function (type, name, source) {\n  var IS_FORCED = type & $export.F;\n  var IS_GLOBAL = type & $export.G;\n  var IS_STATIC = type & $export.S;\n  var IS_PROTO = type & $export.P;\n  var IS_BIND = type & $export.B;\n  var IS_WRAP = type & $export.W;\n  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});\n  var expProto = exports[PROTOTYPE];\n  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];\n  var key, own, out;\n  if (IS_GLOBAL) source = name;\n  for (key in source) {\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    if (own && key in exports) continue;\n    // export native or passed\n    out = own ? target[key] : source[key];\n    // prevent global pollution for namespaces\n    exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]\n    // bind timers to global for call from export context\n    : IS_BIND && own ? ctx(out, global)\n    // wrap global constructors for prevent change them in library\n    : IS_WRAP && target[key] == out ? (function (C) {\n      var F = function (a, b, c) {\n        if (this instanceof C) {\n          switch (arguments.length) {\n            case 0: return new C();\n            case 1: return new C(a);\n            case 2: return new C(a, b);\n          } return new C(a, b, c);\n        } return C.apply(this, arguments);\n      };\n      F[PROTOTYPE] = C[PROTOTYPE];\n      return F;\n    // make static versions for prototype methods\n    })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%\n    if (IS_PROTO) {\n      (exports.virtual || (exports.virtual = {}))[key] = out;\n      // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%\n      if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);\n    }\n  }\n};\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library`\nmodule.exports = $export;\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (e) {\n    return true;\n  }\n};\n","var ctx = require('./_ctx');\nvar call = require('./_iter-call');\nvar isArrayIter = require('./_is-array-iter');\nvar anObject = require('./_an-object');\nvar toLength = require('./_to-length');\nvar getIterFn = require('./core.get-iterator-method');\nvar BREAK = {};\nvar RETURN = {};\nvar exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {\n  var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);\n  var f = ctx(fn, that, entries ? 2 : 1);\n  var index = 0;\n  var length, step, iterator, result;\n  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');\n  // fast case for arrays with default iterator\n  if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {\n    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n    if (result === BREAK || result === RETURN) return result;\n  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {\n    result = call(iterator, f, step.value, entries);\n    if (result === BREAK || result === RETURN) return result;\n  }\n};\nexports.BREAK = BREAK;\nexports.RETURN = RETURN;\n","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self\n  // eslint-disable-next-line no-new-func\n  : Function('return this')();\nif (typeof __g == 'number') __g = global; // eslint-disable-line no-undef\n","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","var dP = require('./_object-dp');\nvar createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function (object, key, value) {\n  return dP.f(object, key, createDesc(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","var document = require('./_global').document;\nmodule.exports = document && document.documentElement;\n","module.exports = !require('./_descriptors') && !require('./_fails')(function () {\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function () { return 7; } }).a != 7;\n});\n","// fast apply, http://jsperf.lnkit.com/fast-apply/5\nmodule.exports = function (fn, args, that) {\n  var un = that === undefined;\n  switch (args.length) {\n    case 0: return un ? fn()\n                      : fn.call(that);\n    case 1: return un ? fn(args[0])\n                      : fn.call(that, args[0]);\n    case 2: return un ? fn(args[0], args[1])\n                      : fn.call(that, args[0], args[1]);\n    case 3: return un ? fn(args[0], args[1], args[2])\n                      : fn.call(that, args[0], args[1], args[2]);\n    case 4: return un ? fn(args[0], args[1], args[2], args[3])\n                      : fn.call(that, args[0], args[1], args[2], args[3]);\n  } return fn.apply(that, args);\n};\n","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\n// eslint-disable-next-line no-prototype-builtins\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n","// check on default Array iterator\nvar Iterators = require('./_iterators');\nvar ITERATOR = require('./_wks')('iterator');\nvar ArrayProto = Array.prototype;\n\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n","// 7.2.2 IsArray(argument)\nvar cof = require('./_cof');\nmodule.exports = Array.isArray || function isArray(arg) {\n  return cof(arg) == 'Array';\n};\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function (iterator, fn, value, entries) {\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch (e) {\n    var ret = iterator['return'];\n    if (ret !== undefined) anObject(ret.call(iterator));\n    throw e;\n  }\n};\n","'use strict';\nvar create = require('./_object-create');\nvar descriptor = require('./_property-desc');\nvar setToStringTag = require('./_set-to-string-tag');\nvar IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function () { return this; });\n\nmodule.exports = function (Constructor, NAME, next) {\n  Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n","'use strict';\nvar LIBRARY = require('./_library');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar hide = require('./_hide');\nvar has = require('./_has');\nvar Iterators = require('./_iterators');\nvar $iterCreate = require('./_iter-create');\nvar setToStringTag = require('./_set-to-string-tag');\nvar getPrototypeOf = require('./_object-gpo');\nvar ITERATOR = require('./_wks')('iterator');\nvar BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`\nvar FF_ITERATOR = '@@iterator';\nvar KEYS = 'keys';\nvar VALUES = 'values';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function (kind) {\n    if (!BUGGY && kind in proto) return proto[kind];\n    switch (kind) {\n      case KEYS: return function keys() { return new Constructor(this, kind); };\n      case VALUES: return function values() { return new Constructor(this, kind); };\n    } return function entries() { return new Constructor(this, kind); };\n  };\n  var TAG = NAME + ' Iterator';\n  var DEF_VALUES = DEFAULT == VALUES;\n  var VALUES_BUG = false;\n  var proto = Base.prototype;\n  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];\n  var $default = $native || getMethod(DEFAULT);\n  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;\n  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;\n  var methods, key, IteratorPrototype;\n  // Fix native\n  if ($anyNative) {\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));\n    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if (!LIBRARY && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if (DEF_VALUES && $native && $native.name !== VALUES) {\n    VALUES_BUG = true;\n    $default = function values() { return $native.call(this); };\n  }\n  // Define iterator\n  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG] = returnThis;\n  if (DEFAULT) {\n    methods = {\n      values: DEF_VALUES ? $default : getMethod(VALUES),\n      keys: IS_SET ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if (FORCED) for (key in methods) {\n      if (!(key in proto)) redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n","var ITERATOR = require('./_wks')('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var riter = [7][ITERATOR]();\n  riter['return'] = function () { SAFE_CLOSING = true; };\n  // eslint-disable-next-line no-throw-literal\n  Array.from(riter, function () { throw 2; });\n} catch (e) { /* empty */ }\n\nmodule.exports = function (exec, skipClosing) {\n  if (!skipClosing && !SAFE_CLOSING) return false;\n  var safe = false;\n  try {\n    var arr = [7];\n    var iter = arr[ITERATOR]();\n    iter.next = function () { return { done: safe = true }; };\n    arr[ITERATOR] = function () { return iter; };\n    exec(arr);\n  } catch (e) { /* empty */ }\n  return safe;\n};\n","module.exports = function (done, value) {\n  return { value: value, done: !!done };\n};\n","module.exports = {};\n","module.exports = true;\n","var META = require('./_uid')('meta');\nvar isObject = require('./_is-object');\nvar has = require('./_has');\nvar setDesc = require('./_object-dp').f;\nvar id = 0;\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\nvar FREEZE = !require('./_fails')(function () {\n  return isExtensible(Object.preventExtensions({}));\n});\nvar setMeta = function (it) {\n  setDesc(it, META, { value: {\n    i: 'O' + ++id, // object ID\n    w: {}          // weak collections IDs\n  } });\n};\nvar fastKey = function (it, create) {\n  // return primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!has(it, META)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMeta(it);\n  // return object ID\n  } return it[META].i;\n};\nvar getWeak = function (it, create) {\n  if (!has(it, META)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMeta(it);\n  // return hash weak collections IDs\n  } return it[META].w;\n};\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);\n  return it;\n};\nvar meta = module.exports = {\n  KEY: META,\n  NEED: false,\n  fastKey: fastKey,\n  getWeak: getWeak,\n  onFreeze: onFreeze\n};\n","var global = require('./_global');\nvar macrotask = require('./_task').set;\nvar Observer = global.MutationObserver || global.WebKitMutationObserver;\nvar process = global.process;\nvar Promise = global.Promise;\nvar isNode = require('./_cof')(process) == 'process';\n\nmodule.exports = function () {\n  var head, last, notify;\n\n  var flush = function () {\n    var parent, fn;\n    if (isNode && (parent = process.domain)) parent.exit();\n    while (head) {\n      fn = head.fn;\n      head = head.next;\n      try {\n        fn();\n      } catch (e) {\n        if (head) notify();\n        else last = undefined;\n        throw e;\n      }\n    } last = undefined;\n    if (parent) parent.enter();\n  };\n\n  // Node.js\n  if (isNode) {\n    notify = function () {\n      process.nextTick(flush);\n    };\n  // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339\n  } else if (Observer && !(global.navigator && global.navigator.standalone)) {\n    var toggle = true;\n    var node = document.createTextNode('');\n    new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new\n    notify = function () {\n      node.data = toggle = !toggle;\n    };\n  // environments with maybe non-completely correct, but existent Promise\n  } else if (Promise && Promise.resolve) {\n    var promise = Promise.resolve();\n    notify = function () {\n      promise.then(flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    notify = function () {\n      // strange IE + webpack dev server bug - use .call(global)\n      macrotask.call(global, flush);\n    };\n  }\n\n  return function (fn) {\n    var task = { fn: fn, next: undefined };\n    if (last) last.next = task;\n    if (!head) {\n      head = task;\n      notify();\n    } last = task;\n  };\n};\n","'use strict';\n// 25.4.1.5 NewPromiseCapability(C)\nvar aFunction = require('./_a-function');\n\nfunction PromiseCapability(C) {\n  var resolve, reject;\n  this.promise = new C(function ($$resolve, $$reject) {\n    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject = $$reject;\n  });\n  this.resolve = aFunction(resolve);\n  this.reject = aFunction(reject);\n}\n\nmodule.exports.f = function (C) {\n  return new PromiseCapability(C);\n};\n","'use strict';\n// 19.1.2.1 Object.assign(target, source, ...)\nvar getKeys = require('./_object-keys');\nvar gOPS = require('./_object-gops');\nvar pIE = require('./_object-pie');\nvar toObject = require('./_to-object');\nvar IObject = require('./_iobject');\nvar $assign = Object.assign;\n\n// should work with symbols and should have deterministic property order (V8 bug)\nmodule.exports = !$assign || require('./_fails')(function () {\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line no-undef\n  var S = Symbol();\n  var K = 'abcdefghijklmnopqrst';\n  A[S] = 7;\n  K.split('').forEach(function (k) { B[k] = k; });\n  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars\n  var T = toObject(target);\n  var aLen = arguments.length;\n  var index = 1;\n  var getSymbols = gOPS.f;\n  var isEnum = pIE.f;\n  while (aLen > index) {\n    var S = IObject(arguments[index++]);\n    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];\n  } return T;\n} : $assign;\n","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject = require('./_an-object');\nvar dPs = require('./_object-dps');\nvar enumBugKeys = require('./_enum-bug-keys');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar Empty = function () { /* empty */ };\nvar PROTOTYPE = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = require('./_dom-create')('iframe');\n  var i = enumBugKeys.length;\n  var lt = '<';\n  var gt = '>';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  require('./_html').appendChild(iframe);\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n  // createDict = iframe.contentWindow.Object;\n  // html.removeChild(iframe);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n  iframeDocument.close();\n  createDict = iframeDocument.F;\n  while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];\n  return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    Empty[PROTOTYPE] = anObject(O);\n    result = new Empty();\n    Empty[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = createDict();\n  return Properties === undefined ? result : dPs(result, Properties);\n};\n","var anObject = require('./_an-object');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar toPrimitive = require('./_to-primitive');\nvar dP = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return dP(O, P, Attributes);\n  } catch (e) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var dP = require('./_object-dp');\nvar anObject = require('./_an-object');\nvar getKeys = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = getKeys(Properties);\n  var length = keys.length;\n  var i = 0;\n  var P;\n  while (length > i) dP.f(O, P = keys[i++], Properties[P]);\n  return O;\n};\n","var pIE = require('./_object-pie');\nvar createDesc = require('./_property-desc');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar has = require('./_has');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P) {\n  O = toIObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return gOPD(O, P);\n  } catch (e) { /* empty */ }\n  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);\n};\n","// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nvar toIObject = require('./_to-iobject');\nvar gOPN = require('./_object-gopn').f;\nvar toString = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return gOPN(it);\n  } catch (e) {\n    return windowNames.slice();\n  }\n};\n\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));\n};\n","// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)\nvar $keys = require('./_object-keys-internal');\nvar hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');\n\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return $keys(O, hiddenKeys);\n};\n","exports.f = Object.getOwnPropertySymbols;\n","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has = require('./_has');\nvar toObject = require('./_to-object');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n","var has = require('./_has');\nvar toIObject = require('./_to-iobject');\nvar arrayIndexOf = require('./_array-includes')(false);\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function (object, names) {\n  var O = toIObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal');\nvar enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O) {\n  return $keys(O, enumBugKeys);\n};\n","exports.f = {}.propertyIsEnumerable;\n","// most Object methods by ES6 should accept primitives\nvar $export = require('./_export');\nvar core = require('./_core');\nvar fails = require('./_fails');\nmodule.exports = function (KEY, exec) {\n  var fn = (core.Object || {})[KEY] || Object[KEY];\n  var exp = {};\n  exp[KEY] = exec(fn);\n  $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);\n};\n","module.exports = function (exec) {\n  try {\n    return { e: false, v: exec() };\n  } catch (e) {\n    return { e: true, v: e };\n  }\n};\n","var anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar newPromiseCapability = require('./_new-promise-capability');\n\nmodule.exports = function (C, x) {\n  anObject(C);\n  if (isObject(x) && x.constructor === C) return x;\n  var promiseCapability = newPromiseCapability.f(C);\n  var resolve = promiseCapability.resolve;\n  resolve(x);\n  return promiseCapability.promise;\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","var hide = require('./_hide');\nmodule.exports = function (target, src, safe) {\n  for (var key in src) {\n    if (safe && target[key]) target[key] = src[key];\n    else hide(target, key, src[key]);\n  } return target;\n};\n","module.exports = require('./_hide');\n","// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nvar isObject = require('./_is-object');\nvar anObject = require('./_an-object');\nvar check = function (O, proto) {\n  anObject(O);\n  if (!isObject(proto) && proto !== null) throw TypeError(proto + \": can't set as prototype!\");\n};\nmodule.exports = {\n  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line\n    function (test, buggy, set) {\n      try {\n        set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);\n        set(test, []);\n        buggy = !(test instanceof Array);\n      } catch (e) { buggy = true; }\n      return function setPrototypeOf(O, proto) {\n        check(O, proto);\n        if (buggy) O.__proto__ = proto;\n        else set(O, proto);\n        return O;\n      };\n    }({}, false) : undefined),\n  check: check\n};\n","'use strict';\nvar global = require('./_global');\nvar core = require('./_core');\nvar dP = require('./_object-dp');\nvar DESCRIPTORS = require('./_descriptors');\nvar SPECIES = require('./_wks')('species');\n\nmodule.exports = function (KEY) {\n  var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];\n  if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {\n    configurable: true,\n    get: function () { return this; }\n  });\n};\n","var def = require('./_object-dp').f;\nvar has = require('./_has');\nvar TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function (it, tag, stat) {\n  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });\n};\n","var shared = require('./_shared')('keys');\nvar uid = require('./_uid');\nmodule.exports = function (key) {\n  return shared[key] || (shared[key] = uid(key));\n};\n","var global = require('./_global');\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || (global[SHARED] = {});\nmodule.exports = function (key) {\n  return store[key] || (store[key] = {});\n};\n","// 7.3.20 SpeciesConstructor(O, defaultConstructor)\nvar anObject = require('./_an-object');\nvar aFunction = require('./_a-function');\nvar SPECIES = require('./_wks')('species');\nmodule.exports = function (O, D) {\n  var C = anObject(O).constructor;\n  var S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);\n};\n","var toInteger = require('./_to-integer');\nvar defined = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function (TO_STRING) {\n  return function (that, pos) {\n    var s = String(defined(that));\n    var i = toInteger(pos);\n    var l = s.length;\n    var a, b;\n    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n","var ctx = require('./_ctx');\nvar invoke = require('./_invoke');\nvar html = require('./_html');\nvar cel = require('./_dom-create');\nvar global = require('./_global');\nvar process = global.process;\nvar setTask = global.setImmediate;\nvar clearTask = global.clearImmediate;\nvar MessageChannel = global.MessageChannel;\nvar Dispatch = global.Dispatch;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar defer, channel, port;\nvar run = function () {\n  var id = +this;\n  // eslint-disable-next-line no-prototype-builtins\n  if (queue.hasOwnProperty(id)) {\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\nvar listener = function (event) {\n  run.call(event.data);\n};\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!setTask || !clearTask) {\n  setTask = function setImmediate(fn) {\n    var args = [];\n    var i = 1;\n    while (arguments.length > i) args.push(arguments[i++]);\n    queue[++counter] = function () {\n      // eslint-disable-next-line no-new-func\n      invoke(typeof fn == 'function' ? fn : Function(fn), args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clearTask = function clearImmediate(id) {\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if (require('./_cof')(process) == 'process') {\n    defer = function (id) {\n      process.nextTick(ctx(run, id, 1));\n    };\n  // Sphere (JS game engine) Dispatch API\n  } else if (Dispatch && Dispatch.now) {\n    defer = function (id) {\n      Dispatch.now(ctx(run, id, 1));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  } else if (MessageChannel) {\n    channel = new MessageChannel();\n    port = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = ctx(port.postMessage, port, 1);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {\n    defer = function (id) {\n      global.postMessage(id + '', '*');\n    };\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if (ONREADYSTATECHANGE in cel('script')) {\n    defer = function (id) {\n      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {\n        html.removeChild(this);\n        run.call(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function (id) {\n      setTimeout(ctx(run, id, 1), 0);\n    };\n  }\n}\nmodule.exports = {\n  set: setTask,\n  clear: clearTask\n};\n","var toInteger = require('./_to-integer');\nvar max = Math.max;\nvar min = Math.min;\nmodule.exports = function (index, length) {\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n","// 7.1.4 ToInteger\nvar ceil = Math.ceil;\nvar floor = Math.floor;\nmodule.exports = function (it) {\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject');\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return IObject(defined(it));\n};\n","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer');\nvar min = Math.min;\nmodule.exports = function (it) {\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return Object(defined(it));\n};\n","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (it, S) {\n  if (!isObject(it)) return it;\n  var fn, val;\n  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","var id = 0;\nvar px = Math.random();\nmodule.exports = function (key) {\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n","var global = require('./_global');\nvar core = require('./_core');\nvar LIBRARY = require('./_library');\nvar wksExt = require('./_wks-ext');\nvar defineProperty = require('./_object-dp').f;\nmodule.exports = function (name) {\n  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});\n  if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });\n};\n","exports.f = require('./_wks');\n","var store = require('./_shared')('wks');\nvar uid = require('./_uid');\nvar Symbol = require('./_global').Symbol;\nvar USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function (name) {\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n","var classof = require('./_classof');\nvar ITERATOR = require('./_wks')('iterator');\nvar Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function (it) {\n  if (it != undefined) return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables');\nvar step = require('./_iter-step');\nvar Iterators = require('./_iterators');\nvar toIObject = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function (iterated, kind) {\n  this._t = toIObject(iterated); // target\n  this._i = 0;                   // next index\n  this._k = kind;                // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function () {\n  var O = this._t;\n  var kind = this._k;\n  var index = this._i++;\n  if (!O || index >= O.length) {\n    this._t = undefined;\n    return step(1);\n  }\n  if (kind == 'keys') return step(0, index);\n  if (kind == 'values') return step(0, O[index]);\n  return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","// 20.2.2.21 Math.log10(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  log10: function log10(x) {\n    return Math.log(x) * Math.LOG10E;\n  }\n});\n","// 20.1.2.2 Number.isFinite(number)\nvar $export = require('./_export');\nvar _isFinite = require('./_global').isFinite;\n\n$export($export.S, 'Number', {\n  isFinite: function isFinite(it) {\n    return typeof it == 'number' && _isFinite(it);\n  }\n});\n","// 19.1.3.1 Object.assign(target, source)\nvar $export = require('./_export');\n\n$export($export.S + $export.F, 'Object', { assign: require('./_object-assign') });\n","var $export = require('./_export');\n// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\n$export($export.S, 'Object', { create: require('./_object-create') });\n","var $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperty: require('./_object-dp').f });\n","// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\nvar toIObject = require('./_to-iobject');\nvar $getOwnPropertyDescriptor = require('./_object-gopd').f;\n\nrequire('./_object-sap')('getOwnPropertyDescriptor', function () {\n  return function getOwnPropertyDescriptor(it, key) {\n    return $getOwnPropertyDescriptor(toIObject(it), key);\n  };\n});\n","// 19.1.2.9 Object.getPrototypeOf(O)\nvar toObject = require('./_to-object');\nvar $getPrototypeOf = require('./_object-gpo');\n\nrequire('./_object-sap')('getPrototypeOf', function () {\n  return function getPrototypeOf(it) {\n    return $getPrototypeOf(toObject(it));\n  };\n});\n","// 19.1.3.19 Object.setPrototypeOf(O, proto)\nvar $export = require('./_export');\n$export($export.S, 'Object', { setPrototypeOf: require('./_set-proto').set });\n","","'use strict';\nvar LIBRARY = require('./_library');\nvar global = require('./_global');\nvar ctx = require('./_ctx');\nvar classof = require('./_classof');\nvar $export = require('./_export');\nvar isObject = require('./_is-object');\nvar aFunction = require('./_a-function');\nvar anInstance = require('./_an-instance');\nvar forOf = require('./_for-of');\nvar speciesConstructor = require('./_species-constructor');\nvar task = require('./_task').set;\nvar microtask = require('./_microtask')();\nvar newPromiseCapabilityModule = require('./_new-promise-capability');\nvar perform = require('./_perform');\nvar promiseResolve = require('./_promise-resolve');\nvar PROMISE = 'Promise';\nvar TypeError = global.TypeError;\nvar process = global.process;\nvar $Promise = global[PROMISE];\nvar isNode = classof(process) == 'process';\nvar empty = function () { /* empty */ };\nvar Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;\nvar newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;\n\nvar USE_NATIVE = !!function () {\n  try {\n    // correct subclassing with @@species support\n    var promise = $Promise.resolve(1);\n    var FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function (exec) {\n      exec(empty, empty);\n    };\n    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;\n  } catch (e) { /* empty */ }\n}();\n\n// helpers\nvar isThenable = function (it) {\n  var then;\n  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n};\nvar notify = function (promise, isReject) {\n  if (promise._n) return;\n  promise._n = true;\n  var chain = promise._c;\n  microtask(function () {\n    var value = promise._v;\n    var ok = promise._s == 1;\n    var i = 0;\n    var run = function (reaction) {\n      var handler = ok ? reaction.ok : reaction.fail;\n      var resolve = reaction.resolve;\n      var reject = reaction.reject;\n      var domain = reaction.domain;\n      var result, then;\n      try {\n        if (handler) {\n          if (!ok) {\n            if (promise._h == 2) onHandleUnhandled(promise);\n            promise._h = 1;\n          }\n          if (handler === true) result = value;\n          else {\n            if (domain) domain.enter();\n            result = handler(value);\n            if (domain) domain.exit();\n          }\n          if (result === reaction.promise) {\n            reject(TypeError('Promise-chain cycle'));\n          } else if (then = isThenable(result)) {\n            then.call(result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch (e) {\n        reject(e);\n      }\n    };\n    while (chain.length > i) run(chain[i++]); // variable length - can't use forEach\n    promise._c = [];\n    promise._n = false;\n    if (isReject && !promise._h) onUnhandled(promise);\n  });\n};\nvar onUnhandled = function (promise) {\n  task.call(global, function () {\n    var value = promise._v;\n    var unhandled = isUnhandled(promise);\n    var result, handler, console;\n    if (unhandled) {\n      result = perform(function () {\n        if (isNode) {\n          process.emit('unhandledRejection', value, promise);\n        } else if (handler = global.onunhandledrejection) {\n          handler({ promise: promise, reason: value });\n        } else if ((console = global.console) && console.error) {\n          console.error('Unhandled promise rejection', value);\n        }\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      promise._h = isNode || isUnhandled(promise) ? 2 : 1;\n    } promise._a = undefined;\n    if (unhandled && result.e) throw result.v;\n  });\n};\nvar isUnhandled = function (promise) {\n  if (promise._h == 1) return false;\n  var chain = promise._a || promise._c;\n  var i = 0;\n  var reaction;\n  while (chain.length > i) {\n    reaction = chain[i++];\n    if (reaction.fail || !isUnhandled(reaction.promise)) return false;\n  } return true;\n};\nvar onHandleUnhandled = function (promise) {\n  task.call(global, function () {\n    var handler;\n    if (isNode) {\n      process.emit('rejectionHandled', promise);\n    } else if (handler = global.onrejectionhandled) {\n      handler({ promise: promise, reason: promise._v });\n    }\n  });\n};\nvar $reject = function (value) {\n  var promise = this;\n  if (promise._d) return;\n  promise._d = true;\n  promise = promise._w || promise; // unwrap\n  promise._v = value;\n  promise._s = 2;\n  if (!promise._a) promise._a = promise._c.slice();\n  notify(promise, true);\n};\nvar $resolve = function (value) {\n  var promise = this;\n  var then;\n  if (promise._d) return;\n  promise._d = true;\n  promise = promise._w || promise; // unwrap\n  try {\n    if (promise === value) throw TypeError(\"Promise can't be resolved itself\");\n    if (then = isThenable(value)) {\n      microtask(function () {\n        var wrapper = { _w: promise, _d: false }; // wrap\n        try {\n          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));\n        } catch (e) {\n          $reject.call(wrapper, e);\n        }\n      });\n    } else {\n      promise._v = value;\n      promise._s = 1;\n      notify(promise, false);\n    }\n  } catch (e) {\n    $reject.call({ _w: promise, _d: false }, e); // wrap\n  }\n};\n\n// constructor polyfill\nif (!USE_NATIVE) {\n  // 25.4.3.1 Promise(executor)\n  $Promise = function Promise(executor) {\n    anInstance(this, $Promise, PROMISE, '_h');\n    aFunction(executor);\n    Internal.call(this);\n    try {\n      executor(ctx($resolve, this, 1), ctx($reject, this, 1));\n    } catch (err) {\n      $reject.call(this, err);\n    }\n  };\n  // eslint-disable-next-line no-unused-vars\n  Internal = function Promise(executor) {\n    this._c = [];             // <- awaiting reactions\n    this._a = undefined;      // <- checked in isUnhandled reactions\n    this._s = 0;              // <- state\n    this._d = false;          // <- done\n    this._v = undefined;      // <- value\n    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled\n    this._n = false;          // <- notify\n  };\n  Internal.prototype = require('./_redefine-all')($Promise.prototype, {\n    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)\n    then: function then(onFulfilled, onRejected) {\n      var reaction = newPromiseCapability(speciesConstructor(this, $Promise));\n      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;\n      reaction.fail = typeof onRejected == 'function' && onRejected;\n      reaction.domain = isNode ? process.domain : undefined;\n      this._c.push(reaction);\n      if (this._a) this._a.push(reaction);\n      if (this._s) notify(this, false);\n      return reaction.promise;\n    },\n    // 25.4.5.1 Promise.prototype.catch(onRejected)\n    'catch': function (onRejected) {\n      return this.then(undefined, onRejected);\n    }\n  });\n  OwnPromiseCapability = function () {\n    var promise = new Internal();\n    this.promise = promise;\n    this.resolve = ctx($resolve, promise, 1);\n    this.reject = ctx($reject, promise, 1);\n  };\n  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n    return C === $Promise || C === Wrapper\n      ? new OwnPromiseCapability(C)\n      : newGenericPromiseCapability(C);\n  };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });\nrequire('./_set-to-string-tag')($Promise, PROMISE);\nrequire('./_set-species')(PROMISE);\nWrapper = require('./_core')[PROMISE];\n\n// statics\n$export($export.S + $export.F * !USE_NATIVE, PROMISE, {\n  // 25.4.4.5 Promise.reject(r)\n  reject: function reject(r) {\n    var capability = newPromiseCapability(this);\n    var $$reject = capability.reject;\n    $$reject(r);\n    return capability.promise;\n  }\n});\n$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {\n  // 25.4.4.6 Promise.resolve(x)\n  resolve: function resolve(x) {\n    return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x);\n  }\n});\n$export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function (iter) {\n  $Promise.all(iter)['catch'](empty);\n})), PROMISE, {\n  // 25.4.4.1 Promise.all(iterable)\n  all: function all(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var values = [];\n      var index = 0;\n      var remaining = 1;\n      forOf(iterable, false, function (promise) {\n        var $index = index++;\n        var alreadyCalled = false;\n        values.push(undefined);\n        remaining++;\n        C.resolve(promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[$index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if (result.e) reject(result.v);\n    return capability.promise;\n  },\n  // 25.4.4.4 Promise.race(iterable)\n  race: function race(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var reject = capability.reject;\n    var result = perform(function () {\n      forOf(iterable, false, function (promise) {\n        C.resolve(promise).then(capability.resolve, reject);\n      });\n    });\n    if (result.e) reject(result.v);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $at = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function (iterated) {\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function () {\n  var O = this._t;\n  var index = this._i;\n  var point;\n  if (index >= O.length) return { value: undefined, done: true };\n  point = $at(O, index);\n  this._i += point.length;\n  return { value: point, done: false };\n});\n","'use strict';\n// ECMAScript 6 symbols shim\nvar global = require('./_global');\nvar has = require('./_has');\nvar DESCRIPTORS = require('./_descriptors');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar META = require('./_meta').KEY;\nvar $fails = require('./_fails');\nvar shared = require('./_shared');\nvar setToStringTag = require('./_set-to-string-tag');\nvar uid = require('./_uid');\nvar wks = require('./_wks');\nvar wksExt = require('./_wks-ext');\nvar wksDefine = require('./_wks-define');\nvar enumKeys = require('./_enum-keys');\nvar isArray = require('./_is-array');\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar createDesc = require('./_property-desc');\nvar _create = require('./_object-create');\nvar gOPNExt = require('./_object-gopn-ext');\nvar $GOPD = require('./_object-gopd');\nvar $DP = require('./_object-dp');\nvar $keys = require('./_object-keys');\nvar gOPD = $GOPD.f;\nvar dP = $DP.f;\nvar gOPN = gOPNExt.f;\nvar $Symbol = global.Symbol;\nvar $JSON = global.JSON;\nvar _stringify = $JSON && $JSON.stringify;\nvar PROTOTYPE = 'prototype';\nvar HIDDEN = wks('_hidden');\nvar TO_PRIMITIVE = wks('toPrimitive');\nvar isEnum = {}.propertyIsEnumerable;\nvar SymbolRegistry = shared('symbol-registry');\nvar AllSymbols = shared('symbols');\nvar OPSymbols = shared('op-symbols');\nvar ObjectProto = Object[PROTOTYPE];\nvar USE_NATIVE = typeof $Symbol == 'function';\nvar QObject = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDesc = DESCRIPTORS && $fails(function () {\n  return _create(dP({}, 'a', {\n    get: function () { return dP(this, 'a', { value: 7 }).a; }\n  })).a != 7;\n}) ? function (it, key, D) {\n  var protoDesc = gOPD(ObjectProto, key);\n  if (protoDesc) delete ObjectProto[key];\n  dP(it, key, D);\n  if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);\n} : dP;\n\nvar wrap = function (tag) {\n  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);\n  sym._k = tag;\n  return sym;\n};\n\nvar isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  return it instanceof $Symbol;\n};\n\nvar $defineProperty = function defineProperty(it, key, D) {\n  if (it === ObjectProto) $defineProperty(OPSymbols, key, D);\n  anObject(it);\n  key = toPrimitive(key, true);\n  anObject(D);\n  if (has(AllSymbols, key)) {\n    if (!D.enumerable) {\n      if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));\n      it[HIDDEN][key] = true;\n    } else {\n      if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;\n      D = _create(D, { enumerable: createDesc(0, false) });\n    } return setSymbolDesc(it, key, D);\n  } return dP(it, key, D);\n};\nvar $defineProperties = function defineProperties(it, P) {\n  anObject(it);\n  var keys = enumKeys(P = toIObject(P));\n  var i = 0;\n  var l = keys.length;\n  var key;\n  while (l > i) $defineProperty(it, key = keys[i++], P[key]);\n  return it;\n};\nvar $create = function create(it, P) {\n  return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n};\nvar $propertyIsEnumerable = function propertyIsEnumerable(key) {\n  var E = isEnum.call(this, key = toPrimitive(key, true));\n  if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;\n  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;\n};\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {\n  it = toIObject(it);\n  key = toPrimitive(key, true);\n  if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;\n  var D = gOPD(it, key);\n  if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;\n  return D;\n};\nvar $getOwnPropertyNames = function getOwnPropertyNames(it) {\n  var names = gOPN(toIObject(it));\n  var result = [];\n  var i = 0;\n  var key;\n  while (names.length > i) {\n    if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);\n  } return result;\n};\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(it) {\n  var IS_OP = it === ObjectProto;\n  var names = gOPN(IS_OP ? OPSymbols : toIObject(it));\n  var result = [];\n  var i = 0;\n  var key;\n  while (names.length > i) {\n    if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);\n  } return result;\n};\n\n// 19.4.1.1 Symbol([description])\nif (!USE_NATIVE) {\n  $Symbol = function Symbol() {\n    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');\n    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);\n    var $set = function (value) {\n      if (this === ObjectProto) $set.call(OPSymbols, value);\n      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;\n      setSymbolDesc(this, tag, createDesc(1, value));\n    };\n    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });\n    return wrap(tag);\n  };\n  redefine($Symbol[PROTOTYPE], 'toString', function toString() {\n    return this._k;\n  });\n\n  $GOPD.f = $getOwnPropertyDescriptor;\n  $DP.f = $defineProperty;\n  require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;\n  require('./_object-pie').f = $propertyIsEnumerable;\n  require('./_object-gops').f = $getOwnPropertySymbols;\n\n  if (DESCRIPTORS && !require('./_library')) {\n    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n  }\n\n  wksExt.f = function (name) {\n    return wrap(wks(name));\n  };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });\n\nfor (var es6Symbols = (\n  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14\n  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'\n).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);\n\nfor (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);\n\n$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {\n  // 19.4.2.1 Symbol.for(key)\n  'for': function (key) {\n    return has(SymbolRegistry, key += '')\n      ? SymbolRegistry[key]\n      : SymbolRegistry[key] = $Symbol(key);\n  },\n  // 19.4.2.5 Symbol.keyFor(sym)\n  keyFor: function keyFor(sym) {\n    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');\n    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;\n  },\n  useSetter: function () { setter = true; },\n  useSimple: function () { setter = false; }\n});\n\n$export($export.S + $export.F * !USE_NATIVE, 'Object', {\n  // 19.1.2.2 Object.create(O [, Properties])\n  create: $create,\n  // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n  defineProperty: $defineProperty,\n  // 19.1.2.3 Object.defineProperties(O, Properties)\n  defineProperties: $defineProperties,\n  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n  // 19.1.2.7 Object.getOwnPropertyNames(O)\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // 19.1.2.8 Object.getOwnPropertySymbols(O)\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// 24.3.2 JSON.stringify(value [, replacer [, space]])\n$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {\n  var S = $Symbol();\n  // MS Edge converts symbol values to JSON as {}\n  // WebKit converts symbol values to JSON as null\n  // V8 throws on boxed symbols\n  return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';\n})), 'JSON', {\n  stringify: function stringify(it) {\n    var args = [it];\n    var i = 1;\n    var replacer, $replacer;\n    while (arguments.length > i) args.push(arguments[i++]);\n    $replacer = replacer = args[1];\n    if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined\n    if (!isArray(replacer)) replacer = function (key, value) {\n      if ($replacer) value = $replacer.call(this, key, value);\n      if (!isSymbol(value)) return value;\n    };\n    args[1] = replacer;\n    return _stringify.apply($JSON, args);\n  }\n});\n\n// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)\n$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n// 19.4.3.5 Symbol.prototype[@@toStringTag]\nsetToStringTag($Symbol, 'Symbol');\n// 20.2.1.9 Math[@@toStringTag]\nsetToStringTag(Math, 'Math', true);\n// 24.3.3 JSON[@@toStringTag]\nsetToStringTag(global.JSON, 'JSON', true);\n","// https://github.com/tc39/proposal-promise-finally\n'use strict';\nvar $export = require('./_export');\nvar core = require('./_core');\nvar global = require('./_global');\nvar speciesConstructor = require('./_species-constructor');\nvar promiseResolve = require('./_promise-resolve');\n\n$export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) {\n  var C = speciesConstructor(this, core.Promise || global.Promise);\n  var isFunction = typeof onFinally == 'function';\n  return this.then(\n    isFunction ? function (x) {\n      return promiseResolve(C, onFinally()).then(function () { return x; });\n    } : onFinally,\n    isFunction ? function (e) {\n      return promiseResolve(C, onFinally()).then(function () { throw e; });\n    } : onFinally\n  );\n} });\n","'use strict';\n// https://github.com/tc39/proposal-promise-try\nvar $export = require('./_export');\nvar newPromiseCapability = require('./_new-promise-capability');\nvar perform = require('./_perform');\n\n$export($export.S, 'Promise', { 'try': function (callbackfn) {\n  var promiseCapability = newPromiseCapability.f(this);\n  var result = perform(callbackfn);\n  (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);\n  return promiseCapability.promise;\n} });\n","require('./_wks-define')('asyncIterator');\n","require('./_wks-define')('observable');\n","require('./es6.array.iterator');\nvar global = require('./_global');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar TO_STRING_TAG = require('./_wks')('toStringTag');\n\nvar DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +\n  'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +\n  'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +\n  'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +\n  'TextTrackList,TouchList').split(',');\n\nfor (var i = 0; i < DOMIterables.length; i++) {\n  var NAME = DOMIterables[i];\n  var Collection = global[NAME];\n  var proto = Collection && Collection.prototype;\n  if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);\n  Iterators[NAME] = Iterators.Array;\n}\n"]} diff --git a/examples/sink-bar-chart-display/css/styles.css b/examples/sink-bar-chart-display/css/styles.css new file mode 100644 index 0000000..ae3f6c4 --- /dev/null +++ b/examples/sink-bar-chart-display/css/styles.css @@ -0,0 +1,20 @@ +html { + font-size: 62.5%; + font-family: arial; +} + +body { + margin: 0; + padding: 20px; +} + +h1 { + font-size: 2.2rem; + margin: 0 0 20px 0; + color: rgba(0, 0, 0, 0.4); + font-family: "Courier New", Courier, monospace; +} + +canvas { + outline: 1px solid #cdcdcd; +} diff --git a/examples/sink-bar-chart-display/index.html b/examples/sink-bar-chart-display/index.html new file mode 100644 index 0000000..8fb8ad6 --- /dev/null +++ b/examples/sink-bar-chart-display/index.html @@ -0,0 +1,15 @@ + + + + + + lfo.sink.BarChartDisplay + + + +

lfo.sink.BarChartDisplay

+ + + + + diff --git a/examples/sink-bar-chart-display/package.json b/examples/sink-bar-chart-display/package.json new file mode 100644 index 0000000..7fdc8c4 --- /dev/null +++ b/examples/sink-bar-chart-display/package.json @@ -0,0 +1,36 @@ +{ + "name": "es6-next-prototyping-client", + "version": "1.0.1", + "description": "ESNext client prototyping boilerplate", + "main": "dist/main.js", + "author": "Benjamin Matuszewski", + "license": "ISC", + "scripts": { + "bundle": "./bin/runner --bundle", + "transpile": "./bin/runner --transpile", + "prewatch": "npm run transpile", + "watch": "./bin/runner --watch", + "serve": "./bin/runner --serve", + "postinstall": "npm run bundle" + }, + "dependencies": { + "babel-runtime": "^6.9.2", + "waves-lfo": "^1.1.5" + }, + "devDependencies": { + "babel-core": "^6.14.0", + "babel-plugin-transform-es2015-modules-commonjs": "^6.14.0", + "babel-plugin-transform-runtime": "^6.12.0", + "babel-preset-latest": "^6.14.0", + "benchmark": "^1.0.0", + "browserify": "^13.0.0", + "colors": "^1.1.2", + "connect": "^3.3.5", + "fs-extra": "^0.26.5", + "ora": "^0.2.0", + "portfinder": "^0.4.0", + "serve-favicon": "^2.2.0", + "serve-static": "^1.9.2", + "watch": "^0.17.1" + } +} diff --git a/examples/sink-bar-chart-display/src/index.js b/examples/sink-bar-chart-display/src/index.js new file mode 100644 index 0000000..10079d9 --- /dev/null +++ b/examples/sink-bar-chart-display/src/index.js @@ -0,0 +1,28 @@ +import * as lfo from 'waves-lfo/client'; + +const frameSize = 5; +const dt = 0.02; + +const eventIn = new lfo.source.EventIn({ + frameSize: frameSize, + frameRate: 1 / dt, + frameType: 'vector', +}); + +const barChart = new lfo.sink.BarChartDisplay({ + canvas: '#bar-chart', +}); + +eventIn.connect(barChart); +eventIn.start(); + +const data = [0, 0.2, 0.4, 0.6, 0.8]; + +(function generateData() { + for (let i = 0; i < frameSize; i++) + data[i] = (data[i] + 0.001) % 1; + + eventIn.process(null, data); + + setTimeout(generateData, dt * 1000); +}()); diff --git a/jsdoc.json b/jsdoc.json index 8fea701..627a5bb 100644 --- a/jsdoc.json +++ b/jsdoc.json @@ -6,7 +6,9 @@ "src/core/SourceMixin.js", "src/common/operator/Biquad.js", + "src/common/operator/Clip.js", "src/common/operator/Dct.js", + "src/common/operator/Delta.js", "src/common/operator/Fft.js", "src/common/operator/Magnitude.js", "src/common/operator/MeanStddev.js", @@ -15,8 +17,11 @@ "src/common/operator/MinMax.js", "src/common/operator/MovingAverage.js", "src/common/operator/MovingMedian.js", + "src/common/operator/Multiplier.js", "src/common/operator/OnOff.js", + "src/common/operator/Power.js", "src/common/operator/Rms.js", + "src/common/operator/Scale.js", "src/common/operator/Segmenter.js", "src/common/operator/Select.js", "src/common/operator/Slicer.js", @@ -30,6 +35,7 @@ "src/common/source/EventIn.js", "src/client/sink/BaseDisplay.js", + "src/client/sink/BarChartDisplay.js", "src/client/sink/BpfDisplay.js", "src/client/sink/MarkerDisplay.js", "src/client/sink/SignalDisplay.js", diff --git a/src/client/sink/BarChartDisplay.js b/src/client/sink/BarChartDisplay.js new file mode 100644 index 0000000..1abf876 --- /dev/null +++ b/src/client/sink/BarChartDisplay.js @@ -0,0 +1,126 @@ +import BaseDisplay from './BaseDisplay'; +import Fft from '../../common/operator/Fft'; +import { getColors } from '../utils/display-utils'; + + +const definitions = { + scale: { + type: 'float', + default: 1, + metas: { kind: 'dynamic' }, + }, + colors: { + type: 'any', + default: getColors('bar-chart'), + nullable: true, + metas: { kind: 'dynamic' }, + }, + min: { + type: 'float', + default: 0, + metas: { kind: 'dynamic' }, + }, + max: { + type: 'float', + default: 1, + metas: { kind: 'dynamic' }, + } +}; + + +/** + * Display a bar chart from an incomming `vector` input. + * + * @memberof module:client.sink + * + * @param {Object} options - Override default parameters. + * @param {String} [options.colors=null] - Colors of the bars. + * @param {Number} [options.min=-80] - Minimum displayed value. + * @param {Number} [options.max=6] - Maximum displayed value. + * @param {Number} [options.width=300] - Width of the canvas. + * _dynamic parameter_ + * @param {Number} [options.height=150] - Height of the canvas. + * _dynamic parameter_ + * @param {Element|CSSSelector} [options.container=null] - Container element + * in which to insert the canvas. _constant parameter_ + * @param {Element|CSSSelector} [options.canvas=null] - Canvas element + * in which to draw. _constant parameter_ + * + * @example + * import * as lfo from 'waves-lfo/client'; + * import * as lfo from 'waves-lfo/client'; + * + * const frameSize = 5; + * const dt = 0.02; + * + * const eventIn = new lfo.source.EventIn({ + * frameSize: frameSize, + * frameRate: 1 / dt, + * frameType: 'vector', + * }); + * + * const barChart = new lfo.sink.BarChartDisplay({ + * canvas: '#bar-chart', + * }); + * + * eventIn.connect(barChart); + * eventIn.start(); + * + * const data = [0, 0.2, 0.4, 0.6, 0.8]; + * + * (function generateData() { + * for (let i = 0; i < frameSize; i++) + * data[i] = (data[i] + 0.001) % 1; + * + * eventIn.process(null, data); + * + * setTimeout(generateData, dt * 1000); + * }()); + */ +class BarChartDisplay extends BaseDisplay { + constructor(options = {}) { + super(definitions, options, false); + } + + /** @private */ + processStreamParams(prevStreamParams) { + this.prepareStreamParams(prevStreamParams); + this.propagateStreamParams(); + } + + /** @private */ + processVector(frame) { + const frameSize = this.streamParams.frameSize; + const width = this.canvasWidth; + const height = this.canvasHeight; + const colors = this.params.get('colors'); + const data = frame.data; + + const barWidth = width / frameSize; + const ctx = this.ctx; + + // error handling needs review... + let error = 0; + + for (let i = 0; i < frameSize; i++) { + const x1Float = i * barWidth + error; + const x1Int = Math.round(x1Float); + const x2Float = x1Float + (barWidth - error); + const x2Int = Math.round(x2Float); + + error = x2Int - x2Float; + + if (x1Int !== x2Int) { + const width = x2Int - x1Int; + const y = this.getYPosition(data[i]); + + ctx.fillStyle = colors[i % colors.length]; + ctx.fillRect(x1Int, y, width, height - y); + } else { + error -= barWidth; + } + } + } +} + +export default BarChartDisplay; diff --git a/src/client/sink/_namespace.js b/src/client/sink/_namespace.js index a72adc3..ad31d8d 100644 --- a/src/client/sink/_namespace.js +++ b/src/client/sink/_namespace.js @@ -6,6 +6,7 @@ import SignalRecorder from '../../common/sink/SignalRecorder'; // client only import BaseDisplay from './BaseDisplay'; +import BarChartDisplay from './BarChartDisplay'; import BpfDisplay from './BpfDisplay'; import MarkerDisplay from './MarkerDisplay'; import SignalDisplay from './SignalDisplay'; @@ -22,6 +23,7 @@ export default { SignalRecorder, BaseDisplay, + BarChartDisplay, BpfDisplay, MarkerDisplay, SignalDisplay, diff --git a/src/client/utils/display-utils.js b/src/client/utils/display-utils.js index 3e5124d..28d9e54 100755 --- a/src/client/utils/display-utils.js +++ b/src/client/utils/display-utils.js @@ -28,6 +28,9 @@ export const getColors = function(type, nbr) { case 'trace': return colors[1]; // orange break; + case 'bar-chart': + return colors; + break; } };